ArduinoPlus开发板-编程手册

用电机 → 四个全往上
当 IO → 四个全往下
切开关 → 一定先断电

┌──────────────────────────────────────────────────────┐
│ 文件 编辑 项目 工具 帮助          [板卡 ▾] [端口 ▾]   │ ← 菜单栏 + 板卡/端口
├────┬─────────────────────────────────────────────────┤
│ 侧 │  ✓ 验证      → 上传      ⌨ 串口监视器            │ ← 顶部工具栏
│ 边 │─────────────────────────────────────────────────│
│ 栏 │                                                 │
│ 📁 │        代码编辑区（有行号、自动补全）             │
│ 📚 │                                                 │
│ 🔍 │                                                 │
├────┴─────────────────────────────────────────────────┤
│ 输出区：编译结果 / 上传进度 / 报错信息（红色）          │
└──────────────────────────────────────────────────────┘

#include <Servo.h>          // ① 引入库

Servo myservo;              // ② 创建一个舵机对象

void setup() {
  myservo.attach(9);        // ③ 告诉库：舵机信号线接在 D9
}

void loop() {
  myservo.write(90);        // ④ 调用库提供的函数：转到 90 度
  delay(1000);
  myservo.write(0);         //     转到 0 度
  delay(1000);
}

void setup() {
  // 上电（或复位）后【只执行一次】，写初始化内容
}

void loop() {
  // setup 结束后【反复执行】，写主逻辑
}

const byte LED_PIN = LED_BUILTIN;   // 常量：板载 LED 引脚 = 13

void setup() {
  pinMode(LED_PIN, OUTPUT);         // 把这个脚设成"输出"
}

void loop() {
  digitalWrite(LED_PIN, HIGH);      // 输出高电平 → 亮
  delay(1000);                      // 等 1000 毫秒 = 1 秒
  digitalWrite(LED_PIN, LOW);       // 输出低电平 → 灭
  delay(1000);
}

// 单行注释：解释这一行在干嘛

/*
   多行注释：
   用在函数开头说明作者、功能、参数
*/

int  score   = 0;        // 声明的同时赋值（推荐）
char grade;              // 先声明
grade = 'A';             // 后赋值
bool isReady = true;     // true / false

const byte LED_PIN = 13;      // 常量：全大写 + 下划线
int  buttonCount   = 0;       // 变量：小驼峰，见名知意
bool isRunning     = false;   // 布尔：用 is/has 开头

int a, b, c;                  // ❌ 不要用这种名字

int globalVal = 10;            // 【全局变量】：任何函数都能用

void setup() {
  int temp = 5;                // 【局部变量】：只在 setup 里有效
  Serial.println(globalVal);   // OK
}

void loop() {
  Serial.println(globalVal);   // OK
  // Serial.println(temp);     // ❌ 编译错误：temp 在 loop 里不存在
}

const byte LED_PIN = LED_BUILTIN;   // ✅ 推荐：有类型检查
#define LED_PIN 13                  // 也可以：编译前文本替换

// 内置常用常量
HIGH / LOW                     // 电平
INPUT / OUTPUT / INPUT_PULLUP  // 引脚模式
true / false
LED_BUILTIN                    // 板载 LED（ArduinoPlus 上 = 13）
PI                             // 3.14159…

int a = 5 / 2;         // 2，不是 2.5
float b = 5.0 / 2;     // 2.5 ✅ 至少写成 5.0
int c = 7 % 3;         // 1 → "7 除以 3 余 1"

if (x >= 0 && x <= 255) { }     // ✅ 判断区间
if (0 <= x <= 255)       { }    // ❌ 错误写法！必须拆成上面那种
if (!isRunning)          { }    // "没有在跑"

int i = 0;
i++;        // 执行后 i 变成 1
i++;        // 再执行，i 变成 2
i--;        // i 变回 1

int i = 5;
int a = i++;     // a = 5（旧值），i = 6
int b = ++i;     // i 先变 7，b = 7（新值）

for (int i = 0; i < 10; i++) { }    // ✅ 最常见用法
                                    // 也可以写 ++i，结果相同

int x = 5;
if (x == 5) { }     // ✅ 判断：x 是不是等于 5
if (x = 5)  { }     // ❌ 赋值：x 被改成 5，条件永远为真，程序逻辑全乱

int  a = 5 / 2;        // 结果是 2（不是 2.5！）
float b = 5.0 / 2;     // 结果是 2.5 ✅ 必须写成 5.0
float c = (float)5 / 2;// 结果 2.5 ✅ 或强制类型转换

for (int i = 0; i < 10; i++) {
  if (i % 2 == 0) Serial.println(i);   // 打印偶数
}
if (n % 5 == 0) { /* 每 5 次做一件事 */ }

if (条件) {
  // 条件成立时执行
}

if (digitalRead(2) == LOW) {      // 按键按下（上拉输入时按下为 LOW）
  digitalWrite(LED_BUILTIN, HIGH);
}

if (条件) {
  // 成立走这里
} else {
  // 不成立走这里
}

if (temperature > 30) {
  Serial.println("太热了");
} else {
  Serial.println("还行");
}

if (score >= 90) {
  Serial.println("优秀");
} else if (score >= 60) {
  Serial.println("及格");
} else {
  Serial.println("加油");
}

if (isRunning) {
  if (speed > 200) {
    Serial.println("高速运行中");
  } else {
    Serial.println("低速运行中");
  }
} else {
  Serial.println("已停止");
}

if (btnA == LOW && btnB == LOW) { }        // 与：两个都按下
if (btnA == LOW || btnB == LOW) { }        // 或：任意一个按下
if (!isRunning) { }                        // 非：没在运行
if (x >= 0 && x <= 255) { }                // 区间（不能写成 0 <= x <= 255）

// 格式：  条件 ? 成立时的值 : 不成立时的值
int absSpeed = (speed < 0) ? -speed : speed;

digitalWrite(dirPin, forward ? HIGH : LOW);   // 根据布尔值选电平

char cmd = Serial.read();

switch (cmd) {
  case 'f':
    Serial.println("前进");
    break;                       // 每个 case 记得 break
  case 'b':
    Serial.println("后退");
    break;
  case 's':
    Serial.println("停止");
    break;
  default:                       // 都不匹配时执行（建议保留）
    Serial.println("未知指令");
    break;
}

for (初始化; 循环条件; 每次结束后更新) {
  // 循环体
}

// 从 0 数到 9
for (int i = 0; i < 10; i++) {
  Serial.println(i);
}

// 倒着数：10 → 1
for (int i = 10; i > 0; i--) {
  Serial.println(i);
}

// 步长不为 1：每次加 5
for (int duty = 0; duty <= 255; duty += 5) {
  analogWrite(9, duty);      // 逐档提高 LED / 电机速度
  delay(50);
}

// 重复做固定次数的事
for (int t = 0; t < 3; t++) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(200);
  digitalWrite(LED_BUILTIN, LOW);
  delay(200);
}

int pins[] = {8, 9, 10, 11};         // 4 个引脚

for (int i = 0; i < 4; i++) {
  pinMode(pins[i], OUTPUT);          // 一次性初始化全部
}

for (int row = 0; row < 3; row++) {        // 外层：行
  for (int col = 0; col < 5; col++) {      // 内层：列
    Serial.print("*");
  }
  Serial.println();                        // 一行结束换行
}

while (条件) {
  // 条件为真就一直执行
}

int count = 0;
while (count < 5) {
  Serial.println(count);
  count++;                       // ❗忘了这句就是死循环
}

// 等待型用法：一直等按键被按下
while (digitalRead(2) == HIGH) {
  // 还没按下，空转等待
}
Serial.println("按下啦！");

// 等待串口数据到来
while (Serial.available() == 0) { }
char c = Serial.read();

int v;
do {
  v = analogRead(A0);            // 先读一次
  delay(100);
} while (v < 500);               // 没到阈值就继续读

for (int i = 0; i < 100; i++) {
  if (digitalRead(2) == LOW) break;      // break：立刻跳出整个循环
  if (i % 2 == 1) continue;              // continue：跳过本次，进入下一轮
  Serial.println(i);
}

delay(1000);           // 等 1000 毫秒 = 1 秒
delay(500);            // 等 0.5 秒
delayMicroseconds(10); // 等 10 微秒

digitalWrite(LED_BUILTIN, HIGH);
delay(1000);                          // 亮 1 秒
digitalWrite(LED_BUILTIN, LOW);
delay(1000);                          // 灭 1 秒

delay(1000) 期间：按键？不响应。串口数据？不读。传感器？不看。

unsigned long lastTime = 0;                  // 记录上次做事的时刻
const unsigned long INTERVAL = 1000;         // 每隔多久做一次

void loop() {
  unsigned long now = millis();

  if (now - lastTime >= INTERVAL) {          // 到点了
    lastTime = now;                          // 更新时间戳
    // 这里写"到点要做的事"
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }

  // loop 继续往下跑，还能同时做别的事
}

unsigned long lastBlink = 0, lastPrint = 0;

void loop() {
  unsigned long now = millis();

  if (now - lastBlink >= 500) {              // 任务1：每 500ms 翻转 LED
    lastBlink = now;
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  }

  if (now - lastPrint >= 2000) {             // 任务2：每 2000ms 打印一次
    lastPrint = now;
    Serial.print("A0 = ");
    Serial.println(analogRead(A0));
  }
}

不用函数：loop() 里 200 行，看不出干了啥
用函数：  loop() 里 5 行，每行一个动作，逻辑清楚

// 返回值类型  函数名(参数类型 参数名)
int add(int a, int b) {
  return a + b;                  // 有返回值
}

void blinkTimes(int times) {     // void = 不返回值
  for (int i = 0; i < times; i++) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
    delay(200);
  }
}

void loop() {
  Serial.println(add(3, 5));     // 调用 → 打印 8
  blinkTimes(3);                 // 调用 → 闪 3 下
}

#define M1_DIR 4
#define M1_PWM 5

void motor1(int speed) {          // speed: -255 ~ +255，负数反转
  if (speed >= 0) {
    digitalWrite(M1_DIR, HIGH);
    analogWrite(M1_PWM, speed);
  } else {
    digitalWrite(M1_DIR, LOW);
    analogWrite(M1_PWM, -speed);
  }
}

void loop() {
  motor1(200);    delay(2000);
  motor1(-150);   delay(2000);
  motor1(0);      delay(2000);
}

int nums[5];                        // 声明 5 个元素，下标 0–4
int scores[] = {90, 85, 78, 92};    // 声明并赋值

nums[0] = 10;                       // 赋值
Serial.println(nums[0]);            // 读取

for (int i = 0; i < 4; i++) {       // 遍历
  Serial.println(scores[i]);
}

int matrix[2][3] = { {1,2,3}, {4,5,6} };
Serial.println(matrix[1][2]);      // 6

char msg[]  = "Hello";       // ✅ UNO 上推荐：字符数组，省内存
String s    = "Hello";       // 也可以用（方便但更耗内存）

Serial.println(msg);
// 拼接：
String line = "Value = " + String(analogRead(A0));

int  raw  = analogRead(A0);
float volt = raw * (5.0 / 1023.0);          // 转成电压值（注意 5.0）
int  duty = constrain(map(raw, 0, 1023, 0, 255), 0, 255);
analogWrite(9, duty);

volatile long pulse = 0;

void count() { pulse++; }     // 中断函数：短、快、无参数无返回值

void setup() {
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), count, FALLING);
}

int(sensor / 10);              // 转 int
float x = float(a) / b;        // 转 float
String(42);                    // 数字转字符串
someString.toInt();            // 字符串转整数

HIGH/LOW → 决定往哪边转     0–255 → 决定转多快

#define M1_DIR 4
#define M1_PWM 5
#define M2_DIR 7
#define M2_PWM 6

void setup() {
  pinMode(M1_DIR, OUTPUT);  pinMode(M1_PWM, OUTPUT);
  pinMode(M2_DIR, OUTPUT);  pinMode(M2_PWM, OUTPUT);
  analogWrite(M1_PWM, 0);   analogWrite(M2_PWM, 0);   // 开局先停，好习惯
}

void loop() {
  // 前进：两台同向同速
  digitalWrite(M1_DIR, HIGH);  analogWrite(M1_PWM, 200);
  digitalWrite(M2_DIR, HIGH);  analogWrite(M2_PWM, 200);
  delay(2000);

  // 停止
  analogWrite(M1_PWM, 0);  analogWrite(M2_PWM, 0);
  delay(1000);
}

void motorRun(byte dirPin, byte pwmPin, bool forward, byte spd) {
  digitalWrite(dirPin, forward ? HIGH : LOW);
  analogWrite(pwmPin, spd);
}
// 调用：motorRun(M1_DIR, M1_PWM, true, 180);
//      motorRun(M1_DIR, M1_PWM, false, 180);   // 反转

for (int spd = 60; spd <= 220; spd += 10) {
  digitalWrite(M1_DIR, HIGH);
  analogWrite(M1_PWM, spd);
  delay(50);
}

// 用参数化函数表达上面这张表（留给你自己实现 ✍️）
// void move(int leftSpeed, int rightSpeed) { ... }

/* ===== 案例 A：按键控制 LED ===== */
const byte BTN_PIN  = 2;            // 按键：一端接 D2，另一端接 GND
const byte LED_PIN  = LED_BUILTIN;  // 板载 LED（D13）

bool ledOn   = false;   // 记录灯当前是否亮着
bool lastBtn = HIGH;    // 记录上一次读到的按键状态（INPUT_PULLUP：松手 = HIGH）

void setup() {
  pinMode(BTN_PIN, INPUT_PULLUP);   // 启用内部上拉电阻，按键另一端直接接 GND 即可
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);       // 开局先灭
}

void loop() {
  bool now = digitalRead(BTN_PIN);  // 读当前状态

  if (lastBtn == HIGH && now == LOW) {   // 下降沿：说明"刚按下"
    ledOn = !ledOn;                      // 状态翻转：亮→灭，灭→亮
    digitalWrite(LED_PIN, ledOn);
    delay(200);                          // 简易去抖：跳过按下瞬间的抖动
  }

  lastBtn = now;   // 把这一次记下来，供下一轮比较
}

/* ===== 案例 B：PWM 呼吸灯 ===== */
const byte LED_PIN = 9;      // 必须是 PWM 脚（D3/D5/D6/D9/D10/D11 之一；别用 D13）

int brightness = 0;          // 当前亮度 0–255
int stepSize   = 5;          // 每步变化量（必须是 int，因为它要变成负数）

void setup() {
  pinMode(LED_PIN, OUTPUT);  // 规范写法：用之前先声明模式
  Serial.begin(9600);
}

void loop() {
  brightness += stepSize;                          // ① 累加（+5 或 -5）
  brightness = constrain(brightness, 0, 255);      // ② 夹住，保证不越界
  analogWrite(LED_PIN, brightness);                // ③ 输出 PWM

  if (brightness <= 0 || brightness >= 255) {      // ④ 到端点就反向
    stepSize = -stepSize;                          //    取相反数：+5 ↔ -5
  }

  Serial.println(brightness);                      // 打开串口监视器看数值变化
  delay(20);
}

/* ===== 案例 C：4 路 LED 流水灯 ===== */
const byte leds[] = {8, 9, 10, 11};        // 4 个 LED 的引脚
const byte LED_COUNT = 4;                  // LED 数量
const int  DELAY_MS  = 150;                // 每个灯亮多久

void setup() {
  for (int i = 0; i < LED_COUNT; i++) {    // 用 for 一次性完成初始化
    pinMode(leds[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < LED_COUNT; i++) {    // 从第一个走到最后一个
    digitalWrite(leds[i], HIGH);
    delay(DELAY_MS);
    digitalWrite(leds[i], LOW);
  }
}

/* ===== 案例 D：串口指令控制 ===== */
const byte LED_PIN = LED_BUILTIN;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);                 // 波特率必须与串口监视器一致
  Serial.println("输入 1 开灯 / 0 关灯 / ? 查询");
}

void loop() {
  if (Serial.available() == 0) return;    // 没数据就直接返回，不往下走

  char cmd = Serial.read();               // 读一个字符

  switch (cmd) {
    case '1':
      digitalWrite(LED_PIN, HIGH);
      Serial.println("LED ON");
      break;
    case '0':
      digitalWrite(LED_PIN, LOW);
      Serial.println("LED OFF");
      break;
    case '?':
      Serial.print("当前状态: ");
      Serial.println(digitalRead(LED_PIN) == HIGH ? "ON" : "OFF");
      break;
    default:
      Serial.println("未知指令（只认 1 / 0 / ?）");
      break;
  }
}

/* ===== 案例 E：电位器调节亮度 ===== */
const byte POT_PIN = A0;     // 电位器
const byte LED_PIN = 9;      // LED（PWM 脚）

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  // 模拟口 A0 用 analogRead 时不需要 pinMode，写了也不影响
}

void loop() {
  int raw  = analogRead(POT_PIN);              // 0–1023
  int duty = map(raw, 0, 1023, 0, 255);        // 量程换算：10 位 → 8 位
  duty     = constrain(duty, 0, 255);          // 保险：确保不越界

  analogWrite(LED_PIN, duty);

  Serial.print("原始值: ");
  Serial.print(raw);
  Serial.print("  →  PWM: ");
  Serial.println(duty);

  delay(50);                                   // 打印太快会刷屏
}

/* ===== 案例 F：红绿灯状态机（非阻塞） ===== */
const byte RED_PIN    = 8;
const byte GREEN_PIN  = 9;
const byte YELLOW_PIN = 10;

const byte pins[]   = {RED_PIN, GREEN_PIN, YELLOW_PIN};  // 0=红 1=绿 2=黄
const unsigned long durations[] = {5000, 5000, 2000};    // 每一步持续多少毫秒
const byte STEP_COUNT = 3;

byte         currentStep = 0;      // 当前走到第几步
unsigned long lastChange  = 0;     // 上一次切换的时刻

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < STEP_COUNT; i++) {
    pinMode(pins[i], OUTPUT);
  }
  digitalWrite(pins[0], HIGH);     // 从红灯开始
  Serial.println("step 0: RED");
}

void loop() {
  // 时间到了就换下一步
  if (millis() - lastChange >= durations[currentStep]) {
    lastChange = millis();

    digitalWrite(pins[currentStep], LOW);        // 灭掉当前灯
    currentStep = (currentStep + 1) % STEP_COUNT;  // 0→1→2→0 循环
    digitalWrite(pins[currentStep], HIGH);       // 点亮下一盏

    Serial.print("step ");
    Serial.println(currentStep);
  }

  // 这里还可以继续写其他逻辑（读按键、读传感器……），不会被卡住
}

/* ===== 案例 G：光控灯 ===== */
const byte LIGHT_PIN = A0;     // 光敏传感器
const byte LED_PIN   = 9;      // LED（PWM 脚）
const int  THRESHOLD = 500;    // 阈值：先用串口观察实际数值后再定

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  Serial.println("用手遮住传感器，观察数值变化……");
}

void loop() {
  int light = analogRead(LIGHT_PIN);   // 0–1023
  Serial.println(light);               // 标定时看这一行

  if (light < THRESHOLD) {             // 数值越小表示越暗（以你手上的传感器为准）
    digitalWrite(LED_PIN, HIGH);       // 天黑 → 开灯
  } else {
    digitalWrite(LED_PIN, LOW);        // 天亮 → 关灯
  }

  delay(100);
}

int duty = map(light, 0, 1023, 255, 0);   // 注意两端"反着写"
duty = constrain(duty, 0, 255);
analogWrite(LED_PIN, duty);

bool lampOn = false;

if (!lampOn && light < 450) lampOn = true;    // 暗到 450 才开灯
if ( lampOn && light > 550) lampOn = false;   // 亮过 550 才关灯
digitalWrite(LED_PIN, lampOn);

/* ===== 案例 H：超声波测距 HC-SR04 ===== */
const byte TRIG_PIN = 8;
const byte ECHO_PIN = 2;

long  duration;      // 回波持续时长（微秒）
float distance;      // 距离（厘米）

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  // 1) 发一个 10 微秒的触发脉冲
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // 2) 量回波持续多久（微秒）；30 ms 收不到就超时，返回 0
  duration = pulseIn(ECHO_PIN, HIGH, 30000L);

  // 3) 换算：声速约 340 m/s = 0.034 cm/微秒，声波走的是往返，所以 ÷ 2
  distance = duration * 0.034 / 2;

  if (duration == 0) {
    Serial.println("超出量程 / 未收到回波");
  } else {
    Serial.print("距离: ");
    Serial.print(distance);
    Serial.println(" cm");
  }

  delay(100);   // 两次测量间隔建议 60 ms 以上
}

if (distance > 0 && distance < 15) {
  analogWrite(5, 0);   analogWrite(6, 0);      // 太近：停
} else if (distance < 40) {
  analogWrite(5, 100); analogWrite(6, 100);    // 中等：减速
} else {
  analogWrite(5, 200); analogWrite(6, 200);    // 安全：正常前进
}

/* ===== 案例 I-1：双路寻线（阈值法） ===== */
const byte L_SENSOR = A0;      // 左传感器
const byte R_SENSOR = A1;      // 右传感器

const byte M1_DIR = 4;         // M1 方向
const byte M1_PWM = 5;         // M1 速度（PWM）
const byte M2_DIR = 7;         // M2 方向
const byte M2_PWM = 6;         // M2 速度（PWM）

const int LINE = 600;          // "看到黑线"的阈值，先打印观察后确定

void setup() {
  Serial.begin(9600);
  pinMode(M1_DIR, OUTPUT);  pinMode(M1_PWM, OUTPUT);
  pinMode(M2_DIR, OUTPUT);  pinMode(M2_PWM, OUTPUT);

  digitalWrite(M1_DIR, HIGH);       // 都设为正转
  digitalWrite(M2_DIR, HIGH);
  analogWrite(M1_PWM, 0);           // 开局先停
  analogWrite(M2_PWM, 0);
}

void loop() {
  int l = analogRead(L_SENSOR);
  int r = analogRead(R_SENSOR);

  Serial.print("L="); Serial.print(l);
  Serial.print("  R="); Serial.println(r);

  if (l > LINE && r > LINE) {          // 两边都看到线：直行（或十字路口）
    analogWrite(M1_PWM, 180);
    analogWrite(M2_PWM, 180);
  } else if (l > LINE) {               // 左边压线：车偏右了，左转回来
    analogWrite(M1_PWM, 80);
    analogWrite(M2_PWM, 200);
  } else if (r > LINE) {               // 右边压线：车偏左了，右转回来
    analogWrite(M1_PWM, 200);
    analogWrite(M2_PWM, 80);
  } else {                             // 两边都看不到：冲出线了，停车最安全
    analogWrite(M1_PWM, 0);
    analogWrite(M2_PWM, 0);
  }

  delay(20);
}

/* ===== 案例 I-2：双路寻线（比例法）—— 只替换 loop 部分 ===== */
const int BASE      = 150;   // 基础速度
const int KP        = 1;     // 比例系数：抖得厉害调小，转不过弯调大
const int MIN_SPEED = 60;    // 死区：低于这个值电机不转，给个最小值

void loop() {
  int l = analogRead(L_SENSOR);
  int r = analogRead(R_SENSOR);
  int error = l - r;                      // 偏差：正 = 左边压线，负 = 右边压线

  int leftSpeed  = BASE + KP * error;     // 左压线 → 左轮快、右轮慢
  int rightSpeed = BASE - KP * error;

  if (leftSpeed  > 0 && leftSpeed  < MIN_SPEED) leftSpeed  = MIN_SPEED;  // 处理死区
  if (rightSpeed > 0 && rightSpeed < MIN_SPEED) rightSpeed = MIN_SPEED;

  leftSpeed  = constrain(leftSpeed,  0, 255);   // 限幅
  rightSpeed = constrain(rightSpeed, 0, 255);

  analogWrite(M1_PWM, leftSpeed);
  analogWrite(M2_PWM, rightSpeed);
}

void setup() { Serial.begin(9600); }        // ① 初始化

Serial.print("x = ");                       // ② 打标签
Serial.println(x);                          // ③ 打数值（换行版）

Serial.print("[进入函数] ");                    // 看程序跑到哪一步了
Serial.print("raw="); Serial.print(raw);       // 看变量原始值
Serial.print(" duty="); Serial.println(duty);  // 看换算结果

① 先确认程序真的烧进去了（加一句 Serial.println("hello") 在 setup 里）
② 在可疑位置前后各打一句日志，缩小范围
③ 怀疑硬件还是软件？写个最小程序只操作这一个引脚
④ 变量值不对就一路 print 到源头

┌────────────────────── ArduinoPlus 语法卡 ──────────────────────┐
│ 骨架：void setup(){ } 初始化一次  /  void loop(){ } 反复执行     │
│                                                                 │
│ 引脚：pinMode(p, OUTPUT|INPUT|INPUT_PULLUP)                     │
│       digitalWrite(p, HIGH|LOW)      digitalRead(p)             │
│       analogWrite(p, 0-255)  [PWM: 3,5,6,9,10,11]               │
│       analogRead(A0-A5) → 0-1023                                │
│                                                                 │
│ if      if (条件) { } else if (条件) { } else { }               │
│ switch  switch(x){ case 1: ...; break; default: ...; }          │
│ for     for (int i=0; i<N; i++) { }          计数               │
│ while   while (条件) { }                      等待/未知次数      │
│ do      do { } while (条件);                  至少执行一次       │
│ 跳出    break（跳出循环） / continue（跳过本次）                │
│                                                                 │
│ delay   delay(1000);              阻塞 1 秒                     │
│ millis  if (millis()-last >= 间隔) { last = millis(); ... }     │
│         ★ 变量必须用 unsigned long                              │
│                                                                 │
│ 函数    int f(int a){ return a; }  /  void g(byte p){ }         │
│ 映射    map(v,0,1023,0,255)   限幅 constrain(v,0,255)           │
│ 串口    Serial.begin(9600)  print / println / available / read  │
│                                                                 │
│ 电机 M1：D4=方向(HIGH/LOW)   D5=转速(analogWrite 0-255)         │
│ 电机 M2：D7=方向(HIGH/LOW)   D6=转速(analogWrite 0-255)         │
│ ★ 用电机 = 四位拨码全部向上；当 IO = 四位全部向下               │
│                                                                 │
│ 调试三宝：Serial.println(标签) + Serial.println(变量值)          │
│           + 先确认 setup 里能不能打印出 hello                    │
│                                                                 │
│ 头号错误：if(x == 5) 别写成 if(x = 5)                           │
│           5/2 = 2，想要 2.5 要写 5.0/2                          │
└─────────────────────────────────────────────────────────────────┘

① 把 for i in range(10): 直接写成 for (10)      → 记住三段式写法
② 忘了 int 声明：写成 x = 5;                    → 编译报错
③ print 保留了 Python 习惯                      → 要用 Serial.println