Smart Home Automation Forum
Portal

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

Username
  

Password
  

Search Forums

(Advanced Search)

Forum Statistics
» Members: 9,018
» Latest member: alinailyin
» Forum threads: 3,974
» Forum posts: 20,144

Full Statistics

Online Users
There are currently 41 online users.
» 0 Member(s) | 26 Guest(s)
AhrefsBot, Amazonbot, Applebot, Baidu, Bing, Google, PetalBot, Yandex, bot

Latest Threads
Current and Power not add...
Forum: N60
Last Post: edalquist
Yesterday, 03:58 AM
» Replies: 10
» Views: 276
Python and arduino code
Forum: News
Last Post: admin
05-08-2026, 12:38 PM
» Replies: 1
» Views: 16
[SOLVED] N10 - no KWH sho...
Forum: N10
Last Post: admin
05-07-2026, 05:56 AM
» Replies: 7
» Views: 116
B24 Smart Controller Wiri...
Forum: B24
Last Post: admin
05-06-2026, 10:12 PM
» Replies: 2
» Views: 92
AIO Hybrid ESP32-S3 IO pi...
Forum: AIO Hybrid
Last Post: H_spadacini
05-06-2026, 10:03 AM
» Replies: 3
» Views: 591
T32M issue with Output 1
Forum: DIY Project
Last Post: BarbaraVikuvis
05-06-2026, 06:49 AM
» Replies: 4
» Views: 358
RTC DS3231 yaml code
Forum: KC868-A16v3
Last Post: admin
05-05-2026, 01:38 PM
» Replies: 1
» Views: 42
T64M PCB layout CAD file
Forum: Schematic & diagram & Dimensions of KinCony PCB layout CAD file
Last Post: admin
05-05-2026, 08:08 AM
» Replies: 0
» Views: 29
T16M PCB layout CAD file
Forum: Schematic & diagram & Dimensions of KinCony PCB layout CAD file
Last Post: admin
05-05-2026, 08:07 AM
» Replies: 0
» Views: 22
24V Pulse input
Forum: F16
Last Post: admin
05-05-2026, 04:23 AM
» Replies: 3
» Views: 31

  [arduino code examples for A16v3]-06 How to use SD Card
Posted by: admin - 01-15-2025, 06:02 AM - Forum: KC868-A16v3 - No Replies

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 13
* - MISO: GPIO 14
* - MOSI: GPIO 12
* - CS: GPIO 11
*/

#include "FS.h"
#include "SD.h"
#include "SPI.h"

// Pin definitions for SD card
#define SCK  13
#define MISO 14
#define MOSI 12
#define CS   11

/**
* @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:
.zip   6-SD.zip (Size: 1.53 KB / Downloads: 481)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   6-SD.ino.merged.zip (Size: 221.26 KB / Downloads: 510)

Print this item

  [arduino code examples for A16v3]-05 Read free GPIO state
Posted by: admin - 01-15-2025, 06:01 AM - Forum: KC868-A16v3 - No Replies

Code:
/*
  Version: 1.0.0
  Created by KinCony (https://www.kincony.com)
  Description:
    This program monitors the state of selected GPIO pins (47, 48, 38, 39, 40, 41, 0)
    and prints the state of each pin when there is a change (HIGH to LOW or LOW to HIGH).
  Date: 2024-12-24
*/

#include "Arduino.h"

// Define GPIO pins to be monitored as input
const int gpioPins[] = {47, 48, 38, 39, 40, 41, 0};
const int numPins = sizeof(gpioPins) / sizeof(gpioPins[0]);
int lastStates[numPins]; // To store the previous states of each pin

void setup() {
  Serial.begin(115200);  // Initialize serial communication at 115200 baud

  // Set all specified GPIO pins as input
  for (int i = 0; i < numPins; i++) {
    pinMode(gpioPins[i], INPUT);  // Set each GPIO pin to INPUT mode
    lastStates[i] = digitalRead(gpioPins[i]);  // Initialize last state to current state
  }

  Serial.println("GPIO Monitoring Started...");  // Print message to indicate the monitoring has started
}

void loop() {
  // Loop through each pin and check for state change
  for (int i = 0; i < numPins; i++) {
    int currentState = digitalRead(gpioPins[i]);  // Read the current state of the pin

    // If the state has changed (from LOW to HIGH or HIGH to LOW)
    if (currentState != lastStates[i]) {
      // Print the pin number and its new state
      Serial.print("GPIO ");
      Serial.print(gpioPins[i]);
      Serial.print(" changed to: ");
      Serial.println(currentState == HIGH ? "HIGH" : "LOW");

      // Update the last state to the current state
      lastStates[i] = currentState;
    }
  }

  // Add a small delay to reduce the load on the MCU and debounce the inputs
  delay(50);  // Delay for 50 milliseconds
}
arduino ino file download:
.zip   5-free-gpio-state.zip (Size: 956 bytes / Downloads: 521)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   5-free-gpio-state.ino.merged.zip (Size: 179.48 KB / Downloads: 482)

Print this item

  [arduino code examples for A16v3]-04 RS485 communication test
Posted by: admin - 01-15-2025, 05:50 AM - Forum: KC868-A16v3 - No Replies

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* RS485 Communication Test
*
* This program is a simple test for RS485 communication using ESP32-S3.
* It will send a message over RS485 and then read incoming messages.
* The TXD pin is defined as GPIO 18 and RXD pin is defined as GPIO 8.
*/

#include <HardwareSerial.h>

// Define RS485 pins
#define RS485_RXD 17
#define RS485_TXD 16

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

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

  // Initialize RS485 Serial communication
  rs485Serial.begin(9600, SERIAL_8N1, RS485_RXD, RS485_TXD);
 
  Serial.println("RS485 Test Start");
}

void loop() {
  // Send a test message
  rs485Serial.println("Hello from KinCony IoT");

  // Wait for a short period
  delay(1000);

  // Check if data is available to read
  if (rs485Serial.available()) {
    String receivedMessage = "";
    while (rs485Serial.available()) {
      char c = rs485Serial.read();
      receivedMessage += c;
    }
    // Print the received message
    Serial.print("Received: ");
    Serial.println(receivedMessage);
  }

  // Wait before sending the next message
  delay(2000);
}
arduino ino file download:
.zip   4-RS485-Test.zip (Size: 759 bytes / Downloads: 527)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   4-RS485-Test.ino.merged.zip (Size: 184.34 KB / Downloads: 526)

Print this item

  [arduino code examples for A16v3]-03 Read analog input ports value
Posted by: admin - 01-15-2025, 05:48 AM - Forum: KC868-A16v3 - No Replies

Code:
#include "Arduino.h"

#define ANALOG_A1   4
#define ANALOG_A2   6
#define ANALOG_A3   7
#define ANALOG_A4   5

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

  pinMode(ANALOG_A1,INPUT);
  pinMode(ANALOG_A2,INPUT);
  pinMode(ANALOG_A3,INPUT);
  pinMode(ANALOG_A4,INPUT);
}

void loop()
{
  delay(1000);
  Serial.printf("Current Reading A1 on Pin(%d)=%d\n",ANALOG_A1,analogRead(ANALOG_A1));
  Serial.printf("Current Reading A2 on Pin(%d)=%d\n",ANALOG_A2,analogRead(ANALOG_A2));
  Serial.printf("Current Reading A3 on Pin(%d)=%d\n",ANALOG_A3,analogRead(ANALOG_A3));
  Serial.printf("Current Reading A4 on Pin(%d)=%d\n",ANALOG_A4,analogRead(ANALOG_A4));
}
arduino ino file download:
.zip   3-analog-input.zip (Size: 415 bytes / Downloads: 564)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   3-analog-input.ino.merged.zip (Size: 184.51 KB / Downloads: 514)

Print this item

  [arduino code examples for A16v3]-02 Read digital input ports state
Posted by: admin - 01-15-2025, 05:46 AM - Forum: KC868-A16v3 - No Replies

Code:
/*
KeyPressed on PIN1
by Mischianti Renzo <http://www.mischianti.org>

https://www.mischianti.org/2019/01/02/pcf8574-i2c-digital-i-o-expander-fast-easy-usage/
*/

#include "Arduino.h"
#include "PCF8574.h"

// Set i2c address
PCF8574 pcf8574_1(0x21);
PCF8574 pcf8574_2(0x22);
unsigned long timeElapsed;
void setup()
{
    Wire.begin(9, 10); // SDA: GPIO9, SCL: GPIO10 (for I2C communication)
  Serial.begin(115200);
    delay(1000);

//    pcf8574.pinMode(P0, OUTPUT);
pcf8574_1.pinMode(P0, INPUT);
pcf8574_1.pinMode(P1, INPUT);
pcf8574_1.pinMode(P2, INPUT);
pcf8574_1.pinMode(P3, INPUT);
pcf8574_1.pinMode(P4, INPUT);
pcf8574_1.pinMode(P5, INPUT);
pcf8574_1.pinMode(P6, INPUT);
pcf8574_1.pinMode(P7, INPUT);

pcf8574_2.pinMode(P0, INPUT);
pcf8574_2.pinMode(P1, INPUT);
pcf8574_2.pinMode(P2, INPUT);
pcf8574_2.pinMode(P3, INPUT);
pcf8574_2.pinMode(P4, INPUT);
pcf8574_2.pinMode(P5, INPUT);
pcf8574_2.pinMode(P6, INPUT);
pcf8574_2.pinMode(P7, INPUT);

    Serial.print("Init pcf8574...");
    if (pcf8574_1.begin()){
        Serial.println("pcf8574_1_OK");
    }else{
        Serial.println("pcf8574_1_KO");
    }

  Serial.print("Init pcf8574...");
  if (pcf8574_2.begin()){
    Serial.println("pcf8574_2_OK");
  }else{
    Serial.println("pcf8574_2_KO");
  }


}

void loop()
{
uint8_t val1 = pcf8574_1.digitalRead(P0);
uint8_t val2 = pcf8574_1.digitalRead(P1);
uint8_t val3 = pcf8574_1.digitalRead(P2);
uint8_t val4 = pcf8574_1.digitalRead(P3);
uint8_t val5 = pcf8574_1.digitalRead(P4);
uint8_t val6 = pcf8574_1.digitalRead(P5);
uint8_t val7 = pcf8574_1.digitalRead(P6);
uint8_t val8 = pcf8574_1.digitalRead(P7);

uint8_t val9 = pcf8574_2.digitalRead(P0);
uint8_t val10 = pcf8574_2.digitalRead(P1);
uint8_t val11 = pcf8574_2.digitalRead(P2);
uint8_t val12 = pcf8574_2.digitalRead(P3);
uint8_t val13 = pcf8574_2.digitalRead(P4);
uint8_t val14 = pcf8574_2.digitalRead(P5);
uint8_t val15 = pcf8574_2.digitalRead(P6);
uint8_t val16 = pcf8574_2.digitalRead(P7);
 
if (val1==LOW) Serial.println("KEY1 PRESSED");
if (val2==LOW) Serial.println("KEY2 PRESSED");
if (val3==LOW) Serial.println("KEY3 PRESSED");
if (val4==LOW) Serial.println("KEY4 PRESSED");
if (val5==LOW) Serial.println("KEY5 PRESSED");
if (val6==LOW) Serial.println("KEY6 PRESSED");
if (val7==LOW) Serial.println("KEY7 PRESSED");
if (val8==LOW) Serial.println("KEY8 PRESSED");

if (val9==LOW) Serial.println("KEY9 PRESSED");
if (val10==LOW) Serial.println("KEY10 PRESSED");
if (val11==LOW) Serial.println("KEY11 PRESSED");
if (val12==LOW) Serial.println("KEY12 PRESSED");
if (val13==LOW) Serial.println("KEY13 PRESSED");
if (val14==LOW) Serial.println("KEY14 PRESSED");
if (val15==LOW) Serial.println("KEY15 PRESSED");
if (val16==LOW) Serial.println("KEY16 PRESSED");
    delay(300);
}
arduino ino file download:
.zip   2-digital-input.zip (Size: 870 bytes / Downloads: 527)
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: 191.48 KB / Downloads: 505)

Print this item

  [arduino code examples for A16v3]-01 Turn ON/OFF OUTPUT
Posted by: admin - 01-15-2025, 05:45 AM - Forum: KC868-A16v3 - No Replies

Code:
/*
  Version: 1.0.0
  Created by KinCony (https://www.kincony.com)
  Description:
    This program controls two PCF8574 I/O expanders connected via I2C to create a chase effect
    across 16 output pins (P0-P7 on PCF8574_1 and PCF8574_2).
    The effect consists of sequentially turning on and off LEDs to create a "running light" or "chase" effect.
  Date: 2024-12-24
*/

#include "Arduino.h"
#include "PCF8574.h"

// Set i2c addresses for the two PCF8574 devices
PCF8574 pcf8574_1(0x24);  // PCF8574 at address 0x24
PCF8574 pcf8574_2(0x25);  // PCF8574 at address 0x25

// Setup function, runs once when the program starts
void setup() {
  Wire.begin(9, 10); // SDA: GPIO9, SCL: GPIO10 (for I2C communication)
  Serial.begin(115200); // Start serial communication for debugging

  // Set pinMode to OUTPUT for all 16 pins on both PCF8574 chips
  for (int i = 0; i < 8; i++) {
    pcf8574_1.pinMode(i, OUTPUT);  // Set pins P0-P7 of pcf8574_1 to OUTPUT
    pcf8574_2.pinMode(i, OUTPUT);  // Set pins P0-P7 of pcf8574_2 to OUTPUT
  }

  // Initialize PCF8574_1 and check if it's successful
  Serial.print("Init pcf8574_1...");
  if (pcf8574_1.begin()) {
    Serial.println("PCF8574_1_OK");
  } else {
    Serial.println("PCF8574_1_KO");
  }

  // Initialize PCF8574_2 and check if it's successful
  Serial.print("Init pcf8574_2...");
  if (pcf8574_2.begin()) {
    Serial.println("PCF8574_2_OK");
  } else {
    Serial.println("PCF8574_2_KO");
  }
}

// Loop function, runs repeatedly
void loop() {
  // Create the "chase" effect by turning on one LED at a time

  // First pass: Turn on pins one by one from P0 to P7 on both PCF8574 chips
  for (int i = 0; i < 8; i++) {
    pcf8574_1.digitalWrite(i, HIGH);  // Turn on the LED on pcf8574_1 (pin P0 to P7)
    delay(100);                       // Delay for 100ms to create the "chase" effect
    pcf8574_1.digitalWrite(i, LOW);   // Turn off the LED on pcf8574_1

    // Similarly, turn on LEDs on pcf8574_2 from P0 to P7
    if (i < 8) {
      pcf8574_2.digitalWrite(i, HIGH);  // Turn on the LED on pcf8574_2
      delay(100);                       // Delay for 100ms
      pcf8574_2.digitalWrite(i, LOW);   // Turn off the LED on pcf8574_2
    }
  }

  // Optionally reverse the sequence for a full "chase" effect
  // Second pass: Turn on LEDs in reverse order from P7 to P0
  for (int i = 7; i >= 0; i--) {
    pcf8574_1.digitalWrite(i, HIGH);  // Turn on the LED on pcf8574_1 (pin P7 to P0)
    delay(100);                       // Delay for 100ms
    pcf8574_1.digitalWrite(i, LOW);   // Turn off the LED on pcf8574_1

    // Similarly, reverse the LEDs on pcf8574_2 from P7 to P0
    if (i < 8) {
      pcf8574_2.digitalWrite(i, HIGH);  // Turn on the LED on pcf8574_2
      delay(100);                       // Delay for 100ms
      pcf8574_2.digitalWrite(i, LOW);   // Turn off the LED on pcf8574_2
    }
  }
}
arduino ino file download:
.zip   1-output.zip (Size: 1.06 KB / Downloads: 547)
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: 191.2 KB / Downloads: 490)

Print this item

  [arduino code examples for A6v3]-11 SX1278 LoRA wireless receiver and transmitter
Posted by: admin - 01-15-2025, 03:21 AM - Forum: KC868-A6v3 - No Replies

SX1278  Transmitter:

Code:
#include <LoRa.h>
#include <SPI.h>

#define ss 38
#define rst 42
#define dio0 41

int counter = 0;

void setup()
{
  Serial.begin(115200);
  while (!Serial);
  Serial.println("LoRa Sender");

  LoRa.setPins(ss, rst, dio0);    //setup LoRa transceiver module
 
  while (!LoRa.begin(433E6))     //433E6 - Asia, 866E6 - Europe, 915E6 - North America
  {
    Serial.println(".");
    delay(500);
  }
  LoRa.setSyncWord(0xA5);
  Serial.println("LoRa Initializing OK!");
}

void loop()
{
  Serial.print("Sending packet: ");
  Serial.println(counter);

  LoRa.beginPacket();   //Send LoRa packet to receiver
  LoRa.print("hello ");
  LoRa.print(counter);
  LoRa.endPacket();

  counter++;

  delay(2000);
}

SX1278 Receiver:
Code:
#include <LoRa.h>
#include <SPI.h>

#define ss 38
#define rst 42
#define dio0 41

void setup()
{
  Serial.begin(115200);
  while (!Serial);
  Serial.println("LoRa Receiver");

  LoRa.setPins(ss, rst, dio0);    //setup LoRa transceiver module

  while (!LoRa.begin(433E6))     //433E6 - Asia, 866E6 - Europe, 915E6 - North America
  {
    Serial.println(".");
    delay(500);
  }
  LoRa.setSyncWord(0xA5);
  Serial.println("LoRa Initializing OK!");
}

void loop()
{
  int packetSize = LoRa.parsePacket();    // try to parse packet
  if (packetSize)
  {
   
    Serial.print("Received packet '");

    while (LoRa.available())              // read packet
    {
      String LoRaData = LoRa.readString();
      Serial.print(LoRaData);
    }
    Serial.print("' with RSSI ");         // print RSSI of packet
    Serial.println(LoRa.packetRssi());
  }
}
Print this item

  [arduino code examples for A6v3]-10 nRF24L01 wireless receiver and transmitter
Posted by: admin - 01-15-2025, 03:17 AM - Forum: KC868-A6v3 - No Replies

nRF24L01 Transmitter:

Code:
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define CE_PIN 40
#define CSN_PIN 38

const uint64_t abc = 0xE8E8F0F0E1LL;

RF24 radio(CE_PIN, CSN_PIN);
char data[] = "Hello World, KinCony";

void setup()
{
   Serial.begin(9600);
   radio.begin();
   radio.openWritingPipe(abc);
}

void loop()
{
   radio.write( data, sizeof(data) );
}

nRF24L01 Receiver:
Code:
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define CE_PIN 40
#define CSN_PIN 38

const uint64_t id = 0xE8E8F0F0E1LL;

RF24 radio(CE_PIN, CSN_PIN);

#define SIZE 32            // this is the maximum for this example. (minimum is 1)
char buffer[SIZE + 1];     // for the RX node
uint8_t counter = 0;       // for counting the number of received payloads

void setup()
{
   Serial.begin(9600);
   delay(1000);
   Serial.println("Nrf24L01 Receiver Starting");
   radio.begin();
   radio.openReadingPipe(1,id);
   radio.startListening();;
}

void loop()
{
    if (radio.available()) {         // is there a payload?
      radio.read(&buffer, SIZE);     // fetch payload from FIFO
      Serial.print("Received:");
      Serial.print(buffer);          // print the payload's value
      Serial.print(" - ");
      Serial.println(counter++);     // print the received counter
    }
}
Print this item

  [arduino code examples for A6v3]-09 Dimmer analog output by GP8403
Posted by: admin - 01-15-2025, 03:15 AM - Forum: KC868-A6v3 - Replies (1)

Code:
/*
* Made by KinCony IoT: https://www.kincony.com
*
* This Arduino program controls the GP8403 DAC I2C chip using an ESP32-S3 board.
* The program sets the DAC outputs for two channels:
* - Channel 0 (CH0) outputs 5V.
* - Channel 1 (CH1) outputs 10V.
*
* The I2C communication is handled using the Wire library, and the SDA and SCL pins
* are custom defined as GPIO12 (SDA) and GPIO11 (SCL).
*
* GP8403 I2C address: 0x58
*/

#include "DFRobot_GP8403.h"

// Initialize the GP8403 DAC object with the I2C address 0x58
DFRobot_GP8403 dac(&Wire, 0x58);

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

  // Initialize I2C communication with custom SDA and SCL pins
  Wire.begin(12, 11);  // SDA = GPIO12, SCL = GPIO11

  // Try to initialize the DAC, retry if initialization fails
  while(dac.begin() != 0) {
    Serial.println("Initialization failed, retrying...");
    delay(1000);  // Wait for 1 second before retrying
  }

  // If initialization succeeds
  Serial.println("Initialization successful!");

  // Set the DAC output range to 10V (this setting applies to both channels)
  dac.setDACOutRange(dac.eOutputRange10V);

  // Set the output for DAC channel 0 to 5V
  // Range for 10V mode is 0-10000, so 5000 represents 5V
  dac.setDACOutVoltage(5000, 0);  // Set CH0 to 5V
  Serial.println("Channel 0 set to 5V");

  // Set the output for DAC channel 1 to 10V
  dac.setDACOutVoltage(10000, 1);  // Set CH1 to 10V
  Serial.println("Channel 1 set to 10V");

  // Store the data in the chip's non-volatile memory so it persists after power-off
  dac.store();
  Serial.println("DAC values stored in memory");
}

void loop() {
  // No need to continuously write the values, the DAC holds the last set value
}
arduino ino file download:
.zip   dac-GP8403.zip (Size: 975 bytes / Downloads: 495)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   dac-GP8403.ino.merged.zip (Size: 189.99 KB / Downloads: 474)

Print this item

  [arduino code examples for A6v3]-08 Print TEXT on SSD1306 OLED displayer
Posted by: admin - 01-15-2025, 03:12 AM - Forum: KC868-A6v3 - No Replies

Code:
/*OLED SSD1306 Code for KC868-A6v3*/

#include <U8g2lib.h>
#include <Wire.h>

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,  11, 12, U8X8_PIN_NONE);//SCL IO11  SDA  IO12   

void page1() {
  u8g2.setFont(u8g2_font_timR18_tf);// Font 18
  u8g2.setFontPosTop();
  u8g2.setCursor(5,0);
  u8g2.print("KINCONY");
  u8g2.setFont(u8g2_font_timR12_tf);//Font 12
  u8g2.setCursor(0,40);
  u8g2.print("www.kincony.com");
}
void setup(){

  u8g2.setI2CAddress(0x3C*2);
  u8g2.begin();
  u8g2.enableUTF8Print();
}
void loop(){
  u8g2.firstPage();
  do
  {
    page1();
  }while(u8g2.nextPage());

}
arduino ino file download:
.zip   oled.zip (Size: 500 bytes / Downloads: 467)
BIN file (you can use esp32 download tool download to ESP32-S3 with address 0x0 then directly to use) download:
.zip   oled.ino.merged.zip (Size: 201.21 KB / Downloads: 457)

Print this item