单摆实验教程

赛题资料和程序代码都已上传到Gitee上，有需要的可以自行下载，下载链接：https://gitee.com/baby-sea/ch32.git

装置调整

根据比赛提供的《单摆实验装置使用说明》，我们首先需要调整单摆装置能正常工作。

1. 先将光电板与单片机用杜邦线连接

单片机	光电板
5V	5V
GND	GND
A0	D1
A1	D2

2. 调整光电板子上的电阻，使用AnalogRead()函数来观察输出电压。

根据提示，analogread();函数可以获取模拟电压值，通过A0与A1两个模拟口获取到电位器R1与接收管中间的电压，当摆绳未遮挡狭缝时，激光器发出的光通过光电门支架上的狭缝照射接收管，在接收管上产生光电流。光电流在R1/R2 上产生电压。此时，输出电压较低。

当摆绳遮挡狭缝时，照射到接收管的光大部分被遮挡，接收管上的光电流减小，R1/R2上的电压降低，输出电压升高。

调节电位器R1、R2,可改变D1、D2在上述两种情况下的输出电压。当输出电压符合要求时，此电路可以用于测量单摆周期和摆动方向。

3. 编写代码，并调整电位器，电位器左转，电位器电阻R变大，D电平更容易为低电平，电位器右转，电位器电阻R变小，D电平更容易为高电平，我们需要调整电阻到恰当的位置，观察触发现象。

void setup() {
  Serial.begin(115200);          //以115200波特率开启串口
}

void loop() {
  int val1;                    //定义一个整型变量val1
  int val2;                    //定义一个整型变量val2
  val1=analogRead(A0);         //读取A1引脚采样的电压值
  val2=analogRead(A1);         //读取A2引脚采样的电压值

  Serial.print("4096");        
  Serial.print(",");        
  Serial.print(val1);        
  Serial.print(",");        
  Serial.println(val2);  
  delay(2);      
}

下位机代码编写

根据比赛提供的《赛题说明》，我们需要获取单摆的时间周期来根据绳长算重力加速度或者根据重力加速度算绳长，根据比赛第二课，应该使用micros () 函数获取微秒数，非阻塞的逻辑来编写程序，并且我们需要通过串口上传间隔时间给上位机。将上述消息发送给AI生成代码。

// 定义光电门引脚
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 状态变量
unsigned long gate1Time = 0;       // 光电门1触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态

// 单摆参数(根据实际装置修改)
const float摆长 = 0.5;             // 单摆摆长(单位:米)
const float半周期系数 = 3.1415926 * 3.1415926;  // π²

void setup() {
  // 初始化引脚
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);
  
  // 初始化串口
  Serial.begin(9600);
  while (!Serial);  // 等待串口准备就绪
  Serial.println("单摆实验系统就绪");
}

void loop() {
  // 读取当前状态
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);

  // 检测光电门1状态变化(低电平->高电平，遮挡触发)
  if (gate1State == HIGH && gate1LastState == LOW) {
    gate1Time = micros();  // 记录触发时间
  }
  
  // 检测光电门2状态变化(低电平->高电平，遮挡触发)
  if (gate2State == HIGH && gate2LastState == LOW) {
    gate2Time = micros();  // 记录触发时间
  }

  // 输出时间数据
  Serial.print("get1:");
  Serial.print(gate1Time);
  Serial.print(",get2:");
  Serial.println(gate2Time);

  // 计算重力加速度(使用光电门1的连续两次触发时间差作为半周期)
  static unsigned long lastGate1Time = 0;
  if (gate1Time != lastGate1Time && lastGate1Time != 0) {
    unsigned long半周期微秒 = gate1Time - lastGate1Time;
    float半周期秒 = 半周期微秒 / 1000000.0;  // 转换为秒
    float重力加速度 = (4 * 半周期系数 * 摆长) / (半周期秒 * 半周期秒);
    
    Serial.print("重力加速度:");
    Serial.print(重力加速度);
    Serial.println(" m/s²");
  }
  lastGate1Time = gate1Time;

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;

  // 短延时避免数据刷屏过快
  delay(10);
}

烧录代码后，编译器发生报错，将错误上传豆包

// 定义光电门引脚
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 状态变量
unsigned long gate1Time = 0;       // 光电门1触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态

// 单摆参数(根据实际装置修改)
const float pendulumLength = 0.5;  // 单摆摆长(单位:米)
const float piSquare = 3.1415926 * 3.1415926;  // π²

void setup() {
  // 初始化引脚
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);
  
  // 初始化串口
  Serial.begin(9600);
  while (!Serial);  // 等待串口准备就绪
  Serial.println("Pendulum experiment system ready");
}

void loop() {
  // 读取当前状态
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);

  // 检测光电门1状态变化(低电平->高电平，遮挡触发)
  if (gate1State == HIGH && gate1LastState == LOW) {
    gate1Time = micros();  // 记录触发时间
  }
  
  // 检测光电门2状态变化(低电平->高电平，遮挡触发)
  if (gate2State == HIGH && gate2LastState == LOW) {
    gate2Time = micros();  // 记录触发时间
  }

  // 输出时间数据
  Serial.print("get1:");
  Serial.print(gate1Time);
  Serial.print(",get2:");
  Serial.println(gate2Time);

  // 计算重力加速度(使用光电门1的连续两次触发时间差作为半周期)
  static unsigned long lastGate1Time = 0;
  if (gate1Time != lastGate1Time && lastGate1Time != 0) {
    unsigned long halfPeriodMicros = gate1Time - lastGate1Time;
    float halfPeriodSec = halfPeriodMicros / 1000000.0;  // 转换为秒
    float gravity = (4 * piSquare * pendulumLength) / (halfPeriodSec * halfPeriodSec);
    
    Serial.print("Gravity:");
    Serial.print(gravity);
    Serial.println(" m/s²");
  }
  lastGate1Time = gate1Time;

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;

  // 短延时避免数据刷屏过快
  delay(10);
}

再次烧录代码，发现得到的重力加速度数值偏大，但数据稳定，反馈给豆包重新生成后代码依旧有问题

// 定义光电门引脚
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 状态变量
unsigned long gate1Time = 0;       // 光电门1触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态
unsigned long debounceTime = 5000; // 防抖时间(微秒)，避免短时间内重复触发

// 单摆参数(根据实际装置修改)
const float pendulumLength = 0.29; // 单摆摆长(单位:米)
const float piSquare = 3.1415926 * 3.1415926;  // π²

void setup() {
  // 初始化引脚（若光电门有上拉电阻，可改为INPUT_PULLUP）
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);
  
  // 初始化串口（波特率115200，与串口监视器一致）
  Serial.begin(115200);
  while (!Serial);  // 等待串口准备就绪
  Serial.println("Pendulum experiment system ready");
}

void loop() {
  // 读取当前状态（稳定读取，避免电平波动）
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);
  unsigned long currentTime = micros(); // 当前时间戳

  // 光电门1触发：检测"低→高"，且距离上次触发超过防抖时间（避免抖动）
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;  // 更新触发时间
  }
  
  // 光电门2触发：同光电门1逻辑
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;  // 更新触发时间
  }

  // 按要求格式输出两个光电门的时间数据（取消注释即可启用）
  Serial.print("get1:");
  Serial.print(gate1Time);
  Serial.print(",get2:");
  Serial.println(gate2Time);

  // 计算重力加速度：使用光电门1的连续两次触发时间差作为【完整周期】
  static unsigned long lastGate1Time = 0;
  if (gate1Time != lastGate1Time && lastGate1Time != 0) {
    unsigned long fullPeriodMicros = gate1Time - lastGate1Time; // 完整周期(微秒)
    float fullPeriodSec = fullPeriodMicros / 1000000.0;        // 转换为秒
    
    // 过滤异常周期（避免数据波动，可根据实际摆长调整范围）
    if (fullPeriodSec > 0.5 && fullPeriodSec < 2.0) {
      float gravity = (4 * piSquare * pendulumLength) / (fullPeriodSec * fullPeriodSec); // 正确公式
      Serial.print("Gravity:");
      Serial.print(gravity, 2); // 保留2位小数，数据更清晰
      Serial.println(" m/s²");
    }
  }
  lastGate1Time = gate1Time; // 更新上一次触发时间

  // 更新上一状态（延迟更新，确保电平稳定）
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

此时需要人工看看代码的逻辑，发现用于计算的单摆时间有问题，应该采用第一次与第三次的触发时间差为一次单摆后期时间，生成代码后，再调整绳长后，发现测量数据完美

// 定义光电门引脚
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 状态变量
unsigned long gate1Time = 0;       // 光电门1当前触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2当前触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态

// 周期计算专用：存储三次触发时间（数组索引0=第1次，1=第2次，2=第3次）
unsigned long gate1TriggerTimes[3] = {0, 0, 0};
int triggerCount = 0;              // 触发次数计数器（0-2循环）
const unsigned long debounceTime = 50000; // 防抖时间（50ms），过滤干扰

// 单摆参数(根据实际装置修改)
const float pendulumLength = 0.29; // 单摆摆长(单位:米)
const float pi = 3.1415926;        // π值（单独定义，计算更清晰）

void setup() {
  // 初始化引脚
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);
  
  // 初始化串口（波特率115200）
  Serial.begin(115200);
  while (!Serial);  // 等待串口准备就绪
  Serial.println("Pendulum System Ready | Use 1st-3rd Trigger for Period");
  Serial.print("Set Pendulum Length: ");
  Serial.print(pendulumLength);
  Serial.println("m");
}

void loop() {
  // 读取当前状态与时间
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);
  unsigned long currentTime = micros();

  // -------------------------- 光电门1触发检测（低→高，带防抖） --------------------------
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;  // 更新当前触发时间
    gate2Time = digitalRead(PHOTO_GATE2) ? currentTime : gate2Time; // 同步更新光电门2时间（若触发）
    
    // 存储当前触发时间到数组，计数器+1（0→1→2→0循环）
    gate1TriggerTimes[triggerCount] = gate1Time;
    triggerCount = (triggerCount + 1) % 3; // 三次后重置，循环采集
    
    // 当数组存满3次触发时间（第3次触发后），计算周期与重力加速度
    if (gate1TriggerTimes[0] != 0 && gate1TriggerTimes[2] != 0) {
      unsigned long fullPeriodMicros = gate1TriggerTimes[2] - gate1TriggerTimes[0]; // 1-3次时间差=完整周期
      float fullPeriodSec = fullPeriodMicros / 1000000.0;                          // 转换为秒
      
      // 过滤异常周期（0.29m摆长理论周期≈1.07秒，范围放宽到0.8~1.5秒）
      if (fullPeriodSec > 0.8 && fullPeriodSec < 1.5) {
        float gravity = (4 * pi * pi * pendulumLength) / (fullPeriodSec * fullPeriodSec); // 标准单摆公式
        // 按要求输出光电门时间 + 计算结果
        Serial.print("get1:");
        Serial.print(gate1Time);
        Serial.print(",get2:");
        Serial.print(gate2Time);
        Serial.print(" | Period:");
        Serial.print(fullPeriodSec, 3); // 周期保留3位小数
        Serial.print("s | Gravity:");
        Serial.print(gravity, 2);       // 重力加速度保留2位小数
        Serial.println(" m/s²");
      }
    }
  }

  // -------------------------- 光电门2独立触发检测（仅记录时间，不参与计算） --------------------------
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;
  }

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

成功获得重力加速度后，需要通过WIFI上传到服务器端，在服务器端的网页上可以发现AT指令的调用方法，再结合比赛第三课的连接WIFI教程，将代码整合一下

#include "wifi.h"  // 引入自定义的 WiFi 模块驱动头文件

#define WIFI_SSID ""  // WiFi 名称，需替换为你自己的 SSID
#define WIFI_PASSWORD ""  // WiFi 密码，需替换为你自己的密码

Wifi wifi;  // 创建一个 Wifi 类的实例，用于控制 WiFi 模块

// 定义光电门引脚
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 状态变量
unsigned long gate1Time = 0;  // 光电门1当前触发时间(微秒)
unsigned long gate2Time = 0;  // 光电门2当前触发时间(微秒)
bool gate1State = LOW;        // 光电门1当前状态
bool gate2State = LOW;        // 光电门2当前状态
bool gate1LastState = LOW;    // 光电门1上一状态
bool gate2LastState = LOW;    // 光电门2上一状态

// 周期计算专用：存储三次触发时间（数组索引0=第1次，1=第2次，2=第3次）
unsigned long gate1TriggerTimes[3] = { 0, 0, 0 };
int triggerCount = 0;                      // 触发次数计数器（0-2循环）
const unsigned long debounceTime = 50000;  // 防抖时间（50ms），过滤干扰

// 单摆参数(根据实际装置修改)
const float pendulumLength = 0.31;  // 单摆摆长(单位:米)
const float pi = 3.1415926;         // π值（单独定义，计算更清晰）

float gravity;
// 函数功能：将float类型转换为char数组（字符串）
// 参数：
//   value: 要转换的float数值
//   result: 存储结果的字符数组
//   bufferSize: 字符数组的大小（建议至少15）
//   decimalPlaces: 保留的小数位数（1-6）
void floatToChar(float value, char *result, int bufferSize, int decimalPlaces = 4) {

  long multiplier = 10000;  // 默认保留4位小数

  // 放大并四舍五入
  long scaled = (long)(value * multiplier + (value >= 0 ? 0.5 : -0.5));

  // 分离整数和小数部分
  int integerPart = scaled / multiplier;
  int fractionalPart = scaled % multiplier;

  // 确保小数部分为正数
  int absFraction = abs(fractionalPart);

  // 格式化字符串，使用动态生成的格式控制符
  char format[10];
  sprintf(format, "%%d.%%0%dd", decimalPlaces);
  snprintf(result, bufferSize, format, integerPart, absFraction);
}

void setup() {
  // 初始化引脚
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);

  // 初始化串口（波特率115200）
  Serial.begin(115200);
  while (!Serial)
    ;  // 等待串口准备就绪
  Serial.println("Pendulum System Ready | Use 1st-3rd Trigger for Period");
  Serial.print("Set Pendulum Length: ");
  Serial.print(pendulumLength);
  Serial.println("m");

  wifi.init(115200);  // 初始化 WiFi 模块，设置串口波特率 115200

  delay(1000);  //延时1000ms，等待wifi模块初始化完成
  // 发送 AT 指令，等待返回 "OK"，超时时间 2000ms，用来检测模块是否正常工作
  wifi.sendATCmd((u8 *)"AT", (u8 *)"OK", 2000);

  // 查询当前 WiFi 模式，期望返回 "+WMODE:1"（Station 模式），超时 2000ms
  wifi.sendATCmd((u8 *)"AT+WMODE?", (u8 *)"+WMODE:1", 2000);

  u8 connectCmd[128];  // 定义一个 128 字节的数组，用于存放连接 WiFi 的 AT 指令
  // 格式化生成连接 WiFi 的 AT 命令，例如：AT+WJAP=SSID,PASSWORD
  sprintf((char *)connectCmd, "AT+WJAP=%s,%s", WIFI_SSID, WIFI_PASSWORD);
  // 发送连接 WiFi 的 AT 指令，等待获取 IP 地址事件 "+EVENT:WIFI_GOT_IP"，超时 10000ms
  wifi.sendATCmd(connectCmd, (u8 *)"+EVENT:WIFI_GOT_IP", 10000);
}

void loop() {
  // 读取当前状态与时间
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);
  unsigned long currentTime = micros();

  // -------------------------- 光电门1触发检测（低→高，带防抖） --------------------------
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;                                         // 更新当前触发时间
    gate2Time = digitalRead(PHOTO_GATE2) ? currentTime : gate2Time;  // 同步更新光电门2时间（若触发）

    // 存储当前触发时间到数组，计数器+1（0→1→2→0循环）
    gate1TriggerTimes[triggerCount] = gate1Time;
    triggerCount = (triggerCount + 1) % 3;  // 三次后重置，循环采集

    // 当数组存满3次触发时间（第3次触发后），计算周期与重力加速度
    if (gate1TriggerTimes[0] != 0 && gate1TriggerTimes[2] != 0) {
      unsigned long fullPeriodMicros = gate1TriggerTimes[2] - gate1TriggerTimes[0];  // 1-3次时间差=完整周期
      float fullPeriodSec = fullPeriodMicros / 1000000.0;                            // 转换为秒

      // 过滤异常周期（0.29m摆长理论周期≈1.07秒，范围放宽到0.8~1.5秒）
      if (fullPeriodSec > 0.8 && fullPeriodSec < 1.5) {
        gravity = (4 * pi * pi * pendulumLength) / (fullPeriodSec * fullPeriodSec);  // 标准单摆公式

        // 先构造json数据
        char str1[15];
        floatToChar(gravity, str1, sizeof(str1), 4);  //gravity就是传感器的数据 该函数将浮点数转换为字符串（WCH库没有开浮点数打印）
        char jsonData[128];
        sprintf(jsonData, "{\"id\": 2, \"username\": \"alice\", \"value\": %s}", str1);  //注意id要改成自己的id，username要改成自己的用户名
        // 计算json数据的实际长度 用于发送json数据给服务器
        int jsonLen = strlen(jsonData);
        // 动态构造AT命令
        char httpCmd[256];
        sprintf((char *)httpCmd, "AT+HTTPRAW=1,3,\"application/json\",192.168.2.15,5000,\"/api/data\",%d", jsonLen);  //192.168.2.15是服务器的IP地址，现场修改
        // 发送AT命令
        wifi.sendATCmd((u8 *)httpCmd, (u8 *)">", 4000);
        // 发送json数据
        wifi.sendATCmd((u8 *)jsonData, (u8 *)"OK", 10000);
      }
    }
  }

  // -------------------------- 光电门2独立触发检测（仅记录时间，不参与计算） --------------------------
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;
  }

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

为了上位机能有更好的展示效果，下位机减少上传服务器的频率，改为收集十次重力加速度后求平均值再上传服务器，而串口打印出每次的光电门触发时间

#include "wifi.h"  // 引入自定义的 WiFi 模块驱动头文件

#define WIFI_SSID ""  // WiFi 名称，需替换为实际 SSID
#define WIFI_PASSWORD ""  // WiFi 密码，需替换为实际密码
#define SERVER_IP "192.168.2.15"    // 服务器IP，现场修改
#define SERVER_PORT 5000            // 服务器端口
#define DATA_COUNT 10               // 缓存重力加速度的次数（10次求平均）

Wifi wifi;  // 创建 WiFi 类实例

// 光电门引脚定义
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 光电门状态与时间变量
unsigned long gate1Time = 0;       // 光电门1当前触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2当前触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态
const unsigned long debounceTime = 50000;  // 防抖时间（50ms）

// 单摆周期计算变量（3次触发求完整周期）
unsigned long gate1TriggerTimes[3] = {0, 0, 0};
int triggerCount = 0;              // 触发次数计数器（0-2循环）
const float pendulumLength = 0.31; // 摆长（米，按实际修改）
const float pi = 3.1415926;        // π值

// 重力加速度缓存与计数（10次求平均）
float gravityBuffer[DATA_COUNT] = {0};  // 缓存10次重力加速度
int gravityCount = 0;                    // 已缓存的次数
float avgGravity = 0;                    // 重力加速度平均值

// float转char数组函数（原功能保留）
void floatToChar(float value, char *result, int bufferSize, int decimalPlaces = 4) {
  long multiplier = 1;
  // 根据保留小数位数计算放大倍数（如4位→10000）
  for (int i = 0; i < decimalPlaces; i++) {
    multiplier *= 10;
  }

  // 放大并四舍五入
  long scaled = (long)(value * multiplier + (value >= 0 ? 0.5 : -0.5));
  int integerPart = scaled / multiplier;
  int fractionalPart = scaled % multiplier;
  int absFraction = abs(fractionalPart);

  // 动态生成格式符（如"%%d.%%04d"）
  char format[10];
  sprintf(format, "%%d.%%0%dd", decimalPlaces);
  snprintf(result, bufferSize, format, integerPart, absFraction);
}

// WiFi上传平均重力加速度函数（封装上传逻辑，代码更简洁）
void uploadAvgGravity(float avgG) {
  char avgGStr[15];
  floatToChar(avgG, avgGStr, sizeof(avgGStr), 4);  // 转成字符串（保留4位小数）
  
  // 构造JSON数据（按实际id和username修改）
  char jsonData[128];
  sprintf(jsonData, "{\"id\": 2, \"username\": \"alice\", \"value\": %s}", avgGStr);
  
  // 构造HTTP请求AT指令
  int jsonLen = strlen(jsonData);
  char httpCmd[256];
  sprintf(httpCmd, "AT+HTTPRAW=1,3,\"application/json\",%s,%d,\"/api/data\",%d", 
          SERVER_IP, SERVER_PORT, jsonLen);
  
  // 发送指令并上传数据
  Serial.print("Uploading avg gravity: ");
  Serial.print(avgG, 4);
  Serial.print(" | JSON: ");
  Serial.println(jsonData);
  
  if (wifi.sendATCmd((u8 *)httpCmd, (u8 *)">", 4000)) {
    if (wifi.sendATCmd((u8 *)jsonData, (u8 *)"OK", 10000)) {
      Serial.println("Upload success!");
    } else {
      Serial.println("Upload data failed!");
    }
  } else {
    Serial.println("Create HTTP request failed!");
  }
}

void setup() {
  // 初始化光电门引脚
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);

  // 初始化串口（波特率115200）
  Serial.begin(115200);
  while (!Serial);
  Serial.println("=== Pendulum System Ready ===");
  Serial.print("Set Pendulum Length: ");
  Serial.print(pendulumLength);
  Serial.println("m");
  Serial.println("Waiting for photo gate trigger...\n");

  // 初始化WiFi模块
  wifi.init(115200);
  // 检测WiFi模块
  if (wifi.sendATCmd((u8 *)"AT", (u8 *)"OK", 2000)) {
    Serial.println("WiFi module detected!");
    // 确认Station模式
    if (wifi.sendATCmd((u8 *)"AT+WMODE?", (u8 *)"+WMODE:1", 2000)) {
      // 连接WiFi
      u8 connectCmd[128];
      sprintf((char *)connectCmd, "AT+WJAP=%s,%s", WIFI_SSID, WIFI_PASSWORD);
      if (wifi.sendATCmd(connectCmd, (u8 *)"+EVENT:WIFI_GOT_IP", 10000)) {
        Serial.println("WiFi connected!");
      } else {
        Serial.println("WiFi connect failed!");
      }
    } else {
      Serial.println("WiFi set Station mode failed!");
    }
  } else {
    Serial.println("WiFi module not detected!");
  }
}

void loop() {
  unsigned long currentTime = micros();
  // 读取当前光电门状态
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);

  // -------------------------- 1. 光电门1触发处理（3次触发求周期） --------------------------
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;  // 更新光电门1触发时间
    // 实时打印触发时间（get1:XXX,get2:XXX）
    Serial.print("get1:");
    Serial.print(gate1Time);
    Serial.print(",get2:");
    Serial.println(gate2Time);

    // 存储触发时间到数组，计数器循环
    gate1TriggerTimes[triggerCount] = gate1Time;
    triggerCount = (triggerCount + 1) % 3;

    // 当3次触发都完成（数组非空），计算周期与重力加速度
    if (gate1TriggerTimes[0] != 0 && gate1TriggerTimes[2] != 0) {
      unsigned long fullPeriodMicros = gate1TriggerTimes[2] - gate1TriggerTimes[0];
      float fullPeriodSec = fullPeriodMicros / 1000000.0;

      // 过滤异常周期（0.8~1.5秒，适配0.31m摆长）
      if (fullPeriodSec > 0.8 && fullPeriodSec < 1.5) {
        float gravity = (4 * pi * pi * pendulumLength) / (fullPeriodSec * fullPeriodSec);
        // 打印单次重力加速度
        Serial.print("Single Gravity: ");
        Serial.print(gravity, 4);
        Serial.println(" m/s²");

        // 缓存重力加速度到数组
        gravityBuffer[gravityCount] = gravity;
        gravityCount++;
        Serial.print("Cached count: ");
        Serial.println(gravityCount);

        // 当缓存满10次，计算平均值并上传
        if (gravityCount >= DATA_COUNT) {
          // 计算平均值
          avgGravity = 0;
          for (int i = 0; i < DATA_COUNT; i++) {
            avgGravity += gravityBuffer[i];
          }
          avgGravity /= DATA_COUNT;

          // 打印平均值
          Serial.print("\n=== 10次 Average Gravity: ");
          Serial.print(avgGravity, 4);
          Serial.println(" m/s² ===");

          // WiFi上传平均值
          uploadAvgGravity(avgGravity);

          // 重置缓存计数与数组（准备下一轮）
          gravityCount = 0;
          memset(gravityBuffer, 0, sizeof(gravityBuffer));
          Serial.println("Buffer reset, waiting for next 10 data...\n");
        }

        // 重置3次触发数组（避免重复计算）
        memset(gate1TriggerTimes, 0, sizeof(gate1TriggerTimes));
      }
    }
  }

  // -------------------------- 2. 光电门2触发处理（仅记录时间，不参与计算） --------------------------
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;  // 更新光电门2触发时间
    // 实时打印触发时间（get1:XXX,get2:XXX）
    Serial.print("get1:");
    Serial.print(gate1Time);
    Serial.print(",get2:");
    Serial.println(gate2Time);
  }

  // 更新上一状态（避免重复触发）
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

观察下位机的打印，可以发现打印里有重复的时间数据，检测代码发现只要光电门被触发就会打印时间数据，需要修改为当两个光电门都触发完毕后，再打印两个光电门的数据

#include "wifi.h"  // 引入自定义的 WiFi 模块驱动头文件

#define WIFI_SSID ""  // WiFi 名称，需替换为实际 SSID
#define WIFI_PASSWORD ""  // WiFi 密码，需替换为实际密码
#define SERVER_IP "192.168.2.15"    // 服务器IP，现场修改
#define SERVER_PORT 5000            // 服务器端口
#define DATA_COUNT 10               // 缓存重力加速度的次数（10次求平均）

Wifi wifi;  // 创建 WiFi 类实例

// 光电门引脚定义
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 光电门状态与时间变量
unsigned long gate1Time = 0;       // 光电门1当前触发时间(微秒)
unsigned long gate2Time = 0;       // 光电门2当前触发时间(微秒)
bool gate1State = LOW;             // 光电门1当前状态
bool gate2State = LOW;             // 光电门2当前状态
bool gate1LastState = LOW;         // 光电门1上一状态
bool gate2LastState = LOW;         // 光电门2上一状态
const unsigned long debounceTime = 50000;  // 防抖时间（50ms）
bool gate1Triggered = false;       // 光电门1是否完成一次有效触发
bool gate2Triggered = false;       // 光电门2是否完成一次有效触发

// 单摆周期计算变量（3次触发求完整周期，基于光电门1）
unsigned long gate1TriggerTimes[3] = {0, 0, 0};
int triggerCount = 0;              // 光电门1触发次数计数器（0-2循环）
const float pendulumLength = 0.31; // 摆长（米，按实际修改）
const float pi = 3.1415926;        // π值

// 重力加速度缓存与计数（10次求平均）
float gravityBuffer[DATA_COUNT] = {0};  // 缓存10次重力加速度
int gravityCount = 0;                    // 已缓存的次数
float avgGravity = 0;                    // 重力加速度平均值

// float转char数组函数（原功能保留）
void floatToChar(float value, char *result, int bufferSize, int decimalPlaces = 4) {
  long multiplier = 1;
  for (int i = 0; i < decimalPlaces; i++) {
    multiplier *= 10;
  }

  long scaled = (long)(value * multiplier + (value >= 0 ? 0.5 : -0.5));
  int integerPart = scaled / multiplier;
  int fractionalPart = scaled % multiplier;
  int absFraction = abs(fractionalPart);

  char format[10];
  sprintf(format, "%%d.%%0%dd", decimalPlaces);
  snprintf(result, bufferSize, format, integerPart, absFraction);
}

// WiFi上传平均重力加速度函数（封装上传逻辑）
void uploadAvgGravity(float avgG) {
  char avgGStr[15];
  floatToChar(avgG, avgGStr, sizeof(avgGStr), 4);
  
  char jsonData[128];
  sprintf(jsonData, "{\"id\": 2, \"username\": \"alice\", \"value\": %s}", avgGStr);
  
  int jsonLen = strlen(jsonData);
  char httpCmd[256];
  sprintf(httpCmd, "AT+HTTPRAW=1,3,\"application/json\",%s,%d,\"/api/data\",%d", 
          SERVER_IP, SERVER_PORT, jsonLen);
  
  Serial.print("\n=== Uploading Avg Gravity: ");
  Serial.print(avgG, 4);
  Serial.println(" m/s² ===");
  if (wifi.sendATCmd((u8 *)httpCmd, (u8 *)">", 4000)) {
    if (wifi.sendATCmd((u8 *)jsonData, (u8 *)"OK", 10000)) {
      Serial.println("Upload Success!\n");
    } else {
      Serial.println("Upload Data Failed!\n");
    }
  } else {
    Serial.println("Create HTTP Request Failed!\n");
  }
}

// 双门均触发后，处理数据（打印时间+计算重力）
void processDualGateData() {
  // 1. 按格式打印双门触发时间
  Serial.print("get1:");
  Serial.print(gate1Time);
  Serial.print(",get2:");
  Serial.println(gate2Time);

  // 2. 基于光电门1的3次触发计算重力加速度
  if (gate1TriggerTimes[0] != 0 && gate1TriggerTimes[2] != 0) {
    unsigned long fullPeriodMicros = gate1TriggerTimes[2] - gate1TriggerTimes[0];
    float fullPeriodSec = fullPeriodMicros / 1000000.0;

    // 过滤异常周期（适配0.31m摆长）
    if (fullPeriodSec > 0.8 && fullPeriodSec < 1.5) {
      float gravity = (4 * pi * pi * pendulumLength) / (fullPeriodSec * fullPeriodSec);
      Serial.print("Single Gravity: ");
      Serial.print(gravity, 4);
      Serial.println(" m/s²");

      // 缓存重力加速度
      gravityBuffer[gravityCount] = gravity;
      gravityCount++;
      Serial.print("Cached Count: ");
      Serial.println(gravityCount);

      // 满10次数据，计算平均值并上传
      if (gravityCount >= DATA_COUNT) {
        avgGravity = 0;
        for (int i = 0; i < DATA_COUNT; i++) {
          avgGravity += gravityBuffer[i];
        }
        avgGravity /= DATA_COUNT;

        uploadAvgGravity(avgGravity);

        // 重置缓存
        gravityCount = 0;
        memset(gravityBuffer, 0, sizeof(gravityBuffer));
        Serial.println("Buffer Reset, Waiting for Next Dual-Gate Triggers...\n");
      }

      // 重置光电门1的3次触发数组
      memset(gate1TriggerTimes, 0, sizeof(gate1TriggerTimes));
    }
  }

  // 3. 重置双门触发标记，等待下一次双门触发
  gate1Triggered = false;
  gate2Triggered = false;
}

void setup() {
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);

  Serial.begin(115200);
  while (!Serial);
  Serial.println("=== Pendulum System Ready ===");
  Serial.print("Set Pendulum Length: ");
  Serial.print(pendulumLength);
  Serial.println("m");
  Serial.println("Waiting for Both Photo Gates Trigger...\n");

  // 初始化WiFi模块
  wifi.init(115200);
  delay(1000);
  if (wifi.sendATCmd((u8 *)"AT", (u8 *)"OK", 2000)) {
    Serial.println("WiFi Module Detected!");
    if (wifi.sendATCmd((u8 *)"AT+WMODE?", (u8 *)"+WMODE:1", 2000)) {
      u8 connectCmd[128];
      sprintf((char *)connectCmd, "AT+WJAP=%s,%s", WIFI_SSID, WIFI_PASSWORD);
      if (wifi.sendATCmd(connectCmd, (u8 *)"+EVENT:WIFI_GOT_IP", 10000)) {
        Serial.println("WiFi Connected!\n");
      } else {
        Serial.println("WiFi Connect Failed!\n");
      }
    } else {
      Serial.println("WiFi Set Station Mode Failed!\n");
    }
  } else {
    Serial.println("WiFi Module Not Detected!\n");
  }
}

void loop() {
  unsigned long currentTime = micros();
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);

  // -------------------------- 1. 光电门1触发处理 --------------------------
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;
    gate1Triggered = true;  // 标记光电门1已触发

    // 存储光电门1的触发时间（用于计算周期）
    gate1TriggerTimes[triggerCount] = gate1Time;
    triggerCount = (triggerCount + 1) % 3;
  }

  // -------------------------- 2. 光电门2触发处理 --------------------------
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;
    gate2Triggered = true;  // 标记光电门2已触发
  }

  // -------------------------- 3. 双门均触发后，处理数据 --------------------------
  if (gate1Triggered && gate2Triggered) {
    processDualGateData();
  }

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

此时AI生成的打印消息恢复正常，但AI把WIFI逻辑也改变了，导致上传失败，人工恢复上次的WIFI逻辑

#include "wifi.h"  // 引入自定义的 WiFi 模块驱动头文件

#define WIFI_SSID ""  // WiFi 名称，需替换为实际 SSID
#define WIFI_PASSWORD ""  // WiFi 密码，需替换为实际密码
#define SERVER_IP "192.168.2.15"    // 服务器IP，现场修改
#define SERVER_PORT 5000            // 服务器端口
#define DATA_COUNT 10               // 缓存重力加速度的次数（10次求平均）

Wifi wifi;  // 创建 WiFi 类实例

// 光电门引脚定义
#define PHOTO_GATE1 A0
#define PHOTO_GATE2 A1

// 光电门状态与时间变量
unsigned long gate1Time = 0;               // 光电门1当前触发时间(微秒)
unsigned long gate2Time = 0;               // 光电门2当前触发时间(微秒)
bool gate1State = LOW;                     // 光电门1当前状态
bool gate2State = LOW;                     // 光电门2当前状态
bool gate1LastState = LOW;                 // 光电门1上一状态
bool gate2LastState = LOW;                 // 光电门2上一状态
const unsigned long debounceTime = 50000;  // 防抖时间（50ms）
bool gate1Triggered = false;               // 光电门1是否完成一次有效触发
bool gate2Triggered = false;               // 光电门2是否完成一次有效触发

// 单摆周期计算变量（3次触发求完整周期，基于光电门1）
unsigned long gate1TriggerTimes[3] = { 0, 0, 0 };
int triggerCount = 0;               // 光电门1触发次数计数器（0-2循环）
const float pendulumLength = 0.31;  // 摆长（米，按实际修改）
const float pi = 3.1415926;         // π值

// 重力加速度缓存与计数（10次求平均）
float gravityBuffer[DATA_COUNT] = { 0 };  // 缓存10次重力加速度
int gravityCount = 0;                     // 已缓存的次数
float avgGravity = 0;                     // 重力加速度平均值

// float转char数组函数（原功能保留）
void floatToChar(float value, char *result, int bufferSize, int decimalPlaces = 4) {
  long multiplier = 1;
  for (int i = 0; i < decimalPlaces; i++) {
    multiplier *= 10;
  }

  long scaled = (long)(value * multiplier + (value >= 0 ? 0.5 : -0.5));
  int integerPart = scaled / multiplier;
  int fractionalPart = scaled % multiplier;
  int absFraction = abs(fractionalPart);

  char format[10];
  sprintf(format, "%%d.%%0%dd", decimalPlaces);
  snprintf(result, bufferSize, format, integerPart, absFraction);
}

// WiFi上传平均重力加速度函数（封装上传逻辑）
void uploadAvgGravity(float avgG) {

  // 先构造json数据
  char str1[15];
  floatToChar(avgG, str1, sizeof(str1), 4);  //avgGravity就是传感器的数据 该函数将浮点数转换为字符串（WCH库没有开浮点数打印）
  char jsonData[128];
  sprintf(jsonData, "{\"id\": 2, \"username\": \"alice\", \"value\": %s}", str1);  //注意id要改成自己的id，username要改成自己的用户名
  // 计算json数据的实际长度 用于发送json数据给服务器
  int jsonLen = strlen(jsonData);
  // 动态构造AT命令
  char httpCmd[256];
  sprintf((char *)httpCmd, "AT+HTTPRAW=1,3,\"application/json\",192.168.2.15,5000,\"/api/data\",%d", jsonLen);  //192.168.2.15是服务器的IP地址，现场修改
                                                                                                                 // 发送AT命令
  wifi.sendATCmd((u8 *)httpCmd, (u8 *)">", 4000);
  // 发送json数据
  wifi.sendATCmd((u8 *)jsonData, (u8 *)"OK", 10000);
}

// 双门均触发后，处理数据（打印时间+计算重力）
void processDualGateData() {
  // 1. 按格式打印双门触发时间
  Serial.print("get1:");
  Serial.print(gate1Time);
  Serial.print(",get2:");
  Serial.println(gate2Time);

  // 2. 基于光电门1的3次触发计算重力加速度
  if (gate1TriggerTimes[0] != 0 && gate1TriggerTimes[2] != 0) {
    unsigned long fullPeriodMicros = gate1TriggerTimes[2] - gate1TriggerTimes[0];
    float fullPeriodSec = fullPeriodMicros / 1000000.0;

    // 过滤异常周期（适配0.31m摆长）
    if (fullPeriodSec > 0.8 && fullPeriodSec < 1.5) {
      float gravity = (4 * pi * pi * pendulumLength) / (fullPeriodSec * fullPeriodSec);
      Serial.print("Single Gravity: ");
      Serial.print(gravity, 4);
      Serial.println(" m/s²");

      // 缓存重力加速度
      gravityBuffer[gravityCount] = gravity;
      gravityCount++;
      Serial.print("Cached Count: ");
      Serial.println(gravityCount);

      // 满10次数据，计算平均值并上传
      if (gravityCount >= DATA_COUNT) {
        avgGravity = 0;
        for (int i = 0; i < DATA_COUNT; i++) {
          avgGravity += gravityBuffer[i];
        }
        avgGravity /= DATA_COUNT;

        uploadAvgGravity(avgGravity);

        // 重置缓存
        gravityCount = 0;
        memset(gravityBuffer, 0, sizeof(gravityBuffer));
        Serial.println("Buffer Reset, Waiting for Next Dual-Gate Triggers...\n");
      }

      // 重置光电门1的3次触发数组
      memset(gate1TriggerTimes, 0, sizeof(gate1TriggerTimes));
    }
  }

  // 3. 重置双门触发标记，等待下一次双门触发
  gate1Triggered = false;
  gate2Triggered = false;
}

void setup() {
  pinMode(PHOTO_GATE1, INPUT);
  pinMode(PHOTO_GATE2, INPUT);

  Serial.begin(115200);
  while (!Serial)
    ;
  Serial.println("=== Pendulum System Ready ===");
  Serial.print("Set Pendulum Length: ");
  Serial.print(pendulumLength);
  Serial.println("m");
  Serial.println("Waiting for Both Photo Gates Trigger...\n");

  // 初始化WiFi模块
  wifi.init(115200);
  delay(1000);
  // 发送 AT 指令，等待返回 "OK"，超时时间 2000ms，用来检测模块是否正常工作
  wifi.sendATCmd((u8 *)"AT", (u8 *)"OK", 2000);

  // 查询当前 WiFi 模式，期望返回 "+WMODE:1"（Station 模式），超时 2000ms
  wifi.sendATCmd((u8 *)"AT+WMODE?", (u8 *)"+WMODE:1", 2000);

  u8 connectCmd[128];  // 定义一个 128 字节的数组，用于存放连接 WiFi 的 AT 指令
  // 格式化生成连接 WiFi 的 AT 命令，例如：AT+WJAP=SSID,PASSWORD
  sprintf((char *)connectCmd, "AT+WJAP=%s,%s", WIFI_SSID, WIFI_PASSWORD);
  // 发送连接 WiFi 的 AT 指令，等待获取 IP 地址事件 "+EVENT:WIFI_GOT_IP"，超时 10000ms
  wifi.sendATCmd(connectCmd, (u8 *)"+EVENT:WIFI_GOT_IP", 10000);
}

void loop() {
  unsigned long currentTime = micros();
  gate1State = digitalRead(PHOTO_GATE1);
  gate2State = digitalRead(PHOTO_GATE2);

  // -------------------------- 1. 光电门1触发处理 --------------------------
  if (gate1State == HIGH && gate1LastState == LOW && (currentTime - gate1Time) > debounceTime) {
    gate1Time = currentTime;
    gate1Triggered = true;  // 标记光电门1已触发

    // 存储光电门1的触发时间（用于计算周期）
    gate1TriggerTimes[triggerCount] = gate1Time;
    triggerCount = (triggerCount + 1) % 3;
  }

  // -------------------------- 2. 光电门2触发处理 --------------------------
  if (gate2State == HIGH && gate2LastState == LOW && (currentTime - gate2Time) > debounceTime) {
    gate2Time = currentTime;
    gate2Triggered = true;  // 标记光电门2已触发
  }

  // -------------------------- 3. 双门均触发后，处理数据 --------------------------
  if (gate1Triggered && gate2Triggered) {
    processDualGateData();
  }

  // 更新上一状态
  gate1LastState = gate1State;
  gate2LastState = gate2State;
}

单摆实验教程

赛题资料和程序代码都已上传到Gitee上，有需要的可以自行下载，下载链接：https://gitee.com/baby-sea/ch32.git

装置调整

根据比赛提供的《单摆实验装置使用说明》，我们首先需要调整单摆装置能正常工作。

1. 先将光电板与单片机用杜邦线连接

2. 调整光电板子上的电阻，使用AnalogRead()函数来观察输出电压。

当摆绳遮挡狭缝时，照射到接收管的光大部分被遮挡，接收管上的光电流减小，R1/R2上的电压降低，输出电压升高。

调节电位器R1、R2,可改变D1、D2在上述两种情况下的输出电压。当输出电压符合要求时，此电路可以用于测量单摆周期和摆动方向。

3. 编写代码，并调整电位器，电位器左转，电位器电阻R变大，D电平更容易为低电平，电位器右转，电位器电阻R变小，D电平更容易为高电平，我们需要调整电阻到恰当的位置，观察触发现象。

下位机代码编写

烧录代码后，编译器发生报错，将错误上传豆包

再次烧录代码，发现得到的重力加速度数值偏大，但数据稳定，反馈给豆包重新生成后代码依旧有问题

此时需要人工看看代码的逻辑，发现用于计算的单摆时间有问题，应该采用第一次与第三次的触发时间差为一次单摆后期时间，生成代码后，再调整绳长后，发现测量数据完美

成功获得重力加速度后，需要通过WIFI上传到服务器端，在服务器端的网页上可以发现AT指令的调用方法，再结合比赛第三课的连接WIFI教程，将代码整合一下

为了上位机能有更好的展示效果，下位机减少上传服务器的频率，改为收集十次重力加速度后求平均值再上传服务器，而串口打印出每次的光电门触发时间

观察下位机的打印，可以发现打印里有重复的时间数据，检测代码发现只要光电门被触发就会打印时间数据，需要修改为当两个光电门都触发完毕后，再打印两个光电门的数据

此时AI生成的打印消息恢复正常，但AI把WIFI逻辑也改变了，导致上传失败，人工恢复上次的WIFI逻辑

至此下位机端的代码已经完成