Sebastian Nieto
d124d013ab
- Buffer de transicion persistente (sprTrans) de 25KB asignado una sola vez en setup() para evitar fallos de memoria heap contigua - Eliminacion de carga y descarga dinamica de fuentes en renderPage2ToSprite durante las transiciones para evitar fugas de RAM - Timeout de seguridad por hardware de 250ms en waitForTouchRelease() para prevenir bloqueos por ruido en la lamina resistiva - Pantallas 2 y 3: Reloj atomico GPS con DSEG7 de 80pt y Telemetria satelital completa (rumbo, satelites, altitud, coordenadas) - Documentacion de conexion y pines para modulo GPS N32+/U-blox
180 lines
6.2 KiB
Markdown
180 lines
6.2 KiB
Markdown
# Integración Módulo GPS N32+ con Modo Reposo por Comandos UBX
|
|
## Placa ESP32-2432S028 (CYD)
|
|
|
|
Este documento detalla la conexión física, el protocolo binario para poner a dormir y despertar el módulo GPS N32+ (U-blox) mediante comandos serie, y el esquema de integración con el firmware del instrumental OBD-II.
|
|
|
|
---
|
|
|
|
## 1. Especificaciones y Pinout del Módulo N32+ GPS
|
|
|
|
|
|
|
|
* **Chipset**: U-blox 7 / NEO-7M (o compatible).
|
|
* **Protocolo de salida**: NMEA 0183 (mensajes $GPRMC, $GPGGA, $GPVTG).
|
|
* **Protocolo de configuración**: Binario U-blox (UBX).
|
|
* **Velocidad predeterminada (Baudrate)**: 9600 bps (8N1).
|
|
* **Voltaje de alimentación**: 5V (conectado a `Vin` del conector P1).
|
|
* **Nivel lógico UART**: 3.3V (compatible directo con ESP32 sin conversores).
|
|
* **Consumo activo**: ~45 a 60 mA.
|
|
* **Consumo en modo reposo (Software Standby / Backup)**: ~0.3 a 0.5 mA.
|
|
|
|
---
|
|
|
|
## 2. Esquema de Conexión Física (Bidireccional)
|
|
|
|
|
|
|
|
Para recibir datos de navegación y al mismo tiempo poder enviar comandos de suspensión y despertar, se utiliza la ficha de 4 pines del conector rotulado como **UART** (o **P1**) en la parte trasera de la placa CYD:
|
|
|
|
| Pin del GPS N32+ | Pin en Conector UART (P1) | Función | Notas |
|
|
| :--- | :--- | :--- | :--- |
|
|
| **VCC / V+EN** (Naranja) | **Pin 1** (`Vin` 5V) | Alimentación | 5V directo del regulador/USB |
|
|
| **RX** (Blanco / Amarillo) | **Pin 2** (`GPIO 1` / TX0) | TX del ESP32 | Salida serial para enviar comandos UBX de reposo |
|
|
| **TX** (Azul / Verde) | **Pin 3** (`GPIO 3` / RX0) | RX del ESP32 | Entrada serial UART0 (sentencias NMEA a 9600 bps) |
|
|
| **GND** (Verde / Negro) | **Pin 4** (`GND`) | Masa común | Retorno de corriente |
|
|
|
|
> **Programación por cable USB**:
|
|
> Dado que el conector UART comparte internamente las líneas GPIO 1 y GPIO 3 con el chip conversor USB-Serie (CH340), **desconectar la ficha de 4 pines del GPS al flashear nuevo firmware por cable USB** para evitar interferencias en la carga. Una vez completada la carga, reconectar la ficha para el funcionamiento normal.
|
|
|
|
---
|
|
|
|
## 3. Comandos Binarios UBX de Reposo y Despertar
|
|
|
|
El chip U-blox cuenta con el mensaje binario **`UBX-RXM-PMREQ`** (Class `0x02`, ID `0x41`), que ordena la desconexión inmediata de la etapa de radiofrecuencia y procesado satelital.
|
|
|
|
### A. Trama para poner a dormir al GPS (Sleep / Backup Mode)
|
|
Estructura de 16 bytes con sincronismo, encabezado, longitud, payload y checksum Fletcher:
|
|
|
|
```text
|
|
Header: 0xB5 0x62 (Sync UBX)
|
|
Class: 0x02 (RXM)
|
|
ID: 0x41 (PMREQ)
|
|
Length: 0x08 0x00 (8 bytes de payload)
|
|
Payload: 0x00 0x00 0x00 0x00 (Duración = 0: suspensión indefinida hasta despertar)
|
|
0x02 0x00 0x00 0x00 (Flags: modo Backup / Software Standby)
|
|
Checksum: 0x4D 0x3B (CK_A, CK_B)
|
|
```
|
|
|
|
**Array en C++ listo para enviar**:
|
|
```cpp
|
|
const uint8_t UBX_SLEEP_CMD[] = {
|
|
0xB5, 0x62, 0x02, 0x41, 0x08, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x00, 0x00, 0x00,
|
|
0x4D, 0x3B
|
|
};
|
|
```
|
|
|
|
### B. Secuencia para despertar al GPS (Wake-up)
|
|
U-blox admite el despertar por actividad en la línea serie (**Wake on UART**). Basta con transmitir una ráfaga corta de bytes (por ejemplo `0xFF`) para que el receptor reactive sus osciladores y vuelva al modo activo.
|
|
|
|
```cpp
|
|
void gpsWake() {
|
|
// Envío de ráfaga de pulsos para despertar el receptor U-blox
|
|
uint8_t wakeBuffer[16];
|
|
memset(wakeBuffer, 0xFF, sizeof(wakeBuffer));
|
|
gpsSerial.write(wakeBuffer, sizeof(wakeBuffer));
|
|
gpsSerial.flush();
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 4. Código Modelo para Integrar en el Firmware
|
|
|
|
```cpp
|
|
#include <HardwareSerial.h>
|
|
#include <TinyGPSPlus.h>
|
|
|
|
#define GPS_RX_PIN 3 // Conector UART Pin 3 (RX0 ESP32, entrada desde TX del GPS)
|
|
#define GPS_TX_PIN 1 // Conector UART Pin 2 (TX0 ESP32, salida hacia RX del GPS)
|
|
#define GPS_BAUDRATE 9600
|
|
|
|
#define gpsSerial Serial // Usamos UART0 por hardware nativo
|
|
TinyGPSPlus gps;
|
|
|
|
bool gpsIsSleeping = false;
|
|
|
|
// Inicialización del puerto serie para GPS
|
|
void setupGPS() {
|
|
pinMode(GPS_RX_PIN, INPUT_PULLUP);
|
|
gpsSerial.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
|
|
}
|
|
|
|
// Poner el GPS en modo reposo de ultra bajo consumo
|
|
void gpsSleep() {
|
|
if (gpsIsSleeping) return;
|
|
|
|
// Trama UBX-RXM-PMREQ para modo Backup permanente
|
|
const uint8_t ubxSleep[] = {
|
|
0xB5, 0x62, 0x02, 0x41, 0x08, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x00, 0x00, 0x00,
|
|
0x4D, 0x3B
|
|
};
|
|
|
|
gpsSerial.write(ubxSleep, sizeof(ubxSleep));
|
|
gpsSerial.flush();
|
|
gpsIsSleeping = true;
|
|
Serial.println(">>> [GPS] Modulo GPS puesto en modo reposo (Sleep).");
|
|
}
|
|
|
|
// Despertar el GPS
|
|
void gpsWake() {
|
|
if (!gpsIsSleeping) return;
|
|
|
|
// Enviar ráfaga de sincronismo en línea serie para disparar el evento Wake-on-UART
|
|
for (uint8_t i = 0; i < 32; i++) {
|
|
gpsSerial.write(0xFF);
|
|
}
|
|
gpsSerial.flush();
|
|
gpsIsSleeping = false;
|
|
Serial.println(">>> [GPS] Modulo GPS despertado.");
|
|
}
|
|
|
|
// Lectura continua en el bucle principal
|
|
void processGPS() {
|
|
if (gpsIsSleeping) return;
|
|
|
|
while (gpsSerial.available() > 0) {
|
|
gps.encode(gpsSerial.read());
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 5. Integración con el Sistema de Reposo Existente
|
|
|
|
En el archivo `sketch/obd2_gauge/config.h`:
|
|
|
|
1. **Al entrar en suspensión (`enterLightSleep`)**:
|
|
```cpp
|
|
gpsSleep(); // Apaga la etapa de radio y antena del GPS
|
|
```
|
|
|
|
2. **Al salir de la suspensión (`wokeFromSleep`)**:
|
|
```cpp
|
|
gpsWake(); // Reactiva el receptor U-blox
|
|
```
|
|
|
|
---
|
|
|
|
## 6. Funcionalidades a Implementar Posteriormente
|
|
|
|
1. **Velocidad Real vs Velocidad OBD-II**:
|
|
- Lectura: `gps.speed.kmph()`.
|
|
- Comparación directa con la velocidad reportada por la ECU (PID `010D`).
|
|
|
|
2. **Cronómetro 0 a 100 km/h (Performance Meter)**:
|
|
- Detección automática de detención (`speed == 0`).
|
|
- Disparo del cronómetro al detectar movimiento (`speed > 1.0 km/h`).
|
|
- Registro del tiempo exacto en milisegundos al cruzar los `100.0 km/h`.
|
|
|
|
3. **Hora Satelital Atómica y Fecha**:
|
|
- Lectura de `gps.time.hour()`, `gps.time.minute()`, `gps.time.second()`.
|
|
- Ajuste de huso horario (`hora - 3` para huso horario UTC-3).
|
|
|
|
4. **Altitud y Rumbo**:
|
|
- `gps.altitude.meters()` para altitud msnm.
|
|
- `gps.course.deg()` para orientación y brújula digital.
|