#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);
        }
            

        #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);
        }
                    

            

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

            

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