2025年2月更新，Step to UEFI 文章索引:
Step to memory 006 DDR外形和自刷新
继续之前的话题，这里来到了《内存的秘密 第二部分》
https://www.bit-tech.net/reviews/tech/memory/the_secrets_of_pc_memory_part_2/1
第一章 紧凑型 DDR
SO-DIMM（小外形双列直插式内存模块，small outline dual in-line memory module）是最常见的移动内存类型：其尺寸几乎是标准 DIMM 的一半，并且不同代之间的连接引脚数量也有所不同。它最常用于笔记本电脑、嵌入式系统、打印机和高端网络设备。除此之外紧凑型和移动型 DDR 还有其他外形尺寸，包括 Mini DIMM 和 Micro DIMM，其区别如下表所示。
引脚数量
尺寸
移动 DDR（例如采用 SO-DIMM 外形尺寸的 DDR）具有一些动态功率调节功能，可以降低自身功耗降尽可能的延长待机时间。这些功能包括部分阵列自刷新 (Partial Array Self-Refresh ，PASR)、温度补偿自刷新 (Temperature Compensated Self-Refresh，TCSR) 和深度省电 (Deep Power Down，DPD)。移动内存设计人员需要努力平衡功耗与性能关系。
个别 DRAM 制造商可能也拥有专有的节能技术，例如，Elpida Memory 就拥有一项名为超级自刷新 (Super Self-Refresh，SSR) 的技术，可将 DDR1 自刷新电流降低 95%。【注释：SSR 是一种新型电路技术，它与嵌入式纠错电路 (ECC) 协同工作，显著延长了内部刷新间隔。ECC 会在退出自刷新周期时检查并纠正数据。SSR 功能取代了传统 SDRAM 中常见的自刷新功能。SSR 利用片上温度传感器（通常称为自动温度补偿自刷新 (ATCSR)），自动调整自刷新时间，以补偿内部温度变化。这是 2005年的技术。】
为了理解移动内存功耗的本质，我们只需使用如下基本公式：
总功率=核心功率+IO功率
DDR GDDR和 移动DDR 内存功耗比较
需要注意的是：DIMM和SO-DIMM使用的DDR芯片通常都是相同的。此外，还有一种 LPDDR (Low Power Double Data Rate SDRAM)的内存芯片，这种和 DDR 芯片差异较大需要特别注意。
DRAM自刷新技术
即使在没有读取数据时，内存（RAM） 也需要持续进行刷新以保持电容器中的电荷。因为DRAM使用电容器来记录数据，其中的电荷会随着时间的推移逐渐泄漏。为了确保数据的可靠必须进行刷新操作，这个操作简单的说就是对于电容再次充电。
这是 RAM （易失性存储器）与非易失性存储器（例如，只读存储器 ROM 或闪存NAND 或 NOR）的主要区别。在笔记本电脑和手持设备等移动设备中，这种自刷新特性不断改进，努力降低功耗，从而延长设备的待机时间。
以下章节介绍了移动 DDR 使用的四种不同的节能方法。
- 温度补偿自刷新
- 部分阵列自刷新
- 深度断电
- 时钟停止模式
当计算机处于休眠或睡眠模式时，在关闭自刷新功能之前，内存内容会被复制到硬盘驱动器，这样内存不消耗电力同时数据也得到了保存。
温度补偿自刷新 (TCSR)
温度补偿自刷新技术在各种内存上都有使用。当DRAM 进行刷新操作时，功耗会增加。此外执行刷新操作时无法进行读写操作。因此，从技术角度厂商都在想办法降低内存刷新的频率。
DDR1 和 DDR2只有一种自刷新模式，而 DDR3 则增强了这项技术，新增了两种温度敏感型自刷新模式。当 DDR3 温度低于 85˚C (185˚F) 时，刷新间隔设置为 7.8µs。如果工作温度介于 85˚C (185˚F) 和 95˚C (203˚F) 之间，则刷新间隔需要降至 3.9µs（速度提高一倍）。
该技术基于以下原理：DRAM 保留数据的时间与工作温度直接相关。较高的温度会导致 DRAM 因电荷泄漏而更快地丢失数据。因此，温度升高后需要增加刷新频率才能保证数据不丢失。
当温度较低时，自刷新周期可以更长，根据这个特性，当 DDR3 在 85˚C (185˚F) 以下运行时，降低刷新频率可以在功耗方面节省近 50%。对于台式机内存模块，因为通常有足够的的空间进行散热， DIMM 的温度很少会超过 60˚C (140˚F)。不同DRAM 制造商的刷新间隔可能略有不同 ， 这取决于各个公司使用的电路和芯片制造技术，但这种差异也可能导致移动内存和设备 BIOS 之间的一些兼容性问题。一些制造商也可能根据他们放置或使用温度传感器的位置而略微不同地实现此功能；有些温度传感器位于片上或 DIMM 上，前者专门检测内存核心温度，而位于DIMM 上的传感器更多用于检测环境温度。
部分阵列自刷新 (Partial Array Self-Refresh ，PASR)
DRAM 芯片内部包含由列和行构成的内存条，类似于 Microsoft Excel 等电子表格程序中的工作表。PASR 技术预先编程了 DRAM 的某些自刷新行为，用于寻址这些列和行，以降低功耗。
例如：
- 完整阵列：组 0、1、2 和 3
- 半阵列：组 0 和 1
- 1/4 阵列：Bank 0
- 1/8 阵列：Bank 0，行地址 MSB = 0
- 1/16 阵列：Bank 0，行地址 MSB 和 MSB-1 均等于零
为了降低自刷新期间的功耗，移动 DDR 可以选择性刷新某些bank中的数据而不刷新其他bank。
部分阵列自刷新示意图 来源：Elpida Memory
不同 的PASR 配置对应的不同电流消耗 来源：Micron Technology
当需要刷新的阵列数量较少时，自刷新电流会下降；但当温度升高时，电流消耗会自动增加，因为阵列需要更频繁地刷新。为此，PASR功能通常使用芯片内部嵌入的热传感器来确定其精确温度。
深度断电 (Deep Power Down , DPD)
在深度掉电模式下，内部电源关闭，所有刷新操作暂停。因此，进入深度掉电模式后数据将无法保留。
在正常运行情况下，单个活动存储体的功耗通常低于 80mA。进行刷新操作时，功耗约为正常运行时的三倍，但在深度掉电模式下，电流消耗降至约 10µA。
自刷新和深度断电模式概述 来源： Elpida Memory
时钟停止模式 （Clock Stop Mode）
此功能通过减少时钟路径上的转换来降低功耗。镁光科技称，主要有两种方法可以实现此目的：
- 当数据传输需要不同的速度时，改变时钟频率
- 在整个时钟停止模式期间，保持 CKE 为高电平，CK 为低电平，CK 为高电平
所采用的方法取决于具体产品的要求。移动 DDR 内存可以在运行过程中更改时钟频率，但只有在满足所有时序和内存刷新要求的情况下才可以这样做。
根据 JEDEC 的规定，在以下条件下甚至可以完全停止时钟：
- 最后一个命令（ACTIVE、READ、WRITE、PRECHARGE、AUTO REFRESH 或 MODE REGISTER SET）已执行完成，包括读取突发期间的任何数据输出；每个访问命令的时钟脉冲数取决于设备的 AC 时序参数和时钟频率。
- 相关时序条件（tRCD、tWR、tRP、tRFC、tMRD）已满足。
- CKE 处于高位。
时钟停止模式的进入和退出 来源： JEDEC
XML 本地格式化工具
最近在研究 KML文件（也是一种XML格式），忽然发现很多工具都是在线的，使用起来并不顺手，因此编写一个本地的 XML 格式化工具。能够帮助将KML变成容易阅读的格式。
使用方法：
XMLLocalFormatter 输入文件名
之后会生成一个“输入文件名_for.XML”的新文件。
代码如下：
#include <iostream>
#include <fstream>
#include <string>
#include "tinyxml2.h"
using namespace std;
using namespace tinyxml2;
int main(int argc, char* argv[]) {
if (argc != 2) {
cerr << "Usage: xml_formatter input_file" << endl;
return EXIT_FAILURE;
}
string inputFile = argv[1];
// Load the XML file using TinyXML2.
XMLDocument doc;
XMLError error = doc.LoadFile(inputFile.c_str());
if (error != XML_SUCCESS) {
cerr << "Error loading file: " << inputFile << ". Error code: " << error << "." << endl;
return EXIT_FAILURE;
}
// 查找最后一个 '.' 的位置以分离扩展名
size_t dotPosition = inputFile.find_last_of('.');
if (dotPosition == std::string::npos || dotPosition == 0) {
std::cerr << "Invalid file name format.\n";
return 1;
}
// 构造新的文件名
std::string baseName = inputFile.substr(0, dotPosition);
std::string extension = inputFile.substr(dotPosition);
std::string newFileName = baseName + "_for" + extension;
const char* output = newFileName.c_str();
// Use PrettyPrint option for formatting.
doc.SaveFile(output,false);
cout << "Formatted XML saved successfully to: " << newFileName << endl;
return EXIT_SUCCESS;
}
运行：
左边是格式化之前的，右边是格式化之后的
有需要的朋友可以试试。
可执行程序（建议自行编译）：
源代码工程：
Intel xHCI
xHCI 是 eXtensible Host Controller Interface Controller的缩写。简单的理解这个是一个 USB Host控制器，能连接外部的诸如USB键盘鼠标U盘等等USB Device ，进行数据的交互传输等等。
例如，在【参考1】描述如下：
The eXtensible Host Controller Interface (xHCI) allows data transfer speed up to 10 Gb/s for USB 3.2 Gen 2×1 ports, and 5 Gb/s for USB 3.2 Gen 1×1 ports. The xHCI supports SuperSpeed USB 10 Gbps, SuperSpeed USB 5 Gbps, High-Speed (HS), Full-Speed (FS) and Low-Speed (LS) traffic on the bus. The xHCI supports USB Debug port on all the USB ports. The xHCI also supports USB Attached SCIS Protocol (UASP).
其中提到了USB Attached SCIS Protocol (UASP)，我查了一下资料【参考2】：
UAS(USB Attached SCSI)是一种位于SCSI协议框架下传输层的一种协议，其作用是通过基于USB的应用层协议约定，将SCSI的协议数据(Protocol Data Unit)用USB进行封装，从而实现使用USB物理连接进行SCSI协议通信的方式。
UAS实际上定义了两个规范，第一个是规定UAS本身使用方式的USB Attached SCSI，另一个是定义了UAS设备类型的Universal Serial Bus Mass Storage Class - USB Attached SCSI Protocol (UASP)。
大约的意思是：这个接口可以驱动符合 USB 协议个U盘这种，走 USB mass Storage 协议。此外，还可以直接走 SCSI 协议。后者传输速度更快效率更高（我个人理解）。这种有点像 ThunderBolt 的 TypeC 接口，可以输出视频信号，但是实现方法有两种：1.USB协议 2.DP 协议。Type-C 内部有一个Mux(切换)芯片，如果发现对方设备握手是一个显示器，那么就直接将DP的视频信号输出，实际上工作的是 Intel 显卡。
上述都是个人理解，如有不妥，欢迎指出。
参考：
Step to UEFI (299）替换ReadKeyStroke的实验
这次的代码是根据之前的文章【参考1】修改而来，将当前系统中 Simple Simple Input Protocol 中的ReadKeyStroke()函数替换为自定的。为了便于验证，如果当前返回了 ‘z’ ，那么会将这个替换为’a’。
完整的代码如下：
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <PiDxe.h>
#include <Protocol/SimpleFileSystem.h>
extern EFI_SYSTEM_TABLE *gST;
EFI_GUID gEfiSimpleTextInputProtocolGuid = {
0x387477c1,
0x69c7,
0x11d2,
{0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b}};
// EFI_FILE_PROTOCOL *Root;
EFI_SIMPLE_TEXT_INPUT_PROTOCOL *SimpleInput;
EFI_INPUT_READ_KEY OldReadKeyStroke;
// This one will replace the Read function of Read in Simple File System
EFI_STATUS
EFIAPI
MyReadKeyStroke(IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
OUT EFI_INPUT_KEY *Key) {
//EFI_INPUT_KEY IKey;
EFI_TPL OldTpl;
EFI_STATUS Status;
//
// Enter critical section
//
OldTpl = gBS->RaiseTPL(TPL_NOTIFY);
Status = (*OldReadKeyStroke)(SimpleInput, Key);
if (Key->UnicodeChar==0x7A) {
Key->UnicodeChar=0x61;
}
//
// Leave critical section and return
//
gBS->RestoreTPL(OldTpl);
return Status;
}
EFI_STATUS
EFIAPI
MyEntryPoint(IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable) {
EFI_STATUS Status;
// Look for one Simple Simple Input Protocol
Status =
gBS->LocateProtocol(&gEfiSimpleTextInputProtocolGuid, NULL, &SimpleInput);
if (EFI_ERROR(Status)) {
gST->ConOut->OutputString(gST->ConOut,
L"Can't find Simple Input PROTOCOL\n");
return Status;
}
OldReadKeyStroke = SimpleInput->ReadKeyStroke;
SimpleInput->ReadKeyStroke = MyReadKeyStroke;
return Status;
}
需要注意的上述代码是驱动：
1.在 MdeModulePkg 下面编译通过，在\MdeModulePkg\MdeModulePkg.dsc 添加如下：
MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.inf
MdeModulePkg/Universal/SmmCommunicationBufferDxe/SmmCommunicationBufferDxe.inf
MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
MdeModulePkg/KSTest/KSTest.inf
[Components.X64]
MdeModulePkg/Universal/CapsulePei/CapsuleX64.inf
[BuildOptions]
2.编译使用
build -a X64 -p MdeModulePkg\MdeModulePkg.dsc -t VS2019
3.运行时使用如下命令加载
load kst.efi
参考：
1.https://www.lab-z.com/stu163rp/ 替换已经存在Protocol中函数的实验
EasyX 用点画椭圆
椭圆的参数方程：
源代码：
#include <graphics.h> // EasyX图形库头文件
#include <conio.h> // 用于_getch()
#include <math.h>
#define a 100
#define b 50
int main()
{
int x,y;
// 初始化640x480像素的图形窗口
initgraph(640, 480);
for (int i = 0; i < 360; i++) {
x = 320 + a * cos(i * 3.1415 / 180); // sin 用弧度做参数
y= 240+ b * sin(i * 3.1415 / 180); // cos 用弧度做参数
putpixel(x, y, RED);
}
// 保持窗口显示
_getch();
// 关闭图形窗口
closegraph();
return 0;
}
运行结果：
和之前画圆类似，直接用点的方法计算：
#include <graphics.h> // EasyX图形库头文件
#include <conio.h> // 用于_getch()
#include <math.h>
#include <stdio.h>
#define Xcenter 320
#define Ycenter 240
// 长轴
#define A 50
// 短轴
#define B 30
// 焦点F1坐标
#define Xf1 (Xcenter-(int)(sqrt(A*A-B*B)))
#define Yf1 Ycenter
// 焦点F2坐标
#define Xf2 (Xcenter+(int)(sqrt(A*A-B*B)))
#define Yf2 Ycenter
// 计算 (x,y) 到焦点F1和F2的距离之和
double CalculateDistance(int x, int y)
{
double f1 = sqrt((x - Xf1) * (x - Xf1) + (y - Yf1) * (y - Yf1));
double f2 = sqrt((x - Xf2) * (x - Xf2) + (y - Yf2) * (y - Yf2));
return (f1+f2);
}
// 找到下一个点位
// 输入当前点位坐标 (Xcurrent,Ycurrent)
// 前一个点位坐标 （Xlast,Ylast
void FindNextPoint(int Xcurrent, int Ycurrent, int Xlast, int Ylast, int *Xnext, int *Ynext)
{
double gap= 1000000000.0;
double tmp;
// 左
if ((Xcurrent - 1 != Xlast) || (Ycurrent != Ylast)) {
tmp = fabs(CalculateDistance(Xcurrent - 1, Ycurrent) - 2 * A);
if (gap > tmp) {
gap = fabs(CalculateDistance(Xcurrent - 1, Ycurrent) - 2 * A);
*Xnext = Xcurrent - 1;
*Ynext = Ycurrent;
}
}
// 左上
if ((Xcurrent-1 != Xlast) || (Ycurrent-1!= Ylast)) {
tmp = fabs(CalculateDistance(Xcurrent - 1, Ycurrent - 1) - 2 * A);
if (gap > tmp) {
gap = fabs(CalculateDistance(Xcurrent - 1, Ycurrent-1) - 2 * A);
*Xnext = Xcurrent - 1;
*Ynext = Ycurrent-1;
}
}
// 上
if ((Xcurrent!= Xlast) || (Ycurrent - 1 != Ylast)) {
tmp = fabs(CalculateDistance(Xcurrent, Ycurrent - 1) - 2 * A);
if (gap > tmp) {
gap = fabs(CalculateDistance(Xcurrent, Ycurrent - 1) - 2 * A);
*Xnext = Xcurrent;
*Ynext = Ycurrent - 1;
}
}
// 右上
if ((Xcurrent+1 != Xlast) || (Ycurrent - 1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent+1, Ycurrent - 1) - 2 * A)) {
gap = fabs(CalculateDistance(Xcurrent+1, Ycurrent - 1) - 2 * A);
*Xnext = Xcurrent+1;
*Ynext = Ycurrent - 1;
}
}
// 右
if ((Xcurrent + 1 != Xlast) || (Ycurrent != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent + 1, Ycurrent) - 2 * A)) {
gap = fabs(CalculateDistance(Xcurrent + 1, Ycurrent) - 2 * A);
*Xnext = Xcurrent + 1;
*Ynext = Ycurrent;
}
}
// 右下
if ((Xcurrent + 1 != Xlast) || (Ycurrent+1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent + 1, Ycurrent+1) - 2 * A)) {
gap = fabs(CalculateDistance(Xcurrent + 1, Ycurrent+1) - 2 * A);
*Xnext = Xcurrent + 1;
*Ynext = Ycurrent + 1;
}
}
// 下
if ((Xcurrent != Xlast) || (Ycurrent +1!= Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent, Ycurrent+1) - 2 * A)) {
gap = fabs(CalculateDistance(Xcurrent, Ycurrent+1) - 2 * A);
*Xnext = Xcurrent;
*Ynext = Ycurrent+1;
}
}
// 左下
if ((Xcurrent-1 != Xlast) || (Ycurrent + 1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent-1, Ycurrent + 1) - 2 * A)) {
gap = fabs(CalculateDistance(Xcurrent-1, Ycurrent + 1) - 2 * A);
*Xnext = Xcurrent-1;
*Ynext = Ycurrent + 1;
}
}
}
int main()
{
int x=0, y= 0;
int Xlast = Xcenter - A, Ylast = Ycenter;
int Xcurrent = Xcenter - A, Ycurrent = Ycenter;
// 初始化640x480像素的图形窗口
initgraph(640, 480);
for (int i = 0; i < 255; i++) {
FindNextPoint(Xcurrent, Ycurrent,Xlast,Ylast,&x,&y);
//printf("%d %d\n", x- Xcenter, y-Ycenter);
putpixel(Xcurrent, Ycurrent, RED);
Xlast = Xcurrent;
Ylast = Ycurrent;
Xcurrent = x;
Ycurrent = y;
if ((i != 0) && (Xcurrent == Xcenter - A) && (Ycurrent == Ycenter)) {
printf("-->%d \n",i);
}
}
// 保持窗口显示
_getch();
// 关闭图形窗口
closegraph();
return 0;
}
之前提到计算周长的问题，椭圆周长公式【参考】：L=T（r+R），其中的 T 是短轴长轴的比例。比如，这里我们 A=50, B=30 因此，T=3.190874858, 计算结果是255.2，上述代码运行之后会输出 “–>231” 意思是在 234 的时候到了起始位置，结果和预期有可比性。
参考：
Step to memory 005 延迟和流程的演变
原文在 https://www.bit-tech.net/reviews/tech/memory/the_secrets_of_pc_memory_part_1/8/
延迟
DDR 的每一代发展都提供了更快的数据速率和更高的容量，但其代价是稳定性和信号准确性的下降。因此，每一代 DDR 都需要适应更高的频率和更高的信号延迟。
延迟可以理解为为时间上的暂停或延迟。当 DDR 信号命令发生变化时，内存子系统需要在不同的内存命令之间暂停。这就像一列火车驶入车站，然后停下来让乘客上下车。
延迟有很多种类型。CAS 延迟通常被认为是最重要的延迟之一，然而随着 DDR 内存的更新换代，它本身的重要性逐渐降低，而多个延迟值的组合则更为重要。许多内存模块将 CAS 延迟表示为“CL”或简称为“C”。例如，CAS 延迟为 3 个时钟周期的内存模块通常被标记为CL3 或 C3。相关知识将在后续文章中讨论。
演化过程 在更高数据吞吐量需求的推动下，DDR 相关的各种技术经历了一系列的演进，同时尽可能保持经济性。
提高内存数据传输频率面临的两大挑战是信号噪声水平和时序精度。这通常被称为有效数据窗口 (Valid Data Window , DVW)。有效数据窗口有时也称为数据有效窗口（Data-Valid Window,DVW）或简称为“眼图”。它是决定信号可靠性主要因素。
为了降低信号反射，。例如：DDR1 采用主板上添加终端电阻方法，DDR2 则采用片上终端电阻 (On-Die Termination，ODT) 方法。DDR3 进一步扩展了 ODT 技术，允许根据情况动态调整 ODT 值。结合各种信号校准技术，可以合理地管理数据完整性，从而实现更快的传输速率。所有内存模块和主板都需要在设计和后期生产过程中进行信号准确性测试和验证，以确保各种内置校准方案正常运行。
这里提到的信号反射指的是高速信号中的反射问题【参考1】https://blog.csdn.net/hs977986979/article/details/142762703
在硬件电路中，高频信号的反射是一个非常重要的现象。当电磁波在传输线上传播时，如果遇到阻抗不连续点（如传输线的末端、拐角、过孔、元件引脚、线宽变化等），就会发生反射。反射波的大小和方向取决于入射波的幅度、相位以及阻抗不连续点的性质。
反射现象会导致信号轮廓失真，产生过冲、欠冲和振荡等问题。这些问题会影响电路的性能和稳定性。为了减小反射，通常需要在传输线的末端添加适当的终端匹配电阻，以确保信号的完整传输。
为了实现更高的效率和更低的散热，需要降低内存电压。数据中心运营商、台式机和笔记本电脑消费者对低功耗计算机越来越感兴趣，原因包括更环保、更长的使用时间以及总体运营成本的降低。
现代数据中心使用大量空调来维持运行。例如，卢卡斯影业 (LucasFilm) 的数据中心在 32 台空调机组中使用了 25 吨冷却剂来维持其系统的运行。功率效率通常以每瓦性能来计算，因此在保持相同性能的情况下，瓦数的降低对行业来说都是利好消息。
计算机内存系统如果没有多年的预先规划和全行业协商，就不会发生重大的范式转变。成员们会将一次又一次的修订提交给像 JEDEC 这样的设计管理机构，然后由一个合作伙伴委员会监督整个设计和批准过程。
制造过程中涉及的制造和测试设备成本高昂，这极大地阻碍了变革，因为自动测试设备 (Automatic Test Equipment，ATE) 价格极其昂贵，通常每台设备的成本高达数百万美元。MOSAID Systems 的 Brad Snoulten 认为，主要挑战有两个：
- 内存制造商无力购买或更换价值数百万美元的测试仪来满足不断增长的生产或工程测试需求。
- 内存ATE供应商面临着设计经济实惠且能有效抵御长期淘汰的解决方案的挑战。内存裕度的不断下降和设备复杂性的不断增加加剧了这些问题。
进步是一个渐进的演变过程，而不会出现跳跃式的进步。
第九章 GDDR，QDR 和 XDR
如果您在过去三年内购买组装一个台式机，它很可能至少有一个 PCI Express 图形扩展接口。这些显卡拥有一种专用的 DDR，即图形 DDR (GDDR) 内存，容量从最小的几十兆字节到超过上千兆字节甚至更多。
GDDR通常用于对带宽要求极高的高性能显卡。需要主意它的架构与 DDR 截然不同， 在JEDEC 的规范中GDDR 与 DDR 标准分属不同规范。
最新的 GDDR 技术已发展到第五代，简称为 GDDR5。不同代之间的主要区别在于性能和带宽。与 DDR 相比，GDDR 具有更高的性能，但在制造成本和功耗方面也明显更高。GDDR3的工作电压为 2.0V，而 DDR3 的工作电压为 1.5V，额外的电压有助于 GDDR 更快地运行，但也使其更容易泄漏电流，从而产生更多热量。这与大型图形运算核心组合意味着显卡产生的热量通常比主板中的 CPU 和内存加起来还要多。
Nvidia 8800GT 上的奇梦达 GDDR3
GDDR 具有较宽的数据接口和更大的帧缓冲区。与 DDR 设备相比，显卡等 GDDR 设备的单位容量较低；这会导致功耗更高且价格更高。增加设备的 GDDR 显存容量会相应增加功耗和设备价格。
QDR和XDR
四倍数据速率 (QDR) 内存系统始于 1999 年，由Cypress 导体公司、IDT 和 NEC 共同开发。此后，包括美光科技、瑞萨电子、三星电子和日立在内的多家公司都以某种形式参与其中。
我们预计， QDR 内存取代 DDR 的可能性不高，最重要的原因是QDR无法实现低成本的量产。其次，此举相当于内存技术的一次重大转向，出于经济性和实用性的考虑，很多制造商对此非常反对。
虽然 QDR 的数据频率和有效数据窗口显著提高，并具有超低延迟，但其内存容量相对于 DDR 而言相对较低。当 DDR3 达到每模块 8GB 时，QDR3 内存容量标准仍然以 MB 为单位。QDR 架构是特地为高性能通信应用而设计。
Lattice半导体公司表示，与 QDR 相比，DDR 技术存在以下缺点：
- 写入和读取共享一条双向数据总线，因此总带宽与 QDR 架构相比减少了一半。这在写入与读取比例接近 1:1 的情况下意义重大。
- 刷新需要中断数据传输。
- 访问延迟相对较高。
- 需要在上电后进行初始化，并在访问之前/之后激活/预充电行（内存接口简化了这一点）。
值得注意的是，目前市场上已经有了QDR内存甚至ODR内存（Octal-Data Rate）。索尼 PlayStation 3 采用 Rambus 的 XDR（极限数据速率）设计，该设计能够在每个时钟周期发送 8 位数据，而 DDR 只能在每个时钟周期发送 2 位数据。三星、奇梦达、尔必达、IBM、东芝、AMD 等公司目前都采用 XDR 设计。这些内存系统价格极其昂贵，而且不像 DDR 那样普及。
有一种罕见的 DDR2 类型，称为 DDR2+（或增强型 DDR2），其核心频率可达 333MHz，而 DDR2 标准频率为 200MHz。DDR2+ 也是由 QDR 联盟联合开发的。
下次我们将研究移动 DDR 和底层 DDR 技术，如温度补偿自刷新、部分阵列自刷新、深度断电和时钟停止模式以及 DRAM 封装和堆叠技术。
======================================================
讲个好玩的事情，三星内存的“反周期策略”：
三星充分利用了存储器行业的强周期特点，在价格下跌、生产过剩、其他企业削减投资的时候，逆势疯狂扩产，通过大规模生产进一步下杀产品价格，从而逼竞争对手退出市场甚至直接破产，世人称之为“反周期定律”。
在存储器这个领域，三星一共祭出过三次“反周期定律”，前两次分别发生在80年代中期和90年代初，让三星从零开始，做到了存储器老大的位置。但三星显然觉得玩的还不够大，于是在2008年金融危机前后，第三次举起了“反周期”屠刀。2007 年初，微软推出了狂吃内存的Vista操作系统，DRAM厂商判断内存需求会大增，于是纷纷上产能，结果Vista 销量不及预期，DRAM 供过于求价格狂跌，加上08 年金融危机的雪上加霜，DRAM 颗粒价格从2.25 美金雪崩至0.31 美金。
就在此时，三星做出令人瞠目结舌的动作：将2007 年三星电子总利润的118%投入DRAM 扩张业务，故意加剧行业亏损，给艰难度日的对手们，加上最后一根稻草。效果是显著的。DRAM价格一路飞流直下，08年中跌破了现金成本，08年底更是跌破了材料成本。2009年初，第三名德系厂商奇梦达首先撑不住，宣布破产，欧洲大陆的内存玩家就此消失。2012年初，第五名尔必达宣布破产，曾经占据DRAM市场50%以上份额的日本，也输掉了最后一张牌。在尔必达宣布破产当晚，京畿道的三星总部彻夜通明，次日股价大涨，全世界都知道韩国人这次又赢了。至此，DRAM领域最终只剩三个玩家：三星、海力士和镁光。尔必达破产后的烂摊子，在2013年被换了新CEO的镁光以20多亿美金的价格打包收走。20亿美金实在是个跳楼价，5年之后，镁光市值从不到100亿美元涨到460亿，20亿美元差不多是它市值一天的振幅。
上述来自雪球 作者：潇潇小鱼 链接：https://xueqiu.com/2691707350/179978325
EasyX 用点画圆
圆形的参数方程如下：
根据这个，编写 EasyX 代码如下：
#include <graphics.h> // EasyX图形库头文件
#include <conio.h> // 用于_getch()
#include <math.h>
#define RAD 100
int main()
{
int x,y;
// 初始化640x480像素的图形窗口
initgraph(640, 480);
for (int i = 0; i < 360; i++) {
x = 320 + RAD * sin(i * 3.1415 / 180); // sin 用弧度做参数
y= 240+ RAD * cos(i * 3.1415 / 180); // cos 用弧度做参数
putpixel(x, y, RED);
}
// 保持窗口显示
_getch();
// 关闭图形窗口
closegraph();
return 0;
}
运行结果：
此外，这里再给出一个奇怪/低效的算法。基于如下限制：所有的点在八个方向上只存在两个点与之相近（换句话，一个像素的线绘制出来的圆形），基于此限制，设计算法如下：
- 给出起始点坐标（Xorg,Yorg）；
- 生成8个方向的坐标，计算这些点位和圆心的距离，然后选择最接近半径的作为下一个点的坐标；
- 重复上述动作计算出所有的点（不过我还没有想明白怎么通过公式计算出点的数量）
#include <graphics.h> // EasyX图形库头文件
#include <conio.h> // 用于_getch()
#include <math.h>
//#include <stdio.h>
#define Xcenter 320
#define Ycenter 240
#define RAD 100
// 计算 (x,y) 到圆心的距离
double CalculateDistance(int x, int y)
{
return (sqrt((x - Xcenter) * (x - Xcenter) + (y - Ycenter) * (y - Ycenter)));
}
// 找到下一个点位
// 输入当前点位坐标 (Xcurrent,Ycurrent)
// 前一个点位坐标 （Xlast,Ylast
void FindNextPoint(int Xcurrent, int Ycurrent, int Xlast, int Ylast, int *Xnext, int *Ynext)
{
double gap= 1000000000.0;
double tmp;
// 左
if ((Xcurrent - 1 != Xlast) || (Ycurrent != Ylast)) {
tmp = CalculateDistance(Xcurrent - 1, Ycurrent);
tmp = fabs(tmp - RAD);
if (gap > tmp) {
gap = fabs(CalculateDistance(Xcurrent - 1, Ycurrent) - RAD);
*Xnext = Xcurrent - 1;
*Ynext = Ycurrent;
}
}
// 左上
if ((Xcurrent-1 != Xlast) || (Ycurrent-1!= Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent - 1, Ycurrent-1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent - 1, Ycurrent-1) - RAD);
*Xnext = Xcurrent - 1;
*Ynext = Ycurrent-1;
}
}
// 上
if ((Xcurrent!= Xlast) || (Ycurrent - 1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent, Ycurrent - 1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent, Ycurrent - 1) - RAD);
*Xnext = Xcurrent;
*Ynext = Ycurrent - 1;
}
}
// 右上
if ((Xcurrent+1 != Xlast) || (Ycurrent - 1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent+1, Ycurrent - 1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent+1, Ycurrent - 1) - RAD);
*Xnext = Xcurrent+1;
*Ynext = Ycurrent - 1;
}
}
// 右
if ((Xcurrent + 1 != Xlast) || (Ycurrent != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent + 1, Ycurrent) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent + 1, Ycurrent) - RAD);
*Xnext = Xcurrent + 1;
*Ynext = Ycurrent;
}
}
// 右下
if ((Xcurrent + 1 != Xlast) || (Ycurrent+1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent + 1, Ycurrent+1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent + 1, Ycurrent+1) - RAD);
*Xnext = Xcurrent + 1;
*Ynext = Ycurrent + 1;
}
}
// 下
if ((Xcurrent != Xlast) || (Ycurrent +1!= Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent, Ycurrent+1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent, Ycurrent+1) - RAD);
*Xnext = Xcurrent;
*Ynext = Ycurrent+1;
}
}
// 左下
if ((Xcurrent-1 != Xlast) || (Ycurrent + 1 != Ylast)) {
if (gap > fabs(CalculateDistance(Xcurrent-1, Ycurrent + 1) - RAD)) {
gap = fabs(CalculateDistance(Xcurrent-1, Ycurrent + 1) - RAD);
*Xnext = Xcurrent-1;
*Ynext = Ycurrent + 1;
}
}
}
int main()
{
int x=0, y= 0;
int Xlast = Xcenter - RAD, Ylast = Ycenter;
int Xcurrent = Xcenter - RAD, Ycurrent = Ycenter;
// 初始化640x480像素的图形窗口
initgraph(640, 480);
for (int i = 0; i < 800; i++) {
FindNextPoint(Xcurrent, Ycurrent,Xlast,Ylast,&x,&y);
//printf("%d %d\n", x, y);
putpixel(Xcurrent, Ycurrent, RED);
Xlast = Xcurrent;
Ylast = Ycurrent;
Xcurrent = x;
Ycurrent = y;
}
// 保持窗口显示
_getch();
// 关闭图形窗口
closegraph();
return 0;
}
Step to memory 004 单通道和双通道
继续 《PC 内存的秘密 第一部分》原文在 https://www.bit-tech.net/reviews/tech/memory/the_secrets_of_pc_memory_part_1/6/
有几个独特但重要的速度概念需要牢记。它们是 DRAM 核心频率、输入输出 (IO) 缓冲区频率、内存总线频率和数据频率。它们用于描述内存系统不同部件的性能水平。
所有计算机内存模块都以数据频率为标称值。例如，DDR2-800 中的“800”数字描述了模块以 800MHz频率搬运数据的能力。另一方面，IO 缓冲区和总线频率将以 400MHz 运行，而 DRAM 核心频率仅以 200MHz 运行。
频率 (MHz) 和数据吞吐量 (Mbps) 之间的关系很简单。一个信号是 1 位数据：0 或 1。下图中的圆形黑色“操作点”。800MHz 数据频率意味着它将以每秒 8 亿次的速度发送 1 位数据，因此两者的乘积等于每秒 800 兆比特 (Mbps)。 （注：请记住，位和字节是不同的：8 位 = 1 字节，因此之前的 800Mbps 仅相当于 100MBps 或每秒兆字节）。
在给定数据频率的情况下，实际或有效数据吞吐量低于预期。例如，800MHz 的 DDR2 不会将该频率全部用于数据流。相反，命令和控制信号会占用部分数据。这有点像购买 160GB 硬盘，格式化后，只有 149GB 可用于数据。这是因为驱动器的一部分被系统级信息（如主引导记录 MBR 和分区表）占用。
对于一些爱好者和完美主义者来说，这是内存超频很好的理由，以使数据吞吐量更接近或超过 800MHz 数据流。使用指定为 1066MHz 的 DDR2 模块可以更好地实现这一点。
双通道和单通道模式
DDR 的另一项重大创新是能够使用双通道，而不是传统的单通道内存总线。这种设计极大地提高了内存性能。
在对称双通道芯片组上，将两个内存模块放在相同颜色的插槽中将自动为用户提供双通道性能，但是在 4 插槽主板上使用 3 个内存模块将使主板切换回单通道模式。非对称双通道芯片组能够使用 3 个 DIMM 在双通道模式下运行，从而始终有效地为用户提供 128 位内存性能。
当前基于台式机的 DDR 内存技术无法支持每通道超过 2 个 DIMM，但基于服务器和工作站的 FB-DIMM（全缓冲 DIMM）内存控制器（用于英特尔 CPU）设计时考虑了每通道 8 个 DIMM。这些高端计算机通常配备四通道配置，需要至少四个 DIMM 才能使用它。
每个标准台式机内存模块支持 64 位数据总线，而基于服务器的内存模块每通道使用 72 位数据总线：额外的 8 位用于纠错码 (ECC)。由于增加了额外的性能和纠错特性的复杂性，R-DIMM 和 FB-DIMM 比台式机使用的内存贵得多。
CPU 和带宽增长
内存系统与 CPU 的演进有着直接的关系。随着更强大的处理器进入市场，需要更多的内存带宽来跟上 CPU 的处理速度。较慢的内存系统无法向快速的 CPU 提供足够的数据，这会导致处理器花费更多的时间在等待更多数据。内存系统的目标是在尽可能短的时间内为不同的任务存储和检索大量数据。如果没有同样快速的内存系统，CPU 将无法充分发挥效能导致效率低下。
下图说明了这一现象。摩尔定律描述 CPU 的处理能力每 18 个月翻一番。英特尔核心团队负责人 David “Dadi” Perlmutter 将其归类为“经济性和技术进步的简单关系”。计算机的效率在很大程度上依赖于内存系统来跟上 CPU 方面的改进。
单核 CPU 过去只是通过提高处理频率来提升性能。2004-2005 年，一种新的台式机 CPU 设计将处理器改进的动态从原始速度的单一因素转变为两个因素：处理速度以及核心数量。
此后的 CPU 性能提升依赖于核心频率的改进、处理器封装内的核心数量、具有更先进的预测和预取优化的缓存技术以及改进的总线效率以避免瓶颈。用于内存访问的数据预测和预取算法对处理器效率有重大影响。其他因素包括 L1、L2（和 L3）缓存的使用方式及其相关算法和访问分配。
第七章 EMI和内存控制器
由于内存速度从未真正能够跟上 CPU 性能，内存系统设计人员一直在使用多种手段改进性能。出于成本考虑原因，设计的主要目标一直是尽可能降低制造成本。
创新的设计人员没有选择提升内存的原始速度，而是通过并行访问的方法来提升整体速度。这些创造性的技术包括：双倍数据速率技术（DDR）、双通道或四通道模式（Dual or Quad Channel Modes）以及预取技术（Pre-fetching ）等等。
需要特别主意的是，DDR DRAM 在技术工程角度存在成本限制，核心频率限制在 200MHz时整体成本最优。提升芯片外部总线传输频率相较于提升 DRAM 核心频率成本上要划算的多。
而为了达到上述目标，主板和内存模块必须在精确的信号管理和电磁干扰（EMI）控制机制方面取得设计和制造突破。因此，内存改进不仅仅是 DRAM 设计人员考虑的问题，也是从 CPU 架构师、芯片组和 DRAM 设计人员到主板和内存模块制造商的全行业协调努力的结果。
内存控制器
内存控制器的职责是对内存模块发送命令、管理内存模块和路由信号到内存模块。每个 DRAM 通常有四个或八个内存组，访问方式与 Microsoft Excel 工作表类似：有行和列。每当 CPU 需要读取或存储数据时，它都会通过内存控制器将信息发送到 RAM。
英特尔今年已经以 P35 和 X38 芯片组的形式发布了“Bearlake”3 系列家族下的第一代 DDR3 主板。Nvidia 和后来的 AMD 为其自己的 CPU 推出的未来芯片组也将在 2008 年支持 DDR3。当前的 DDR2/DDR3“组合”主板能够支持现有的 DDR2-800 或新的 DDR3-1066/1333 内存模块，但不能同时支持两个标准。DDR2 和 DDR3 使用不同的内存插槽，因为它们具有不同的模块键槽位置。
Intel 从Nehalem架构(45nm)开始整合了内存控制器（Integrated Memory Controller,IMC）。现在市面上的Intel处理器都已经整合了IMC。
将内存集成到 CPU 封装中的直接经济效益是降低该特定平台的主板制造成本。技术效益是减短CPU 对内存传输数据路径。集成内存控制器消除了对物理前端总线 (FSB) 的需求。无需独立的内存控制器芯片，主板制造商的设计和测试过程变得更简单 ： EMI 问题更少，整个系统本耗设更低。理论上，这种设计消除了前端总线（FSB）带来的带宽瓶颈，可以显著提高内存性能。
集成内存控制器的缺点是它占用了处理器芯片上的空间，而这些空间原本可以用于更大的 L1、L2 和 L3 缓存。此外，任何直接内存访问 (DMA) 都必须经由 CPU 才能进入内存，这会为需要快速访内存的其他组件（如显卡）带来额外的延迟。
讲一个好玩的，我入行的时候是在昆山的微兴做台式机主板，偶然发现 Intel 的内存兼容性要比 AMD 好多了。发现的原因是当前公司研发有一批DQA 人员负责测试。有时候项目到了后期，实在没有什么好测试的他们就会拿出来内存“扫”一圈。Intel 通常没啥问题，比如，上一次是两三个型号有问题，这一次仍然是这些有问题。但是 AMD 就麻烦了，这次扫出来的和上一次有问题的型号往往不同，让人无比头大。
后来稍微有点经验，对于有问题的内存通过 SPD 信息判断，然后升高电压来解决。万幸的是这种方法对于大部分问题都有效果。
不使用第三方库实现 IIS 麦克风转HTTP
这段代码展示了不使用第三方库实现在一个 HTTP Server, 然后电脑可以通过浏览器打开 http://ip/stream 即可听到 IIS 麦克风拾取到的声音。实验使用MSM261S4030H0的 IIS 音频传感器。
#include <WiFi.h>
#include <WebServer.h>
#include <driver/i2s.h>
// WiFi配置
const char* ssid = "YOURSSID";
const char* password = "YOURPASSWORD";
// I2S配置
#define I2S_MIC_WS 37
#define I2S_MIC_SD 48
#define I2S_MIC_SCK 45
#define SAMPLE_RATE 16000
#define BITS_PER_SAMPLE 32
#define BUFFER_SIZE 1024
WebServer server(80);
int32_t audioBuffer[BUFFER_SIZE];
void setup() {
Serial.begin(2000000);
// 初始化I2S
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_SIZE,
.use_apll = false
};
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_MIC_SCK,
.ws_io_num = I2S_MIC_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_MIC_SD
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
i2s_set_pin(I2S_NUM_0, &pin_config);
// 连接WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected");
Serial.println("IP address: " + WiFi.localIP().toString());
// 设置HTTP路由
server.on("/stream", HTTP_GET, handleAudioStream);
server.begin();
}
void loop() {
server.handleClient();
// 持续读取音频数据
size_t bytesRead;
i2s_read(I2S_NUM_0, &audioBuffer, BUFFER_SIZE * sizeof(int32_t), &bytesRead, portMAX_DELAY);
}
void handleAudioStream() {
// 生成WAV文件头
uint8_t wavHeader[44];
generateWavHeader(wavHeader, SAMPLE_RATE, 32);
// 发送HTTP头
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, "audio/wav", "");
// 先发送WAV头
server.sendContent((const char*)wavHeader, sizeof(wavHeader));
// 持续发送音频数据
while(server.client().connected()) {
size_t bytesRead;
i2s_read(I2S_NUM_0, &audioBuffer, BUFFER_SIZE*4, &bytesRead, portMAX_DELAY);
server.sendContent((const char*)audioBuffer, bytesRead);
}
}
void generateWavHeader(uint8_t* header, uint32_t sampleRate, uint32_t bitDepth) {
// RIFF块标识
header[0] = 'R'; header[1] = 'I'; header[2] = 'F'; header[3] = 'F';
// 文件总大小占位（后续更新）
header[4] = 0; header[5] = 0; header[6] = 0; header[7] = 0;
// WAVE格式标识
header[8] = 'W'; header[9] = 'A'; header[10] = 'V'; header[11] = 'E';
// fmt子块标识
header[12] = 'f'; header[13] = 'm'; header[14] = 't'; header[15] = ' ';
// fmt块大小（16字节）
header[16] = 16; header[17] = 0; header[18] = 0; header[19] = 0;
// 音频格式（1=PCM）
header[20] = 1; header[21] = 0;
// 声道数（1=单声道）
header[22] = 1; header[23] = 0;
// 采样率
header[24] = sampleRate & 0xFF;
header[25] = (sampleRate >> 8) & 0xFF;
header[26] = (sampleRate >> 16) & 0xFF;
header[27] = (sampleRate >> 24) & 0xFF;
// 字节率 = 采样率 * 声道数 * 位深度/8
uint32_t byteRate = sampleRate * (bitDepth/8);
header[28] = byteRate & 0xFF;
header[29] = (byteRate >> 8) & 0xFF;
header[30] = (byteRate >> 16) & 0xFF;
header[31] = (byteRate >> 24) & 0xFF;
// 块对齐 = 声道数 * 位深度/8
uint16_t blockAlign = (bitDepth/8);
header[32] = blockAlign & 0xFF;
header[33] = (blockAlign >> 8) & 0xFF;
// 位深度
header[34] = bitDepth & 0xFF;
header[35] = (bitDepth >> 8) & 0xFF;
// data子块标识
header[36] = 'd'; header[37] = 'a'; header[38] = 't'; header[39] = 'a';
// data块大小占位（后续更新）
header[40] = 0; header[41] = 0; header[42] = 0; header[43] = 0;
}
类似的，有时候传感器送出 32Bits 数据，我们需要转为 16Bits输出，编写代码如下：
#include <WiFi.h>
#include <WebServer.h>
#include <driver/i2s.h>
// WiFi配置
const char* ssid = "CMCC-TSR6739";
const char* password = "!!1783az";
// I2S配置
#define I2S_MIC_WS 37
#define I2S_MIC_SD 48
#define I2S_MIC_SCK 45
#define SAMPLE_RATE 16000
#define BITS_PER_SAMPLE 32
#define BUFFER_SIZE 1024
WebServer server(80);
int32_t audioBuffer[BUFFER_SIZE];
int16_t webaudioBuffer[BUFFER_SIZE];
void setup() {
Serial.begin(2000000);
// 初始化I2S
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = I2S_COMM_FORMAT_STAND_I2S,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = BUFFER_SIZE,
.use_apll = false
};
i2s_pin_config_t pin_config = {
.bck_io_num = I2S_MIC_SCK,
.ws_io_num = I2S_MIC_WS,
.data_out_num = I2S_PIN_NO_CHANGE,
.data_in_num = I2S_MIC_SD
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
i2s_set_pin(I2S_NUM_0, &pin_config);
// 连接WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWiFi connected");
Serial.println("IP address: " + WiFi.localIP().toString());
// 设置HTTP路由
server.on("/stream", HTTP_GET, handleAudioStream);
server.begin();
}
void loop() {
server.handleClient();
// 持续读取音频数据
size_t bytesRead;
i2s_read(I2S_NUM_0, &audioBuffer, BUFFER_SIZE * sizeof(int32_t), &bytesRead, portMAX_DELAY);
}
void handleAudioStream() {
// 生成WAV文件头
uint8_t wavHeader[44];
generateWavHeader(wavHeader, SAMPLE_RATE, 16);
// 发送HTTP头
server.setContentLength(CONTENT_LENGTH_UNKNOWN);
server.send(200, "audio/wav", "");
// 先发送WAV头
server.sendContent((const char*)wavHeader, sizeof(wavHeader));
// 持续发送音频数据
while(server.client().connected()) {
size_t bytesRead;
i2s_read(I2S_NUM_0, &audioBuffer, BUFFER_SIZE*4, &bytesRead, portMAX_DELAY);
for (int i=0;i<BUFFER_SIZE;i++) {
int32_t audio_24bit = audioBuffer[i] >> 8; // 提取高 24 位
webaudioBuffer[i]=(int16_t)((audio_24bit + 128) >> 8); // 四舍五入到 16 位
}
server.sendContent((const char*)webaudioBuffer, bytesRead/2);
}
}
void generateWavHeader(uint8_t* header, uint32_t sampleRate, uint32_t bitDepth) {
// RIFF块标识
header[0] = 'R'; header[1] = 'I'; header[2] = 'F'; header[3] = 'F';
// 文件总大小占位（后续更新）
header[4] = 0; header[5] = 0; header[6] = 0; header[7] = 0;
// WAVE格式标识
header[8] = 'W'; header[9] = 'A'; header[10] = 'V'; header[11] = 'E';
// fmt子块标识
header[12] = 'f'; header[13] = 'm'; header[14] = 't'; header[15] = ' ';
// fmt块大小（16字节）
header[16] = 16; header[17] = 0; header[18] = 0; header[19] = 0;
// 音频格式（1=PCM）
header[20] = 1; header[21] = 0;
// 声道数（1=单声道）
header[22] = 1; header[23] = 0;
// 采样率
header[24] = sampleRate & 0xFF;
header[25] = (sampleRate >> 8) & 0xFF;
header[26] = (sampleRate >> 16) & 0xFF;
header[27] = (sampleRate >> 24) & 0xFF;
// 字节率 = 采样率 * 声道数 * 位深度/8
uint32_t byteRate = sampleRate * (bitDepth/8);
header[28] = byteRate & 0xFF;
header[29] = (byteRate >> 8) & 0xFF;
header[30] = (byteRate >> 16) & 0xFF;
header[31] = (byteRate >> 24) & 0xFF;
// 块对齐 = 声道数 * 位深度/8
uint16_t blockAlign = (bitDepth/8);
header[32] = blockAlign & 0xFF;
header[33] = (blockAlign >> 8) & 0xFF;
// 位深度
header[34] = bitDepth & 0xFF;
header[35] = (bitDepth >> 8) & 0xFF;
// data子块标识
header[36] = 'd'; header[37] = 'a'; header[38] = 't'; header[39] = 'a';
// data块大小占位（后续更新）
header[40] = 0; header[41] = 0; header[42] = 0; header[43] = 0;
}
Easy X用点画阿基米德螺旋线
、
#include <graphics.h> // EasyX图形库头文件
#include <conio.h> // 用于_getch()
#include <math.h>
#define a 0 // 从原点开始
#define b 60*3.1415/180 //半径增加的速率
int main()
{
int x,y;
// 初始化640x480像素的图形窗口
initgraph(640, 480);
for (int i = 0; i < 360*30; i++) {
x = 320 + (a+ b * (i * 3.1415 / 180)) * cos(i * 3.1415 / 180);
y= 240+ (a + b * (i * 3.1415 / 180)) * sin(i * 3.1415 / 180);
putpixel(x, y, YELLOW);
}
// 保持窗口显示
_getch();
// 关闭图形窗口
closegraph();
return 0;
}
运行结果：
