Integrar ESP32 y Arduino con Bloomit: tutorial completo

El repositorio de ejemplos

Bloomit tiene un repositorio oficial con ejemplos funcionales para integrar cualquier placa con la API: github.com/ezequielcorbalan/bloomit-integration. Incluye tres implementaciones completas:

• arduino/BloomitWiFi/
  Arduino + WiFi: HTTP directo desde ESP32 o ESP8266
• arduino/BloomitSerial/
  Arduino + Serial: Cualquier Arduino sin WiFi, vía USB
• esp32/
  ESP32 ESP-IDF: Framework nativo con NVS, RTOS y HTTPS

Antes de entrar a cada uno, hay un concepto clave que vale la pena entender bien: el flujo de autenticación de Bloomit.

Flujo de autenticación: dos tokens, un solo registro

Bloomit usa dos tokens distintos con propósitos distintos:

• user_token

  Se obtiene al hacer login en bloomit.app

  Solo se usa una vez, para registrar el dispositivo. Puede expirar.

• device_token

  Lo devuelve el endpoint /register/public

  Nunca expira. Se guarda en la placa y se usa para todo.

La lógica es: hacés el setup una sola vez (login + registro), la placa guarda eldevice_token en EEPROM o NVS, y de ahí en adelante opera de forma autónoma sin necesidad de volver a autenticarse.

Registro del dispositivo

El ID de registro se genera a partir de la MAC address de la placa en formato REG-AABBCCDDEEFF. Así cada placa tiene un ID único y reproducible sin necesidad de configurarlo manualmente.

POST https://device.api.bloomit.app/register/public
Content-Type: application/json

{
  "userToken": "eyJhbGci...",
  "device_registration_id": "REG-AABBCCDDEEFF"
}

// Respuesta exitosa (201):
{
  "success": true,
  "device_token": "eyJhbGci...",   // ← guardar en EEPROM/NVS
  "data": {
    "device_id": 123,
    "user_id": 456,
    "is_active": true
  }
}

Opción 1: Arduino WiFi (ESP32 / ESP8266)

El sketch BloomitWiFi.ino es la integración más directa: la placa conecta al WiFi y hace HTTP POST a la API. No necesita intermediarios, funciona de forma autónoma las 24 horas.

Librerías necesarias

Instalá desde el Library Manager del Arduino IDE:

• ArduinoJson (v7.0.0 o superior) — para serializar el payload
• WiFi.h, HTTPClient.h — ya vienen incluidas en los cores de ESP32/ESP8266

Configuración inicial

// En BloomitWiFi.ino, modificar estas constantes:

const char* WIFI_SSID     = "tu_red_wifi";
const char* WIFI_PASSWORD = "tu_password";
const char* DEVICE_TOKEN  = "eyJhbGci...";  // tu device_token

// Intervalo entre lecturas (ms)
const unsigned long SENSOR_INTERVAL = 30000; // 30 segundos

Enviar datos de sensores

El sketch usa dos endpoints: /sense para lecturas y /device/logpara logs. La función central es:

// POST /sense
{
  "sensorType": "temperature",  // o "humidity", "soil_humidity", "ph", "tds"
  "value": "25.5"               // siempre como string
}

// POST /device/log
{
  "type": "info",               // "info" | "warning" | "error" | "debug"
  "message": "Heartbeat OK"
}

Para ESP8266 el sketch agrega client.setInsecure() ya que el chip no tiene suficiente RAM para validar certificados. En ESP32 la conexión HTTPS funciona sin configuración extra.

Comandos serie disponibles

El sketch tiene una interfaz de comandos por Serial a 9600 baud que es muy útil durante el desarrollo:

• statusEstado de conexión y token
• senseEnviar lectura ahora
• log <msg>Enviar log manualmente
• infoConsultar info del dispositivo en la API
• clearBorrar credenciales guardadas
• registerForzar re-registro

Opción 2: Arduino Serial (sin WiFi)

El sketch BloomitSerial.ino funciona con cualquier Arduino, incluso los que no tienen WiFi (Uno, Mega, Nano). La placa imprime JSON por el puerto serie y un intermediario se encarga de reenviar los datos a la API.

Hay dos intermediarios disponibles:

• Panel web de Bloomit (recomendado): abrís bloomit.app/devices/test en Chrome o Edge, conectás el puerto USB y el panel lee el serial y reenvía automáticamente a la API. Sin instalar nada.
• Script Python serial_bridge.py: alternativa si necesitás correr el bridge sin navegador, en un servidor, o en Linux/Raspberry Pi.

Formato del protocolo Serial

El sketch imprime una línea JSON completa por mensaje (con Serial.println()):

// Lectura de sensor (sensorType: 1=temperatura, 2=humedad)
{"token":"eyJhbGci...","cmd":"sense","sensorType":1,"value":25.4,"text":"Temperature reading"}

// Log de debug
{"token":"eyJhbGci...","cmd":"log","type":"info","message":"Dispositivo iniciado"}

El baud rate del sketch Serial es 9600. Asegurate de configurar lo mismo en el panel web o en el script Python.

Configuración del sketch

// En BloomitSerial.ino:
const char DEVICE_TOKEN[] = "eyJhbGci...";  // tu device_token

// Intervalo de envío
const unsigned long SENSOR_INTERVAL = 30000; // 30 segundos

Usando el bridge Python

Si preferís no usar el navegador, el script serial_bridge.py detecta el puerto automáticamente:

# Instalar dependencias
pip3 install pyserial requests

# Ejecutar (detecta el Arduino automáticamente)
python3 serial_bridge.py

# Salida:
# [OK] Found Arduino on /dev/ttyUSB0
# [OK] Connected! Waiting for sensor data...
# [SENSOR] Temperature: 25.4 (Temperature reading)
# [OK] Sensor data sent to Bloomit API
# [LOG] INFO: Heartbeat - Device running normally
# [OK] Log sent to Bloomit API

Opción 3: ESP32 con ESP-IDF

Para producción o cuando necesitás control total del hardware, el ejemplo ESP-IDF usa el framework nativo de Espressif con FreeRTOS, almacenamiento NVS persistente, HTTPS con esp_http_client, y arquitectura event-driven para el WiFi.

Requisitos

• ESP-IDF v5.0 o superior
• Cualquier ESP32 (ESP32, S2, S3, C3, C6)

Configurar y flashear

# 1. Activar entorno ESP-IDF
. $HOME/esp/esp-idf/export.sh

# 2. Editar main/main.c
#define WIFI_SSID      "tu_red"
#define WIFI_PASSWORD  "tu_password"
#define USER_TOKEN     "eyJhbGci..."  // se usa solo para el registro inicial

# 3. Compilar y flashear
idf.py set-target esp32
idf.py build
idf.py -p /dev/ttyUSB0 flash monitor

Almacenamiento NVS

El ejemplo guarda el device_token, device_id y user_id en la NVS (Non-Volatile Storage) del ESP32. Al reiniciar, la placa carga las credenciales guardadas y omite el registro si ya está registrada. Para forzar un re-registro:

# Borrar toda la NVS (factory reset)
idf.py erase-flash
idf.py flash

Arquitectura del código ESP-IDF

El ejemplo implementa la API de Bloomit con funciones modulares:

• bloomit_register_device()Registra la placa (skip si ya tiene token)
• bloomit_send_sensor_data(type, value)POST /sense con Bearer token
• bloomit_send_log(type, message)POST /device/log
• bloomit_get_device_info()GET /api/device — verifica el estado
• log_info / log_warning / log_errorWrappers convenientes para logs

Reemplazar los sensores simulados por los reales

Los tres ejemplos usan sensores simulados por defecto (valores aleatorios dentro de un rango). Para usar sensores reales, reemplazás las funciones readTemperature() y readHumidity() con el código de tu sensor específico. Por ejemplo, para un DHT22:

#include <DHT.h>
#define DHT_PIN  4
#define DHT_TYPE DHT22

DHT dht(DHT_PIN, DHT_TYPE);

void setup() {
  dht.begin();
}

float readTemperature() {
  return dht.readTemperature();
}

float readHumidity() {
  return dht.readHumidity();
}

Para un sensor de humedad del suelo capacitivo:

#define SOIL_PIN 34

float readSoilHumidity() {
  int raw = analogRead(SOIL_PIN);
  // Calibrar: 4095 = seco (0%), 1500 = saturado (100%)
  float humidity = map(raw, 4095, 1500, 0, 100);
  return constrain(humidity, 0, 100);
}

// Usar sensorType "soil_humidity" al enviar

Referencia rápida de la API

Todos los endpoints que usan los ejemplos:

• POST/register/publicNo requiere authRegistro del dispositivo con userToken
• POST/senseBearer device_tokenEnviar lectura de sensor
• POST/device/logBearer device_tokenEnviar log de debug
• GET/api/deviceBearer device_tokenEstado y info del dispositivo

La documentación completa de los endpoints está en la sección Docs del panel o en el README del repositorio.

¿Qué opción elegir?

• ESP32/ESP8266 + WiFiDispositivo instalado, funciona sin PC. Producción y campo.
• Arduino + SerialCualquier Arduino, ideal para prototipar o cuando no querés configurar WiFi.
• ESP-IDFControl total del hardware, producción crítica, múltiples tareas FreeRTOS.

El hardware Bloomit con sensores ya integrados (humedad de suelo, temperatura, humedad ambiental) está disponible en bloomit.com.ar. Si querés traer tu propia placa, el plan SaaS te da acceso completo a la API con los mismos endpoints que usan estos ejemplos.