Smart Home Automation Forum - KC868-A6v3

Can't connect using KCS firmware

Sun, 15 Feb 2026 17:30:20 +0800

I just purchased KC868-A6V3 Board.
On connecting the unit I tried connecting using wifi hotspot.
I did not find the hotspot I was expecting instead a "Hidden network" appeared in Wifi network list.
I was unable to connect to this
I thought that perhaps unit had shipped unconfigured as I purchased from Aliexpress.
I then tried flashing using KCS_A6V3__v3.19.0 firmware but got the same result.
Firmware tool indicated successful installation.
I then tried setting up using ESPhome in HA using your supplied YAML file and that worked OK , unit comes online , relays are able to be used.
I tried again using KCS firmware but still same result and Hidden network appeared again in Wifi list.
I tried connecting using SSID of ALR-0070077FE024 and passkey supplied in ESPhome YAML file which got me to the message "unable to connect to this network"
I then went back to ESPhome configuration and it works again and appears online , relays work
This proves that the hardware works but I really want to use the Lora functionality to control some water controllers I have.
Also the LCD display has never displayed anything , - why
Any assistance you can supply is much appreciated

Using a different OLED

Thu, 14 Aug 2025 17:38:01 +0800

Good Evening, hoping someone has done this or knows what I need todo.

I'm looking to add a larger screen to the A6v3.

I'm looking to add this type of screen, im having an issue with selecting the appropriate pins on the board & assigning the appropriate pins in my arduino code.

Thankyou in advance

Damien

KC868 0-5 inputs

Mon, 04 Aug 2025 16:30:18 +0800

I have a Kincony KC868-A6 and I wonder if I could convert the 2 4-20mA inputs to 0-5v DC inputs.
I went trough the documentation (and diagram) and I can’t figure out how to do this.
https://www.kincony.com/download/KC868-A6-schematic.pdf

I understand that I need to replace two resistance switch "4-20mA" --> "0-5v" type signal but I can't figure out what to do.
Best regards,
Vincent

How to calculate ADC voltage input?

Mon, 28 Jul 2025 19:32:42 +0800

Hi everyone,

I'm using the KC868-A16- board and its on-board analog input circuit. I've observed a resistive divider (R1=5.1K, R2=10K) connected to an op-amp, which then feeds into the ADC. Does this on-board op-amp alter the voltage coming from the resistive divider for measurement purposes? Or just for protection? I'm using Vout = Vin * R2/(R1+R2).

USB serial not working

Thu, 05 Jun 2025 05:35:17 +0800

I just received the A6v3 board but it won't connect to my computer properly. I have to reconnected the cable about 30-40 times before I get a working serial connection. I have tried 5 different usbc and usba cables and it makes no difference. I also tried it on 2 computers using all available usb ports. I have also tried reinstalling all USB drivers.

I have never had a problem with any ESP32 board including A6v1, A4 or any esp32 dev module including the espressif esp32-s3 devkit module.

What am I doing wrong or is this board faulty?

Board was purchased from Kincony controller store on aliexpress.

[arduino code examples for A6v3]-12 Read DS18B20 by 1-wire

Fri, 18 Apr 2025 13:33:20 +0800

here is ESP32 DS18B20 arduino library for KC868-A6v3.

esp32-ds18b20-main.zip (Size: 6.49 KB / Downloads: 473)

KC868-A6v3 ESPHome yaml for home assistant

Sat, 15 Feb 2025 13:43:55 +0800

Code:
esphome:

  name: a6v3

  friendly_name: a6v3

esp32:

  board: esp32-s3-devkitc-1

  framework:

    type: arduino

# Enable logging

logger:

# Enable Home Assistant API

api:

wifi:

  ssid: "KinCony"

  password: "a12345678"

  # Enable fallback hotspot (captive portal) in case wifi connection fails

  ap:

    ssid: "A6 Fallback Hotspot"

    password: "GLdHSsZr1p96"

captive_portal:

i2c:

  sda: 12

  scl: 11

  scan: true

  id: bus_a

pcf8574:

  - id: 'pcf8574_hub_out_1'  # for output channel 1-8

    address: 0x24

  - id: 'pcf8574_hub_in_1'  # for input channel 1-8

    address: 0x22

uart:

  - id: uart_1    #RS485

    baud_rate: 9600

    debug:

      direction: BOTH

      dummy_receiver: true

      after:

        timeout: 10ms

    tx_pin: 17

    rx_pin: 18

  - id: uart_2    #RS232

    baud_rate: 9600

    debug:

      direction: BOTH

      dummy_receiver: true

      after:

        timeout: 10ms

    tx_pin: 9

    rx_pin: 10

switch:

  - platform: gpio

    name: "A6v3-output1"

    id: a6v3_output1

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 0

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "A6v3-output2"

    id: a6v3_output2

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 1

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "A6v3-output3"

    id: a6v3_output3

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 2

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "A6v3-output4"

    id: a6v3_output4

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 3

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "A6v3-output5"

    id: a6v3_output5

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 4

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "A6v3-output6"

    id: a6v3_output6

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 5

      mode: OUTPUT

      inverted: true

  - platform: uart

    uart_id: uart_1

    name: "RS485 Button"

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

  - platform: uart

    uart_id: uart_2

    name: "RS232 Button"

    data: [0x55, 0x66, 0x77, 0x88, 0x99]

binary_sensor:

  - platform: gpio

    name: "A6v3-input1"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 0

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "A6v3-input2"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 1

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "A6v3-input3"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 2

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "A6v3-input4"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 3

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "A6v3-input5"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 4

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "A6v3-input6"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 5

      mode: INPUT

      inverted: true

##pull-up resistance on PCB

  - platform: gpio

    name: "A6v3-W1-io15"

    pin: 

      number: 15

      inverted: true

  - platform: gpio

    name: "A6v3-W1-io16"

    pin: 

      number: 16

      inverted: true

  - platform: gpio

    name: "A6v3-W1-DW"

    pin: 

      number: 0

      inverted: true

sensor:

  - platform: adc

    pin: 4

    name: "A6v3 A1 Voltage"

    update_interval: 5s

    attenuation: 11db

    filters:

      - lambda:

          if (x >= 3.11) {

            return x * 1.60256;

          } else if (x <= 0.15) {

            return 0;

          } else {

            return x * 1.51;

          }

  - platform: adc

    pin: 5

    name: "A6v3 A2 Voltage"

    update_interval: 5s

    attenuation: 11db

    filters:

      # - multiply: 1.51515

      - lambda:

          if (x >= 3.11) {

            return x * 1.60256;

          } else if (x <= 0.15) {

            return 0;

          } else {

            return x * 1.51;

          }

  - platform: adc

    pin: 6

    name: "A6v3 A3 Current"

    update_interval: 5s

    unit_of_measurement: mA

    attenuation: 11db

    filters:

      - multiply: 6.66666666

  - platform: adc

    pin: 7

    name: "A6v3 A4 Current"

    update_interval: 5s

    unit_of_measurement: mA

    attenuation: 11db

    filters:

      - multiply: 6.66666666

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), "KinCony A6v3");

gp8403:

  id: my_gp8403

  voltage: 10V

output:

  - platform: gp8403

    id: gp8403_output_1

    gp8403_id: my_gp8403

    channel: 0

  - platform: gp8403

    id: gp8403_output_2

    gp8403_id: my_gp8403

    channel: 1

light:

  - platform: monochromatic

    name: "A6v3-DAC-1"

    output: gp8403_output_1

  - platform: monochromatic

    name: "A6v3-DAC-2"

    output: gp8403_output_2

web_server:

  port: 80

esphome yaml file download:
A6v3-HA.txt (Size: 5.11 KB / Downloads: 627)

KC868-A6v3 ESP32-S3 IO pins define

Sat, 15 Feb 2025 13:42:50 +0800

ANALOG_A1 GPIO4
ANALOG_A2 GPIO5
ANALOG_A3 GPIO6
ANALOG_A4 GPIO7

1-wire (pull-up resistance on PCB):
1-wire1:GPIO15
1-wire2:GPIO16

GP8403 DAC i2c address: 0x58

IIC SDA:GPIO12
IIC SCL:GPIO11

Input_IIC_address 0x22
Relay_IIC_address 0x24

RS485 RXD: GPIO18
RS485 TXD: GPIO17

SPI_Bus: (For LoRA/nRF24L01)
CS: GPIO38
MOSI: GPIO43
MISO: GPIO44
SCK: GPIO39

LoRA sx1278:
RST:GPIO42
DIO0:GPIO41

nRF24L01:
CE: GPIO40

RS232:
TXD:GPIO9
RXD:GPIO10

free GPIO on PCB (beside ESP32-S3 module)
GPIO8
GPIO13
GPIO14
GPIO21
GPIO47
GPIO48

[arduino code examples for A6v3]-11 SX1278 LoRA wireless receiver and transmitter

Wed, 15 Jan 2025 11:21:57 +0800

SX1278 Transmitter:

Code:
#include 

#include 

#define ss 38

#define rst 42

#define dio0 41

int counter = 0;

void setup() 

{

  Serial.begin(115200); 

  while (!Serial);

  Serial.println("LoRa Sender");

  LoRa.setPins(ss, rst, dio0);    //setup LoRa transceiver module

  while (!LoRa.begin(433E6))     //433E6 - Asia, 866E6 - Europe, 915E6 - North America

  {

    Serial.println(".");

    delay(500);

  }

  LoRa.setSyncWord(0xA5);

  Serial.println("LoRa Initializing OK!");

}

void loop() 

{

  Serial.print("Sending packet: ");

  Serial.println(counter);

  LoRa.beginPacket();   //Send LoRa packet to receiver

  LoRa.print("hello ");

  LoRa.print(counter);

  LoRa.endPacket();

  counter++;

  delay(2000);

}

SX1278 Receiver:

Code:
#include 

#include 

#define ss 38

#define rst 42

#define dio0 41

void setup() 

{

  Serial.begin(115200);

  while (!Serial);

  Serial.println("LoRa Receiver");

  LoRa.setPins(ss, rst, dio0);    //setup LoRa transceiver module

  while (!LoRa.begin(433E6))     //433E6 - Asia, 866E6 - Europe, 915E6 - North America

  {

    Serial.println(".");

    delay(500);

  }

  LoRa.setSyncWord(0xA5);

  Serial.println("LoRa Initializing OK!");

}

void loop() 

{

  int packetSize = LoRa.parsePacket();    // try to parse packet

  if (packetSize) 

  {

    Serial.print("Received packet '");

    while (LoRa.available())              // read packet

    {

      String LoRaData = LoRa.readString();

      Serial.print(LoRaData); 

    }

    Serial.print("' with RSSI ");         // print RSSI of packet

    Serial.println(LoRa.packetRssi());

  }

}

[arduino code examples for A6v3]-10 nRF24L01 wireless receiver and transmitter

Wed, 15 Jan 2025 11:17:44 +0800

nRF24L01 Transmitter:

Code:
#include 

#include 

#include 

#define CE_PIN 40

#define CSN_PIN 38

const uint64_t abc = 0xE8E8F0F0E1LL;

RF24 radio(CE_PIN, CSN_PIN);

char data[] = "Hello World, KinCony"; 

void setup()

 {

   Serial.begin(9600);

   radio.begin();

   radio.openWritingPipe(abc);

 }

void loop()

 {

   radio.write( data, sizeof(data) );

 }

nRF24L01 Receiver:

Code:
#include 

#include 

#include 

#define CE_PIN 40

#define CSN_PIN 38

const uint64_t id = 0xE8E8F0F0E1LL;

RF24 radio(CE_PIN, CSN_PIN);

#define SIZE 32            // this is the maximum for this example. (minimum is 1)

char buffer[SIZE + 1];     // for the RX node

uint8_t counter = 0;       // for counting the number of received payloads

void setup()

 {

   Serial.begin(9600);

   delay(1000);

   Serial.println("Nrf24L01 Receiver Starting");

   radio.begin();

   radio.openReadingPipe(1,id);

   radio.startListening();;

 }

void loop()

 {

    if (radio.available()) {         // is there a payload?

      radio.read(&buffer, SIZE);     // fetch payload from FIFO

      Serial.print("Received:");

      Serial.print(buffer);          // print the payload's value

      Serial.print(" - ");

      Serial.println(counter++);     // print the received counter

    }

 }

[arduino code examples for A6v3]-09 Dimmer analog output by GP8403

Wed, 15 Jan 2025 11:15:36 +0800

Code:
/*

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

 *

 * This Arduino program controls the GP8403 DAC I2C chip using an ESP32-S3 board. 

 * The program sets the DAC outputs for two channels:

 * - Channel 0 (CH0) outputs 5V.

 * - Channel 1 (CH1) outputs 10V.

 *

 * The I2C communication is handled using the Wire library, and the SDA and SCL pins 

 * are custom defined as GPIO12 (SDA) and GPIO11 (SCL).

 *

 * GP8403 I2C address: 0x58

 */

#include "DFRobot_GP8403.h"

// Initialize the GP8403 DAC object with the I2C address 0x58

DFRobot_GP8403 dac(&Wire, 0x58);

void setup() {

  // Start serial communication for debugging purposes

  Serial.begin(115200);

  // Initialize I2C communication with custom SDA and SCL pins

  Wire.begin(12, 11);  // SDA = GPIO12, SCL = GPIO11

  // Try to initialize the DAC, retry if initialization fails

  while(dac.begin() != 0) {

    Serial.println("Initialization failed, retrying...");

    delay(1000);  // Wait for 1 second before retrying

  }

  // If initialization succeeds

  Serial.println("Initialization successful!");

  // Set the DAC output range to 10V (this setting applies to both channels)

  dac.setDACOutRange(dac.eOutputRange10V);

  // Set the output for DAC channel 0 to 5V

  // Range for 10V mode is 0-10000, so 5000 represents 5V

  dac.setDACOutVoltage(5000, 0);  // Set CH0 to 5V

  Serial.println("Channel 0 set to 5V");

  // Set the output for DAC channel 1 to 10V

  dac.setDACOutVoltage(10000, 1);  // Set CH1 to 10V

  Serial.println("Channel 1 set to 10V");

  // Store the data in the chip's non-volatile memory so it persists after power-off

  dac.store();

  Serial.println("DAC values stored in memory");

}

void loop() {

  // No need to continuously write the values, the DAC holds the last set value

}

arduino ino file download:
dac-GP8403.zip (Size: 975 bytes / Downloads: 471)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
dac-GP8403.ino.merged.zip (Size: 189.99 KB / Downloads: 453)

[arduino code examples for A6v3]-08 Print TEXT on SSD1306 OLED displayer

Wed, 15 Jan 2025 11:12:57 +0800

Code:
/*OLED SSD1306 Code for KC868-A6v3*/

#include 

#include 

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,  11, 12, U8X8_PIN_NONE);//SCL IO11  SDA  IO12   

void page1() {

  u8g2.setFont(u8g2_font_timR18_tf);// Font 18

  u8g2.setFontPosTop();

  u8g2.setCursor(5,0);

  u8g2.print("KINCONY");

  u8g2.setFont(u8g2_font_timR12_tf);//Font 12

  u8g2.setCursor(0,40);

  u8g2.print("www.kincony.com");

}

void setup(){

  u8g2.setI2CAddress(0x3C*2);

  u8g2.begin();

  u8g2.enableUTF8Print();

}

void loop(){

  u8g2.firstPage();

  do

  {

    page1();

  }while(u8g2.nextPage());

}

arduino ino file download:
oled.zip (Size: 500 bytes / Downloads: 451)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
oled.ino.merged.zip (Size: 201.21 KB / Downloads: 439)

[arduino code examples for A6v3]-07 digital INPUT trigger OUTPUT directly

Wed, 15 Jan 2025 11:10:00 +0800

Code:
/*

  PCF8574 I2C Digital I/O Expander Example

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

  Description:

  This program demonstrates how to use a PCF8574 I2C expander to read input pins and control relays.

  It reads input states from a PCF8574 module and controls corresponding relays.

  The program initializes the input pins as INPUT and output pins as OUTPUT.

  When an input is triggered (LOW), the corresponding relay (output) will activate (LOW).

  It also prevents the relays from briefly activating on startup.

  Custom I2C pins are defined for SDA and SCL.

  License:

  You are free to use and modify this code for personal or commercial purposes as long as this

  copyright notice remains intact.

*/

// Define custom I2C pins for communication

#define SDA_PIN 12    // Set SDA pin for I2C communication

#define SCL_PIN 11   // Set SCL pin for I2C communication

#include "Arduino.h"

#include "PCF8574.h"

#include 

// Define I2C addresses for the input and output PCF8574 modules

PCF8574 pcf8574_input(0x22);  // I2C address for the input expander (change according to your setup)

PCF8574 pcf8574_output(0x24); // I2C address for the output expander (change according to your setup)

void setup() {

  // Start serial communication for debugging purposes

  Serial.begin(115200);

  delay(1000);  // Wait for serial communication to initialize

  // Initialize I2C and set custom SDA and SCL pins

  Wire.begin(SDA_PIN, SCL_PIN);

  // Ensure all relay outputs are set to HIGH (deactivated) before initializing the expander

  // This step is to avoid any relay from briefly turning on during setup

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

    pcf8574_output.digitalWrite(i, HIGH);

  }

  // Initialize input pins as INPUT

  pcf8574_input.pinMode(P0, INPUT);

  pcf8574_input.pinMode(P1, INPUT);

  pcf8574_input.pinMode(P2, INPUT);

  pcf8574_input.pinMode(P3, INPUT);

  pcf8574_input.pinMode(P4, INPUT);

  pcf8574_input.pinMode(P5, INPUT);

  // Initialize output pins as OUTPUT (these control the relays)

  pcf8574_output.pinMode(P0, OUTPUT);

  pcf8574_output.pinMode(P1, OUTPUT);

  pcf8574_output.pinMode(P2, OUTPUT);

  pcf8574_output.pinMode(P3, OUTPUT);

  pcf8574_output.pinMode(P4, OUTPUT);

  pcf8574_output.pinMode(P5, OUTPUT);

  // Ensure all outputs (relays) are deactivated at the start (set to HIGH)

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

    pcf8574_output.digitalWrite(i, HIGH);

  }

  // Initialize the PCF8574 modules and check for errors

  Serial.print("Init pcf8574_input...");

  if (pcf8574_input.begin()) {

    Serial.println("OK");  // Input expander initialized successfully

  } else {

    Serial.println("KO");  // Input expander initialization failed

  }

  Serial.print("Init pcf8574_output...");

  if (pcf8574_output.begin()) {

    Serial.println("OK");  // Output expander initialized successfully

  } else {

    Serial.println("KO");  // Output expander initialization failed

  }

}

void loop() {

  // Read input states from the input expander (PCF8574)

  uint8_t val[6];  // Array to store input states

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

    val[i] = pcf8574_input.digitalRead(i);  // Read the state of each input pin

  }

  // Control relays based on the input states

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

    if (val[i] == LOW) {

      // If the input is LOW (triggered), activate the corresponding relay (set to LOW)

      pcf8574_output.digitalWrite(i, LOW);

    } else {

      // If the input is HIGH (not triggered), deactivate the corresponding relay (set to HIGH)

      pcf8574_output.digitalWrite(i, HIGH);

    }

  }

  delay(300);  // Small delay to prevent rapid state changes

}

arduino ino file download:
Input-trigger-Output.zip (Size: 1.35 KB / Downloads: 468)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
Input-trigger-Output.ino.merged.zip (Size: 191.31 KB / Downloads: 427)

[arduino code examples for A6v3]-06 how to DS3231 RTC clock

Wed, 15 Jan 2025 11:08:04 +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 12

 * - SCL: GPIO 11

 */

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

#define SCL_PIN   11

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:
DS3231-RTC.zip (Size: 1.55 KB / Downloads: 487)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
DS3231-RTC.ino.merged.zip (Size: 191.07 KB / Downloads: 467)

[arduino code examples for A6v3]-05 RS232 communication test

Wed, 15 Jan 2025 11:06:08 +0800

Code:
#include "Arduino.h"

// Define RS232 pins

#define RS232_TXD 9 // TX pin

#define RS232_RXD 10 // RX pin

// Define RS232 communication

HardwareSerial RS232(1); // Use UART1

void setup() {

  // Initialize RS232 serial communication

  RS232.begin(9600, SERIAL_8N1, RS232_RXD, RS232_TXD); // Baud rate 9600, 8 data bits, no parity, 1 stop bit

  Serial.begin(115200); // Debug serial communication

  Serial.println("RS232 Communication Initialized");

}

void loop() {

  static unsigned long lastSendTime = 0;

  // Send a string to RS232 every 5 seconds

  if (millis() - lastSendTime >= 5000) {

    RS232.println("This is KinCony A6v3");

    Serial.println("Sent: This is KinCony A6v3");

    lastSendTime = millis();

  }

  // Check if data is available from RS232

  while (RS232.available()) {

    String receivedData = RS232.readStringUntil('\n'); // Read data from RS232

    RS232.println(receivedData); // Echo the received data back to RS232

    Serial.println("Received and echoed: " + receivedData); // Print the received data to the debug console

  }

}

arduino ino file download:
RS232.zip (Size: 659 bytes / Downloads: 453)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
RS232.ino.merged.zip (Size: 184.5 KB / Downloads: 459)