HC-SR501 人体红外移动检测传感器 STM32F103 接线与代码

/*
 * ============================================================================
 * 12_HC-SR501 | STM32F103C8T6 BluePill + HC-SR501 人体红外 + 0.96" OLED(SSD1306)
 * ----------------------------------------------------------------------------
 * 重要概念:
 *   HC-SR501 是被动式红外(PIR)"人体移动"检测模块, 只对"移动的人体红外
 *   辐射"有响应, 不是"静止人体存在"检测。有人静坐不动时模块同样输出 LOW,
 *   这是模块正常特性。因此全程序统一使用:
 *     RAW=0 -> NO MOTION (未检测到移动)
 *     RAW=1 -> MOTION    (检测到移动)
 *   不引入"有人/无人""静止有人"等 HC-SR501 无法可靠判断的状态。
 *
 * 功能:
 *   1. PA0 读取 HC-SR501 OUT, 板载 LED(PC13, 低电平点亮) 跟随状态
 *   2. 仅在 LOW->HIGH 上升沿触发计数 COUNT+1
 *      (持续移动输出保持 HIGH 期间只计 1 次, 必须回落 LOW 后再次 HIGH 才 +1)
 *   3. 输入经 40ms 稳定确认, 毛刺不计数、不乱跳
 *   4. OLED: 开机页 -> 预热倒计时页 -> 运行页(大字 MOTION! + 小人动画)
 *   5. 串口 115200, 每 400ms 输出一次状态
 *   6. 全部使用 millis() 非阻塞时序, 无长 delay()
 *
 * 接线:
 *   HC-SR501 -> BluePill:  VCC->5V   GND->GND   OUT->PA0
 *   OLED     -> BluePill:  VCC->3.3V GND->GND   SCL->PB8  SDA->PB9 (I2C 0x3C)
 *
 * 注意: 不同批次 HC-SR501 引脚排列可能不同, 实际接线以模块丝印为准!
 * ============================================================================
 */

#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <math.h>

#define FIRMWARE_VERSION "v1.0"

/* ------------------------- 引脚常量 ------------------------- */
constexpr uint8_t PIR_PIN      = PA0;   // HC-SR501 OUT, 数字输入
constexpr uint8_t LED_PIN      = PC13;  // 板载 LED, 低电平点亮
constexpr uint8_t I2C_SDA_PIN  = PB9;   // OLED SDA
constexpr uint8_t I2C_SCL_PIN  = PB8;   // OLED SCL
constexpr uint8_t OLED_ADDRESS = 0x3C;  // SSD1306 I2C 地址

/* ------------------------- OLED ------------------------- */
constexpr int SCREEN_WIDTH  = 128;
constexpr int SCREEN_HEIGHT = 64;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

/* ------------------------- 时序参数 (ms) ------------------------- */
constexpr uint32_t BOOT_SCREEN_MS  = 1500UL;   // 开机画面停留时长
constexpr uint32_t PIR_WARMUP_MS   = 30000UL;  // PIR 预热时间(录制演示可改 10000UL)
constexpr uint32_t INPUT_STABLE_MS = 40UL;     // 输入稳定确认时间(30~50ms)
constexpr uint32_t SERIAL_INTERVAL = 400UL;    // 串口输出周期(200~500ms)
constexpr uint32_t ANIM_TICK_MS    = 200UL;    // 动画帧间隔
constexpr uint32_t LED_BLINK_MS    = 500UL;    // 预热阶段 LED 闪烁周期

/* ------------------------- 状态变量 ------------------------- */
enum class Phase : uint8_t { BOOT, WARMUP, RUN };

Phase    phase         = Phase::BOOT;
uint32_t phaseStartMs  = 0;

uint8_t  lastSample    = LOW;    // 最近一次采样到的电平
uint8_t  confirmedRaw  = LOW;    // 连续稳定 INPUT_STABLE_MS 后确认的电平
uint32_t rawChangeMs   = 0;      // 采样电平发生变化的时刻
uint32_t motionCount   = 0;      // 移动触发次数(仅上升沿 +1)
bool     stateDirty    = false;  // 运行页需要刷新

uint8_t  lastCountdown = 255;    // 上次显示过的预热剩余秒数
bool     displayOk     = false;  // OLED 初始化是否成功
uint32_t lastSerialMs  = 0;
uint32_t lastDisplayMs = 0;
uint32_t lastLedMs     = 0;

/* ------------------------- OLED 绘制辅助 ------------------------- */

// 屏幕水平居中显示一行文字(默认 5x7 字体)
void drawCentered(const char* s, int16_t y, uint8_t size = 1) {
  display.setTextSize(size);
  int16_t x1, y1;
  uint16_t w, h;
  display.getTextBounds(s, 0, 0, &x1, &y1, &w, &h);
  display.setCursor((SCREEN_WIDTH - (int16_t)w) / 2, y);
  display.print(s);
}

// 小人图标: (cx, cy) 为头部圆心
void drawStickFigure(int16_t cx, int16_t cy) {
  display.drawCircle(cx, cy, 3, SSD1306_WHITE);                    // 头
  display.drawLine(cx, cy + 3, cx, cy + 11, SSD1306_WHITE);        // 身体
  display.drawLine(cx, cy + 6, cx - 5, cy + 3, SSD1306_WHITE);     // 左臂
  display.drawLine(cx, cy + 6, cx + 5, cy + 3, SSD1306_WHITE);     // 右臂
  display.drawLine(cx, cy + 11, cx - 4, cy + 19, SSD1306_WHITE);   // 左腿
  display.drawLine(cx, cy + 11, cx + 4, cy + 19, SSD1306_WHITE);   // 右腿
}

// 感应波纹: 以 (cx,cy) 为圆心、半径 r 画一圈点
void drawRipple(int16_t cx, int16_t cy, int16_t r) {
  for (int deg = 0; deg < 360; deg += 30) {
    float rad = deg * (3.14159265f / 180.0f);
    display.drawPixel((int16_t)(cx + r * cosf(rad)),
                      (int16_t)(cy + r * sinf(rad)), SSD1306_WHITE);
  }
}

/* ------------------------- OLED 页面 ------------------------- */

// 开机页
void drawBootPage() {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);
  drawCentered("HC-SR501 PIR", 16);
  drawCentered("Initializing...", 32);
  display.display();
}

// 预热倒计时页
void drawWarmupPage(uint8_t remainSec) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);
  drawCentered("PIR SENSOR", 0);
  drawCentered("WARMING UP", 16);
  drawCentered("Please wait...", 24);
  char buf[12];
  snprintf(buf, sizeof(buf), "%u s", (unsigned)remainSec);
  drawCentered(buf, 40);
  display.display();
}

// 运行页: motion=是否检测到移动, animPhase=动画相位(0~3)
void drawRunPage(bool motion, uint8_t animPhase) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);
  drawCentered("PIR SENSOR", 0);

  display.setTextSize(1);
  display.setCursor(0, 16);
  display.print("STATE:");

  if (!motion) {
    /* NO MOTION: 未检测到移动, 小人静止 */
    display.setCursor(0, 26);
    display.print("NO MOTION");
    drawStickFigure(96, 24);
  } else {
    /* MOTION: 检测到移动, 大字反白闪烁 + 波纹 + 小人左右轻摆 */
    if ((animPhase & 1U) == 0U) {
      display.fillRect(0, 26, 84, 16, SSD1306_WHITE);
      display.setTextColor(SSD1306_BLACK);
    } else {
      display.setTextColor(SSD1306_WHITE);
    }
    display.setTextSize(2);
    display.setCursor(0, 26);
    display.print("MOTION!");
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);

    drawRipple(96, 34, 8 + (animPhase % 4U));                    // 扩散波纹
    drawStickFigure(96 + ((animPhase & 1U) ? 1 : -1), 24);       // 轻微左右移动
  }

  char line[20];
  snprintf(line, sizeof(line), "RAW: %u", (unsigned)confirmedRaw);
  display.setCursor(0, 48);
  display.print(line);
  snprintf(line, sizeof(line), "COUNT: %lu", (unsigned long)motionCount);
  display.setCursor(0, 56);
  display.print(line);

  display.display();
}

/* ------------------------- 阶段切换 ------------------------- */

// 预热结束进入正常运行: 以当前实际电平作为基准, 避免预热残留电平误计数
void enterRun(uint32_t now) {
  phase        = Phase::RUN;
  phaseStartMs = now;
  lastSample   = digitalRead(PIR_PIN);
  confirmedRaw = lastSample;
  rawChangeMs  = now;
  motionCount  = 0;
  stateDirty   = true;
  lastSerialMs = now;
  digitalWrite(LED_PIN, (confirmedRaw == HIGH) ? LOW : HIGH);
  Serial.println("PIR | WARMUP DONE | RUNNING");
}

/* ------------------------- setup / loop ------------------------- */

void setup() {
  Serial.begin(115200);

  pinMode(PIR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);   // 开机 LED 灭(PC13 低电平点亮)

  Wire.setSDA(I2C_SDA_PIN);
  Wire.setSCL(I2C_SCL_PIN);
  Wire.begin();
  Wire.setClock(400000);

  Serial.println("HC-SR501 PIR TEST");
  Serial.print("Firmware: ");
  Serial.println(FIRMWARE_VERSION);
  Serial.println();

  // 先探测 I2C 地址, 给出明确错误信息(display.begin 的返回值不保证真实 ACK)
  Wire.beginTransmission(OLED_ADDRESS);
  if (Wire.endTransmission() != 0) {
    Serial.println("ERROR: OLED not found at 0x3C (check wiring/I2C)");
    displayOk = false;
    return;
  }

  displayOk = display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS, true, false);
  if (!displayOk) {
    Serial.println("ERROR: OLED init failed");
    return;   // loop() 中快速闪灯提示
  }

  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextWrap(false);

  phase        = Phase::BOOT;
  phaseStartMs = millis();
  drawBootPage();
}

void loop() {
  uint32_t now = millis();

  if (!displayOk) {
    // OLED 初始化失败: PC13 快速闪灯报警(非阻塞)
    if (now - lastLedMs >= 100) {
      lastLedMs = now;
      digitalWrite(LED_PIN, !digitalRead(LED_PIN));
    }
    return;
  }

  switch (phase) {

    case Phase::BOOT:
      if (now - phaseStartMs >= BOOT_SCREEN_MS) {
        phase         = Phase::WARMUP;
        phaseStartMs  = now;
        lastCountdown = 255;   // 强制立刻刷新倒计时
        lastLedMs     = 0;
      }
      break;

    case Phase::WARMUP: {
      uint32_t elapsed = now - phaseStartMs;
      if (elapsed >= PIR_WARMUP_MS) {
        enterRun(now);
        break;
      }

      // 预热期间不采样、不计数: 此时模块输出不可信

      uint8_t remain = (uint8_t)((PIR_WARMUP_MS - elapsed + 999) / 1000);
      if (remain != lastCountdown) {        // 剩余秒数变化才刷新 OLED
        lastCountdown = remain;
        drawWarmupPage(remain);
      }
      if (now - lastSerialMs >= 1000) {     // 串口每秒报一次预热进度
        lastSerialMs = now;
        Serial.print("PIR | WARMING UP | ");
        Serial.print(remain);
        Serial.println(" s");
      }
      if (now - lastLedMs >= LED_BLINK_MS) {  // 预热阶段 LED 慢闪
        lastLedMs = now;
        digitalWrite(LED_PIN, !digitalRead(LED_PIN));
      }
      break;
    }

    case Phase::RUN: {
      /* 1) 采样 + 稳定确认(去毛刺): 电平连续稳定 INPUT_STABLE_MS 才承认变化 */
      uint8_t sample = digitalRead(PIR_PIN);
      if (sample != lastSample) {
        lastSample  = sample;
        rawChangeMs = now;               // 出现变化, 重新计时
      }
      if (now - rawChangeMs >= INPUT_STABLE_MS) {
        if (confirmedRaw != lastSample) {  // 稳定变化被确认
          uint8_t prev = confirmedRaw;
          confirmedRaw = lastSample;
          if (prev == LOW && confirmedRaw == HIGH) {
            motionCount++;                 // 仅 LOW->HIGH 上升沿计数一次
          }
          stateDirty = true;
        }
      }

      /* 2) LED: 检测到移动->亮, 未检测到移动->灭 (PC13 低电平点亮) */
      digitalWrite(LED_PIN, (confirmedRaw == HIGH) ? LOW : HIGH);

      /* 3) 串口: 每 400ms 输出一次, 与 OLED 状态完全一致 */
      if (now - lastSerialMs >= SERIAL_INTERVAL) {
        lastSerialMs = now;
        Serial.print("PIR | RAW=");
        Serial.print(confirmedRaw);
        Serial.print(" | STATE=");
        Serial.print(confirmedRaw == HIGH ? "MOTION    " : "NO MOTION ");
        Serial.print("| COUNT=");
        Serial.println(motionCount);
      }

      /* 4) OLED: 状态变化立即刷新; MOTION 期间每 200ms 播一帧动画 */
      if (stateDirty ||
          (confirmedRaw == HIGH && now - lastDisplayMs >= ANIM_TICK_MS)) {
        stateDirty    = false;
        lastDisplayMs = now;
        drawRunPage(confirmedRaw == HIGH,
                    (uint8_t)((now / ANIM_TICK_MS) % 4U));
      }
      break;
    }
  }
}