Demo Multi-Protocolo Pico: Serial, I2C, SPI y ADC en RP2040

Introducción

¡Bienvenido a la Demo Multi-Protocolo Pico! En este tutorial, exploraremos cómo usar la Raspberry Pi Pico (RP2040) para comunicarse a través de múltiples protocolos simultáneamente: Serial, I2C, SPI y ADC. Este es un ejemplo avanzado que reúne varias habilidades clave para el desarrollo embebido. Construiremos el circuito en el simulador Velxio, escribiremos el código y repasaremos cada parte paso a paso.

Diagrama del circuito pico-multi-protocolo en el lienzo del simulador Velxio

Recorrido del Circuito

Veamos los componentes y el cableado. El circuito utiliza una Raspberry Pi Pico (Nano RP2040 Connect) y varios periféricos:

LED azul (led-i2c): Conectado al pin D12 (GP12) a través de una resistencia limitadora de corriente. El ánodo (A) se conecta a D12, el cátodo (C) a GND.
LED amarillo (led-spi): Conectado al pin D7 (GP7) de manera similar.
Potenciómetro (pot-adc): El pin de señal (SIG) se conecta a A0 (GP26). VCC va a 3.3V, GND a GND.
LED verde (led-gpio): Conectado al pin D2 (GP2).

Todos los LEDs comparten una tierra común. El potenciómetro se alimenta desde el rail de 3.3V. El cableado es sencillo, pero ten en cuenta que estamos usando los periféricos I2C y SPI integrados de la Pico (aunque no se muestren explícitamente en el esquema, el código asume que están disponibles en los pines predeterminados).

Análisis del Código

El código está escrito en Arduino C++ y utiliza las librerías Wire y SPI. Vamos a desglosarlo sección por sección.

Configuración

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(115200);
  delay(500);

  Serial.println("==============================");
  Serial.println(" Pico Multi-Protocol Demo");
  Serial.println("==============================");
  Serial.println();

Comenzamos inicializando el LED integrado y el Serial a 115200 baudios. La pausa da tiempo para que el monitor serie se conecte.

1. Escáner I2C

  Wire.begin();
  Serial.println("[I2C] Escaneando bus...");
  int found = 0;
  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    if (Wire.endTransmission() == 0) {
      found++;
      Serial.print("  Dispositivo encontrado en 0x");
      if (addr < 16) Serial.print('0');
      Serial.println(addr, HEX);
    }
  }
  Serial.print("  Total de dispositivos: "); Serial.println(found);
  Serial.println();

Esto escanea todas las direcciones I2C posibles (1-126) e informa de aquellas que responden. En el simulador, es posible que veas dispositivos virtuales en direcciones como 0x50 (EEPROM) y 0x68 (RTC).

2. Lectura/Escritura EEPROM I2C

  Serial.println("[I2C] Prueba de EEPROM en 0x50...");
  Wire.beginTransmission(0x50);
  Wire.write(0x00); // registro 0
  Wire.write(0x42); // dato
  Wire.endTransmission();
  delay(5);

  Wire.beginTransmission(0x50);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(0x50, 1);
  if (Wire.available()) {
    byte val = Wire.read();
    Serial.print("  Escrito 0x42, Leído 0x");
    Serial.print(val, HEX);
    Serial.println(val == 0x42 ? " — OK" : " — FALLO");
  }
  Serial.println();

Escribimos el valor 0x42 en el registro 0 de la EEPROM en la dirección 0x50, luego lo leemos de vuelta para verificar. Esto prueba la lectura/escritura básica de I2C.

3. RTC I2C

  Serial.println("[I2C] Leyendo RTC DS1307 en 0x68...");
  Wire.beginTransmission(0x68);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(0x68, 3);
  if (Wire.available() >= 3) {
    byte sec = ((Wire.read() & 0x7F) >> 4) * 10 + (Wire.read() & 0x0F);
    byte min2 = Wire.read();
    (void)sec; (void)min2;
    Serial.println("  RTC respondió OK");
  }
  Serial.println();

Aquí intentamos leer los registros de hora de un RTC DS1307 en la dirección 0x68. El código lee tres bytes (segundos, minutos, horas) pero solo verifica si el dispositivo respondió.

4. Bucle de Retorno SPI

  Serial.println("[SPI] Prueba de bucle de retorno...");
  SPI.begin();
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));
  byte tx = 0xAB;
  byte rx = SPI.transfer(tx);
  Serial.print("  TX: 0x"); Serial.print(tx, HEX);
  Serial.print("  RX: 0x"); Serial.println(rx, HEX);
  SPI.endTransaction();
  Serial.println();

Esto realiza un simple bucle de retorno SPI: envía 0xAB y lee lo que se recibe. En el simulador, MISO y MOSI no están conectados externamente, por lo que el valor recibido podría ser 0xFF u otro. Esto prueba el hardware SPI.

5. ADC

  Serial.println("[ADC] Leyendo canales analógicos...");
  analogReadResolution(12);
  int a0 = analogRead(A0);
  Serial.print("  A0 (GP26): "); Serial.println(a0);
  Serial.println();

Configuramos la resolución del ADC a 12 bits y leemos el valor de A0 (GP26). Se lee el voltaje del cursor del potenciómetro, dando un valor entre 0 y 4095.

6. Parpadeo GPIO

  Serial.println("[GPIO] Parpadeando LED...");
  for (int i = 0; i < 3; i++) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
    delay(200);
  }
  Serial.println("  3 parpadeos completados");
  Serial.println();

  Serial.println("=== Todas las pruebas de protocolo completadas ===");
}

Finalmente, hacemos parpadear el LED integrado tres veces para indicar que la configuración está completa.

Bucle Principal

void loop() {
  // Heartbeat
  static unsigned long last = 0;
  if (millis() - last >= 3000) {
    last = millis();
    Serial.print("[Heartbeat] ");
    Serial.print(millis() / 1000);
    Serial.println("s");
  }
}

El bucle imprime un mensaje de latido cada 3 segundos para mostrar que el programa sigue ejecutándose.

Conceptos Clave

Integración multi-protocolo: Combinar Serial, I2C, SPI y ADC en un solo sketch te enseña a gestionar múltiples periféricos sin conflictos.
Direccionamiento I2C: Comprender cómo escanear y comunicarse con dispositivos en direcciones específicas.
Configuración SPI: Ajustar la velocidad del reloj, el orden de bits y el modo.
Resolución del ADC: Usar analogReadResolution() para obtener mayor precisión.
Depuración por Serial: Usar el Monitor Serie para mostrar datos en tiempo real.

Errores Comunes y Consejos de Depuración

Resistencias pull-up I2C: La Pico tiene pull-ups internos, pero pueden ser necesarios externos para cables más largos. En el simulador, esto se maneja automáticamente.
Bucle de retorno SPI: Sin un bucle de retorno físico, los datos recibidos pueden ser basura. Usa un cable puente entre MOSI y MISO para una prueba de bucle de retorno real.
Ruido del ADC: Los potenciómetros pueden ser ruidosos; añadir un condensador entre el cursor y tierra ayuda.
Desajuste de velocidad en baudios del Serial: Asegúrate de que tu Monitor Serie esté configurado a 115200 baudios.

Extensiones Sugeridas

Añade un sensor I2C externo (ej. temperatura/humedad) y muestra sus lecturas.
Usa SPI para controlar una pantalla OLED.
Implementa un registrador de datos simple que lea el ADC y almacene valores en la EEPROM.
Añade un botón para activar diferentes modos de prueba.

¡Pruébalo Tú Mismo!

¿Listo para experimentar? Abre el ejemplo en vivo en Velxio y ejecuta la simulación. Puedes modificar el código, añadir componentes y ver los resultados al instante.

Lanzar la Demo Multi-Protocolo Pico en Velxio

Barra de herramientas del editor de Velxio con controles de compilación y ejecución