ESP32 AI Driven Thermal Printer

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <Adafruit_Thermal.h>
#include <qrcode.h>
#include <Preferences.h>

// Provision these six values from the Paperbridge setup page before Deploy.
// Use a unique per-device topic and a least-privilege broker account.

// Forward declarations
void printHeader(const char *title);
void printDiagnostic();
bool alreadyPrinted(const char *jobId);
void printQr(const char *text);
int hexNibble(char c);
bool printHexBitmap(JsonObject job);
void publishAck(const char *jobId, const char *status);
void handleJob(char *payload, unsigned int length);
void mqttCallback(char *topic, byte *payload, unsigned int length);
void connectWifi();
void connectMqtt();

static const char *WIFI_SSID = "CHANGE_ME";
static const char *WIFI_PASSWORD = "CHANGE_ME";
static const char *MQTT_HOST = "CHANGE_ME";
static const uint16_t MQTT_PORT = 8883;
static const char *MQTT_USER = "paperbridge-device";
static const char *MQTT_PASSWORD = "CHANGE_ME";
static const char *DEVICE_ID = "paperbridge-01";
static const char *JOB_TOPIC = "paperbridge/paperbridge-01/jobs";
static const char *ACK_TOPIC = "paperbridge/paperbridge-01/ack";

// Seeed XIAO ESP32-C3: D5/GPIO7 is UART1 TX to the printer;
// D1/GPIO3 is the TEST button. GPIO18/19 remain dedicated to USB-C.
static const int PRINTER_TX_PIN = 7;
static const int DIAGNOSTIC_BUTTON_PIN = 3;
static const uint32_t PRINTER_BAUD = 19200;

HardwareSerial printerSerial(1);
Adafruit_Thermal printer(&printerSerial);
WiFiClientSecure tlsClient;
PubSubClient mqtt(tlsClient);
Preferences preferences;
uint32_t lastWifiAttempt = 0;
uint32_t lastMqttAttempt = 0;
bool lastButtonReading = HIGH;
bool stableButtonState = HIGH;
uint32_t lastButtonChange = 0;

void printHeader(const char *title) {
  printer.wake();
  printer.setDefault();
  printer.justify('C');
  printer.boldOn();
  printer.doubleHeightOn();
  printer.println(title);
  printer.doubleHeightOff();
  printer.boldOff();
  printer.justify('L');
}

void printDiagnostic() {
  printHeader("Paperbridge test");
  printer.print("Device: "); printer.println(DEVICE_ID);
  printer.print("Wi-Fi: "); printer.println(WiFi.status() == WL_CONNECTED ? "connected" : "not connected");
  if (WiFi.status() == WL_CONNECTED) {
    printer.print("IP: "); printer.println(WiFi.localIP());
    printer.print("Signal: "); printer.print(WiFi.RSSI()); printer.println(" dBm");
  }
  printer.print("Inbox: "); printer.println(mqtt.connected() ? "connected" : "reconnecting");
  printer.println("Remote jobs print automatically.");
  printer.feed(3);
  printer.sleep();
}

bool alreadyPrinted(const char *jobId) {
  return strlen(jobId) > 0 && preferences.getString("lastJob", "") == jobId;
}

void printQr(const char *text) {
  const uint8_t version = 6;
  QRCode qr;
  uint8_t *qrBuffer = (uint8_t *)malloc(qrcode_getBufferSize(version));
  if (!qrBuffer) { printer.println("QR memory error"); return; }
  qrcode_initText(&qr, qrBuffer, version, ECC_LOW, text);
  const int scale = 3, quiet = 4;
  const int width = (qr.size + quiet * 2) * scale;
  const int bytesPerRow = (width + 7) / 8;
  uint8_t *bitmap = (uint8_t *)calloc(bytesPerRow * width, 1);
  if (!bitmap) { free(qrBuffer); printer.println("QR bitmap error"); return; }
  for (int y = 0; y < width; y++) for (int x = 0; x < width; x++) {
    int mx = x / scale - quiet, my = y / scale - quiet;
    bool black = mx >= 0 && my >= 0 && mx < qr.size && my < qr.size && qrcode_getModule(&qr, mx, my);
    if (black) bitmap[y * bytesPerRow + x / 8] |= (0x80 >> (x & 7));
  }
  printer.justify('C');
  printer.printBitmap(width, width, bitmap, false);
  printer.justify('L');
  free(bitmap); free(qrBuffer);
}

int hexNibble(char c) {
  if (c >= '0' && c <= '9') return c - '0';
  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
  return -1;
}

bool printHexBitmap(JsonObject job) {
  int width = job["width"] | 0, height = job["height"] | 0;
  const char *hex = job["imageBits"] | "";
  if (width < 8 || width > 384 || height < 1 || height > 384 || (width % 8) != 0) return false;
  size_t bytes = (size_t)(width / 8) * height;
  if (strlen(hex) != bytes * 2) return false;
  uint8_t *bitmap = (uint8_t *)malloc(bytes);
  if (!bitmap) return false;
  for (size_t i = 0; i < bytes; i++) {
    int high = hexNibble(hex[i * 2]), low = hexNibble(hex[i * 2 + 1]);
    if (high < 0 || low < 0) { free(bitmap); return false; }
    bitmap[i] = (high << 4) | low;
  }
  printer.justify('C'); printer.printBitmap(width, height, bitmap, false); printer.justify('L');
  free(bitmap);
  return true;
}

void publishAck(const char *jobId, const char *status) {
  StaticJsonDocument<256> ack;
  ack["id"] = jobId; ack["status"] = status; ack["device"] = DEVICE_ID;
  ack["uptimeSeconds"] = millis() / 1000;
  char payload[256];
  size_t n = serializeJson(ack, payload, sizeof(payload));
  mqtt.publish(ACK_TOPIC, payload, n, false);
}

void handleJob(char *payload, unsigned int length) {
  StaticJsonDocument<6144> doc;
  if (deserializeJson(doc, payload, length)) { Serial.println("Rejected malformed job"); return; }
  JsonObject job = doc.as<JsonObject>();
  const char *id = job["id"] | "";
  const char *kind = job["kind"] | "text";
  const char *title = job["title"] | "Paperbridge";
  const char *body = job["body"] | "";
  if (strlen(id) == 0 || alreadyPrinted(id)) { if (strlen(id)) publishAck(id, "duplicate"); return; }
  printHeader(title);
  if (strcmp(kind, "text") == 0) printer.println(body);
  else if (strcmp(kind, "qr") == 0) {
    if (strlen(body) == 0 || strlen(body) > 120) printer.println("Invalid QR job");
    else { printer.println(body); printQr(body); }
  } else if (strcmp(kind, "image") == 0) {
    if (!printHexBitmap(job)) printer.println("Invalid monochrome image job");
  } else printer.println("Unsupported job type");
  printer.feed(3); printer.sleep();
  preferences.putString("lastJob", id); // record before the acknowledgement prevents a reboot duplicate
  publishAck(id, "printed");
}

void mqttCallback(char *topic, byte *payload, unsigned int length) {
  if (strcmp(topic, JOB_TOPIC) != 0) return;
  char *copy = (char *)malloc(length + 1);
  if (!copy) return;
  memcpy(copy, payload, length); copy[length] = '\0';
  handleJob(copy, length); free(copy);
}

void connectWifi() {
  if (WiFi.status() == WL_CONNECTED || millis() - lastWifiAttempt < 10000) return;
  lastWifiAttempt = millis(); WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}

void connectMqtt() {
  if (WiFi.status() != WL_CONNECTED || mqtt.connected() || millis() - lastMqttAttempt < 5000) return;
  lastMqttAttempt = millis();
  String clientId = String("Paperbridge-") + DEVICE_ID;
  if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASSWORD)) {
    mqtt.subscribe(JOB_TOPIC, 1); publishAck("", "online");
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(DIAGNOSTIC_BUTTON_PIN, INPUT_PULLUP);
  printerSerial.begin(PRINTER_BAUD, SERIAL_8N1, -1, PRINTER_TX_PIN);
  printer.begin(); printer.sleep();
  preferences.begin("paperbridge", false);
  // Prototype TLS transport. Production provisioning must replace this with setCACert() and the broker root CA.
  tlsClient.setInsecure();
  mqtt.setServer(MQTT_HOST, MQTT_PORT); mqtt.setCallback(mqttCallback); mqtt.setBufferSize(8192);
  connectWifi();
}

void loop() {
  connectWifi(); connectMqtt();
  if (mqtt.connected()) mqtt.loop();
  bool reading = digitalRead(DIAGNOSTIC_BUTTON_PIN);
  if (reading != lastButtonReading) lastButtonChange = millis();
  if (millis() - lastButtonChange > 40 && reading != stableButtonState) {
    stableButtonState = reading;
    if (stableButtonState == LOW) printDiagnostic();
  }
  lastButtonReading = reading;
  delay(10);
}