FireBeetle 2 ESP32-UE: Qué Tiene de Especial esta Placa ESP32 y Cómo Configurarla

Un ESP32 de 4 MB con antena de pista funciona de maravilla encima de la mesa. Los problemas empiezan cuando el proyecto sale de la protoboard: hay que meterlo en una caja, alimentarlo con batería, colocarlo en el trastero o en el jardín y que aguante semanas sin tocarlo. La FireBeetle 2 ESP32-UE de DFRobot está pensada justo para ese momento. Su chip no tiene nada de nuevo, es el ESP32 de siempre. Lo que cambia es todo lo que lleva alrededor: conector para antena externa, cargador de batería integrado, un modo de bajo consumo que se activa con un corte en la placa, 16 MB de flash, 2 MB de PSRAM y un conector para pantallas.

Esta guía repasa qué aporta cada una de esas piezas, cuándo compensa frente a una placa ESP32 genérica y cómo configurarla en el IDE de Arduino. Ese último paso tiene un par de trampas que la documentación no deja claras y que hacen que mucha gente use la placa como si tuviera 4 MB y ninguna PSRAM.

Puntos clave

• Mismo ESP32, otra placa: lleva el módulo ESP32-WROOM-32UE-N16R2, con el ESP32 de doble núcleo clásico. No es un S3 ni un C6, así que tu código para ESP32 sirve sin cambios mientras no use GPIO16.
• La antena va aparte, siempre: el módulo no tiene antena de pista, solo un conector IPEX de primera generación (compatible con U.FL). Sin antena conectada, el WiFi y el Bluetooth apenas llegan a ningún sitio.
• Configúrala a mano en el IDE: la entrada «FireBeetle 2 ESP32-E» viene con la flash en 4 MB y la PSRAM desactivada. Hay que cambiar las dos cosas para aprovechar la placa.
• GPIO16 no está disponible: lo ocupa la PSRAM. Ojo si portas código de otra FireBeetle que use D11 o los pines por defecto de Serial2.
• El pad de bajo consumo decide la autonomía: según DFRobot, cortarlo ahorra unos 500 µA en reposo y deja el deep sleep en 13 µA. Si el nodo despierta cada hora, la diferencia es de unos dos meses de batería a más de siete.

Qué es la FireBeetle 2 ESP32-UE

Es una placa de desarrollo de DFRobot (referencia DFR1140) de la familia FireBeetle 2, construida alrededor del módulo ESP32-WROOM-32UE-N16R2 de Espressif. La «U» del nombre indica que el módulo saca la radio por un conector en lugar de por una antena impresa, y «N16R2» significa 16 MB de flash y 2 MB de PSRAM.

En la placa, junto al módulo, hay un conector USB-C para programar y alimentar, un conector PH2.0 para una batería Li-ion de una celda con su circuito de carga, un conector GDI para pantallas, un LED normal, un LED RGB direccionable y un botón de usuario.

Ficha técnica

Estos son los datos que publica DFRobot en la wiki oficial de la placa:

Característica	FireBeetle 2 ESP32-UE
Módulo	ESP32-WROOM-32UE-N16R2
Procesador	Tensilica Xtensa LX6 de doble núcleo, hasta 240 MHz
Memoria	520 KB de SRAM, 448 KB de ROM, 16 MB de flash y 2 MB de PSRAM
Conectividad	WiFi 802.11 b/g/n a 2,4 GHz, Bluetooth 4.2 (BR/EDR) y BLE
Antena	Externa, por conector IPEX de 1.ª generación (compatible con U.FL y MHF I)
Alimentación	USB-C a 5 V (admite de 4,75 a 5,5 V) o batería Li-ion de 3,7 V por conector PH2.0
Pines	17 digitales y 11 analógicos
Periféricos	3 UART, 1 SPI, 1 I2C, 1 I2S, 2 DAC, 7 entradas táctiles y 16 canales PWM (LEDC)
En la placa	LED en GPIO2 (D9), LED RGB WS2812 en GPIO5 (D8), botón en GPIO27 (D4) y conector GDI
Tamaño y peso	25,4 × 60 mm y 23,4 g

ESP32-E, ESP32-E N16R2 y ESP32-UE: en qué se diferencian

DFRobot vende varias FireBeetle 2 con el mismo ESP32 y nombres muy parecidos, así que conviene tener clara la diferencia antes de comprar:

	FireBeetle 2 ESP32-E	FireBeetle 2 ESP32-E N16R2	FireBeetle 2 ESP32-UE
Referencia	DFR0654	DFR1139	DFR1140
Flash / PSRAM	4 MB / sin PSRAM	16 MB / 2 MB	16 MB / 2 MB
Antena	De pista, integrada	De pista, integrada	Externa (IPEX)
GPIO16 (D11)	Disponible	Ocupado por la PSRAM	Ocupado por la PSRAM

Si no necesitas sacar la antena fuera de una caja, la ESP32-E N16R2 te da la misma memoria sin depender de una antena externa. La UE tiene sentido cuando la placa va a vivir en un sitio donde la antena integrada se queda corta. DFRobot no es muy consistente con los nombres en su tienda, así que comprueba la referencia antes de pagar.

Por qué una antena externa (y qué esperar de ella)

Lo que aporta la antena externa es poder decidir dónde está la antena, y eso suele pesar más que la antena en sí. Una antena de pista dentro de una caja metálica, pegada a una batería o detrás de una pantalla pierde buena parte de la señal antes de que salga de la caja. Con la UE, la placa puede quedarse dentro y la antena fuera, orientada hacia el router.

El módulo usa un conector IPEX de primera generación. Según la hoja de datos de Espressif, es compatible con el U.FL de Hirose, el MHF I de I-PEX y el AMC de Amphenol. Lo que no encaja es el MHF4, más pequeño y muy habitual en tarjetas WiFi de portátil: en fotos parecen iguales, pero no lo son.

Tres cosas que conviene saber antes de enchufar nada:

1. Usa una antena de 2,4 GHz. Las antenas de 868 MHz para LoRa o las de 5 GHz no sirven, aunque el conector encaje.
2. Si la caja es metálica, usa un pigtail U.FL a SMA. El U.FL, que es delicado, se queda dentro, y el SMA atraviesa la pared de la caja. Así puedes cambiar de antena sin tocar el conector pequeño, que aguanta pocos ciclos de conexión.
3. No pruebes la radio sin antena. Sin nada conectado, el alcance cae a unos pocos metros y no es buena práctica dejar transmitiendo la etapa de RF sin carga.

Todo lo relacionado con elegir el cable, la ganancia de la antena y dónde colocarla lo tienes explicado en detalle en la guía sobre cómo añadir una antena externa a un ESP32. Esa guía incluye también un sketch para medir el RSSI medio antes y después del cambio.

Batería sin módulo cargador aparte

La placa carga una batería Li-ion o LiPo de una celda directamente desde el USB-C, así que te ahorras el típico módulo cargador TP4056 y su cableado. Cuando hay USB, la placa se alimenta de él y carga la batería. Al desconectarlo, pasa a la batería sin cortes.

Algunos detalles prácticos que salen de la wiki de DFRobot:

• El conector de batería admite de 3,5 a 4,2 V, es decir, una celda Li-ion o LiPo estándar desde casi descargada hasta llena.
• El pin VCC da unos 4,7 V con USB y, con batería, más o menos la tensión de la propia batería (unos 4 V con una celda a media carga). El pin 3V3 da 3,3 V en ambos casos.
• El LED rojo de carga se enciende mientras carga y se apaga cuando la batería está llena. Si conectas el USB sin batería, parpadea rápido.

Cuidado con la polaridad del conector. Los conectores PH2.0 de las baterías LiPo no siguen un estándar de polaridad: hay fabricantes que ponen el rojo a un lado y otros al contrario. Antes de enchufar una batería por primera vez, compara el cable rojo con la serigrafía «+» de la placa. Una batería conectada al revés puede dañar el circuito de carga al instante.

El pad de bajo consumo: el detalle que más batería ahorra

La placa tiene un pequeño puente de soldadura de bajo consumo, marcado como «Low Power» en la documentación de DFRobot, que viene unido de fábrica. Según DFRobot, si cortas la pista fina que une sus dos mitades, el consumo estático baja en unos 500 µA, y con el ESP32 en deep sleep la placa se queda en unos 13 µA. La contrapartida es que, con el pad cortado, el LED RGB solo funciona cuando la placa recibe alimentación por USB.

DFRobot no detalla qué alimenta ese pad, pero la pista está en el LED RGB: los LED direccionables tipo WS2812 consumen fracciones de miliamperio en reposo aunque estén apagados, lo que cuadra con esos 500 µA. Si el nodo va a funcionar con batería, córtalo. Si siempre va a estar enchufado a USB, no ganas nada.

¿Cuánto se nota? Haz la cuenta para un nodo típico que despierta, lee un sensor, envía el dato por WiFi en unos 5 segundos y vuelve a dormir. La corriente media es:

I media = (I activa × t activo + I reposo × t reposo) / t total

Con una batería de 1000 mAh, una ráfaga de 5 s a 120 mA de media (un valor razonable para un ESP32 que se conecta a la WiFi y transmite, pero mídelo en tu caso) y una lectura cada 10 minutos, salen unos 41 días con el pad cortado y unos 28 con el pad unido. Con una lectura por hora, la diferencia se dispara: unos 232 días frente a 61.

Se ve un patrón claro. Si el nodo despierta cada pocos minutos, el consumo lo marca el tiempo que pasa despierto y conectado a la WiFi, así que optimiza eso primero: conexión con IP fija, menos reintentos, envío rápido. Si despierta cada hora o menos, lo que manda es el consumo en reposo, y cortar el pad es lo más rentable que puedes hacer. Ten en cuenta que esto es un cálculo teórico: no incluye la autodescarga de la batería ni lo que consuman los sensores que dejes alimentados.

Qué aportan los 16 MB de flash y los 2 MB de PSRAM

La mayoría de placas ESP32 básicas llevan 4 MB de flash y nada de PSRAM. Cuatro veces más flash significa sitio para programas grandes con OTA (dos copias del firmware), un sistema de archivos generoso para guardar páginas web, fuentes, imágenes o registros de datos, o ambas cosas a la vez.

La PSRAM son 2 MB de RAM externa que se suman a los 520 KB internos. Es más lenta que la SRAM interna, pero muy útil para lo que no cabe en ella: búferes de pantalla, respuestas JSON largas de una API, colas de lecturas acumuladas mientras no hay WiFi o búferes de audio. Lo que no hace es acelerar el programa: si tu sketch cabe sin problemas en la RAM interna, no notarás nada.

El conector GDI para pantallas

El conector GDI es un FPC de 18 pines propio de DFRobot. Permite conectar las pantallas compatibles de la marca con un cable plano, sin cablear el bus SPI pin a pin. Si vas a usar una de sus pantallas, es cómodo y limpio. Si usas pantallas de otros fabricantes, lo normal es conectarlas por los pines de siempre. Consulta en la wiki qué pines comparte el GDI con el resto de la placa antes de usarlos para otra cosa.

Pinout: qué pines usar y cuáles evitar

La FireBeetle 2 ESP32-UE comparte nomenclatura con el resto de la familia: cada pin tiene su número de GPIO y una etiqueta de DFRobot (D2, D9, A4…) que es la que reconoce el IDE de Arduino al elegir la placa. Puedes usar cualquiera de los dos nombres en el código.

Las reglas que más problemas evitan:

• GPIO16 no existe para ti. En los módulos N16R2, Espressif lo conecta a la PSRAM y no se puede usar para nada más. En la definición de la placa para Arduino, GPIO16 es D11 y también el RX por defecto de Serial2. Si llamas a Serial2.begin(9600) sin indicar pines, apuntas a la PSRAM. Pásale siempre los pines de forma explícita, por ejemplo Serial2.begin(9600, SERIAL_8N1, 25, 26).
• GPIO12 (D13) debe estar a nivel bajo al arrancar. Es un pin de configuración que fija la tensión de alimentación de la flash y la PSRAM. Si un sensor o una resistencia de pull-up lo mantiene en alto durante el encendido, el módulo puede no arrancar.
• GPIO0, GPIO2, GPIO5 y GPIO15 también intervienen en el arranque. Puedes usarlos, pero no les conectes nada que fuerce un nivel durante el reinicio. Además, GPIO2 y GPIO5 ya tienen conectados los dos LED de la placa.
• Con WiFi activo, solo funciona el ADC1. En el ESP32 clásico, el ADC2 comparte recursos con la radio, así que las lecturas analógicas en GPIO0, 2, 4, 12-15, 25 y 26 fallan mientras la WiFi está encendida. Para sensores analógicos usa GPIO34 (A2) o GPIO35 (A3), que son del ADC1. Ojo: son solo de entrada y no tienen resistencias pull-up ni pull-down internas.
• GPIO1 y GPIO3 son el puerto serie del USB. Si los usas para otra cosa, pierdes la carga de programas y el monitor serie.

Si quieres profundizar en lo que hace cada GPIO del módulo, tienes el detalle en nuestra guía del pinout del ESP32-WROOM.

Cómo configurar la FireBeetle 2 ESP32-UE en el IDE de Arduino

No hay una entrada específica para la UE en el IDE. Se usa la de la FireBeetle 2 ESP32-E, que comparte chip y mapa de pines. El problema es que esa entrada viene pensada para la versión de 4 MB: flash en 4 MB y PSRAM desactivada. Si no cambias nada, todo funciona, pero desperdicias 12 MB de flash y los 2 MB de PSRAM.

1. En Herramientas > Placa > Gestor de placas, instala el paquete «esp32» de Espressif Systems. Si no te aparece, añade esta URL en Archivo > Preferencias > Gestor de URLs adicionales de tarjetas: https://espressif.github.io/arduino-esp32/package_esp32_index.json. Si es la primera vez que trabajas con un ESP32, tienes el proceso completo en la guía para iniciar proyectos IoT con ESP32.
2. Elige Herramientas > Placa > esp32 > FireBeetle 2 ESP32-E.
3. Ajusta las opciones del menú Herramientas según la tabla de abajo.
4. Conecta la placa con un cable USB-C de datos (muchos cables de carga no llevan los hilos de datos) y selecciona su puerto.

Opción del menú Herramientas	Valor por defecto	Valor para la ESP32-UE
Flash Size	4MB (32Mb)	16MB (128Mb)
Partition Scheme	Default 4MB with spiffs	16M Flash (3MB APP/9MB FATFS) o 16M Flash (2MB APP/12.5MB FAT)
PSRAM	Disabled	Enabled

El esquema «3MB APP/9MB FATFS» reserva dos particiones de 3 MB para el programa, de modo que puedes actualizar por OTA, y deja 9 MB para archivos. El de «2MB APP/12.5MB FAT» va mejor si guardas muchos datos y tu programa es pequeño.

Si trabajas con PlatformIO, pasa lo mismo: la placa dfrobot_firebeetle2_esp32e viene configurada a 4 MB. Algo así en el platformio.ini lo deja ajustado:

[env:firebeetle2_esp32ue]
platform = espressif32
board = dfrobot_firebeetle2_esp32e
framework = arduino
board_upload.flash_size = 16MB
board_build.partitions = default_16MB.csv
build_flags = -DBOARD_HAS_PSRAM

Primera prueba: los dos LED de la placa

Este sketch hace parpadear el LED de GPIO2 y alterna el LED RGB entre azul y rojo con poca intensidad. Usa rgbLedWrite(), la función del núcleo de Arduino-ESP32 para LED WS2812. En versiones antiguas del núcleo (2.x) se llamaba neopixelWrite().

// FireBeetle 2 ESP32-UE: primera prueba con los dos LED de la placa
const int PIN_LED = 2;   // D9: LED sencillo
const int PIN_RGB = 5;   // D8: LED RGB WS2812

void setup() {
  Serial.begin(115200);
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  digitalWrite(PIN_LED, HIGH);
  rgbLedWrite(PIN_RGB, 0, 0, 40);   // azul suave
  delay(500);

  digitalWrite(PIN_LED, LOW);
  rgbLedWrite(PIN_RGB, 40, 0, 0);   // rojo suave
  delay(500);
}

Si el LED RGB no se enciende con la placa a batería, recuerda que con el pad de bajo consumo cortado solo funciona con USB.

Comprobar que la PSRAM y la flash están activas

Este segundo sketch es el que te dice si la configuración del IDE es correcta. Muestra el tamaño de la flash, el espacio disponible para el programa y la PSRAM, y además reserva 1 MB en la PSRAM para confirmar que se puede usar:

// Comprueba que el IDE está aprovechando la flash y la PSRAM de la placa
void setup() {
  Serial.begin(115200);
  delay(1000);

  Serial.printf("Flash del chip: %u MB\n", ESP.getFlashChipSize() / (1024 * 1024));
  Serial.printf("Espacio para el sketch: %u KB\n", ESP.getFreeSketchSpace() / 1024);

  if (!psramFound()) {
    Serial.println("PSRAM no detectada: activa Herramientas > PSRAM > Enabled");
    return;
  }

  Serial.printf("PSRAM total: %u KB, libre: %u KB\n",
                ESP.getPsramSize() / 1024, ESP.getFreePsram() / 1024);

  // Reserva 1 MB en la PSRAM para comprobar que se puede usar de verdad
  const size_t TAM = 1024 * 1024;
  uint8_t* buffer = (uint8_t*) ps_malloc(TAM);
  if (buffer != nullptr) {
    memset(buffer, 0xAA, TAM);
    Serial.printf("1 MB reservado en PSRAM. Quedan %u KB libres\n",
                  ESP.getFreePsram() / 1024);
    free(buffer);
  } else {
    Serial.println("No se ha podido reservar 1 MB en la PSRAM");
  }
}

void loop() {}

Cómo leer el resultado en el monitor serie (115200 baudios):

• Flash del chip: 16 MB aparece siempre. En el núcleo 3.x se lee del propio chip, así que no te dice si el IDE está bien configurado.
• Espacio para el sketch sí lo dice: con el esquema de 16 MB de «3MB APP» verás 3072 KB. Si ves 1280 KB, el IDE sigue usando el esquema de 4 MB.
• PSRAM total debería rondar los 2048 KB, algo menos porque el sistema reserva una parte. Si ves el aviso de «PSRAM no detectada», revisa la opción PSRAM del menú Herramientas.

Cómo comprobar que la antena funciona

La forma más rápida es leer el RSSI, la potencia de la señal que recibe la placa en dBm. Cuanto más cerca de cero, mejor: −45 dBm es una señal excelente, −67 dBm va bien para casi todo y por debajo de −80 dBm empiezan los cortes. No te fíes de una sola lectura, porque el RSSI oscila varios dB de un segundo a otro. Haz la media de 10 o 20 muestras en cada posición.

Para comparar con una placa de antena integrada, la prueba solo vale si mantienes todo lo demás igual: el mismo punto de acceso, las mismas posiciones, la placa en la caja definitiva y varias muestras en cada sitio. El sketch de RSSI medio que usamos en la guía de antenas externas para ESP32 sirve tal cual en esta placa.

Un nodo de sensor a batería con deep sleep

Así se juntan todas las piezas en un caso real. El sketch despierta cada 10 minutos, lee un sensor analógico en GPIO34 (ADC1, que funciona con la WiFi encendida), se conecta a la red, envía el dato y vuelve a dormir. La variable marcada con RTC_DATA_ATTR guarda el número de despertares durante el deep sleep, porque la RAM normal se borra al dormir.

// Nodo de sensor a batería: despierta, lee, envía por WiFi y vuelve a dormir
#include <WiFi.h>
#include <esp_sleep.h>

const char* ssid     = "TU_RED_WIFI";
const char* password = "TU_CONTRASENA";

const int PIN_SENSOR = 34;               // A2, canal del ADC1: funciona con el WiFi activo
const uint64_t MINUTOS_DORMIDO = 10;

RTC_DATA_ATTR uint32_t despertares = 0;  // se conserva durante el deep sleep

void setup() {
  Serial.begin(115200);
  despertares++;

  // Lee antes de encender la radio: así la medida no se ve afectada por el pico de consumo
  int milivoltios = analogReadMilliVolts(PIN_SENSOR);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  unsigned long inicio = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - inicio < 10000) {
    delay(100);
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.printf("Despertar %u: sensor %d mV, RSSI %d dBm\n",
                  despertares, milivoltios, WiFi.RSSI());
    // Aquí enviarías el dato: MQTT, HTTP, etc.
  } else {
    Serial.printf("Despertar %u: sin WiFi, lectura de %d mV sin enviar\n",
                  despertares, milivoltios);
  }

  WiFi.disconnect(true);
  WiFi.mode(WIFI_OFF);

  esp_sleep_enable_timer_wakeup(MINUTOS_DORMIDO * 60ULL * 1000000ULL);
  Serial.flush();
  esp_deep_sleep_start();
}

void loop() {}

Para un proyecto real, sustituye el Serial.printf por el envío del dato a un broker MQTT o a un servidor HTTP. Y si el sensor se alimenta desde el pin 3V3, recuerda que seguirá consumiendo mientras la placa duerme: aliméntalo desde un GPIO que pongas a nivel alto solo mientras lees, siempre que su consumo lo permita (unos pocos miliamperios como mucho).

Cómo medir el consumo en deep sleep

Los 13 µA son la cifra de DFRobot con el pad cortado. Para saber cuánto consume tu montaje, mídelo así:

1. Desconecta el USB. Si no, la placa se alimenta de él y la medida no sirve.
2. Pon el multímetro en serie con el cable positivo de la batería.
3. Arranca con el multímetro en la escala de miliamperios, o con un puente que cortocircuite sus puntas. En la escala de microamperios la resistencia interna del multímetro es alta, y el pico de consumo de la WiFi provoca una caída de tensión que puede reiniciar el ESP32 en bucle.
4. Cuando la placa esté dormida, quita el puente o pasa a la escala de µA y lee.

Si mides bastante más de lo esperado, revisa por este orden: el pad sin cortar, sensores o módulos alimentados desde 3V3, LED de alimentación de esos módulos y resistencias pull-up que quedan conduciendo.

¿Merece la pena la FireBeetle 2 ESP32-UE?

Merece la pena cuando se juntan varias de sus ventajas en el mismo proyecto: un nodo con batería, dentro de una caja, lejos del router y con datos o firmware que necesitan espacio. Una estación meteorológica en el jardín, un sensor en un trastero con puerta metálica o un registrador que guarda datos cuando no hay WiFi y los envía después son casos de libro.

No compensa para aprender, para un proyecto que siempre va a estar enchufado junto al router o cuando la antena externa es más estorbo que ayuda. Para eso, una placa ESP32 básica o la FireBeetle 2 ESP32-E con antena integrada cumplen igual y son más simples. Tampoco es la mejor opción si necesitas USB nativo, cámara o más potencia de cálculo: el ESP32-S3 encaja mejor ahí. Y si lo que buscas es WiFi 6, Thread o Zigbee, mira las placas basadas en ESP32-C6, que DFRobot también tiene en la familia FireBeetle.

Preguntas frecuentes

¿Puedo usar la FireBeetle 2 ESP32-UE sin antena?

Para cargar programas sí: la programación va por USB y no usa la radio. Para WiFi o Bluetooth no es recomendable. Sin antena el alcance se queda en unos pocos metros y la etapa de radio trabaja sin carga. Conecta una antena de 2,4 GHz antes de activar la radio.

¿Qué antena necesito?

Una antena de 2,4 GHz con conector U.FL, IPEX MHF I o equivalente de primera generación, o un pigtail de U.FL a SMA si la antena va en el exterior de la caja. Las antenas con conector MHF4 no encajan.

¿Qué placa elijo en el IDE de Arduino?

«FireBeetle 2 ESP32-E», dentro del paquete esp32 de Espressif. Después ajusta Flash Size a 16MB, un esquema de particiones de 16 MB y PSRAM en Enabled, porque por defecto viene configurada para la versión de 4 MB.

¿Por qué mi sketch no detecta la PSRAM?

Casi siempre es porque la opción PSRAM del menú Herramientas está en Disabled, que es su valor por defecto para esta placa. Actívala, vuelve a compilar y carga el programa de nuevo.

¿Puedo usar cualquier batería LiPo de 3,7 V?

Sí, siempre que sea de una sola celda y tenga conector PH2.0 (o lo adaptes). Antes de conectarla comprueba la polaridad: no todos los fabricantes colocan el cable rojo en el mismo lado del conector.

¿Cuánto consume en deep sleep?

DFRobot indica unos 13 µA con el pad de bajo consumo cortado. Con el pad unido, como viene de fábrica, hay que sumar unos 500 µA más. A eso se añade lo que consuma todo lo que tengas conectado a la placa.

Por dónde seguir

Si ya tienes la placa, el primer paso útil es cargar el sketch de memoria y dejar bien configurado el IDE. Si va a funcionar con batería, decide pronto si cortas el pad, porque es lo que más cambia la autonomía. Y antes de cerrar la caja, mide el RSSI con la antena ya en su sitio definitivo: es la única forma de saber si está bien colocada.