情绪共振纸雕灯——基于人在传感器的情感化交互照明装置 简单

/*
 * 归途 HomeMood FINAL v2
 *
 * 帧协议: 0x43 0x42 距离
 * 快速靠近 → 彩虹灯 + 蜂鸣器(持续)
 * 缓慢靠近 → 暖白常亮 + 静音(持续)
 * 5秒无移动 → 3秒渐灭
 *
 * v2: TH_FAST=8, MOOD_MS=3s
 */

#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#define PIN_RX    2
#define PIN_TX    3
#define PIN_LED   5
#define PIN_BUZZ  9

#define NUM_LEDS    45
#define COMPUTE_MS  500
#define AVG_COUNT   3
#define TH_MOVE     5
#define TH_FAST     8
#define GONE_MS     5000
#define MOOD_MS     3000
#define FADE_MS     3000

#define F_H1  0x43
#define F_H2  0x42

enum Mode { MODE_OFF, MODE_FADING, MODE_SAD, MODE_HAPPY };

static const uint8_t sineTab[64] PROGMEM = {
  128,140,153,165,177,188,199,209,
  218,226,234,240,245,250,253,254,
  255,254,253,250,245,240,234,226,
  218,209,199,188,177,165,153,140,
  128,116,103,91,79,68,57,47,
  38,30,22,16,11,6,3,2,
  1,2,3,6,11,16,22,30,
  38,47,57,68,79,91,103,116
};

SoftwareSerial radar(PIN_RX, PIN_TX);

uint8_t ledBuf[NUM_LEDS * 3];
uint8_t gBrCur = 0, gBrTgt = 0;
Mode gMode = MODE_OFF;
unsigned long gModeTime = 0;
uint8_t gFadeStartBr = 0;

uint16_t gDist = 0;
uint32_t accSum = 0;
uint16_t accCnt = 0;
int16_t prevAvgDist = -1;
int16_t spdBuf[AVG_COUNT];
uint8_t spdIdx = 0, spdCnt = 0;
int16_t rawSpeed = 0, smoothSpeed = 0;

bool personHere = false, wasHere = false;
bool moodDecided = false;
Mode moodLocked = MODE_SAD;
int16_t peakSpd = 0;
unsigned long arrivalTime = 0;
unsigned long lastMoveTime = 0;

unsigned long gLastCompute = 0, gLastLed = 0, gLastPrint = 0;
unsigned long bzNext = 0;
uint8_t bzIdx = 0;
uint8_t pState = 0;
uint16_t frmCnt = 0;

const uint16_t mFreq[] = {523, 587, 659, 698, 784, 880, 988, 1047};
const uint8_t mLen = 8;

// ==================== WS2812 ====================
void wsInit() {
  DDRD |= _BV(PD5);
  PORTD &= ~_BV(PD5);
  memset(ledBuf, 0, sizeof(ledBuf));
}

void setLed(uint8_t i, uint8_t r, uint8_t g, uint8_t b) {
  uint16_t idx = (uint16_t)i * 3;
  ledBuf[idx] = g;
  ledBuf[idx + 1] = r;
  ledBuf[idx + 2] = b;
}

void fillAll(uint8_t r, uint8_t g, uint8_t b) {
  for (uint8_t i = 0; i < NUM_LEDS; i++) setLed(i, r, g, b);
}

__attribute__((optimize("O2")))
void wsSendByte(uint8_t b) {
  uint8_t hi = PORTD | _BV(PD5);
  uint8_t lo = PORTD & ~_BV(PD5);
  #define WSBIT(m) do { \
    PORTD = hi; \
    __asm__ volatile("nop\n"::); \
    if (b & (m)) { \
      __asm__ volatile("nop\nnop\nnop\nnop\nnop\nnop\nnop\n"::); \
    } \
    PORTD = lo; \
    __asm__ volatile("nop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\nnop\n"::); \
  } while(0)
  WSBIT(0x80); WSBIT(0x40); WSBIT(0x20); WSBIT(0x10);
  WSBIT(0x08); WSBIT(0x04); WSBIT(0x02); WSBIT(0x01);
  #undef WSBIT
}

void wsShow() {
  if (gBrCur < gBrTgt) {
    uint8_t d = gBrTgt - gBrCur;
    gBrCur += (d > 4) ? 4 : d;
  } else if (gBrCur > gBrTgt) {
    uint8_t d = gBrCur - gBrTgt;
    gBrCur -= (d > 4) ? 4 : d;
  }
  uint8_t oldSREG = SREG;
  cli();
  uint8_t *p = ledBuf;
  uint16_t n = NUM_LEDS * 3;
  uint8_t br = gBrCur;
  if (br >= 255) {
    while (n--) wsSendByte(*p++);
  } else if (br == 0) {
    while (n--) { wsSendByte(0); p++; }
  } else {
    while (n--) {
      wsSendByte((uint8_t)(((uint16_t)*p * br) >> 8));
      p++;
    }
  }
  SREG = oldSREG;
  _delay_us(60);
}

// ==================== 工具 ====================
uint8_t sin8(uint8_t x) {
  return pgm_read_byte(&sineTab[x >> 2]);
}

void hsvToRgb(uint8_t h, uint8_t *r, uint8_t *g, uint8_t *b) {
  uint8_t region = h / 43;
  uint8_t rem = (h - (region * 43)) * 6;
  uint8_t q = 255 - (uint8_t)(((uint16_t)255 * rem) >> 8);
  uint8_t t = (uint8_t)(((uint16_t)255 * rem) >> 8);
  switch (region) {
    case 0:  *r = 255; *g = t;   *b = 0;   break;
    case 1:  *r = q;   *g = 255; *b = 0;   break;
    case 2:  *r = 0;   *g = 255; *b = t;   break;
    case 3:  *r = 0;   *g = q;   *b = 255; break;
    case 4:  *r = t;   *g = 0;   *b = 255; break;
    default: *r = 255; *g = 0;   *b = q;   break;
  }
}

// ==================== 状态切换 ====================
void setMode(Mode m, unsigned long now) {
  if (m == gMode) return;
  if (m == MODE_OFF && gMode == MODE_FADING) return;
  if (m == MODE_FADING && gMode == MODE_OFF) return;
  if (m == MODE_FADING) gFadeStartBr = gBrCur;
  gMode = m;
  gModeTime = now;
  Serial.print(F(">> MODE -> "));
  switch (m) {
    case MODE_OFF:    Serial.println(F("OFF"));     break;
    case MODE_FADING: Serial.println(F("FADING"));  break;
    case MODE_SAD:    Serial.println(F("SAD/warm")); break;
    case MODE_HAPPY:  Serial.println(F("HAPPY/rainbow")); break;
  }
}

// ==================== 传感器 ====================
void pollSensor() {
  while (radar.available()) {
    uint8_t b = radar.read();
    switch (pState) {
      case 0:
        if (b == F_H1) pState = 1;
        break;
      case 1:
        if (b == F_H2) pState = 2;
        else if (b == F_H1) pState = 1;
        else pState = 0;
        break;
      case 2:
        gDist = b;
        accSum += b;
        accCnt++;
        frmCnt++;
        pState = 0;
        break;
    }
  }
}

// ==================== 速度 ====================
void computeSpeed() {
  if (accCnt < 1) return;
  uint16_t avgDist = (uint16_t)(accSum / accCnt);
  accSum = 0;
  accCnt = 0;

  rawSpeed = 0;
  if (prevAvgDist > 0) {
    rawSpeed = ((int16_t)prevAvgDist - (int16_t)avgDist)
               * (int16_t)(1000L / COMPUTE_MS);
  }
  prevAvgDist = (int16_t)avgDist;
  if (rawSpeed > 250) rawSpeed = 250;
  if (rawSpeed < -250) rawSpeed = -250;

  spdBuf[spdIdx] = rawSpeed;
  spdIdx = (spdIdx + 1) % AVG_COUNT;
  if (spdCnt < AVG_COUNT) spdCnt++;

  int32_t s = 0;
  for (uint8_t i = 0; i < spdCnt; i++) s += spdBuf[i];
  smoothSpeed = (int16_t)(s / spdCnt);
}

// ==================== LED ====================
void tickLED(unsigned long now) {
  unsigned long elapsed = now - gModeTime;
  switch (gMode) {
    case MODE_OFF:
      gBrTgt = 0;
      memset(ledBuf, 0, sizeof(ledBuf));
      break;
    case MODE_FADING:
      if (elapsed >= (unsigned long)FADE_MS) {
        gMode = MODE_OFF;
        gBrTgt = 0;
        memset(ledBuf, 0, sizeof(ledBuf));
      } else {
        gBrTgt = (uint8_t)((uint32_t)gFadeStartBr
                           * ((unsigned long)FADE_MS - elapsed)
                           / (unsigned long)FADE_MS);
      }
      break;
    case MODE_SAD:
      fillAll(255, 200, 140);
      gBrTgt = 153;
      break;
    case MODE_HAPPY: {
      uint8_t timeBase = (uint8_t)(now * 80UL / 1000UL);
      for (uint8_t i = 0; i < NUM_LEDS; i++) {
        uint8_t hue = (uint8_t)((uint16_t)i * 256UL / NUM_LEDS) + timeBase;
        uint8_t r, g, b;
        hsvToRgb(hue, &r, &g, &b);
        setLed(i, r, g, b);
      }
      uint8_t sv = sin8((uint8_t)(now * 256UL / 2000UL));
      gBrTgt = 180 + (uint8_t)((uint16_t)sv * 75UL / 255UL);
      break;
    }
  }
  wsShow();
}

// ==================== 蜂鸣器 ====================
void tickBuzz(unsigned long now) {
  if (gMode != MODE_HAPPY) {
    if (bzIdx > 0 || bzNext > 0) {
      noTone(PIN_BUZZ);
      bzIdx = 0; bzNext = 0;
    }
    return;
  }
  if (bzNext == 0) { bzNext = now; bzIdx = 0; }
  if (now >= bzNext) {
    tone(PIN_BUZZ, mFreq[bzIdx], 120);
    bzNext = now + 180;
    bzIdx = (bzIdx + 1) % mLen;
  }
}

// ==================== 串口 ====================
void printDebug() {
  Serial.print(F("frm="));
  Serial.print(frmCnt);
  Serial.print(F(" D="));
  if (gDist < 100) Serial.print(' ');
  if (gDist < 10)  Serial.print(' ');
  Serial.print(gDist);
  Serial.print(F(" avg="));
  if (smoothSpeed >= 0) Serial.print('+');
  if (abs(smoothSpeed) < 100) Serial.print(' ');
  if (abs(smoothSpeed) < 10)  Serial.print(' ');
  Serial.print(smoothSpeed);
  Serial.print(F(" pk="));
  Serial.print(peakSpd);
  unsigned long noMove = (millis() - lastMoveTime) / 1000UL;
  Serial.print(F(" noMv="));
  Serial.print(noMove);
  Serial.print(F("s"));
  Serial.print(F(" P="));
  Serial.print(personHere ? F("Y") : F("N"));
  Serial.print(F(" M="));
  if (moodDecided) {
    Serial.print(moodLocked == MODE_HAPPY ? F("HAP") : F("SAD"));
  } else {
    Serial.print(F("---"));
  }
  Serial.print(F(" ["));
  switch (gMode) {
    case MODE_OFF:    Serial.print(F("OFF"));   break;
    case MODE_FADING: Serial.print(F("FADE"));  break;
    case MODE_SAD:    Serial.print(F("WARM"));  break;
    case MODE_HAPPY:  Serial.print(F("RAIN"));  break;
  }
  Serial.print(F("] Br="));
  Serial.println(gBrCur);
}

// ==================== SETUP ====================
void setup() {
  Serial.begin(115200);
  radar.begin(9600);
  wsInit();
  pinMode(PIN_BUZZ, OUTPUT);
  noTone(PIN_BUZZ);
  gModeTime = millis();
  lastMoveTime = millis();
  Serial.println(F(""));
  Serial.println(F("============================="));
  Serial.println(F("  HomeMood FINAL v2"));
  Serial.println(F("  0x43 0x42 DIST"));
  Serial.println(F("  MOVE=5 FAST=8 GONE=5s"));
  Serial.println(F("  MOOD=3s"));
  Serial.println(F("============================="));
  Serial.println(F(""));
}

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

  pollSensor();

  if (now - gLastCompute >= COMPUTE_MS) {
    gLastCompute = now;
    computeSpeed();

    wasHere = personHere;

    if (personHere) {
      if (abs(smoothSpeed) >= TH_MOVE) {
        lastMoveTime = now;
      }
      if ((now - lastMoveTime) > (unsigned long)GONE_MS) {
        personHere = false;
      }
    }

    if (!personHere) {
      if (abs(smoothSpeed) >= TH_MOVE) {
        personHere = true;
        lastMoveTime = now;
      }
    }

    if (personHere && !wasHere) {
      Serial.println(F(""));
      Serial.println(F(">> Person ARRIVED!"));
      moodDecided = false;
      peakSpd = 0;
      arrivalTime = now;
    }

    if (!personHere && wasHere) {
      Serial.println(F(""));
      Serial.println(F(">> Person LEFT!"));
      moodDecided = false;
      if (gMode == MODE_HAPPY || gMode == MODE_SAD) {
        setMode(MODE_FADING, now);
      }
    }

    if (personHere && !moodDecided) {
      int16_t absSpd = abs(smoothSpeed);
      if (absSpd > peakSpd) peakSpd = absSpd;

      if ((now - arrivalTime) > (unsigned long)MOOD_MS) {
        if (peakSpd > TH_FAST) {
          moodLocked = MODE_HAPPY;
          moodDecided = true;
          setMode(MODE_HAPPY, now);
          Serial.print(F(">> HAPPY (pk="));
          Serial.print(peakSpd);
          Serial.println(F(")"));
        } else {
          moodLocked = MODE_SAD;
          moodDecided = true;
          setMode(MODE_SAD, now);
          Serial.print(F(">> SAD (pk="));
          Serial.print(peakSpd);
          Serial.println(F(")"));
        }
      }
    }
  }

  if (now - gLastLed >= 20) {
    gLastLed = now;
    tickLED(now);
  }

  tickBuzz(now);

  if (now - gLastPrint >= 500) {
    gLastPrint = now;
    printDebug();
  }
}