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

Username
  

Password
  





Search Forums

(Advanced Search)

Forum Statistics
» Members: 8,305
» Latest member: robola
» Forum threads: 3,629
» Forum posts: 18,734

Full Statistics

Online Users
There are currently 53 online users.
» 0 Member(s) | 36 Guest(s)
AhrefsBot, Amazonbot, Applebot, Bytespider, Crawl, PetalBot, Yandex, bot

Latest Threads
KC868-M16v2 configure yam...
Forum: KC868-M16 / M1 / MB / M30
Last Post: admin
5 minutes ago
» Replies: 118
» Views: 25,151
Replacing ESP32 with Kinc...
Forum: KC868-A16
Last Post: admin
24 minutes ago
» Replies: 1
» Views: 1
N30 Energy entry not work...
Forum: N30
Last Post: admin
25 minutes ago
» Replies: 11
» Views: 71
KC868-Server ESP32 Ethern...
Forum: KC868-Server Raspberry Pi4 local server
Last Post: admin
26 minutes ago
» Replies: 7
» Views: 61
Single Moment switch
Forum: DIY Project
Last Post: admin
30 minutes ago
» Replies: 1
» Views: 6
Help with Product Slectio...
Forum: Suggestions and feedback on KinCony's products
Last Post: admin
Yesterday, 12:06 AM
» Replies: 5
» Views: 56
Loxone RS485
Forum: KinCony integrate with Loxone home automation
Last Post: admin
Yesterday, 12:03 AM
» Replies: 9
» Views: 1,117
adaptor V2 and KC868 h32b...
Forum: KC868-ATC / Tuya adapter V2
Last Post: admin
12-23-2025, 01:19 AM
» Replies: 1
» Views: 14
KC868-A6 - how to connect...
Forum: KC868-A6
Last Post: admin
12-23-2025, 01:18 AM
» Replies: 1
» Views: 15
easy way to export/import...
Forum: KC868-A series and Uair Smart Controller
Last Post: admin
12-23-2025, 01:09 AM
» Replies: 7
» Views: 5,635

  [arduino code examples for T32M]-06 digital INPUT trigger OUTPUT directly
Posted by: admin - 06-23-2025, 05:27 AM - Forum: T32M - No Replies

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* This program reads 32 input states from two PCF8575 I/O expanders
* and controls 32 relays via another two PCF8575 I/O expanders.
* When an input pin is LOW, the corresponding relay is turned ON (active LOW).
* When the input pin is HIGH, the corresponding relay is turned OFF.
*
* I2C Bus-1 Pin Definitions:
* - SDA: GPIO 48
* - SCL: GPIO 47
*
* I2C Addresses:
* - Output1-16:  0x20
* - Output17-32: 0x21
* - Input1-16:   0x24
* - Input17-32:  0x25
*/

#include <Wire.h>
#include <PCF8575.h>

// Define I2C pins
#define I2C_SDA 48
#define I2C_SCL 47

// PCF8575 I2C addresses
#define OUTPUT1_ADDR 0x20
#define OUTPUT2_ADDR 0x21
#define INPUT1_ADDR  0x24
#define INPUT2_ADDR  0x25

// Create PCF8575 objects
PCF8575 pcf8575_IN1(INPUT1_ADDR);   // Inputs 1~16
PCF8575 pcf8575_IN2(INPUT2_ADDR);   // Inputs 17~32
PCF8575 pcf8575_OUT1(OUTPUT1_ADDR); // Outputs 1~16
PCF8575 pcf8575_OUT2(OUTPUT2_ADDR); // Outputs 17~32

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

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

  // Initialize all PCF8575 devices
  pcf8575_IN1.begin();
  pcf8575_IN2.begin();
  pcf8575_OUT1.begin();
  pcf8575_OUT2.begin();

  // Turn off all relays at start (LOW = OFF)
  for (int i = 0; i < 16; i++) {
    pcf8575_OUT1.write(i, HIGH);  // HIGH means OFF for relay
    pcf8575_OUT2.write(i, HIGH);
  }

  Serial.println("System started: 32 inputs controlling 32 relays");
}

void loop() {
  uint32_t inputState = 0;

  // Read inputs 1~16
  for (int i = 0; i < 16; i++) {
    if (pcf8575_IN1.read(i)) {
      inputState |= (1UL << i);
    }
  }

  // Read inputs 17~32
  for (int i = 0; i < 16; i++) {
    if (pcf8575_IN2.read(i)) {
      inputState |= (1UL << (i + 16));
    }
  }

  // Control outputs 1~16
  for (int i = 0; i < 16; i++) {
    if (inputState & (1UL << i)) {
      pcf8575_OUT1.write(i, HIGH);  // Input HIGH -> Relay OFF
    } else {
      pcf8575_OUT1.write(i, LOW);   // Input LOW -> Relay ON
    }
  }

  // Control outputs 17~32
  for (int i = 0; i < 16; i++) {
    if (inputState & (1UL << (i + 16))) {
      pcf8575_OUT2.write(i, HIGH);  // Input HIGH -> Relay OFF
    } else {
      pcf8575_OUT2.write(i, LOW);   // Input LOW -> Relay ON
    }
  }

  delay(500);
}
arduino ino file download:

.zip   6-input-trigger-output.zip (Size: 1 KB / Downloads: 277)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download: 

.zip   6-input-trigger-output.ino.merged.zip (Size: 181.75 KB / Downloads: 257)

Print this item

  [arduino code examples for T32M]-05 Ethernet W5500 chip work with TCP Server mode
Posted by: admin - 06-23-2025, 05:25 AM - Forum: T32M - No Replies

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 <SPI.h>
#include <Ethernet.h>

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

.zip   5-Ethernet-W5500.zip (Size: 1.23 KB / Downloads: 265)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download: 

.zip   5-Ethernet-W5500.ino.merged.zip (Size: 191.08 KB / Downloads: 251)

Print this item

  [arduino code examples for T32M]-04 Read free GPIO state
Posted by: admin - 06-23-2025, 05:23 AM - Forum: T32M - No Replies

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 8
* - GPIO 9
* - GPIO 10
* - GPIO 15
* - GPIO 16
* - GPIO 17
* - GPIO 18
* - GPIO 0
*
* Hardware Requirements:
* - Connect the pins to appropriate devices or pull them to HIGH/LOW for testing
*/

#define GPIO_PIN_8 8
#define GPIO_PIN_9 9
#define GPIO_PIN_10 10
#define GPIO_PIN_15 15
#define GPIO_PIN_16 16
#define GPIO_PIN_17 17
#define GPIO_PIN_18 18
#define GPIO_PIN_0 0

// 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_8, INPUT);
  pinMode(GPIO_PIN_9, INPUT);
  pinMode(GPIO_PIN_10, INPUT);
  pinMode(GPIO_PIN_15, INPUT);
  pinMode(GPIO_PIN_16, INPUT);
  pinMode(GPIO_PIN_17, INPUT);
  pinMode(GPIO_PIN_18, INPUT);
  pinMode(GPIO_PIN_0, 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_8);
  currentState[1] = digitalRead(GPIO_PIN_9);
  currentState[2] = digitalRead(GPIO_PIN_10);
  currentState[3] = digitalRead(GPIO_PIN_15);
  currentState[4] = digitalRead(GPIO_PIN_16);
  currentState[5] = digitalRead(GPIO_PIN_17);
  currentState[6] = digitalRead(GPIO_PIN_18);
  currentState[7] = digitalRead(GPIO_PIN_0);

  // 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_8 :
                   i == 1 ? GPIO_PIN_9 :
                   i == 2 ? GPIO_PIN_10 :
                   i == 3 ? GPIO_PIN_15 :
                   i == 4 ? GPIO_PIN_16 :
                   i == 5 ? GPIO_PIN_17 :
                   i == 6 ? GPIO_PIN_18 : GPIO_PIN_0);
      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:

.zip   4-free-gpio-state.zip (Size: 1.04 KB / Downloads: 273)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download: 

.zip   4-free-gpio-state.ino.merged.zip (Size: 181.77 KB / Downloads: 276)

Print this item

  [arduino code examples for T32M]-03 RS485 communication test
Posted by: admin - 06-23-2025, 05:22 AM - Forum: T32M - No Replies

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* RS485 Communication Test with Direction Control (SP3485EEN)
*
* 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 13, RXD is GPIO 21, and EN is GPIO 14.
*/

#include <HardwareSerial.h>

// Define RS485 pins
#define RS485_RXD 21     // RS485 Receive
#define RS485_TXD 13     // RS485 Transmit
#define RS485_EN  14     // RS485 Direction control (High: Send, Low: Receive)

// Create a hardware serial object on UART1
HardwareSerial rs485Serial(1);

void setup() {
  // Start serial communication for debugging
  Serial.begin(115200);
  while (!Serial);

  // Set RS485 direction control pin
  pinMode(RS485_EN, OUTPUT);
  digitalWrite(RS485_EN, LOW); // Start in receive mode

  // Initialize RS485 serial communication
  rs485Serial.begin(9600, SERIAL_8N1, RS485_RXD, RS485_TXD);

  Serial.println("RS485 Test Start (with direction control)");
}

void loop() {
  // Prepare the message to send
  String message = "Hello from KinCony T32M!";
 
  // Switch to transmit mode
  digitalWrite(RS485_EN, HIGH);
  delay(2); // Short delay to allow driver to switch
 
  // Send the message
  rs485Serial.println(message);
  rs485Serial.flush(); // Wait for transmission to complete
 
  // Switch back to receive mode
  digitalWrite(RS485_EN, LOW);
 
  Serial.println("Message sent. Waiting for response...");

  // Wait for a response (up to 1 second)
  unsigned long startTime = millis();
  while (millis() - startTime < 1000) {
    if (rs485Serial.available()) {
      String receivedMessage = "";
      while (rs485Serial.available()) {
        char c = rs485Serial.read();
        receivedMessage += c;
      }
      // Print the received message
      Serial.print("Received: ");
      Serial.println(receivedMessage);
      break;
    }
  }

  // Wait before sending the next message
  delay(2000);
}
arduino ino file download:

.zip   3-RS485-Test.zip (Size: 1.02 KB / Downloads: 296)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download: 

.zip   3-RS485-Test.ino.merged.zip (Size: 186.67 KB / Downloads: 293)

Print this item

  [arduino code examples for T32M]-02 Read digital input ports state
Posted by: admin - 06-23-2025, 05:20 AM - Forum: T32M - No Replies

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* Description:
* This Arduino program reads the state of two 16-channel PCF8575 I/O expanders
* and prints the combined state of all 32 input pins to the Serial Monitor.
* Each pin state is represented as a bit in a 32-bit value (printed in binary format).
*
* Pin Definitions:
* - SDA: GPIO 48
* - SCL: GPIO 47
*
* PCF8575 I2C Addresses:
* - 0x24: input pins 1~16
* - 0x25: input pins 17~32
*/

#include "Arduino.h"
#include "PCF8575.h"
#include <Wire.h>

// Define I2C pins
#define I2C_SDA 48  // SDA pin
#define I2C_SCL 47  // SCL pin

// Create PCF8575 instances
PCF8575 pcf8575_IN1(0x24); // Inputs 1~16
PCF8575 pcf8575_IN2(0x25); // Inputs 17~32

void setup() {
    Serial.begin(115200);

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

    // Initialize both PCF8575 expanders
    pcf8575_IN1.begin();
    pcf8575_IN2.begin();

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

void loop() {
    uint32_t inputState = 0; // 32-bit variable to store combined state

    // Read input pins 1~16
    for (int pin = 0; pin < 16; pin++) {
        if (pcf8575_IN1.read(pin)) {
            inputState |= (1UL << pin); // Set corresponding bit
        }
    }

    // Read input pins 17~32
    for (int pin = 0; pin < 16; pin++) {
        if (pcf8575_IN2.read(pin)) {
            inputState |= (1UL << (pin + 16)); // Set corresponding bit
        }
    }

    Serial.print("Input state: ");
    for (int i = 31; i >= 0; i--) {
        Serial.print(bitRead(inputState, i));
    }
    Serial.println();

    delay(500); // Wait for 500 milliseconds
}
arduino ino file download:

.zip   2-digital-input.zip (Size: 907 bytes / Downloads: 272)
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: 192.33 KB / Downloads: 277)

Print this item

  [arduino code examples for T32M]-01 Turn ON/OFF OUTPUT
Posted by: admin - 06-23-2025, 05:18 AM - Forum: T32M - No Replies

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 (1~32) and then turns them off in a loop.
*
* Pin Definitions:
* - SDA: GPIO 48
* - SCL: GPIO 47
*
* PCF8575 I2C Addresses:
* - 0x20: controls relays 1~16
* - 0x21: controls relays 17~32
*
* 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_PIN 48           // Define the SDA pin
#define SCL_PIN 47           // Define the SCL pin
#define DELAY_TIME 200       // Define the delay time in milliseconds

// Set I2C addresses of the PCF8575 modules
#define I2C_ADDRESS1 0x20    // PCF8575 for relays 1~16
#define I2C_ADDRESS2 0x21    // PCF8575 for relays 17~32

// Create PCF8575 objects for each module
PCF8575 pcf8575_R1(I2C_ADDRESS1); // For relays 1~16
PCF8575 pcf8575_R2(I2C_ADDRESS2); // For relays 17~32

void setup() {
  // Initialize I2C communication
  Wire.begin(SDA_PIN, SCL_PIN);

  // Initialize serial communication for debugging (optional)
  Serial.begin(115200);
  Serial.println("PCF8575 32-Channel Relay Control: Starting...");

  // Initialize both PCF8575 modules
  pcf8575_R1.begin();
  pcf8575_R2.begin();

  // Turn off all relays initially (set all pins HIGH)
  for (int i = 0; i < 16; i++) {
    pcf8575_R1.write(i, HIGH); // Relays 1~16
    pcf8575_R2.write(i, HIGH); // Relays 17~32
  }
}

void loop() {
  // Sequentially turn on each relay (1~32)
  for (int i = 0; i < 32; i++) {
    if (i < 16) {
      pcf8575_R1.write(i, LOW);  // Turn on relay 1~16
    } else {
      pcf8575_R2.write(i - 16, LOW); // Turn on relay 17~32
    }
    delay(DELAY_TIME);
  }

  // Sequentially turn off each relay (1~32)
  for (int i = 0; i < 32; i++) {
    if (i < 16) {
      pcf8575_R1.write(i, HIGH); // Turn off relay 1~16
    } else {
      pcf8575_R2.write(i - 16, HIGH); // Turn off relay 17~32
    }
    delay(DELAY_TIME);
  }
}
arduino ino file download:

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

.zip   1-output.ino.merged.zip (Size: 192.14 KB / Downloads: 248)

Print this item

  T32M ESPHome yaml for home assistant
Posted by: admin - 06-23-2025, 05:17 AM - Forum: T32M - No Replies

Code:
esphome:
  name: t32m
  friendly_name: t32m

esp32:
  board: esp32-s3-devkitc-1
  framework:
    type: esp-idf

# Enable logging
logger:
  hardware_uart: USB_SERIAL_JTAG
# 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: 48
     scl: 47
     scan: true
     frequency: 400kHz

pcf8574:
  - id: 'pcf8574_hub_out_1'  # for output channel 1-16
    i2c_id: bus_a
    address: 0x21
    pcf8575: true

  - id: 'pcf8574_hub_out_2'  # for output channel 17-32
    i2c_id: bus_a
    address: 0x20
    pcf8575: true

  - id: 'pcf8574_hub_in_1'  # for input channel 1-16
    i2c_id: bus_a
    address: 0x25
    pcf8575: true

  - id: 'pcf8574_hub_in_2'  # for input channel 17-32
    i2c_id: bus_a
    address: 0x24
    pcf8575: true

switch:
  - platform: gpio
    name: "t32m-output01"
    id: "t32m_output01"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 0
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output02"
    id: "t32m_output02"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 1
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output03"
    id: "t32m_output03"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 2
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output04"
    id: "t32m_output04"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 3
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output05"
    id: "t32m_output05"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 4
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output06"
    id: "t32m_output06"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 5
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output07"
    id: "t32m_output07"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 6
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output08"
    id: "t32m_output08"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 7
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output09"
    id: "t32m_output09"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 8
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output10"
    id: "t32m_output10"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 9
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output11"
    id: "t32m_output11"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 10
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output12"
    id: "t32m_output12"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 11
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output13"
    id: "t32m_output13"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 12
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output14"
    id: "t32m_output14"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 13
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output15"
    id: "t32m_output15"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 14
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output16"
    id: "t32m_output16"
    pin:
      pcf8574: pcf8574_hub_out_1
      number: 15
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output17"
    id: "t32m_output17"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 0
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output18"
    id: "t32m_output18"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 1
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output19"
    id: "t32m_output19"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 2
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output20"
    id: "t32m_output20"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 3
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output21"
    id: "t32m_output21"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 4
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output22"
    id: "t32m_output22"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 5
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output23"
    id: "t32m_output23"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 6
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output24"
    id: "t32m_output24"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 7
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output25"
    id: "t32m_output25"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 8
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output26"
    id: "t32m_output26"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 9
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output27"
    id: "t32m_output27"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 10
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output28"
    id: "t32m_output28"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 11
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output29"
    id: "t32m_output29"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 12
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output30"
    id: "t32m_output30"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 13
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output31"
    id: "t32m_output31"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 14
      mode: OUTPUT
      inverted: true

  - platform: gpio
    name: "t32m-output32"
    id: "t32m_output32"
    pin:
      pcf8574: pcf8574_hub_out_2
      number: 15
      mode: OUTPUT
      inverted: true

binary_sensor:
  - platform: gpio
    name: "t32m-input01"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 0
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input02"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 1
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input03"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 2
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input04"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 3
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input05"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 4
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input06"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 5
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input07"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 6
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input08"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 7
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input09"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 8
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input10"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 9
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input11"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 10
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input12"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 11
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input13"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 12
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input14"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 13
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input15"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 14
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input16"
    pin:
      pcf8574: pcf8574_hub_in_1
      number: 15
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input17"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 0
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input18"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 1
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input19"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 2
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input20"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 3
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input21"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 4
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input22"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 5
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input23"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 6
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input24"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 7
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input25"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 8
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input26"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 9
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input27"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 10
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input28"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 11
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input29"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 12
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input30"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 13
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input31"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 14
      mode: INPUT
      inverted: true

  - platform: gpio
    name: "t32m-input32"
    pin:
      pcf8574: pcf8574_hub_in_2
      number: 15
      mode: INPUT
      inverted: true

## pull-up resistance on PCB
  - platform: gpio
    name: "t32m-W1-io15"
    pin:
      number: 15
      inverted: true

  - platform: gpio
    name: "t32m-W1-io16"
    pin:
      number: 16
      inverted: false

  - platform: gpio
    name: "t32m-W1-io17"
    pin:
      number: 17
      inverted:  false

  - platform: gpio
    name: "t32m-W1-io18"
    pin:
      number: 18
      inverted:  false

## without pull-up resistance on PCB
  - platform: gpio
    name: "t32m-io0"
    pin:
      number: 0
      inverted:  false

  - platform: gpio
    name: "t32m-io8"
    pin:
      number: 8
      inverted:  false

  - platform: gpio
    name: "t32m-io9"
    pin:
      number: 9
      inverted:  false

  - platform: gpio
    name: "t32m-io10"
    pin:
      number: 10
      inverted:  false

sensor:
  - platform: adc
    pin: 7
    name: "t32m 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: 6
    name: "t32m 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: 5
    name: "t32m A3 Current"
    update_interval: 5s
    unit_of_measurement: mA
    attenuation: 11db
    filters:
      - multiply: 6.66666666
  - platform: adc
    pin: 4
    name: "t32m A4 Current"
    update_interval: 5s
    unit_of_measurement: mA
    attenuation: 11db
    filters:
      - multiply: 6.66666666

web_server:
  port: 80
download yaml file:

.txt   T32M-HA.txt (Size: 13.02 KB / Downloads: 163)

Print this item

  T32M ESP32-S3 IO pins define
Posted by: admin - 06-23-2025, 05:14 AM - Forum: T32M - No Replies

analog A1 (0-5v): GPIO7
analog A2 (0-5v): GPIO6
analog A3 (4-20mA): GPIO5
analog A4 (4-20mA): GPIO4

-----------------
IIC Bus-1:

SDA:GPIO48
SCL:GPIO47

PCF8575: (output1-16): i2c address:0x20
PCF8575: (output17-32): i2c address:0x21
PCF8575: (input1-16): i2c address:0x24
PCF8575: (input17-32): i2c address:0x25

24C02 EPROM i2c address: 0x50

-----------------

1-wire (pull-up resistance on PCB):
GPIO15
GPIO16
GPIO17
GPIO18

free GPIO:
GPIO8
GPIO9
GPIO10

-----------------

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:GPIO21
TXD:GPIO13
EN:GPIO14

Print this item

  [arduino code examples for B8]-11 digital INPUT trigger OUTPUT directly
Posted by: admin - 06-23-2025, 05:02 AM - Forum: B8 - No Replies

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* This program reads 8 input states from a PCF8575 I/O expander and
* controls a corresponding 8-channel relay module. When an input pin
* is LOW, the corresponding relay is turned ON (LOW means ON for the relay).
* When the input pin is HIGH, the corresponding relay is turned OFF.
*/

#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 = 8; i < 16; 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 = 0; i < 8; 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)) {
      pcf8575_RL.write(i+8, HIGH);  // If input is HIGH, turn the relay OFF
    } else {
      pcf8575_RL.write(i+8, 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: 968 bytes / Downloads: 306)
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: 192.21 KB / Downloads: 299)

Print this item

  [arduino code examples for B8]-10 Print TEXT on SSD1306 OLED displayer
Posted by: admin - 06-23-2025, 05:00 AM - Forum: B8 - 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: 303)
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: 202.58 KB / Downloads: 273)

Print this item