RGB Matrix using ESP32s3 module

#include <Wire.h>
#include "Seeed_Arduino_GroveAI.h"
#include "WiFi.h"
#include <esp_now.h>

GroveAI ai(Wire);
uint8_t state = 0;

uint8_t receiver_addr[] = {0x10, 0x20, 0xBA, 0x59, 0x7A, 0xC8};

typedef struct predictions  {
  uint8_t id;
  uint8_t confidence;
} predictions;

predictions myresults;

uint8_t ie_results = 0x00; 

esp_now_peer_info_t peerInfo;

//send callback
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void setup() {
  // put your setup code here, to run once:
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  //send callback
  esp_now_register_send_cb(esp_now_send_cb_t(OnDataSent));
  
  memcpy(peerInfo.peer_addr, receiver_addr, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if(esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
  }

  Wire.begin(8, 7);    //sda,scl
  Serial.begin(115200);
  WiFi.mode(WIFI_MODE_STA);
  Serial.println(WiFi.macAddress());
  

  Serial.println("Initializing....");
  if(ai.begin(ALGO_OBJECT_DETECTION, MODEL_EXT_INDEX_1)) {
    Serial.println("Version: 0x");
    Serial.println(ai.version(), HEX);
    Serial.println("ID: 0x");
    Serial.println(ai.id(), HEX);
    Serial.println("Algorithm: ");
    Serial.println(ai.algo());
    Serial.println("Model: ");
    Serial.println(ai.model());
    Serial.println("Confidence:");
    Serial.println(ai.confidence());
    state=1;
    
    } else {
      Serial.println("Algorithm initialization failed.");
      }
}

void loop() {
  // put your main code here, to run repeatedly:
  if (state == 1) {
        uint32_t tick = millis();
        if (ai.invoke()) { // Start invocation
            while (ai.state() != CMD_STATE_IDLE) { // Wait for invocation to finish
                delay(20);
            }

            uint8_t len = ai.get_result_len(); // Get the number of detected objects
            if (len > 0) {
                Serial.print("Time consumed: ");
                Serial.println(millis() - tick);
                Serial.print("Number of detected objects: ");
                Serial.println(len);

                for (int i = 0; i < len; i++) {
                    object_detection_t data; // Prepare to receive data
                    ai.get_result(i, (uint8_t *)&data, sizeof(object_detection_t)); // Get result
                    printDetectionResult(data);
                    if (data.target == 0) {
                      ie_results = 0xF0;
                      Serial.println("Five Detected");
                    }
                    else {
                      ie_results = 0xFE;
                      Serial.println("Punch Detected");
                    }
                    myresults.confidence = data.confidence;
                }                
                Serial.println("Sending espnow data");    

                esp_err_t result = esp_now_send(receiver_addr, (uint8_t *) &ie_results, sizeof(ie_results));
                
                if (result == ESP_OK) {
                  Serial.println("Sent with success");
                }
                else {
                  Serial.println("Error sending the data");
                }
              }
                
            else {
                Serial.println("No objects detected.");
            }
        } 
        else {
            delay(1000);
            Serial.println("Invocation failed.");
        }
    } 
  else {
        state = 0; // Reset state
    }
}

void printDetectionResult(const object_detection_t &data) {
    Serial.println("Result: Detected");
    Serial.print("Object: ");
    Serial.print(data.target);
    Serial.print("\tX: ");
    Serial.print(data.x);
    Serial.print("\tY: ");
    Serial.print(data.y);
    Serial.print("\tWidth: ");
    Serial.print(data.w);
    Serial.print("\tHeight: ");
    Serial.print(data.h);
    Serial.print("\tConfidence: ");
    Serial.println(data.confidence);
}

#include <Keypad.h>
#include "WiFi.h"
#include <esp_now.h>
#include <esp_wifi.h>

uint8_t val;
esp_err_t result;

const byte ROWS = 4;
const byte COLS = 4;

char keys[ROWS][COLS]  {
  { '1', '2', '3', 'A' },
  { '4', '5', '6', 'B' },
  { '7', '8', '9', 'C' },
  { '*', '0', '#', 'D' }
};

byte rawPins[ROWS] = {8, 7, 6, 5};
byte colPins[COLS] = {4, 3, 2, 1};

Keypad keypad = Keypad(makeKeymap(keys), rawPins, colPins, ROWS, COLS);

//espnow related defines
uint8_t receiver_addr[] = {0x10, 0x20, 0xBA, 0x59, 0x7A, 0xC8};
esp_now_peer_info_t peerInfo;

//send callback
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);

  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_MODE_STA);
  esp_wifi_set_protocol( WIFI_IF_STA , WIFI_PROTOCOL_LR);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  //send callback
  esp_now_register_send_cb(esp_now_send_cb_t(OnDataSent));
  
  memcpy(peerInfo.peer_addr, receiver_addr, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if(esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  char key = keypad.getKey();
  if(key) {
    Serial.println("Key Pressed : ");
    Serial.println(key);
    val = (int)key;

    switch (val) {
    //2 pressed
      case 50:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
      
      case 51:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
      case 53:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 54:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 56:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 57:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 48:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 65:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 66:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 67:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
        case 68:
        result = esp_now_send(receiver_addr, (uint8_t *) &val, sizeof(val));
                
        if (result == ESP_OK) {
          Serial.println("Sent with success");
        }
        else {
          Serial.println("Error sending the data");
        }
        break;
    }
    Serial.println(val);
  }
}