Smart Home Automation Forum - AIO Hybrid

AIO Hybrid Smart Controller ESP32 system block diagram

Fri, 24 Apr 2026 14:58:58 +0800

KinCony-AIO-Hybrid-Smart-Controller-Diagram.png.png (Size: 879.54 KB / Downloads: 80)

AIO Hybrid wiring diagram

Sun, 05 Apr 2026 13:45:23 +0800

aio-hybird-diagram.JPG (Size: 113.02 KB / Downloads: 87)

Battery backup model on AOI

Mon, 16 Mar 2026 17:42:54 +0800

Francais :
Serait-il possible de connaitre la référence de la pile bouton qui doit va dans le rtc battery socket qui peut-être mis sur le AIO pour maintenir sa sauvegarde.
Cordialement.

English :
Could you please provide the part number for the button cell battery that fits into the RTC battery socket, which can be installed on the AIO to maintain its backup?
Regards.

Inputs

Thu, 18 Sep 2025 16:41:30 +0800

Why does it have so few dry-contact inputs? only 12 ...
old ESP32 AIO has 56

Is there any option to increase this and have external inputs available in one KCS v3 configuration (to use any input from outsite AIO Hybrid in AIO Hybrid IFTTT)?

[arduino code examples for AIO Hybrid]-13 RF433M receiver

Mon, 15 Sep 2025 09:40:56 +0800

Code:
/*

  Simple example for receiving

  https://github.com/sui77/rc-switch/

*/

#include 

RCSwitch mySwitch = RCSwitch();

void setup() {

  Serial.begin(9600);

  mySwitch.enableReceive(digitalPinToInterrupt(40)); 

  Serial.print("begin test");

}

void loop() {

  if (mySwitch.available()) {

    Serial.print("Received ");

    Serial.print( mySwitch.getReceivedValue() );

    Serial.print(" / ");

    Serial.print( mySwitch.getReceivedBitlength() );

    Serial.print("bit ");

    Serial.print("Protocol: ");

    Serial.println( mySwitch.getReceivedProtocol() );

    mySwitch.resetAvailable();

  }

}

arduino ino file download:

  13-433-decode.zip (Size: 457 bytes / Downloads: 341)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

  13-433-decode.ino.merged.zip (Size: 185.99 KB / Downloads: 352)

  arduino.png (Size: 131.43 KB / Downloads: 346)

[arduino code examples for AIO Hybrid]-12 DAC MCP4728 analog output

Mon, 15 Sep 2025 09:39:36 +0800

Code:
// Basic demo for configuring the MCP4728 4-Channel 12-bit I2C DAC

#include 

#include 

// I2C pin definitions

#define I2C_SDA 8

#define I2C_SCL 18

Adafruit_MCP4728 mcp;

void setup(void) {

  Serial.begin(115200);

  while (!Serial)

    delay(10); // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit MCP4728 test!");

  Wire.begin(I2C_SDA, I2C_SCL);

  // Try to initialize!

  if (!mcp.begin()) {

    Serial.println("Failed to find MCP4728 chip");

    while (1) {

      delay(10);

    }

  }

  mcp.setChannelValue(MCP4728_CHANNEL_A, 4095);

  mcp.setChannelValue(MCP4728_CHANNEL_B, 2048);

  mcp.setChannelValue(MCP4728_CHANNEL_C, 1024);

  mcp.setChannelValue(MCP4728_CHANNEL_D, 0);

}

void loop() { delay(1000); }

arduino ino file download:

12-DAC-MCP4728.zip (Size: 566 bytes / Downloads: 339)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

12-DAC-MCP4728.ino.merged.zip (Size: 198.76 KB / Downloads: 346)

[arduino code examples for AIO Hybrid]-11 IR send and receive

Mon, 15 Sep 2025 09:37:32 +0800

Code:
/*

 * SimpleReceiver.cpp

 *

 * Demonstrates receiving ONLY NEC protocol IR codes with IRremote

 * If no protocol is defined, all protocols (except Bang&Olufsen) are active.

 *

 *  This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.

 *

 ************************************************************************************

 * MIT License

 *

 * Copyright (c) 2020-2025 Armin Joachimsmeyer

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is furnished

 * to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,

 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE

 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 ************************************************************************************

 */

#include 

#include  // include the library

uint8_t receiver_pin = 17;

void setup() {

    Serial.begin(115200);

    IrReceiver.begin(receiver_pin, false);

}

void loop() {

  if (IrReceiver.decode()) {

      Serial.println("recv data");

      if (IrReceiver.decodedIRData.protocol == UNKNOWN) {

          Serial.println(F("Received noise or an unknown (or not yet enabled) protocol"));

          // We have an unknown protocol here, print extended info

          IrReceiver.printIRResultRawFormatted(&Serial, true);

          IrReceiver.resume(); // Do it here, to preserve raw data for printing with printIRResultRawFormatted()

      } else {

          IrReceiver.resume(); // Early enable receiving of the next IR frame

          IrReceiver.printIRResultShort(&Serial);

          IrReceiver.printIRSendUsage(&Serial);

      }

  } else {

    // Serial.println("no data");

  }

}

arduino ino file download:

11-SimpleSendReceiver.zip (Size: 1.31 KB / Downloads: 361)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

11-SimpleSendReceiver.ino.merged.zip (Size: 197.43 KB / Downloads: 340)

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

Mon, 15 Sep 2025 09:36:28 +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: 357)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

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

[arduino code examples for AIO Hybrid]-09 how to communication with Tuya Zigbee modul

Mon, 15 Sep 2025 09:35:29 +0800

Code:
#define TUYA_RXD 15

#define TUYA_TXD 48

void setup() {

  Serial0.begin(115200);  // Serial0

  while (!Serial0);

  Serial2.begin(115200, SERIAL_8N1, TUYA_RXD, TUYA_TXD);

  delay(100);

  byte tuya_cmd[] = {0x55, 0xAA, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04};

  Serial0.println("send data to Tuya module:");

  for (int i = 0; i < sizeof(tuya_cmd); i++) {

    Serial0.printf("%02X ", tuya_cmd[i]);

    Serial2.write(tuya_cmd[i]);

  }

  Serial0.println();

}

void loop() {

  if (Serial2.available()) {

    Serial0.print("received from tuya: ");

    while (Serial2.available()) {

      byte b = Serial2.read();

      Serial0.printf("%02X ", b);

    }

    Serial0.println();

  }

  delay(100);

}

arduino ino file download:

9-Zigbee-ZSU.zip (Size: 496 bytes / Downloads: 318)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

9-Zigbee-ZSU.ino.merged.zip (Size: 190.24 KB / Downloads: 324)

[arduino code examples for AIO Hybrid]-08 Ethernet W5500 chip work with TCP Server mo

Mon, 15 Sep 2025 09:32:38 +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: 331)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

8-Ethernet-W5500.ino.merged.zip (Size: 188.93 KB / Downloads: 337)

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

Mon, 15 Sep 2025 09:31:39 +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: 332)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

7-DS3231-RTC.ino.merged.zip (Size: 198.29 KB / Downloads: 326)

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

Mon, 15 Sep 2025 09:30:37 +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: 308)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

6-SD.ino.merged.zip (Size: 221.05 KB / Downloads: 352)

[arduino code examples for AIO Hybrid]-05 IR send

Mon, 15 Sep 2025 09:29:39 +0800

Code:
/*

 * Copyright (c) 2025 KinCony IoT

 * https://www.kincony.com

 *

 * Description:

 * This program generates a 38 kHz PWM signal on a specified GPIO pin

 * using the ESP32-S3 LEDC hardware peripheral.

 * The output can be used to drive an IR LED for infrared signal transmission.

 */

#include 

#include "driver/ledc.h"

#define IR_SEND_PIN 14  // GPIO pin connected to the IR LED

void setup() {

  Serial.begin(115200);

  // Configure the LEDC timer

  ledc_timer_config_t ledc_timer = {

      .speed_mode = LEDC_LOW_SPEED_MODE,       // Use low-speed mode

      .duty_resolution = LEDC_TIMER_8_BIT,     // 8-bit resolution (0-255)

      .timer_num = LEDC_TIMER_0,               // Select timer 0

      .freq_hz = 38000,                        // Set frequency to 38 kHz

      .clk_cfg = LEDC_AUTO_CLK                 // Automatically select the clock source

  };

  ledc_timer_config(&ledc_timer);

  // Configure the LEDC channel

  ledc_channel_config_t ledc_channel = {

      .gpio_num = IR_SEND_PIN,                 // Output GPIO pin

      .speed_mode = LEDC_LOW_SPEED_MODE,       // Use low-speed mode

      .channel = LEDC_CHANNEL_0,               // Channel 0

      .intr_type = LEDC_INTR_DISABLE,          // Disable interrupts

      .timer_sel = LEDC_TIMER_0,                // Use timer 0

      .duty = 128,                             // 50% duty cycle (128/255)

      .hpoint = 0                              // Start at high point 0

  };

  ledc_channel_config(&ledc_channel);

  Serial.println("38kHz PWM started.");

}

void loop() {

  // Continuously output the carrier wave

}

arduino ino file download:

5-IR-send-ESP32.zip (Size: 904 bytes / Downloads: 334)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

5-IR-send-ESP32.ino.merged.zip (Size: 187.02 KB / Downloads: 285)

[arduino code examples for AIO Hybrid]-04 RS485 communication test

Mon, 15 Sep 2025 09:28:29 +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 47

#define RS485_TXD 3

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

  // 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: 766 bytes / Downloads: 278)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

4-RS485-Test.ino.merged.zip (Size: 189.46 KB / Downloads: 302)

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

Mon, 15 Sep 2025 09:27:28 +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: 297)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

3-analog-input.ino.merged.zip (Size: 189.25 KB / Downloads: 319)