// ESP32-C3 SuperMini 버전 (ai_pet_c6_ble에서 핀만 변경, 2026-11-10) // AI 펫 C6 - 5단계: BLE 앱 + 표정 꾸미기 + 동작 학습(k-NN) + 소리 + 터치 // // 스케치 폴더에 motion_learn.h 를 같이 두세요. // 필요 라이브러리 (라이브러리 매니저): // - Adafruit SSD1306 (GFX 함께 설치) // - NimBLE-Arduino (by h2zero, 2.x) // 보드: XIAO_ESP32C6, USB CDC On Boot: Enabled // 배선: 3V3/GND, D4(GPIO22)=SDA, D5(GPIO23)=SCL (MPU6050 + OLED 공유) // D6(GPIO16) = 수동 피에조 (다른 쪽은 GND) // TTP223 터치: D2(GPIO2)=머리, D3(GPIO21)=등, D7(GPIO17)=턱 (VCC 3V3, 기본 모드) #include #include #include #include #include #include #include "motion_learn.h" // ===== Arduino IDE 자동 프로토타입보다 앞에 둘 정의 ===== struct Imu { float ax, ay, az, gx, gy, gz; }; struct CmdItem { uint8_t len; uint8_t d[19]; }; struct Note { uint16_t f0, f1, ms; }; // f0→f1로 미끄러지는 음, f0=0이면 쉼 struct SoundDef { const Note *n; uint8_t len; }; struct TouchReact { uint8_t mood, snd; uint16_t ms; const char *name; }; #define DEBUG_MOTION 0 // 1이면 시리얼 플로터에 움직임 감지 값 출력 (확인 끝나면 0) #define PIN_SDA 8 // C3 SuperMini GPIO8 #define PIN_SCL 9 // C3 SuperMini GPIO9 #define PIN_BUZZ 21 // C3 SuperMini GPIO21 (KY-006 S) — 2026-11-11 GPIO10에서 변경 const uint8_t TOUCH_PINS[3] = {5, 6, 7}; // C3: GPIO5 머리, GPIO6 등, GPIO7 턱 enum { Z_HEAD, Z_BACK, Z_CHIN }; #define MPU_ADDR 0x68 // BLE UUID (앱과 동일해야 함) #define SVC_UUID "6e400000-a1b2-4c3d-9e8f-0123456789ab" #define SENSOR_UUID "6e400001-a1b2-4c3d-9e8f-0123456789ab" // notify 14B: int16 ax,ay,az(mg) gx,gy,gz(dps) + mood + 터치 비트 #define FACE_UUID "6e400002-a1b2-4c3d-9e8f-0123456789ab" // read 56B(7기분x8) / write [mood, cmd, p0..p7] #define NAME_UUID "6e400003-a1b2-4c3d-9e8f-0123456789ab" // read/write 이름(최대 16바이트) #define TRAIN_UUID "6e400004-a1b2-4c3d-9e8f-0123456789ab" // write 학습 명령 #define MODEL_UUID "6e400005-a1b2-4c3d-9e8f-0123456789ab" // read 97B: thr(u16) + 5 x [used, mood, nEx, name16] #define EVENT_UUID "6e400006-a1b2-4c3d-9e8f-0123456789ab" // notify: 학습 상태 / 인식 결과 / 모델 변경 #define SET_UUID "6e400007-a1b2-4c3d-9e8f-0123456789ab" // read [ver, vol] / write [1, vol] 크기, [2, id] 들어보기 // 학습 명령 (TRAIN write) #define CMD_RECORD 0x01 // [slot] 예시 녹화 시작 #define CMD_DEL_LABEL 0x02 // [slot] 동작 삭제 #define CMD_DEL_EX 0x03 // [slot, idx] 예시 하나 삭제 #define CMD_CLEAR 0x04 // 전부 지우기 #define CMD_SET_MOOD 0x05 // [slot, mood] 반응 표정 #define CMD_SET_NAME 0x06 // [slot, name…] 이름 (없던 동작이면 새로 만듦) #define CMD_SET_THR 0x07 // [lo, hi] 모르겠어 기준 x100 #define CMD_CANCEL 0x08 // 녹화 취소 // 이벤트 (EVENT notify) #define EV_TRAIN 1 // [1, state, slot, nEx] #define EV_RESULT 2 // [2, label(255=모름), best x100 lo, hi, d0..d4 (x25, 최대 255)] #define EV_MODEL 3 // [3] 모델 바뀜 → 앱이 MODEL 다시 읽음 #define EV_TOUCH 4 // [4, 터치 동작 번호] // 학습 상태 enum { T_IDLE = 0, T_ARMED = 1, T_WAIT = 2, T_REC = 3, T_SAVED = 4, T_CANCEL = 5 }; // 기분: 0 기본, 1 행복, 2 놀람, 3 배고픔, 4 졸림, 5 모르겠어, 6 싫어, 7 집중(앱 표시용) #define MOOD_COUNT 7 enum { MOOD_BASIC, MOOD_HAPPY, MOOD_SURPRISE, MOOD_HUNGRY, MOOD_SLEEPY, MOOD_UNKNOWN, MOOD_ANGRY, MOOD_LEARNING }; // 표정 파라미터 8개 (0~255): // 0 눈 너비, 1 눈 높이, 2 둥글기, 3 눈 간격, 4 위 눈꺼풀 기울기(128=수평, 작으면 슬픔, 크면 화남), // 5 아래 눈꺼풀(반달 웃음), 6 눈 감김, 7 깜빡임 빈도(0=안 깜빡임) const uint8_t DEFAULT_FACES[MOOD_COUNT][8] = { {102, 166, 157, 110, 128, 0, 0, 140}, // 기본 {115, 150, 200, 110, 128, 170, 0, 120}, // 행복 (반달 웃음) {130, 210, 255, 115, 128, 0, 0, 60}, // 놀람 {100, 160, 160, 115, 40, 0, 30, 100}, // 배고픔 (슬픈 눈) {110, 140, 120, 110, 128, 0, 170, 40}, // 졸림 {110, 120, 255, 90, 128, 0, 40, 80}, // 모르겠어 {110, 160, 120, 100, 215, 0, 0, 120}, // 싫어 (화난 눈) }; const uint8_t READY_FACE[8] = {120, 190, 255, 105, 128, 0, 0, 0}; // 배우는 중: 동그랗게 집중 Adafruit_SSD1306 oled(128, 64, &Wire, -1); Preferences prefs; uint8_t faces[MOOD_COUNT][8]; uint8_t previewFace[8]; volatile int previewMood = -1; volatile uint32_t previewUntil = 0; volatile bool pendingFaceSave = false, pendingNameSave = false; volatile bool bleConnected = false; char petName[17] = ""; char bleName[16]; uint8_t currentMood = MOOD_BASIC; NimBLECharacteristic *chSensor, *chFace, *chName, *chTrain, *chModel, *chEvent, *chSet; QueueHandle_t cmdQueue; uint8_t oledAddr = 0; bool mpuOk = false; uint8_t touchMask = 0; // 지금 눌린 터치 (비트0 머리, 비트1 등, 비트2 턱) // ===== 동작 학습 상태 ===== MLModel model; float mlSd[ML_FEAT]; float ring[ML_PRE][ML_AXES]; int ringPos = 0; float capWin[ML_WIN][ML_AXES]; int capN = 0, capStill = 0; bool capturing = false; int trainState = T_IDLE, trainSlot = 0; uint32_t stateT = 0, stillSince = 0, cooldownUntil = 0; const uint8_t *flashFace = nullptr; // 잠깐 보여줄 반응 표정 uint8_t flashMood = 0; uint32_t flashUntil = 0; bool modelDirty = false; // ================= MPU6050 ================= void mpuWrite(uint8_t reg, uint8_t val) { Wire.beginTransmission(MPU_ADDR); Wire.write(reg); Wire.write(val); Wire.endTransmission(); } bool mpuInit() { Wire.beginTransmission(MPU_ADDR); if (Wire.endTransmission() != 0) return false; // 칩 확인 (정품 0x68, 호환 칩은 0x70·0x71·0x98 등) Wire.beginTransmission(MPU_ADDR); Wire.write(0x75); Wire.endTransmission(false); if (Wire.requestFrom(MPU_ADDR, 1) == 1) Serial.printf("IMU WHO_AM_I = 0x%02X\n", Wire.read()); mpuWrite(0x6B, 0x00); // 슬립 해제 delay(50); mpuWrite(0x1A, 0x03); // DLPF 약 44Hz mpuWrite(0x1B, 0x08); // 자이로 ±500 dps mpuWrite(0x1C, 0x08); // 가속도 ±4g return true; } float gBias[3] = {0, 0, 0}; // 자이로 바이어스 (dps), 켤 때 측정 float aBase[3] = {0, 0, 1}; // 켤 때의 중력 방향 (g) = 기본 자세 float gLp[3] = {0, 0, 1}; // 천천히 따라가는 중력 방향 (움직임 계산용) bool gInit = false; volatile bool pendingCalib = false; // 앱에서 "자세 다시 맞추기" bool mpuRead(Imu &d) { Wire.beginTransmission(MPU_ADDR); Wire.write(0x3B); if (Wire.endTransmission(false) != 0) return false; if (Wire.requestFrom(MPU_ADDR, 14) != 14) return false; int16_t r[7]; for (int i = 0; i < 7; i++) r[i] = (Wire.read() << 8) | Wire.read(); d.ax = r[0] / 8192.0f; d.ay = r[1] / 8192.0f; d.az = r[2] / 8192.0f; d.gx = r[4] / 65.5f - gBias[0]; d.gy = r[5] / 65.5f - gBias[1]; d.gz = r[6] / 65.5f - gBias[2]; return true; } // ================= 자세 초기화 (켤 때의 자세를 기준으로) ================= // 1초 동안 가만히 있는 값을 모아서 // - 자이로: 가만히 있어도 나오는 틀어짐(바이어스)을 0으로 맞춤 → 움직임·정지 판정이 정확해짐 // - 가속도: 그때의 중력 방향을 "똑바로 선 자세"로 저장 → 어떻게 세워 넣어도 눈동자가 가운데 // 움직이는 중이었으면 다시 시도, 끝내 실패하면 이전 값을 그대로 씀. bool calibrateImu(int tries) { if (!mpuOk) return false; for (int t = 0; t < tries; t++) { float gs[3] = {0, 0, 0}, as[3] = {0, 0, 0}; float gmn[3] = {1e9, 1e9, 1e9}, gmx[3] = {-1e9, -1e9, -1e9}; float amn[3] = {1e9, 1e9, 1e9}, amx[3] = {-1e9, -1e9, -1e9}; const int N = 100; for (int i = 0; i < N; i++) { Imu d; mpuRead(d); float g[3] = {d.gx, d.gy, d.gz}, a[3] = {d.ax, d.ay, d.az}; for (int k = 0; k < 3; k++) { gs[k] += g[k]; as[k] += a[k]; gmn[k] = min(gmn[k], g[k]); gmx[k] = max(gmx[k], g[k]); amn[k] = min(amn[k], a[k]); amx[k] = max(amx[k], a[k]); } delay(10); } bool still = true; for (int k = 0; k < 3; k++) if (gmx[k] - gmn[k] > 12.0f || amx[k] - amn[k] > 0.08f) still = false; if (still) { for (int k = 0; k < 3; k++) { gBias[k] += gs[k] / N; // mpuRead가 이미 빼고 있던 값에 더해서 갱신 aBase[k] = as[k] / N; gLp[k] = aBase[k]; } gInit = true; Serial.printf("자세 초기화 완료: 자이로 바이어스 %.1f %.1f %.1f dps, 기준 중력 %.2f %.2f %.2f g\n", gBias[0], gBias[1], gBias[2], aBase[0], aBase[1], aBase[2]); return true; } Serial.printf("자세 초기화: 움직임 감지, 다시 시도 (%d/%d)\n", t + 1, tries); if (oledAddr) { oled.clearDisplay(); oled.setTextSize(1); oled.setCursor(10, 28); oled.print("Keep still..."); oled.display(); } } Serial.println("자세 초기화 실패: 이전 값 사용"); return false; } // ================= 표정 그리기 ================= // 앱(app.html)의 drawFace()와 같은 계산식. 바꿀 때는 양쪽을 같이 바꿀 것. void drawFace(const uint8_t *p, int gx, int gy, bool blink) { int w = 10 + p[0] * 40 / 255; int h = 4 + p[1] * 40 / 255; int r = (min(w, h) / 2) * p[2] / 255; int gap = 30 + p[3] * 60 / 255; int close = p[6] * (h - 2) / 255; int cy = 28 + gy; for (int i = 0; i < 2; i++) { int side = (i == 0) ? -1 : 1; // -1 왼쪽 눈, +1 오른쪽 눈 int cx = 64 + side * gap / 2 + gx; int left = cx - w / 2; if (blink) { oled.fillRoundRect(left, cy - 1, w, 3, 1, SSD1306_WHITE); continue; } int eh = h - close; int top = cy - h / 2 + close; oled.fillRoundRect(left, top, w, eh, r, SSD1306_WHITE); // 위 눈꺼풀: 화남(>128)은 안쪽이 내려감, 슬픔(<128)은 바깥쪽이 내려감 int t = p[4] - 128; if (t != 0) { int d = abs(t) * eh * 6 / 1280; bool innerIsRight = (side == -1); bool lowRight = (t > 0) ? innerIsRight : !innerIsRight; int x0 = left - 1, x1 = left + w, y0 = top - 1; if (lowRight) oled.fillTriangle(x0, y0, x1, y0, x1, y0 + d, SSD1306_BLACK); else oled.fillTriangle(x0, y0, x1, y0, x0, y0 + d, SSD1306_BLACK); } // 아래 눈꺼풀(반달 웃음): 아래에서 원으로 파냄 int s = p[5] * eh * 6 / 2550; if (s > 0) { int R = w * 3 / 4; oled.fillCircle(cx, top + eh + R - s, R, SSD1306_BLACK); } } } // ================= 소리 ================= // 피에조 공진(약 3kHz) 근처 음 위주. 별도 태스크에서 재생해서 화면·센서가 멈추지 않음. enum { SND_BASIC, SND_HAPPY, SND_SURPRISE, SND_HUNGRY, SND_SLEEPY, SND_UNKNOWN, SND_ANGRY, // 0~6 = 기분 번호와 같음 SND_BOOT, SND_READY, SND_SAVED, SND_CANCEL, SND_TICK, SND_CONNECT, SND_DISCONNECT, SND_WAKE, SND_GIGGLE, SND_PURR, SND_LOVE, SND_COUNT }; const Note SN_BASIC[] = {{2800, 3300, 90}}; const Note SN_HAPPY[] = {{2600, 2600, 70}, {0, 0, 20}, {3000, 3000, 70}, {0, 0, 20}, {3400, 3400, 140}}; const Note SN_SURPRISE[] = {{2000, 4000, 140}, {3800, 3800, 70}}; const Note SN_HUNGRY[] = {{2400, 2400, 180}, {0, 0, 60}, {2200, 1900, 320}}; const Note SN_SLEEPY[] = {{3200, 1800, 450}, {0, 0, 150}, {2000, 1600, 350}}; const Note SN_UNKNOWN[] = {{2400, 2400, 110}, {0, 0, 50}, {2400, 3300, 240}}; const Note SN_BOOT[] = {{2400, 2400, 90}, {2800, 2800, 90}, {3200, 3200, 90}, {3600, 3600, 180}}; const Note SN_READY[] = {{3000, 3000, 60}, {0, 0, 70}, {3000, 3000, 60}}; const Note SN_SAVED[] = {{2600, 2600, 70}, {3200, 3200, 70}, {3900, 3900, 160}}; const Note SN_CANCEL[] = {{2300, 2300, 350}}; const Note SN_TICK[] = {{3000, 3000, 40}}; const Note SN_CONNECT[] = {{2800, 2800, 60}, {3400, 3400, 90}}; const Note SN_DISCON[] = {{3400, 3400, 60}, {2800, 2800, 90}}; const Note SN_WAKE[] = {{2400, 3200, 120}, {3000, 3000, 60}}; const Note SN_ANGRY[] = {{1600, 1600, 90}, {0, 0, 30}, {1500, 1500, 90}, {0, 0, 30}, {1700, 1400, 220}}; const Note SN_GIGGLE[] = {{3000, 3000, 50}, {0, 0, 30}, {3400, 3400, 50}, {0, 0, 30}, {3000, 3000, 50}, {0, 0, 30}, {3600, 3600, 70}}; const Note SN_PURR[] = {{2200, 2400, 120}, {0, 0, 60}, {2200, 2400, 120}, {0, 0, 60}, {2200, 2400, 120}}; const Note SN_LOVE[] = {{2600, 2600, 80}, {3000, 3000, 80}, {3400, 3400, 80}, {0, 0, 40}, {3000, 3000, 60}, {3600, 3600, 200}}; #define SD(a) {a, (uint8_t)(sizeof(a) / sizeof(a[0]))} const SoundDef SOUNDS[SND_COUNT] = { SD(SN_BASIC), SD(SN_HAPPY), SD(SN_SURPRISE), SD(SN_HUNGRY), SD(SN_SLEEPY), SD(SN_UNKNOWN), SD(SN_ANGRY), SD(SN_BOOT), SD(SN_READY), SD(SN_SAVED), SD(SN_CANCEL), SD(SN_TICK), SD(SN_CONNECT), SD(SN_DISCON), SD(SN_WAKE), SD(SN_GIGGLE), SD(SN_PURR), SD(SN_LOVE), }; // 크기 0 끔, 1 작게, 2 보통, 3 크게 (PWM 듀티, 8비트) const uint8_t VOL_DUTY[4] = {0, 8, 32, 128}; volatile uint8_t soundVol = 2; volatile bool pendingVolSave = false; QueueHandle_t sndQueue = nullptr; // 어디서 불러도 됨 (BLE 콜백 포함). 새 소리가 재생 중인 소리를 끊고 들어감. void playSound(uint8_t id) { if (soundVol == 0 || !sndQueue || id >= SND_COUNT) return; xQueueOverwrite(sndQueue, &id); } void soundTask(void *arg) { ledcAttach(PIN_BUZZ, 3000, 8); ledcWrite(PIN_BUZZ, 0); const Note *seq = nullptr; uint8_t len = 0, idx = 0; uint32_t t0 = 0; int lastF = 0; for (;;) { uint8_t id; // 재생 중이 아니면 다음 소리 요청이 올 때까지 잠듦 if (xQueueReceive(sndQueue, &id, seq ? 0 : portMAX_DELAY) == pdTRUE && id < SND_COUNT) { seq = SOUNDS[id].n; len = SOUNDS[id].len; idx = 0; t0 = millis(); lastF = -1; } if (seq) { uint32_t now = millis(); while (idx < len && now - t0 >= seq[idx].ms) { t0 += seq[idx].ms; idx++; } if (idx >= len || soundVol == 0) { ledcWrite(PIN_BUZZ, 0); seq = nullptr; } else { const Note &n = seq[idx]; int f = 0; if (n.f0) f = n.f0 + ((int)n.f1 - (int)n.f0) * (int)(now - t0) / (int)n.ms; f = f / 20 * 20; // 20Hz 단위로만 바꿔서 불필요한 재설정 줄임 if (f != lastF) { if (f <= 0) ledcWrite(PIN_BUZZ, 0); else { ledcChangeFrequency(PIN_BUZZ, f, 8); ledcWrite(PIN_BUZZ, VOL_DUTY[soundVol]); } lastF = f; } } } vTaskDelay(pdMS_TO_TICKS(2)); } } // ================= BLE ================= void refreshFaceValue() { chFace->setValue((uint8_t *)faces, sizeof(faces)); } void refreshModelValue() { uint8_t buf[2 + ML_LABELS * 19]; buf[0] = model.thrX100 & 0xFF; buf[1] = model.thrX100 >> 8; for (int i = 0; i < ML_LABELS; i++) { uint8_t *q = buf + 2 + i * 19; q[0] = model.used[i]; q[1] = model.mood[i]; q[2] = model.used[i] ? model.nEx[i] : 0; memcpy(q + 3, model.name[i], 16); } chModel->setValue(buf, sizeof(buf)); } void refreshSetValue() { uint8_t b[2] = {1, soundVol}; chSet->setValue(b, sizeof(b)); } void sendEvent(const uint8_t *b, size_t n) { if (!bleConnected) return; chEvent->setValue(b, n); chEvent->notify(); } void sendTrainEvent(int state) { uint8_t b[4] = {EV_TRAIN, (uint8_t)state, (uint8_t)trainSlot, model.nEx[trainSlot]}; sendEvent(b, sizeof(b)); } class ServerCB : public NimBLEServerCallbacks { void onConnect(NimBLEServer *s, NimBLEConnInfo &info) override { bleConnected = true; playSound(SND_CONNECT); Serial.println("BLE 연결됨"); } void onDisconnect(NimBLEServer *s, NimBLEConnInfo &info, int reason) override { bleConnected = false; previewMood = -1; playSound(SND_DISCONNECT); Serial.println("BLE 연결 끊김"); NimBLEDevice::startAdvertising(); } }; class FaceCB : public NimBLECharacteristicCallbacks { void onWrite(NimBLECharacteristic *c, NimBLEConnInfo &info) override { NimBLEAttValue v = c->getValue(); const uint8_t *d = v.data(); size_t n = v.length(); if (n >= 2 && d[0] < MOOD_COUNT) { uint8_t mood = d[0], cmd = d[1]; if (cmd == 0 && n >= 10) { // 미리보기 (저장 안 함) memcpy(previewFace, d + 2, 8); previewMood = mood; previewUntil = millis() + 5000; } else if (cmd == 1 && n >= 10) { // 저장 memcpy(faces[mood], d + 2, 8); memcpy(previewFace, d + 2, 8); previewMood = mood; previewUntil = millis() + 2000; pendingFaceSave = true; } else if (cmd == 2) { // 이 기분만 기본값으로 memcpy(faces[mood], DEFAULT_FACES[mood], 8); pendingFaceSave = true; } } refreshFaceValue(); // 읽기 값은 항상 전체 표정(48바이트) } }; class NameCB : public NimBLECharacteristicCallbacks { void onWrite(NimBLECharacteristic *c, NimBLEConnInfo &info) override { NimBLEAttValue v = c->getValue(); size_t n = v.length(); if (n > 16) n = 16; memcpy(petName, v.data(), n); petName[n] = 0; pendingNameSave = true; } }; // 설정: [1, vol] 소리 크기, [2, id] 소리 들어보기, [3, 0] 자세 다시 맞추기 class SetCB : public NimBLECharacteristicCallbacks { void onWrite(NimBLECharacteristic *c, NimBLEConnInfo &info) override { NimBLEAttValue v = c->getValue(); const uint8_t *d = v.data(); if (v.length() < 2) return; if (d[0] == 1 && d[1] <= 3) { soundVol = d[1]; pendingVolSave = true; } else if (d[0] == 2) { playSound(d[1]); } else if (d[0] == 3) { pendingCalib = true; // 1초 걸리므로 loop에서 실행 } } }; // 학습 명령은 큐에 넣고 loop에서 처리 (센서 처리와 충돌 방지) class TrainCB : public NimBLECharacteristicCallbacks { void onWrite(NimBLECharacteristic *c, NimBLEConnInfo &info) override { NimBLEAttValue v = c->getValue(); CmdItem it; size_t n = v.length(); if (n == 0) return; if (n > sizeof(it.d)) n = sizeof(it.d); it.len = (uint8_t)n; memcpy(it.d, v.data(), n); xQueueSend(cmdQueue, &it, 0); } }; void bleSetup() { uint64_t mac = ESP.getEfuseMac(); snprintf(bleName, sizeof(bleName), "AIPet-%04X", (unsigned)((mac >> 32) & 0xFFFF)); NimBLEDevice::init(bleName); NimBLEServer *srv = NimBLEDevice::createServer(); srv->setCallbacks(new ServerCB()); NimBLEService *svc = srv->createService(SVC_UUID); chSensor = svc->createCharacteristic(SENSOR_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY); chFace = svc->createCharacteristic(FACE_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_NR); chName = svc->createCharacteristic(NAME_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE); chTrain = svc->createCharacteristic(TRAIN_UUID, NIMBLE_PROPERTY::WRITE); chModel = svc->createCharacteristic(MODEL_UUID, NIMBLE_PROPERTY::READ); chEvent = svc->createCharacteristic(EVENT_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY); chSet = svc->createCharacteristic(SET_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::WRITE); chFace->setCallbacks(new FaceCB()); chName->setCallbacks(new NameCB()); chTrain->setCallbacks(new TrainCB()); chSet->setCallbacks(new SetCB()); refreshFaceValue(); refreshModelValue(); refreshSetValue(); chName->setValue((uint8_t *)petName, strlen(petName)); svc->start(); // 광고: 이름은 광고 패킷, 서비스 UUID는 스캔 응답 (31바이트 제한) NimBLEAdvertising *adv = NimBLEDevice::getAdvertising(); NimBLEAdvertisementData ad; ad.setFlags(BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP); ad.setName(bleName); NimBLEAdvertisementData sr; sr.setCompleteServices(NimBLEUUID(SVC_UUID)); adv->setAdvertisementData(ad); adv->setScanResponseData(sr); adv->start(); Serial.printf("BLE 광고 시작: %s\n", bleName); } void sendSensor(const Imu &d) { int16_t v[6] = { (int16_t)constrain(d.ax * 1000, -32000, 32000), (int16_t)constrain(d.ay * 1000, -32000, 32000), (int16_t)constrain(d.az * 1000, -32000, 32000), (int16_t)constrain(d.gx, -32000, 32000), (int16_t)constrain(d.gy, -32000, 32000), (int16_t)constrain(d.gz, -32000, 32000)}; uint8_t buf[14]; memcpy(buf, v, 12); // ESP32는 리틀엔디언 buf[12] = currentMood; buf[13] = touchMask; // 비트0 머리, 비트1 등, 비트2 턱 chSensor->setValue(buf, sizeof(buf)); chSensor->notify(); } // ================= 저장 ================= void loadPrefs() { prefs.begin("pet", false); memcpy(faces, DEFAULT_FACES, sizeof(faces)); size_t fl = prefs.getBytesLength("faces"); // 예전 버전(6기분, 48바이트)으로 저장된 표정도 그대로 불러오고, 새 기분(싫어)만 기본값 if (fl == sizeof(faces) || fl == 6 * 8) prefs.getBytes("faces", faces, fl); String n = prefs.getString("name", ""); strncpy(petName, n.c_str(), 16); petName[16] = 0; soundVol = prefs.getUChar("vol", 2); if (soundVol > 3) soundVol = 2; if (prefs.getBytesLength("model") == sizeof(model)) { prefs.getBytes("model", &model, sizeof(model)); if (model.ver != ML_VER) mlInit(model); } else { mlInit(model); } mlNorm(model, mlSd); Serial.printf("학습된 예시: %d개\n", mlTotal(model)); } void saveModel() { prefs.putBytes("model", &model, sizeof(model)); } // ================= 동작 학습 ================= void showReaction(const uint8_t *face, uint8_t mood, uint32_t ms) { flashFace = face; flashMood = mood; flashUntil = millis() + ms; } void cancelTraining() { Serial.printf("녹화 취소 (상태 %d)\n", trainState); trainState = T_IDLE; capturing = false; sendTrainEvent(T_CANCEL); showReaction(faces[MOOD_UNKNOWN], MOOD_UNKNOWN, 800); playSound(SND_CANCEL); } void handleCommand(const CmdItem &c) { uint8_t op = c.d[0]; int slot = (c.len > 1) ? c.d[1] : -1; bool slotOk = slot >= 0 && slot < ML_LABELS; switch (op) { case CMD_RECORD: if (!mpuOk) { // 움직임 센서가 없으면 녹화할 수 없음 → 바로 취소 알림 Serial.println("녹화 불가: 움직임 센서(MPU6050) 인식 안 됨"); if (slotOk) trainSlot = slot; cancelTraining(); break; } if (slotOk && !model.used[slot]) Serial.printf("녹화 불가: 동작 %d 이 만들어지지 않음\n", slot); if (slotOk && model.used[slot] && trainState == T_IDLE && !capturing) { Serial.printf("녹화 준비: 동작 %d (가만히 0.5초)\n", slot); trainSlot = slot; trainState = T_ARMED; stateT = stillSince = millis(); sendTrainEvent(T_ARMED); playSound(SND_TICK); } break; case CMD_DEL_LABEL: if (slotOk) { mlDeleteLabel(model, slot); modelDirty = true; } break; case CMD_DEL_EX: if (slotOk && c.len > 2) { mlDeleteExample(model, slot, c.d[2]); modelDirty = true; } break; case CMD_CLEAR: { uint16_t thr = model.thrX100; mlInit(model); model.thrX100 = thr; modelDirty = true; break; } case CMD_SET_MOOD: if (slotOk && c.len > 2 && c.d[2] < MOOD_COUNT) { model.mood[slot] = c.d[2]; modelDirty = true; } break; case CMD_SET_NAME: if (slotOk) { size_t n = (c.len > 2) ? c.len - 2 : 0; if (n > 16) n = 16; memset(model.name[slot], 0, sizeof(model.name[slot])); memcpy(model.name[slot], c.d + 2, n); if (!model.used[slot]) { model.used[slot] = 1; model.nEx[slot] = 0; } modelDirty = true; } break; case CMD_SET_THR: if (c.len > 2) { model.thrX100 = c.d[1] | (c.d[2] << 8); modelDirty = true; } break; case CMD_CANCEL: if (trainState != T_IDLE) cancelTraining(); break; } } void startCapture() { // 링버퍼(직전 0.3초)를 시간 순서대로 창 앞부분에 복사 for (int i = 0; i < ML_PRE; i++) memcpy(capWin[i], ring[(ringPos + i) % ML_PRE], sizeof(capWin[i])); capN = ML_PRE; capStill = 0; capturing = true; if (trainState == T_WAIT) { trainState = T_REC; sendTrainEvent(T_REC); Serial.println("녹화 시작"); } } void finishCapture(uint32_t now) { float f[ML_FEAT]; mlFeatures(capWin, capN, f); cooldownUntil = now + 400; Serial.printf("녹화 길이: %d ms\n", capN * 10); if (trainState == T_REC) { mlAddExample(model, trainSlot, f); trainState = T_IDLE; modelDirty = true; sendTrainEvent(T_SAVED); showReaction(faces[MOOD_HAPPY], MOOD_HAPPY, 800); playSound(SND_SAVED); Serial.printf("예시 저장: 동작 %d, %d개\n", trainSlot, model.nEx[trainSlot]); return; } // 인식 MLResult r = mlClassify(model, f, mlSd); uint8_t ev[4 + ML_LABELS]; ev[0] = EV_RESULT; ev[1] = (r.label < 0) ? 255 : (uint8_t)r.label; uint16_t b = (uint16_t)(r.best * 100 > 65000 ? 65000 : r.best * 100); ev[2] = b & 0xFF; ev[3] = b >> 8; for (int l = 0; l < ML_LABELS; l++) { float d = r.perLabel[l] * 25; ev[4 + l] = (uint8_t)(d > 255 ? 255 : d); } sendEvent(ev, sizeof(ev)); if (r.label >= 0) { uint8_t m = model.mood[r.label]; showReaction(faces[m], m, 2500); playSound(m); // 기분 번호 = 소리 번호 Serial.printf("인식: %s (거리 %.2f)\n", model.name[r.label], r.best); } else { showReaction(faces[MOOD_UNKNOWN], MOOD_UNKNOWN, 2000); playSound(SND_UNKNOWN); Serial.printf("모르겠어 (가장 가까운 거리 %.2f)\n", r.best); } } // 중력을 뺀 "실제로 움직인" 가속도 크기 (g) // 예전 방식 |전체 크기 - 1g| 는 중력과 직각 방향(세워 둔 펫의 앞뒤·좌우) 흔들기를 거의 못 느낌: // 0.5g로 흔들어도 √(1+0.25) - 1 = 0.12g 로만 보임 → 이 방식은 0.5g 그대로 보임 float dynAccel(const Imu &d) { float a[3] = {d.ax, d.ay, d.az}; if (!gInit) { memcpy(gLp, a, sizeof(gLp)); gInit = true; } float s = 0; for (int i = 0; i < 3; i++) { gLp[i] += (a[i] - gLp[i]) * 0.02f; // 천천히 따라가는 평균 = 중력 방향 (약 0.5초) float v = a[i] - gLp[i]; s += v * v; } return sqrtf(s); } // 100Hz 샘플마다 호출. dyn = dynAccel() 결과 void onSample(const Imu &d, uint32_t now, float dyn) { float s[ML_AXES] = {d.ax, d.ay, d.az, d.gx, d.gy, d.gz}; memcpy(ring[ringPos], s, sizeof(s)); ringPos = (ringPos + 1) % ML_PRE; float gmag = sqrtf(d.gx * d.gx + d.gy * d.gy + d.gz * d.gz); bool moving = gmag > 80 || dyn > 0.3f; // 동작 시작 감지 기준 bool still = gmag < 40 && dyn < 0.15f; // 가만히 있음 (동작 끝 판단에도 사용) if (capturing) { memcpy(capWin[capN++], s, sizeof(s)); capStill = still ? capStill + 1 : 0; // 움직임이 멈추면 바로 끝 (최소 0.3초는 녹화), 아니면 최대 1.5초 bool ended = capN >= ML_PRE + ML_MIN_POST && capStill >= ML_STILL_END; if (ended || capN >= ML_WIN) { capturing = false; finishCapture(now); } return; } switch (trainState) { case T_ARMED: // 0.5초 가만히 있으면 준비 완료 if (!still) stillSince = now; else if (now - stillSince >= 500) { trainState = T_WAIT; stateT = now; sendTrainEvent(T_WAIT); Serial.println("녹화 대기: 이제 동작하세요 (5초)"); playSound(SND_READY); // 삑삑 = 이제 동작하세요 break; } if (now - stateT > 5000) cancelTraining(); break; case T_WAIT: // 5초 안에 움직이면 녹화 시작 if (moving) startCapture(); else if (now - stateT > 5000) cancelTraining(); break; case T_IDLE: // 학습된 게 있으면 움직임마다 인식 if (mlTotal(model) > 0 && now > cooldownUntil && moving) startCapture(); break; } } // ================= 메인 ================= float lookX = 0, lookY = 0; uint32_t nextBlink = 0, blinkEnd = 0, surprisedUntil = 0, lastMotion = 0; // ================= 터치 ================= // 터치 동작 번호 (앱과 같음) enum { G_TAP_HEAD, G_TAP_BACK, G_TAP_CHIN, // 톡 (0.6초 안에 뗌) G_HOLD_HEAD, G_HOLD_BACK, G_HOLD_CHIN, // 손 얹기 (0.8초 이상) G_STROKE, G_STROKE_BACKWARD, // 머리→등 쓰다듬기 / 등→머리 거꾸로 G_HUG, // 두 곳 이상 0.6초 동시에 G_COUNT }; const TouchReact TOUCH_REACT[G_COUNT] = { {MOOD_HAPPY, SND_HAPPY, 1500, "머리 톡"}, {MOOD_SURPRISE, SND_SURPRISE, 900, "등 톡 (깜짝)"}, {MOOD_HAPPY, SND_GIGGLE, 1500, "턱 톡 (간지럼)"}, {MOOD_HAPPY, SND_PURR, 2500, "머리 손 얹기"}, {MOOD_BASIC, SND_PURR, 2000, "등 손 얹기"}, {MOOD_SLEEPY, SND_PURR, 2500, "턱 쓰다듬기 (기분 좋아 눈 감음)"}, {MOOD_HAPPY, SND_LOVE, 3000, "쓰다듬기 (머리→등)"}, {MOOD_ANGRY, SND_ANGRY, 2000, "거꾸로 쓰다듬기 (등→머리)"}, {MOOD_HAPPY, SND_LOVE, 3000, "안아주기"}, }; // 터치 판정 기준 (ms) #define TAP_MAX 600 // 이보다 짧게 누르면 톡 #define HOLD_MIN 800 // 이만큼 누르고 있으면 손 얹기 #define STROKE_GAP 700 // 첫 터치 후 이 시간 안에 다음 곳을 누르면 쓰다듬기 #define HUG_MIN 600 // 두 곳을 이만큼 동시에 누르면 안아주기 bool tDown[3], tUsed[3]; uint32_t tDownAt[3], tLastPress[3]; uint32_t multiSince = 0; bool hugFired = false; int pendingTap = -1; // 머리·등 톡은 쓰다듬기의 시작일 수 있어서 잠깐 기다렸다 판정 uint32_t pendingTapAt = 0; void touchGesture(uint8_t g) { bool busy = trainState == T_ARMED || trainState == T_WAIT || trainState == T_REC || capturing; if (busy || g >= G_COUNT) return; // 동작 가르치는 중에는 터치 반응 안 함 const TouchReact &r = TOUCH_REACT[g]; showReaction(faces[r.mood], r.mood, r.ms); playSound(r.snd); uint8_t ev[2] = {EV_TOUCH, g}; sendEvent(ev, sizeof(ev)); Serial.printf("터치: %s\n", r.name); } // 10ms마다 호출 void touchUpdate(uint32_t now) { uint8_t mask = 0; for (int i = 0; i < 3; i++) if (digitalRead(TOUCH_PINS[i])) mask |= 1 << i; int count = __builtin_popcount(mask); for (int i = 0; i < 3; i++) { bool d = mask & (1 << i); if (d && !tDown[i]) { // 눌림 tDown[i] = true; tDownAt[i] = now; tUsed[i] = false; // 쓰다듬는 방향: 머리 다음 등 = 좋아함, 등 다음 머리 = 싫어함 int other = (i == Z_BACK) ? Z_HEAD : (i == Z_HEAD) ? Z_BACK : -1; if (other >= 0 && tLastPress[other] && now - tLastPress[other] < STROKE_GAP && now - tLastPress[other] > 60) { pendingTap = -1; // 앞의 톡은 쓰다듬기의 일부였음 touchGesture(i == Z_BACK ? G_STROKE : G_STROKE_BACKWARD); tUsed[i] = true; tUsed[other] = true; tLastPress[other] = 0; tLastPress[i] = 0; } else { tLastPress[i] = now; } } else if (!d && tDown[i]) { // 뗌 tDown[i] = false; if (!tUsed[i] && now - tDownAt[i] < TAP_MAX && count == 0) { if (i == Z_CHIN) touchGesture(G_TAP_CHIN); else { pendingTap = i; pendingTapAt = tDownAt[i] + STROKE_GAP; } } } else if (d && !tUsed[i] && count == 1 && now - tDownAt[i] >= HOLD_MIN) { // 계속 누름 touchGesture(G_HOLD_HEAD + i); tUsed[i] = true; } } // 안아주기: 두 곳 이상을 함께 누르고 있음 if (count >= 2) { if (!multiSince) multiSince = now; if (!hugFired && now - multiSince >= HUG_MIN) { touchGesture(G_HUG); hugFired = true; for (int i = 0; i < 3; i++) if (tDown[i]) tUsed[i] = true; } } else { multiSince = 0; if (count == 0) hugFired = false; } // 기다리던 톡: 그동안 쓰다듬기로 이어지지 않았으면 톡으로 확정 if (pendingTap >= 0 && (int32_t)(now - pendingTapAt) >= 0) { touchGesture(G_TAP_HEAD + pendingTap); pendingTap = -1; } touchMask = mask; if (mask) lastMotion = now; // 만져 주면 깨어 있음 } void setup() { // (C6 전용 안테나 스위치 코드 제거: C3에서 GPIO14는 플래시 칩 선택 핀이라 건드리면 멈춤) Serial.begin(115200); delay(1000); Serial.println("\n=== AI 펫 C3: BLE + 동작 학습 + 소리 + 터치 ==="); for (int i = 0; i < 3; i++) pinMode(TOUCH_PINS[i], INPUT_PULLDOWN); // 선이 빠져도 눌림으로 안 읽히게 cmdQueue = xQueueCreate(8, sizeof(CmdItem)); sndQueue = xQueueCreate(1, sizeof(uint8_t)); xTaskCreate(soundTask, "sound", 3072, nullptr, 3, nullptr); Wire.begin(PIN_SDA, PIN_SCL); Wire.setClock(400000); for (uint8_t a : {0x3C, 0x3D}) { Wire.beginTransmission(a); if (Wire.endTransmission() == 0) { oledAddr = a; break; } } mpuOk = mpuInit(); Serial.println(mpuOk ? "MPU6050 OK" : "MPU6050 실패"); loadPrefs(); bleSetup(); if (oledAddr && oled.begin(SSD1306_SWITCHCAPVCC, oledAddr)) { oled.clearDisplay(); oled.setTextColor(SSD1306_WHITE); oled.setTextSize(1); oled.setCursor(0, 8); oled.print(petName[0] ? petName : "AI Pet"); oled.setTextSize(2); oled.setCursor(4, 32); oled.print(bleName); oled.display(); playSound(SND_BOOT); delay(800); } else { oledAddr = 0; Serial.println("OLED 실패"); } // 이름 화면이 떠 있는 동안 켤 때의 자세를 기준으로 초기화 (약 1초, 움직이면 최대 3번 재시도) delay(200); // 전원 스위치를 누른 손이 떨어질 시간 calibrateImu(3); randomSeed(esp_random()); lastMotion = millis(); } void loop() { static uint32_t lastImu = 0, lastDraw = 0, lastNotify = 0, lastTouch = 0; static Imu d = {0, 0, 1, 0, 0, 0}; uint32_t now = millis(); // 터치 100Hz if (now - lastTouch >= 10) { lastTouch = now; touchUpdate(now); } // 앱에서 온 학습 명령 처리 CmdItem cmd; while (xQueueReceive(cmdQueue, &cmd, 0) == pdTRUE) handleCommand(cmd); // 센서 100Hz if (mpuOk && now - lastImu >= 10) { lastImu = now; static uint16_t mpuErr = 0; if (!mpuRead(d)) { // 읽기 실패한 샘플은 쓰지 않음 (선 접촉 불량 대비) if (++mpuErr % 100 == 1) Serial.printf("IMU 읽기 실패 %u회\n", mpuErr); if (mpuErr % 200 == 0) mpuInit(); goto afterImu; } { float dyn = dynAccel(d); onSample(d, now, dyn); float gmag = sqrtf(d.gx * d.gx + d.gy * d.gy + d.gz * d.gz); // 학습된 동작이 없을 때만 흔들기 = 놀람 (있으면 인식 결과로 반응) if (mlTotal(model) == 0 && (gmag > 300 || dyn > 0.8f)) surprisedUntil = now + 1000; if (gmag > 20 || dyn > 0.1f) lastMotion = now; #if DEBUG_MOTION // 감지 기준 조정용 (시리얼 플로터): 움직임 가속도(g), 회전(÷100), 시작 기준선 0.3 / 0.8 static uint8_t dbg = 0; if (++dbg >= 5) { dbg = 0; Serial.printf("move_g:%.2f,rot_x100:%.2f,start:0.3,start_rot:0.8\n", dyn, gmag / 100.0f); } #endif } } afterImu: // 녹화 준비·대기 시간 초과는 센서와 상관없이 처리 (센서가 멈춰도 앱이 '준비 중'에 갇히지 않게) if (!capturing && (trainState == T_ARMED || trainState == T_WAIT) && now - stateT > 6000) cancelTraining(); // 자동 기분: 흔들면 놀람, 30초 가만히 두면 졸림 uint8_t autoMood = MOOD_BASIC; if (now < surprisedUntil) autoMood = MOOD_SURPRISE; else if (now - lastMotion > 30000) autoMood = MOOD_SLEEPY; // 자동 기분이 바뀌는 순간에만 소리 (흔드는 동안 계속 울리지 않도록) static uint8_t prevAuto = MOOD_BASIC; if (autoMood != prevAuto) { if (autoMood == MOOD_SURPRISE) playSound(SND_SURPRISE); else if (autoMood == MOOD_SLEEPY) playSound(SND_SLEEPY); // 터치·인식 반응으로 깨어난 거면 그 소리를 덮지 않음 else if (prevAuto == MOOD_SLEEPY && !(flashFace && (int32_t)(flashUntil - now) > 0)) playSound(SND_WAKE); prevAuto = autoMood; } // 표정 우선순위: 배우는 중 > 앱 미리보기 > 반응(인식 결과) > 자동 기분 const uint8_t *p; // 배우는 중이거나, 동작을 감지해 보는 중이면 바로 집중한 눈 (반응이 빠르게 느껴지도록) bool learning = trainState == T_ARMED || trainState == T_WAIT || trainState == T_REC || capturing; if (learning) { p = READY_FACE; currentMood = MOOD_LEARNING; } else if (previewMood >= 0 && (int32_t)(previewUntil - now) > 0) { p = previewFace; currentMood = previewMood; } else if (flashFace && (int32_t)(flashUntil - now) > 0) { previewMood = -1; p = flashFace; currentMood = flashMood; } else { previewMood = -1; flashFace = nullptr; p = faces[autoMood]; currentMood = autoMood; } // 화면 약 30fps if (oledAddr && now - lastDraw >= 33) { lastDraw = now; // 켤 때 자세(aBase)에서 얼마나 기울었는지로 시선 이동. 방향이 반대면 부호 변경 float tx = constrain(-(d.ay - aBase[1]) * 25.0f, -14.0f, 14.0f); float ty = constrain((d.ax - aBase[0]) * 18.0f, -8.0f, 8.0f); if (learning) { tx = 0; ty = 0; } // 배우는 동안은 정면 lookX += (tx - lookX) * 0.3f; lookY += (ty - lookY) * 0.3f; if (p[7] > 0 && now > nextBlink) { blinkEnd = now + 120; nextBlink = now + (8000 - p[7] * 25) + random(-400, 400); } bool blinking = now < blinkEnd && currentMood != MOOD_SURPRISE && !learning; oled.clearDisplay(); drawFace(p, (int)lookX, (int)lookY, blinking); if (bleConnected) oled.fillCircle(124, 3, 2, SSD1306_WHITE); // 연결 표시 // 학습 상태 표시: 대기 중 깜빡이는 점, 녹화 중 꽉 찬 막대 if (trainState == T_WAIT && (now / 250) % 2) oled.fillCircle(4, 4, 3, SSD1306_WHITE); if (trainState == T_REC) oled.fillRect(0, 60, capN * 128 / ML_WIN, 4, SSD1306_WHITE); oled.display(); } // 폰으로 센서 전송 20Hz if (bleConnected && now - lastNotify >= 50) { lastNotify = now; sendSensor(d); } // 저장은 BLE 콜백 밖에서 if (modelDirty) { modelDirty = false; mlNorm(model, mlSd); saveModel(); refreshModelValue(); uint8_t ev[1] = {EV_MODEL}; sendEvent(ev, 1); } if (pendingFaceSave) { pendingFaceSave = false; prefs.putBytes("faces", faces, sizeof(faces)); Serial.println("표정 저장"); } if (pendingCalib) { pendingCalib = false; playSound(SND_TICK); bool ok = calibrateImu(3); playSound(ok ? SND_SAVED : SND_CANCEL); lastMotion = millis(); } if (pendingVolSave) { pendingVolSave = false; prefs.putUChar("vol", soundVol); refreshSetValue(); playSound(SND_TICK); // 바뀐 크기로 한 번 들려줌 Serial.printf("소리 크기: %d\n", soundVol); } if (pendingNameSave) { pendingNameSave = false; prefs.putString("name", petName); chName->setValue((uint8_t *)petName, strlen(petName)); Serial.printf("이름 저장: %s\n", petName); } }