0911 ATECC608A 加密存储芯片
(WCMCU-608模块) 完整技术资料

#include <ArduinoECCX08.h>
#include <utility/ECCX08SelfSignedCert.h>
#include <utility/ECCX08DefaultTLSConfig.h>   // 库自带的默认TLS配置数组

// 确认 ECCX08.locked() 为 false 之后：
ECCX08.writeConfiguration(ECCX08_DEFAULT_TLS_CONFIG);  // 写入官方默认配置
ECCX08.lock();                                          // 永久锁定，不可逆！

// Lock 之后才能：
ECCX08.generatePrivateKey(slot, publicKey);   // 在 slot(0~4)里生成新私钥，返回对应公钥
ECCX08.ecSign(slot, message32bytes, signature);      // 用该私钥签名(输入必须是32字节)
ECCX08.ecdsaVerify(message32bytes, signature, publicKey);  // 验签
ECCX08.random(65535);                          // 生成随机数(Lock后才可用)

[env:esp32dev]
platform = espressif32@6.13.0
board = esp32dev
framework = arduino
board_build.partitions = huge_app.csv
; Arduino-ESP32 核心3.x(ESP-IDF5)在这台机器上链接报错:
;   undefined reference to `esp_bt_controller_mem_release'
; 是工具链BT库版本不匹配的已知问题，跟代码无关。固定用2.0.17这个稳定核心版本绕开。
; (跟 02_中文触摸效率时钟、U1205 BMM150、02601 DPS310 项目踩过的坑是同一个，写法照抄。)
platform_packages =
    framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32/releases/download/2.0.17/esp32-2.0.17.zip
upload_port = COM20
monitor_port = COM20
monitor_speed = 115200

; TFT_eSPI版本/引脚定义照抄02_中文触摸效率时钟项目里已验证过的配置。
; U8g2 + U8g2_for_TFT_eSPI：给TFT_eSPI加中文字体支持(文泉驿点阵字库wqy16/wqy12)，
; 字库数据直接编译进固件，不用额外生成.vlw字库文件。
lib_deps =
    bodmer/TFT_eSPI @ ^2.5.43
    olikraus/U8g2 @ ^2.35.19
    https://github.com/Bodmer/U8g2_for_TFT_eSPI.git

build_flags =
    -D USER_SETUP_LOADED=1
    -D ST7789_DRIVER=1
    -D TFT_WIDTH=240
    -D TFT_HEIGHT=320
    -D TFT_MOSI=13
    -D TFT_SCLK=14
    -D TFT_CS=15
    -D TFT_DC=2
    -D TFT_RST=-1
    -D TFT_MISO=-1
    -D TFT_BL=21
    -D TFT_BACKLIGHT_ON=HIGH
    -D TFT_INVERSION_OFF=1
    -D SPI_FREQUENCY=40000000
    -D LOAD_GLCD=1
    -D LOAD_FONT2=1
    -D LOAD_FONT4=1
    -D LOAD_FONT6=1
    -D LOAD_FONT7=1
    -D LOAD_FONT8=1
    -D LOAD_GFXFF=1
    -D SMOOTH_FONT=1

/*
  ESP32-2432S028R(2.8寸屏CYD) + ATECC608A 触摸UI演示（中文版）
  接线：模块 VCC->3.3V，GND->GND，SDA->IO27，SCL->IO22(跟BMM150/DPS310项目同一路I2C排针)
  屏幕/触摸引脚沿用 02_中文触摸效率时钟、03_BMI160单独测试UI 两个项目已验证过的配置。
  中文字体用 U8g2_for_TFT_eSPI + U8g2 自带的文泉驿点阵字体(wqy16/wqy12)，
  不用额外生成字库文件，字库数据直接编译进固件。

  交互：
    - 单击：翻页/切换演示内容
    - 长按(HOLD_MS，当前5秒，按住期间屏幕下方有红色进度条)：确认"永久Lock"这类
      不可逆操作；主页长按=重新扫描芯片；演示页长按=返回主页

  SIMULATE_LOCK = 1 (当前默认)：
    只走UI/状态机流程，不会真的调用 ECCX08.writeConfiguration()/lock()，也不会真的
    执行签名/生成密钥/随机数——全部用标了"模拟"字样的假数据展示，用来先把触摸交互
    和翻页调试顺，不碰物理芯片的真实配置。
    确认UI没问题、且用户明确同意要真的Lock这颗芯片之后，把这个宏改成0再重新烧录，
    才会真的执行 Configuration+Lock 和调用真实的签名/密钥/随机数功能。
*/

#include <SPI.h>
#include <TFT_eSPI.h>
#include <U8g2_for_TFT_eSPI.h>
#include <Wire.h>
#include <ArduinoECCX08.h>

#define SIMULATE_LOCK 1

#define I2C_SDA 27
#define I2C_SCL 22

#define TOUCH_CS 33
#define TOUCH_IRQ 36

#define HOLD_MS 5000UL
#define KEY_SLOT 0

#define SCREEN_W 320
#define SCREEN_H 240

#define COL_BG      TFT_BLACK
#define COL_TEXT    TFT_WHITE
#define COL_DIM     TFT_DARKGREY
#define COL_OK      TFT_GREEN
#define COL_WARN    TFT_RED
#define COL_ACCENT  TFT_YELLOW
#define COL_BAR_BG  0x2104   // 深灰
#define COL_BAR_FG  TFT_RED

TFT_eSPI tft = TFT_eSPI();
U8g2_for_TFT_eSPI u8f;

enum AppState {
  STATE_DETECT,
  STATE_ERROR,
  STATE_INFO,
  STATE_LOCK_CONFIRM,
  STATE_MENU_KEYGEN,
  STATE_MENU_SIGN,
  STATE_MENU_RANDOM,
  STATE_MENU_SHA256,
};

static AppState state = STATE_DETECT;
static bool chipLockedReal = false;   // ECCX08.locked() 的真实结果
static bool simLocked = false;        // 仅SIMULATE_LOCK=1时，软件层面假装"已锁定"
static String serialNumberStr;

static bool isLockedEffective() {
#if SIMULATE_LOCK
  return simLocked;
#else
  return chipLockedReal;
#endif
}

// ---------------- 触摸：只用IRQ判断"有没有摁下"，不做坐标映射 ----------------
// XPT2046在CS拉低期间，只要屏幕被摁着，PENIRQ会一直是低电平——足够用来做
// "单击/长按"这种不需要具体坐标的交互，省掉坐标标定这一步(跟03号项目思路一致，
// 那边也是靠"点哪都算"，没做坐标映射)。
static void touchInit() {
  pinMode(TOUCH_CS, OUTPUT);
  digitalWrite(TOUCH_CS, LOW);   // 常拉低，让IRQ一直有效
  pinMode(TOUCH_IRQ, INPUT);
}

static bool isTouchedNow() {
  return digitalRead(TOUCH_IRQ) == LOW;
}

// ---------------- 画面绘制小工具 ----------------
// 中文用U8g2的文泉驿点阵字体：wqy16(16px，标题/正文用) + wqy12(12px，提示小字用)。
// 这两个字体是等宽位图字体，一个汉字/一个ASCII字符基本都是"字号"px宽，
// 320屏两边各留12px边距，可用宽度296px，正文最多约18个汉字，够用不会超屏。
static int cursorY;

static void resetCursor(int y) { cursorY = y; }
static void setPrimaryFont()   { u8f.setFont(u8g2_font_wqy16_t_gb2312); }   // 16px
static void setSecondaryFont() { u8f.setFont(u8g2_font_wqy12_t_gb2312); }   // 12px

static void drawHeader(const char *title, uint16_t color) {
  tft.fillScreen(COL_BG);
  u8f.setForegroundColor(color);
  setPrimaryFont();
  u8f.drawUTF8(12, 30, title);
  tft.drawFastHLine(0, 40, SCREEN_W, COL_DIM);
#if SIMULATE_LOCK
  u8f.setForegroundColor(COL_ACCENT);
  setSecondaryFont();
  u8f.drawUTF8(12, SCREEN_H - 8, "模拟模式 - 未触碰真实芯片");
#endif
  resetCursor(62);
}

// tier: 2=正文(默认，16px文泉驿)，1=小字提示(12px文泉驿)
static void printLine(const String &text, uint16_t color, uint8_t tier = 2) {
  u8f.setForegroundColor(color);
  if (tier >= 2) setPrimaryFont(); else setSecondaryFont();
  u8f.drawUTF8(12, cursorY, text.c_str());
  cursorY += (tier >= 2) ? 24 : 18;
}

static void printGap(int px) { cursorY += px; }

static void drawProgressBar(uint32_t elapsedMs) {
  const int x = 12, y = SCREEN_H - 46, w = SCREEN_W - 24, h = 16;
  uint32_t clamped = elapsedMs > HOLD_MS ? HOLD_MS : elapsedMs;
  int fillW = (int)((uint32_t)w * clamped / HOLD_MS);
  tft.fillRect(x, y, w, h, COL_BAR_BG);
  if (fillW > 0) tft.fillRect(x, y, fillW, h, COL_BAR_FG);
  tft.drawRect(x, y, w, h, COL_TEXT);
}

static void clearProgressBar() {
  const int x = 12, y = SCREEN_H - 46, w = SCREEN_W - 24, h = 16;
  tft.fillRect(x, y, w, h, COL_BAR_BG);
  tft.drawRect(x, y, w, h, COL_TEXT);
}

// 只转前 len 字节，每 8 字节一行(16个hex字符)，用正文字号显示也不会超屏。
static String toHex(const uint8_t *data, int len) {
  String s;
  char buf[3];
  for (int i = 0; i < len; i++) {
    sprintf(buf, "%02X", data[i]);
    s += buf;
  }
  return s;
}

// ---------------- 各页面绘制 ----------------
static void renderDetectPage() {
  drawHeader("检测中...", COL_TEXT);
}

static void renderErrorPage() {
  drawHeader("未找到芯片", COL_WARN);
  printLine("请检查接线：", COL_TEXT);
  printLine("SDA=IO27 SCL=IO22", COL_TEXT);
  printGap(10);
  printLine("长按5秒重试", COL_DIM, 1);
}

static void renderInfoPage() {
  drawHeader("已找到芯片", COL_OK);
  printLine("型号：ATECC608A", COL_TEXT);
  printLine("序列号：", COL_DIM, 1);
  printLine(serialNumberStr, COL_TEXT);
  printGap(6);
  if (isLockedEffective()) {
    printLine("已锁定", COL_OK);
    printGap(6);
    printLine("轻触：查看演示", COL_DIM, 1);
  } else {
    printLine("未锁定（出厂状态）", COL_WARN);
    printGap(6);
    printLine("轻触：进入锁定步骤", COL_DIM, 1);
  }
  printLine("长按5秒：重新扫描", COL_DIM, 1);
}

static void renderLockConfirmPage(uint32_t heldMs) {
  drawHeader("永久锁定确认", COL_WARN);
  printLine("该操作不可撤销！", COL_TEXT);
  printLine("确认后配置永久生效", COL_TEXT);
  printGap(10);
  printLine("长按5秒确认锁定", COL_ACCENT);
  drawProgressBar(heldMs);
}

static void renderLockResultPage(bool ok) {
  drawHeader(ok ? "锁定成功" : "锁定失败", ok ? COL_OK : COL_WARN);
#if SIMULATE_LOCK
  printLine("（模拟，未写入真实配置）", COL_ACCENT);
#else
  printLine(ok ? "配置已写入并锁定" : "写入或锁定失败", COL_TEXT);
#endif
  printGap(10);
  printLine("轻触继续", COL_DIM, 1);
}

static void renderKeygenPage() {
  drawHeader("生成密钥", COL_TEXT);
  printLine("槽位：" + String(KEY_SLOT), COL_TEXT);
  printGap(6);

  uint8_t publicKey[64];
#if SIMULATE_LOCK
  for (int i = 0; i < 64; i++) publicKey[i] = (uint8_t)(0xA5 ^ (i * 7 + 3));
  printLine("公钥（模拟）：", COL_ACCENT, 1);
#else
  ECCX08.generatePrivateKey(KEY_SLOT, publicKey);
  printLine("公钥（真实）：", COL_ACCENT, 1);
#endif
  printLine(toHex(publicKey, 8), COL_TEXT);
  printLine(toHex(publicKey + 8, 8), COL_TEXT);
  printGap(10);
  printLine("轻触：下一个  长按5秒：主页", COL_DIM, 1);
}

static void renderSignPage() {
  drawHeader("签名与验证", COL_TEXT);

  const byte input[32] = {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
  };
  byte signature[64];
  byte publicKey[64];
  bool verified;

#if SIMULATE_LOCK
  for (int i = 0; i < 64; i++) signature[i] = (uint8_t)(0x5A ^ (i * 11 + 1));
  verified = true;
  printLine("签名（模拟）：", COL_ACCENT, 1);
#else
  ECCX08.generatePublicKey(KEY_SLOT, publicKey);
  ECCX08.ecSign(KEY_SLOT, input, signature);
  verified = ECCX08.ecdsaVerify(input, signature, publicKey);
  printLine("签名（真实）：", COL_ACCENT, 1);
#endif
  printLine(toHex(signature, 8), COL_TEXT);
  printLine(toHex(signature + 8, 8), COL_TEXT);
  printGap(6);
  printLine(verified ? "验证：通过" : "验证：失败", verified ? COL_OK : COL_WARN);
  printGap(10);
  printLine("轻触：下一个  长按5秒：主页", COL_DIM, 1);
}

static void renderRandomPage() {
  drawHeader("生成随机数", COL_TEXT);

  long value;
#if SIMULATE_LOCK
  value = random(0, 65535);
  printLine("随机数（模拟）：", COL_ACCENT, 1);
#else
  value = ECCX08.random(65535);
  printLine("随机数（真实）：", COL_ACCENT, 1);
#endif
  printGap(6);
  printLine(String(value), COL_TEXT);
  printGap(10);
  printLine("轻触：换一个新数", COL_DIM, 1);
  printLine("长按5秒：返回主页", COL_DIM, 1);
}

static void renderSha256Page() {
  drawHeader("SHA-256哈希", COL_TEXT);

  const byte input[32] = {
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
  };
  byte digest[32];

  printLine("对32字节数据求哈希", COL_TEXT, 1);
  printGap(4);
#if SIMULATE_LOCK
  for (int i = 0; i < 32; i++) digest[i] = (uint8_t)(0x3C ^ (i * 13 + 5));
  printLine("摘要（模拟）：", COL_ACCENT, 1);
#else
  ECCX08.SHA256(input, sizeof(input), digest);
  printLine("摘要（真实）：", COL_ACCENT, 1);
#endif
  printLine(toHex(digest, 8), COL_TEXT);
  printLine(toHex(digest + 8, 8), COL_TEXT);
  printGap(10);
  printLine("轻触：下一个  长按5秒：主页", COL_DIM, 1);
}

static void renderCurrentState() {
  switch (state) {
    case STATE_DETECT:       renderDetectPage(); break;
    case STATE_ERROR:        renderErrorPage(); break;
    case STATE_INFO:         renderInfoPage(); break;
    case STATE_LOCK_CONFIRM: renderLockConfirmPage(0); break;
    case STATE_MENU_KEYGEN:  renderKeygenPage(); break;
    case STATE_MENU_SIGN:    renderSignPage(); break;
    case STATE_MENU_RANDOM:  renderRandomPage(); break;
    case STATE_MENU_SHA256:  renderSha256Page(); break;
  }
}

// ---------------- Lock 执行(模拟或真实，由 SIMULATE_LOCK 决定) ----------------
static bool performLock() {
#if SIMULATE_LOCK
  delay(1200);   // 假装在写配置，凑一个真实感的等待时间
  simLocked = true;
  return true;
#else
  if (!ECCX08.writeConfiguration(ECCX08_DEFAULT_TLS_CONFIG)) return false;
  if (!ECCX08.lock()) return false;
  chipLockedReal = true;
  return true;
#endif
}

// ---------------- 触摸事件 -> 状态机 ----------------
static void onShortTap() {
  switch (state) {
    case STATE_ERROR:
      break; // 只能长按重试，单击不响应
    case STATE_INFO:
      state = isLockedEffective() ? STATE_MENU_KEYGEN : STATE_LOCK_CONFIRM;
      renderCurrentState();
      break;
    case STATE_LOCK_CONFIRM:
      // 没按满5秒的单击视为无效操作，停留在本页(不取消也不确认)
      clearProgressBar();
      break;
    case STATE_MENU_KEYGEN:
      state = STATE_MENU_SIGN;
      renderCurrentState();
      break;
    case STATE_MENU_SIGN:
      state = STATE_MENU_RANDOM;
      renderCurrentState();
      break;
    case STATE_MENU_RANDOM:
      state = STATE_MENU_SHA256;
      renderCurrentState();
      break;
    case STATE_MENU_SHA256:
      state = STATE_MENU_KEYGEN;
      renderCurrentState();
      break;
    default:
      break;
  }
}

static void onLongPressComplete() {
  switch (state) {
    case STATE_ERROR:
      ESP.restart();
      break;
    case STATE_INFO:
      // 在主页长按 = 真的重新扫描一次芯片(软复位)，跟"演示页长按=回主页"分开，
      // 两个长按动作不会互相冲突。
      ESP.restart();
      break;
    case STATE_LOCK_CONFIRM: {
      drawHeader("锁定中...", COL_ACCENT);
      printLine("请稍候", COL_TEXT);
      bool ok = performLock();
      renderLockResultPage(ok);
      // 下一次单击会走到 renderCurrentState()，state先切到INFO，
      // 让"轻触继续"点一下之后按当前锁定状态正确分流到菜单。
      state = STATE_INFO;
      break;
    }
    case STATE_MENU_KEYGEN:
    case STATE_MENU_SIGN:
    case STATE_MENU_RANDOM:
    case STATE_MENU_SHA256:
      // 长按回主页，不用整个重启——软件层面的模拟锁定状态也会保留。
      state = STATE_INFO;
      renderCurrentState();
      break;
    default:
      break;
  }
}

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

  tft.init();
  tft.setRotation(1);
  tft.fillScreen(COL_BG);

  u8f.begin(tft);
  u8f.setFontMode(1);       // 透明背景，不用每次单独填底色
  u8f.setFontDirection(0);

  touchInit();

  Wire.begin(I2C_SDA, I2C_SCL);

  renderDetectPage();

  if (!ECCX08.begin()) {
    Serial.println("ATECC608A not found");
    state = STATE_ERROR;
    renderCurrentState();
    return;
  }

  serialNumberStr = ECCX08.serialNumber();
  chipLockedReal = ECCX08.locked();

  Serial.print("S/N: ");
  Serial.println(serialNumberStr);
  Serial.print("Locked: ");
  Serial.println(chipLockedReal ? "yes" : "no");

  state = STATE_INFO;
  renderCurrentState();
}

void loop() {
  static uint32_t lastPoll = 0;
  static bool wasDown = false;
  static uint32_t pressStartMs = 0;
  static bool longFired = false;
  static uint32_t lastActionMs = 0;

  uint32_t now = millis();
  if (now - lastPoll < 20) return;
  lastPoll = now;

  bool down = isTouchedNow();

  if (down && !wasDown) {
    pressStartMs = now;
    longFired = false;
  }

  if (down) {
    uint32_t held = now - pressStartMs;
    if ((state == STATE_LOCK_CONFIRM) ||
        (state == STATE_ERROR) ||
        (state == STATE_INFO) ||
        (state == STATE_MENU_KEYGEN) || (state == STATE_MENU_SIGN) ||
        (state == STATE_MENU_RANDOM) || (state == STATE_MENU_SHA256)) {
      if (state == STATE_LOCK_CONFIRM) drawProgressBar(held);
      if (!longFired && held >= HOLD_MS) {
        longFired = true;
        lastActionMs = now;
        onLongPressComplete();
      }
    }
  }

  if (!down && wasDown && !longFired && (now - lastActionMs > 250)) {
    lastActionMs = now;
    onShortTap();
  }

  wasDown = down;
}