org-hub/learn/BLE_Projects_roadmap_ideas.md

# BLE + ESP32: Síntesis & Roadmap para Edge AI

## Resumen Ejecutivo

Has completado una **masterclass exhaustiva** que cubre:

✅ **Módulo 0**: Fundamentos BLE (PHY, Link Layer, GATT, Seguridad)
✅ **Módulo 1**: Advertising & Discovery (Beacons, Data types)
✅ **Módulo 2**: Connections & GATT (Server, Notificaciones)
✅ **Módulo 3**: Security & Advanced (LESC, Bonding, NVS)
✅ **Debugging**: Logging, GDB+OpenOCD, ASAN, HCI Sniffing
✅ **Ejercicios**: 4 niveles progresivos con código completo

---

## Checklist de Dominio

Antes de avanzar a Edge AI + Blockchain, valida que **entiendes profundamente**:

### Teoría BLE (✓ si respondes sin dudar)

- [ ] Diferencia entre PHY 1M, 2M, Coded. ¿Cuándo usarías cada uno?
- [ ] ¿Por qué BLE usa frequency hopping? ¿Cuál es el parámetro `hop_increment`?
- [ ] ¿Qué es CCCD y por qué es crítico para notificaciones?
- [ ] ¿Cuál es la diferencia entre Notificar e Indicar?
- [ ] ECDH vs Legacy Pairing: ¿Cuáles son los puntos vulnerables?
- [ ] ¿Cómo funciona RPA (Resolvable Private Address)?

### Práctica ESP32 (✓ si compilas sin errors)

- [ ] ¿Puedes implementar un beacon custom en 10 minutos?
- [ ] ¿Puedes crear un GATT server con 3+ características?
- [ ] ¿Puedes hacer pairing LESC + bonding?
- [ ] ¿Puedes debuggear un crash con GDB + stack trace?
- [ ] ¿Puedes optimizar connection parameters para batería?

### NimBLE Internals (✓ si entiendes el flujo)

- [ ] ¿Cómo fluye un evento BLE en NimBLE? (HCI → Host task → app callback)
- [ ] ¿Dónde se almacenan bonded devices? (NVS, qué namespace)
- [ ] ¿Cuál es la diferencia entre `ble_gap_adv_set_fields` y `ble_gap_adv_start`?
- [ ] ¿Por qué `nimble_host_task` es una task FreeRTOS separada?

---

## Integración: Edge AI + BLE + Blockchain

### 1️⃣ Scenario: Federated Learning en Wearables

```
┌──────────────────────┐
│  Smartphone Central  │  (Orquestador)
│  - Modelo ML global  │
│  - Verifica signaturas│
├──────────────────────┤
│     BLE (NimBLE)     │
└──────────────────────┘
         │ ▲
         │ │ (gradientes cuantizados)
         ▼ │
    ┌─────────────┐
    │   ESP32 #1  │  Reloj (acelerómetro)
    │  - TFLite    │  → Localdetect caída
    │  - Entrena  │  → Sube gradientes
    └─────────────┘
```

**Implementación BLE:**
- Central (smartphone) se conecta a múltiples periféricos (ESP32).
- ESP32 notifica cambios de modelo cada 10 minutos.
- Central agrega gradientes con CUDA.
- Re-envía modelo actualizado vía BLE.

**Código (conceptual):**
```c
// ESP32: Detecta caída via ML, prepara gradientes
void ml_inference_task(void) {
    float *gradients = tflite_get_gradients();  // 4 KB comprimido
    
    // Notificar al central
    ble_gatts_notify_custom(conn_handle, grad_handle, gradients, 4096);
}

// Central: Agrega y re-distribuye
void federated_aggregation(std::vector<uint8_t*> all_grads) {
    aggregate_on_gpu(all_grads);
    broadcast_via_ble(updated_model);
}
```

---

### 2️⃣ Scenario: Verificación de Datos en Blockchain

```
┌─────────────────┐
│  ESP32 Sensor   │
│  - ADC temp     │
│  - Sign with SK │
│  - BLE send     │
└─────────────────┘
         │
         ▼
┌─────────────────┐
│  Smartphone     │
│  - Recibe firma │
│  - Verifica PK  │
│  - Envía a Dapp│
└─────────────────┘
         │
         ▼
┌─────────────────┐
│ Blockchain      │
│ (Substrate)     │
│ - Verifica data │
│ - Almacena hash │
│ - Emite evento  │
└─────────────────┘
```

**Criptografía BLE:**
- ESP32 usa SK (private key) para firmar lecturas.
- Central verifica con PK (public key).
- Hash se envía a blockchain para verificación.

---

### 3️⃣ Scenario: IoT Mesh con Coordinación

```
     Central (Coordinator)
           │
    ┌──────┼──────┐
    │      │      │
  Node1  Node2  Node3  (ESP32s con sensores)
    │      │      │
    └──────┼──────┘
           │
      Blockchain
      (Consensus)
```

**Protocolo:**
1. Cada nodo es periférico (BLE).
2. Coordinator es central (conecta a todos).
3. Cada 30s, nodos reportan sensores.
4. Coordinator agrega y firma.
5. Envía a blockchain via API.

---

## Próximos Pasos: Roadmap Personalizado

### Fase 1: Validar BLE Mastery (1-2 semanas)

```
[ ] Ejercicio 4 completo: IoT Sensor Sync
[ ] Implementar custom beacon con 128-bit UUID
[ ] Crear GATT server con encriptación LESC
[ ] Debuggear con GDB: set 3+ breakpoints
[ ] Medir consumo de potencia en 3 connection params
```

**Criterio de éxito:** Debuggeas un crash en GATT sin ayuda y optimizas latencia.

---

### Fase 2: TensorFlow Lite Micro + BLE (2-3 semanas)

**Objetivo:** Ejecutar modelo ML en ESP32, actualizarlo via BLE.

**Pasos:**
1. Entrenar modelo pequeño (< 100 KB).
   - MobileNetV2 cuantizado.
   - DistilBERT para procesamiento de lenguaje.
   
2. Compilar para ESP32 con TFLite Micro.
   ```bash
   python3 -m tensorflow.lite.python.convert \
       --inference_input_type=QUANTIZED_UINT8 \
       --inference_output_type=QUANTIZED_UINT8 \
       model.h5 model.tflite
   xxd -i model.tflite > model.h
   ```

3. Integrar con BLE para actualizaciones OTA.
   ```c
   void ota_update_model_task(void) {
       // Recibe chunks via BLE notification
       // Escribe a flash partition
       // Reinicia con nuevo modelo
   }
   ```

**Recurso:** TensorFlow Lite for Microcontrollers guide.

---

### Fase 3: Rust + NimBLE Safety (1-2 semanas)

**Objetivo:** Dominar Rust para **seguridad memory-safe**.

**Pasos:**
1. Setups Rust ESP32 toolchain.
   ```bash
   rustup target add xtensa-esp32-espidf
   cargo install cargo-espflash
   ```

2. Reescribir componentes críticos (GAP, GATT).
   ```rust
   pub struct BleDevice {
       stack: NimbleStack,
       services: Vec<GattService>,
   }
   
   impl BleDevice {
       pub fn new() -> Result<Self, BleError> {
           // Safe initialization
       }
   }
   ```

3. Integrar con C via FFI.

**Recurso:** The Embedded Rust Book + esp-idf-hal.

---

### Fase 4: Blockchain Coordination (2-3 semanas)

**Objetivo:** Verificar datos IoT en blockchain (Substrate/Tendermint).

**Pasos:**
1. Setups cadena local.
   ```bash
   substrate-contracts-node --dev
   ```

2. Escribir pallet Substrate.
   ```rust
   #[pallet::call_index(0)]
   pub fn record_iot_reading(
       origin: OriginFor<T>,
       device_id: u64,
       reading: u32,
       proof: BoundedVec<u8, ConstU32<64>>,
   ) -> DispatchResult {
       ensure_signed(origin)?;
       // Verificar firma BLE
       // Almacenar lectura
       Ok(())
   }
   ```

3. Conectar ESP32 → Pallet via HTTP/WebSocket.

**Recurso:** Substrate Developer Hub + Ink! (smart contracts).

---

### Fase 5: Federated Learning (3-4 semanas)

**Objetivo:** Entrenar modelo distribuido entre múltiples ESP32s.

**Arquitectura:**
```
Central (Coordinator)
├─ Aggregador ML (PyTorch)
├─ BLE Central
└─ API REST

ESP32 Periféricos
├─ TFLite Micro (inference)
├─ Gradientes locales (4-16 KB)
└─ BLE Periférico
```

**Pasos:**
1. Implementar local SGD en ESP32.
   ```c
   void sgd_step(float *weights, float *gradients, int size) {
       for (int i = 0; i < size; i++) {
           weights[i] -= LEARNING_RATE * gradients[i];
       }
   }
   ```

2. Agregación en Central (PyTorch/Rust).
   ```python
   def aggregate_gradients(esp32_grads):
       return torch.stack(esp32_grads).mean(dim=0)
   ```

3. Broadcasting del modelo nuevo.

**Recurso:** Federated Learning with PyTorch + TensorFlow Federated.

---

## Matriz de Decisión: ¿Qué Aprender Primero?

| Necesidad | Prioridad | Tiempo | Roadmap |
|-----------|-----------|--------|---------|
| **Validar BLE** | 🔴 Ahora | 1w | Fase 1 |
| **ML en Edge** | 🟠 Pronto | 2w | Fase 2 |
| **Memory Safety** | 🟠 Pronto | 2w | Fase 3 |
| **Blockchain** | 🟡 Importante | 3w | Fase 4 |
| **Federated Learning** | 🟢 Después | 4w | Fase 5 |

**Recomendación:** Fases 1 → 2 → 4 (en paralelo 3 si tiempo).

---

## Herramientas Esenciales

### Debugging & Testing

```bash
# Terminal 1: OpenOCD
openocd -f interface/esp32_prog.cfg -f target/esp32.cfg

# Terminal 2: GDB
xtensa-esp32-elf-gdb build/app.elf
(gdb) target remote localhost:3333

# Terminal 3: Monitor
idf.py -p /dev/ttyUSB0 monitor

# Análisis de logs
idf.py monitor | tee session.log
grep "BLE_GATT\|ERROR" session.log | tail -20
```

### Mobile Testing

- **nRF Connect** (Android/iOS): Scan, connect, notif, indicaciones.
- **LightBlue** (iOS): RSSI, timing.

### Hardware Sniffing (Avanzado)

- **Wireshark + Ubertooth One**: Captura OTA de conexiones.
- **Raspberry Pi + OpenOCD**: Debuggeo JTAG local.

---

## Referencias Finales

### Especificaciones (Obligatorios)

1. **Bluetooth Core Spec Vol 4 Part A-H**: https://bluetooth.com
2. **ESP32 Technical Reference Manual**: Espressif docs
3. **Apache NimBLE Architecture**: mynewt.apache.org

### Documentación Técnica

- **ESP-IDF Programming Guide**: docs.espressif.com
- **TensorFlow Lite Micro**: tensorflow.org/lite/microcontrollers
- **Substrate Developer Hub**: substrate.dev

### Repositorios Clave

```bash
# ESP-IDF ejemplos
git clone https://github.com/espressif/esp-idf
cd esp-idf/examples/bluetooth/ble_get_started

# NimBLE
git clone https://github.com/apache/mynewt-nimble

# Raspberry Pi Pico + NimBLE
git clone https://github.com/h2zero/NimBLE-Arduino

# TensorFlow Lite Micro ESP32
git clone https://github.com/tensorflow/tflite-micro

# Substrate template
git clone https://github.com/substrate-developer-hub/substrate-node-template
```

### Papers & Blogs Recomendados

1. **"BLE Security Analysis"** - NoveBits (2024)
2. **"Frequency Hopping in BLE"** - arxiv.org/pdf/... (2019)
3. **"Federated Learning for IoT"** - Google Research (2022)
4. **"Edge AI Inference Optimization"** - TensorFlow Blog (2023)

---

## Ejercicio Final Integrador: Mini-Proyecto Capstone

**Propósito:** Combina BLE + ML + Blockchain.

### Especificación

**Sistema:** "Smart Home Energy Monitor"

```
┌──────────────────┐
│   Smart Meter    │
│  (ESP32 + Sensor)│
│  - Mide potencia │
│  - Detecta anomalías (TFLite)
│  - BLE periférico│
└──────────────────┘
        │ BLE
        ▼
┌──────────────────┐
│  Hub (Central)   │
│  - Recibe datos  │
│  - Agrega stats  │
│  - Firma + blockchain
└──────────────────┘
        │ HTTP
        ▼
  Blockchain
  (Substrate)
```

### Requisitos

**Hardware:**
- 1x ESP32 con sensor ADC (simular consumo).
- 1x Smartphone o PC como central.

**Software:**
- **BLE Periférico (ESP32):**
  - Beacon: consumo actual (W).
  - GATT Service: historiales (últimas 10 lecturas).
  - Notificaciones: cada lectura nueva.
  - LESC + Bonding.

- **BLE Central (Smartphone/PC):**
  - Conectar múltiples medidores.
  - Agregar consumo total.
  - Detectar anomalías (> 2σ).

- **Blockchain (Local Substrate):**
  - Pallet `EnergyReading` con readings.
  - Verificación de firma (public key ESP32).
  - Query: consumo por hora/día.

### Entregables

1. Código BLE (periférico + central).
2. Pallet Substrate + tests.
3. Documentación: arquitectura, security, resultados de pruebas.
4. Análisis: latencia BLE, consumo energético, throughput.

### Criterios de Éxito

✅ Periférico con LESC + bonding persistente.
✅ Central agrega datos de 2+ periféricos.
✅ Detección de anomalías (algoritmo simple OK).
✅ Blockchain verifica firma y registra.
✅ Demo: De sensor a blockchain en < 5s.

---

## Último Consejo: Tu Diferenciador Competitivo

Combine **estas 3 áreas** rara vez juntas:

1. **BLE Low-Level** (PHY, Link Layer, Seguridad).
2. **Embedded Rust** (Memory-safety en IoT).
3. **Blockchain Smart Contracts** (Verificación descentralizada).

Esto te posiciona como **experto en Edge AI + Distributed Trust**, muy demandado en:
- **Autonomous vehicles**: Coordinación de sensores.
- **Smart cities**: Redes IoT verificadas.
- **Healthcare wearables**: Datos verificables en cadena.
- **Industria 4.0**: IoT industrial con blockchain.

---

**¡Felicidades! Ya tienes todo el conocimiento. Ahora, a construir.** 🚀

---

## Quick Reference: Comandos Útiles

```bash
# Build & Flash
idf.py set-target esp32
idf.py build
idf.py -p /dev/ttyUSB0 flash monitor

# Menuconfig
idf.py menuconfig
# → Component config → Bluetooth → NimBLE vs Bluedroid
# → Log level → DEBUG

# GDB + OpenOCD
openocd -f interface/ftdi/esp32_devkitj_v1.cfg -f target/esp32.cfg &
xtensa-esp32-elf-gdb build/app.elf
(gdb) target remote localhost:3333
(gdb) thb app_main
(gdb) c

# Monitoring
idf.py monitor
# Dentro del monitor:
# Ctrl+T Ctrl+L → elegir nivel log
# Ctrl+T Ctrl+R → reset
# Ctrl+] → salir

# NVS (bonding)
idf.py erase-flash  # Limpia bonding

# Memory profiling
idf.py size-components build/app.elf
```

---

**Documento finalizado. ¡Adelante con el aprendizaje!** 📚