Smart Home Automation Forum - B4M

4-20mA loop voltage consideration

Tue, 11 Aug 2026 14:21:07 +0800

Although the B4 and B4M devices allow connection of a 24Vdc supply it is not clear to me that the 4-20 mA analog inputs allow use of a 24 volt loop supply. The example drawings show 12 volt supply devices connected and I am concerned that I may damage the inputs by using a 24vdc loop. Please advise what is acceptable.

Questions on the B4M

Thu, 16 Jul 2026 19:07:11 +0800

I have a bunch of questions about the B4M that I don't see in any of the docs:

What is rated DC V and A range for the MOSFET relays? I'd like to use it for 5-24V, no more than 2A.

Can the B8M relays can handle mixed voltages/references? Like 12V on one relay and 24V on a different one?

What wire gauge size range do the relay terminals accept?

What is the power supply rating (V, A) in the B4M bundle B power supply?

With the KDS v3 firmware: does the B4M will present its relays over the network to Home Assistant (via auto discovery)?

If I connect several DS18B20 temperature sensors to the B4M one wire interfaces will these be automatically presented to Home Assistant as temp sensors across the network or will have to code the Home Assistant presentation and auto-discovery on the B4M?

Thanks for any help.

RS485 issue

Wed, 24 Jun 2026 19:10:38 +0800

Hi Kincony,
I have bought some of your B4M modules, and try to use the RS485 port.
I try to run the code here: https://www.kincony.com/forum/showthread.php?tid=8934

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 18 and RXD pin is defined as GPIO 8.

 */

#include 

// Define RS485 pins

#define RS485_RXD 39

#define RS485_TXD 38

// 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);

}

void loop() {

  // Send a test message

  rs485Serial.println("Hello from KinCony B8M!");

  // 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);

  } else 

  {

    Serial.println("RS485 is not available");

  }

  // Wait before sending the next message

  delay(2000);

}

but cannot receive the data from RS485 port. The log shows that port is not available.
Can you help me troubleshoot this issue?

Best regards,
Hai Pham

B4M Smart Controller Wiring Examples

Sat, 18 Apr 2026 10:23:11 +0800

B4M_wiring.jpg (Size: 283.6 KB / Downloads: 269)

B4M Smart Controller ESP32 system block diagram

Sat, 18 Apr 2026 10:11:39 +0800

KinCony-B4M-Smart-Controller-diagram.png (Size: 1.73 MB / Downloads: 247)

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

Wed, 14 Jan 2026 12:05:21 +0800

Code:
/*

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

 *

 * This program reads 4 input states from a PCF8574 I/O expander and 

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

PCF8574 pcf8574_IN(INPUT_I2C_ADDRESS);

void setup() {

  // Initialize I2C communication

  Wire.begin(SDA, SCL);

  // Initialize serial communication

  Serial.begin(115200);

    pcf8574_IN.pinMode(P0, INPUT);

    pcf8574_IN.pinMode(P1, INPUT);

    pcf8574_IN.pinMode(P2, INPUT);

    pcf8574_IN.pinMode(P3, INPUT);

      pcf8574_IN.pinMode(P4, OUTPUT);

    pcf8574_IN.pinMode(P5, OUTPUT);

    pcf8574_IN.pinMode(P6, OUTPUT);

    pcf8574_IN.pinMode(P7, OUTPUT);

  // Initialize PCF8575

  pcf8574_IN.begin();

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

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

    pcf8574_IN.digitalWrite(i, HIGH);  // Set to HIGH to turn off the relay

  }

  delay(50);

}

void loop() {

  if (pcf8574_IN.digitalRead(0)) pcf8574_IN.digitalWrite(4, HIGH); else pcf8574_IN.digitalWrite(4, LOW);

  delay(50);

  if (pcf8574_IN.digitalRead(1)) pcf8574_IN.digitalWrite(5, HIGH); else pcf8574_IN.digitalWrite(5, LOW);       

  delay(50);

  if (pcf8574_IN.digitalRead(2)) pcf8574_IN.digitalWrite(6, HIGH); else pcf8574_IN.digitalWrite(6, LOW);

  delay(50);

  if (pcf8574_IN.digitalRead(3)) pcf8574_IN.digitalWrite(7, HIGH); else pcf8574_IN.digitalWrite(7, LOW);

  delay(50);

}

arduino ino file download:

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

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

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

Wed, 14 Jan 2026 12:04:09 +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: 269)
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: 202.58 KB / Downloads: 260)

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

Wed, 14 Jan 2026 12:02:55 +0800

Code:
/*

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

 * 

 * This Arduino program implements communication between ESP32 and the Tuya module

 * via UART (serial communication). It listens for specific packets from the Tuya module

 * and responds according to the predefined commands.

 * 

 * Functionality:

 * 1. When the ESP32 receives a heartbeat packet (55 AA 00 00 00 00 FF),

 *    it sends a heartbeat response (55 AA 03 00 00 01 00 03).

 * 2. When the ESP32 receives a product information request (55 AA 00 01 00 00 00),

 *    it sends a product information response (55 AA 03 01 ...).

 * 3. When the ESP32 receives a work mode request (55 AA 00 02 00 00 01),

 *    it sends a work mode response (55 AA 03 02 00 03 10 1C 14 47).

 * 4. When the ESP32 receives a network status request (55 AA 00 03 00 01 00 03),

 *    it sends a network status response (55 AA 03 03 00 00 05).

 * 5. Subsequent heartbeat packets (55 AA 00 00 00 00 FF) are responded to with

 *    (55 AA 03 00 00 01 01 04).

 */

#include 

// Create a HardwareSerial object for UART communication on ESP32

HardwareSerial tuyaSerial(1);

// Define the GPIO pins for TXD and RXD used for serial communication

#define TXD_PIN 15

#define RXD_PIN 16

// Set the baud rate for Tuya module communication to 9600

#define BAUD_RATE 9600

// Define the response packets for different commands from the Tuya module

// Heartbeat response: 55 AA 03 00 00 01 00 03

uint8_t heartBeatResponse[] = {0x55, 0xAA, 0x03, 0x00, 0x00, 0x01, 0x00, 0x03};

// Product info response with a detailed payload (e.g., firmware version, product name, etc.)

uint8_t productInfoResponse[] = {

  0x55, 0xAA, 0x03, 0x01, 0x00, 0x2A, 0x7B, 0x22, 0x70, 0x22, 0x3A, 0x22, 

  0x63, 0x68, 0x6D, 0x7A, 0x6C, 0x67, 0x6A, 0x70, 0x61, 0x64, 0x70, 0x71, 

  0x78, 0x64, 0x6B, 0x6F, 0x22, 0x2C, 0x22, 0x76, 0x22, 0x3A, 0x22, 0x31, 

  0x2E, 0x30, 0x2E, 0x30, 0x22, 0x2C, 0x22, 0x6D, 0x22, 0x3A, 0x30, 0x7D, 0xAA

};

// Work mode response: 55 AA 03 02 00 03 10 1C 14 47

uint8_t workModeResponse[] = {0x55, 0xAA, 0x03, 0x02, 0x00, 0x03, 0x10, 0x1C, 0x14, 0x47};

// Network status response: 55 AA 03 03 00 00 05

uint8_t netStatusResponse[] = {0x55, 0xAA, 0x03, 0x03, 0x00, 0x00, 0x05};

// Subsequent heartbeat response: 55 AA 03 00 00 01 01 04

uint8_t secondHeartBeatResponse[] = {0x55, 0xAA, 0x03, 0x00, 0x00, 0x01, 0x01, 0x04};

void setup() {

  // Initialize the serial communication for debugging at 115200 baud rate

  Serial.begin(115200);

  // Initialize the serial communication with Tuya module at 9600 baud rate

  tuyaSerial.begin(BAUD_RATE, SERIAL_8N1, RXD_PIN, TXD_PIN);

  // Debug message to indicate that the serial communication has been initialized

  Serial.println("ESP32-Tuya serial communication initialized.");

}

void loop() {

  // Check if data is available from the Tuya module

  if (tuyaSerial.available()) {

    uint8_t incomingPacket[7];  // Array to store the received packet

    size_t bytesRead = tuyaSerial.readBytes(incomingPacket, 7); // Read 7 bytes from Tuya

    // Check if the packet has a valid header (0x55, 0xAA)

    if (bytesRead >= 2 && incomingPacket[0] == 0x55 && incomingPacket[1] == 0xAA) {

      // If less than 7 bytes were received, wait for more data

      if (bytesRead < 7) {

        Serial.println("Incomplete packet received. Waiting for remaining bytes...");

        delay(50); // Delay to allow more data to be received

        while (tuyaSerial.available()) {

          incomingPacket[bytesRead++] = tuyaSerial.read(); // Continue reading remaining bytes

          if (bytesRead >= 7) break;

        }

      }

      // If still less than 7 bytes, discard the incomplete packet

      if (bytesRead < 7) {

        Serial.println("Error: Incomplete packet discarded.");

        return;

      }

      // Debug: Print the received packet for logging

      Serial.print("Received packet: ");

      for (size_t i = 0; i < 7; i++) {

        Serial.print(incomingPacket[i], HEX);

        Serial.print(" ");

      }

      Serial.println();

      // Call the function to process the received packet

      processTuyaPacket(incomingPacket, 7);

    } else {

      // If the header is invalid, discard the packet and flush the buffer

      Serial.print("Error: Invalid packet header. Data received: ");

      for (size_t i = 0; i < bytesRead; i++) {

        Serial.print(incomingPacket[i], HEX);

        Serial.print(" ");

      }

      Serial.println();

      tuyaSerial.flush(); // Clear the serial buffer

    }

  }

  // Delay to avoid CPU overuse

  delay(100);

}

// Function to process the received packet and send the appropriate response

void processTuyaPacket(uint8_t* packet, size_t size) {

  // Ensure the packet size is 7 and the header is valid

  if (size == 7 && packet[0] == 0x55 && packet[1] == 0xAA) {

    // Determine the command in the packet (packet[2])

    switch(packet[2]) {

      case 0x00:

        if (packet[3] == 0x00 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0xFF) {

          Serial.println("Heartbeat received.");

          sendPacket(heartBeatResponse, sizeof(heartBeatResponse));

        } else if (packet[3] == 0x01 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0x00) {

          Serial.println("Product info request received.");

          sendPacket(productInfoResponse, sizeof(productInfoResponse));

        } else if (packet[3] == 0x02 && packet[4] == 0x00 && packet[5] == 0x00 && packet[6] == 0x01) {

          Serial.println("Work mode request received.");

          sendPacket(workModeResponse, sizeof(workModeResponse));

        } else if (packet[3] == 0x03 && packet[4] == 0x00 && packet[5] == 0x01 && packet[6] == 0x00) {

          Serial.println("Network status request received.");

          sendPacket(netStatusResponse, sizeof(netStatusResponse));

        }

        break;

      default:

        Serial.println("Error: Unhandled command received.");

        break;

    }

  }

}

// Function to send the response packet to the Tuya module

void sendPacket(uint8_t* packet, size_t size) {

  // Send the packet via UART to Tuya module

  tuyaSerial.write(packet, size);

  // Debug: Print the sent packet for logging

  Serial.print("Sent packet: ");

  for (size_t i = 0; i < size; i++) {

    Serial.print(packet[i], HEX);

    Serial.print(" ");

  }

  Serial.println();

}

arduino ino file download:

9-tuya-wifi-config.zip (Size: 2 KB / Downloads: 296)

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

Wed, 14 Jan 2026 12:01:47 +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  42

#define W5500_RST_PIN 44

#define W5500_INT_PIN 43

#define W5500_CLK_PIN 1

#define W5500_MOSI_PIN 2

#define W5500_MISO_PIN 41

// 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: 290)
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: 191.06 KB / Downloads: 302)

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

Wed, 14 Jan 2026 12:00:42 +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

*    Set date and time command example: D2024-09-19T11:50:22

*    print current date and time command: current time

*

 *

 * 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.56 KB / Downloads: 316)
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: 193.65 KB / Downloads: 271)

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

Wed, 14 Jan 2026 11:59:29 +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: 333)
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: 219.15 KB / Downloads: 277)

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

Wed, 14 Jan 2026 11:58:03 +0800

Code:
/*

 * ESP32 GPIO State Reader

 * Reads the state of GPIO47, GPIO48, GPIO7, GPIO40, GPIO0, and GPIO5

 * and prints the results to the serial monitor.

 * 

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

 */

#define GPIO_13  13

#define GPIO_40  40

#define GPIO_14  14

#define GPIO_48  48

#define GPIO_0   0

#define GPIO_47  47

#define GPIO_17  17

#define GPIO_21  21

void setup() {

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

    // Set GPIOs as input

    pinMode(GPIO_13, INPUT);

    pinMode(GPIO_40, INPUT);

    pinMode(GPIO_14, INPUT);

    pinMode(GPIO_48, INPUT);

    pinMode(GPIO_0, INPUT);

    pinMode(GPIO_47, INPUT);

    pinMode(GPIO_17, INPUT);

    pinMode(GPIO_21, INPUT);            

}

void loop() {

    // Read GPIO states

    int state_13 = digitalRead(GPIO_13);

    int state_40 = digitalRead(GPIO_40);

    int state_14  = digitalRead(GPIO_14);

    int state_48 = digitalRead(GPIO_48);

    int state_0  = digitalRead(GPIO_0);

    int state_47 = digitalRead(GPIO_47);

    int state_17 = digitalRead(GPIO_17);

    int state_21 = digitalRead(GPIO_21);

    // Print GPIO states to the serial monitor

    Serial.printf("GPIO13: %d, GPIO40: %d, GPIO14: %d, GPIO48: %d, GPIO0: %d, GPIO47: %d, GPIO17: %d, GPIO21: %d\n",

                  state_13, state_40, state_14, state_48, state_0, state_47, state_17, state_21);

    delay(1000); // Read GPIO states every second

}

arduino ino file download:

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

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

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

Wed, 14 Jan 2026 11:55:13 +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 18 and RXD pin is defined as GPIO 8.

 */

#include 

// Define RS485 pins

#define RS485_RXD 39

#define RS485_TXD 38

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

  // Wait for a short period

  delay(1000);

  // Check if data is available to read

  if (rs485Serial.available()) {

    String receivedMessage = "";

    while (rs485Serial.available()) {

      char c = rs485Serial.read();

      receivedMessage += c;

    }

    // Print the received message

    Serial.print("Received: ");

    Serial.println(receivedMessage);

  }

  // Wait before sending the next message

  delay(2000);

}

arduino ino file download:

4-RS485-Test.zip (Size: 763 bytes / Downloads: 294)
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: 190.13 KB / Downloads: 279)

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

Wed, 14 Jan 2026 11:53:54 +0800

Code:
/*

 * This program reads voltage values from the ADS1115 analog-to-digital converter

 * on all four channels (A0, A1, A2, A3) and prints the results through the serial port.

 * The ADS1115 communicates via the I2C protocol. This version of the code includes 

 * the capability to specify custom SDA and SCL pins for I2C communication.

 *

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

 *

 */

#include                 // Library for I2C communication

#include      // Library for ADS1115 ADC module

// Define the I2C SDA and SCL pins for communication with ADS1115

#define SDA_PIN 8  

#define SCL_PIN 18  

// Initialize ADS1115 instance using the Wire library

DFRobot_ADS1115 ads(&Wire);

void setup(void) 

{

    // Begin serial communication at a baud rate of 115200

    Serial.begin(115200);

    // Initialize the I2C bus using the defined SDA and SCL pins

    Wire.begin(SDA_PIN, SCL_PIN);

    // Set the I2C address for the ADS1115 (default: 0x49)

    ads.setAddr_ADS1115(ADS1115_IIC_ADDRESS0);   // Address is 0x49

    // Set the gain for the ADS1115 (2/3x gain allows for a maximum input voltage of 6.144V)

    ads.setGain(eGAIN_TWOTHIRDS);

    // Set the ADS1115 to operate in single-shot mode (each reading is a single conversion)

    ads.setMode(eMODE_SINGLE);

    // Set the sample rate to 128 samples per second (SPS)

    ads.setRate(eRATE_128);

    // Set the operational status mode to single-conversion start

    ads.setOSMode(eOSMODE_SINGLE);

    // Initialize the ADS1115 module

    ads.init();

}

void loop(void) 

{

    // Check if the ADS1115 is properly connected and functioning

    if (ads.checkADS1115())

    {

        // Variables to store the voltage readings for each channel

        int16_t adc0, adc1, adc2, adc3;

        // Read the voltage from channel A0 and print the value

        adc0 = ads.readVoltage(0);

        Serial.print("A0:");

        Serial.print(adc0);

        Serial.print("mV,  ");    // Print the value in millivolts

        // Read the voltage from channel A1 and print the value

        adc1 = ads.readVoltage(1);

        Serial.print("A1:");

        Serial.print(adc1);

        Serial.print("mV,  ");    // Print the value in millivolts

        // Read the voltage from channel A2 and print the value

        adc2 = ads.readVoltage(2);

        Serial.print("A2:");

        Serial.print(adc2);

        Serial.print("mV,  ");    // Print the value in millivolts

        // Read the voltage from channel A3 and print the value

        adc3 = ads.readVoltage(3);

        Serial.print("A3:");

        Serial.print(adc3);

        Serial.println("mV");     // Print the value in millivolts and end the line

    }

    else

    {

        // If ADS1115 is not connected, print a message indicating disconnection

        Serial.println("ADS1115 Disconnected!");

    }

    // Wait for 1 second before the next loop iteration

    delay(1000);

}

arduino ino file download:

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

3-ads1115_adc.ino.merged.zip (Size: 192.69 KB / Downloads: 296)

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

Wed, 14 Jan 2026 11:52:37 +0800

Code:
/*

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

 *

 * Description:

 * This Arduino program reads the state of a 16-channel PCF8574 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 "PCF8574.h"

// Define I2C pins

#define I2C_SDA 8  // Define SDA pin

#define I2C_SCL 18  // Define SCL pin

// Set I2C address

PCF8574 pcf8574_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

    pcf8574_IN1.pinMode(P0, INPUT);

    pcf8574_IN1.pinMode(P1, INPUT);

    pcf8574_IN1.pinMode(P2, INPUT);

    pcf8574_IN1.pinMode(P3, INPUT);

    pcf8574_IN1.begin(); // Initialize the PCF8575

    Serial.println("KinCony F4 4 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 < 4; pin++) {

        if (pcf8574_IN1.digitalRead(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:

2-digital-input.zip (Size: 879 bytes / Downloads: 300)
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: 199.52 KB / Downloads: 303)