ESP32 1.28-inch Round Display Tutorial¶

// Define the pin number for the button
const int buttonPin = 1;  // The pin number where the button is connected

// Variable to store the current state of the button
int buttonState = 0;  // Variable to hold the button's state, initially set to HIGH (0)

void setup() {
  Serial.begin(115200);  // Initialize serial communication at a baud rate of 115200
  pinMode(buttonPin, INPUT);  // Set the button pin as an input
}

void loop() {
  // Read the current state of the button (HIGH or LOW)
  buttonState = digitalRead(buttonPin);

  // If the button is pressed (connected to ground, state is LOW)
  if (buttonState == LOW) {
    Serial.println("Button Press");  // Print a message when the button is pressed
  } 
  // If the button is not pressed, it is in the release state (HIGH)
  else {
    Serial.println("Button release");  // Print a message when the button is released
  }

  // Note: This loop will continuously read the button state and print messages.
  // This may not be the desired behavior in all applications.
  // Consider adding a delay or using a debouncing method for the button.
}

// Encoder defines
#define ENCODER_A_PIN 19  // Pin definition for Encoder input A
#define ENCODER_B_PIN 18  // Pin definition for Encoder input B
#define SWITCH_PIN    8    // Pin definition for Switch

bool switchPressed = false;  // Variable to track switch state
long position_tmp = 0;       // Temporary variable to hold encoder position

// Encoder update function to track changes in encoder state
void updateEncoder() {
  static int previousState = 0;  // Hold the previous state of the encoder pins
  static int flag_A = 0;         // Counter for 'forward' direction
  static int flag_C = 0;         // Counter for 'reversal' direction

  int currentState = (digitalRead(ENCODER_A_PIN) << 1) | digitalRead(ENCODER_B_PIN);  // Read the current state of the encoder

  // Check for 'forward' direction logic
  if ((currentState == 0b00 && previousState == 0b01) || 
      (currentState == 0b01 && previousState == 0b11) || 
      (currentState == 0b11 && previousState == 0b10) || 
      (currentState == 0b10 && previousState == 0b00)) {
    flag_A++;
    if (flag_A == 50) {
      flag_A = 0;
      flag_C = 0;
      position_tmp = 1;
      Serial.println("forward");  // Print out the direction
    }
  } 
  // Check for 'reversal' direction logic
  else if ((currentState == 0b01 && previousState == 0b00) || 
           (currentState == 0b11 && previousState == 0b01) || 
           (currentState == 0b10 && previousState == 0b11) || 
           (currentState == 0b00 && previousState == 0b10)) {
    flag_C++;
    if (flag_C == 50) {
      flag_C = 0;
      flag_A = 0;
      position_tmp = 0;
      Serial.println("reversal");  // Print out the direction
    }
  }

  previousState = currentState;  // Update the previous state
}

// Interrupt function for switch press
void switchPressedInterrupt() {
  switchPressed = !switchPressed;  // Toggle the switchPressed state
  if (switchPressed) {
    Serial.println("press");  // Indicate switch press
  } else {
    Serial.println("release");  // Indicate switch release
  }
}

void setup() {
  Serial.begin(115200);  // Start serial communication
  pinMode(ENCODER_A_PIN, INPUT_PULLUP);  // Set encoder pins as input with pull-up
  pinMode(ENCODER_B_PIN, INPUT_PULLUP);
  pinMode(SWITCH_PIN, INPUT_PULLUP);

  // Attach interrupts for encoder and switch
  attachInterrupt(digitalPinToInterrupt(ENCODER_A_PIN), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENCODER_B_PIN), updateEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(SWITCH_PIN), switchPressedInterrupt, FALLING);
}

void loop() {
  // Main loop, currently does nothing but wait
  delay(10);
}

// Define the pin number for the buzzer
#define BUZZER 3  

void setup() {
  // This code runs once at the beginning of the program:
  pinMode(BUZZER, OUTPUT);  // Set the buzzer pin as an output
  digitalWrite(BUZZER, LOW);  // Initially set the buzzer to a low state (off)
}

void loop() {
  // This code runs repeatedly after the setup():
  tone(BUZZER, 100);  // Make the buzzer produce a tone at a frequency of 100 Hz
  delay(1000);  // Wait for one second
  tone(BUZZER, 0);  // Stop the buzzer from producing sound (frequency set to 0)
  delay(1000);  // Wait for another second
}

#include "I2C_BM8563.h"

#define I2C_SDA 4  // Define the SDA pin for I2C communication
#define I2C_SCL 5  // Define the SCL pin for I2C communication

I2C_BM8563 rtc(I2C_BM8563_DEFAULT_ADDRESS, Wire);  // Create an RTC object using the default I2C address and Wire library
I2C_BM8563_DateTypeDef dateStruct;  // Define a structure to hold the date information
I2C_BM8563_TimeTypeDef timeStruct;  // Define a structure to hold the time information

// Function to initialize the RTC
void RTC_init() {
  rtc.begin();  // Begin communication with the RTC
  // The following lines are commented out and provided as an example
  // of how to set a custom time and date if needed:
  /*
  I2C_BM8563_TimeTypeDef timeStruct;  // Define a time structure
  timeStruct.hours   = 11;    // Set the hour (0 - 23)
  timeStruct.minutes = 59;   // Set the minute (0 - 59)
  timeStruct.seconds = 0;    // Set the second (0 - 59)
  rtc.setTime(&timeStruct);  // Set the time in the RTC
  */
  /*
  I2C_BM8563_DateTypeDef dateStruct;  // Define a date structure
  dateStruct.weekDay = 3;    // Set the weekday (0 - 6, where 0 is Sunday)
  dateStruct.month   = 1;    // Set the month (1 - 12)
  dateStruct.date    = 24;   // Set the day of the month (1 - 31)
  dateStruct.year    = 2024; // Set the year
  rtc.setDate(&dateStruct);  // Set the date in the RTC
  */
}

void setup() {
  Serial.begin(115200);  // Start serial communication at 115200 baud rate
  Wire.begin(I2C_SDA, I2C_SCL);  // Initialize the I2C bus with defined SDA and SCL pins
  RTC_init();  // Call the RTC initialization function
}

void loop() {
  rtc.getDate(&dateStruct);  // Get the current date from the RTC
  rtc.getTime(&timeStruct);  // Get the current time from the RTC
  // Print the current time in a formatted manner
  Serial.printf("The update time is: %02d:%02d:%02d\n",
                timeStruct.hours,
                timeStruct.minutes,
                timeStruct.seconds
               );
  delay(1000);  // Wait for 1 second before updating the time again
}

#include <Wire.h>

#define PI4IO_I2C_ADDR 0x43  // I2C address for the I/O extender

// Function to initialize the I/O extender
void init_IO_extender() {
  Wire.beginTransmission(PI4IO_I2C_ADDR);  // Start I2C transmission to the extender
  Wire.write(0x01);  // Select the test register
  Wire.endTransmission();  // End the transmission
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);  // Request 1 byte from the extender
  uint8_t rxdata = Wire.read();  // Read the received data
  Serial.print("Device ID: ");
  Serial.println(rxdata, HEX);  // Print the device ID in hexadecimal

  Wire.beginTransmission(PI4IO_I2C_ADDR);  // Start I2C transmission again
  Wire.write(0x03);  // Select the I/O direction register
  Wire.write((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4));  // Set pins 0-4 as outputs
  Wire.endTransmission();  // End the transmission

  Wire.beginTransmission(PI4IO_I2C_ADDR);  // Start I2C transmission
  Wire.write(0x07);  // Select the Output Hi-Z register
  Wire.write(~((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4)));  // Set pins 0-4 low
  Wire.endTransmission();  // End the transmission
}

// Function to set the state of a specific pin on the I/O extender
void set_pin_io(uint8_t pin_number, bool value) {
  Wire.beginTransmission(PI4IO_I2C_ADDR);  // Start I2C transmission
  Wire.write(0x05);  // Select the test register
  Wire.endTransmission();  // End the transmission
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);  // Request 1 byte from the extender
  uint8_t rxdata = Wire.read();  // Read the received data
  Serial.print("Before the change: ");
  Serial.println(rxdata, HEX);  // Print the data before change

  Wire.beginTransmission(PI4IO_I2C_ADDR);  // Start I2C transmission
  Wire.write(0x05);  // Select the Output register

  if (!value) {
    Wire.write((~(1 << pin_number)) & rxdata);  // Set the pin low
  } else {
    Wire.write((1 << pin_number) | rxdata);  // Set the pin high
  }
  Wire.endTransmission();  // End the transmission

  // Read the output state to verify the change
  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x05);
  Wire.endTransmission();
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);
  rxdata = Wire.read();
  Serial.print("after the change: ");
  Serial.println(rxdata, HEX);  // Print the data after change
}

void setup() {
  Serial.begin(115200);  // Start serial communication at 115200 baud rate
  Wire.begin(4, 5);  // Initialize I2C bus with SDA and SCL pins
  init_IO_extender();  // Initialize the I/O extender
  delay(100);  // Short delay
}

void loop() {
  // Main code to run repeatedly
  set_pin_io(0, true);  // Set pin 0 to high
  delay(1000);  // Wait for 1000 milliseconds
  set_pin_io(0, false);  // Set pin 0 to low
  delay(1000);  // Wait for another 1000 milliseconds
}

char val;  // Variable to store the read value from the serial buffer

void setup() {
  Serial.begin(115200);  // Initialize the serial communication at a baud rate of 115200
}

void loop() {
  // Check if there is data available in the serial buffer
  if (Serial.available()) {
    val = Serial.read();  // Read the data from the buffer and store it in 'val'
    Serial.print(val);  // Print the read character back to the serial monitor
  }
}

#include "WiFi.h"  // Include the WiFi library for ESP32

void setup() {
  Serial.begin(115200);  // Start the serial communication at a baud rate of 115200
  WiFi.softAP("ESP32C3_AP", "12345678");  // Set up the ESP32 as an Access Point with the SSID "ESP32C3_AP" and password "12345678"
}

void loop() {
  Serial.print("Host Name:");  // Print the host name of the ESP32
  Serial.println(WiFi.softAPgetHostname());
  Serial.print("Host IP Address:");  // Print the IP address of the Access Point
  Serial.println(WiFi.softAPIP());
  Serial.print("Host IPV6:");  // Print the IPv6 address of the Access Point
  Serial.println(WiFi.softAPIPv6());
  Serial.print("Host SSID:");  // Print the SSID of the Access Point
  Serial.println(WiFi.SSID());
  Serial.print("Host Broadcast IP:");  // Print the broadcast IP address of the Access Point
  Serial.println(WiFi.softAPBroadcastIP());
  Serial.print("Host Mac Address:");  // Print the MAC address of the Access Point
  Serial.println(WiFi.softAPmacAddress());
  Serial.print("Number Of Host Connections:");  // Print the number of devices connected to the Access Point
  Serial.println(WiFi.softAPgetStationNum());
  Serial.print("Host Network ID:");  // Print the network ID
  Serial.println(WiFi.softAPNetworkID());
  Serial.print("Host State:");  // Print the current state of the WiFi host (Access Point)
  Serial.println(WiFi.status());
  delay(1000);  // Wait for 1 second before printing the information again
}

#include "WiFi.h"  // Include the WiFi library for ESP8266 or ESP32

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

  // Start WiFi connection with given SSID and password
  WiFi.begin("elecrow-test", "1223334444");
  // Enable auto-reconnect feature
  WiFi.setAutoReconnect(true);
}

void loop() {
  // Print the connection status: true if connected, false otherwise
  Serial.print("Connection Status:");
  Serial.println(WiFi.isConnected());
  // Print the local IP address of the device
  Serial.print("Local IP:");
  Serial.println(WiFi.localIP());
  // Print the local IPv6 address of the device
  Serial.print("Local IPv6:");
  Serial.println(WiFi.localIPv6());
  // Print the MAC address of the device
  Serial.print("Mac Address:");
  Serial.println(WiFi.macAddress());
  // Print the network ID
  Serial.print("Network ID:");
  Serial.println(WiFi.networkID());
  // Print the sleep mode setting
  Serial.print("Sleep:");
  Serial.println(WiFi.getSleep());
  // Print the WiFi status bits
  Serial.print("Get Status:");
  Serial.println(WiFi.getStatusBits());
  // Print the transmission power setting
  Serial.print("Get Tx Power:");
  Serial.println(WiFi.getTxPower());
  // Print the auto connect setting
  Serial.print("get Auto Connect:");
  Serial.println(WiFi.getAutoConnect());
  // Print the auto reconnect setting
  Serial.print("Get Auto Reconnect:");
  Serial.println(WiFi.getAutoReconnect());
  // Print the current WiFi mode (1 - WIFI_OFF, 2 - WIFI_STA, 3 - WIFI_AP, 4 - WIFI_AP_STA)
  Serial.print("Get Mode:");
  Serial.println(WiFi.getMode());
  // Print the device's hostname
  Serial.print("Get Hostname:");
  Serial.println(WiFi.getHostname());
  // Print the gateway IP address
  Serial.print("Gateway IP:");
  Serial.println(WiFi.gatewayIP());
  // Print the DNS server IP address
  Serial.print("dns IP:");
  Serial.println(WiFi.dnsIP());
  // Print the current WiFi status
  Serial.print("Status:");
  Serial.println(WiFi.status());
  delay(1000);  // Wait for 1 second before printing the information again
}

#include <WiFi.h>

const char *ssid = "elecrow-test";  // The SSID of the WiFi network to connect to
const char *password = "1223334444";  // The password of the WiFi network

const IPAddress serverIP(192, 168, 3, 105);  // The IP address of the server to connect to
uint16_t serverPort = 9527;  // The port number on the server to connect to

WiFiClient client;  // Create an instance of the WiFiClient class to create a TCP connection

void setup() {
  Serial.begin(115200);  // Start the serial communication at a baud rate of 115200
  delay(1000);  // Delay for 1000 milliseconds to give the serial console time to initialize
  WiFi.begin(ssid, password);  // Initiate a connection to the WiFi network
  // Wait for the WiFi connection to be established
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("Connected");  // Print a message to indicate the connection is established
  Serial.print("IP Address:");  // Print the IP address assigned to the device
  Serial.println(WiFi.localIP());
}

void loop() {
  // Attempt to establish a TCP connection with the server
  if (client.connect(serverIP, serverPort)) {
    client.print("Hello world!");  // Send a "Hello world!" message to the server
    // Keep the connection open and interact with the server
    while (client.connected() || client.available()) {
      if (client.available()) {  // Check if there is data available from the server
        String line = client.readStringUntil('\n');  // Read a line of data from the server
        Serial.print("Read data:");  // Print a message indicating data was read
        Serial.println(line);
        client.write(line.c_str());  // Echo the received data back to the server
      }
    }
    Serial.println("Close Current Connection");  // Print a message indicating the connection is closed
    client.stop();  // Close the TCP connection
  } else {
    Serial.println("Access Failure");  // Print a message indicating the connection failed
    client.stop();  // Ensure the client stops any attempt to connect
  }
  delay(5000);  // Wait for 5000 milliseconds before attempting to reconnect
}

#include <WiFi.h>         // Include the WiFi library for ESP8266 or ESP32
#include <WiFiClient.h>   // Include the WiFiClient library for client functionality

const char* ssid = "elecrow-test";  // The SSID of the WiFi network
const char* password = "1223334444";  // The password of the WiFi network

WiFiServer server(1234);  // Create a WiFiServer object to handle incoming TCP connections on port 1234

void setup() {
  Serial.begin(115200);  // Start the serial communication at a baud rate of 115200
  delay(1000);            // Delay for 1000 milliseconds to ensure the serial port is ready
  WiFi.begin(ssid, password);  // Initiate a connection to the WiFi network
  // Wait for the WiFi connection to be established
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  server.begin();  // Start the server to listen for incoming connections
  Serial.println("WiFi connected");
  Serial.println("IP address: " + WiFi.localIP().toString());  // Print the IP address of the device
}

void loop() {
  // Check if there is a new client that has connected
  WiFiClient client = server.available();
  if (client) {
    Serial.println("New client connected");
    // Keep the connection open while the client is connected
    while (client.connected()) {
      if (client.available()) {  // Check if there is data available from the client
        String data = client.readStringUntil('\n');  // Read a line of data sent by the client
        Serial.print("Received data: ");
        Serial.println(data);  // Print the received data
        String response = "Server received: " + data;  // Create a response string
        client.println(response);  // Send the response back to the client
      }
    }
    client.stop();  // Close the connection once the client disconnects
    Serial.println("Client disconnected");
  }
}

#include <WiFi.h>
#include <AsyncUDP.h> 

const char *ssid = "elecrow-test";  // SSID of the WiFi network
const char *password = "1223334444";  // Password of the WiFi network

AsyncUDP udp;  // Create an AsyncUDP object for handling UDP packets
unsigned int localUdpPort = 9527;  // Local UDP port number

unsigned int broadcastPort = localUdpPort;  // Port number for broadcasting
const char *broadcastData = "from esp32c3";  // Data to be sent as broadcast

// Callback function for handling incoming UDP packets
void onPacketCallBack(AsyncUDPPacket packet) {
  Serial.print("UDP packet source type: ");
  Serial.println(packet.isBroadcast() ? "broadcast data" : (packet.isMulticast() ? "Multicast" : "Unicast"));
  Serial.print("Remote address and port number: ");
  Serial.print(packet.remoteIP());
  Serial.print(":");
  Serial.println(packet.remotePort());
  Serial.print("Destination address and port number: ");
  Serial.print(packet.localIP());
  Serial.print(":");
  Serial.println(packet.localPort());
  Serial.print("data length: ");
  Serial.println(packet.length());
  Serial.print("data content: ");
  Serial.write(packet.data(), packet.length());
  Serial.println();
  // Send a reply back to the source of the packet
  packet.print("reply data");
  broadcastPort = packet.remotePort();  // Update the broadcast port to the remote port
}

void setup() {
  Serial.begin(115200);  // Start serial communication
  WiFi.begin(ssid, password);  // Initiate WiFi connection
  // Wait for WiFi to connect
  while (!WiFi.isConnected()) {
    delay(1000);
    Serial.print(".");
  }
  Serial.println("Connected");
  Serial.print("IP Address:");
  Serial.println(WiFi.localIP());  // Print the assigned IP address

  // Start listening for UDP packets on the local port
  while (!udp.listen(localUdpPort)) {
  }
  // Set the callback function to be called when a packet is received
  udp.onPacket(onPacketCallBack);
}

void loop() {
  delay(5000);  // Wait for 5 seconds

  // Send a broadcast message to the previously received remote port
  udp.broadcastTo(broadcastData, broadcastPort); 
  // The following lines are commented out as they are not used in this example
  /*
  IPAddress broadcastAddr((~(uint32_t)WiFi.subnetMask())|((uint32_t)WiFi.localIP())); 
  udp.writeTo(broadcastData, sizeof(broadcastData), broadcastAddr, localUdpPort);
  */
}

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"  // UUID for the service
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"  // UUID for the characteristic

BLECharacteristic *pCharacteristic;  // Pointer to the BLE characteristic

void setup() {
  Serial.begin(115200);  // Initialize serial communication at a baud rate of 115200
  BLEDevice::init("ESP32C3_BLE_Server");  // Initialize the BLE device with a name
  BLEServer *pServer = BLEDevice::createServer();  // Create a BLE server
  BLEService *pService = pServer->createService(SERVICE_UUID);  // Create a service with the specified UUID

  // Create a characteristic with read and notify properties
  pCharacteristic = pService->createCharacteristic(
                       CHARACTERISTIC_UUID,
                       BLECharacteristic::PROPERTY_READ |
                       BLECharacteristic::PROPERTY_NOTIFY
                     );

  pCharacteristic->setValue("Hello World");  // Set the initial value of the characteristic
  pService->start();  // Start the service
  pServer->getAdvertising()->start();  // Start advertising the BLE device
}

void loop() {
  // This loop function does nothing in this example as the BLE server does not require
  // continuous processing in the loop once it's set up and running.
}

#define LGFX_USE_V1
#include "Arduino.h"
#include <lvgl.h>
#include "demos/lv_demos.h"
#include <LovyanGFX.hpp>
#include "CST816D.h"

// I2C pins
#define I2C_SDA 4
#define I2C_SCL 5
// Touch panel interrupt and reset pins
#define TP_INT 0
#define TP_RST -1

// I2C address for the I/O extender
#define PI4IO_I2C_ADDR 0x43

// Buffer size definition
#define buf_size 120

// LGFX class definition for display device interface
class LGFX : public lgfx::LGFX_Device
{
  // Internal components of the LGFX class
    lgfx::Panel_GC9A01 _panel_instance;
    lgfx::Bus_SPI _bus_instance;
  public:
    LGFX(void)
    {
      {
        // Configuration for the SPI bus and panel
        auto cfg = _bus_instance.config();
        cfg.spi_host = SPI2_HOST;
        cfg.spi_mode = 0;
        cfg.freq_write = 80000000;
        cfg.freq_read = 20000000;
        cfg.spi_3wire = true;
        cfg.use_lock = true;
        cfg.dma_channel = SPI_DMA_CH_AUTO;
        cfg.pin_sclk = 6;
        cfg.pin_mosi = 7;
        cfg.pin_miso = -1;
        cfg.pin_dc = 2;
        _bus_instance.config(cfg);
        _panel_instance.setBus(&_bus_instance);
      }
      {
        auto cfg = _panel_instance.config();
        cfg.pin_cs = 10;
        cfg.pin_rst = -1;
        cfg.pin_busy = -1;
        cfg.memory_width = 240;
        cfg.memory_height = 240;
        cfg.panel_width = 240;
        cfg.panel_height = 240;
        cfg.offset_x = 0;
        cfg.offset_y = 0;
        cfg.offset_rotation = 0;
        cfg.dummy_read_pixel = 8;
        cfg.dummy_read_bits = 1;
        cfg.readable = false;
        cfg.invert = true;
        cfg.rgb_order = false;
        cfg.dlen_16bit = false;
        cfg.bus_shared = false;
        _panel_instance.config(cfg);
      }
      setPanel(&_panel_instance);
    }
};

// Global instances for the display and touch screen
LGFX tft;
CST816D touch(I2C_SDA, I2C_SCL, TP_RST, TP_INT);

/*Change to your screen resolution*/
static const uint32_t screenWidth = 240;
static const uint32_t screenHeight = 240;

static lv_disp_draw_buf_t draw_buf;
static lv_color_t buf[2][screenWidth * buf_size];

#if LV_USE_LOG != 0
// Custom print function for LVGL debugging
void my_print(lv_log_level_t level, const char *file, uint32_t line, const char *fn_name, const char *dsc)
{
  Serial.printf("%s(%s)@%d->%s\r\n", file, fn_name, line, dsc);
  Serial.flush();
}
#endif

// Function to handle flushing of display buffer to the screen
void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
{
  if (tft.getStartCount() == 0)
  {
    tft.endWrite();
  }

  tft.pushImageDMA(area->x1, area->y1, area->x2 - area->x1 + 1, area->y2 - area->y1 + 1, (lgfx::swap565_t *)&color_p->full);

  lv_disp_flush_ready(disp); /* tell lvgl that flushing is done */
}

// Function to read touchpad input
void my_touchpad_read(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
{
  bool touched;
  uint8_t gesture;
  uint16_t touchX, touchY;
  touched = touch.getTouch(&touchX, &touchY, &gesture);
  if (!touched)
  {
    data->state = LV_INDEV_STATE_REL;
  }
  else
  {
    data->state = LV_INDEV_STATE_PR;
    /*Set the coordinates*/
    data->point.x = touchX;
    data->point.y = touchY;
  }
}

// Function to initialize I/O extender
void init_IO_extender() {
  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x01); // test register
  Wire.endTransmission();
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);
  uint8_t rxdata = Wire.read();
  Serial.print("Device ID: ");
  Serial.println(rxdata, HEX);

  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x03); // IO direction register
  Wire.write((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4)); // set pins 0, 1, 2 as outputs
  Wire.endTransmission();

  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x07); // Output Hi-Z register
  Wire.write(~((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4))); // set pins 0, 1, 2 low
  Wire.endTransmission();
}

// Function to set I/O pin state on the extender
void set_pin_io(uint8_t pin_number, bool value) {

  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x05); // test register
  Wire.endTransmission();
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);
  uint8_t rxdata = Wire.read();
  Serial.print("Before the change: ");
  Serial.println(rxdata, HEX);

  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x05); // Output register

  if (!value)
    Wire.write((~(1 << pin_number)) & rxdata); // set pin low
  else
    Wire.write((1 << pin_number) | rxdata); // set pin high
  Wire.endTransmission();

  Wire.beginTransmission(PI4IO_I2C_ADDR);
  Wire.write(0x05); // test register
  Wire.endTransmission();
  Wire.requestFrom(PI4IO_I2C_ADDR, 1);
  rxdata = Wire.read();
  Serial.print("after the change: ");
  Serial.println(rxdata, HEX);
}

void setup()
{
  // Initialization of serial communication, I2C, display, touch screen, and LVGL
  Serial.begin(115200); /* prepare for possible serial debug */
  Serial.println("I am LVGL_Arduino");
  Wire.begin(4, 5);
  init_IO_extender();
  delay(100);
  set_pin_io(3, true);
  set_pin_io(4, true);
  set_pin_io(2, true);
  tft.init();
  tft.initDMA();
  tft.startWrite();
  tft.setColor(0, 0, 0);

  tft.fillScreen(TFT_BLACK);
  delay(200);
  touch.begin();
  lv_init();
#if LV_USE_LOG != 0
  //lv_log_register_print_cb(my_print); /* register print function for debugging */
#endif

  lv_disp_draw_buf_init(&draw_buf, buf[0], buf[1], screenWidth * buf_size);

  /*Initialize the display*/
  static lv_disp_drv_t disp_drv;
  lv_disp_drv_init(&disp_drv);
  /*Change the following line to your display resolution*/
  disp_drv.hor_res = screenWidth;
  disp_drv.ver_res = screenHeight;
  disp_drv.flush_cb = my_disp_flush;
  disp_drv.draw_buf = &draw_buf;
  lv_disp_drv_register(&disp_drv);

  /*Initialize the (dummy) input device driver*/
  static lv_indev_drv_t indev_drv;
  lv_indev_drv_init(&indev_drv);
  indev_drv.type = LV_INDEV_TYPE_POINTER;
  indev_drv.read_cb = my_touchpad_read;
  lv_indev_drv_register(&indev_drv);


#if 0
  /* Create simple label */
  lv_obj_t *label = lv_label_create( lv_scr_act() );
  lv_label_set_text( label, "Hello Arduino! (V8.0.X)" );
  lv_obj_align( label, LV_ALIGN_CENTER, 0, 0 );
#else
  // uncomment one of these demos
  lv_demo_widgets(); // OK
#endif
  Serial.println("Setup done");
}


void loop()
{
  lv_timer_handler(); /* let the GUI do its work */
  delay(5);
}