Lab 6 三模式游戏

先玩一遍再读代码。 菜单按 A 进视觉模式,B 进听觉模式,C 进记忆模式,* 看成绩。在任何子界面按 * 回菜单。视觉等绿灯,听觉等蜂鸣,收到提示才向红外模块挥手。记忆模式先看完三组数字,再按键盘逐组输入。

第 1–50 行 · 读接线和三类参数

Uno R3 接线如下。LCD 电源接匹配的供电,所有模块共地。单颗 LED 串联限流电阻。

器件 脚位
红外反射传感器 Vout D2,检测到手默认 LOW
红、黄、绿灯 D3、D4、D5
无源蜂鸣器 D6
键盘 R1–R4 D7、D8、D9、D10
键盘 C1–C4 D11、D12、D13、A0,A0 此处当数字脚
I²C LCD SDA→A4,SCL→A5,地址 0x27

Wire 和 LiquidCrystal_I2C 管屏幕通信,string.h 提供字符串比较,stdio.h 提供文字格式化。KEY_LAYOUT 是行列到键值的对照表,索引从 0 开始,例如第 2 行第 3 列得到 '6'。键盘要求稳定 35 ms,红外要求稳定 40 ms。反应等待最多 10 秒,成绩显示 6 秒。记忆默认 4 位、每组 5 秒,共 3 组。

展开原代码第 1–50 行
   1  
   2  #include <Wire.h>
   3  #include <LiquidCrystal_I2C.h>
   4  #include <string.h>
   5  #include <stdio.h>
   6  
   7  // LAB 6: Visual reaction + Audio reaction + 3-number memory game
   8  // Arduino Uno R3, IR reflective sensor, G/Y/R traffic LEDs,
   9  // passive piezo buzzer, 4x4 matrix keypad and I2C LCD1602.
  10  // No Keypad library is needed: the matrix is scanned in this sketch.
  11  
  12  // ------------------- Wiring -------------------
  13  const byte IR_PIN = 2;        // IR module Vout
  14  const byte RED_PIN = 3;       // Traffic light R
  15  const byte YELLOW_PIN = 4;    // Traffic light Y
  16  const byte GREEN_PIN = 5;     // Traffic light G
  17  const byte BUZZER_PIN = 6;    // Low-current passive buzzer +
  18  
  19  const byte ROW_PINS[4] = {7, 8, 9, 10};       // R1, R2, R3, R4
  20  const byte COL_PINS[4] = {11, 12, 13, A0};   // C1, C2, C3, C4
  21  
  22  const char KEY_LAYOUT[4][4] = {
  23    {'1', '2', '3', 'A'},
  24    {'4', '5', '6', 'B'},
  25    {'7', '8', '9', 'C'},
  26    {'*', '0', '#', 'D'}
  27  };
  28  
  29  // A4 = SDA, A5 = SCL (Arduino Uno R3)
  30  LiquidCrystal_I2C lcd(0x27, 16, 2);
  31  
  32  // Most 3-pin obstacle-sensing IR modules drive Vout LOW when detecting a hand.
  33  // Change to HIGH if your module is active-high.
  34  const byte IR_ACTIVE_LEVEL = LOW;
  35  
  36  const unsigned long IR_DEBOUNCE_MS = 40;
  37  const unsigned long KEY_DEBOUNCE_MS = 35;
  38  
  39  // Reaction settings
  40  const unsigned long RESPONSE_TIMEOUT_MS = 10000UL;
  41  const unsigned long RESULT_DISPLAY_MS = 6000UL;
  42  
  43  // Memory settings
  44  // A/B = number length
  45  // C/0 = display time
  46  // D = Backspace
  47  byte numberLength = 4;
  48  byte showSeconds = 5;
  49  const byte GROUP_COUNT = 3;
  50  

第 51–116 行 · 状态变量保存了什么

enum GameState 给 18 个界面或过程各一个名字。视觉走 READY → RED → YELLOW → GO,听觉走 READY → WAIT → GO。抢跑、结果、成绩是独立状态。记忆分设置、准备、展示、间隔、输入、反馈、成绩。程序用 state 保存当前状态,用 stateSince 保存进入时间,用 cueTime 单独存提示发出时刻。

redTimeMs、yellowTimeMs、audioWaitMs 存抽出的等待时间。成绩分别存视觉最短、听觉最短和记忆最高,反应以 0 表示初始无成绩,记忆以 −1 表示未玩,0 分可正常保存。

memoryNumbers[3][9] 放三组字符串,一组最多八个数字加结束符 '\0'。showingGroup 是当前看第几组,answeringGroup 是正在答第几组。entered 和 enteredCount 保存本组已输内容和长度。perfectGroups 记整组正确数,correctPositions 累加逐位匹配数。最后几个变量保存原始键值、稳定键值、红外原始与稳定状态的时间,以及成绩屏已显示的页号。

展开原代码第 51–116 行
  51  // ------------------- State machine -------------------
  52  enum GameState {
  53    MENU,
  54    VISUAL_READY,
  55    VISUAL_RED,
  56    VISUAL_YELLOW,
  57    VISUAL_GO,
  58    AUDIO_READY,
  59    AUDIO_WAIT,
  60    AUDIO_GO,
  61    REACTION_RESULT,
  62    FALSE_START,
  63    BEST_SCREEN,
  64    MEMORY_SETUP,
  65    MEMORY_PREP,
  66    MEMORY_SHOW,
  67    MEMORY_GAP,
  68    MEMORY_INPUT,
  69    MEMORY_FEEDBACK,
  70    MEMORY_RESULT
  71  };
  72  
  73  GameState state = MENU;
  74  
  75  unsigned long stateSince = 0;
  76  unsigned long cueTime = 0;
  77  
  78  unsigned long redTimeMs = 0;
  79  unsigned long yellowTimeMs = 0;
  80  unsigned long audioWaitMs = 0;
  81  
  82  unsigned long lastReactionMs = 0;
  83  unsigned long bestVisualMs = 0;
  84  unsigned long bestAudioMs = 0;
  85  
  86  bool lastModeAudio = false;
  87  
  88  // Three memory groups, each up to 8 digits + null terminator
  89  char memoryNumbers[3][9] = {{0}};
  90  
  91  byte showingGroup = 0;
  92  byte answeringGroup = 0;
  93  
  94  char entered[9] = {0};
  95  byte enteredCount = 0;
  96  
  97  byte perfectGroups = 0;
  98  byte correctPositions = 0;
  99  byte lastMemoryScore = 0;
 100  
 101  int bestMemoryScore = -1;
 102  bool lastAnswerCorrect = false;
 103  
 104  // Matrix keypad debouncing
 105  char lastRawKey = 0;
 106  char stableKey = 0;
 107  unsigned long rawKeyChangedAt = 0;
 108  
 109  // IR input debouncing
 110  bool lastRawIR = false;
 111  bool stableIR = false;
 112  unsigned long irRawChangedAt = 0;
 113  unsigned long lastWaveStartMs = 0;
 114  
 115  byte displayedBestPage = 255;
 116  

第 117–158 行 · 三个输出工具和进入状态的函数

  • lights(red,yellow,green) 把三个布尔值分别写到三个引脚。例如 lights(false,false,true) 只亮绿灯。
  • showLine(row,message) 先定位到该行开头,逐字输出,遇结束符停止,最多 16 字符。行尾补空格覆盖旧字。showTwoLines() 调两次,一次写第 0 行,一次写第 1 行。
  • enterState(next,now) 同时更新状态和进入时间。之后用 millis()-stateSince 算在此状态待了多久。
  • shortBeep() 通过 tone 输出频率和时长。默认 1400 Hz、75 ms,函数返回后蜂鸣器继续响,主循环继续查键盘与红外。
展开原代码第 117–158 行
 117  // ------------------- Hardware helpers -------------------
 118  
 119  void lights(bool red, bool yellow, bool green) {
 120    digitalWrite(RED_PIN, red ? HIGH : LOW);
 121    digitalWrite(YELLOW_PIN, yellow ? HIGH : LOW);
 122    digitalWrite(GREEN_PIN, green ? HIGH : LOW);
 123  }
 124  
 125  void showLine(byte row, const char *message) {
 126    lcd.setCursor(0, row);
 127  
 128    byte i = 0;
 129  
 130    while (i < 16 && message[i] != '\0') {
 131      lcd.print(message[i]);
 132      i++;
 133    }
 134  
 135    while (i < 16) {
 136      lcd.print(' ');
 137      i++;
 138    }
 139  }
 140  
 141  void showTwoLines(const char *top, const char *bottom) {
 142    showLine(0, top);
 143    showLine(1, bottom);
 144  }
 145  
 146  void enterState(GameState next, unsigned long now) {
 147    state = next;
 148    stateSince = now;
 149  }
 150  
 151  void shortBeep(
 152    unsigned int frequency = 1400,
 153    unsigned long duration = 75
 154  ) {
 155    // tone() is asynchronous; no blocking delay
 156    tone(BUZZER_PIN, frequency, duration);
 157  }
 158  

第 159–206 行 · 扫键盘,再把抖动滤掉

keypadRaw() 逐行扫描。先让本行成为低电平输出,等 3 μs,然后查四列。列脚配置为上拉输入,未按时 HIGH。按下某键使这行的低电平连到该列,读到 LOW 便从 KEY_LAYOUT[r][c] 取字符。无论找到与否,离开这一行前都改回 INPUT。四行全扫不到返回 0。

readKeyPress(now) 先看原始读数有没有变化。变了就记录新值和时刻。某值连续不变至少 35 ms 且与上次稳定值不同,才更新稳定值。新稳定值是按键字符时返回它,松开时只更新状态。举例,按 'A' 在 100 ms→102 ms 抖动,最后从 105 ms 起一直读 'A',最早在 140 ms 发出一个按键事件。一直按住时只发一次。

展开原代码第 159–206 行
 159  // ------------------- Keypad -------------------
 160  
 161  // Scan membrane keypad without Keypad library.
 162  // Inactive rows are high impedance.
 163  
 164  char keypadRaw() {
 165    for (byte r = 0; r < 4; r++) {
 166  
 167      digitalWrite(ROW_PINS[r], LOW);
 168      pinMode(ROW_PINS[r], OUTPUT);
 169      delayMicroseconds(3);
 170  
 171      for (byte c = 0; c < 4; c++) {
 172        if (digitalRead(COL_PINS[c]) == LOW) {
 173          pinMode(ROW_PINS[r], INPUT);
 174          return KEY_LAYOUT[r][c];
 175        }
 176      }
 177  
 178      pinMode(ROW_PINS[r], INPUT);
 179    }
 180  
 181    return 0;
 182  }
 183  
 184  char readKeyPress(unsigned long now) {
 185    char raw = keypadRaw();
 186  
 187    if (raw != lastRawKey) {
 188      lastRawKey = raw;
 189      rawKeyChangedAt = now;
 190    }
 191  
 192    if (
 193      raw != stableKey &&
 194      now - rawKeyChangedAt >= KEY_DEBOUNCE_MS
 195    ) {
 196      stableKey = raw;
 197  
 198      // One event per physical press
 199      if (raw != 0) {
 200        return raw;
 201      }
 202    }
 203  
 204    return 0;
 205  }
 206  

第 207–232 行 · 把挥手变成一个带时间的事件

digitalRead(IR_PIN)==IR_ACTIVE_LEVEL 把电平转换成「有手」。原始状态改变时记 irRawChangedAt。它持续至少 40 ms 且不同于稳定状态,才更新稳定值。只在稳定变为有手时返回 true,记 lastWaveStartMs 为这次变化的初始时刻。若在 4780 ms 检测到手、4820 ms 才确认稳定,反应时间用 4780 ms 计算,因此不会额外多加 40 ms。手移开并稳定后,下次挥手才能产生新事件。

展开原代码第 207–232 行
 207  // ------------------- IR Detection -------------------
 208  
 209  bool readNewWave(unsigned long now) {
 210    bool raw = (digitalRead(IR_PIN) == IR_ACTIVE_LEVEL);
 211  
 212    if (raw != lastRawIR) {
 213      lastRawIR = raw;
 214      irRawChangedAt = now;
 215    }
 216  
 217    if (
 218      raw != stableIR &&
 219      now - irRawChangedAt >= IR_DEBOUNCE_MS
 220    ) {
 221      stableIR = raw;
 222  
 223      if (stableIR) {
 224        // Exclude debounce delay from reaction time
 225        lastWaveStartMs = irRawChangedAt;
 226        return true;
 227      }
 228    }
 229  
 230    return false;
 231  }
 232  

第 233–262 行 · 菜单和开始前的画面

openMenu() 设 MENU、灭灯并停止蜂鸣,显示 A/B/C 和 * 的功能。openReactionReady(audio,now) 保存是听觉还是视觉,灭灯,按 audio 选对应 READY 状态和标题,第二行提示 # 开始、* 返回。调用这一段只是准备,计时在真正的提示发出时开始。

展开原代码第 233–262 行
 233  // ------------------- Main Screens -------------------
 234  
 235  void openMenu(unsigned long now) {
 236    enterState(MENU, now);
 237  
 238    lights(false, false, false);
 239    noTone(BUZZER_PIN);
 240  
 241    showTwoLines(
 242      "A:Visual B:Audio",
 243      "C:Memory *:Best"
 244    );
 245  }
 246  
 247  void openReactionReady(bool audio, unsigned long now) {
 248    lastModeAudio = audio;
 249  
 250    lights(false, false, false);
 251  
 252    enterState(
 253      audio ? AUDIO_READY : VISUAL_READY,
 254      now
 255    );
 256  
 257    showTwoLines(
 258      audio ? "Audio Reaction" : "Visual Reaction",
 259      "# Start  * Back"
 260    );
 261  }
 262  

第 263–321 行 · 抽取等待时间,处理抢跑

beginReaction 用当前微秒计数做随机种子。听觉抽 2000–5000 ms,灭灯、提示听声音,进入 AUDIO_WAIT。视觉抽红灯 1500–3500 ms、黄灯 800–1800 ms,先亮红灯并进入 VISUAL_RED。random(min,max) 取到下界但取不到上界,所以写 5001 才能包含 5000。

falseStart(now) 进 FALSE_START,屏幕提示太早,亮红灯,响 320 Hz 的 350 ms 低音,串口报错。闪灯节奏和返回由主循环决定。

展开原代码第 263–321 行
 263  // ------------------- Reaction Game -------------------
 264  
 265  void beginReaction(bool audio, unsigned long now) {
 266    lastModeAudio = audio;
 267  
 268    randomSeed(micros());
 269  
 270    if (audio) {
 271  
 272      audioWaitMs = (unsigned long)random(2000, 5001);
 273  
 274      lights(false, false, false);
 275  
 276      showTwoLines(
 277        "Audio Reaction",
 278        "Listen closely!"
 279      );
 280  
 281      enterState(AUDIO_WAIT, now);
 282  
 283      Serial.println(
 284        F("AUDIO waiting; respond after beep")
 285      );
 286  
 287    } else {
 288  
 289      redTimeMs = (unsigned long)random(1500, 3501);
 290      yellowTimeMs = (unsigned long)random(800, 1801);
 291  
 292      lights(true, false, false);
 293  
 294      showTwoLines(
 295        "RED: Stop",
 296        "Wait for GREEN"
 297      );
 298  
 299      enterState(VISUAL_RED, now);
 300  
 301      Serial.println(
 302        F("VISUAL red; wait for green")
 303      );
 304    }
 305  }
 306  
 307  void falseStart(unsigned long now) {
 308    enterState(FALSE_START, now);
 309  
 310    showTwoLines(
 311      "TOO EARLY!",
 312      "Wait for signal"
 313    );
 314  
 315    lights(true, false, false);
 316  
 317    shortBeep(320, 350);
 318  
 319    Serial.println(F("FALSE START"));
 320  }
 321  

第 322–411 行 · 反应结果、纪录和成绩屏首屏

unsigned long &best 让 best 成为对应纪录变量的别名。听觉更新 bestAudioMs,视觉更新 bestVisualMs。若尚无纪录或新时间更短,立即保存为纪录。两段 snprintf 将模式、时间和文字写进两个 17 字节的缓冲区,最多显示 16 字符并留结束符。显示结果后灭灯,按是否破纪录选择音高,进入 REACTION_RESULT,串口记录模式、本次时间和最佳时间。

showBest(now) 进入 BEST_SCREEN,令 displayedBestPage=255,为下一轮强制刷新做准备。先显示视觉与听觉最短用时。纪录为 0 时显示横线。之后主循环轮播两种成绩页。

展开原代码第 322–411 行
 322  void showReactionResult(unsigned long now) {
 323    bool newRecord = false;
 324  
 325    unsigned long &best =
 326      lastModeAudio ? bestAudioMs : bestVisualMs;
 327  
 328    if (best == 0 || lastReactionMs < best) {
 329      best = lastReactionMs;
 330      newRecord = true;
 331    }
 332  
 333    char line1[17];
 334    char line2[17];
 335  
 336    snprintf(
 337      line1,
 338      sizeof(line1),
 339      "%c:%lums%s",
 340      lastModeAudio ? 'A' : 'V',
 341      lastReactionMs,
 342      newRecord ? " BEST!" : ""
 343    );
 344  
 345    snprintf(
 346      line2,
 347      sizeof(line2),
 348      "B:%lums #Again",
 349      best
 350    );
 351  
 352    showTwoLines(line1, line2);
 353  
 354    lights(false, false, false);
 355  
 356    shortBeep(
 357      newRecord ? 2100 : 1300,
 358      130
 359    );
 360  
 361    enterState(REACTION_RESULT, now);
 362  
 363    Serial.print(
 364      lastModeAudio ? F("AUDIO") : F("VISUAL")
 365    );
 366  
 367    Serial.print(F(" reaction_ms="));
 368    Serial.print(lastReactionMs);
 369  
 370    Serial.print(F(" best_ms="));
 371    Serial.println(best);
 372  }
 373  
 374  // ------------------- Best Score -------------------
 375  
 376  void showBest(unsigned long now) {
 377    enterState(BEST_SCREEN, now);
 378  
 379    displayedBestPage = 255;
 380  
 381    lights(false, false, false);
 382  
 383    char b[17];
 384  
 385    if (bestVisualMs != 0) {
 386      snprintf(
 387        b,
 388        sizeof(b),
 389        "Visual %lu ms",
 390        bestVisualMs
 391      );
 392    } else {
 393      snprintf(b, sizeof(b), "Visual: ---");
 394    }
 395  
 396    showLine(0, b);
 397  
 398    if (bestAudioMs != 0) {
 399      snprintf(
 400        b,
 401        sizeof(b),
 402        "Audio %lu ms",
 403        bestAudioMs
 404      );
 405    } else {
 406      snprintf(b, sizeof(b), "Audio: ---");
 407    }
 408  
 409    showLine(1, b);
 410  }
 411  

第 412–492 行 · 设置记忆题、生成三组、重置进度

showMemorySetup() 用 snprintf 写位数和秒数,下面一行提醒 A/B 加减位数、C/0 加减秒数。openMemorySetup() 进入状态,灭灯,显示设置和串口说明。

makeMemoryNumbers() 外层循环走三组,内层走本组每一位。random(0,10) 取 0–9,加字符 '0' 得到 '0'–'9',所以 0042 可保留开头的零。写完把末尾设为 '\0'。例如四位就是下标 0–3 存数字、下标 4 结束。

startMemory() 重新生成三组,清整组分数和逐位分数、展示和作答下标以及输入长度。显示准备画面,亮黄灯,进入 MEMORY_PREP,再打印当前位数和秒数。

展开原代码第 412–492 行
 412  // ------------------- Memory Setup -------------------
 413  
 414  void showMemorySetup() {
 415    char b[17];
 416  
 417    snprintf(
 418      b,
 419      sizeof(b),
 420      "Len:%u  Show:%us",
 421      numberLength,
 422      showSeconds
 423    );
 424  
 425    showTwoLines(
 426      b,
 427      "A/B Len C/0 Time"
 428    );
 429  }
 430  
 431  void openMemorySetup(unsigned long now) {
 432    enterState(MEMORY_SETUP, now);
 433  
 434    lights(false, false, false);
 435  
 436    showMemorySetup();
 437  
 438    Serial.println(
 439      F("MEMORY: A=length+ B=length- C=seconds+ 0=seconds-")
 440    );
 441  
 442    Serial.println(
 443      F("MEMORY: #=start *=menu D=Backspace during input")
 444    );
 445  }
 446  
 447  // ------------------- Generate Memory Numbers -------------------
 448  
 449  void makeMemoryNumbers() {
 450    for (byte group = 0; group < GROUP_COUNT; group++) {
 451  
 452      for (byte i = 0; i < numberLength; i++) {
 453  
 454        // Leading zeros are allowed
 455        memoryNumbers[group][i] =
 456          '0' + (char)random(0, 10);
 457      }
 458  
 459      memoryNumbers[group][numberLength] = '\0';
 460    }
 461  }
 462  
 463  void startMemory(unsigned long now) {
 464    randomSeed(micros());
 465  
 466    makeMemoryNumbers();
 467  
 468    perfectGroups = 0;
 469    correctPositions = 0;
 470  
 471    showingGroup = 0;
 472    answeringGroup = 0;
 473  
 474    enteredCount = 0;
 475    entered[0] = '\0';
 476  
 477    lights(false, true, false);
 478  
 479    showTwoLines(
 480      "Remember 3 nums",
 481      "Starting soon..."
 482    );
 483  
 484    enterState(MEMORY_PREP, now);
 485  
 486    Serial.print(F("MEMORY start: len="));
 487    Serial.print(numberLength);
 488  
 489    Serial.print(F(" time_s="));
 490    Serial.println(showSeconds);
 491  }
 492  

第 493–553 行 · 放题、开启答题、画输入

showMemoryGroup 进入 MEMORY_SHOW、亮黄灯,第一行写第几组,第二行显示当前待记字符串,再响一声。showMemoryEntry 进入 MEMORY_INPUT,把上一组的输入清空,亮绿灯并提示 # 确认、D 删除。refreshTypedAnswer 每一位如果已有输入就显示字符,否则写下划线。例如长度 4,输入 6、0,屏上看到 60__。末尾加 NUL,确保显示函数知道在哪里停止。

展开原代码第 493–553 行
 493  // ------------------- Show Memory Numbers -------------------
 494  
 495  void showMemoryGroup(unsigned long now) {
 496    enterState(MEMORY_SHOW, now);
 497  
 498    lights(false, true, false);
 499  
 500    char b[17];
 501  
 502    snprintf(
 503      b,
 504      sizeof(b),
 505      "Number %u / 3",
 506      showingGroup + 1
 507    );
 508  
 509    showTwoLines(
 510      b,
 511      memoryNumbers[showingGroup]
 512    );
 513  
 514    // Beep when each group appears
 515    shortBeep(1500, 100);
 516  }
 517  
 518  // ------------------- Memory Answer Input -------------------
 519  
 520  void showMemoryEntry(unsigned long now) {
 521    enterState(MEMORY_INPUT, now);
 522  
 523    enteredCount = 0;
 524    entered[0] = '\0';
 525  
 526    lights(false, false, true);
 527  
 528    char b[17];
 529  
 530    snprintf(
 531      b,
 532      sizeof(b),
 533      "R%u/3 #OK D:Del",
 534      answeringGroup + 1
 535    );
 536  
 537    showTwoLines(b, "");
 538  }
 539  
 540  void refreshTypedAnswer() {
 541    char b[17];
 542  
 543    for (byte i = 0; i < numberLength; i++) {
 544  
 545      b[i] = (i < enteredCount) ?
 546        entered[i] : '_';
 547    }
 548  
 549    b[numberLength] = '\0';
 550  
 551    showLine(1, b);
 552  }
 553  

第 554–620 行 · 整组是否正确,逐位又对多少

strcmp(entered,expected)==0 说明两串字符逐一相同,perfectGroups 加一。另走一遍每个下标,相等就给 correctPositions 加一。假设题目 0427、提交 0457,四位分别是对、对、错、对,整组计 0,逐位累计加 3。之后屏幕、灯和蜂鸣提示对错,进入 MEMORY_FEEDBACK,串口打印题号、正确串、输入串、整组对错。

展开原代码第 554–620 行
 554  // ------------------- Grade Memory Answer -------------------
 555  
 556  void gradeMemoryAnswer(unsigned long now) {
 557  
 558    lastAnswerCorrect = (
 559      strcmp(
 560        entered,
 561        memoryNumbers[answeringGroup]
 562      ) == 0
 563    );
 564  
 565    if (lastAnswerCorrect) {
 566      perfectGroups++;
 567    }
 568  
 569    for (byte i = 0; i < numberLength; i++) {
 570      if (
 571        entered[i] ==
 572        memoryNumbers[answeringGroup][i]
 573      ) {
 574        correctPositions++;
 575      }
 576    }
 577  
 578    char b[17];
 579  
 580    snprintf(
 581      b,
 582      sizeof(b),
 583      "Group %u: %s",
 584      answeringGroup + 1,
 585      lastAnswerCorrect ? "CORRECT" : "WRONG"
 586    );
 587  
 588    showTwoLines(
 589      b,
 590      lastAnswerCorrect ?
 591        "Nice memory!" :
 592        "Keep trying!"
 593    );
 594  
 595    lights(
 596      !lastAnswerCorrect,
 597      false,
 598      lastAnswerCorrect
 599    );
 600  
 601    shortBeep(
 602      lastAnswerCorrect ? 1900 : 400,
 603      180
 604    );
 605  
 606    enterState(MEMORY_FEEDBACK, now);
 607  
 608    Serial.print(F("MEMORY group="));
 609    Serial.print(answeringGroup + 1);
 610  
 611    Serial.print(F(" expected="));
 612    Serial.print(memoryNumbers[answeringGroup]);
 613  
 614    Serial.print(F(" entered="));
 615    Serial.print(entered);
 616  
 617    Serial.print(F(" exact="));
 618    Serial.println(lastAnswerCorrect ? 1 : 0);
 619  }
 620  

第 621–685 行 · 最终百分制如何手算

总位数是三组乘每组位数。把逐位正确数乘 100 再除总位数即可得百分数。整数除法丢小数,代码先在分子加上整数版的半个分母做四舍五入。

N=3×位数,score=⌊100×正确位数+⌊N/2⌋N⌋N=3\times\text{位数},\qquad score=\left\lfloor\frac{100\times\text{正确位数}+\lfloor N/2\rfloor}{N}\right\rfloor

例如三组各 4 位,共 12 位,答对 8 位,(8×100+6)/12=806/12(8\times100+6)/12=806/12,整数结果 67 分。若比历史最高分高就更新。LCD 第一行写整组全对数,第二行写百分制分数。全对时亮三灯、响更高的音。进入 MEMORY_RESULT 并用串口记录总位数、正确位数、本次和最佳分数。

读实物照片。 10 月 30 日的 LCD 照片显示 Correct: 2/3 和 Score: 92/100。4 位一组时,总共 12 位。两组全对占 8 位,若另一组只错一位,累计就是 11 位。按代码计算 ⌊(11×100+6)/12⌋=92\lfloor(11\times100+6)/12\rfloor=92,所以「整组正确数」和「逐位得分」会同时显示不同结果。

展开原代码第 621–685 行
 621  // ------------------- Final Memory Score -------------------
 622  
 623  void finishMemory(unsigned long now) {
 624    byte totalPositions =
 625      (byte)(GROUP_COUNT * numberLength);
 626  
 627    lastMemoryScore = (byte)(
 628      (
 629        (unsigned int)correctPositions * 100U +
 630        totalPositions / 2U
 631      ) / totalPositions
 632    );
 633  
 634    if ((int)lastMemoryScore > bestMemoryScore) {
 635      bestMemoryScore = lastMemoryScore;
 636    }
 637  
 638    char a[17];
 639    char b[17];
 640  
 641    snprintf(
 642      a,
 643      sizeof(a),
 644      "Correct: %u/3",
 645      perfectGroups
 646    );
 647  
 648    snprintf(
 649      b,
 650      sizeof(b),
 651      "Score: %u/100",
 652      lastMemoryScore
 653    );
 654  
 655    showTwoLines(a, b);
 656  
 657    lights(false, false, false);
 658  
 659    if (perfectGroups == GROUP_COUNT) {
 660      lights(true, true, true);
 661    }
 662  
 663    shortBeep(
 664      perfectGroups == GROUP_COUNT ? 2100 : 1100,
 665      250
 666    );
 667  
 668    enterState(MEMORY_RESULT, now);
 669  
 670    Serial.print(F("MEMORY final: exact_groups="));
 671    Serial.print(perfectGroups);
 672  
 673    Serial.print(F("/3 matched_positions="));
 674    Serial.print(correctPositions);
 675  
 676    Serial.print(F("/"));
 677    Serial.print(totalPositions);
 678  
 679    Serial.print(F(" score="));
 680    Serial.print(lastMemoryScore);
 681  
 682    Serial.print(F(" best_score="));
 683    Serial.println(bestMemoryScore);
 684  }
 685  

第 686–744 行 · 开机顺序与循环的入口

串口设为 115200。红外设上拉输入,三色灯和蜂鸣器设输出。键盘四行初始为高阻输入,四列为上拉输入。红外先读取一次,把原始与稳定状态设成相同,再初始化屏幕、开背光、清屏和进入菜单。

以后每轮先取当前时间,再读一个键盘事件和一个挥手事件。若不是菜单且按了 *,直接回菜单并结束本轮。否则按 state 进入对应的 case。时长判断只做比较,不用等待数秒才执行下一次循环。

展开原代码第 686–744 行
 686  // ------------------- SETUP -------------------
 687  
 688  void setup() {
 689    Serial.begin(115200);
 690  
 691    pinMode(IR_PIN, INPUT_PULLUP);
 692  
 693    pinMode(RED_PIN, OUTPUT);
 694    pinMode(YELLOW_PIN, OUTPUT);
 695    pinMode(GREEN_PIN, OUTPUT);
 696    pinMode(BUZZER_PIN, OUTPUT);
 697  
 698    lights(false, false, false);
 699  
 700    // Initialize keypad pins
 701    for (byte i = 0; i < 4; i++) {
 702      pinMode(ROW_PINS[i], INPUT);
 703      digitalWrite(ROW_PINS[i], LOW);
 704  
 705      pinMode(COL_PINS[i], INPUT_PULLUP);
 706    }
 707  
 708    // Initialize IR
 709    lastRawIR = (
 710      digitalRead(IR_PIN) == IR_ACTIVE_LEVEL
 711    );
 712  
 713    stableIR = lastRawIR;
 714    irRawChangedAt = millis();
 715  
 716    // Initialize LCD
 717    lcd.init();
 718    lcd.backlight();
 719    lcd.clear();
 720  
 721    openMenu(millis());
 722  
 723    Serial.println(
 724      F("Lab6 Three-mode Arcade ready; Serial=115200")
 725    );
 726  }
 727  
 728  // ------------------- MAIN LOOP -------------------
 729  
 730  void loop() {
 731  
 732    unsigned long now = millis();
 733  
 734    char key = readKeyPress(now);
 735    bool wave = readNewWave(now);
 736  
 737    // * opens Best on menu
 738    // * returns to menu elsewhere
 739    if (key == '*' && state != MENU) {
 740      openMenu(now);
 741      return;
 742    }
 743  
 744    switch (state) {

第 745–784 行 · 菜单按键与准备界面

MENU 读到 A、B、C、* 分别打开视觉准备、听觉准备、记忆设置、纪录。两个 READY 状态内,按 # 或检测到一次挥手就开局,函数参数 false/true 选视觉/听觉。没有事件时直接跳出 switch,下一轮继续读。

展开原代码第 745–784 行
 745  
 746      // ---------------- MENU ----------------
 747      case MENU:
 748  
 749        if (key == 'A') {
 750          openReactionReady(false, now);
 751        }
 752  
 753        else if (key == 'B') {
 754          openReactionReady(true, now);
 755        }
 756  
 757        else if (key == 'C') {
 758          openMemorySetup(now);
 759        }
 760  
 761        else if (key == '*') {
 762          showBest(now);
 763        }
 764  
 765        break;
 766  
 767      // ---------------- VISUAL READY ----------------
 768      case VISUAL_READY:
 769  
 770        if (key == '#' || wave) {
 771          beginReaction(false, now);
 772        }
 773  
 774        break;
 775  
 776      // ---------------- AUDIO READY ----------------
 777      case AUDIO_READY:
 778  
 779        if (key == '#' || wave) {
 780          beginReaction(true, now);
 781        }
 782  
 783        break;
 784  

第 785–856 行 · 红、黄、绿三段与反应时

当前状态 发生了什么 下一步
VISUAL_RED 挥手 抢跑
VISUAL_RED 等够本局红灯时间 点黄、提示等待、进入 VISUAL_YELLOW
VISUAL_YELLOW 挥手 抢跑
VISUAL_YELLOW 等够本局黄灯时间 点绿、立即记 cueTime、换 VISUAL_GO、提示挥手
VISUAL_GO 挥手,起始时间在提示之前 抢跑
VISUAL_GO 挥手,起始时间在提示之后 相减求反应时间、显示结果
VISUAL_GO 未挥手且超过 10 秒 回到准备画面,提示超时

手算边界。绿灯 4500 ms。手在 4480 ms 开始,4520 ms 才被确认为稳定。虽已进入 GO,起始时刻仍比提示早 20 ms,判抢跑。若手 4780 ms 开始,则 4780−4500=2804780-4500=280 ms。源码将两时刻差转成有符号 long,在 Uno 的短时间间隔内用负差检查抢跑。

展开原代码第 785–856 行
 785      // ---------------- VISUAL RED ----------------
 786      case VISUAL_RED:
 787  
 788        if (wave) {
 789          falseStart(now);
 790        }
 791  
 792        else if (now - stateSince >= redTimeMs) {
 793  
 794          lights(false, true, false);
 795  
 796          showTwoLines(
 797            "YELLOW: Ready",
 798            "Wait for GREEN"
 799          );
 800  
 801          enterState(VISUAL_YELLOW, now);
 802        }
 803  
 804        break;
 805  
 806      // ---------------- VISUAL YELLOW ----------------
 807      case VISUAL_YELLOW:
 808  
 809        if (wave) {
 810          falseStart(now);
 811        }
 812  
 813        else if (now - stateSince >= yellowTimeMs) {
 814  
 815          lights(false, false, true);
 816  
 817          cueTime = millis();
 818  
 819          enterState(VISUAL_GO, cueTime);
 820  
 821          showTwoLines(
 822            "GREEN! GO!",
 823            "Wave NOW!"
 824          );
 825        }
 826  
 827        break;
 828  
 829      // ---------------- VISUAL GO ----------------
 830      case VISUAL_GO:
 831  
 832        if (wave) {
 833  
 834          if ((long)(lastWaveStartMs - cueTime) < 0) {
 835            falseStart(now);
 836          }
 837  
 838          else {
 839            lastReactionMs = lastWaveStartMs - cueTime;
 840            showReactionResult(now);
 841          }
 842        }
 843  
 844        else if (
 845          now - cueTime >= RESPONSE_TIMEOUT_MS
 846        ) {
 847          openReactionReady(false, now);
 848  
 849          showTwoLines(
 850            "Time out!",
 851            "# Retry  * Back"
 852          );
 853        }
 854  
 855        break;
 856  

第 857–905 行 · 听觉提示只响一声

AUDIO_WAIT 中,先挥手就抢跑。等够随机时间后记 cueTime,响 1800 Hz、180 ms,不切换灯光或屏幕,再进 AUDIO_GO。GO 中的计算和视觉相同,比较挥手开始时刻与提示时刻。收到较晚的事件就算出时间,无事件且满 10 秒则回听觉准备页。

展开原代码第 857–905 行
 857      // ---------------- AUDIO WAIT ----------------
 858      case AUDIO_WAIT:
 859  
 860        if (wave) {
 861          falseStart(now);
 862        }
 863  
 864        else if (
 865          now - stateSince >= audioWaitMs
 866        ) {
 867          cueTime = millis();
 868  
 869          // Audio cue only
 870          // LCD and LEDs do not change
 871          shortBeep(1800, 180);
 872  
 873          enterState(AUDIO_GO, cueTime);
 874        }
 875  
 876        break;
 877  
 878      // ---------------- AUDIO GO ----------------
 879      case AUDIO_GO:
 880  
 881        if (wave) {
 882  
 883          if ((long)(lastWaveStartMs - cueTime) < 0) {
 884            falseStart(now);
 885          }
 886  
 887          else {
 888            lastReactionMs = lastWaveStartMs - cueTime;
 889            showReactionResult(now);
 890          }
 891        }
 892  
 893        else if (
 894          now - cueTime >= RESPONSE_TIMEOUT_MS
 895        ) {
 896          openReactionReady(true, now);
 897  
 898          showTwoLines(
 899            "Time out!",
 900            "# Retry  * Back"
 901          );
 902        }
 903  
 904        break;
 905  

第 906–937 行 · 抢跑后闪灯,成绩页可重来

FALSE_START 以经过时间除 200 ms,取整数,再取余数判断亮灭。0–199 ms 的商是 0,红灯亮。200–399 ms 的商是 1,红灯灭。如此交替,满 1600 ms 回到原模式准备界面。REACTION_RESULT 按 # 立即重开,没按则 6000 ms 后回准备界面。

展开原代码第 906–937 行
 906      // ---------------- FALSE START ----------------
 907      case FALSE_START:
 908  
 909        lights(
 910          ((now - stateSince) / 200UL) % 2UL == 0UL,
 911          false,
 912          false
 913        );
 914  
 915        if (
 916          now - stateSince >= 1600UL
 917        ) {
 918          openReactionReady(lastModeAudio, now);
 919        }
 920  
 921        break;
 922  
 923      // ---------------- REACTION RESULT ----------------
 924      case REACTION_RESULT:
 925  
 926        if (key == '#') {
 927          beginReaction(lastModeAudio, now);
 928        }
 929  
 930        else if (
 931          now - stateSince >= RESULT_DISPLAY_MS
 932        ) {
 933          openReactionReady(lastModeAudio, now);
 934        }
 935  
 936        break;
 937  

第 938–1017 行 · 纪录两页轮播

从进 BEST_SCREEN 起每过 2500 ms 取一个整数,用 %2 得到交替的 0、1 页。只有页号变化才更新屏幕。第 0 页写视觉和听觉的最短时间,无成绩写横线。第 1 页写记忆最高分,−1 时写未玩。反应竞速看最小值,记忆答题看最大值。

展开原代码第 938–1017 行
 938      // ---------------- BEST SCREEN ----------------
 939      case BEST_SCREEN: {
 940  
 941        byte page = (byte)(
 942          ((now - stateSince) / 2500UL) % 2UL
 943        );
 944  
 945        if (page != displayedBestPage) {
 946  
 947          displayedBestPage = page;
 948  
 949          char b[17];
 950  
 951          if (page == 1) {
 952  
 953            showLine(
 954              0,
 955              "Memory highscore"
 956            );
 957  
 958            if (bestMemoryScore < 0) {
 959  
 960              showLine(
 961                1,
 962                "Not played yet"
 963              );
 964  
 965            } else {
 966  
 967              snprintf(
 968                b,
 969                sizeof(b),
 970                "%d/100  * Back",
 971                bestMemoryScore
 972              );
 973  
 974              showLine(1, b);
 975            }
 976  
 977          } else {
 978  
 979            if (bestVisualMs) {
 980              snprintf(
 981                b,
 982                sizeof(b),
 983                "Visual %lums",
 984                bestVisualMs
 985              );
 986            } else {
 987              snprintf(
 988                b,
 989                sizeof(b),
 990                "Visual: ---"
 991              );
 992            }
 993  
 994            showLine(0, b);
 995  
 996            if (bestAudioMs) {
 997              snprintf(
 998                b,
 999                sizeof(b),
1000                "Audio %lums",
1001                bestAudioMs
1002              );
1003            } else {
1004              snprintf(
1005                b,
1006                sizeof(b),
1007                "Audio: ---"
1008              );
1009            }
1010  
1011            showLine(1, b);
1012          }
1013        }
1014  
1015        break;
1016      }
1017  

第 1018–1058 行 · 改位数和显示秒数

MEMORY_SETUP 内 A 加一位、B 减一位,允许 2–8 位。C 加一秒、0 减一秒,允许 2–10 秒。只在变化后重写画面,因此达到边界时按键不再改变设置。按 # 调用 startMemory()。

展开原代码第 1018–1058 行
1018      // ---------------- MEMORY SETUP ----------------
1019      case MEMORY_SETUP:
1020  
1021        if (
1022          key == 'A' &&
1023          numberLength < 8
1024        ) {
1025          numberLength++;
1026          showMemorySetup();
1027        }
1028  
1029        else if (
1030          key == 'B' &&
1031          numberLength > 2
1032        ) {
1033          numberLength--;
1034          showMemorySetup();
1035        }
1036  
1037        else if (
1038          key == 'C' &&
1039          showSeconds < 10
1040        ) {
1041          showSeconds++;
1042          showMemorySetup();
1043        }
1044  
1045        else if (
1046          key == '0' &&
1047          showSeconds > 2
1048        ) {
1049          showSeconds--;
1050          showMemorySetup();
1051        }
1052  
1053        else if (key == '#') {
1054          startMemory(now);
1055        }
1056  
1057        break;
1058  

第 1059–1122 行 · 展示每组数字及组间空档

MEMORY_PREP 满 1200 ms 后显示第一组。MEMORY_SHOW 等满 showSeconds*1000 ms,灭灯并切到 MEMORY_GAP。若还有下一组,屏幕提示下一组将开始。三组全看完则提示回忆。MEMORY_GAP 满 900 ms,有下一组就把下标加一并显示,否则开启第一组作答并画下划线。

例如每组显示 5 秒,忽略少量刷新时间,按 # 后第 1.2 秒出第一组,第 6.2 秒进入空档,第 7.1 秒出第二组。

展开原代码第 1059–1122 行
1059      // ---------------- MEMORY PREP ----------------
1060      case MEMORY_PREP:
1061  
1062        if (
1063          now - stateSince >= 1200UL
1064        ) {
1065          showMemoryGroup(now);
1066        }
1067  
1068        break;
1069  
1070      // ---------------- MEMORY SHOW ----------------
1071      case MEMORY_SHOW:
1072  
1073        if (
1074          now - stateSince >=
1075          (unsigned long)showSeconds * 1000UL
1076        ) {
1077  
1078          lights(false, false, false);
1079  
1080          enterState(MEMORY_GAP, now);
1081  
1082          if (
1083            showingGroup + 1 < GROUP_COUNT
1084          ) {
1085            showTwoLines(
1086              "Next number...",
1087              "Get ready"
1088            );
1089          }
1090  
1091          else {
1092            showTwoLines(
1093              "Time to recall",
1094              "Enter 3 numbers"
1095            );
1096          }
1097        }
1098  
1099        break;
1100  
1101      // ---------------- MEMORY GAP ----------------
1102      case MEMORY_GAP:
1103  
1104        if (
1105          now - stateSince >= 900UL
1106        ) {
1107  
1108          if (
1109            showingGroup + 1 < GROUP_COUNT
1110          ) {
1111            showingGroup++;
1112            showMemoryGroup(now);
1113          }
1114  
1115          else {
1116            showMemoryEntry(now);
1117            refreshTypedAnswer();
1118          }
1119        }
1120  
1121        break;
1122  

第 1123–1168 行 · 输入、删除和确认

数字键且长度还未满时,向当前下标写键值并自增长度,把结束符紧跟在最后一个字符之后。D 在已有一位时将长度减一,再把结束符写到新末尾。两种操作都刷新下划线。按 # 时长度正好才评分,没填满发 350 Hz 短音继续等待。比如 60__ 再按 9 得 609_,按 D 回到 60__,此时按 # 只响,补足两位才提交。

展开原代码第 1123–1168 行
1123      // ---------------- MEMORY INPUT ----------------
1124      case MEMORY_INPUT:
1125  
1126        // Number input
1127        if (
1128          key >= '0' &&
1129          key <= '9' &&
1130          enteredCount < numberLength
1131        ) {
1132  
1133          entered[enteredCount++] = key;
1134          entered[enteredCount] = '\0';
1135  
1136          refreshTypedAnswer();
1137        }
1138  
1139        // D = DELETE / BACKSPACE
1140        // Delete one digit each time
1141        else if (
1142          key == 'D' &&
1143          enteredCount > 0
1144        ) {
1145  
1146          enteredCount--;
1147  
1148          entered[enteredCount] = '\0';
1149  
1150          refreshTypedAnswer();
1151        }
1152  
1153        // Confirm answer
1154        else if (key == '#') {
1155  
1156          if (
1157            enteredCount == numberLength
1158          ) {
1159            gradeMemoryAnswer(now);
1160          }
1161  
1162          else {
1163            shortBeep(350, 120);
1164          }
1165        }
1166  
1167        break;
1168  

第 1169–1201 行 · 反馈、下一组和最终返回

每组反馈显示至少 1100 ms。后面还有组就令 answeringGroup++,清输入并显示下一组。全部三组完成就调用 finishMemory()。成绩页按 # 回设置,可以改参数再玩。任何非菜单状态仍适用前面的 * 返回。串口最后一行中的 exact_groups、matched_positions、score 分别记录整组全对数、逐位正确数和百分制得分。

展开原代码第 1169–1201 行
1169      // ---------------- MEMORY FEEDBACK ----------------
1170      case MEMORY_FEEDBACK:
1171  
1172        if (
1173          now - stateSince >= 1100UL
1174        ) {
1175  
1176          if (
1177            answeringGroup + 1 < GROUP_COUNT
1178          ) {
1179  
1180            answeringGroup++;
1181  
1182            showMemoryEntry(now);
1183            refreshTypedAnswer();
1184  
1185          } else {
1186            finishMemory(now);
1187          }
1188        }
1189  
1190        break;
1191  
1192      // ---------------- MEMORY RESULT ----------------
1193      case MEMORY_RESULT:
1194  
1195        if (key == '#') {
1196          openMemorySetup(now);
1197        }
1198  
1199        break;
1200    }
1201  }