Comunicate con LoRa y ubícate con GNSS
E80-900M2213S | ESP32-S3 |
---|---|
MISO | GPIO41 |
MOSI | GPIO40 |
SCK | GPIO39 |
NSS (CS) | GPIO3 |
BUSY | GPIO13 |
LR_NRESET | GPIO2 |
DIO9 | GPIO12 |
DIO8 | GPIO1 |
DIO7 | GPIO11 |
MAX-M10S | ESP32-S3 |
---|---|
TXD | GPIO44 |
RXD | GPIO43 |
SCL | GPIO47 |
SDA | GPIO48 |
/**
* Escáner de canales LR1121 (solo RX, sin TX).
* Barre las bandas de 868 MHz y 2.4 GHz cambiando BW y SF dinámicamente.
* Mide el RSSI (ruido de canal) y muestra los resultados en formato CSV.
*/
/* ───────── KODE | docs.kode.diy ───────── */
#include <Arduino.h>
#include <RadioLib.h>
/* Configuración de pines (según tu diseño) */
#define NSS_PIN 3 /* Chip Select */
#define DIO1_PIN 12 /* IRQ */
#define NRST_PIN 2 /* Reset */
#define BUSY_PIN 13 /* Busy */
#define MISO_PIN 41
#define MOSI_PIN 40
#define SCK_PIN 39
/* Mapeo del RF Switch para E80-900M2213S */
static const uint32_t rfswitch_dio_pins[] = {
RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6,
RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC
};
static const Module::RfSwitchMode_t rfswitch_table[] = {
{ LR11x0::MODE_STBY, { LOW, LOW } },
{ LR11x0::MODE_RX, { LOW, LOW } }, /* RX */
{ LR11x0::MODE_TX, { LOW, HIGH } }, /* TX Sub-1GHz LP */
{ LR11x0::MODE_TX_HP, { HIGH, LOW } }, /* TX Sub-1GHz HP */
{ LR11x0::MODE_TX_HF, { HIGH, HIGH } }, /* TX 2.4GHz */
{ LR11x0::MODE_GNSS, { LOW, LOW } },
{ LR11x0::MODE_WIFI, { LOW, LOW } },
END_OF_MODE_TABLE,
};
/* Instancias */
SPIClass spi(HSPI);
LR1121 radio = new Module(NSS_PIN, DIO1_PIN, NRST_PIN, BUSY_PIN, spi);
/* Configuración de barrido de frecuencias */
const float FREQS_868[] = { 863.0, 866.0, 868.0, 869.5 };
const float FREQS_24[] = { 2403.5, 2425.0, 2450.0, 2479.5 };
const size_t N_868 = sizeof(FREQS_868) / sizeof(FREQS_868[0]);
const size_t N_24 = sizeof(FREQS_24) / sizeof(FREQS_24[0]);
/* Parámetros dinámicos */
const float BWS_KHZ[] = { 125.0, 203.125 };
const int SFS[] = { 7, 9, 12 };
const int CR = 5;
const int PWR_DBM = 10;
const uint8_t PREAMBLE = 8;
const float TCXO_V = 1.8;
/* Tiempo de escucha por punto de medida */
const uint16_t DWELL_MS = 200;
/* Funciones auxiliares */
/* Reset físico del LR1121 */
static void hardResetModule() {
pinMode(NRST_PIN, OUTPUT);
digitalWrite(NRST_PIN, LOW);
delay(50);
digitalWrite(NRST_PIN, HIGH);
delay(50);
}
/* Configura el LR1121 con los parámetros indicados */
static bool configRadio(float freqMHz, float bwkHz, int sf) {
int st = radio.begin(freqMHz, bwkHz, sf, CR, 0x12 /*sync*/, PWR_DBM, PREAMBLE, TCXO_V);
if (st != RADIOLIB_ERR_NONE) {
Serial.print("Fallo de configuración f="); Serial.print(freqMHz, 3);
Serial.print(" MHz BW="); Serial.print(bwkHz, 3);
Serial.print(" kHz SF="); Serial.print(sf);
Serial.print(" código="); Serial.println(st);
return false;
}
return true;
}
/* Mide una vez el RSSI con los parámetros indicados y muestra línea CSV */
static void measureOnce(float freqMHz, float bwkHz, int sf, const char* bandTag) {
if (!configRadio(freqMHz, bwkHz, sf)) return;
/* Iniciar recepción */
int st = radio.startReceive();
if (st != RADIOLIB_ERR_NONE) {
Serial.print("Fallo al iniciar RX, código="); Serial.println(st);
return;
}
delay(DWELL_MS);
float rssi = radio.getRSSI();
/* Salida en formato CSV: BANDA,FREQ_MHz,BW_kHz,SF,RSSI_dBm */
Serial.print(bandTag); Serial.print(",");
Serial.print(freqMHz, 3); Serial.print(",");
Serial.print(bwkHz, 3); Serial.print(",");
Serial.print(sf); Serial.print(",");
Serial.println(rssi, 1);
radio.standby();
}
/* Escanea toda una banda de frecuencias variando BW y SF */
static void scanBand(const float* freqs, size_t nFreq, const char* bandTag) {
Serial.println();
Serial.println("BANDA,FREQ_MHz,BW_kHz,SF,RSSI_dBm");
for (size_t i = 0; i < nFreq; i++) {
for (size_t b = 0; b < sizeof(BWS_KHZ)/sizeof(BWS_KHZ[0]); b++) {
for (size_t s = 0; s < sizeof(SFS)/sizeof(SFS[0]); s++) {
measureOnce(freqs[i], BWS_KHZ[b], SFS[s], bandTag);
}
}
}
}
/* Setup */
void setup() {
Serial.begin(115200);
while (!Serial) { delay(10); }
Serial.println("\n=== Escáner de canales LR1121 (solo RSSI) ===");
Serial.println("RSSI = ruido de canal (más cerca de 0 => más ruido)");
pinMode(BUSY_PIN, INPUT);
Serial.println("Reseteando módulo...");
hardResetModule();
Serial.println("Inicializando SPI...");
spi.begin(SCK_PIN, MISO_PIN, MOSI_PIN, NSS_PIN);
radio.setRfSwitchTable(rfswitch_dio_pins, rfswitch_table);
Serial.println("\n--- Escaneo: 868 MHz ---");
scanBand(FREQS_868, N_868, "868MHz");
Serial.println("\n--- Escaneo: 2.4 GHz ---");
scanBand(FREQS_24, N_24, "2400MHz");
Serial.println("\nFin del escaneo. Reinicia para repetir.");
}
/* Loop */
void loop() {
delay(1000);
}
/**
* Ejemplo: Lectura de datos GNSS (GPS) desde un Módulo de Radio Kode vía I2C.
* Obtiene latitud, longitud y altitud del módulo u-blox.
* Utiliza el mensaje PVT (Posición, Velocidad, Tiempo) para la lectura de datos.
*/
/* ───────── KODE | docs.kode.diy ───────── */
#include <SparkFun_u-blox_GNSS_v3.h>
#include <Wire.h>
/* Objeto del módulo GNSS */
SFE_UBLOX_GNSS myGNSS;
void setup()
{
Serial.begin(115200);
delay(1000);
Serial.println("Ejemplo de Módulo de Radio Kode");
/* ─── Inicializar I2C con SDA = GPIO48, SCL = GPIO47 ─── */
Wire.begin(48, 47);
/* Habilitar mensajes de depuración GNSS por Serial (opcional) */
myGNSS.enableDebugging(); // Comenta esta línea para desactivar mensajes de depuración
/* Intentar conectar con el módulo GNSS u-blox hasta que tenga éxito */
while (myGNSS.begin() == false)
{
Serial.println(F("u-blox GNSS no detectado. Reintentando..."));
delay(1000);
}
/* Configurar salida I2C en protocolo UBX únicamente (desactiva mensajes NMEA) */
myGNSS.setI2COutput(COM_TYPE_UBX);
}
void loop()
{
/* Si hay datos PVT disponibles, leerlos y mostrarlos */
if (myGNSS.getPVT() == true)
{
/* Obtener e imprimir latitud */
int32_t latitude = myGNSS.getLatitude();
Serial.print(F("Lat: "));
Serial.print(latitude);
/* Obtener e imprimir longitud */
int32_t longitude = myGNSS.getLongitude();
Serial.print(F(" Long: "));
Serial.print(longitude);
Serial.print(F(" (grados * 10^-7)"));
/* Obtener e imprimir altitud (MSL) */
int32_t altitude = myGNSS.getAltitudeMSL();
Serial.print(F(" Alt: "));
Serial.print(altitude);
Serial.print(F(" (mm)"));
Serial.println();
}
}
#include <SparkFun_u-blox_GNSS_v3.h>
/* Objeto GNSS para comunicación vía puerto serie */
SFE_UBLOX_GNSS_SERIAL myGNSS;
/* ─── Mapeo de pines para UART GNSS ───
* GNSS_RX_PIN → pin del MCU que recibe datos desde TX del GNSS
* GNSS_TX_PIN → pin del MCU que envía datos hacia RX del GNSS
*/
static const int GNSS_RX_PIN = 44; // MCU recibe por GPIO44
static const int GNSS_TX_PIN = 43; // MCU transmite por GPIO43
/* Instancia de puerto serie hardware (UART1) */
HardwareSerial GNSSSerial(1);
void setup()
{
Serial.begin(115200);
delay(1000);
Serial.println("u-blox GNSS vía UART1 (GPIO44/43)");
/* ─── Inicializar UART1 en los pines indicados ───
* Velocidad: 38400 baudios
* Formato: 8 bits, sin paridad, 1 bit de stop (SERIAL_8N1)
*/
GNSSSerial.begin(38400, SERIAL_8N1, GNSS_RX_PIN, GNSS_TX_PIN);
/* Activar mensajes de depuración en el puerto serie principal (opcional) */
myGNSS.enableDebugging(Serial);
/* Configurar salida de datos por UART1 → Solo protocolo UBX, sin NMEA */
myGNSS.setUART1Output(COM_TYPE_UBX);
/* Intentar conectar con el módulo GNSS hasta que responda */
while (!myGNSS.begin(GNSSSerial)) {
Serial.println(F("u-blox GNSS no detectado. Reintentando..."));
delay(1000);
}
}
void loop()
{
/* Si hay datos PVT (Posición, Velocidad, Tiempo) disponibles, mostrarlos */
if (myGNSS.getPVT()) {
int32_t lat = myGNSS.getLatitude(); // Latitud en grados * 10^-7
int32_t lon = myGNSS.getLongitude(); // Longitud en grados * 10^-7
int32_t alt = myGNSS.getAltitudeMSL(); // Altitud MSL en milímetros
Serial.print(F("Lat: ")); Serial.print(lat);
Serial.print(F(" Long: ")); Serial.print(lon);
Serial.print(F(" (deg*1e-7) Alt: ")); Serial.print(alt);
Serial.println(F(" (mm)"));
}
}
¿Esta página le ayudó?