Smart Home Automation Forum - T64M

T64M Smart Controller Wiring Examples

Mon, 20 Apr 2026 13:38:11 +0800

T64M_wiring.jpg (Size: 229.09 KB / Downloads: 68)

T64M Smart Controller ESP32 system block diagram

Mon, 20 Apr 2026 13:34:18 +0800

KinCony-T64M-smart-controller-diagram.png (Size: 774.21 KB / Downloads: 64)

Digital Input Voltage

Wed, 04 Feb 2026 16:36:06 +0800

What is the acceptable Voltage range for the Digital Inputs?

Release Dates for T64M and T128M

Tue, 06 May 2025 22:51:10 +0800

Hello everyone,

Could you please let us know when the T64M and T128M will be released?
Thank you for your feedback.
Have a great day.

[arduino code examples for T64M]-08 read analog input ports

Thu, 24 Apr 2025 09:10:38 +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 7

 * - A2: GPIO 6

 * - A3: GPIO 5

 * - A4: GPIO 4

 */

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

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

#define ANALOG_A3   5   // 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:

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

8-analog-input.ino.merged.zip (Size: 187.2 KB / Downloads: 473)

[arduino code examples for T64M]-07 i2c scanner search online devices

Sun, 20 Apr 2025 15:45:29 +0800

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

// This sketch scans two I2C buses and prints all detected device addresses.

// IIC Bus-1: SDA - GPIO48, SCL - GPIO47

// IIC Bus-2: SDA - GPIO12, SCL - GPIO11

#include 

// Create two I2C bus objects

TwoWire I2C_BUS1 = TwoWire(0);

TwoWire I2C_BUS2 = TwoWire(1);

// Scan function for a specific I2C bus

void scanI2CBus(TwoWire &bus, const char* busName) {

  Serial.println();

  Serial.print("Scanning ");

  Serial.print(busName);

  Serial.println(" at 100kHz...");

  byte error, address;

  int nDevices = 0;

  for (address = 1; address < 127; address++) {

    bus.beginTransmission(address);

    error = bus.endTransmission();

    if (error == 0) {

      Serial.print("I2C device found at address 0x");

      if (address < 16)

        Serial.print("0");

      Serial.print(address, HEX);

      Serial.println("  ✓");

      nDevices++;

    } else if (error == 4) {

      Serial.print("Unknown error at address 0x");

      if (address < 16)

        Serial.print("0");

      Serial.println(address, HEX);

    }

  }

  if (nDevices == 0)

    Serial.println("No I2C devices found.");

  else

    Serial.println("Scan completed.");

}

void setup() {

  Serial.begin(115200);

  delay(1000); // Wait for serial to initialize

  // Initialize IIC Bus-1 (GPIO48 = SDA, GPIO47 = SCL) at 100kHz

  I2C_BUS1.begin(48, 47);

  // Initialize IIC Bus-2 (GPIO12 = SDA, GPIO11 = SCL) at 100kHz

  I2C_BUS2.begin(12, 11);

  // Start scanning both buses

  scanI2CBus(I2C_BUS1, "IIC Bus-1");

  scanI2CBus(I2C_BUS2, "IIC Bus-2");

}

void loop() {

  // Nothing to do in the loop

}

arduino ino file download:

7-i2c-scanner.zip (Size: 841 bytes / Downloads: 433)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:

7-i2c-scanner.ino.merged.zip (Size: 192.17 KB / Downloads: 441)

[arduino code examples for T64M]-06 digital INPUT trigger OUTPUT directly

Sun, 20 Apr 2025 15:44:21 +0800

Code:
/*

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

 *

 * This Arduino program reads 64 input channels from 4 PCF8575 modules on I2C Bus-2

 * and controls 64 output channels on 4 PCF8575 modules on I2C Bus-1.

 * When an input pin is pulled LOW (connected to GND), the corresponding output relay is turned ON (LOW).

 * Otherwise, the relay is turned OFF (HIGH).

 *

 * I2C Bus-1 (Outputs):

 * - SDA: GPIO 48

 * - SCL: GPIO 47

 * - Output1~16  : 0x25

 * - Output17~32 : 0x24

 * - Output33~48 : 0x21

 * - Output49~64 : 0x20

 *

 * I2C Bus-2 (Inputs):

 * - SDA: GPIO 12

 * - SCL: GPIO 11

 * - Input1~16   : 0x25

 * - Input17~32  : 0x24

 * - Input33~48  : 0x21

 * - Input49~64  : 0x20

 */

#include 

#include 

// === Create two independent Wire objects ===

TwoWire I2C_Output = TwoWire(0);  // I2C Bus 1 - for output control

TwoWire I2C_Input  = TwoWire(1);  // I2C Bus 2 - for reading inputs

// === Output PCF8575 modules (connected to relays) ===

PCF8575 output_1(0x25, &I2C_Output);  // Output 1-16

PCF8575 output_2(0x24, &I2C_Output);  // Output 17-32

PCF8575 output_3(0x21, &I2C_Output);  // Output 33-48

PCF8575 output_4(0x20, &I2C_Output);  // Output 49-64

// === Input PCF8575 modules ===

PCF8575 input_1(0x25, &I2C_Input);    // Input 1-16

PCF8575 input_2(0x24, &I2C_Input);    // Input 17-32

PCF8575 input_3(0x21, &I2C_Input);    // Input 33-48

PCF8575 input_4(0x20, &I2C_Input);    // Input 49-64

// === Arrays to manage all input/output modules ===

PCF8575* inputArray[4]  = { &input_1, &input_2, &input_3, &input_4 };

PCF8575* outputArray[4] = { &output_1, &output_2, &output_3, &output_4 };

void setup() {

  Serial.begin(115200);

  Serial.println("KinCony 64-Channel Input-Output Mapping Test");

  // Initialize I2C buses

  I2C_Output.begin(48, 47); // SDA: GPIO48, SCL: GPIO47

  I2C_Input.begin(12, 11);  // SDA: GPIO12, SCL: GPIO11

  // Initialize all PCF8575 modules

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

    inputArray[i]->begin();

    outputArray[i]->begin();

    // Initially turn off all relays (set to HIGH)

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

      outputArray[i]->write(j, HIGH);

    }

  }

}

void loop() {

  for (int chip = 0; chip < 4; chip++) {

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

      int globalPin = chip * 16 + pin;  // 0~63

      bool inputState = inputArray[chip]->read(pin);

      // 0 = Signal present (connected to GND), relay ON (output LOW)

      // 1 = No signal, relay OFF (output HIGH)

      outputArray[chip]->write(pin, inputState ? HIGH : LOW);

    }

  }

  delay(200); // Slight delay to avoid excessive reading

}

arduino ino file download:

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

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

[arduino code examples for T64M]-05 Ethernet W5500 chip work with TCP Server mode

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

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

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

[arduino code examples for T64M]-04 Read free GPIO state

Sun, 20 Apr 2025 15:38:45 +0800

Code:
/*

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

 *

 * GPIO Status Monitoring

 *

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

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

 *

 * GPIO Pins Monitored:

 * - GPIO 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:

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

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

[arduino code examples for T64M]-03 RS485 communication test

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

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 

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

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

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

3-RS485-Test.ino.merged.zip (Size: 186.66 KB / Downloads: 478)

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

Sun, 20 Apr 2025 15:35:51 +0800

Code:
/*

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

 *

 * Description:

 * This Arduino program reads the state of 64 input channels using 4 PCF8575 I/O expanders

 * and prints the state of all input pins to the Serial Monitor. Each input state is printed

 * in binary (0 = ON, 1 = OFF), grouped by 16 bits per chip.

 *

 * I2C Pin Definitions:

 * - SDA: GPIO 12

 * - SCL: GPIO 11

 *

 * PCF8575 Addresses:

 * - Input  1~16 : 0x25

 * - Input 17~32: 0x24

 * - Input 33~48: 0x21

 * - Input 49~64: 0x20

 */

#include 

#include 

// Define I2C pins

#define SDA_PIN 12

#define SCL_PIN 11

// Create PCF8575 objects

PCF8575 pcf_1(0x25); // Input  1-16

PCF8575 pcf_2(0x24); // Input 17-32

PCF8575 pcf_3(0x21); // Input 33-48

PCF8575 pcf_4(0x20); // Input 49-64

// Array of PCF8575 pointers

PCF8575* pcfArray[4] = { &pcf_1, &pcf_2, &pcf_3, &pcf_4 };

void setup() {

  Serial.begin(115200);

  Wire.begin(SDA_PIN, SCL_PIN); // Initialize I2C

  // Initialize each PCF8575

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

    pcfArray[i]->begin();

  }

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

}

void loop() {

  Serial.println("Reading Inputs...");

  for (int chip = 0; chip < 4; chip++) {

    uint16_t state = 0;

    // Read 16 input pins per PCF8575

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

      if (pcfArray[chip]->read(pin)) {

        state |= (1 << pin); // Bit = 1 means OFF (no signal), 0 means ON

      }

    }

    // Display result

    Serial.print("Input ");

    Serial.print(chip * 16 + 1);

    Serial.print("~");

    Serial.print((chip + 1) * 16);

    Serial.print(": ");

    for (int b = 15; b >= 0; b--) {

      Serial.print(bitRead(state, b));

    }

    Serial.println();

  }

  Serial.println(); // Blank line between readings

  delay(500);       // Wait 500ms before next read

}

arduino ino file download:

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

2-digital-input.ino.merged.zip (Size: 192.41 KB / Downloads: 428)

[arduino code examples for T64M]-01 Turn ON/OFF OUTPUT

Sun, 20 Apr 2025 15:34:36 +0800

Code:
/*

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

 *

 * This program controls 64 outputs using 4 PCF8575 I/O expanders.

 * It sequentially turns on outputs 1 to 64, then turns them off from 64 to 1, in a loop.

 * 

 * I2C Pin Definitions:

 * - SDA: GPIO 48

 * - SCL: GPIO 47

 *

 * PCF8575 Addresses:

 * - Output  1~16 : 0x25

 * - Output 17~32: 0x24

 * - Output 33~48: 0x21

 * - Output 49~64: 0x20

 *

 * Delay Time:

 * - 200 milliseconds between switching outputs

 */

#include         // Include the Wire library for I2C communication

#include      // Include the PCF8575 library

#define SDA_PIN 48       // Define SDA pin

#define SCL_PIN 47       // Define SCL pin

#define DELAY_TIME 200   // Delay between operations in milliseconds

// Create PCF8575 objects for each chip

PCF8575 pcf_1(0x25); // output  1-16

PCF8575 pcf_2(0x24); // output 17-32

PCF8575 pcf_3(0x21); // output 33-48

PCF8575 pcf_4(0x20); // output 49-64

// Array of pointers to PCF8575 objects

PCF8575* pcfArray[4] = { &pcf_1, &pcf_2, &pcf_3, &pcf_4 };

void setup() {

  Wire.begin(SDA_PIN, SCL_PIN);  // Initialize I2C with specified pins

  Serial.begin(115200);

  Serial.println("PCF8575 64-Channel Output Control Starting...");

  // Initialize all PCF8575 modules and set all pins to HIGH (OFF)

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

    pcfArray[i]->begin();

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

      pcfArray[i]->write(j, HIGH);  // Turn off all outputs initially

    }

  }

}

void loop() {

  // Turn ON outputs from 1 to 64 (LOW)

  for (int channel = 0; channel < 64; channel++) {

    int chipIndex = channel / 16;         // Which PCF8575 (0 to 3)

    int pinIndex = channel % 16;          // Which pin on that PCF8575 (0 to 15)

    pcfArray[chipIndex]->write(pinIndex, LOW); // Turn ON the output

    delay(DELAY_TIME);

  }

  // Turn OFF outputs from 64 to 1 (HIGH)

  for (int channel = 63; channel >= 0; channel--) {

    int chipIndex = channel / 16;

    int pinIndex = channel % 16;

    pcfArray[chipIndex]->write(pinIndex, HIGH); // Turn OFF the output

    delay(DELAY_TIME);

  }

}

arduino ino file download:

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

1-output.ino.merged.zip (Size: 192.12 KB / Downloads: 424)

T64M ESPHome yaml for home assistant

Sun, 20 Apr 2025 15:32:49 +0800

Code:
/*

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

 *

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

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

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

 *

 * Pin Definitions:

 * - SDA: GPIO 8

 * - SCL: GPIO 18

 * - PCF8575 I2C Address: 0x24

 */

#include 

#include 

// I2C pins

#define SDA 8

#define SCL 18

// PCF8575 I2C address

#define INPUT_I2C_ADDRESS 0x24   

// Create PCF8575 object

PCF8575 pcf8575_IN(INPUT_I2C_ADDRESS);

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL);

  // Initialize serial communication

  Serial.begin(115200);

  // Initialize PCF8575

  pcf8575_IN.begin();

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

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

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

  }

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

}

void loop() {

  // Read 16-bit state from PCF8575

  uint16_t inputState = pcf8575_IN.read16(); 

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

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

    Serial.print("DI");

    Serial.print(i + 1);

    Serial.print(" State: ");

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

    // Control relay (LOW activates the relay)

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

  }

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

  delay(500);

}

yaml download:

T64M-HA.txt (Size: 23.77 KB / Downloads: 382)

T64M ESP32-S3 IO pins define

Sun, 20 Apr 2025 15:30:16 +0800

Code:
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:0x25

PCF8575:(output17-32): i2c address:0x24

PCF8575:(output33-48): i2c address:0x21

PCF8575:(output49-64): i2c address:0x20

24C02 EPROM i2c address: 0x50

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

IIC Bus-2:

SDA:GPIO12

SCL:GPIO11

PCF8575:(input1-16): i2c address:0x25

PCF8575:(input17-32): i2c address:0x24

PCF8575:(input33-48): i2c address:0x21

PCF8575:(input49-64): i2c address:0x20

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

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