// Generated with ChatGPT (OpenAI)
// Prompt:
// Arduino UNO SPI Slave code that receives commands from an SPI Master. Turn an LED on pin 8 ON when receiving 0x01 and OFF when receiving 0x00, print the status to the Serial Monitor, and echo the received byte back to the master.

        #include <SPI.h>

        // LED pin definition
        const int ledPin = 8;
        volatile byte receivedCommand = 0;
        volatile bool newCommand = false;

        void setup() {

        Serial.begin(9600);
        pinMode(ledPin, OUTPUT);
        digitalWrite(ledPin, LOW);

        // Configure SPI pins
        pinMode(MISO, OUTPUT);
        pinMode(MOSI, INPUT);
        pinMode(SCK, INPUT);
        pinMode(SS, INPUT);

        // SPI configuration: Enable SPI, Slave Mode, MSB First, Mode 0
        SPCR = (1 << SPE);  // SPE = 1 (enable SPI), MSTR = 0 (slave mode)

        Serial.println("Arduino UNO SPI Slave Ready");
        }

        void loop() {

        // Check if data is available in the SPI buffer
        if (SPSR & (1 << SPIF)) {

            // Read the received byte
            receivedCommand = SPDR;

            // Process the command
            if (receivedCommand == 0x01) {
            digitalWrite(ledPin, HIGH);
            Serial.println("LED TURNED ON");
            } 
            else if (receivedCommand == 0x00) {
            digitalWrite(ledPin, LOW);
            Serial.println("LED TURNED OFF");
            }

            // Send the same byte back as response (echo)
            SPDR = receivedCommand;
        }

        delay(10);
        }
            

// Generated with ChatGPT (OpenAI)
// Prompt:
// ESP32 SPI Master code that uses a push button on pin 13 to control an Arduino UNO SPI Slave. When the button is pressed, toggle the LED state by sending command 0x01 (ON) or 0x00 (OFF) via SPI, using VSPI pins and displaying status messages in the Serial Monitor.

        #include <SPI.h>

        // SPI pins for ESP32
        #define VSPI_MISO 19
        #define VSPI_MOSI 23
        #define VSPI_SCLK 18
        #define VSPI_SS   5

        // Button pin
        const int buttonPin = 13;
        bool lastButtonState = LOW;
        bool ledState = false;

        void setup() {

        Serial.begin(115200);
        delay(1000);

        // Configure button pin
        pinMode(buttonPin, INPUT_PULLDOWN);

        // Configure CS pin
        pinMode(VSPI_SS, OUTPUT);
        digitalWrite(VSPI_SS, HIGH);

        // Initialize SPI
        SPI.begin(VSPI_SCLK, VSPI_MISO, VSPI_MOSI, VSPI_SS);
        SPI.setFrequency(500000);      
        SPI.setDataMode(SPI_MODE0);    
        SPI.setBitOrder(MSBFIRST);     

        Serial.println("ESP32 SPI Master Ready");
        Serial.println("Press the button to control the LED");
        }

        void loop() {

        // Read button state
        bool currentButtonState = digitalRead(buttonPin);

        // Check for button press (transition from LOW to HIGH)
        if (currentButtonState == HIGH && lastButtonState == LOW) {

            delay(50); // Debounce delay

            // Confirm button press after debounce
            if (digitalRead(buttonPin) == HIGH) {

            ledState = !ledState; // Toggle LED state

            if (ledState) {
                Serial.println("Button pressed - TURNING LED ON");
                sendSPICommand(0x01);
            } 
            else {
                Serial.println("Button pressed - TURNING LED OFF");
                sendSPICommand(0x00);
            }
            }
        }

        lastButtonState = currentButtonState;
        delay(10);
        }

        void sendSPICommand(byte command) {

        // Select the slave (Arduino UNO)
        digitalWrite(VSPI_SS, LOW);
        delayMicroseconds(5);

        // Send command via SPI
        SPI.transfer(command);

        delayMicroseconds(5);

        // Deselect the slave
        digitalWrite(VSPI_SS, HIGH);
        }
                    

            

// Generated with ChatGPT (OpenAI)
// Prompt:
// Arduino code for a XIAO ESP32-S3 with an NRF24L01 module and a joystick. Read the X and Y analog values from the joystick, store them in a structure, and transmit the data wirelessly every 50 ms using the RF24 library. Print the transmitted values to the Serial Monitor for debugging.

        // NRF24L01 Transmisor con Joystick y XIAO ESP32-S3
        // Envía valores X e Y del joystick de forma inalámbrica

        #include <SPI.h>
        #include <RF24.h>
        #include <Wire.h>

        // Definir pines del NRF24L01
        #define CE_PIN D2
        #define CSN_PIN D3

        // Pines del joystick
        #define JOYSTICK_X D4
        #define JOYSTICK_Y D5

        // Crear objeto radio
        RF24 radio(CE_PIN, CSN_PIN);
        const byte address[6] = "00001";

        // Estructura para enviar datos del joystick
        struct JoystickData {
        int xValue;
        int yValue;
        bool buttonPressed;
        };

        JoystickData joystickData;

        unsigned long lastSendTime = 0;
        const unsigned long sendInterval = 50;

        void setup() {

        Serial.begin(115200);

        // Configurar pines del joystick
        pinMode(JOYSTICK_X, INPUT);
        pinMode(JOYSTICK_Y, INPUT);

        // Inicializar módulo NRF24L01
        if(!radio.begin()) {
            Serial.println("Error: Radio no responde!");
            while(1);
        }

        radio.openWritingPipe(address);
        radio.setPALevel(RF24_PA_MIN);
        radio.setDataRate(RF24_250KBPS);
        radio.stopListening();

        Serial.println("Transmisor Joystick iniciado");
        }

        void loop() {

        // Leer valores del joystick
        joystickData.xValue = analogRead(JOYSTICK_X);
        joystickData.yValue = analogRead(JOYSTICK_Y);

        // Enviar datos cada cierto intervalo
        if((millis() - lastSendTime) >= sendInterval) {

            lastSendTime = millis();

            // Enviar estructura completa
            bool result = radio.write(&joystickData, sizeof(JoystickData));

            // Debug por Serial
            Serial.print("X: ");
            Serial.print(joystickData.xValue);
            Serial.print(" | Y: ");
            Serial.println(joystickData.yValue);

            if(!result) {
                Serial.println("Fallo al enviar");
            }
        }

        delay(10);
        }

            

// Generated with ChatGPT (OpenAI)
// Prompt:
// Arduino code for a XIAO ESP32-S3 with an NRF24L01 receiver and a 128x64 SSD1306 OLED display. Receive joystick X and Y values sent wirelessly from another NRF24L01 module, display the values and percentages on the OLED, show the joystick position graphically, print the received data to the Serial Monitor, and display a timeout message if no data is received for 500 ms.
 
        // NRF24L01 Receptor con OLED y XIAO ESP32-S3
        // Recibe datos del joystick y los muestra en pantalla SSD1306

        #include <SPI.h>
        #include <RF24.h>
        #include <Wire.h>
        #include <Adafruit_SSD1306.h>
        #include <Adafruit_GFX.h>

        // Definir pines del NRF24L01
        #define CE_PIN D2
        #define CSN_PIN D3

        // Configuración del OLED
        #define SCREEN_WIDTH 128
        #define SCREEN_HEIGHT 64
        #define OLED_RESET -1
        #define OLED_ADDRESS 0x3C

        // Crear objeto radio
        RF24 radio(CE_PIN, CSN_PIN);
        const byte address[6] = "00001";

        // Crear objeto display
        Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

        // Estructura de datos del joystick
        struct JoystickData {
        int xValue;
        int yValue;
        bool buttonPressed;
        };

        JoystickData joystickData;

        unsigned long lastReceiveTime = 0;
        const unsigned long timeout = 500;

        int lastX = 0;
        int lastY = 0;

        void setup() {

        Serial.begin(115200);

        // Inicializar I2C
        Wire.begin(D4, D5);

        // Inicializar OLED
        if(!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
            Serial.println("Error: OLED no encontrado!");
            while(1);
        }

        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(0, 0);
        display.println("Esperando datos...");
        display.display();

        // Inicializar radio
        if(!radio.begin()) {
            Serial.println("Error: Radio no responde!");
            while(1);
        }

        radio.openReadingPipe(0, address);
        radio.setPALevel(RF24_PA_MIN);
        radio.setDataRate(RF24_250KBPS);
        radio.startListening();

        Serial.println("Receptor OLED iniciado");
        }

        void loop() {

        // Verificar datos disponibles
        if(radio.available()) {

            radio.read(&joystickData, sizeof(JoystickData));
            lastReceiveTime = millis();

            displayJoystickValues(joystickData.xValue, joystickData.yValue);

            Serial.print("Recibido - X: ");
            Serial.print(joystickData.xValue);
            Serial.print(" | Y: ");
            Serial.println(joystickData.yValue);
        }

        // Verificar timeout
        if((millis() - lastReceiveTime) > timeout) {

            display.clearDisplay();
            display.setCursor(0, 0);
            display.println("Sin conexion!");
            display.println("Esperando...");
            display.display();
        }

        delay(10);
        }

        // Mostrar valores del joystick en OLED
        void displayJoystickValues(int x, int y) {

        display.clearDisplay();

        display.setTextSize(1);
        display.setCursor(0, 0);
        display.println("Joystick Values");
        display.drawLine(0, 10, 128, 10, SSD1306_WHITE);

        display.setCursor(0, 15);
        display.print("X: ");
        display.println(x);

        display.setCursor(0, 25);
        display.print("Y: ");
        display.println(y);

        int xPercent = map(x, 0, 4095, 0, 100);
        int yPercent = map(y, 0, 4095, 0, 100);

        display.setCursor(0, 35);
        display.print("X%: ");
        display.print(xPercent);
        display.println("%");

        display.setCursor(0, 45);
        display.print("Y%: ");
        display.print(yPercent);
        display.println("%");

        int displayX = map(x, 0, 4095, 10, 118);
        int displayY = map(y, 0, 4095, 54, 10);

        display.fillCircle(displayX, displayY, 3, SSD1306_WHITE);
        display.drawCircle(displayX, displayY, 4, SSD1306_WHITE);

        display.drawLine(64, 54, 64, 10, SSD1306_WHITE);
        display.drawLine(10, 32, 118, 32, SSD1306_WHITE);

        display.display();
        }