Smart Home Automation Forum - KC868-A2v3

KC868-A2v3 FILES

Tue, 31 Mar 2026 18:28:36 +0800

Hi,
I am planning to design a custom case for the KC868-A2v3 board and would like to ensure accurate fitting.
Could you please provide the mechanical drawings (including dimensions and mounting holes) and, if available, the 3D CAD files (STEP/STP format) for this board?

KC868-a8v3 IFTTT for Aircon use

Thu, 12 Mar 2026 18:59:17 +0800

I have KC868-a8v3.1 board loaded with the current firmware V3.23.2

It is used for switching 24VAC to control AC ducts in conjunction with Home Assistant.

My challenge is that the Rumpus room duct (controlled by DO8 on KC868) is fed from a master upstairs duct (controller by DO2 on KC868) so both ducts need to be open for AC to reach the Rumpus room.
For ease of user operation I would like to setup the a IFTTT rule so that;
1. when a user turns on the Rumpus duct (D08) the upstairs duct will also activate (D02) (turn on could by by HA or RF on the KC868)
2. if the user subsequently turns off the Rumpus duct, the Upstairs duct will remain open.

Also, if the Upstairs duct is turned off, there should be a rule to turn on the Rumpus room duct, this is necessary to reflect through to the HA dashboard.

Using IFTTT I setup an IF condition on the DO8 which performs an action on D02.

I found that this doesn't work properly and the KC web page status indicator for D02 and D08 are not linked corectly by the rule. At one stage the KC868 crashed and I had to relead the formward with the formward loader tool.

Can you please advise if IFTTT can be used for this sort of rules or is there another way on the KC868 to achieve this.

Regards

Error Flashing new KCS firmware using ESP32 Download Tool

Sat, 12 Jul 2025 15:36:36 +0800

Hi everyone, I'm new to Kincony products and this forum. I recently bought a Kincony A2V3.1 board to test these products and their integration with Home Assistant.
Once the board arrived, I connected it to my router via LAN cable, but I cannot see any IP address on the A2V3 screen, nor can I find it on my network.

For this reason, I tried to reflash the KCS v3 firmware using ESP32 Download Tool V3.9.2 and entering download mode (turn off → press S2 button → turn on power → release S2).
However, when I press "start" on the ESP32 Download Tool, I get this error:

Code:
1 kill

test offset :  0 0x0

case ok

test offset :  0 0x0

case ok

Uploading stub...

Running stub...

[2025-07-12 09:22:45,885][ESP8266Loader_spi[1]][espDownloader.py][line:586][ERROR]: ESP32 Chip stub error esp_stub_and_set_baud.

no log file output ...

I already tested it with different USB cable, different PC and different power supply. But getting always same error.

Here a screenshot from ESP32 Download Tool V3.9.2:

Screenshot 2025-07-12 092304.png (Size: 63.1 KB / Downloads: 670)

Can you please help me debugging this issue?

regards,
Stefano

[arduino code examples for A2v3]-11 Digital input trigger relay output

Sun, 20 Apr 2025 14:07:04 +0800

Code:
/**

 * @brief Example to control relays based on digital input states using ESP32

 * @details This program reads the states of two digital inputs (GPIO16, GPIO17)

 *          and controls two relays (GPIO40, GPIO39) accordingly.

 *

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

 */

// Define the GPIO pins for digital inputs

#define INPUT1_PIN 16  // GPIO16 for Digital Input 1

#define INPUT2_PIN 17  // GPIO17 for Digital Input 2

// Define the GPIO pins for relays

#define RELAY1_PIN 40  // GPIO40 for Relay 1

#define RELAY2_PIN 39  // GPIO39 for Relay 2

void setup() {

    // Initialize the serial communication for debugging

    Serial.begin(115200);

    Serial.println("ESP32 Input-Controlled Relay Example");

    // Set the input pins as INPUT

    pinMode(INPUT1_PIN, INPUT);

    pinMode(INPUT2_PIN, INPUT);

    // Set the relay pins as OUTPUT

    pinMode(RELAY1_PIN, OUTPUT);

    pinMode(RELAY2_PIN, OUTPUT);

    // Turn off both relays at startup (assuming active LOW relays)

    digitalWrite(RELAY1_PIN, HIGH);

    digitalWrite(RELAY2_PIN, HIGH);

}

void loop() {

    // Read the state of the digital inputs

    int state1 = digitalRead(INPUT1_PIN);

    int state2 = digitalRead(INPUT2_PIN);

    // Control the relays based on input states

    digitalWrite(RELAY1_PIN, state1 == HIGH ? LOW : HIGH); // Activate relay if input is HIGH

    digitalWrite(RELAY2_PIN, state2 == HIGH ? LOW : HIGH); // Activate relay if input is HIGH

    // Print the states to the Serial Monitor

    Serial.print("Digital Input 1 State: ");

    Serial.println(state1);

    Serial.print("Digital Input 2 State: ");

    Serial.println(state2);

    // Wait for 100 milliseconds before reading again

    delay(100);

}

arduino ino file download:

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

11-input-trigger-output.ino.merged.zip (Size: 179.47 KB / Downloads: 447)

[arduino code examples for A2v3]-10 Print TEXT on SSD1306 OLED displayer

Sun, 20 Apr 2025 14:04:08 +0800

Code:
/*

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

 * 

 * This Arduino program demonstrates how to display text on an SSD1306 128x64 OLED display using the U8g2 library.

 * The program draws two lines of text on the display:

 * - The first line is "KINCONY" in a larger font.

 * - The second line is "www.kincony.com" in a smaller font.

 * 

 * The display is connected via I2C (software implementation) with:

 * - SCL (clock) on pin IO47

 * - SDA (data) on pin IO48

 * 

 * The display's I2C address is set to 0x3C.

 */

#include   // Include the U8g2 library for controlling the OLED display

#include      // Include the Wire library for I2C communication

// Initialize the display using the software I2C method (SCL = IO47, SDA = IO48)

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,  47, 48, U8X8_PIN_NONE);  // Screen rotation: U8G2_R0

// Function to display page 1 content

void page1() {

  // Set font size 18 for the larger "KINCONY" text

  u8g2.setFont(u8g2_font_timR18_tf);  // Use the Times Roman font, size 18

  u8g2.setFontPosTop();               // Set the text position at the top of the display

  u8g2.setCursor(5, 0);               // Position the cursor at coordinates (5, 0)

  u8g2.print("KINCONY");              // Display the text "KINCONY" on the screen

  // Set font size 12 for the smaller "www.kincony.com" text

  u8g2.setFont(u8g2_font_timR12_tf);  // Use the Times Roman font, size 12

  u8g2.setCursor(0, 40);              // Position the cursor at coordinates (0, 40)

  u8g2.print("www.kincony.com");      // Display the text "www.kincony.com"

}

// Setup function, runs once when the program starts

void setup() {

  // Set the I2C address for the display to 0x3C

  u8g2.setI2CAddress(0x3C*2);  // I2C address shift for 8-bit format

  // Initialize the display

  u8g2.begin();

  // Enable UTF-8 character printing for the display

  u8g2.enableUTF8Print();  // Allow UTF-8 encoded text to be printed

}

// Main loop function, continuously runs after setup()

void loop() {

  // Begin the display drawing process

  u8g2.firstPage();  // Prepare the first page for drawing

  do {

    // Call the page1() function to draw content on the display

    page1();

  } while (u8g2.nextPage());  // Continue to the next page until all pages are drawn

}

arduino ino file download:

10-oled-ssd1306.zip (Size: 1.12 KB / Downloads: 463)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

10-oled-ssd1306.ino.merged.zip (Size: 201.24 KB / Downloads: 447)

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

Sun, 20 Apr 2025 14:01:46 +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: GPIO42

 * - MOSI: GPIO43

 * - MISO: GPIO44

 * - CS: GPIO41

 * - RST: GPIO1

 * - INT: GPIO2

 *

 * 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  41

#define W5500_RST_PIN 1

#define W5500_INT_PIN 2

#define W5500_CLK_PIN 42

#define W5500_MOSI_PIN 43

#define W5500_MISO_PIN 44

// 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: 470)
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: 451)

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

Sun, 20 Apr 2025 14:00:17 +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 48

 * - SCL: GPIO 47

 */

#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   48

#define SCL_PIN   47

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: 465)
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.09 KB / Downloads: 454)

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

Sun, 20 Apr 2025 13:58:47 +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 13

 * - MISO: GPIO 14

 * - MOSI: GPIO 12

 * - CS: GPIO 11

 */

#include "FS.h"

#include "SD.h"

#include "SPI.h"

// Pin definitions for SD card

#define SCK  13

#define MISO 14

#define MOSI 12

#define CS   11

/**

 * @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: 446)
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: 413)

[arduino code examples for A2v3]-05 Read free GPIO state

Sun, 20 Apr 2025 13:57:11 +0800

Code:
/**

 * @brief Simple example to read multiple digital inputs using ESP32

 * @details This program demonstrates how to read digital input states

 *          from GPIO18, GPIO8, GPIO4, GPIO5, GPIO6, and GPIO38 of an ESP32 development board.

 *

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

 */

// Define the GPIO pins for digital inputs

#define INPUT1_PIN 18  // GPIO18

#define INPUT2_PIN 8   // GPIO8

#define INPUT3_PIN 4   // GPIO4

#define INPUT4_PIN 5   // GPIO5

#define INPUT5_PIN 6   // GPIO6

#define INPUT6_PIN 38  // GPIO38

void setup() {

    // Initialize the serial communication for debugging

    Serial.begin(115200);

    Serial.println("ESP32 Digital Input Read Example");

    // Set the input pins as INPUT

    pinMode(INPUT1_PIN, INPUT);

    pinMode(INPUT2_PIN, INPUT);

    pinMode(INPUT3_PIN, INPUT);

    pinMode(INPUT4_PIN, INPUT);

    pinMode(INPUT5_PIN, INPUT);

    pinMode(INPUT6_PIN, INPUT);

}

void loop() {

    // Read the state of the digital inputs

    int state1 = digitalRead(INPUT1_PIN);

    int state2 = digitalRead(INPUT2_PIN);

    int state3 = digitalRead(INPUT3_PIN);

    int state4 = digitalRead(INPUT4_PIN);

    int state5 = digitalRead(INPUT5_PIN);

    int state6 = digitalRead(INPUT6_PIN);

    // Print the states to the Serial Monitor

    Serial.print("GPIO18 State: ");

    Serial.println(state1);

    Serial.print("GPIO8 State: ");

    Serial.println(state2);

    Serial.print("GPIO4 State: ");

    Serial.println(state3);

    Serial.print("GPIO5 State: ");

    Serial.println(state4);

    Serial.print("GPIO6 State: ");

    Serial.println(state5);

    Serial.print("GPIO38 State: ");

    Serial.println(state6);

    // Wait for 500 milliseconds before reading again

    delay(500);

}

arduino ino file download:

5-free-gpio-state.zip (Size: 773 bytes / Downloads: 430)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

5-free-gpio-state.ino.merged.zip (Size: 179.48 KB / Downloads: 449)

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

Sun, 20 Apr 2025 13:54:17 +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 15

#define RS485_TXD 7

// 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 A2v3!");

  // 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: 763 bytes / Downloads: 471)
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: 184.35 KB / Downloads: 450)

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

Sun, 20 Apr 2025 13:50:59 +0800

Code:
/**

 * @brief Simple example to read two digital inputs using ESP32

 * @details This program demonstrates how to read two digital input states

 *          from GPIO16 and GPIO17 of an ESP32 development board.

 *

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

 */

// Define the GPIO pins for digital inputs

#define INPUT1_PIN 16  // GPIO16 for Digital Input 1

#define INPUT2_PIN 17  // GPIO17 for Digital Input 2

void setup() {

    // Initialize the serial communication for debugging

    Serial.begin(115200);

    Serial.println("ESP32 Digital Input Read Example");

    // Set the input pins as INPUT

    pinMode(INPUT1_PIN, INPUT);

    pinMode(INPUT2_PIN, INPUT);

}

void loop() {

    // Read the state of the digital inputs

    int state1 = digitalRead(INPUT1_PIN);

    int state2 = digitalRead(INPUT2_PIN);

    // Print the states to the Serial Monitor

    Serial.print("Digital Input 1 State: ");

    Serial.println(state1);

    Serial.print("Digital Input 2 State: ");

    Serial.println(state2);

    // Wait for 500 milliseconds before reading again

    delay(500);

}

arduino ino file download:

2-digital-input.zip (Size: 667 bytes / Downloads: 422)
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: 179.35 KB / Downloads: 414)

[arduino code examples for A2v3]-01 Turn ON/OFF OUTPUT

Sun, 20 Apr 2025 13:48:14 +0800

Code:
/**

 * @brief Simple example to control two relays using ESP32

 * @details This program demonstrates how to control two relays connected to GPIO40 and GPIO39

 *          of an ESP32 development board.

 *

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

 */

// Define the GPIO pins for the relays

#define RELAY1_PIN 40  // GPIO40 for Relay 1

#define RELAY2_PIN 39  // GPIO39 for Relay 2

void setup() {

    // Initialize the serial communication for debugging

    Serial.begin(115200);

    Serial.println("ESP32 Relay Control Example");

    // Set the relay pins as output

    pinMode(RELAY1_PIN, OUTPUT);

    pinMode(RELAY2_PIN, OUTPUT);

    // Turn off both relays at startup (assuming active LOW relays)

    digitalWrite(RELAY1_PIN, HIGH);

    digitalWrite(RELAY2_PIN, HIGH);

}

void loop() {

    Serial.println("Turning ON Relay 1");

    digitalWrite(RELAY1_PIN, LOW); // Activate relay 1

    delay(1000); // Wait for 1 second

    Serial.println("Turning OFF Relay 1");

    digitalWrite(RELAY1_PIN, HIGH); // Deactivate relay 1

    delay(1000);

    Serial.println("Turning ON Relay 2");

    digitalWrite(RELAY2_PIN, LOW); // Activate relay 2

    delay(1000);

    Serial.println("Turning OFF Relay 2");

    digitalWrite(RELAY2_PIN, HIGH); // Deactivate relay 2

    delay(1000);

}

arduino ino file download:

1-output.zip (Size: 683 bytes / Downloads: 427)
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: 179.19 KB / Downloads: 461)

KC868-A2v3 ESPHome yaml for home assistant

Sun, 20 Apr 2025 13:46:01 +0800

A2v3-HA.png (Size: 95.9 KB / Downloads: 761)

Code:
esphome:

  name: a2v3

  friendly_name: a2v3

esp32:

  board: esp32-s3-devkitc-1

  framework:

    type: arduino

# Enable logging

logger:

# Enable Home Assistant API

api:

ethernet:

  type: W5500

  clk_pin: GPIO42

  mosi_pin: GPIO43

  miso_pin: GPIO44

  cs_pin: GPIO41

  interrupt_pin: GPIO2

  reset_pin: GPIO1

i2c:

   - id: bus_a

     sda: 48

     scl: 47

     scan: true

     frequency: 400kHz

uart:

  - id: uart_1

    baud_rate: 9600

    debug:

      direction: BOTH

      dummy_receiver: true

      after:

        timeout: 10ms

    tx_pin: 7

    rx_pin: 15

  - id: uart_sim7600

    baud_rate: 115200

    debug:

      direction: BOTH

      dummy_receiver: true

      after:

        timeout: 10ms

      sequence:

        - lambda: UARTDebug::log_string(direction, bytes);

    tx_pin: 10

    rx_pin: 9

switch:

  - platform: gpio

    pin: 40

    name: "A2v3-Relay1"

  - platform: gpio

    pin: 39

    name: "A2v3-Relay2"

  - platform: uart

    uart_id: uart_1

    name: "RS485 Button"

    data: [0x11, 0x22, 0x33, 0x44, 0x55]

  - platform: uart

    uart_id: uart_sim7600

    name: "UART 4G"

    data: "AT+CGSN\r\n" # read 4G SIM7600 ID

binary_sensor:

  - platform: gpio

    name: "A2v3-input1"

    pin: 

      number: 16

      inverted: true

  - platform: gpio

    name: "A2v3-input2"

    pin:

      number: 17

      inverted: true

  - platform: gpio

    name: "IO18"

    pin:

      number: 18

      inverted: true

  - platform: gpio

    name: "IO8"

    pin:

      number: 8

      inverted: true

  - platform: gpio

    name: "IO4"

    pin:

      number: 4

      mode:

        input: true

        pullup: true

      inverted: true

  - platform: gpio

    name: "IO5"

    pin:

      number: 5

      mode:

        input: true

        pullup: true

      inverted: true

  - platform: gpio

    name: "IO6"

    pin:

      number: 6

      mode:

        input: true

        pullup: true

      inverted: true

  - platform: gpio

    name: "IO38"

    pin:

      number: 38

      mode:

        input: true

        pullup: true

      inverted: true

web_server:

  port: 80

font:

  - file: "gfonts://Roboto"

    id: roboto

    size: 20

display:

  - platform: ssd1306_i2c

    i2c_id: bus_a

    model: "SSD1306 128x64"

    address: 0x3C

    lambda: |-

      it.printf(0, 0, id(roboto), "A2v3");

esphome yaml file download:

A2v3-HA.txt (Size: 2.39 KB / Downloads: 383)

KC868-A2v3 ESP32-S3 IO pins define

Sun, 20 Apr 2025 13:44:35 +0800

IIC Bus:

SDA:GPIO48
SCL:GPIO47

24C02 EPROM i2c address: 0x50
DS3231 RTC i2c address: 0x68
SSD1306 display: i2c address:0x3c
-----------------

1-wire (pull-up resistance on PCB):
1-wire(TMP1):GPIO18
1-wire(TMP2):GPIO8

free GPIOs (without pull-up resistance on PCB):
free gpio-1:GPIO4
free gpio-2:GPIO5
free gpio-3:GPIO6
free gpio-4:GPIO38
-----------------

Ethernet (W5500) I/O define:

clk_pin: GPIO42
mosi_pin: GPIO43
miso_pin: GPIO44
cs_pin: GPIO41

interrupt_pin: GPIO2
reset_pin: GPIO1

--------------------
RS485:
RXD:GPIO15
TXD:GPIO7

4G module:
RXD:GPIO9
TXD:GPIO10

--------------------
SD Card:
SPI-MOSI:GPIO12
SPI-SCK:GPIO13
SPI-MISO:GPIO14
SPI-CS:GPIO11
SPI-CD:GPIO21

--------------------
Relay1:GPIO40
Relay2:GPIO39

--------------------
digital input-1:GPIO16
digital input-2:GPIO17