Smart Home Automation Forum - F32

F32 and 433 Mhz

Thu, 15 Jan 2026 08:21:12 +0800

Hello,

on the F32, if I want to use a Kincony 433 Mhz remote:

- can I do this with ESPHome instead of KCS?
- do I need to buy a RF433 MHz tx/rx module, or is it included in the board already?
- with the ESPHome firmware, how do I learn the codes from the remote controller and associate them to relays?

Thank you!

[arduino code examples for F32]-11 digital INPUT trigger OUTPUT directly

Tue, 04 Nov 2025 07:33:42 +0800

Code:
/*

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

 *

 * This program reads 32 input states from three PCF8575 I/O expanders and 

 * controls a corresponding 32-channel relay module. 

 * When an input pin is LOW, the corresponding relay is turned ON (LOW means ON for the relay).

 * When the input pin is HIGH, the corresponding relay is turned OFF.

 *

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

PCF8575:U27 (relay17-32) i2c address:0x25

PCF8575:U23 (DI1-16) i2c address:0x24

PCF8575:U49 i2c address: 0x26

  PCF8575(pin number0-7):DI17-24

  PCF8575(pin number8-11):relay13-16

  PCF8575(pin number12-15):relay9-12

PCF8575:U62 i2c address: 0x27

  PCF8575(pin number0-7):DI25-32

  PCF8575(pin number8-15):relay1-8

 */

#include         // I2C communication

#include      // Library to control the PCF8575 I/O expander

// Define I2C pins

#define SDA 8            // SDA pin

#define SCL 18           // SCL pin

// I2C addresses for the PCF8575 modules

#define INPUT_I2C_ADDRESS_1 0x24   

#define INPUT_RELAY_I2C_ADDRESS_2 0x26  

#define RELAY_I2C_ADDRESS_3 0x25  

#define INPUT_RELAY_I2C_ADDRESS_3 0x27   

PCF8575 pcf8575_IN1(INPUT_I2C_ADDRESS_1);    

PCF8575 pcf8575_IN2(INPUT_RELAY_I2C_ADDRESS_2);    

PCF8575 pcf8575_RL(RELAY_I2C_ADDRESS_3);   

PCF8575 pcf8575_IN3(INPUT_RELAY_I2C_ADDRESS_3); 

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL);

  // Initialize serial communication

  Serial.begin(115200);

  // Initialize input and relay modules

  pcf8575_IN1.begin();  

  pcf8575_IN2.begin();  

  pcf8575_IN3.begin(); 

  pcf8575_RL.begin();  

  // Turn off all relays at the start (LOW means OFF)

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

    pcf8575_IN2.write(i, HIGH); 

  }

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

    pcf8575_RL.write(i, HIGH); 

  }

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

    pcf8575_IN3.write(i, HIGH);  

  }

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

}

void loop() {

    bool inputState;

    inputState = pcf8575_IN1.read(0);  // input1 control relay1

    if (inputState) {

      pcf8575_IN3.write(8, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(8, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(1);  // input2 control relay2

    if (inputState) {

      pcf8575_IN3.write(9, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(9, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(2);  // input3 control relay3

    if (inputState) {

      pcf8575_IN3.write(10, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(10, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(3);  // input4 control relay4

    if (inputState) {

      pcf8575_IN3.write(11, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(11, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(4);  // input5 control relay5

    if (inputState) {

      pcf8575_IN3.write(12, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(12, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(5);  // input6 control relay6

    if (inputState) {

      pcf8575_IN3.write(13, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(13, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(6);  // input7 control relay7

    if (inputState) {

      pcf8575_IN3.write(14, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(14, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(7);  // input8 control relay8

    if (inputState) {

      pcf8575_IN3.write(15, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN3.write(15, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(8);  // input9 control relay9

    if (inputState) {

      pcf8575_IN2.write(12, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(12, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(9);  // input10 control relay10

    if (inputState) {

      pcf8575_IN2.write(13, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(13, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(10);  // input11 control relay11

    if (inputState) {

      pcf8575_IN2.write(14, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(14, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(11);  // input12 control relay12

    if (inputState) {

      pcf8575_IN2.write(15, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(15, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(12);  // input13 control relay13

    if (inputState) {

      pcf8575_IN2.write(8, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(8, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(13);  // input14 control relay14

    if (inputState) {

      pcf8575_IN2.write(9, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(9, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(14);  // input15 control relay15

    if (inputState) {

      pcf8575_IN2.write(10, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(10, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN1.read(15);  // input16 control relay16

    if (inputState) {

      pcf8575_IN2.write(11, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_IN2.write(11, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(0);  // input17 control relay17

    if (inputState) {

      pcf8575_RL.write(0, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(0, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(1);  // input18 control relay18

    if (inputState) {

      pcf8575_RL.write(1, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(1, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(2);  // input19 control relay19

    if (inputState) {

      pcf8575_RL.write(2, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(2, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(3);  // input20 control relay20

    if (inputState) {

      pcf8575_RL.write(3, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(3, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(4);  // input21 control relay21

    if (inputState) {

      pcf8575_RL.write(4, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(4, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(5);  // input22 control relay22

    if (inputState) {

      pcf8575_RL.write(5, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(5, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(6);  // input23 control relay23

    if (inputState) {

      pcf8575_RL.write(6, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(6, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN2.read(7);  // input24 control relay24

    if (inputState) {

      pcf8575_RL.write(7, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(7, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(0);  // input25 control relay25

    if (inputState) {

      pcf8575_RL.write(8, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(8, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(1);  // input26 control relay26

    if (inputState) {

      pcf8575_RL.write(9, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(9, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(2);  // input27 control relay27

    if (inputState) {

      pcf8575_RL.write(10, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(10, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(3);  // input28 control relay28

    if (inputState) {

      pcf8575_RL.write(11, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(11, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(4);  // input29 control relay29

    if (inputState) {

      pcf8575_RL.write(12, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(12, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(5);  // input30 control relay30

    if (inputState) {

      pcf8575_RL.write(13, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(13, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(6);  // input31 control relay31

    if (inputState) {

      pcf8575_RL.write(14, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(14, LOW);   // If input is LOW, turn the corresponding relay ON

    }

    inputState = pcf8575_IN3.read(7);  // input32 control relay32

    if (inputState) {

      pcf8575_RL.write(15, HIGH);  // If input is HIGH, turn the corresponding relay OFF

    } else {

      pcf8575_RL.write(15, LOW);   // If input is LOW, turn the corresponding relay ON

    }

  // Delay for 500 milliseconds

  delay(500);

}

arduino ino file download:

11-input-trigger-output.zip (Size: 1.54 KB / Downloads: 175)
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: 198.09 KB / Downloads: 184)

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

Tue, 04 Nov 2025 07:27:08 +0800

Code:
/*

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

 *

 *

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * - PCF8575 I2C Address: 0x24 for inputs 1-16, 0x26 for inputs 17-24, 0x27 for inputs 18-25

 */

#include "Arduino.h"

#include "PCF8575.h"

// Define I2C pins

#define I2C_SDA 8  // Define SDA pin

#define I2C_SCL 18  // Define SCL pin

// Set I2C addresses

PCF8575 pcf8575_IN1(0x24); // The I2C address of the first PCF8575 (inputs 1-16)

PCF8575 pcf8575_IN2(0x26); // The I2C address of the second PCF8575 (inputs 17-24)

PCF8575 pcf8575_IN3(0x27); // The I2C address of the second PCF8575 (inputs 25-32)

void setup() {

    Serial.begin(115200);

    // Initialize I2C communication

    Wire.begin(I2C_SDA, I2C_SCL); // Initialize I2C with defined SDA and SCL pins

    // Initialize both PCF8575 modules

    pcf8575_IN1.begin();

    pcf8575_IN2.begin();

    pcf8575_IN3.begin();

    Serial.println("KinCony F32 32 channel input state 0:ON  1:OFF");

}

void loop() {

    uint32_t state = 0; // Use a 32-bit variable to store the state of all 24 pins

    // Read the state of each pin from the first PCF8575 (inputs 1-16)

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

        if (pcf8575_IN1.read(pin)) {

            state |= (1UL << pin); // Set the bit for the active pin (inputs 1-16)

        }

    }

    // Read the state of each pin from the second PCF8575 (inputs 17-24, corresponding to pins 0-7)

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

        if (pcf8575_IN2.read(pin)) {

            state |= (1UL << (pin + 16)); // Set the bit for the active pin (inputs 17-24)

        }

    }

    // Read the state of each pin from the second PCF8575 (inputs 25-32, corresponding to pins 0-7)

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

        if (pcf8575_IN3.read(pin)) {

            state |= (1UL << (pin + 24));

        }

    }

    // Print the state of all 24 inputs in binary format

    Serial.print("Input state: ");

    Serial.println(state, BIN); // Print the state of inputs in binary

    delay(500); // Delay 500ms

}

arduino ino file download:

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

2-digital-input.ino.merged.zip (Size: 197.91 KB / Downloads: 180)

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

Tue, 04 Nov 2025 07:25:24 +0800

Code:
/*

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

 *

 * This program controls a 32-channel relay board via two PCF8575 I/O expanders.

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

 * 

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * 

 * Delay Time:

 * - 200 milliseconds between switching relays

 */

#include         // Include the Wire library for I2C communication

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

#define SDA 8            // Define the SDA pin

#define SCL 18           // Define the SCL pin

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

// Set I2C addresses of the PCF8575 modules

#define I2C_ADDRESS_R1 0x25 // I2C address of the first PCF8575 module

#define I2C_ADDRESS_R2 0x26 // I2C address of the second PCF8575 module

#define I2C_ADDRESS_R3 0x27 // I2C address of the second PCF8575 module

PCF8575 pcf8575_R1(I2C_ADDRESS_R1); // Create a PCF8575 object for the first module (for relays 17-32)

PCF8575 pcf8575_R2(I2C_ADDRESS_R2); // Create a PCF8575 object for the second module (for relays 9-16)

PCF8575 pcf8575_R3(I2C_ADDRESS_R3); // Create a PCF8575 object for the second module (for relays 1-8)

void setup() {

  // Initialize I2C communication

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

  // Initialize serial communication for debugging (optional)

  Serial.begin(115200);

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

  // Initialize the PCF8575 modules

  pcf8575_R1.begin();

  pcf8575_R2.begin();

  pcf8575_R3.begin();

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

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

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

    pcf8575_R2.write(i, HIGH); // Set relays 9-16 to OFF (assuming HIGH means OFF for relays)

  }

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

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

    pcf8575_R3.write(i, HIGH); // Set relays 1-8 to OFF (assuming HIGH means OFF for relays)

  }

}

void loop() {

  // Sequentially turn on each relay (1-32)

  // First control the relays on the second PCF8575 (relays 1-8, corresponding to pins 8-15)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // First control the relays on the second PCF8575 (relays 9-16, corresponding to pins 8-15)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // Then control the relays on the first PCF8575 (relays 17-32)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // Sequentially turn off each relay (1-24)

  // First control the relays on the second PCF8575 (relays 1-8, corresponding to pins 8-15)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // First control the relays on the second PCF8575 (relays 9-16, corresponding to pins 8-15)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // Then control the relays on the first PCF8575 (relays 17-32)

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

}

arduino ino file download:

1-relay.zip (Size: 1.08 KB / Downloads: 167)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

1-relay.ino.merged.zip (Size: 197.73 KB / Downloads: 168)

F32 ESPHome yaml for home assistant without tuya

Tue, 04 Nov 2025 07:22:41 +0800

Code:
esphome:

  name: f32

  friendly_name: f32

esp32:

  board: esp32-s3-devkitc-1

  framework:

    type: arduino

# Enable logging

logger:

  level: DEBUG  

  hardware_uart: USB_CDC

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

     scl: 18

     scan: true

     frequency: 400kHz

pcf8574:

  - id: 'pcf8574_hub_out_1'  # for output channel 17-32

    i2c_id: bus_a

    address: 0x25

    pcf8575: true

  - id: 'pcf8574_hub_in_1'  # for digital input channel 1-16

    i2c_id: bus_a

    address: 0x24

    pcf8575: true

  - id: 'pcf8574_hub_out_in_2'  # for output channel 9-16  + (input 17-24)

    i2c_id: bus_a

    address: 0x26

    pcf8575: true

  - id: 'pcf8574_hub_out_in_3'  # for output channel 1-8  + (input 17-24)

    i2c_id: bus_a

    address: 0x27

    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

switch:

  - platform: uart

    uart_id: uart_1

    name: "RS485 Button"

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

  - platform: gpio

    name: "f32-output01"

    id: "f32_output01"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 8

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output02"

    id: "f32_output02"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 9

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output03"

    id: "f32_output03"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 10

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output04"

    id: "f32_output04"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 11

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output05"

    id: "f32_output05"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 12

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output06"

    id: "f32_output06"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 13

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output07"

    id: "f32_output07"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 14

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output08"

    id: "f32_output08"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 15

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output09"

    id: "f32_output09"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 12

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output10"

    id: "f32_output10"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 13

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output11"

    id: "f32_output11"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 14

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output12"

    id: "f32_output12"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 15

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output13"

    id: "f32_output13"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 8

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output14"

    id: "f32_output14"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 9

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output15"

    id: "f32_output15"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 10

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output16"

    id: "f32_output16"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 11

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output17"

    id: "f32_output17"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 0

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output18"

    id: "f32_output18"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 1

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output19"

    id: "f32_output19"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 2

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output20"

    id: "f32_output20"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 3

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output21"

    id: "f32_output21"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 4

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output22"

    id: "f32_output22"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 5

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output23"

    id: "f32_output23"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 6

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output24"

    id: "f32_output24"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 7

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output25"

    id: "f32_output25"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 8

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output26"

    id: "f32_output26"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 9

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output27"

    id: "f32_output27"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 10

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output28"

    id: "f32_output28"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 11

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output29"

    id: "f32_output29"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 12

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output30"

    id: "f32_output30"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 13

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output31"

    id: "f32_output31"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 14

      mode: OUTPUT

      inverted: true

  - platform: gpio

    name: "f32-output32"

    id: "f32_output32"

    pin:

      pcf8574: pcf8574_hub_out_1

      number: 15

      mode: OUTPUT

      inverted: true

binary_sensor:

  - platform: gpio

    name: "f32-input01"

    id: "f32_input01"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 0

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input02"

    id: "f32_input02"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 1

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input03"

    id: "f32_input03"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 2

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input04"

    id: "f32_input04"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 3

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input05"

    id: "f32_input05"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 4

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input06"

    id: "f32_input06"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 5

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input07"

    id: "f32_input07"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 6

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input08"

    id: "f32_input08"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 7

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input09"

    id: "f32_input09"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 8

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input10"

    id: "f32_input10"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 9

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input11"

    id: "f32_input11"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 10

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input12"

    id: "f32_input12"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 11

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input13"

    id: "f32_input13"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 12

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input14"

    id: "f32_input14"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 13

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input15"

    id: "f32_input15"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 14

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input16"

    id: "f32_input16"

    pin:

      pcf8574: pcf8574_hub_in_1

      number: 15

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input17"

    id: "f32_input17"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 0

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input18"

    id: "f32_input18"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 1

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input19"

    id: "f32_input19"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 2

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input20"

    id: "f32_input20"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 3

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input21"

    id: "f32_input21"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 4

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input22"

    id: "f32_input22"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 5

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input23"

    id: "f32_input23"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 6

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input24"

    id: "f32_input24"

    pin:

      pcf8574: pcf8574_hub_out_in_2

      number: 7

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input25"

    id: "f32_input25"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 0

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input26"

    id: "f32_input26"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 1

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input27"

    id: "f32_input27"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 2

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input28"

    id: "f32_input28"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 3

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input29"

    id: "f32_input29"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 4

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input30"

    id: "f32_input30"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 5

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input31"

    id: "f32_input31"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 6

      mode: INPUT

      inverted: true

  - platform: gpio

    name: "f32-input32"

    id: "f32_input32"

    pin:

      pcf8574: pcf8574_hub_out_in_3

      number: 7

      mode: INPUT

      inverted: true

##pull-up resistance on PCB

  - platform: gpio

    name: "f32-W1-io48"

    pin: 

      number: 48

      inverted: true

  - platform: gpio

    name: "f32-W1-io47"

    pin: 

      number: 47

      inverted: true

  - platform: gpio

    name: "f32-W1-io21"

    pin: 

      number: 21

      inverted: true

  - platform: gpio

    name: "f32-W1-io15"

    pin: 

      number: 15

      inverted: true

## without resistance on PCB

  - platform: gpio

    name: "f32-W1-io13"

    pin: 

      number: 13

      inverted: false

  - platform: gpio

    name: "f32-W1-io14"

    pin: 

      number: 14

      inverted:  false

  - platform: gpio

    name: "f32-433M"

    pin: 

      number: 40

      inverted:  false

sensor:

  - platform: adc

    pin: 5

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

    update_interval: 5s

    unit_of_measurement: mA

    attenuation: 11db

    filters:

      - multiply: 6.66666666

  - platform: adc

    pin: 4

    name: "f32 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 F32");

download yaml file:

F32-HA-without-tuya.txt (Size: 14.25 KB / Downloads: 198)

F32 ESP32-S3 IO pins define

Tue, 04 Nov 2025 07:21:02 +0800

ANALOG_A1(0-5v) GPIO5
ANALOG_A2(0-5v) GPIO7
ANALOG_A3(4-20mA) GPIO6
ANALOG_A4(4-20mA) GPIO4

IIC SDA:GPIO8
IIC SCL:GPIO18

PCF8575:U27 (relay17-32) i2c address:0x25
PCF8575:U23 (DI1-16) i2c address:0x24
PCF8575:U49 i2c address: 0x26
PCF8575(pin number0-7) : DI17-24
PCF8575(pin number8-11) : relay13-16
PCF8575(pin number12-15) : relay9-12

PCF8575:U62 i2c address: 0x27
PCF8575(pin number0-7) : DI25-32
PCF8575(pin number8-15) :relay1-8

if config by ESPHome:

relay9: pcf8575(U49) number:12
relay10: pcf8575(U49) number:13
relay11: pcf8575(U49) number:14
relay12: pcf8575(U49) number:15
relay13: pcf8575(U49) number:8
relay14: pcf8575(U49) number:9
relay15: pcf8575(U49) number:10
relay16: pcf8575(U49) number:11

RF433MHz wireless receiver: GPIO40
------------------------

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:GPIO17
TXD:GPIO16
--------------------
Tuya module:
RXD:GPIO38
TXD:GPIO39

Tuya network button: Tuya module's P28
Tuya network LED: Tuya module's P16

---------------------
1-wire (pull-up resistance on PCB):
1-wire1:GPIO48
1-wire2:GPIO47
1-wire3:GPIO21
1-wire4:GPIO15

1-wire (without resistance on PCB):
1-wire1:GPIO13
1-wire2:GPIO14
------------------------
SD Card:
SPI-MOSI:GPIO10
SPI-SCK:GPIO11
SPI-MISO:GPIO12
SPI-CS:GPIO9
------------------------
24C02 EPROM i2c address: 0x50
DS3231 RTC i2c address: 0x68
SSD1306 display: i2c address:0x3c

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

Thu, 28 Nov 2024 19:50:29 +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: 457)

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

Thu, 28 Nov 2024 19:49:35 +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: 466)

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

Thu, 28 Nov 2024 19:48:30 +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: 426)

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

Thu, 28 Nov 2024 19:47:21 +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: 454)

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

Thu, 28 Nov 2024 19:46:16 +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: 441)

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

Thu, 28 Nov 2024 19:45:17 +0800

Code:
/*

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

 *

 * GPIO Status Monitoring

 *

 * This program monitors the status (high or low) of multiple GPIO pins on the ESP32-S3.

 * It prints the status of the pins to the serial monitor whenever a change is detected.

 *

 * GPIO Pins Monitored:

 * - GPIO 48

 * - GPIO 47

 * - GPIO 21

 * - GPIO 15

 * - GPIO 14

 * - GPIO 13

 * - GPIO 12

 * - GPIO 40

 *

 * Hardware Requirements:

 * - Connect the pins to appropriate devices or pull them to HIGH/LOW for testing

 */

#define GPIO_PIN_48 48

#define GPIO_PIN_47 47

#define GPIO_PIN_21 21

#define GPIO_PIN_15 15

#define GPIO_PIN_14 14

#define GPIO_PIN_13 13

#define GPIO_PIN_12 12

#define GPIO_PIN_40 40

// Store the previous state of the GPIO pins

bool prevState[8] = {false, false, false, false, false, false, false, false};

void setup() {

  // Initialize serial communication for debugging purposes

  Serial.begin(115200); // Initialize the serial monitor at 115200 baud

  while (!Serial);      // Wait for the serial monitor to open

  // Initialize GPIO pins as inputs

  pinMode(GPIO_PIN_48, INPUT);

  pinMode(GPIO_PIN_47, INPUT);

  pinMode(GPIO_PIN_21, INPUT);

  pinMode(GPIO_PIN_15, INPUT);

  pinMode(GPIO_PIN_14, INPUT);

  pinMode(GPIO_PIN_13, INPUT);

  pinMode(GPIO_PIN_12, INPUT);

  pinMode(GPIO_PIN_40, INPUT);

  Serial.println("GPIO Status Monitoring Started");

}

void loop() {

  // Read the current state of each GPIO pin

  bool currentState[8];

  currentState[0] = digitalRead(GPIO_PIN_48);

  currentState[1] = digitalRead(GPIO_PIN_47);

  currentState[2] = digitalRead(GPIO_PIN_21);

  currentState[3] = digitalRead(GPIO_PIN_15);

  currentState[4] = digitalRead(GPIO_PIN_14);

  currentState[5] = digitalRead(GPIO_PIN_13);

  currentState[6] = digitalRead(GPIO_PIN_12);

  currentState[7] = digitalRead(GPIO_PIN_40);

  // Check for changes in GPIO pin states

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

    if (currentState[i] != prevState[i]) {

      // Print the pin number and its new state if it has changed

      Serial.print("GPIO ");

      Serial.print(i == 0 ? GPIO_PIN_48 : 

                   i == 1 ? GPIO_PIN_47 : 

                   i == 2 ? GPIO_PIN_21 : 

                   i == 3 ? GPIO_PIN_15 : 

                   i == 4 ? GPIO_PIN_14 : 

                   i == 5 ? GPIO_PIN_13 : 

                   i == 6 ? GPIO_PIN_12 : GPIO_PIN_40);

      Serial.print(" changed to ");

      Serial.println(currentState[i] ? "HIGH" : "LOW");

      // Update the previous state

      prevState[i] = currentState[i];

    }

  }

  // Delay to avoid flooding the serial monitor

  delay(100); // Adjust the delay as needed

}

arduino ino file download:

5-free-gpio-state.zip (Size: 1.05 KB / Downloads: 455)

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

Thu, 28 Nov 2024 19:44:19 +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 16 and RXD pin is defined as GPIO 17.

 */

#include 

// Define RS485 pins

#define RS485_RXD 17

#define RS485_TXD 16

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

  // 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: 441)

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

Thu, 28 Nov 2024 19:43:08 +0800

Code:
/*

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

 *

 * Description:

 * This Arduino program reads analog values from four analog input pins (A1, A2, A3, A4)

 * and prints the values to the Serial Monitor. The analog inputs are defined with specific

 * GPIO pins and the program reads the voltage levels from these pins every 2 seconds.

 *

 * Pin Definitions:

 * - A1: GPIO 5

 * - A2: GPIO 7

 * - A3: GPIO 6

 * - A4: GPIO 4

 */

#define ANALOG_A1   5   // Define GPIO pin for analog input A1

#define ANALOG_A2   7   // Define GPIO pin for analog input A2

#define ANALOG_A3   6   // Define GPIO pin for analog input A3

#define ANALOG_A4   4   // Define GPIO pin for analog input A4

void setup()

{

    Serial.begin(115200); // Initialize serial communication at 115200 baud rate

    delay(500); // Short delay to allow serial communication to start

    pinMode(ANALOG_A1, INPUT); // Set GPIO 5 as an input for analog signal A1

    pinMode(ANALOG_A2, INPUT); // Set GPIO 7 as an input for analog signal A2

    pinMode(ANALOG_A3, INPUT); // Set GPIO 6 as an input for analog signal A3

    pinMode(ANALOG_A4, INPUT); // Set GPIO 4 as an input for analog signal A4

}

void loop()

{

    // Read and print analog values from the defined pins

    Serial.print("A1="); 

    Serial.println(analogRead(ANALOG_A1)); // Read and print the value from A1

    Serial.print("A2=");

    Serial.println(analogRead(ANALOG_A2)); // Read and print the value from A2

    Serial.print("A3=");

    Serial.println(analogRead(ANALOG_A3)); // Read and print the value from A3

    Serial.print("A4=");

    Serial.println(analogRead(ANALOG_A4)); // Read and print the value from A4

    delay(2000); // Wait for 2 seconds before the next reading

}

arduino ino file download:

3-analog-input.zip (Size: 769 bytes / Downloads: 455)