Smart Home Automation Forum

Welcome, Guest

You have to register before you can post on our site.

Search Forums

(Advanced Search)

Forum Statistics

» Members: 9,564
» Latest member: rayscreations
» Forum threads: 4,185
» Forum posts: 20,810

Full Statistics

Online Users

There are currently 55 online users.
» 0 Member(s) | 42 Guest(s)
Amazonbot, Baidu, Bing, Bytespider, PetalBot, bot

Latest Threads

4-20mA loop voltage consi...
Forum: B4M
Last Post: Armsp0
1 hour ago
» Replies: 0
» Views: 2

N60 Voltage reference
Forum: N60
Last Post: admin
9 hours ago
» Replies: 1
» Views: 6

K868-a32 plastic case
Forum: KC868-A series and Uair Smart Controller
Last Post: admin
Yesterday, 08:48 AM
» Replies: 3
» Views: 1,175

CT Clamp Compatibility
Forum: KC868-M16 / M1 / MB / M30
Last Post: admin
08-09-2026, 10:32 PM
» Replies: 10
» Views: 1,636

KinCony F8 + ESPHome: Una...
Forum: F8
Last Post: admin
08-08-2026, 11:51 PM
» Replies: 6
» Views: 82

How to get started
Forum: KC868-A16
Last Post: admin
08-07-2026, 11:42 PM
» Replies: 39
» Views: 9,656

Questions on the B4M
Forum: B4M
Last Post: admin
08-07-2026, 11:19 PM
» Replies: 3
» Views: 205

cannot see KC868-A6 in ro...
Forum: "KCS" v2 firmware system
Last Post: admin
08-07-2026, 09:59 AM
» Replies: 7
» Views: 303

CAN-BUS Transceiver
Forum: T16M
Last Post: admin
08-07-2026, 09:57 AM
» Replies: 1
» Views: 12

N60 configure yaml for ES...
Forum: N60
Last Post: chuyskywalker
08-06-2026, 07:18 AM
» Replies: 5
» Views: 1,782

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

Posted by: admin - 04-20-2025, 07:12 AM - Forum: F8 - No Replies

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:

.zip

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

.zip

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

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

Posted by: admin - 04-20-2025, 07:04 AM - Forum: F8 - No Replies

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 <HardwareSerial.h>

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

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

.zip

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

.zip

4-RS485-Test.ino.merged.zip (Size: 184.34 KB / Downloads: 596)

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

Posted by: admin - 04-20-2025, 07:03 AM - Forum: F8 - No Replies

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:

.zip

3-analog-input.zip (Size: 769 bytes / Downloads: 598)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

.zip

3-analog-input.ino.merged.zip (Size: 184.64 KB / Downloads: 602)

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

Posted by: admin - 04-20-2025, 07:02 AM - Forum: F8 - No Replies

Code:
/*

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

 *

 * Description:

 * This Arduino program reads the state of a 16-channel PCF8575 I/O expander

 * and prints the state of all input pins to the Serial Monitor. The state of 

 * each pin is represented as a bit in a 8-bit value, where each bit corresponds 

 * to an input pin. The program prints the input state in binary format.

 *

 * Pin Definitions:

 * - SDA: GPIO 21

 * - SCL: GPIO 22

 * - PCF8575 I2C Address: 0x24

 */

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

PCF8575 pcf8575_IN1(0x24); // The I2C address of the PCF8575

void setup() {

    Serial.begin(115200);

    // Initialize I2C communication

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

    pcf8575_IN1.begin(); // Initialize the PCF8575

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

}

void loop() {

    uint16_t state = 0;

    // Read the state of each pin (assuming 16 pins)

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

        if (pcf8575_IN1.read(pin)) {

            state |= (1 << pin); // Set the bit for the active pin

        }

    }

    Serial.print("Input state: ");

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

    delay(500); // Delay 500ms

}

arduino ino file download:

.zip

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

.zip

2-digital-input.ino.merged.zip (Size: 189.49 KB / Downloads: 579)

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

Posted by: admin - 04-20-2025, 07:00 AM - Forum: F8 - No Replies

Code:
/*

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

 *

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

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

 * 

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * 

 * Delay Time:

 * - 200 milliseconds between switching relays

 */

#include <Wire.h>        // Include the Wire library for I2C communication

#include <PCF8575.h>     // Include the PCF8575 library to control the I/O expander

#define SDA 8            // Define the SDA pin

#define SCL 18           // Define the SCL pin

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

// Set I2C address of the PCF8575 module

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

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

void setup() {

  // Initialize I2C communication

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

  // Initialize serial communication for debugging (optional)

  Serial.begin(115200);

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

  // Initialize the PCF8575 module

  pcf8575_R1.begin();

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

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

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

  }

}

void loop() {

  // Sequentially turn on each relay

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

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

    delay(DELAY_TIME);          // Wait for DELAY_TIME milliseconds

  }

  // Sequentially turn off each relay

  for (int i = 8; 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:

.zip

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

.zip

1-relay.ino.merged.zip (Size: 189.21 KB / Downloads: 614)

F8 ESPHome yaml for home assistant

Posted by: admin - 04-20-2025, 06:53 AM - Forum: F8 - No Replies

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.1.0

# 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 input channel 1-16

    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-output7-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 file download:

.txt

F8-HA.txt (Size: 8.67 KB / Downloads: 483)

KinCony F8 ESP32-S3 IO pins define

Posted by: admin - 04-20-2025, 06:52 AM - Forum: F8 - Replies (1)

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:U23 i2c address:0x24

PCF8575->P0 (DI1)
PCF8575->P1 (DI2)
PCF8575->P2 (DI3)
PCF8575->P3 (DI4)
PCF8575->P4 (DI5)
PCF8575->P5 (DI6)
PCF8575->P6 (DI7)
PCF8575->P7 (DI8)

PCF8575->P8 (relay1)
PCF8575->P9 (relay2)
PCF8575->P10 (relay3)
PCF8575->P11 (relay4)
PCF8575->P12 (relay5)
PCF8575->P13 (relay6)
PCF8575->P14 (relay7)
PCF8575->P15 (relay8)

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-wire2:GPIO14
------------------------
SD Card:
SPI-MOSI:GPIO10
SPI-SCK:GPIO11
SPI-MISO:GPIO12
SPI-CS:GPIO9
SPI-CD:GPIO13
------------------------
24C02 EPROM i2c address: 0x50
DS3231 RTC i2c address: 0x68
SSD1306 display: i2c address:0x3c

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

Posted by: admin - 04-20-2025, 06:46 AM - Forum: KC868-A8v3 - No Replies

Code:
/*

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

 *

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

 * controls a corresponding 16-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 38

 * - SCL: GPIO 39

 * - Input I2C Address: 0x24

 * - Relay I2C Address: 0x25

 */

#include <Wire.h>        // I2C communication

#include <PCF8575.h>     // Library to control the PCF8575 I/O expander

// Define I2C pins

#define SDA 8           // SDA pin

#define SCL 18           // SCL pin

// I2C addresses

#define RELAY_I2C_ADDRESS 0x22   // I2C address for the relay PCF8575 module

PCF8575 pcf8575_RL(RELAY_I2C_ADDRESS);    // Create an object for the relay PCF8575

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL);

  // Initialize serial communication

  Serial.begin(115200);

  // Initialize input and relay modules

  pcf8575_RL.begin();

  // Turn off all relays at the start

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

    pcf8575_RL.write(i, LOW);  // Assuming relays are LOW when OFF, setting all relays to OFF initially

  }

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

}

void loop() {

  uint16_t inputState = 0;

  // Read the state of 16 inputs

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

    if (pcf8575_RL.read(i)) {

      inputState |= (1 << i);  // If input is HIGH, set the corresponding bit

    } else {

      inputState &= ~(1 << i); // Otherwise, clear the corresponding bit

    }

  }

  // Control the relays based on the input state

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

    if (inputState & (1 << i+8)) {

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

    } else {

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

    }

  }

  // Delay for 500 milliseconds

  delay(500);

}

arduino ino file download:

.zip

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

.zip

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

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

Posted by: admin - 04-20-2025, 06:44 AM - Forum: KC868-A8v3 - No Replies

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 <U8g2lib.h>  // Include the U8g2 library for controlling the OLED display

#include <Wire.h>     // 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:

.zip

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

.zip

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

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

Posted by: admin - 04-20-2025, 06:43 AM - Forum: KC868-A8v3 - No Replies

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 <HardwareSerial.h>

// 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 16

#define RXD_PIN 17

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

.zip

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

.zip

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

Pages (415): « Previous 1 … 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 … 415 Next »

Login
Username:
Password:	Lost Password?
	Remember me