Smart Home Automation Forum - F8

F8 ESPHome yaml for home assistant with tuya

Mon, 03 Aug 2026 07:00:09 +0800

Code:
esphome:

  name: f8

  friendly_name: f8

  platformio_options:

    board_build.extra_flags:

      # WIFI_CONTROL_SELF_MODE = 0

      # WIFI_CONTROL_SELF_MODE = 1

      - "-DWIFI_CONTROL_SELF_MODE=1"

esp32:

  board: esp32-s3-devkitc-1

  framework:

    type: arduino

external_components:

  - source:

      type: git

      url: https://github.com/hzkincony/esphome-tuya-wifi-mcu

      ref: v1.3.1

# Enable logging

  # hardware_uart: USB_SERIAL_JTAG

# Enable Home Assistant API

api:

  encryption:

    key: "WeVOuL5oNhjXcfzXtTirlOwvtWvCD5yqIxd3oV4es1k="

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: 8

     scl: 18

     scan: true

     frequency: 400kHz

pcf8574:

  - id: 'pcf8574_hub_in_1'  # for DI1-DI4 Relay1-Relay4

    i2c_id: bus_a

    address: 0x24

    pcf8575: true

uart:

  - id: uart_1    #RS485

    baud_rate: 9600

    debug:

      direction: BOTH

      dummy_receiver: true

      after:

        timeout: 10ms

    tx_pin: 16

    rx_pin: 17

  - id: tuya_mcu_uart

    tx_pin: GPIO39

    rx_pin: GPIO38

    baud_rate: 9600

tuya_wifi_mcu:

  # tuya mcu product id

  product_id: gk6ok3aysk6lw1bb

  uart_id: tuya_mcu_uart

  wifi_reset_pin: 28

  wifi_led_pin: 16

switch:

  - platform: uart

    uart_id: uart_1

    name: "RS485 Button"

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

  - platform: gpio

    name: "f8-output01"

    id: "f8_output01"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 8

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output1-tuya

    dp_id: 1

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output01"

  - platform: gpio

    name: "f8-output02"

    id: "f8_output02"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 9

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output2-tuya

    dp_id: 2

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output02"

  - platform: gpio

    name: "f8-output03"

    id: "f8_output03"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 10

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output3-tuya

    dp_id: 3

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output03"

  - platform: gpio

    name: "f8-output04"

    id: "f8_output04"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 11

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output4-tuya

    dp_id: 4

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output04"

  - platform: gpio

    name: "f8-output05"

    id: "f8_output05"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 12

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output5-tuya

    dp_id: 5

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output05"

  - platform: gpio

    name: "f8-output06"

    id: "f8_output06"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 13

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output6-tuya

    dp_id: 6

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output06"

  - platform: gpio

    name: "f8-output07"

    id: "f8_output07"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 14

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output4-tuya

    dp_id: 101

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output07"

  - platform: gpio

    name: "f8-output08"

    id: "f8_output08"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 15

      mode: OUTPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-output8-tuya

    dp_id: 102

    # hide from homeassistant ui

    internal: true

    # bind other switch, sync state

    bind_switch_id: "f8_output08"

binary_sensor:

  - platform: gpio

    name: "f8-input01"

    id: "f8_input01"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 0

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input1-tuya

    dp_id: 111

    bind_binary_sensor_id: f8_input01

    internal: true

  - platform: gpio

    name: "f8-input02"

    id: "f8_input02"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 1

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input2-tuya

    dp_id: 112

    bind_binary_sensor_id: f8_input02

    internal: true

  - platform: gpio

    name: "f8-input03"

    id: "f8_input03"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 2

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input3-tuya

    dp_id: 113

    bind_binary_sensor_id: f8_input03

    internal: true

  - platform: gpio

    name: "f8-input04"

    id: "f8_input04"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 3

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input4-tuya

    dp_id: 114

    bind_binary_sensor_id: f8_input04

    internal: true

  - platform: gpio

    name: "f8-input05"

    id: "f8_input05"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 4

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input5-tuya

    dp_id: 115

    bind_binary_sensor_id: f8_input05

    internal: true

  - platform: gpio

    name: "f8-input06"

    id: "f8_input06"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 5

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input6-tuya

    dp_id: 116

    bind_binary_sensor_id: f8_input06

    internal: true

  - platform: gpio

    name: "f8-input07"

    id: "f8_input07"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 6

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input7-tuya

    dp_id: 117

    bind_binary_sensor_id: f8_input07

    internal: true

  - platform: gpio

    name: "f8-input08"

    id: "f8_input08"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 7

      mode: INPUT

      inverted: true

  - platform: tuya_wifi_mcu

    name: f8-input8-tuya

    dp_id: 118

    bind_binary_sensor_id: f8_input08

    internal: true

##pull-up resistance on PCB

  - platform: gpio

    name: "f8-W1-io48"

    pin: 

      number: 48

      inverted: true

  - platform: gpio

    name: "f8-W1-io47"

    pin: 

      number: 47

      inverted: true

  - platform: gpio

    name: "f8-W1-io21"

    pin: 

      number: 21

      inverted: true

  - platform: gpio

    name: "f8-W1-io15"

    pin: 

      number: 15

      inverted: true

## without resistance on PCB

  - platform: gpio

    name: "f8-W1-io14"

    pin: 

      number: 14

      inverted:  false

  - platform: gpio

    name: "f8-433M"

    pin: 

      number: 40

      inverted:  false

  - platform: gpio

    name: "f8-io0"

    pin: 

      number: 0

      inverted:  false

sensor:

  - platform: adc

    pin: 5

    name: "f8 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: 7

    name: "f8 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: "f8 A3 Current"

    update_interval: 5s

    unit_of_measurement: mA

    attenuation: 11db

    filters:

      - multiply: 6.66666666

  - platform: adc

    pin: 4

    name: "f8 A4 Current"

    update_interval: 5s

    unit_of_measurement: mA

    attenuation: 11db

    filters:

      - multiply: 6.66666666

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

esphome yaml:

F8-HA-tuya.txt (Size: 8.68 KB / Downloads: 127)

KinCony F8 + ESPHome: Unable to Enter Tuya Pairing Mode (Smart Config)

Sat, 01 Aug 2026 19:49:35 +0800

Hi!

I'm trying to pair a KinCony F8 device with my Tuya account. I flashed it with an ESPHome firmware, and it is working perfectly with Home Assistant.

Now I'd like to add Tuya connectivity. Based on the example code shared in this forum, I installed the firmware on my device, but I can't get it to enter pairing mode.

One thing that seems unusual is that the Tuya module never appears to complete its initialization. As shown in the attached ESPHome logs, the message "begin smart config" is printed repeatedly about every 50 ms, making it look as if the module is continuously trying to enter Smart Config instead of staying in pairing mode. Could this indicate that the Tuya module is not responding correctly or that I'm missing an initialization step?

I've attached the ESPHome firmware and the ESPHome logs.

I would really appreciate your help identifying what I'm doing wrong and how to get it working.

Thank you very much!
Guillermo

test-logs.txt (Size: 6.34 KB / Downloads: 158)

Kincony-F8-ESPHome-Tuya.txt (Size: 4.14 KB / Downloads: 102)

F8 Smart Controller Wiring Examples

Sun, 19 Apr 2026 15:42:46 +0800

F8_wiring.jpg (Size: 335 KB / Downloads: 382)

F8 Smart Controller ESP32 system block diagram

Sun, 19 Apr 2026 15:41:51 +0800

KinCony-F8-smart-controller-diagram.png (Size: 792.15 KB / Downloads: 392)

F8 on device physical switches in ESPHome

Sun, 15 Mar 2026 04:07:51 +0800

Hi - with esp-idf in ESPHome, how can I access the state of the physical on device switches?

I can't seem to observe those on any GPIO pins.

I would like to configure (in esphome) some of them to control their output relay directly, but for others for them to act as momentary switches. I can manage all the coding myself if I can work out where to observe their state...

Thanks.

F8 N16R8

Fri, 30 Jan 2026 20:15:03 +0800

Hi Gerarding model F8 N16R8 . There are have UART pin ?

F8 physical on device switches

Mon, 12 Jan 2026 18:54:34 +0800

Hello KinCony,

I have a question about the physical switch exists on the device itself, I need to be able to change their behavior to toggle switch instead of normal switch. I mean to toggle the relay state (on -> off, or off -> on) once it is flipped.

btw, thank your for such awesome devices.

Delay Relay F8

Wed, 24 Sep 2025 14:13:35 +0800

Pin Definitions:
Subject: Request: Sequential 8-relay example for F8 (ESP32-S3), 1.5s step, reverse on shutdown

Message:
Hello KinCony team,

I am using the KinCony F8 (ESP32-S3) board with the PCF8575 I/O expander to control 8 relays. I would like to have an Arduino example that performs the following:
• Sequential ON: Relay1 → Relay8, with 1.5 seconds delay between each relay.
• Sequential OFF: Relay8 → Relay1, with the same 1.5 seconds delay.
• Arduino IDE, using I2C with SDA = GPIO8, SCL = GPIO18, and PCF8575 address = 0x24 (please confirm).

My questions are:
1. What is the exact GPIO mapping for each relay on the F8 hardware revision?
2. Do you have an official Arduino example implementing this sequence?
3. If there is a recommended library or header file for this board, could you please share the link?

Here is a sample code I tested so far (for reference):
// I2C pins
#define SDA 8
#define SCL 18
#include
#include

#define I2C_SDA 8
#define I2C_SCL 18
#define PCF8575_ADDR 0x24

PCF8575 pcf(PCF8575_ADDR);
const uint8_t RELAY_PINS[8] = {P0, P1, P2, P3, P4, P5, P6, P7};

void setup() {
Serial.begin(115200);
if (!pcf.begin(I2C_SDA, I2C_SCL)) {
Serial.println("PCF8575 not found!");
while (1);
}
for (int i = 0; i < 8; i++) {
pcf.write(RELAY_PINS[i], HIGH); // OFF at start
}
}

void loop() {
// Sequential ON
for (int i = 0; i < 8; i++) {
Serial.print("Relay ON: "); Serial.println(i+1);
pcf.write(RELAY_PINS[i], LOW);
delay(1500);
}

// Sequential OFF
for (int i = 7; i >= 0; i--) {
Serial.print("Relay OFF: "); Serial.println(i+1);
pcf.write(RELAY_PINS[i], HIGH);
delay(1500);
}
}

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

Sun, 20 Apr 2025 15:28:23 +0800

Code:
/*

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

 *

 * This program reads 8 input states from a PCF8575 I/O expander and 

 * controls a corresponding 8-channel relay module. When an input pin 

 * is LOW, the corresponding relay is turned ON (LOW means ON for the relay).

 *

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * - PCF8575 I2C Address: 0x24

 */

#include 

#include 

// I2C pins

#define SDA 8

#define SCL 18

// PCF8575 I2C address

#define INPUT_I2C_ADDRESS 0x24   

// Create PCF8575 object

PCF8575 pcf8575_IN(INPUT_I2C_ADDRESS);

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL);

  // Initialize serial communication

  Serial.begin(115200);

  // Initialize PCF8575

  pcf8575_IN.begin();

  // Turn off all relays first (assuming LOW activates the relay)

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

    pcf8575_IN.write(i, HIGH);  // Set to HIGH to turn off the relay

  }

  Serial.println("System started: Input state controlling 8 relays");

}

void loop() {

  // Read 16-bit state from PCF8575

  uint16_t inputState = pcf8575_IN.read16(); 

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

    bool state = bitRead(inputState, i); // Read digital input state

    Serial.print("DI");

    Serial.print(i + 1);

    Serial.print(" State: ");

    Serial.println(state ? "HIGH" : "LOW");

    // Control relay (LOW activates the relay)

    pcf8575_IN.write(8 + i, state ? HIGH : LOW);

  }

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

  delay(500);

}

arduino ino file download:

11-input-trigger-output.zip (Size: 898 bytes / Downloads: 727)
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: 189.63 KB / Downloads: 690)

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

Sun, 20 Apr 2025 15:21:27 +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 IO18

 * - SDA (data) on pin IO8

 * 

 * 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 = IO18, SDA = IO8)

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,  18, 8, 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.11 KB / Downloads: 682)
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: 687)

[arduino code examples for F8]-09 how to communication with Tuya WiFi module

Sun, 20 Apr 2025 15:19:19 +0800

Code:
/*

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

 * 

 * This Arduino program implements communication between ESP32 and the Tuya module

 * via UART (serial communication). It listens for specific packets from the Tuya module

 * and responds according to the predefined commands.

 * 

 * Functionality:

 * 1. When the ESP32 receives a heartbeat packet (55 AA 00 00 00 00 FF),

 *    it sends a heartbeat response (55 AA 03 00 00 01 00 03).

 * 2. When the ESP32 receives a product information request (55 AA 00 01 00 00 00),

 *    it sends a product information response (55 AA 03 01 ...).

 * 3. When the ESP32 receives a work mode request (55 AA 00 02 00 00 01),

 *    it sends a work mode response (55 AA 03 02 00 03 10 1C 14 47).

 * 4. When the ESP32 receives a network status request (55 AA 00 03 00 01 00 03),

 *    it sends a network status response (55 AA 03 03 00 00 05).

 * 5. Subsequent heartbeat packets (55 AA 00 00 00 00 FF) are responded to with

 *    (55 AA 03 00 00 01 01 04).

 */

#include 

// Create a HardwareSerial object for UART communication on ESP32

HardwareSerial tuyaSerial(1);

// Define the GPIO pins for TXD and RXD used for serial communication

#define TXD_PIN 39

#define RXD_PIN 38

// Set the baud rate for Tuya module communication to 9600

#define BAUD_RATE 9600

// Define the response packets for different commands from the Tuya module

// Heartbeat response: 55 AA 03 00 00 01 00 03

uint8_t heartBeatResponse[] = {0x55, 0xAA, 0x03, 0x00, 0x00, 0x01, 0x00, 0x03};

// Product info response with a detailed payload (e.g., firmware version, product name, etc.)

uint8_t productInfoResponse[] = {

  0x55, 0xAA, 0x03, 0x01, 0x00, 0x2A, 0x7B, 0x22, 0x70, 0x22, 0x3A, 0x22, 

  0x63, 0x68, 0x6D, 0x7A, 0x6C, 0x67, 0x6A, 0x70, 0x61, 0x64, 0x70, 0x71, 

  0x78, 0x64, 0x6B, 0x6F, 0x22, 0x2C, 0x22, 0x76, 0x22, 0x3A, 0x22, 0x31, 

  0x2E, 0x30, 0x2E, 0x30, 0x22, 0x2C, 0x22, 0x6D, 0x22, 0x3A, 0x30, 0x7D, 0xAA

};

// Work mode response: 55 AA 03 02 00 03 10 1C 14 47

uint8_t workModeResponse[] = {0x55, 0xAA, 0x03, 0x02, 0x00, 0x03, 0x10, 0x1C, 0x14, 0x47};

// Network status response: 55 AA 03 03 00 00 05

uint8_t netStatusResponse[] = {0x55, 0xAA, 0x03, 0x03, 0x00, 0x00, 0x05};

// Subsequent heartbeat response: 55 AA 03 00 00 01 01 04

uint8_t secondHeartBeatResponse[] = {0x55, 0xAA, 0x03, 0x00, 0x00, 0x01, 0x01, 0x04};

void setup() {

  // Initialize the serial communication for debugging at 115200 baud rate

  Serial.begin(115200);

  // Initialize the serial communication with Tuya module at 9600 baud rate

  tuyaSerial.begin(BAUD_RATE, SERIAL_8N1, RXD_PIN, TXD_PIN);

  // Debug message to indicate that the serial communication has been initialized

  Serial.println("ESP32-Tuya serial communication initialized.");

}

void loop() {

  // Check if data is available from the Tuya module

  if (tuyaSerial.available()) {

    uint8_t incomingPacket[7];  // Array to store the received packet

    size_t bytesRead = tuyaSerial.readBytes(incomingPacket, 7); // Read 7 bytes from Tuya

    // Check if the packet has a valid header (0x55, 0xAA)

    if (bytesRead >= 2 && incomingPacket[0] == 0x55 && incomingPacket[1] == 0xAA) {

      // If less than 7 bytes were received, wait for more data

      if (bytesRead < 7) {

        Serial.println("Incomplete packet received. Waiting for remaining bytes...");

        delay(50); // Delay to allow more data to be received

        while (tuyaSerial.available()) {

          incomingPacket[bytesRead++] = tuyaSerial.read(); // Continue reading remaining bytes

          if (bytesRead >= 7) break;

        }

      }

      // If still less than 7 bytes, discard the incomplete packet

      if (bytesRead < 7) {

        Serial.println("Error: Incomplete packet discarded.");

        return;

      }

      // Debug: Print the received packet for logging

      Serial.print("Received packet: ");

      for (size_t i = 0; i < 7; i++) {

        Serial.print(incomingPacket[i], HEX);

        Serial.print(" ");

      }

      Serial.println();

      // Call the function to process the received packet

      processTuyaPacket(incomingPacket, 7);

    } else {

      // If the header is invalid, discard the packet and flush the buffer

      Serial.print("Error: Invalid packet header. Data received: ");

      for (size_t i = 0; i < bytesRead; i++) {

        Serial.print(incomingPacket[i], HEX);

        Serial.print(" ");

      }

      Serial.println();

      tuyaSerial.flush(); // Clear the serial buffer

    }

  }

  // Delay to avoid CPU overuse

  delay(100);

}

// Function to process the received packet and send the appropriate response

void processTuyaPacket(uint8_t* packet, size_t size) {

  // Ensure the packet size is 7 and the header is valid

  if (size == 7 && packet[0] == 0x55 && packet[1] == 0xAA) {

    // Determine the command in the packet (packet[2])

    switch(packet[2]) {

      case 0x00:

        if (packet[3] == 0x00 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0xFF) {

          Serial.println("Heartbeat received.");

          sendPacket(heartBeatResponse, sizeof(heartBeatResponse));

        } else if (packet[3] == 0x01 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0x00) {

          Serial.println("Product info request received.");

          sendPacket(productInfoResponse, sizeof(productInfoResponse));

        } else if (packet[3] == 0x02 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0x01) {

          Serial.println("Work mode request received.");

          sendPacket(workModeResponse, sizeof(workModeResponse));

        } else if (packet[3] == 0x03 && packet[4] == 0x00 && packet[5] == 0x01 && packet[6] == 0x00) {

          Serial.println("Network status request received.");

          sendPacket(netStatusResponse, sizeof(netStatusResponse));

        }

        break;

      default:

        Serial.println("Error: Unhandled command received.");

        break;

    }

  }

}

// Function to send the response packet to the Tuya module

void sendPacket(uint8_t* packet, size_t size) {

  // Send the packet via UART to Tuya module

  tuyaSerial.write(packet, size);

  // Debug: Print the sent packet for logging

  Serial.print("Sent packet: ");

  for (size_t i = 0; i < size; i++) {

    Serial.print(packet[i], HEX);

    Serial.print(" ");

  }

  Serial.println();

}

arduino ino file download:

9-tuya-wifi-config.zip (Size: 2 KB / Downloads: 745)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

9-tuya-wifi-config.ino.merged.zip (Size: 184.92 KB / Downloads: 761)

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

Sun, 20 Apr 2025 15:17:36 +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: 693)
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: 707)

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

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

 *

 * 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.51 KB / Downloads: 688)
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: 707)

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

Sun, 20 Apr 2025 15:13:57 +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: 682)
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: 681)

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

Sun, 20 Apr 2025 15:12:37 +0800

Code:
/**

 * @brief Example to read multiple digital inputs using ESP32

 * @details This program reads the states of GPIO48, GPIO47, GPIO21, GPIO15, GPIO14, and GPIO40

 *          and prints the results to the Serial Monitor.

 *

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

 */

// Define the GPIO pins for digital inputs

#define INPUT1_PIN 48  // GPIO48

#define INPUT2_PIN 47  // GPIO47

#define INPUT3_PIN 21  // GPIO21

#define INPUT4_PIN 15  // GPIO15

#define INPUT5_PIN 14  // GPIO14

#define INPUT6_PIN 40  // GPIO40

#define INPUT7_PIN 0  // GPIO0

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);

    pinMode(INPUT7_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);

    int state7 = digitalRead(INPUT7_PIN);

    // Print the states to the Serial Monitor

    Serial.print("GPIO48 State: ");

    Serial.println(state1);

    Serial.print("GPIO47 State: ");

    Serial.println(state2);

    Serial.print("GPIO21 State: ");

    Serial.println(state3);

    Serial.print("GPIO15 State: ");

    Serial.println(state4);

    Serial.print("GPIO14 State: ");

    Serial.println(state5);

    Serial.print("GPIO40 State: ");

    Serial.println(state6);

    Serial.print("GPIO0 State: ");

    Serial.println(state7);

    // Wait for 500 milliseconds before reading again

    delay(500);

}

arduino ino file download:

5-free-gpio-state.zip (Size: 780 bytes / Downloads: 683)
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.5 KB / Downloads: 692)