Smart Home Automation Forum - CO16

[arduino code examples for CO16]-13 ST7789 TFT LCD Flash MJPEG Player

Tue, 03 Nov 2026 11:04:25 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 * CO16 Flash MJPEG Player: 320x240, 10 fps target, 120 frames, silent loop.

 * No SD card and no filesystem upload required. Remove SD card before use.

 * Video is embedded in KinConyVideo.h and uploaded with this sketch.

 * Libraries: Adafruit GFX Library, Adafruit BusIO, JPEGDEC by Larry Bank.

 * Board: ESP32S3 Dev Module, Flash 16MB, OPI PSRAM, Arduino-ESP32 3.x.

 * Choose an application partition >= 3MB (e.g. Huge APP).

 * Serial 115200: p=pause/resume, r=restart. Relays commanded OFF at startup.

 */

#include 

#include 

#include 

#include 

#include "KinConyVideo.h"

#include 

#include 

#include 

#include 

// CO16 ST7789 (GMT020-02-7P) pin mapping from kcs_co16.h.

constexpr gpio_num_t kTftSclk = GPIO_NUM_11;

constexpr gpio_num_t kTftMosi = GPIO_NUM_10;

constexpr gpio_num_t kTftMiso = GPIO_NUM_12;

constexpr gpio_num_t kTftCs = GPIO_NUM_4;

constexpr gpio_num_t kTftDc = GPIO_NUM_0;

constexpr gpio_num_t kTftReset = GPIO_NUM_5;

constexpr gpio_num_t kTftBacklight = GPIO_NUM_40;

constexpr int16_t kDisplayWidth = 320;

constexpr int16_t kDisplayHeight = 240;

constexpr int16_t kTransferChunkHeight = 10;

constexpr uint32_t kDisplaySpiFrequency = 20 * 1000 * 1000;

constexpr uint8_t kCo16Madctl = 0x68;  // MX | MV | BGR.

constexpr uint16_t kBlack = 0x0000;

constexpr uint16_t kBlue = 0x001F;

constexpr uint16_t kRed = 0xF800;

constexpr uint16_t kGreen = 0x07E0;

constexpr uint16_t kCyan = 0x07FF;

constexpr uint16_t kMagenta = 0xF81F;

constexpr uint16_t kYellow = 0xFFE0;

constexpr uint16_t kWhite = 0xFFFF;

class Co16St7789 : public Adafruit_GFX {

 public:

  Co16St7789() : Adafruit_GFX(kDisplayWidth, kDisplayHeight) {}

  bool begin() {

    gpio_reset_pin(kTftCs);

    gpio_set_direction(kTftCs, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftCs, 1);

    gpio_reset_pin(kTftDc);

    gpio_set_direction(kTftDc, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftDc, 1);

    gpio_reset_pin(kTftBacklight);

    gpio_set_direction(kTftBacklight, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftBacklight, 0);

    // SPI3 is initialized once by setup(); only the display uses it.

    esp_err_t err;

    spi_device_interface_config_t deviceConfig = {};

    deviceConfig.clock_speed_hz = kDisplaySpiFrequency;

    deviceConfig.mode = 0;

    deviceConfig.spics_io_num = -1;

    deviceConfig.queue_size = 1;

    err = spi_bus_add_device(SPI3_HOST, &deviceConfig, &spiDevice_);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI device setup failed: %s\n",

                    esp_err_to_name(err));

      return false;

    }

    drawBuffer_ = static_cast(heap_caps_malloc(

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t),

        MALLOC_CAP_DMA));

    if (drawBuffer_ == nullptr) {

      Serial.println("ST7789 DMA buffer allocation failed");

      return false;

    }

    // GPIO5 is shared with the optional LoRa module. Match the working KCS

    // firmware and issue one reset pulse before initializing the controller.

    gpio_reset_pin(kTftReset);

    gpio_set_direction(kTftReset, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftReset, 1);

    delay(1);

    gpio_set_level(kTftReset, 0);

    delay(1);

    gpio_set_level(kTftReset, 1);

    delay(10);

    if (!initializeController()) {

      return false;

    }

    fillScreen(kBlack);

    delay(120);

    if (!writeCommand(0x29)) {  // Display on.

      return false;

    }

    delay(120);

    gpio_set_level(kTftBacklight, 1);

    initialized_ = true;

    return true;

  }

  void drawPixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void writePixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void fillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                uint16_t color) override {

    if (x < 0) {

      width += x;

      x = 0;

    }

    if (y < 0) {

      height += y;

      y = 0;

    }

    if (x + width > kDisplayWidth) {

      width = kDisplayWidth - x;

    }

    if (y + height > kDisplayHeight) {

      height = kDisplayHeight - y;

    }

    if (drawBuffer_ == nullptr || width <= 0 || height <= 0) {

      return;

    }

    const uint8_t high = color >> 8;

    const uint8_t low = color;

    for (int16_t row = y; row < y + height;

         row += kTransferChunkHeight) {

      const int16_t chunkHeight =

          min(kTransferChunkHeight, y + height - row);

      const size_t pixelCount = width * chunkHeight;

      for (size_t index = 0; index < pixelCount; ++index) {

        drawBuffer_[index * 2] = high;

        drawBuffer_[index * 2 + 1] = low;

      }

      if (!setWindow(x, row, x + width, row + chunkHeight) ||

          !writePixels(drawBuffer_, pixelCount * sizeof(uint16_t))) {

        Serial.println("ST7789 pixel transfer failed");

        return;

      }

    }

  }

  void writeFillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                     uint16_t color) override {

    fillRect(x, y, width, height, color);

  }

  // Copy a fully rendered RGB565 frame into the DMA staging buffer.

  bool present(const uint16_t* pixels) {

    if (!initialized_ || pixels == nullptr) return false;

    for (int y = 0; y < kDisplayHeight; y += kTransferChunkHeight) {

      const int rows = min(kTransferChunkHeight, kDisplayHeight - y);

      const int count = kDisplayWidth * rows;

      for (int i = 0; i < count; ++i) {

        uint16_t c = pixels[y * kDisplayWidth + i];

        drawBuffer_[2 * i] = c >> 8;

        drawBuffer_[2 * i + 1] = c & 0xFF;

      }

      if (!setWindow(0, y, kDisplayWidth, y + rows) ||

          !writePixels(drawBuffer_, count * 2)) return false;

    }

    return true;

  }

  bool initialized() const { return initialized_; }

 private:

  bool transmit(const void* data, size_t length, int dcLevel) {

    if (data == nullptr || length == 0) {

      return true;

    }

    gpio_set_level(kTftDc, dcLevel);

    spi_transaction_t transaction = {};

    transaction.length = length * 8;

    transaction.tx_buffer = data;

    const esp_err_t err = spi_device_polling_transmit(spiDevice_, &transaction);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI transfer failed: %s\n", esp_err_to_name(err));

      return false;

    }

    return true;

  }

  bool writeCommand(uint8_t command) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool writeCommandData(uint8_t command, const uint8_t* data, size_t length) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool setWindow(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {

    const uint8_t columns[] = {

        static_cast(x1 >> 8), static_cast(x1),

        static_cast((x2 - 1) >> 8), static_cast(x2 - 1),

    };

    const uint8_t rows[] = {

        static_cast(y1 >> 8), static_cast(y1),

        static_cast((y2 - 1) >> 8), static_cast(y2 - 1),

    };

    return writeCommandData(0x2A, columns, sizeof(columns)) &&

           writeCommandData(0x2B, rows, sizeof(rows));

  }

  bool writePixels(const uint8_t* data, size_t length) {

    constexpr uint8_t kRamWrite = 0x2C;

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&kRamWrite, sizeof(kRamWrite), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool initializeController() {

    const uint8_t madctl[] = {kCo16Madctl};

    const uint8_t displayFunction[] = {0x0A, 0x82};

    const uint8_t pixelFormat[] = {0x55};

    const uint8_t porchControl[] = {0x0C, 0x0C, 0x00, 0x33, 0x33};

    const uint8_t gateControl[] = {0x35};

    const uint8_t vcom[] = {0x28};

    const uint8_t lcmControl[] = {0x0C};

    const uint8_t vdvVrhEnable[] = {0x01, 0xFF};

    const uint8_t vrh[] = {0x10};

    const uint8_t vdv[] = {0x20};

    const uint8_t frameRate[] = {0x0F};

    const uint8_t powerControl[] = {0xA4, 0xA1};

    const uint8_t positiveGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32,

        0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17,

    };

    const uint8_t negativeGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31,

        0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E,

    };

    if (!writeCommand(0x11)) {  // Sleep out.

      return false;

    }

    delay(120);

    return writeCommand(0x13) &&

           writeCommandData(0x36, madctl, sizeof(madctl)) &&

           writeCommandData(0xB6, displayFunction, sizeof(displayFunction)) &&

           writeCommandData(0x3A, pixelFormat, sizeof(pixelFormat)) &&

           (delay(10), true) &&

           writeCommandData(0xB2, porchControl, sizeof(porchControl)) &&

           writeCommandData(0xB7, gateControl, sizeof(gateControl)) &&

           writeCommandData(0xBB, vcom, sizeof(vcom)) &&

           writeCommandData(0xC0, lcmControl, sizeof(lcmControl)) &&

           writeCommandData(0xC2, vdvVrhEnable, sizeof(vdvVrhEnable)) &&

           writeCommandData(0xC3, vrh, sizeof(vrh)) &&

           writeCommandData(0xC4, vdv, sizeof(vdv)) &&

           writeCommandData(0xC6, frameRate, sizeof(frameRate)) &&

           writeCommandData(0xD0, powerControl, sizeof(powerControl)) &&

           writeCommandData(0xE0, positiveGamma, sizeof(positiveGamma)) &&

           writeCommandData(0xE1, negativeGamma, sizeof(negativeGamma)) &&

           writeCommand(0x21);  // Display inversion on.

  }

  spi_device_handle_t spiDevice_ = nullptr;

  uint8_t* drawBuffer_ = nullptr;

  bool initialized_ = false;

};

constexpr uint32_t VIDEO_FPS = 10;

constexpr uint32_t FRAME_INTERVAL_MS = 1000 / VIDEO_FPS;

static_assert(VIDEO_FPS > 0 && VIDEO_FPS <= 30, "Choose FPS between 1 and 30");

Co16St7789 display;

JPEGDEC jpeg;

uint16_t* frameBuffer = nullptr;

bool paused = false;

uint32_t frameCount = 0, reportStart = 0, reportFrames = 0;

void haltPlayer(const char* title, const char* hint) {

  Serial.printf("%s: %s\n", title, hint);

  if (display.initialized()) {

    display.fillScreen(kBlack);

    display.setTextWrap(true);

    display.setTextSize(2);

    display.setTextColor(kRed);

    display.setCursor(8, 30);

    display.print(title);

    display.setTextSize(1);

    display.setTextColor(kWhite);

    display.setCursor(8, 85);

    display.print(hint);

  }

  while (true) delay(1000);

}

void* allocateVideoMemory(size_t size) {

  void* p = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);

  if (!p) p = heap_caps_malloc(size, MALLOC_CAP_8BIT);

  return p;

}

int decodedPixels(JPEGDRAW* block) {

  if (!frameBuffer || !block || block->iBpp != 16 || block->x < 0 || block->y < 0)

    return 0;

  if (block->x >= 320 || block->y >= 240) return 0;

  int width = min(block->iWidthUsed, 320 - block->x);

  int height = min(block->iHeight, 240 - block->y);

  if (width <= 0 || height <= 0) return 0;

  for (int row = 0; row < height; ++row) {

    memcpy(frameBuffer + (block->y + row) * 320 + block->x,

           block->pPixels + row * block->iWidth, width * sizeof(uint16_t));

  }

  return 1;

}

void setup() {

  Serial.begin(115200);

  Wire.begin(8, 18);

  Wire.setClock(100000);

  Wire.setTimeOut(20);

  Wire.beginTransmission(0x22);

  Wire.write(uint8_t(0xFF));

  Wire.write(uint8_t(0xFF));

  if (Wire.endTransmission() != 0) Serial.println("Warning: relay OFF command not acknowledged.");

  // Keep unused SPI peripherals deselected. Remove the SD card for this demo.

  const int csPins[] = {4, 9, 13, 14, 42};

  for (int pin : csPins) { digitalWrite(pin, HIGH); pinMode(pin, OUTPUT); }

  pinMode(40, OUTPUT);

  digitalWrite(40, LOW);

  spi_bus_config_t bus = {};

  bus.sclk_io_num = 11;

  bus.mosi_io_num = 10;

  bus.miso_io_num = 12;

  bus.quadwp_io_num = -1;

  bus.quadhd_io_num = -1;

  bus.max_transfer_sz = 320 * kTransferChunkHeight * 2;

  esp_err_t err = spi_bus_initialize(SPI3_HOST, &bus, SPI_DMA_CH_AUTO);

  if (err != ESP_OK) haltPlayer("SPI init failed", esp_err_to_name(err));

  if (!display.begin()) haltPlayer("LCD init failed", "Check serial output and CO16 board selection.");

  display.setTextWrap(false);

  display.setTextSize(2);

  display.setTextColor(kCyan);

  display.setCursor(30, 90);

  display.print("KinCony MJPEG");

  display.setTextSize(1);

  display.setCursor(30, 122);

  display.print("Loading slogan video ...");

  frameBuffer = static_cast(allocateVideoMemory(320 * 240 * 2));

  if (!frameBuffer)

    haltPlayer("Not enough RAM", "Enable OPI PSRAM for ESP32-S3 N16R8 and upload again.");

  Serial.printf("Embedded video: %u bytes, %lu frames\n",

                unsigned(sizeof(kVideoData)), static_cast(kVideoFrameCount));

  reportStart = millis();

  Serial.println("Player ready. 10 fps target; p=pause/resume, r=restart.");

}

void loop() {

  while (Serial.available()) {

    char c = Serial.read();

    if (c == 'p') paused = !paused;

    if (c == 'r') {

      frameCount = 0;

      paused = false;

    }

  }

  if (paused) {

    reportStart = millis(); reportFrames = 0;

    delay(10); return;

  }

  uint32_t started = millis();

  if (frameCount >= kVideoFrameCount) frameCount = 0;

  uint32_t offset = kFrameOffsets[frameCount];

  uint32_t end = kFrameOffsets[frameCount + 1];

  if (end <= offset || end > sizeof(kVideoData))

    haltPlayer("Bad frame index", "Re-upload the complete firmware package.");

  if (!jpeg.openFLASH(kVideoData + offset, int(end - offset), decodedPixels))

    haltPlayer("JPEG open failed", "Check JPEGDEC library and embedded video data.");

  if (jpeg.getWidth() != 320 || jpeg.getHeight() != 240) {

    jpeg.close();

    haltPlayer("Wrong frame size", "Convert the video to exactly 320x240 pixels.");

  }

  jpeg.setPixelType(RGB565_LITTLE_ENDIAN);

  memset(frameBuffer, 0, 320 * 240 * 2);

  int decoded = jpeg.decode(0, 0, 0);

  int jpegError = jpeg.getLastError();

  jpeg.close();

  if (!decoded) {

    Serial.printf("JPEG decode error: %d\n", jpegError);

    haltPlayer("JPEG decode failed", "Check video integrity and JPEGDEC library.");

  }

  // Present the decoded full frame to the display.

  if (!display.present(frameBuffer)) haltPlayer("LCD write failed", "Check power and SPI connection.");

  ++frameCount;

  ++reportFrames;

  uint32_t elapsed = millis() - started;

  if (elapsed < FRAME_INTERVAL_MS) delay(FRAME_INTERVAL_MS - elapsed);

  else delay(1); // Yield; do not skip frames or run catch-up bursts.

  uint32_t now = millis();

  if (now - reportStart >= 5000) {

    Serial.printf("Playback %.1f fps, read/decode/display %lu ms, frame %lu\n",

                  reportFrames * 1000.0f / (now - reportStart),

                  static_cast(elapsed), static_cast(frameCount));

    reportStart = now; reportFrames = 0;

  }

}

arduino ino file download:

13-CO16_Flash_MJPEG_Player.zip (Size: 8.21 MB / Downloads: 4)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

13-CO16_Flash_MJPEG_Player.ino.merged.zip (Size: 1.05 MB / Downloads: 7)

[arduino code examples for CO16]-12 ST7789 TFT LCD image display

Tue, 03 Nov 2026 09:34:38 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 * CO16 Image Display - show the supplied photograph on the onboard LCD.

 * Target: ESP32-S3 CO16, ST7789 320x240 landscape.

 * Uses the display initialization from the validated CO16 Cyber Show sketch.

 * Install Adafruit GFX Library and its Adafruit BusIO dependency.

 * Select ESP32S3 Dev Module; retain your working CO16 board settings.

 * Keep image_data.h in the same folder as this sketch.

 * Image is stored in flash as RGB565; no SD card, JPEG decoder or Wi-Fi.

 * Full image is resized to 320x240 with no margins; aspect ratio changes.

 * PCF8575 relay outputs at 0x22 are commanded OFF at startup.

 */

#include 

#include 

#include "image_data.h"

#include 

#include 

#include 

#include 

// CO16 ST7789 (GMT020-02-7P) pin mapping from kcs_co16.h.

constexpr gpio_num_t kTftSclk = GPIO_NUM_11;

constexpr gpio_num_t kTftMosi = GPIO_NUM_10;

constexpr gpio_num_t kTftMiso = GPIO_NUM_12;

constexpr gpio_num_t kTftCs = GPIO_NUM_4;

constexpr gpio_num_t kTftDc = GPIO_NUM_0;

constexpr gpio_num_t kTftReset = GPIO_NUM_5;

constexpr gpio_num_t kTftBacklight = GPIO_NUM_40;

constexpr int16_t kDisplayWidth = 320;

constexpr int16_t kDisplayHeight = 240;

constexpr int16_t kTransferChunkHeight = 10;

constexpr uint32_t kDisplaySpiFrequency = 20 * 1000 * 1000;

constexpr uint8_t kCo16Madctl = 0x68;  // MX | MV | BGR.

constexpr uint16_t kBlack = 0x0000;

constexpr uint16_t kBlue = 0x001F;

constexpr uint16_t kRed = 0xF800;

constexpr uint16_t kGreen = 0x07E0;

constexpr uint16_t kCyan = 0x07FF;

constexpr uint16_t kMagenta = 0xF81F;

constexpr uint16_t kYellow = 0xFFE0;

constexpr uint16_t kWhite = 0xFFFF;

class Co16St7789 : public Adafruit_GFX {

 public:

  Co16St7789() : Adafruit_GFX(kDisplayWidth, kDisplayHeight) {}

  bool begin() {

    gpio_reset_pin(kTftCs);

    gpio_set_direction(kTftCs, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftCs, 1);

    gpio_reset_pin(kTftDc);

    gpio_set_direction(kTftDc, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftDc, 1);

    gpio_reset_pin(kTftBacklight);

    gpio_set_direction(kTftBacklight, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftBacklight, 0);

    spi_bus_config_t busConfig = {};

    busConfig.sclk_io_num = kTftSclk;

    busConfig.mosi_io_num = kTftMosi;

    busConfig.miso_io_num = kTftMiso;

    busConfig.quadwp_io_num = -1;

    busConfig.quadhd_io_num = -1;

    busConfig.max_transfer_sz =

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t);

    esp_err_t err =

        spi_bus_initialize(SPI3_HOST, &busConfig, SPI_DMA_CH_AUTO);

    if (err != ESP_OK) {

      Serial.printf("SPI3 initialization failed: %s\n", esp_err_to_name(err));

      return false;

    }

    spi_device_interface_config_t deviceConfig = {};

    deviceConfig.clock_speed_hz = kDisplaySpiFrequency;

    deviceConfig.mode = 0;

    deviceConfig.spics_io_num = -1;

    deviceConfig.queue_size = 1;

    err = spi_bus_add_device(SPI3_HOST, &deviceConfig, &spiDevice_);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI device setup failed: %s\n",

                    esp_err_to_name(err));

      return false;

    }

    drawBuffer_ = static_cast(heap_caps_malloc(

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t),

        MALLOC_CAP_DMA));

    if (drawBuffer_ == nullptr) {

      Serial.println("ST7789 DMA buffer allocation failed");

      return false;

    }

    // GPIO5 is shared with the optional LoRa module. Match the working KCS

    // firmware and issue one reset pulse before initializing the controller.

    gpio_reset_pin(kTftReset);

    gpio_set_direction(kTftReset, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftReset, 1);

    delay(1);

    gpio_set_level(kTftReset, 0);

    delay(1);

    gpio_set_level(kTftReset, 1);

    delay(10);

    if (!initializeController()) {

      return false;

    }

    fillScreen(kBlack);

    delay(120);

    if (!writeCommand(0x29)) {  // Display on.

      return false;

    }

    delay(120);

    gpio_set_level(kTftBacklight, 1);

    initialized_ = true;

    return true;

  }

  void drawPixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void writePixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void fillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                uint16_t color) override {

    if (x < 0) {

      width += x;

      x = 0;

    }

    if (y < 0) {

      height += y;

      y = 0;

    }

    if (x + width > kDisplayWidth) {

      width = kDisplayWidth - x;

    }

    if (y + height > kDisplayHeight) {

      height = kDisplayHeight - y;

    }

    if (drawBuffer_ == nullptr || width <= 0 || height <= 0) {

      return;

    }

    const uint8_t high = color >> 8;

    const uint8_t low = color;

    for (int16_t row = y; row < y + height;

         row += kTransferChunkHeight) {

      const int16_t chunkHeight =

          min(kTransferChunkHeight, y + height - row);

      const size_t pixelCount = width * chunkHeight;

      for (size_t index = 0; index < pixelCount; ++index) {

        drawBuffer_[index * 2] = high;

        drawBuffer_[index * 2 + 1] = low;

      }

      if (!setWindow(x, row, x + width, row + chunkHeight) ||

          !writePixels(drawBuffer_, pixelCount * sizeof(uint16_t))) {

        Serial.println("ST7789 pixel transfer failed");

        return;

      }

    }

  }

  void writeFillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                     uint16_t color) override {

    fillRect(x, y, width, height, color);

  }

  // Copy a fully rendered RGB565 frame into the DMA staging buffer.

  bool present(const uint16_t* pixels) {

    if (!initialized_ || pixels == nullptr) return false;

    for (int y = 0; y < kDisplayHeight; y += kTransferChunkHeight) {

      const int rows = min(kTransferChunkHeight, kDisplayHeight - y);

      const int count = kDisplayWidth * rows;

      for (int i = 0; i < count; ++i) {

        uint16_t c = pixels[y * kDisplayWidth + i];

        drawBuffer_[2 * i] = c >> 8;

        drawBuffer_[2 * i + 1] = c & 0xFF;

      }

      if (!setWindow(0, y, kDisplayWidth, y + rows) ||

          !writePixels(drawBuffer_, count * 2)) return false;

    }

    return true;

  }

  bool initialized() const { return initialized_; }

 private:

  bool transmit(const void* data, size_t length, int dcLevel) {

    if (data == nullptr || length == 0) {

      return true;

    }

    gpio_set_level(kTftDc, dcLevel);

    spi_transaction_t transaction = {};

    transaction.length = length * 8;

    transaction.tx_buffer = data;

    const esp_err_t err = spi_device_polling_transmit(spiDevice_, &transaction);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI transfer failed: %s\n", esp_err_to_name(err));

      return false;

    }

    return true;

  }

  bool writeCommand(uint8_t command) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool writeCommandData(uint8_t command, const uint8_t* data, size_t length) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool setWindow(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {

    const uint8_t columns[] = {

        static_cast(x1 >> 8), static_cast(x1),

        static_cast((x2 - 1) >> 8), static_cast(x2 - 1),

    };

    const uint8_t rows[] = {

        static_cast(y1 >> 8), static_cast(y1),

        static_cast((y2 - 1) >> 8), static_cast(y2 - 1),

    };

    return writeCommandData(0x2A, columns, sizeof(columns)) &&

           writeCommandData(0x2B, rows, sizeof(rows));

  }

  bool writePixels(const uint8_t* data, size_t length) {

    constexpr uint8_t kRamWrite = 0x2C;

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&kRamWrite, sizeof(kRamWrite), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool initializeController() {

    const uint8_t madctl[] = {kCo16Madctl};

    const uint8_t displayFunction[] = {0x0A, 0x82};

    const uint8_t pixelFormat[] = {0x55};

    const uint8_t porchControl[] = {0x0C, 0x0C, 0x00, 0x33, 0x33};

    const uint8_t gateControl[] = {0x35};

    const uint8_t vcom[] = {0x28};

    const uint8_t lcmControl[] = {0x0C};

    const uint8_t vdvVrhEnable[] = {0x01, 0xFF};

    const uint8_t vrh[] = {0x10};

    const uint8_t vdv[] = {0x20};

    const uint8_t frameRate[] = {0x0F};

    const uint8_t powerControl[] = {0xA4, 0xA1};

    const uint8_t positiveGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32,

        0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17,

    };

    const uint8_t negativeGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31,

        0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E,

    };

    if (!writeCommand(0x11)) {  // Sleep out.

      return false;

    }

    delay(120);

    return writeCommand(0x13) &&

           writeCommandData(0x36, madctl, sizeof(madctl)) &&

           writeCommandData(0xB6, displayFunction, sizeof(displayFunction)) &&

           writeCommandData(0x3A, pixelFormat, sizeof(pixelFormat)) &&

           (delay(10), true) &&

           writeCommandData(0xB2, porchControl, sizeof(porchControl)) &&

           writeCommandData(0xB7, gateControl, sizeof(gateControl)) &&

           writeCommandData(0xBB, vcom, sizeof(vcom)) &&

           writeCommandData(0xC0, lcmControl, sizeof(lcmControl)) &&

           writeCommandData(0xC2, vdvVrhEnable, sizeof(vdvVrhEnable)) &&

           writeCommandData(0xC3, vrh, sizeof(vrh)) &&

           writeCommandData(0xC4, vdv, sizeof(vdv)) &&

           writeCommandData(0xC6, frameRate, sizeof(frameRate)) &&

           writeCommandData(0xD0, powerControl, sizeof(powerControl)) &&

           writeCommandData(0xE0, positiveGamma, sizeof(positiveGamma)) &&

           writeCommandData(0xE1, negativeGamma, sizeof(negativeGamma)) &&

           writeCommand(0x21);  // Display inversion on.

  }

  spi_device_handle_t spiDevice_ = nullptr;

  uint8_t* drawBuffer_ = nullptr;

  bool initialized_ = false;

};

Co16St7789 display;

void setup() {

  Serial.begin(115200);

  Wire.begin(8, 18);

  Wire.setClock(100000);

  Wire.setTimeOut(20);

  // Active-low PCF8575 relay outputs: HIGH on all channels means OFF.

  Wire.beginTransmission(0x22);

  Wire.write(uint8_t(0xFF));

  Wire.write(uint8_t(0xFF));

  if (Wire.endTransmission() != 0) {

    Serial.println("Warning: relay OFF command not acknowledged at 0x22.");

  }

  // Deselect all other SPI peripherals before initializing the LCD bus.

  const int inactiveCs[] = {9, 13, 14, 42};

  for (int pin : inactiveCs) {

    digitalWrite(pin, HIGH);

    pinMode(pin, OUTPUT);

  }

  if (!display.begin()) {

    Serial.println("ST7789 initialization failed.");

    while (true) delay(1000);

  }

  // ESP32 flash is memory mapped. present() reads the constant image into

  // a small DMA-capable staging buffer, then sends it to the ST7789.

  if (!display.present(kImageRgb565)) {

    Serial.println("Image transfer failed.");

    while (true) delay(1000);

  }

  Serial.println("Image displayed: 320x240 RGB565, full-screen image.");

}

void loop() {

  // The LCD retains its image; no continuous redraw is necessary.

  delay(1000);

}

arduino ino file download:

  12-CO16_Image_Display.zip (Size: 729.92 KB / Downloads: 9)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

  12-CO16_Image_Display.ino.merged.zip (Size: 273.66 KB / Downloads: 8)

  CO16-image-1.jpg (Size: 262.26 KB / Downloads: 16)

  CO16-image-2.jpg (Size: 259.66 KB / Downloads: 19)

[arduino code examples for CO16]-11 ST7789 TFT LCD Cyber Show With Relay

Tue, 03 Nov 2026 08:15:17 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 * CO16 CYBER SHOW - standalone Shorts demo, 32-second automatic loop.

 * Target: ESP32-S3, CO16 with PCF8575 relay outputs at 0x22.

 * Display: 320x240 ST7789; native SPI3 initialization from CO16-pcb-test.ino.

 * Install Adafruit GFX Library and its Adafruit BusIO dependency.

 * Board: ESP32S3 Dev Module; retain the settings used for the factory sketch.

 * No PCF8575, Ethernet, SD, RTC or ADC libraries required.

 *

 * IMPORTANT: disconnect all loads from relay terminals before filming.

 * These are mechanical relays: use this as a short filming demo, not a

 * continuous endurance test. The graphics are synthetic, not sensor data.

 * Relay tiles show acknowledged output commands, NOT contact feedback.

 *

 * Serial Monitor, 115200 baud (no line ending needed):

 *   0 = automatic show from beginning; 1..5 = hold a scene

 *   p = pause/resume (pause switches relays OFF); r = restart auto show

 *   x = disable relay motion; e = enable relay motion

 * Frame rendering uses 153600 bytes of RAM plus a 6400-byte DMA buffer.

 * No EEPROM writes, networking, SD operations or other peripheral tests.

 */

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

// CO16 ST7789 (GMT020-02-7P) pin mapping from kcs_co16.h.

constexpr gpio_num_t kTftSclk = GPIO_NUM_11;

constexpr gpio_num_t kTftMosi = GPIO_NUM_10;

constexpr gpio_num_t kTftMiso = GPIO_NUM_12;

constexpr gpio_num_t kTftCs = GPIO_NUM_4;

constexpr gpio_num_t kTftDc = GPIO_NUM_0;

constexpr gpio_num_t kTftReset = GPIO_NUM_5;

constexpr gpio_num_t kTftBacklight = GPIO_NUM_40;

constexpr int16_t kDisplayWidth = 320;

constexpr int16_t kDisplayHeight = 240;

constexpr int16_t kTransferChunkHeight = 10;

constexpr uint32_t kDisplaySpiFrequency = 20 * 1000 * 1000;

constexpr uint8_t kCo16Madctl = 0x68;  // MX | MV | BGR.

constexpr uint16_t kBlack = 0x0000;

constexpr uint16_t kBlue = 0x001F;

constexpr uint16_t kRed = 0xF800;

constexpr uint16_t kGreen = 0x07E0;

constexpr uint16_t kCyan = 0x07FF;

constexpr uint16_t kMagenta = 0xF81F;

constexpr uint16_t kYellow = 0xFFE0;

constexpr uint16_t kWhite = 0xFFFF;

class Co16St7789 : public Adafruit_GFX {

 public:

  Co16St7789() : Adafruit_GFX(kDisplayWidth, kDisplayHeight) {}

  bool begin() {

    gpio_reset_pin(kTftCs);

    gpio_set_direction(kTftCs, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftCs, 1);

    gpio_reset_pin(kTftDc);

    gpio_set_direction(kTftDc, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftDc, 1);

    gpio_reset_pin(kTftBacklight);

    gpio_set_direction(kTftBacklight, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftBacklight, 0);

    spi_bus_config_t busConfig = {};

    busConfig.sclk_io_num = kTftSclk;

    busConfig.mosi_io_num = kTftMosi;

    busConfig.miso_io_num = kTftMiso;

    busConfig.quadwp_io_num = -1;

    busConfig.quadhd_io_num = -1;

    busConfig.max_transfer_sz =

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t);

    esp_err_t err =

        spi_bus_initialize(SPI3_HOST, &busConfig, SPI_DMA_CH_AUTO);

    if (err != ESP_OK) {

      Serial.printf("SPI3 initialization failed: %s\n", esp_err_to_name(err));

      return false;

    }

    spi_device_interface_config_t deviceConfig = {};

    deviceConfig.clock_speed_hz = kDisplaySpiFrequency;

    deviceConfig.mode = 0;

    deviceConfig.spics_io_num = -1;

    deviceConfig.queue_size = 1;

    err = spi_bus_add_device(SPI3_HOST, &deviceConfig, &spiDevice_);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI device setup failed: %s\n",

                    esp_err_to_name(err));

      return false;

    }

    drawBuffer_ = static_cast(heap_caps_malloc(

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t),

        MALLOC_CAP_DMA));

    if (drawBuffer_ == nullptr) {

      Serial.println("ST7789 DMA buffer allocation failed");

      return false;

    }

    // GPIO5 is shared with the optional LoRa module. Match the working KCS

    // firmware and issue one reset pulse before initializing the controller.

    gpio_reset_pin(kTftReset);

    gpio_set_direction(kTftReset, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftReset, 1);

    delay(1);

    gpio_set_level(kTftReset, 0);

    delay(1);

    gpio_set_level(kTftReset, 1);

    delay(10);

    if (!initializeController()) {

      return false;

    }

    fillScreen(kBlack);

    delay(120);

    if (!writeCommand(0x29)) {  // Display on.

      return false;

    }

    delay(120);

    gpio_set_level(kTftBacklight, 1);

    initialized_ = true;

    return true;

  }

  void drawPixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void writePixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void fillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                uint16_t color) override {

    if (x < 0) {

      width += x;

      x = 0;

    }

    if (y < 0) {

      height += y;

      y = 0;

    }

    if (x + width > kDisplayWidth) {

      width = kDisplayWidth - x;

    }

    if (y + height > kDisplayHeight) {

      height = kDisplayHeight - y;

    }

    if (drawBuffer_ == nullptr || width <= 0 || height <= 0) {

      return;

    }

    const uint8_t high = color >> 8;

    const uint8_t low = color;

    for (int16_t row = y; row < y + height;

         row += kTransferChunkHeight) {

      const int16_t chunkHeight =

          min(kTransferChunkHeight, y + height - row);

      const size_t pixelCount = width * chunkHeight;

      for (size_t index = 0; index < pixelCount; ++index) {

        drawBuffer_[index * 2] = high;

        drawBuffer_[index * 2 + 1] = low;

      }

      if (!setWindow(x, row, x + width, row + chunkHeight) ||

          !writePixels(drawBuffer_, pixelCount * sizeof(uint16_t))) {

        Serial.println("ST7789 pixel transfer failed");

        return;

      }

    }

  }

  void writeFillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                     uint16_t color) override {

    fillRect(x, y, width, height, color);

  }

  // Copy a fully rendered RGB565 frame into the DMA staging buffer.

  bool present(const uint16_t* pixels) {

    if (!initialized_ || pixels == nullptr) return false;

    for (int y = 0; y < kDisplayHeight; y += kTransferChunkHeight) {

      const int rows = min(kTransferChunkHeight, kDisplayHeight - y);

      const int count = kDisplayWidth * rows;

      for (int i = 0; i < count; ++i) {

        uint16_t c = pixels[y * kDisplayWidth + i];

        drawBuffer_[2 * i] = c >> 8;

        drawBuffer_[2 * i + 1] = c & 0xFF;

      }

      if (!setWindow(0, y, kDisplayWidth, y + rows) ||

          !writePixels(drawBuffer_, count * 2)) return false;

    }

    return true;

  }

  bool initialized() const { return initialized_; }

 private:

  bool transmit(const void* data, size_t length, int dcLevel) {

    if (data == nullptr || length == 0) {

      return true;

    }

    gpio_set_level(kTftDc, dcLevel);

    spi_transaction_t transaction = {};

    transaction.length = length * 8;

    transaction.tx_buffer = data;

    const esp_err_t err = spi_device_polling_transmit(spiDevice_, &transaction);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI transfer failed: %s\n", esp_err_to_name(err));

      return false;

    }

    return true;

  }

  bool writeCommand(uint8_t command) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool writeCommandData(uint8_t command, const uint8_t* data, size_t length) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool setWindow(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {

    const uint8_t columns[] = {

        static_cast(x1 >> 8), static_cast(x1),

        static_cast((x2 - 1) >> 8), static_cast(x2 - 1),

    };

    const uint8_t rows[] = {

        static_cast(y1 >> 8), static_cast(y1),

        static_cast((y2 - 1) >> 8), static_cast(y2 - 1),

    };

    return writeCommandData(0x2A, columns, sizeof(columns)) &&

           writeCommandData(0x2B, rows, sizeof(rows));

  }

  bool writePixels(const uint8_t* data, size_t length) {

    constexpr uint8_t kRamWrite = 0x2C;

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&kRamWrite, sizeof(kRamWrite), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool initializeController() {

    const uint8_t madctl[] = {kCo16Madctl};

    const uint8_t displayFunction[] = {0x0A, 0x82};

    const uint8_t pixelFormat[] = {0x55};

    const uint8_t porchControl[] = {0x0C, 0x0C, 0x00, 0x33, 0x33};

    const uint8_t gateControl[] = {0x35};

    const uint8_t vcom[] = {0x28};

    const uint8_t lcmControl[] = {0x0C};

    const uint8_t vdvVrhEnable[] = {0x01, 0xFF};

    const uint8_t vrh[] = {0x10};

    const uint8_t vdv[] = {0x20};

    const uint8_t frameRate[] = {0x0F};

    const uint8_t powerControl[] = {0xA4, 0xA1};

    const uint8_t positiveGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32,

        0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17,

    };

    const uint8_t negativeGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31,

        0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E,

    };

    if (!writeCommand(0x11)) {  // Sleep out.

      return false;

    }

    delay(120);

    return writeCommand(0x13) &&

           writeCommandData(0x36, madctl, sizeof(madctl)) &&

           writeCommandData(0xB6, displayFunction, sizeof(displayFunction)) &&

           writeCommandData(0x3A, pixelFormat, sizeof(pixelFormat)) &&

           (delay(10), true) &&

           writeCommandData(0xB2, porchControl, sizeof(porchControl)) &&

           writeCommandData(0xB7, gateControl, sizeof(gateControl)) &&

           writeCommandData(0xBB, vcom, sizeof(vcom)) &&

           writeCommandData(0xC0, lcmControl, sizeof(lcmControl)) &&

           writeCommandData(0xC2, vdvVrhEnable, sizeof(vdvVrhEnable)) &&

           writeCommandData(0xC3, vrh, sizeof(vrh)) &&

           writeCommandData(0xC4, vdv, sizeof(vdv)) &&

           writeCommandData(0xC6, frameRate, sizeof(frameRate)) &&

           writeCommandData(0xD0, powerControl, sizeof(powerControl)) &&

           writeCommandData(0xE0, positiveGamma, sizeof(positiveGamma)) &&

           writeCommandData(0xE1, negativeGamma, sizeof(negativeGamma)) &&

           writeCommand(0x21);  // Display inversion on.

  }

  spi_device_handle_t spiDevice_ = nullptr;

  uint8_t* drawBuffer_ = nullptr;

  bool initialized_ = false;

};

Co16St7789 display;

GFXcanvas16 canvas(320, 240);

constexpr uint32_t FRAME_MS = 80;   // Target ~12.5 FPS; actual rate depends on SPI.

constexpr uint32_t RELAY_STEP_MS = 250;

constexpr uint32_t SHOW_MS = 32000;

constexpr uint8_t RELAY_ADDRESS = 0x22;

constexpr float TAU = 6.28318530718f;

constexpr uint16_t BG = 0x0001, GRID = 0x0843, CYAN = 0x07FF;

constexpr uint16_t PINK = 0xF81F, WHITE = 0xFFFF, DIM = 0x5B6D;

constexpr uint16_t GREEN = 0x07E0, GOLD = 0xFDE0;

const char* const SCENE_NAMES[] = {

  "SYSTEM BOOT", "RELAY RADAR", "ENERGY CORE", "BEAT MATRIX", "ONE BRAIN"

};

uint32_t showTime = 0, lastTick = 0, lastFrame = 0, lastRelay = 0;

uint16_t relayMask = 0;

bool relayEnabled = true, paused = false, relayFault = false;

int manualScene = -1;

// A single two-byte write changes all 16 PCF8575 outputs together.

// P0 is channel 1. HIGH = OFF, LOW = ON, as in the supplied test.

bool writeRelays(uint16_t mask) {

  uint16_t raw = uint16_t(~mask);

  Wire.beginTransmission(RELAY_ADDRESS);

  Wire.write(uint8_t(raw));

  Wire.write(uint8_t(raw >> 8));

  bool ok = Wire.endTransmission() == 0;

  if (ok) relayMask = mask;

  return ok;

}

uint16_t channelBit(int i) { return uint16_t(1u << (i & 15)); }

int sceneAt(uint32_t t) {

  if (t < 4000) return 0;

  if (t < 12000) return 1;

  if (t < 20000) return 2;

  if (t < 28000) return 3;

  return 4;

}

uint32_t sceneStart(int s) {

  const uint32_t starts[] = {0, 4000, 12000, 20000, 28000};

  return starts[s];

}

uint16_t patternFor(int s, uint32_t t) {

  uint32_t step = t / RELAY_STEP_MS;

  switch (s) {

    case 0: return channelBit(step % 16);

    case 1: return channelBit(step % 16);

    case 2: {

      int p = step % 14;

      if (p > 7) p = 14 - p;

      return channelBit(p) | channelBit(15 - p);

    }

    case 3: {

      const uint16_t beats[] = {0x1111, 0, 0x2222, 0, 0x4444, 0, 0x8888, 0};

      return beats[step % 8];

    }

    default: return t < 3000 ? channelBit(15 - (step % 16)) : 0;

  }

}

void label(int x, int y, const char* text, int size, uint16_t color) {

  canvas.setTextSize(size);

  canvas.setTextColor(color);

  canvas.setCursor(x, y);

  canvas.print(text);

}

void center(int y, const char* text, int size, uint16_t color) {

  label((320 - int(strlen(text)) * 6 * size) / 2, y, text, size, color);

}

void background(uint32_t t) {

  canvas.fillScreen(BG);

  for (int x = 0; x < 320; x += 20) canvas.drawFastVLine(x, 30, 158, GRID);

  for (int y = 30; y < 188; y += 20) canvas.drawFastHLine(0, y, 320, GRID);

  // Deterministic drifting stars, without allocations or random-state changes.

  for (int i = 0; i < 36; ++i) {

    int x = (i * 73 + t / (15 + i % 7)) % 320;

    int y = 34 + (i * 47) % 149;

    canvas.drawPixel(x, y, i % 3 ? DIM : CYAN);

  }

}

void drawBoot(uint32_t t) {

  center(42, "KinCony", 4, CYAN);

  center(80, "CO16", 3, WHITE);

  center(112, "INITIALIZING THE SHOW", 1, DIM);

  canvas.drawRoundRect(36, 132, 248, 18, 4, CYAN);

  int progress = int((t % 4000) * 242 / 3999);

  canvas.fillRect(39, 135, progress, 12, PINK);

  char line[32];

  snprintf(line, sizeof(line), "16 CHANNELS / %02lu%%", (unsigned long)((t % 4000) * 100 / 3999));

  center(163, line, 1, WHITE);

}

void drawRadar(uint32_t t) {

  const int cx = 96, cy = 108;

  for (int r = 20; r <= 64; r += 22) canvas.drawCircle(cx, cy, r, 0x0329);

  canvas.drawFastHLine(29, cy, 135, 0x0329);

  canvas.drawFastVLine(cx, 41, 135, 0x0329);

  float angle = (t % 4000) * TAU / 4000.0f - TAU / 4;

  for (int j = 12; j >= 0; --j) {

    float a = angle - j * 0.035f;

    canvas.drawLine(cx, cy, cx + int(cosf(a) * 63), cy + int(sinf(a) * 63),

                    j == 0 ? CYAN : uint16_t((12 - j + 3) << 5));

  }

  for (int i = 0; i < 16; ++i) {

    float a = i * TAU / 16 - TAU / 4;

    int x = cx + int(cosf(a) * 54), y = cy + int(sinf(a) * 54);

    bool on = relayMask & channelBit(i);

    canvas.fillCircle(x, y, on ? 5 : 2, on ? GOLD : DIM);

    if (on) canvas.drawCircle(x, y, 8, CYAN);

  }

  label(181, 51, "SCAN", 3, CYAN);

  label(182, 83, "16 RELAY NODES", 1, WHITE);

  char buf[16];

  snprintf(buf, sizeof(buf), "CH %02lu", (unsigned long)((t / RELAY_STEP_MS) % 16 + 1));

  label(182, 110, buf, 2, GOLD);

  label(182, 144, "COMMAND TRACKER", 1, DIM);

  label(182, 160, "250ms / STEP", 1, DIM);

}

void drawCore(uint32_t t) {

  float phase = t * 0.002f;

  for (int i = 0; i < 4; ++i) {

    int r = 24 + i * 13;

    for (int k = 0; k < 46; ++k) {

      float a = phase * (i % 2 ? -1 : 1) + k * TAU / 60;

      float b = a + TAU / 65;

      canvas.drawLine(160 + int(cosf(a) * r), 109 + int(sinf(a) * r),

                      160 + int(cosf(b) * r), 109 + int(sinf(b) * r), i % 2 ? PINK : CYAN);

    }

  }

  canvas.fillCircle(160, 109, 18 + int(3 * sinf(phase * 3)), 0x0410);

  label(148, 102, "16", 2, WHITE);

  for (int i = 0; i < 8; ++i) {

    int h = 5 + int((sinf(phase * 2 + i * 0.6f) + 1) * 24);

    canvas.fillRect(14 + i * 6, 139 - h, 4, h, CYAN);

    canvas.fillRect(260 + i * 6, 139 - h, 4, h, PINK);

  }

  label(12, 155, "CH 1-8", 1, DIM);

  label(255, 155, "CH 9-16", 1, DIM);

  center(176, "DUAL-WAVE SYNCHRONIZATION", 1, WHITE);

}

void drawBeat(uint32_t t) {

  // Synthetic frequency bars. No microphone, FFT, or audio synchronization.

  float phase = t * 0.004f;

  for (int i = 0; i < 16; ++i) {

    float v = (sinf(phase + i * 0.67f) + sinf(phase * 0.63f - i * 0.41f) + 2) / 4;

    int levels = 2 + int(v * 14);

    for (int j = 0; j < levels; ++j)

      canvas.fillRect(9 + i * 19, 166 - j * 6, 13, 4, j > 11 ? PINK : (j > 6 ? CYAN : 0x0410));

  }

  center(43, "BEAT MATRIX", 2, WHITE);

  center(65, "120 BPM / SYNTHETIC VISUALIZER", 1, DIM);

  canvas.fillCircle(299, 45, 4, (t % 500 < 250) ? GOLD : DIM);

}

void drawFinale(uint32_t t) {

  for (int i = 0; i < 32; ++i) {

    float a = i * TAU / 32;

    int r = 20 + (int(t / 12) + i * 17) % 130;

    canvas.drawLine(160 + int(cosf(a) * r), 108 + int(sinf(a) * r * 0.50f),

                    160 + int(cosf(a) * (r + 7)), 108 + int(sinf(a) * (r + 7) * 0.50f), GRID);

  }

  center(56, "16 CHANNELS", 3, CYAN);

  center(94, "ONE BRAIN.", 3, WHITE);

  center(136, "KinCony CO16 / ESP32-S3", 1, PINK);

  center(165, "www.kincony.com", 1, DIM);

}

void render(int scene, uint32_t t) {

  background(t);

  switch (scene) {

    case 0: drawBoot(t); break;

    case 1: drawRadar(t); break;

    case 2: drawCore(t); break;

    case 3: drawBeat(t); break;

    default: drawFinale(t); break;

  }

  canvas.fillRect(0, 0, 320, 29, BG);

  label(8, 9, "CO16", 2, CYAN);

  label(80, 12, SCENE_NAMES[scene], 1, WHITE);

  label(271, 12, manualScene < 0 ? "AUTO" : "HOLD", 1, PINK);

  canvas.drawFastHLine(8, 28, 304, CYAN);

  // Two rows of numbered output tiles, all drawn from the last ACKed command.

  canvas.fillRect(0, 190, 320, 50, BG);

  for (int i = 0; i < 16; ++i) {

    int x = 8 + (i % 8) * 39, y = 191 + (i / 8) * 18;

    bool on = relayMask & channelBit(i);

    canvas.fillRoundRect(x, y, 32, 15, 3, on ? CYAN : GRID);

    char number[4];

    snprintf(number, sizeof(number), "%02d", i + 1);

    label(x + 10, y + 4, number, 1, on ? BG : DIM);

  }

  const char* status = relayFault ? "I2C ERROR / OUTPUT UNKNOWN" :

    paused ? "PAUSED / RELAYS OFF" : !relayEnabled ? "SCREEN ONLY / RELAYS OFF" : "RELAY COMMANDS / VISUAL DEMO";

  center(231, status, 1, relayFault ? GOLD : DIM);

  if (!display.present(canvas.getBuffer())) {

    writeRelays(0);

    Serial.println("Display transfer failed. Demo halted; OFF command attempted.");

    while (true) { writeRelays(0); delay(1000); }

  }

}

void handleSerial() {

  while (Serial.available()) {

    char c = Serial.read();

    if (c == 'p') paused = !paused;

    if (c == 'x') relayEnabled = false;

    if (c == 'e') relayEnabled = true;

    if (c == '0' || c == 'r') { manualScene = -1; showTime = 0; paused = false; }

    if (c >= '1' && c <= '5') { manualScene = c - '1'; showTime = 0; paused = false; }

    if (c == 'p' || c == 'x' || c == '0' || c == 'r' || (c >= '1' && c <= '5')) {

      if (!writeRelays(0)) relayFault = true;

      lastRelay = millis();

    }

  }

}

void setup() {

  Serial.begin(115200);

  Wire.begin(8, 18);

  Wire.setClock(100000);

  Wire.setTimeOut(20);

  relayFault = !writeRelays(0);

  // Deselect other devices sharing the TFT wires BEFORE enabling SPI3.

  // Do not initialize SD, LoRa, or software SPI on this bus in this demo.

  const int inactiveCs[] = {9, 13, 14, 42};

  for (int pin : inactiveCs) { digitalWrite(pin, HIGH); pinMode(pin, OUTPUT); }

  if (!canvas.getBuffer() || !display.begin()) {

    Serial.println("Display/buffer initialization failed. Demo halted.");

    while (true) { writeRelays(0); delay(1000); }

  }

  canvas.setTextWrap(false);

  Serial.println("CO16 CYBER SHOW: 0=auto 1..5=scene p=pause x=relays off e=relays on r=restart");

  lastTick = lastRelay = millis();

}

void loop() {

  handleSerial();

  uint32_t now = millis();

  uint32_t dt = now - lastTick;

  lastTick = now;

  if (!paused) showTime = (showTime + dt) % SHOW_MS;

  int scene = manualScene < 0 ? sceneAt(showTime) : manualScene;

  uint32_t localTime = manualScene < 0 ? showTime - sceneStart(scene) : showTime;

  // Limit real relay updates independently of display rendering.

  if (now - lastRelay >= RELAY_STEP_MS) {

    lastRelay = now;

    uint16_t wanted = (paused || !relayEnabled || relayFault) ? 0 : patternFor(scene, localTime);

    if (relayFault || wanted != relayMask) {

      if (!writeRelays(wanted)) {

        relayFault = true;  // Latched until reset. Retry OFF, never resume motion.

        Serial.println("Relay I2C error: motion disabled; retrying OFF.");

        writeRelays(0);

      }

    }

  }

  if (now - lastFrame >= FRAME_MS) {

    lastFrame = now;

    render(scene, localTime);

  }

  delay(1);

}

arduino ino file download:
[attachment=10732]
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

  11-CO16_Cyber_Show.ino.merged.zip (Size: 218.48 KB / Downloads: 9)

  CO16_Cyber_Show-1.JPG (Size: 347.55 KB / Downloads: 19)

  CO16_Cyber_Show-2.JPG (Size: 486.6 KB / Downloads: 21)

  CO16_Cyber_Show-3.JPG (Size: 553.72 KB / Downloads: 20)

  CO16_Cyber_Show-4.JPG (Size: 371.06 KB / Downloads: 20)

  CO16_Cyber_Show-5.JPG (Size: 381.15 KB / Downloads: 19)

Questions on CO16

Sun, 13 Sep 2026 17:38:48 +0800

Hi,

I have several questions on CO16 that I would like to use to replace my alarm system :-)

1/ Are there free GPIO that can be accessed (I need to add Wiegand input)
2/ Is there a socket to expand I2C bus ?
3/ Which GPIO are used for KNX ?
4/ With ESPHome can we send KNX messages from CO16
5/ Regarding the SIM7600E expansion, what is the wiring (I already have such a module and I would like to know if it will be compatible)
6/ Any idea on how to generate sound for a remote loundspeaker (the one that tells alarm in service / door left open / ....) ?
7/ Is there any electronic between GPIO38/39 and RS485 socket ?

Regards
Philippe

KNX ETS software project file for CO16

Tue, 08 Sep 2026 11:44:37 +0800

  KNX-test.jpg (Size: 191.09 KB / Downloads: 129)

  ETS.png (Size: 163.54 KB / Downloads: 143)
ETS project download:

  CO16.zip (Size: 103.09 KB / Downloads: 126)

[arduino code examples for CO16]-10 ST7789 TFT color display

Mon, 31 Aug 2026 08:16:23 +0800

Code:
#include 

#include 

#include 

#include 

namespace {

// CO16 ST7789 (GMT020-02-7P) pin mapping from kcs_co16.h.

constexpr gpio_num_t kTftSclk = GPIO_NUM_11;

constexpr gpio_num_t kTftMosi = GPIO_NUM_10;

constexpr gpio_num_t kTftMiso = GPIO_NUM_12;

constexpr gpio_num_t kTftCs = GPIO_NUM_4;

constexpr gpio_num_t kTftDc = GPIO_NUM_0;

constexpr gpio_num_t kTftReset = GPIO_NUM_5;

constexpr gpio_num_t kTftBacklight = GPIO_NUM_40;

constexpr int16_t kDisplayWidth = 320;

constexpr int16_t kDisplayHeight = 240;

constexpr int16_t kTransferChunkHeight = 10;

constexpr uint32_t kDisplaySpiFrequency = 20 * 1000 * 1000;

constexpr uint8_t kCo16Madctl = 0x68;  // MX | MV | BGR.

constexpr uint16_t kBlack = 0x0000;

constexpr uint16_t kBlue = 0x001F;

constexpr uint16_t kRed = 0xF800;

constexpr uint16_t kGreen = 0x07E0;

constexpr uint16_t kCyan = 0x07FF;

constexpr uint16_t kMagenta = 0xF81F;

constexpr uint16_t kYellow = 0xFFE0;

constexpr uint16_t kWhite = 0xFFFF;

class Co16St7789 : public Adafruit_GFX {

 public:

  Co16St7789() : Adafruit_GFX(kDisplayWidth, kDisplayHeight) {}

  bool begin() {

    gpio_reset_pin(kTftCs);

    gpio_set_direction(kTftCs, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftCs, 1);

    gpio_reset_pin(kTftDc);

    gpio_set_direction(kTftDc, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftDc, 1);

    gpio_reset_pin(kTftBacklight);

    gpio_set_direction(kTftBacklight, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftBacklight, 0);

    spi_bus_config_t busConfig = {};

    busConfig.sclk_io_num = kTftSclk;

    busConfig.mosi_io_num = kTftMosi;

    busConfig.miso_io_num = kTftMiso;

    busConfig.quadwp_io_num = -1;

    busConfig.quadhd_io_num = -1;

    busConfig.max_transfer_sz =

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t);

    esp_err_t err =

        spi_bus_initialize(SPI3_HOST, &busConfig, SPI_DMA_CH_AUTO);

    if (err != ESP_OK) {

      Serial.printf("SPI3 initialization failed: %s\n", esp_err_to_name(err));

      return false;

    }

    spi_device_interface_config_t deviceConfig = {};

    deviceConfig.clock_speed_hz = kDisplaySpiFrequency;

    deviceConfig.mode = 0;

    deviceConfig.spics_io_num = -1;

    deviceConfig.queue_size = 1;

    err = spi_bus_add_device(SPI3_HOST, &deviceConfig, &spiDevice_);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI device setup failed: %s\n",

                    esp_err_to_name(err));

      return false;

    }

    drawBuffer_ = static_cast(heap_caps_malloc(

        kDisplayWidth * kTransferChunkHeight * sizeof(uint16_t),

        MALLOC_CAP_DMA));

    if (drawBuffer_ == nullptr) {

      Serial.println("ST7789 DMA buffer allocation failed");

      return false;

    }

    // GPIO5 is shared with the optional LoRa module. Match the working KCS

    // firmware and issue one reset pulse before initializing the controller.

    gpio_reset_pin(kTftReset);

    gpio_set_direction(kTftReset, GPIO_MODE_OUTPUT);

    gpio_set_level(kTftReset, 1);

    delay(1);

    gpio_set_level(kTftReset, 0);

    delay(1);

    gpio_set_level(kTftReset, 1);

    delay(10);

    if (!initializeController()) {

      return false;

    }

    fillScreen(kBlack);

    delay(120);

    if (!writeCommand(0x29)) {  // Display on.

      return false;

    }

    delay(120);

    gpio_set_level(kTftBacklight, 1);

    initialized_ = true;

    return true;

  }

  void drawPixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void writePixel(int16_t x, int16_t y, uint16_t color) override {

    fillRect(x, y, 1, 1, color);

  }

  void fillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                uint16_t color) override {

    if (x < 0) {

      width += x;

      x = 0;

    }

    if (y < 0) {

      height += y;

      y = 0;

    }

    if (x + width > kDisplayWidth) {

      width = kDisplayWidth - x;

    }

    if (y + height > kDisplayHeight) {

      height = kDisplayHeight - y;

    }

    if (drawBuffer_ == nullptr || width <= 0 || height <= 0) {

      return;

    }

    const uint8_t high = color >> 8;

    const uint8_t low = color;

    for (int16_t row = y; row < y + height;

         row += kTransferChunkHeight) {

      const int16_t chunkHeight =

          min(kTransferChunkHeight, y + height - row);

      const size_t pixelCount = width * chunkHeight;

      for (size_t index = 0; index < pixelCount; ++index) {

        drawBuffer_[index * 2] = high;

        drawBuffer_[index * 2 + 1] = low;

      }

      if (!setWindow(x, row, x + width, row + chunkHeight) ||

          !writePixels(drawBuffer_, pixelCount * sizeof(uint16_t))) {

        Serial.println("ST7789 pixel transfer failed");

        return;

      }

    }

  }

  void writeFillRect(int16_t x, int16_t y, int16_t width, int16_t height,

                     uint16_t color) override {

    fillRect(x, y, width, height, color);

  }

  bool initialized() const { return initialized_; }

 private:

  bool transmit(const void* data, size_t length, int dcLevel) {

    if (data == nullptr || length == 0) {

      return true;

    }

    gpio_set_level(kTftDc, dcLevel);

    spi_transaction_t transaction = {};

    transaction.length = length * 8;

    transaction.tx_buffer = data;

    const esp_err_t err = spi_device_polling_transmit(spiDevice_, &transaction);

    if (err != ESP_OK) {

      Serial.printf("ST7789 SPI transfer failed: %s\n", esp_err_to_name(err));

      return false;

    }

    return true;

  }

  bool writeCommand(uint8_t command) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool writeCommandData(uint8_t command, const uint8_t* data, size_t length) {

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&command, sizeof(command), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool setWindow(int16_t x1, int16_t y1, int16_t x2, int16_t y2) {

    const uint8_t columns[] = {

        static_cast(x1 >> 8), static_cast(x1),

        static_cast((x2 - 1) >> 8), static_cast(x2 - 1),

    };

    const uint8_t rows[] = {

        static_cast(y1 >> 8), static_cast(y1),

        static_cast((y2 - 1) >> 8), static_cast(y2 - 1),

    };

    return writeCommandData(0x2A, columns, sizeof(columns)) &&

           writeCommandData(0x2B, rows, sizeof(rows));

  }

  bool writePixels(const uint8_t* data, size_t length) {

    constexpr uint8_t kRamWrite = 0x2C;

    gpio_set_level(kTftCs, 0);

    const bool success = transmit(&kRamWrite, sizeof(kRamWrite), 0) &&

                         transmit(data, length, 1);

    gpio_set_level(kTftCs, 1);

    return success;

  }

  bool initializeController() {

    const uint8_t madctl[] = {kCo16Madctl};

    const uint8_t displayFunction[] = {0x0A, 0x82};

    const uint8_t pixelFormat[] = {0x55};

    const uint8_t porchControl[] = {0x0C, 0x0C, 0x00, 0x33, 0x33};

    const uint8_t gateControl[] = {0x35};

    const uint8_t vcom[] = {0x28};

    const uint8_t lcmControl[] = {0x0C};

    const uint8_t vdvVrhEnable[] = {0x01, 0xFF};

    const uint8_t vrh[] = {0x10};

    const uint8_t vdv[] = {0x20};

    const uint8_t frameRate[] = {0x0F};

    const uint8_t powerControl[] = {0xA4, 0xA1};

    const uint8_t positiveGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32,

        0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17,

    };

    const uint8_t negativeGamma[] = {

        0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31,

        0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E,

    };

    if (!writeCommand(0x11)) {  // Sleep out.

      return false;

    }

    delay(120);

    return writeCommand(0x13) &&

           writeCommandData(0x36, madctl, sizeof(madctl)) &&

           writeCommandData(0xB6, displayFunction, sizeof(displayFunction)) &&

           writeCommandData(0x3A, pixelFormat, sizeof(pixelFormat)) &&

           (delay(10), true) &&

           writeCommandData(0xB2, porchControl, sizeof(porchControl)) &&

           writeCommandData(0xB7, gateControl, sizeof(gateControl)) &&

           writeCommandData(0xBB, vcom, sizeof(vcom)) &&

           writeCommandData(0xC0, lcmControl, sizeof(lcmControl)) &&

           writeCommandData(0xC2, vdvVrhEnable, sizeof(vdvVrhEnable)) &&

           writeCommandData(0xC3, vrh, sizeof(vrh)) &&

           writeCommandData(0xC4, vdv, sizeof(vdv)) &&

           writeCommandData(0xC6, frameRate, sizeof(frameRate)) &&

           writeCommandData(0xD0, powerControl, sizeof(powerControl)) &&

           writeCommandData(0xE0, positiveGamma, sizeof(positiveGamma)) &&

           writeCommandData(0xE1, negativeGamma, sizeof(negativeGamma)) &&

           writeCommand(0x21);  // Display inversion on.

  }

  spi_device_handle_t spiDevice_ = nullptr;

  uint8_t* drawBuffer_ = nullptr;

  bool initialized_ = false;

};

Co16St7789 display;

uint32_t frameCount = 0;

void drawColorBars() {

  constexpr uint16_t colors[] = {

      kRed,

      kGreen,

      kBlue,

      kCyan,

      kMagenta,

      kYellow,

  };

  constexpr size_t colorCount = sizeof(colors) / sizeof(colors[0]);

  const int barWidth = kDisplayWidth / colorCount;

  for (size_t index = 0; index < colorCount; ++index) {

    const int x = index * barWidth;

    const int width =

        (index == colorCount - 1) ? kDisplayWidth - x : barWidth;

    display.fillRect(x, 132, width, 44, colors[index]);

  }

}

void drawStaticScreen() {

  display.fillScreen(kBlack);

  display.drawRect(0, 0, kDisplayWidth, kDisplayHeight, kWhite);

  display.setTextWrap(false);

  display.setTextColor(kCyan);

  display.setTextSize(3);

  display.setCursor(34, 20);

  display.print("KinCony CO16");

  display.setTextColor(kWhite);

  display.setTextSize(2);

  display.setCursor(24, 64);

  display.print("ST7789 display test");

  display.setCursor(24, 92);

  display.print("SPI3 native driver");

  drawColorBars();

  display.setTextColor(kGreen);

  display.setCursor(24, 194);

  display.print("Frame:");

}

void updateFrameCounter() {

  display.fillRect(108, 190, 190, 28, kBlack);

  display.setTextColor(kGreen);

  display.setTextSize(2);

  display.setCursor(108, 194);

  display.print(frameCount++);

}

}  // namespace

void setup() {

  Serial.begin(115200);

  delay(1000);

  Serial.println();

  Serial.println("KinCony CO16 standalone ST7789 example");

  Serial.printf("SPI3 SCLK=%d MOSI=%d MISO=%d CS=%d mode=0 clock=%u Hz\n",

                kTftSclk, kTftMosi, kTftMiso, kTftCs,

                kDisplaySpiFrequency);

  Serial.printf("LCD DC=%d RESET=%d BACKLIGHT=%d\n", kTftDc, kTftReset,

                kTftBacklight);

  if (!display.begin()) {

    Serial.println("Display initialization failed");

    while (true) {

      delay(1000);

    }

  }

  drawStaticScreen();

  updateFrameCounter();

  Serial.printf("Display initialized: %dx%d, MADCTL=0x%02X, invert=on\n",

                display.width(), display.height(), kCo16Madctl);

}

void loop() {

  updateFrameCounter();

  delay(1000);

}

  ST7789.jpg (Size: 262.38 KB / Downloads: 152)
arduino ino file download:

  10-TFT-LCD-ST7789.zip (Size: 3.05 KB / Downloads: 132)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

  10-TFT-LCD-ST7789.ino.merged.zip (Size: 211.33 KB / Downloads: 134)
before run code , need install these arduino library:

  Adafruit-GFX-Library.png (Size: 122.69 KB / Downloads: 149)

  Adafruit-ST7735-and-ST7789-Library.png (Size: 118.05 KB / Downloads: 134)

[arduino code examples for CO16]-09 digital INPUT trigger OUTPUT directly

Mon, 31 Aug 2026 08:11:58 +0800

Code:
/*

  Made by KinCony IoT: https://www.kincony.com

  Program functionality:

  This program uses ESP32-S3 to read inputs from PCA9555 I/O expander chip (I2C address 0x24)

  for channels 1-16, and control corresponding relays using PCF8575 I/O expander chip (I2C address 0x22)

  for controlling 16 relays (1-16). When input (DI) is triggered (LOW), corresponding relay (OUTPUT) is activated (LOW).

*/

#include 

#include 

#include 

// Initialize the PCA9555 objects for reading inputs (channels 1-16)

PCA9555 input_ioex1;  // For channels 1-16 (I2C address 0x24)

// Set I2C address of the PCF8575 module for output relays

#define I2C_ADDRESS 0x22

PCF8575 pcf8575_R1(I2C_ADDRESS);

void setup() {

    Serial.begin(115200);

    delay(10);

    // Initialize I2C bus: SDA=GPIO8, SCL=GPIO18, 100kHz

    Wire.begin(8, 18, 100000);

    // Initialize PCF8575 for outputs

    pcf8575_R1.begin();

    // Turn off all relays initially (set all pins HIGH - relay OFF)

    for (int i = 0; i < 16; i++) {

        pcf8575_R1.write(i, HIGH);

    }

    // Configure input PCA9555 (for inputs 1-16)

    input_ioex1.attach(Wire, 0x24);

    input_ioex1.polarity(PCA95x5::Polarity::ORIGINAL_ALL);

    input_ioex1.direction(PCA95x5::Direction::IN_ALL);

    delay(50);

}

void loop() {

    // Read input states from XL9535 (inputs 1-16)

    uint16_t inputs_1_16 = input_ioex1.read();

    // Control outputs based on inputs

    // When input is LOW, set corresponding output to LOW (activate relay)

    for (int channel = 0; channel < 16; channel++) {

        if (!(inputs_1_16 & (1 << channel))) {

            pcf8575_R1.write(channel, LOW);   // Input triggered, activate relay

        } else {

            pcf8575_R1.write(channel, HIGH);  // Input not triggered, deactivate relay

        }

    }

    delay(100);

}

arduino ino file download:

9-input-trigger-output.zip (Size: 997 bytes / Downloads: 134)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

9-input-trigger-output.ino.merged.zip (Size: 197.75 KB / Downloads: 140)

[arduino code examples for CO16]-08 Ethernet W5500 chip work with TCP Server mode

Mon, 31 Aug 2026 08:09:39 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 *

 * This Arduino program sets up an ESP32-S3 with a W5500 Ethernet module

 * as a TCP server. It listens on port 4196 and echoes back any string 

 * received from a client.

 *

 * Hardware connections:

 * - CLK: GPIO1

 * - MOSI: GPIO2

 * - MISO: GPIO41

 * - CS: GPIO42

 * - RST: GPIO44

 * - INT: GPIO43

 *

 * Static IP address: 192.168.3.55

 * Subnet Mask: 255.255.255.0

 * Gateway: 192.168.3.1

 * DNS: 192.168.3.1

 */

#include 

#include 

// Define the W5500 Ethernet module pins

#define W5500_CS_PIN  42

#define W5500_RST_PIN 44

#define W5500_INT_PIN 43

#define W5500_CLK_PIN 1

#define W5500_MOSI_PIN 2

#define W5500_MISO_PIN 41

// MAC address for your Ethernet shield (must be unique on your network)

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Static IP address configuration

IPAddress ip(192, 168, 3, 55);       // Static IP address

IPAddress subnet(255, 255, 255, 0);   // Subnet mask

IPAddress gateway(192, 168, 3, 1);    // Default gateway

IPAddress dns(192, 168, 3, 1);        // DNS server address

// Create an EthernetServer object to handle TCP connections

EthernetServer server(4196);

void setup() {

  // Initialize serial communication

  Serial.begin(115200);

  while (!Serial) {

    ; // Wait for serial port to connect

  }

  // Initialize the W5500 module

  pinMode(W5500_RST_PIN, OUTPUT);

  pinMode(W5500_INT_PIN, INPUT);

  digitalWrite(W5500_RST_PIN, LOW);  // Reset the W5500 module

  delay(100);                       // Wait for reset to complete

  digitalWrite(W5500_RST_PIN, HIGH); // Release reset

  // Initialize SPI with the correct pin definitions

  SPI.begin(W5500_CLK_PIN, W5500_MISO_PIN, W5500_MOSI_PIN);

  // Set up the Ethernet library with W5500-specific pins

  Ethernet.init(W5500_CS_PIN);

  // Start the Ethernet connection with static IP configuration

  Ethernet.begin(mac, ip, dns, gateway, subnet);

  // Print the IP address to the serial monitor

  Serial.print("IP Address: ");

  Serial.println(Ethernet.localIP());

  // Start listening for incoming TCP connections

  server.begin();

}

void loop() {

  // Check for incoming client connections

  EthernetClient client = server.available();

  if (client) {

    Serial.println("New client connected");

    // Read data from the client and echo it back

    while (client.connected()) {

      if (client.available()) {

        char c = client.read();

        server.write(c);

      }

    }

    // Close the connection when done

    client.stop();

    Serial.println("Client disconnected");

  }

}

arduino ino file download:

8-Ethernet-W5500.zip (Size: 1.23 KB / Downloads: 131)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

8-Ethernet-W5500.ino.merged.zip (Size: 188.93 KB / Downloads: 139)

[arduino code examples for CO16]-07 how to DS3231 RTC clock

Mon, 31 Aug 2026 08:08:28 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 *

 * DS3231 RTC with Arduino

 *

 * This program demonstrates how to use the DS3231 RTC (Real-Time Clock) module with the Arduino.

 * It includes functionality to:

 * - Initialize the DS3231 RTC module

 * - Read the current date and time from the RTC

 * - Set the RTC time based on a serial command:Command format: DYYYY-MM-DDTHH:MM:SS

*    Set date and time command example: D2024-09-19T11:50:22

*    print current date and time command: current time

*

 *

 * Hardware Connections:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 */

#include 

#include 

String serial_cmd_rcv = ""; // Serial port receiver

typedef struct

{

  byte year;    // Last two digits of the year, library adds 2000.

  byte month;

  byte day;

  byte hour;

  byte minute;

  byte second;

} MY_DATE_STR;

MY_DATE_STR my_date_str = {0};

// Define constants for relay control

#define OPEN_RLY_DATA    26

#define OPEN_RLY_MONTH   4

#define CLOSE_RLY_DATA   2

#define CLOSE_RLY_MONTH  5

// Define pin connections

#define SDA_PIN   8

#define SCL_PIN   18

DS3231 rtc; // Create an instance of the DS3231 RTC

bool h12Flag;

bool pmFlag;

static bool bCentury = false;

static bool old_level_high = false;

static bool old_level_low = false;

/**

 * @brief Print the current time from the RTC to the Serial Monitor.

 */

static void PrintfCurTime()

{

  Serial.print("Current time is: ");

  int year = rtc.getYear() + 2000;

  Serial.print(year);

  Serial.print("-");

  Serial.print(rtc.getMonth(bCentury), DEC);

  Serial.print("-");

  Serial.print(rtc.getDate(), DEC);

  Serial.print(" ");

  Serial.print(rtc.getHour(h12Flag, pmFlag), DEC);

  Serial.print(":");

  Serial.print(rtc.getMinute(), DEC);

  Serial.print(":");

  Serial.println(rtc.getSecond(), DEC);

}

/**

 * @brief Process serial commands to set the RTC time.

 * Command format: DYYYY-MM-DDTHH:MM:SS

 */

static void GetSerialCmd()

{

  if (Serial.available() > 0)

  {

    delay(100);

    int num_read = Serial.available();

    while (num_read--)

      serial_cmd_rcv += char(Serial.read());

  }

  else return;

  serial_cmd_rcv.trim();

  if (serial_cmd_rcv == "current time")

  {

    PrintfCurTime();

    serial_cmd_rcv = "";

    return;

  }

  Serial.print("Received length: ");

  Serial.println(serial_cmd_rcv.length());

  int indexof_d = serial_cmd_rcv.indexOf('D');

  int indexof_t = serial_cmd_rcv.indexOf('T');

  Serial.print("D index: ");

  Serial.print(indexof_d);

  Serial.print(" T index: ");

  Serial.println(indexof_t);

  if (serial_cmd_rcv.length() != 20 || 

      serial_cmd_rcv.substring(0, 1) != "D" ||

      serial_cmd_rcv.substring(11, 12) != "T")  

  {

    Serial.println(serial_cmd_rcv);

    serial_cmd_rcv = "";

    return;

  }

  Serial.println("Setting time...");

  my_date_str.year = (byte)serial_cmd_rcv.substring(3, 5).toInt();

  my_date_str.month = (byte)serial_cmd_rcv.substring(6, 8).toInt();

  my_date_str.day = (byte)serial_cmd_rcv.substring(9, 11).toInt();

  my_date_str.hour = (byte)serial_cmd_rcv.substring(12, 14).toInt();

  my_date_str.minute = (byte)serial_cmd_rcv.substring(15, 17).toInt();

  my_date_str.second = (byte)serial_cmd_rcv.substring(18).toInt();

  rtc.setYear(my_date_str.year);

  rtc.setMonth(my_date_str.month);

  rtc.setDate(my_date_str.day);

  rtc.setHour(my_date_str.hour);

  rtc.setMinute(my_date_str.minute);

  rtc.setSecond(my_date_str.second);

  serial_cmd_rcv = "";

  Serial.println("Time set.");

}

void setup() {

  // Initialize the I2C interface

  Wire.begin(SDA_PIN, SCL_PIN, 40000);

  // Initialize Serial communication

  Serial.begin(115200);

  // Set the RTC to 24-hour mode

  rtc.setClockMode(false); // 24-hour format

  // Print current time to Serial Monitor

  PrintfCurTime();

  // Clear any remaining serial data

  while (Serial.read() >= 0) {}

}

void loop() {

  // Process incoming serial commands

  GetSerialCmd(); 

  delay(1000); // Delay for 1 second

}

arduino ino file download:

7-DS3231-RTC.zip (Size: 1.56 KB / Downloads: 132)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

7-DS3231-RTC.ino.merged.zip (Size: 191.08 KB / Downloads: 147)

[arduino code examples for CO16]-06 How to use SD Card

Mon, 31 Aug 2026 08:06:31 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 *

 * SD Card File Operations

 *

 * This program demonstrates basic file operations on an SD card using the ESP32.

 * It includes functionality to:

 * - Initialize and test the SD card

 * - Read from, write to, append to, and delete files on the SD card

 * - Measure file read and write performance

 *

 * Hardware Connections:

 * - SCK: GPIO 11

 * - MISO: GPIO 12

 * - MOSI: GPIO 10

 * - CS: GPIO 9

 */

#include "FS.h"

#include "SD.h"

#include "SPI.h"

// Pin definitions for SD card

#define SCK  11

#define MISO 12

#define MOSI 10

#define CS   9

/**

 * @brief Reads the contents of a file from the SD card and prints it to the serial monitor.

 * 

 * @param fs File system to use (in this case, SD).

 * @param path Path of the file to read.

 */

void readFile(fs::FS &fs, const char * path) {

  Serial.printf("Reading file: %s\n", path);

  File file = fs.open(path);

  if (!file) {

    Serial.println("Failed to open file for reading");

    return;

  }

  Serial.print("Read from file: ");

  while (file.available()) {

    Serial.print((char)file.read());

  }

  file.close();

}

/**

 * @brief Writes a message to a file on the SD card.

 * 

 * @param fs File system to use (in this case, SD).

 * @param path Path of the file to write.

 * @param message Message to write to the file.

 */

void writeFile(fs::FS &fs, const char * path, const char * message) {

  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);

  if (!file) {

    Serial.println("Failed to open file for writing");

    return;

  }

  if (file.print(message)) {

    Serial.println("File written");

  } else {

    Serial.println("Write failed");

  }

  file.close();

}

/**

 * @brief Appends a message to a file on the SD card.

 * 

 * @param fs File system to use (in this case, SD).

 * @param path Path of the file to append.

 * @param message Message to append to the file.

 */

void appendFile(fs::FS &fs, const char * path, const char * message) {

  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);

  if (!file) {

    Serial.println("Failed to open file for appending");

    return;

  }

  if (file.print(message)) {

    Serial.println("Message appended");

  } else {

    Serial.println("Append failed");

  }

  file.close();

}

/**

 * @brief Deletes a file from the SD card.

 * 

 * @param fs File system to use (in this case, SD).

 * @param path Path of the file to delete.

 */

void deleteFile(fs::FS &fs, const char * path) {

  Serial.printf("Deleting file: %s\n", path);

  if (fs.remove(path)) {

    Serial.println("File deleted");

  } else {

    Serial.println("Delete failed");

  }

}

/**

 * @brief Tests file read and write performance.

 * 

 * @param fs File system to use (in this case, SD).

 * @param path Path of the file to test.

 */

void testFileIO(fs::FS &fs, const char * path) {

  File file = fs.open(path);

  static uint8_t buf[512];

  size_t len = 0;

  uint32_t start = millis();

  uint32_t end = start;

  if (file) {

    len = file.size();

    size_t flen = len;

    start = millis();

    while (len) {

      size_t toRead = len;

      if (toRead > 512) {

        toRead = 512;

      }

      file.read(buf, toRead);

      len -= toRead;

    }

    end = millis() - start;

    Serial.printf("%u bytes read for %u ms\n", flen, end);

    file.close();

  } else {

    Serial.println("Failed to open file for reading");

  }

  file = fs.open(path, FILE_WRITE);

  if (!file) {

    Serial.println("Failed to open file for writing");

    return;

  }

  size_t i;

  start = millis();

  for (i = 0; i < 2048; i++) {

    file.write(buf, 512);

  }

  end = millis() - start;

  Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);

  file.close();

}

void setup() {

  // Initialize serial communication

  Serial.begin(115200);

  // Initialize SPI and SD card

  SPIClass spi = SPIClass(HSPI);

  spi.begin(SCK, MISO, MOSI, CS);

  if (!SD.begin(CS, spi, 80000000)) {

    Serial.println("Card Mount Failed");

    return;

  }

  uint8_t cardType = SD.cardType();

  if (cardType == CARD_NONE) {

    Serial.println("No SD card attached");

    return;

  }

  Serial.print("SD Card Type: ");

  if (cardType == CARD_MMC) {

    Serial.println("MMC");

  } else if (cardType == CARD_SD) {

    Serial.println("SDSC");

  } else if (cardType == CARD_SDHC) {

    Serial.println("SDHC");

  } else {

    Serial.println("UNKNOWN");

  }

  uint64_t cardSize = SD.cardSize() / (1024 * 1024);

  Serial.printf("SD Card Size: %lluMB\n", cardSize);

  delay(2000);

  // Perform file operations

  deleteFile(SD, "/hello.txt");

  writeFile(SD, "/hello.txt", "Hello ");

  appendFile(SD, "/hello.txt", "World!\n");

  readFile(SD, "/hello.txt");

  testFileIO(SD, "/test.txt");

  Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));

  Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));

}

void loop() {

  // No operation in loop

}

arduino ino file download:

6-SD.zip (Size: 1.53 KB / Downloads: 128)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

6-SD.ino.merged.zip (Size: 221.25 KB / Downloads: 136)

[arduino code examples for CO16]-05 Read PT100 temperature sensor

Mon, 31 Aug 2026 08:04:58 +0800

Code:
#include 

namespace {

// CO16 MAX31865 software-SPI pins.

constexpr int kPt100Sclk = 11;

constexpr int kPt100Mosi = 10;

constexpr int kPt100Miso = 12;

constexpr int kPt100Cs = 14;

// NX3L4051PW channel select pins. S3 is fixed LOW on CO16.

constexpr int kMuxS1 = 7;

constexpr int kMuxS2 = 21;

constexpr uint8_t kPt100ChannelCount = 4;

constexpr uint32_t kMuxSettlingTimeMs = 20;

constexpr float kRtdNominalOhms = 100.0F;

constexpr float kReferenceResistorOhms = 400.0F;

Adafruit_MAX31865 pt100(kPt100Cs, kPt100Mosi, kPt100Miso, kPt100Sclk);

void selectPt100Channel(uint8_t channel) {

  const uint8_t muxAddress = channel - 1;

  // S3 is fixed LOW, so S2/S1 select PT100 channels 1-4.

  digitalWrite(kMuxS1, muxAddress & 0x01);

  digitalWrite(kMuxS2, (muxAddress >> 1) & 0x01);

  delay(kMuxSettlingTimeMs);

}

void printFault(uint8_t fault) {

  Serial.printf(" fault=0x%02X", fault);

  if (fault & MAX31865_FAULT_HIGHTHRESH) {

    Serial.print(" RTD_HIGH_THRESHOLD");

  }

  if (fault & MAX31865_FAULT_LOWTHRESH) {

    Serial.print(" RTD_LOW_THRESHOLD");

  }

  if (fault & MAX31865_FAULT_REFINLOW) {

    Serial.print(" REFIN_HIGH");

  }

  if (fault & MAX31865_FAULT_REFINHIGH) {

    Serial.print(" REFIN_LOW_OR_FORCE_OPEN");

  }

  if (fault & MAX31865_FAULT_RTDINLOW) {

    Serial.print(" RTDIN_LOW_OR_FORCE_OPEN");

  }

  if (fault & MAX31865_FAULT_OVUV) {

    Serial.print(" OVER_UNDERVOLTAGE");

  }

}

}  // namespace

void setup() {

  Serial.begin(115200);

  delay(1000);

  pinMode(kMuxS1, OUTPUT);

  pinMode(kMuxS2, OUTPUT);

  selectPt100Channel(1);

  Serial.println();

  Serial.println("KinCony CO16 four-channel PT100 example");

  Serial.printf("MUX S3=LOW S2=%d S1=%d; SPI SCLK=%d MOSI=%d MISO=%d CS=%d\n",

                kMuxS2, kMuxS1, kPt100Sclk, kPt100Mosi, kPt100Miso,

                kPt100Cs);

  pt100.begin(MAX31865_3WIRE);

  pt100.enable50Hz(true);

}

void loop() {

  for (uint8_t channel = 1; channel <= kPt100ChannelCount; ++channel) {

    selectPt100Channel(channel);

    const uint16_t raw = pt100.readRTD();

    const float resistance =

        static_cast(raw) * kReferenceResistorOhms / 32768.0F;

    const float temperature = pt100.calculateTemperature(

        raw, kRtdNominalOhms, kReferenceResistorOhms);

    const uint8_t fault = pt100.readFault(MAX31865_FAULT_NONE);

    Serial.printf("CH%u raw=%u resistance=%.3f ohm temperature=%.2f C",

                  channel, raw, resistance, temperature);

    if (fault != 0) {

      printFault(fault);

      pt100.clearFault();

    } else {

      Serial.print(" fault=0x00");

    }

    Serial.println();

  }

  Serial.println();

  delay(1000);

}

arduino ino file download:

  5-PT100.zip (Size: 1.11 KB / Downloads: 133)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

  5-PT100.ino.merged.zip (Size: 198.5 KB / Downloads: 132)
before run code , need install max31865 arduino library

  max31865-library.png (Size: 122.09 KB / Downloads: 127)

  pt100-test.jpg (Size: 593.56 KB / Downloads: 98)

[arduino code examples for CO16]-04 RS485 communication test

Mon, 31 Aug 2026 08:02:27 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 *

 * RS485 Communication Test

 *

 * This program is a simple test for RS485 communication using ESP32-S3.

 * It will send a message over RS485 and then read incoming messages.

 * The TXD pin is defined as GPIO 18 and RXD pin is defined as GPIO 8.

 */

#include 

// Define RS485 pins

#define RS485_RXD 38

#define RS485_TXD 39

// Create a hardware serial object

HardwareSerial rs485Serial(1);

void setup() {

  // Start serial communication for debugging

  Serial.begin(115200);

  while (!Serial);

  // Initialize RS485 Serial communication

  rs485Serial.begin(9600, SERIAL_8N1, RS485_RXD, RS485_TXD);

  Serial.println("RS485 Test Start");

}

void loop() {

  // Send a test message

  rs485Serial.println("Hello from KinCony!");

  // Wait for a short period

  delay(1000);

  // Check if data is available to read

  if (rs485Serial.available()) {

    String receivedMessage = "";

    while (rs485Serial.available()) {

      char c = rs485Serial.read();

      receivedMessage += c;

    }

    // Print the received message

    Serial.print("Received: ");

    Serial.println(receivedMessage);

  }

  // Wait before sending the next message

  delay(2000);

}

arduino ino file download:

4-RS485-Test.zip (Size: 760 bytes / Downloads: 135)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

4-RS485-Test.ino.merged.zip (Size: 190.1 KB / Downloads: 119)

[arduino code examples for CO16]-03 Read analog input ports value

Mon, 31 Aug 2026 08:00:50 +0800

Code:
/*

 * KinCony 16-Channel Analog Input Monitor

 *

 * Four ADS1115 ADC modules are used:

 *

 * ADS1115-1 (U35): CH1-CH4   I2C address: 0x48

 * ADS1115-2 (U7):  CH5-CH8   I2C address: 0x49

 * ADS1115-3 (U15): CH9-CH12  I2C address: 0x4B

 * ADS1115-4 (U19): CH13-CH16 I2C address: 0x4A

 *

 * ESPHome equivalent configuration:

 *

 * gain: 4.096

 * filters:

 *   - lambda: 'return x <= 0.0025f ? 0.0f : x;'

 *   - multiply: 5.16696

 *   - clamp:

 *       min_value: 0.0

 *       max_value: 10.0

 *

 * Only channels with an input voltage greater than 0.5V

 * will be printed.

 *

 * Copyright: Made by KinCony IoT: https://www.kincony.com

 */

#include 

#include 

// I2C pins

#define SDA_PIN 8

#define SCL_PIN 18

// ADS1115 I2C addresses

#define ADS1115_1_ADDR 0x48

#define ADS1115_2_ADDR 0x49

#define ADS1115_3_ADDR 0x4B

#define ADS1115_4_ADDR 0x4A

// ESPHome calibration multiplier

#define VOLTAGE_MULTIPLIER 5.16696f

// ESPHome zero threshold

#define ADC_ZERO_THRESHOLD 0.0025f

// Print threshold

#define PRINT_THRESHOLD 0.5f

// Maximum input voltage

#define MAX_INPUT_VOLTAGE 10.0f

// Create ADS1115 objects

DFRobot_ADS1115 ads1(&Wire);

DFRobot_ADS1115 ads2(&Wire);

DFRobot_ADS1115 ads3(&Wire);

DFRobot_ADS1115 ads4(&Wire);

/*

 * Read ADS1115 channel and convert to actual input voltage.

 *

 * DFRobot readVoltage() returns voltage in mV.

 *

 * ESPHome:

 *     x <= 0.0025V -> 0V

 *     x * 5.16696

 *     clamp 0~10V

 */

float readInputVoltage(DFRobot_ADS1115 &ads, uint8_t channel)

{

    // Read ADC voltage in mV

    uint16_t adc_mV = ads.readVoltage(channel);

    // Convert mV to V

    float adcVoltage = adc_mV / 1000.0f;

    // ESPHome lambda filter

    if (adcVoltage <= ADC_ZERO_THRESHOLD)

    {

        return 0.0f;

    }

    // ESPHome multiply filter

    float inputVoltage = adcVoltage * VOLTAGE_MULTIPLIER;

    // ESPHome clamp filter

    if (inputVoltage < 0.0f)

    {

        inputVoltage = 0.0f;

    }

    if (inputVoltage > MAX_INPUT_VOLTAGE)

    {

        inputVoltage = MAX_INPUT_VOLTAGE;

    }

    return inputVoltage;

}

/*

 * Check one analog channel.

 *

 * If the actual input voltage is greater than 0.5V,

 * print the channel number and voltage.

 */

void checkChannel(

    DFRobot_ADS1115 &ads,

    uint8_t adcChannel,

    uint8_t channelNumber)

{

    float voltage = readInputVoltage(ads, adcChannel);

    if (voltage > PRINT_THRESHOLD)

    {

        Serial.print("CH");

        Serial.print(channelNumber);

        Serial.print(": ");

        Serial.print(voltage, 2);

        Serial.println(" V");

    }

}

void setup(void)

{

    // Initialize serial communication

    Serial.begin(115200);

    // Initialize I2C

    Wire.begin(SDA_PIN, SCL_PIN);

    /*

     * ADS1115 gain = 4.096V

     *

     * This corresponds to ESPHome:

     *

     * gain: 4.096

     *

     * DFRobot library:

     * eGAIN_ONE = 4.096V

     */

    // ADS1115-1

    ads1.setAddr_ADS1115(ADS1115_1_ADDR);

    ads1.setGain(eGAIN_ONE);

    ads1.setMode(eMODE_SINGLE);

    ads1.setRate(eRATE_128);

    ads1.setOSMode(eOSMODE_SINGLE);

    ads1.init();

    // ADS1115-2

    ads2.setAddr_ADS1115(ADS1115_2_ADDR);

    ads2.setGain(eGAIN_ONE);

    ads2.setMode(eMODE_SINGLE);

    ads2.setRate(eRATE_128);

    ads2.setOSMode(eOSMODE_SINGLE);

    ads2.init();

    // ADS1115-3

    ads3.setAddr_ADS1115(ADS1115_3_ADDR);

    ads3.setGain(eGAIN_ONE);

    ads3.setMode(eMODE_SINGLE);

    ads3.setRate(eRATE_128);

    ads3.setOSMode(eOSMODE_SINGLE);

    ads3.init();

    // ADS1115-4

    ads4.setAddr_ADS1115(ADS1115_4_ADDR);

    ads4.setGain(eGAIN_ONE);

    ads4.setMode(eMODE_SINGLE);

    ads4.setRate(eRATE_128);

    ads4.setOSMode(eOSMODE_SINGLE);

    ads4.init();

    Serial.println();

    Serial.println("KinCony 16-Channel Analog Input Test");

    Serial.println("--------------------------------------");

    Serial.println("ADS1115 Gain: 4.096V");

    Serial.println("Multiplier: 5.16696");

    Serial.println("Print threshold: 0.50V");

    Serial.println();

}

void loop(void)

{

    // ADS1115-1: CH1 ~ CH4

    if (ads1.checkADS1115())

    {

        checkChannel(ads1, 0, 1);

        checkChannel(ads1, 1, 2);

        checkChannel(ads1, 2, 3);

        checkChannel(ads1, 3, 4);

    }

    else

    {

        Serial.println("ADS1115-1 (0x48) Disconnected!");

    }

    // ADS1115-2: CH5 ~ CH8

    if (ads2.checkADS1115())

    {

        checkChannel(ads2, 0, 5);

        checkChannel(ads2, 1, 6);

        checkChannel(ads2, 2, 7);

        checkChannel(ads2, 3, 8);

    }

    else

    {

        Serial.println("ADS1115-2 (0x49) Disconnected!");

    }

    // ADS1115-3: CH9 ~ CH12

    if (ads3.checkADS1115())

    {

        checkChannel(ads3, 0, 9);

        checkChannel(ads3, 1, 10);

        checkChannel(ads3, 2, 11);

        checkChannel(ads3, 3, 12);

    }

    else

    {

        Serial.println("ADS1115-3 (0x4B) Disconnected!");

    }

    // ADS1115-4: CH13 ~ CH16

    if (ads4.checkADS1115())

    {

        checkChannel(ads4, 0, 13);

        checkChannel(ads4, 1, 14);

        checkChannel(ads4, 2, 15);

        checkChannel(ads4, 3, 16);

    }

    else

    {

        Serial.println("ADS1115-4 (0x4A) Disconnected!");

    }

    // Scan every 1 second

    delay(1000);

}

arduino ino file download:

3-ads1115_adc.zip (Size: 1.68 KB / Downloads: 124)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

3-ads1115_adc.ino.merged.zip (Size: 195.04 KB / Downloads: 120)

[arduino code examples for CO16]-02 Read digital input ports state

Mon, 31 Aug 2026 07:58:42 +0800

Code:
/*

  Made by KinCony IoT: https://www.kincony.com

  Program functionality:

  This program uses an ESP32-S3 to read inputs from an XL9535 I/O expander chip 

  (I2C address 0x24) via I2C. The XL9535 chip handles channels 1-16. 

  The program reads the state of all these inputs and prints them in binary format 

  to the serial monitor.

  Key points:

  - The I2C bus is initialized on GPIO pins 8 (SDA) and 18 (SCL) with a frequency of 40kHz.

  - The XL9535 chip reads the state of input pins for channels 1-16.

  - The state of the inputs is printed to the serial monitor in binary format every second.

  - Note: The original description mentioned three expander chips, but this implementation

    currently uses only one XL9535 (PCA9555 compatible) at address 0x24.

*/

#include 

#include 

// Initialize the PCA9555 object for XL9535 chip (channels 1-16)

PCA9555 ioex1;  // XL9535 I/O expander at I2C address 0x24, handles channels 1-16

void setup() {

    // Start serial communication for debugging

    Serial.begin(115200);

    delay(2000);  // Wait for 2 seconds to ensure serial monitor is ready

    // Initialize the I2C bus with GPIO 8 as SDA and GPIO 18 as SCL, 40kHz frequency

    Wire.begin(8, 18, 40000);

    // Attach the PCA9555 device at I2C address 0x24

    ioex1.attach(Wire, 0x24);

    // Set polarity to original (no inversion)

    ioex1.polarity(PCA95x5::Polarity::ORIGINAL_ALL);

    // Configure all 16 pins as inputs

    ioex1.direction(PCA95x5::Direction::IN_ALL);

}

void loop() {

    // Read and print the state of inputs from the XL9535 (channels 1-16)

    Serial.print("1-16 input states: ");

    // Read all 16 pins and print as 16-bit binary value

    Serial.println(ioex1.read(), BIN);

    delay(1000);  // Wait for 1 second before the next reading

}

arduino ino file download:

2-digital-input.zip (Size: 1,013 bytes / Downloads: 132)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

2-digital-input.ino.merged.zip (Size: 197.84 KB / Downloads: 140)

[arduino code examples for CO16]-01 Turn ON/OFF relay

Mon, 31 Aug 2026 07:56:48 +0800

Code:
/*

 * Made by KinCony IoT: https://www.kincony.com

 *

 * This program controls a 16-channel relay board via a PCF8575 I/O expander.

 * It sequentially turns on each relay and then turns them off in a loop.

 * 

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * 

 * Delay Time:

 * - 200 milliseconds between switching relays

 */

#include         // Include the Wire library for I2C communication

#include      // Include the PCF8575 library to control the I/O expander

#define SDA 8           // Define the SDA pin

#define SCL 18           // Define the SCL pin

#define DELAY_TIME 200   // Define the delay time in milliseconds

// Set I2C address of the PCF8575 module

#define I2C_ADDRESS 0x22 // I2C address of the PCF8575 module

PCF8575 pcf8575_R1(I2C_ADDRESS); // Create a PCF8575 object with the specified I2C address

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL); // SDA on GPIO 8, SCL on GPIO 18 (according to your board's configuration)

  // Initialize serial communication for debugging (optional)

  Serial.begin(115200);

  Serial.println("PCF8575 Relay Control: Starting...");

  // Initialize the PCF8575 module

  pcf8575_R1.begin();

  // Turn off all relays initially (set all pins HIGH)

  for (int i = 0; i < 16; i++) {

    pcf8575_R1.write(i, HIGH); // Set all relays to OFF (assuming HIGH means OFF for relays)

  }

}

void loop() {

  // Sequentially turn on each relay

  for (int i = 0; i < 16; i++) {

    pcf8575_R1.write(i, LOW);   // Turn on the relay at pin i (LOW means ON for the relay)

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // Sequentially turn off each relay

  for (int i = 0; i < 16; i++) {

    pcf8575_R1.write(i, HIGH);  // Turn off the relay at pin i (HIGH means OFF for the relay)

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

}

arduino ino file download:

1-output.zip (Size: 926 bytes / Downloads: 131)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

1-output.ino.merged.zip (Size: 197.66 KB / Downloads: 135)