ESP32-S3 + ADXL335 impulsando una pantalla redonda JD9855 como panel de aceleración de 3 ejes|Por qué agitar se nota más que inclinar
Usa un ESP32-S3 + ADXL335 (GY-61) para impulsar una pantalla redonda QSPI JD9855 como panel de aceleración de 3 ejes en tiempo real. Incluye esquema de cableado, código completo de Arduino y resolución de problemas frecuentes, y explica con claridad la física del acelerómetro que hay detrás de «por qué agitar se nota más que inclinar».

Dificultad: ⭐⭐☆☆☆ (con algo de experiencia previa en Arduino basta para empezar) Tiempo estimado: 30-40 minutos (incluyendo calibración y depuración) Entorno de prueba: Arduino IDE 2.3.8 · ESP32 Arduino Core 3.3.10
TL;DR (puesta en marcha rápida):
- Conecta la pantalla (QSPI de 6 hilos) y el ADXL335 (tres entradas analógicas X/Y/Z) según la tabla de cableado
- GPIO5 / GPIO9 / GPIO10 están todos dentro del rango ADC1 del ESP32-S3, así que no tienes que preocuparte por conflictos con el Wi-Fi
- Tras dar corriente, deja el dispositivo plano y quieto para que el programa muestree y calibre el cero automáticamente (unos 1 segundo)
- Inclina lentamente o agita el dispositivo con fuerza y observa cómo reaccionan en la pantalla los tres anillos de color junto con la aguja central
Prefacio
Tras dos días de trasteo, conseguí subir los datos de tres ejes del ADXL335 en tiempo real a una pantalla redonda de 360×360. Al inclinar el dispositivo despacio, la aguja casi no se mueve; en cuanto lo agitas con fuerza, la aguja sale disparada casi media vuelta. Al principio pensé que la calibración estaba mal; tras consultar varias fuentes me di cuenta de que, por su principio físico, esto no es un «inclinómetro» puro: mide aceleración, y cuanto más fuerte agites, más exagerada será la lectura. Es así por diseño, no es un bug. También descubrí que mi placa de desarrollo ESP32-S3 casera no aguanta bien la alimentación: al conectar el sensor y la pantalla hay momentos en los que la pantalla se oscurece claramente. Parece que tendré que actualizar mi placa de desarrollo ESP32-S3.
Así que además del cableado completo, el código y el registro de tropiezos, este artículo quiere dejar clara la razón de «por qué agitar se nota más que inclinar», para que no acabes dudando de ti mismo cuando reproduzcas el experimento.
Resultado del experimento
Esta pantalla redonda de 360×360 muestra en tiempo real los datos de aceleración de 3 ejes del ADXL335 (ojo, es aceleración, no un ángulo de actitud puro): los tres anillos exterores rojo / verde / azul corresponden a los ejes X / Y / Z respectivamente, y la aguja de colores central apunta a la dirección de la fuerza resultante. Cuanto más fuerte agites, más exagerado será el balanceo de la aguja; además, el borde tiene un efecto de luz «respiratoria» como decoración.

Descripción de los componentes
La placa de desarrollo ESP32-S3 no necesita presentación; si estás leyendo este artículo es que ya has usado un ESP32. Aquí solo hablo de los otros dos componentes centrales.
Acelerómetro ADXL335 (módulo GY-61)
Lo que hace el ADXL335 se parece un poco a una báscula de baño: no sabe si «estás derecho o torcido», solo sabe qué fuerza está recibiendo en este momento, y descompone esa fuerza en tres componentes X/Y/Z para ti. Es un acelerómetro MEMS de 3 ejes con salida analógica, encargado de convertir la fuerza resultante que recibe el dispositivo (componente de gravedad + aceleración generada por el movimiento) en tres señales de voltaje.
| Parámetro | Valor |
|---|---|
| Tipo | Acelerómetro MEMS de 3 ejes con salida analógica |
| Rango | ±3.6g (típico) / ±3g (mínimo garantizado) |
| Sensibilidad | 300 mV/g (valor típico con VS = 3V, proporcional a la alimentación) |
| Tensión de trabajo | 1.8V ~ 3.6V |
| Ancho de banda (por defecto del módulo GY-61) | aprox. 50Hz (determinado por el condensador de filtrado de 0.1μF de la placa) |
| Densidad de ruido | X/Y aprox. 270 µg/√Hz, Z aprox. 550 µg/√Hz (Z es aproximadamente 2× la de X/Y) |
La razón para usarlo es sencilla: es barato, su salida analógica facilita el cableado y se puede leer con cualquier pin ADC. Es ideal para proyectos pequeños de visualización; si no persigues una resolución profesional de actitud, es más que suficiente.
Descripción de pines
ADXL335 (GY-61)
| Pin del módulo | Descripción |
|---|---|
| VCC / GND | Alimentación 3.3V |
| X / Y / Z | Tres salidas analógicas, a pines ADC |
| ST | Pin de autocomprobación, normalmente sin conectar |
Pantalla redonda TK015F5785 (driver JD9855, interfaz QSPI)
Esta pantalla puede entenderse como «un lienzo que solo entiende las señales de cuatro líneas de datos»: el JD9855 es el chip driver, encargado de llevar los datos de color enviados por el MCU a cada píxel de la pantalla; la interfaz QSPI (serie de cuatro hilos) se encarga de alcanzar mayor velocidad de refresco con menos pines. Es una pantalla TFT redonda de unas 1.5 pulgadas y resolución 360×360, que se controla con cinco señales (SCLK/D0-D3/CS) más la alimentación, sin necesitar un pin DC (datos/comando) adicional.
| Parámetro | Valor |
|---|---|
| Tamaño | 1.5 pulgadas IPS redonda |
| Resolución | 360 × 360 |
| Chip driver | JD9855 |
| Interfaz | QSPI (cuatro hilos) |
| Alimentación | 3.3V |
| Brillo / contraste | Según la hoja de datos del vendedor (puede variar entre lotes) |
La razón para elegirlo es también directa: una pantalla redonda queda genial para visualizaciones tipo cuadro de mandos, la interfaz QSPI solo ocupa 5 GPIO (ahorra pines frente al puerto paralelo tradicional) y el DMA del ESP32-S3 puede moverla sin problemas.
Descripción de pines
Pantalla TK015F5785 (JD9855 QSPI)
| Pin de la pantalla | Descripción |
|---|---|
| SCLK | Reloj QSPI |
| D0 ~ D3 | Cuatro líneas de datos QSPI |
| CS | Selección de chip |
| VCC / GND | Alimentación 3.3V |
Lista de materiales (BOM)
| Componente | Modelo / parámetros | Cantidad | Precio aprox. | Uso |
|---|---|---|---|---|
| Placa principal | Placa de desarrollo ESP32-S3 | 1 | aprox. 30-50 yuanes | MCU + Wi-Fi/Bluetooth de reserva |
| Pantalla redonda | TK015F5785 (JD9855, 360×360, QSPI) | 1 | según vendedor | Visualización |
| Acelerómetro | ADXL335 (módulo GY-61) | 1 | aprox. 8-15 yuanes | Captura de aceleración de 3 ejes |
| Cables Dupont | Hembra a hembra | varios | - | Cableado |
Forma de cableado
Pantalla → ESP32-S3
| Pin de la pantalla | Pin ESP32-S3 |
|---|---|
| SCLK | GPIO6 |
| D0 | GPIO15 |
| D1 | GPIO7 |
| D2 | GPIO11 |
| D3 | GPIO12 |
| CS | GPIO16 |
| VCC | 3.3V |
| GND | GND |
ADXL335 → ESP32-S3
| Pin del módulo | Pin ESP32-S3 |
|---|---|
| VCC | 3.3V |
| GND | GND |
| X | GPIO5 (ADC1) |
| Y | GPIO9 (ADC1) |
| Z | GPIO10 (ADC1) |
Recomienda revisarlos uno por uno tras cablear; te ahorrará el 80 % del tiempo de depuración — sobre todo las cuatro líneas D0~D3 de la pantalla: si inviertes una, lo más probable es que la pantalla muestre ruido o no se encienda.
Librerías que necesitas instalar
No hace falta instalar ninguna librería de terceros. El driver de la pantalla llama directamente a las interfaces esp_lcd_panel_io y driver/spi_master incluidas en ESP-IDF para escribir a mano el driver QSPI; no necesitas buscar nada en el gestor de librerías.
Lo único a tener en cuenta respecto a versiones:
- Arduino IDE: 2.3.8 (probado OK)
- Paquete de placa ESP32 (esp32 by Espressif Systems): 3.3.10 (basado en ESP-IDF 5.x) — debe ser v3.x, porque el flag
quad_modeusado por el código y algunas interfaces DMA no siempre están completos en el núcleo v2.x anterior - Selección de placa: ESP32S3 Dev Module, con USB CDC On Boot puesto en Enabled
Código
/*
* =============================================================================
* ADXL335 + TK015F5785 pantalla redonda —— panel de aceleración de 3 ejes
* =====================================================================
*
* Escena única: panel de aceleración de 3 ejes —— muestra en tiempo real los datos de los 3 ejes + dirección de la fuerza resultante; la aguja central apunta hacia la fuerza resultante
*
* Hardware: ESP32-S3 + TK015F5785 (JD9855 QSPI) + ADXL335 (GY-61)
*
* ┌─────────────────────────────────────────────────────────────────────┐
* │ Esquema de cableado │
* ├─────────────────────────────────────────────────────────────────────┤
* │ 【Pantalla TK015F5785】 │ 【ADXL335 (GY-61)】 │
* │ SCLK → GPIO6 │ VCC → 3.3V │
* │ D0 → GPIO15 │ GND → GND │
* │ D1 → GPIO7 │ X → GPIO5 (ADC) │
* │ D2 → GPIO11 │ Y → GPIO9 (ADC) │
* │ D3 → GPIO12 │ Z → GPIO10 (ADC) │
* │ CS → GPIO16 │ │
* │ VCC → 3.3V │ │
* │ GND → GND │ │
* └─────────────────────────────────────────────────────────────────────┘
*
* Dependencias: solo el núcleo de placa esp32 v3.x de Arduino IDE
* Subida: Placa=ESP32S3 Dev Module, USB CDC On Boot=Enabled
* =============================================================================
*/
#include <Arduino.h>
#include <math.h>
#include <initializer_list>
#include "driver/spi_master.h"
#include "esp_lcd_panel_io.h"
#include "esp_heap_caps.h"
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
/* ----------------------------- Configuración de pines ----------------------------- */
// Pines de la pantalla
#define PIN_LCD_SCLK 6
#define PIN_LCD_D0 15
#define PIN_LCD_D1 7
#define PIN_LCD_D2 11
#define PIN_LCD_D3 12
#define PIN_LCD_CS 16
#define PIN_LCD_BL -1
// Pines del ADXL335 (entradas analógicas)
#define PIN_ACCEL_X 5
#define PIN_ACCEL_Y 9
#define PIN_ACCEL_Z 10
/* =====================================================================
* Clase de driver para pantalla JD9855 QSPI
* ===================================================================== */
#define JD9855_SWRESET 0x01
#define JD9855_CASET 0x2A
#define JD9855_RASET 0x2B
#define JD9855_RAMWR 0x2C
#define JD9855_MADCTL 0x36
#define JD9855_COLMOD 0x3A
#define JD9855_SLPOUT 0x11
#define JD9855_DISPON 0x29
class JD9855_QSPI {
public:
static constexpr int H_RES = 360;
static constexpr int V_RES = 360;
static uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
return ((uint16_t)(r & 0xF8) << 8) | ((uint16_t)(g & 0xFC) << 3) | (b >> 3);
}
bool begin(int sclk, int d0, int d1, int d2, int d3, int cs, int backlight = -1) {
if (backlight >= 0) { pinMode(backlight, OUTPUT); digitalWrite(backlight, HIGH); }
spi_bus_config_t buscfg = {};
buscfg.sclk_io_num = sclk;
buscfg.data0_io_num = d0;
buscfg.data1_io_num = d1;
buscfg.data2_io_num = d2;
buscfg.data3_io_num = d3;
buscfg.max_transfer_sz = H_RES * V_RES * 2;
esp_err_t ret = spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
if (ret != ESP_OK) { log_e("spi_bus_initialize: %s", esp_err_to_name(ret)); return false; }
esp_lcd_panel_io_spi_config_t io_config = {};
io_config.cs_gpio_num = cs;
io_config.dc_gpio_num = -1;
io_config.spi_mode = 3;
io_config.pclk_hz = 20 * 1000 * 1000; // El cableado no aguanta 40MHz; bajamos a 20MHz estable
io_config.trans_queue_depth = 10;
io_config.lcd_cmd_bits = 32;
io_config.lcd_param_bits = 8;
io_config.flags.quad_mode = true;
ret = esp_lcd_new_panel_io_spi(SPI2_HOST, &io_config, &io);
if (ret != ESP_OK) { log_e("esp_lcd_new_panel_io_spi: %s", esp_err_to_name(ret)); return false; }
sendCmd(JD9855_SWRESET);
delay(20);
sendInitCommands();
return true;
}
void pushRect(int x, int y, int w, int h, const uint16_t *data) {
if (w <= 0 || h <= 0) return;
setAddrWindow(x, y, x + w - 1, y + h - 1);
size_t n = (size_t)w * h;
ensureDmaBuf(n * 2);
for (size_t i = 0; i < n; i++) {
uint16_t c = data[i];
dma_buf[i * 2] = c >> 8;
dma_buf[i * 2 + 1] = c & 0xFF;
}
sendColor(JD9855_RAMWR, dma_buf, n * 2);
}
void fillScreen(uint16_t color) {
uint8_t hi = color >> 8, lo = color & 0xFF;
const int BUF_PIX = H_RES;
ensureDmaBuf(BUF_PIX * 2);
for (int i = 0; i < BUF_PIX; i++) { dma_buf[i*2] = hi; dma_buf[i*2+1] = lo; }
for (int y = 0; y < V_RES; y++) {
setAddrWindow(0, y, H_RES - 1, y);
sendColor(JD9855_RAMWR, dma_buf, BUF_PIX * 2);
}
}
private:
esp_lcd_panel_io_handle_t io = nullptr;
uint8_t *dma_buf = nullptr;
size_t dma_buf_size = 0;
void ensureDmaBuf(size_t need) {
if (dma_buf_size >= need) return;
if (dma_buf) free(dma_buf);
dma_buf = (uint8_t *)heap_caps_malloc(need, MALLOC_CAP_DMA);
if (!dma_buf) dma_buf = (uint8_t *)heap_caps_malloc(need, MALLOC_CAP_8BIT);
dma_buf_size = need;
}
void setAddrWindow(int x0, int y0, int x1, int y1) {
uint8_t caset[4] = { (uint8_t)(x0>>8),(uint8_t)(x0&0xFF),(uint8_t)(x1>>8),(uint8_t)(x1&0xFF) };
uint8_t raset[4] = { (uint8_t)(y0>>8),(uint8_t)(y0&0xFF),(uint8_t)(y1>>8),(uint8_t)(y1&0xFF) };
sendCmd(JD9855_CASET, caset, 4);
sendCmd(JD9855_RASET, raset, 4);
}
void sendCmd(uint8_t cmd, const uint8_t *data = nullptr, size_t len = 0) {
uint32_t c = ((uint32_t)cmd << 8) | (0x02UL << 24);
esp_lcd_panel_io_tx_param(io, c, data, len);
}
void sendCmd(uint8_t cmd, std::initializer_list<uint8_t> data) {
sendCmd(cmd, data.begin(), data.size());
}
void sendColor(uint8_t cmd, const uint8_t *data, size_t len) {
uint32_t c = ((uint32_t)cmd << 8) | (0x32UL << 24);
esp_lcd_panel_io_tx_color(io, c, data, len);
}
void sendInitCommands() {
sendCmd(0xFF, {0x20, 0x10, 0x00});
sendCmd(JD9855_MADCTL, {0x00});
sendCmd(JD9855_COLMOD, {0x55});
sendCmd(0xDE, {0x00});
sendCmd(0xDF, {0x98, 0x55});
sendCmd(0xCE, {0x0D, 0x00});
sendCmd(0xD8, {0x08, 0x00});
sendCmd(0xB2, {0x30});
sendCmd(0xB7, {0x01, 0x35, 0x01, 0x5D});
sendCmd(0xBB, {0x1B, 0x64, 0xE3, 0x34, 0x3E, 0xF3});
sendCmd(0xBC, {0x00, 0x1A, 0xF3, 0xC0});
sendCmd(0xC0, {0x22, 0xC1});
sendCmd(0xC3, {0x00, 0x01, 0x8D, 0x0B, 0x08, 0x48, 0x07, 0x04, 0x62, 0x30, 0x30});
sendCmd(0xC4, {0x40, 0x00, 0xAD, 0x68, 0x37, 0x07, 0x04, 0x16, 0x43, 0x07, 0x04});
sendCmd(0xC8, {0x3F, 0x2D, 0x22, 0x1D, 0x1D, 0x1F, 0x1B, 0x1C, 0x1B, 0x1B, 0x17, 0x0D, 0x09, 0x05, 0x01, 0x02});
sendCmd(0xC8, {0x3F, 0x2D, 0x22, 0x1D, 0x1D, 0x1F, 0x1B, 0x1C, 0x1B, 0x1B, 0x17, 0x0D, 0x09, 0x05, 0x01, 0x02});
sendCmd(0xD3, {0x28, 0x13});
sendCmd(0xD9, {0x00, 0x00, 0xFF, 0x00, 0xF0, 0x00});
sendCmd(0xDE, {0x01});
sendCmd(0xB7, {0x17, 0xA7, 0x64, 0x3B, 0x06, 0x36, 0x18, 0x18});
sendCmd(0xBE, {0x00});
sendCmd(0xC1, {0x04, 0x40, 0x90, 0x08});
sendCmd(0xC2, {0x00, 0x16, 0xDA, 0xE7});
sendCmd(0xC4, {0x72, 0x12});
sendCmd(0xC7, {0x00, 0x00, 0x02, 0x32, 0x10, 0x32});
sendCmd(0xC8, {0x00, 0x00, 0x0B, 0x32, 0x12, 0x2E});
sendCmd(0xC9, {0x00, 0x0A, 0x08, 0x06, 0x04});
sendCmd(0xCA, {0x1E, 0x1F, 0x10, 0x17, 0x18});
sendCmd(0xCB, {0x01, 0x0B, 0x09, 0x07, 0x05});
sendCmd(0xCC, {0x1E, 0x1F, 0x11, 0x17, 0x18});
sendCmd(0xCD, {0x31, 0x25, 0x27, 0x29, 0x2B});
sendCmd(0xCE, {0x3F, 0x3E, 0x21, 0x37, 0x38});
sendCmd(0xCF, {0x30, 0x24, 0x26, 0x28, 0x2A});
sendCmd(0xD0, {0x3F, 0x3E, 0x20, 0x37, 0x38});
sendCmd(0xD1, {0x06, 0x30, 0xA5, 0xDB, 0x30});
sendCmd(0xD3, {0x3B, 0x08, 0x00, 0x00, 0x00, 0x00});
sendCmd(0xD4, {0x67, 0x00, 0x00, 0x01, 0x00, 0x01});
sendCmd(0xD5, {0x10, 0x10, 0x07, 0x07, 0x0F, 0x94, 0x26});
sendCmd(0xD6, {0x00, 0x00, 0x40});
sendCmd(0xD7, {0x01, 0x84, 0x20});
sendCmd(0xDE, {0x02});
sendCmd(0xB6, {0x1C});
sendCmd(0xDE, {0x00});
sendCmd(0x2A, {0x00, 0x00, 0x01, 0x67});
sendCmd(0x2B, {0x00, 0x00, 0x01, 0x67});
sendCmd(0x35);
sendCmd(0x36, {0x00});
sendCmd(0x3A, {0x55});
sendCmd(0xDE, {0x00});
sendCmd(0x11);
delay(120);
sendCmd(0x29);
delay(10);
}
};
/* =====================================================================
* Variables globales
* ===================================================================== */
JD9855_QSPI lcd;
static constexpr int W = JD9855_QSPI::H_RES; // 360
static constexpr int H = JD9855_QSPI::V_RES; // 360
static constexpr int CX = W / 2; // Centro x = 180
static constexpr int CY = H / 2; // Centro y = 180
static constexpr int RADIUS = 180;
static constexpr int R2MAX = RADIUS * RADIUS;
static const int BLOCK_H = 40;
uint16_t blockBuf[W * BLOCK_H];
// Tabla de ángulos por píxel relativos al centro (atan2 precalculado en 0-255), para no llamar atan2f píxel a píxel al renderizar
uint8_t *angleTab = nullptr;
// Datos del acelerómetro (tras filtrado)
float accelX = 0, accelY = 0, accelZ = 0;
// Valor central bruto del acelerómetro (valor ADC en reposo, necesita calibración)
int accelXCenter = 2048, accelYCenter = 2048, accelZCenter = 2730;
// Definiciones de color
uint16_t COLOR_BLACK;
uint16_t COLOR_WHITE;
uint16_t COLOR_LIGHT_GRAY;
/* =====================================================================
* Funciones de utilidad
* ===================================================================== */
uint16_t hsvTo565(int h, uint8_t s, uint8_t v) {
uint8_t region = h / 60;
uint8_t rem = (h - region * 60) * 255 / 60;
uint8_t p = (uint16_t)v * (255 - s) / 255;
uint8_t q = (uint16_t)v * (255 - (uint16_t)s * rem / 255) / 255;
uint8_t t = (uint16_t)v * (255 - (uint16_t)s * (255 - rem) / 255) / 255;
uint8_t r, g, b;
switch (region) {
case 0: r = v; g = t; b = p; break;
case 1: r = q; g = v; b = p; break;
case 2: r = p; g = v; b = t; break;
case 3: r = p; g = q; b = v; break;
case 4: r = t; g = p; b = v; break;
default: r = v; g = p; b = q; break;
}
return JD9855_QSPI::color565(r, g, b);
}
void initColors() {
COLOR_BLACK = JD9855_QSPI::color565(0, 0, 0);
COLOR_WHITE = JD9855_QSPI::color565(255, 255, 255);
COLOR_LIGHT_GRAY = JD9855_QSPI::color565(100, 100, 110);
}
/* =====================================================================
* Lectura y filtrado del acelerómetro
* ===================================================================== */
void readAccelerometer() {
// Lectura de valores ADC en bruto (ESP32-S3 ADC de 12 bits, 0-4095)
int rawX = analogRead(PIN_ACCEL_X);
int rawY = analogRead(PIN_ACCEL_Y);
int rawZ = analogRead(PIN_ACCEL_Z);
// Conversión a valor normalizado de -1.0 a 1.0
// ADXL335 con alimentación de 3.3V: unos 330mV por g, centro aprox. 1.65V
// ADC 3.3V = 4095, por tanto ~409 unidades ADC por g
float newX = (rawX - accelXCenter) / 409.0f;
float newY = (rawY - accelYCenter) / 409.0f;
float newZ = (rawZ - accelZCenter) / 409.0f;
// Limitación
newX = constrain(newX, -1.5f, 1.5f);
newY = constrain(newY, -1.5f, 1.5f);
newZ = constrain(newZ, -1.5f, 1.5f);
// Filtro paso bajo (suavizado)
const float alpha = 0.3f;
accelX = accelX * (1 - alpha) + newX * alpha;
accelY = accelY * (1 - alpha) + newY * alpha;
accelZ = accelZ * (1 - alpha) + newZ * alpha;
}
/* Precalcula el ángulo (atan2) de cada píxel relativo al centro y lo guarda en una tabla 0-255.
En runtime, cada píxel solo consulta la tabla y convierte a radianes, sin llamar atan2f en cada frame — eso era el culpable del parón original.
Se calcula una sola vez en setup. Prioridad RAM interna (~126KB); si no cabe, cae a PSRAM;
si tampoco hay, se deja nullptr y el render regresa a atan2f (sigue funcionando, solo más lento). */
void buildAngleTable() {
size_t n = (size_t)W * H;
angleTab = (uint8_t *)heap_caps_malloc(n, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
if (!angleTab) angleTab = (uint8_t *)heap_caps_malloc(n, MALLOC_CAP_SPIRAM);
if (!angleTab) { Serial.println(F("[WARN] angleTab: asignación fallida, el render será más lento")); return; }
for (int y = 0; y < H; y++) {
for (int x = 0; x < W; x++) {
float dx = (float)(x - CX), dy = (float)(y - CY);
float a = atan2f(dy, dx) / (2.0f * (float)M_PI); // -0.5..0.5
angleTab[y * W + x] = (uint8_t)(a * 256.0f);
}
}
Serial.printf("[INIT] Tabla de ángulos %d KB lista\n", (int)(n / 1024));
}
/* =====================================================================
* Escena: panel de aceleración de 3 ejes
* Muestra datos en tiempo real de los 3 ejes, con aguja dinámica y valores
* ===================================================================== */
void renderGaugeScene() {
// ---- Constantes por frame (sacadas del bucle, para no recalcularlas por píxel) ----
int t = millis() / 50;
float breathe = (sinf(t * 0.1f) + 1) / 2;
float tiltAngle = atan2f(accelY, accelX);
float tiltMag = sqrtf(accelX * accelX + accelY * accelY);
tiltMag = min(1.0f, tiltMag);
float xAngle = accelX * M_PI / 2;
float yAngle = -M_PI / 2 + accelY * M_PI / 2;
float zVal = (accelZ + 1) / 2;
float fillAngle = -M_PI + zVal * 2 * M_PI;
const float A8SCALE = M_PI / 128.0f; // Tabla de ángulos (0-255) -> radianes
// Los umbrales de radio usan r^2 (comparación entera) para evitar sqrtf por píxel — solo la pequeña aguja central necesita float r
const int R2_TICK_LO = 160 * 160, R2_TICK_HI = 175 * 175;
const int R2_X_LO = 135 * 135, R2_X_HI = 155 * 155;
const int R2_Y_LO = 95 * 95, R2_Y_HI = 115 * 115;
const int R2_Z_LO = 55 * 55, R2_Z_HI = 75 * 75;
const int R2_NDL_LO = 5 * 5, R2_NDL_HI = 50 * 50;
const int R2_BR_LO = 175 * 175, R2_BR_HI = 180 * 180;
const int R2_145_LO = 145 * 145, R2_145_HI = 146 * 146;
const int R2_105_LO = 105 * 105, R2_105_HI = 106 * 106;
const int R2_65_LO = 65 * 65, R2_65_HI = 66 * 66;
const int R2_165 = 165 * 165;
for (int by = 0; by < H; by += BLOCK_H) {
int bh = min(BLOCK_H, H - by);
for (int y = 0; y < bh; y++) {
int yy = by + y;
const uint8_t *angRow = angleTab ? &angleTab[yy * W] : nullptr; // Puntero a inicio de fila, una vez por fila
for (int x = 0; x < W; x++) {
int dx = x - CX, dy = yy - CY;
int r2 = dx * dx + dy * dy;
if (r2 > R2MAX) {
blockBuf[y * W + x] = COLOR_BLACK;
continue;
}
float angle = angRow ? ((int8_t)angRow[x] * A8SCALE)
: atan2f((float)dy, (float)dx);
// Fondo oscuro
uint16_t color = JD9855_QSPI::color565(15, 20, 30);
// Marcas exteriores
if (r2 > R2_TICK_LO && r2 < R2_TICK_HI) {
int deg = (int)((angle + M_PI) * 180 / M_PI) % 30;
if (deg < 3 || (r2 > R2_165 && deg % 10 < 2)) {
color = COLOR_LIGHT_GRAY;
}
}
// Eje X (anillo exterior, rojo)
if (r2 > R2_X_LO && r2 < R2_X_HI) {
float angleDiff = fabsf(angle - xAngle);
if (angleDiff > M_PI) angleDiff = 2 * M_PI - angleDiff;
if (angleDiff < 0.3f) {
float tt = 1 - angleDiff / 0.3f;
color = JD9855_QSPI::color565(100 + tt * 155, 30, 30);
} else if (r2 >= R2_145_LO && r2 < R2_145_HI) {
color = JD9855_QSPI::color565(60, 20, 20);
}
}
// Eje Y (anillo medio, verde)
if (r2 > R2_Y_LO && r2 < R2_Y_HI) {
float angleDiff = fabsf(angle - yAngle);
if (angleDiff > M_PI) angleDiff = 2 * M_PI - angleDiff;
if (angleDiff < 0.3f) {
float tt = 1 - angleDiff / 0.3f;
color = JD9855_QSPI::color565(30, 100 + tt * 155, 30);
} else if (r2 >= R2_105_LO && r2 < R2_105_HI) {
color = JD9855_QSPI::color565(20, 60, 20);
}
}
// Eje Z (anillo interior, azul)
if (r2 > R2_Z_LO && r2 < R2_Z_HI) {
if (angle < fillAngle || angle < -M_PI + 0.1) {
color = JD9855_QSPI::color565(30, 80, 200);
} else if (r2 >= R2_65_LO && r2 < R2_65_HI) {
color = JD9855_QSPI::color565(20, 30, 80);
}
}
// Aguja central (apunta a la dirección de la fuerza resultante) —— solo aquí hace falta float r
if (r2 > R2_NDL_LO && r2 < R2_NDL_HI) {
float r = sqrtf((float)r2);
float angleDiff = fabsf(angle - tiltAngle);
if (angleDiff > M_PI) angleDiff = 2 * M_PI - angleDiff;
float needleWidth = 0.15f * (1 - r / 50);
if (angleDiff < needleWidth && r < 45 * tiltMag + 10) {
int hue = (int)(tiltAngle * 180 / M_PI + 180) % 360;
color = hsvTo565(hue, 200, 255);
}
}
// Punto central
if (r2 < 64) {
color = COLOR_WHITE;
}
// Decoración de luz respiratoria (breathe ya calculado fuera del bucle)
if (r2 > R2_BR_LO && r2 < R2_BR_HI) {
int hue = ((int)(angle * 180 / M_PI) + t * 2) % 360;
color = hsvTo565(hue, 255, 100 + breathe * 100);
}
blockBuf[y * W + x] = color;
}
}
lcd.pushRect(0, by, W, bh, blockBuf);
}
}
/* =====================================================================
* Programa principal
* ===================================================================== */
void setup() {
Serial.begin(115200);
delay(200);
Serial.println();
Serial.println(F("[ADXL335 + TK015F5785] panel de aceleración de 3 ejes"));
// Inicializar colores
initColors();
// Inicializar ADC (ESP32-S3)
analogReadResolution(12);
analogSetAttenuation(ADC_11db); // Rango 0-3.3V
pinMode(PIN_ACCEL_X, INPUT);
pinMode(PIN_ACCEL_Y, INPUT);
pinMode(PIN_ACCEL_Z, INPUT);
// Calibración: leer el valor central en estado de reposo
Serial.println(F("[ACCEL] Calibrando, mantén el dispositivo plano y quieto..."));
delay(500);
long sumX = 0, sumY = 0, sumZ = 0;
for (int i = 0; i < 100; i++) {
sumX += analogRead(PIN_ACCEL_X);
sumY += analogRead(PIN_ACCEL_Y);
sumZ += analogRead(PIN_ACCEL_Z);
delay(10);
}
accelXCenter = sumX / 100;
accelYCenter = sumY / 100;
accelZCenter = sumZ / 100 - 409; // El eje Z en reposo es aprox. 1g; restamos el offset de 1g
Serial.printf("[ACCEL] Calibración completa: X=%d, Y=%d, Z=%d\n", accelXCenter, accelYCenter, accelZCenter);
// Inicializar la pantalla
Serial.println(F("[LCD] Inicializando..."));
bool ok = lcd.begin(PIN_LCD_SCLK, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2,
PIN_LCD_D3, PIN_LCD_CS, PIN_LCD_BL);
if (!ok) {
Serial.println(F("[LCD] Inicialización fallida!"));
while (true) { delay(1000); }
}
Serial.println(F("[LCD] Inicialización correcta"));
buildAngleTable(); // Precalcula el ángulo por píxel para que el render del panel no tiemble
lcd.fillScreen(COLOR_BLACK);
Serial.println(F("[DEMO] Panel de aceleración de 3 ejes"));
}
void loop() {
// Leer el acelerómetro
readAccelerometer();
// Renderizar el panel
renderGaugeScene();
// Imprimir información de depuración (una vez por segundo)
static uint32_t lastPrint = 0;
if (millis() - lastPrint > 1000) {
lastPrint = millis();
Serial.printf("X=%.2f Y=%.2f Z=%.2f\n", accelX, accelY, accelZ);
}
}
Explicación del código
- Parte del driver de la pantalla: la clase
JD9855_QSPIllama directamente a la interfazesp_lcd_panel_io_spide ESP-IDF para escribir el driver a mano, sin depender de ninguna librería gráfica de terceros.pclk_hzse bajó a propósito de los habituales 40MHz a 20MHz porque, cuando el cableado es largo, 40MHz tiende a producir ruido en pantalla. Es el valor estable tras probar y tropezar; si tu cableado es corto y la calidad del cable de la pantalla es buena, puedes intentar subirlo. - Tabla de ángulos
buildAngleTable(): es la clave de rendimiento de todo el render. Primero, ensetup(), precalcula el ángulo de cada píxel de 360×360 relativo al centro, lo comprime y guarda en una tabla de un byte (0-255); segundo, al renderizar, cada píxel solo hace una consulta a la matriz, sin llamar al lentoatan2f()por píxel. Esta optimización decide directamente si el refresco del panel es fluido o no. readAccelerometer()lectura y filtrado: primero lee el valor ADC en bruto; segundo convierte el voltaje a un valor normalizado -1~1 con el factor de 409 counts/g (este factor viene de la sensibilidad típica de 300mV/g del ADXL335 × el valor teórico de fondo de escala de 3.3V del ADC de 12 bits del ESP32-S3; en la práctica se recomienda ajustarlo a tu propio módulo); tercero aplica un filtro paso bajo de primer orden (alpha = 0.3) para suavizar los picos.- Por qué «agitar» se nota más que «inclinar» y dónde se ve en el código: la línea
xAngle = accelX * M_PI / 2mapea linealmente los ±1g de accelX a ±90°. Al inclinar despacio, el límite teórico de accelX es ±1g, que corresponde exactamente a ±90°; pero al agitar, la aceleración inercial se suma a la gravedad y la lectura real de accelX supera a menudo ±1, siendo limitada porconstrain()a ±1.5g, así que el ángulo mapeado se balancea mucho más violentamente que con una inclinación lenta — no es un problema de la lógica de dibujo, lo decide la física del acelerómetro. - Render del eje Z:
zValmapea accelZ de -11 a 01 y luego lo convierte en un ángulo de rellenofillAngle; en el fondo muestra el valor del eje Z en forma de «anillo de progreso»; si observas que este anillo tiembla ligeramente todo el tiempo, es normal (más abajo, en las FAQ, se explica).
Resolución de problemas frecuentes
No te asustes: el 80 % de los problemas vienen de estos sitios:
- La pantalla no se enciende o muestra ruido: primero comprueba si las cuatro líneas de datos D0~D3 del QSPI están invertidas; luego confirma que CS/SCLK van cada una a su pin correcto de forma independiente; por último verifica que la alimentación de la pantalla esté estable en 3.3V (también ripple alto en la alimentación produce ruido en pantalla).
- La lectura del ADXL335 se queda atascada cerca de 2048 sin moverse: comprueba si lo has conectado a un pin ADC que no funciona, o si la alimentación del módulo itself es anómala; los GPIO5/9/10 usados en este proyecto están todos dentro del rango ADC1 del ESP32-S3, así que no se ven afectados por el uso de ADC2 por parte del Wi-Fi; puedes descartar esa posibilidad.
- El valor del eje Z no deja de saltar: es una característica de diseño original del ADXL335; la densidad de ruido del eje Z es inherentemente más alta que la de los ejes X/Y, no es un problema de cableado ni de código. Puedes aliviarlo bajando el coeficiente de filtrado
alpha(por ejemplo de 0.3 a 0.1), o haciendo múltiples muestras y promediando en el código (sobremuestreo). - Al inclinar despacio no reacciona, solo al agitar: es la naturaleza física del acelerómetro — mide la «fuerza resultante», no un ángulo de actitud puro. Solo combinándolo con un giroscopio y haciendo fusión de sensores se obtiene una salida de actitud estable y no afectada por el movimiento.
- Error de compilación: no se encuentra
esp_lcd_panel_io.h: revisa la versión del paquete de placa ESP32 en Arduino IDE; debe ser v3.x (basado en ESP-IDF 5.x); el núcleo antiguo no tiene estas interfaces. - El valor central está claramente desplazado tras calibrar: durante la fase de calibración el dispositivo no estaba plano o estaba en movimiento; se recomienda ponerlo sobre una mesa horizontal antes de darle corriente y, durante ese segundo de calibración, evitar tocarlo.
Preguntas frecuentes (FAQ)
P: ¿El ADXL335 mide inclinación o movimiento? R: Estrictamente, mide «fuerza específica» (la composición de componente gravitatoria + aceleración de movimiento), no puede separar las dos. Una inclinación lenta y continua solo cambia la componente de gravedad en ±1g como máximo, mientras que agitar añade la aceleración de movimiento, con una amplitud que a menudo supera ±1g, por lo que visualmente «agitar» se nota mucho más que «inclinar despacio». Para obtener un ángulo de actitud puro hace falta pasar a una IMU de 6 ejes con giroscopio (p. ej. MPU6050) y hacer fusión de sensores.
P: ¿Por qué la lectura del eje Z no para de saltar, mientras que X/Y son relativamente estables? R: Es una característica de diseño original del ADXL335 — la hoja de datos indica que la densidad de ruido de salida del eje Z es aproximadamente el doble que la de los ejes X/Y, no es un problema de cableado ni de código. Se puede mitigar aumentando el filtro paso bajo o añadiendo sobremuestreo del ADC, pero no eliminarlo del todo.
P: ¿Qué tan rápido puede medir el módulo GY-61? R: El condensador de filtrado integrado de 0.1μF limita el ancho de banda de cada eje a unos 50Hz, suficiente para agitaciones e inclinaciones cotidianas; si necesitas medir vibraciones de mayor frecuencia, tendrás que cambiar a un condensador de filtrado de menor capacidad.
P: ¿Usar GPIO5/9/10 del ESP32-S3 como ADC entra en conflicto con el Wi-Fi?
R: No. Estos tres pines están dentro del rango ADC1 del ESP32-S3 (GPIO110); solo el ADC2 (GPIO1120) se ve restringido cuando el Wi-Fi está activo. En este proyecto no tienes que preocuparte por ese problema.
P: ¿Por qué hay que mantener el dispositivo plano y quieto al calibrar? R: Tras dar corriente, el código muestrea 100 veces seguidas y promedia, usando esa media como punto de referencia de «0g». Si durante la calibración el dispositivo está torcido o en movimiento, el punto de referencia se desviará y todas las conversiones posteriores se arrastrarán con ese desfase.
P: ¿Hace falta instalar alguna librería de terceros adicional para este código?
R: No. El driver de la pantalla llama directamente a las interfaces esp_lcd_panel_io y spi_master incluidas en ESP-IDF, escritas a mano; siempre que el paquete de placa ESP32 en Arduino IDE sea v3.x es suficiente, no hace falta instalar nada desde el gestor de librerías.
Ideas para seguir experimentando
- Añade una IMU de 6 ejes (por ejemplo MPU6050) y haz fusión de sensores para obtener un panel de actitud verdaderamente estable y no afectado por sacudidas
- Extrae por separado la «intensidad de agitación» y construye un sencillo «detector de impactos» que cambie de color o avise al superar un umbral
- Conecta un zumbador o un LED RGB que avise al superar un ángulo determinado, como un nivel de burbuja casero
- Registra los datos de movimiento en una tarjeta SD y expórtalos después para dibujar curvas y revisarlos