TeslaMate en Homelab: Telemetría Completa con Docker, Grafana y n8n (Guía Completa 2025)

🎯 TL;DR (Resumen Ejecutivo)

TeslaMate es un sistema de telemetría self-hosted escrito en Elixir que registra todos los datos de tu Tesla en tiempo real sin consumo vampírico adicional. Se integra con PostgreSQL para almacenar datos, Grafana para visualización, MQTT para automatizaciones, y n8n para workflows avanzados.

¿Qué aprenderás?

Instalar TeslaMate completo con Docker Compose en tu homelab
Configurar 19 dashboards de Grafana para análisis profundo
Integrar con Home Assistant y n8n via MQTT
Optimizar para evitar consumo de batería (vampire drain)
Monitorizar degradación de batería, eficiencia, costes de carga
Crear geo-fencing y localizaciones personalizadas
Importar datos históricos desde TeslaFi

⏱️ Tiempo lectura: 18 minutos

📦 Complejidad: Intermedia (requiere conocimientos básicos de Docker)

🔧 Requisitos: Homelab con Docker, Tesla con API access, 2GB RAM mínimo

—

—

¿Qué es TeslaMate y por qué usarlo?

TeslaMate es un data logger self-hosted de código abierto creado por Adrian Kumpf que registra todos los datos de telemetría de tu Tesla con precisión milimétrica. A diferencia de servicios cloud como TeslaFi (que cuestan $5-8/mes), TeslaMate es completamente gratuito y tus datos quedan 100% bajo tu control.

Características principales

Alta precisión: Registro de datos cada 1-5 segundos durante la conducción
Cero vampire drain: El coche entra en modo sleep automáticamente
Lookup automático de direcciones: Geocoding inverso de ubicaciones
Multi-vehículo: Soporta múltiples Teslas en la misma cuenta
Tracking de costes: Calcula el coste real de cada carga
Geo-fencing: Crea ubicaciones personalizadas (casa, trabajo, supercargadores)
Importación de datos: Migra desde TeslaFi o tesla-apiscraper
Integración Home Assistant: Publica datos via MQTT en tiempo real
Open source: Licencia MIT, código auditable

¿Por qué TeslaMate vs servicios cloud?

Característica	TeslaMate	TeslaFi	Teslascope
Coste	✅ Gratis (self-hosted)	❌ $5-8/mes	❌ $4-7/mes
Privacidad	✅ Tus datos, tu servidor	❌ Cloud de terceros	❌ Cloud de terceros
Personalización	✅ Código abierto	❌ Limitado	❌ Limitado
Grafana	✅ 19 dashboards incluidos	❌ Dashboards propietarios	❌ UI propia
MQTT	✅ Broker local	❌ No soportado	❌ No soportado
Integraciones	✅ Home Assistant, n8n, Node-RED	⚠️ Webhooks limitados	⚠️ API limitada
Latencia	✅ Local (<10ms)	⚠️ 500-2000ms	⚠️ 500-2000ms

—

Arquitectura del sistema

TeslaMate utiliza una arquitectura de microservicios basada en Docker:

┌──────────────────────────────────────────────────────────┐
│                      TESLA API                           │
│            (Streaming de telemetría)                     │
└────────────────┬─────────────────────────────────────────┘
                 │
                 ▼
┌────────────────────────────────────────────────────────────┐
│                   TeslaMate                                │
│              (Elixir + Phoenix)                            │
│   - Autenticación Tesla OAuth                              │
│   - Sleep logic (vampire drain prevention)                 │
│   - Geocoding (OpenStreetMap)                              │
│   - Web UI (puerto 4000)                                   │
└─────┬───────────────────────────┬──────────────────────────┘
      │                           │
      ▼                           ▼
┌────────────────┐       ┌────────────────────────┐
│  PostgreSQL    │       │    Mosquitto MQTT      │
│                │       │    (puerto 1883)       │
│  - Timeseries  │       │                        │
│  - Geo data    │       │  Topics publicados:    │
│  - Stats       │       │  teslamate/cars/1/*    │
└────────┬───────┘       └────────┬───────────────┘
         │                        │
         │                        ├──────────┐
         ▼                        ▼          ▼
┌────────────────┐       ┌─────────────┐  ┌──────────────┐
│     Grafana    │       │ Home        │  │     n8n      │
│  (puerto 3000) │       │ Assistant   │  │ (workflows)  │
│                │       │             │  │              │
│  19 dashboards │       │  Entities:  │  │  - Alertas   │
│  - Battery     │       │  - location │  │  - Telegram  │
│  - Efficiency  │       │  - speed    │  │  - Email     │
│  - Costs       │       │  - battery  │  │  - Backup    │
└────────────────┘       └─────────────┘  └──────────────┘

Componentes del stack

TeslaMate (contenedor principal)

– Runtime: Elixir 1.15 + Erlang/OTP 26

– Puerto: 4000 (Web UI)

– Función: Polling API de Tesla, lógica de sleep, geocoding

PostgreSQL 16

– Almacena: Drives, charges, positions, settings

– Tamaño: ~500MB/año de datos por vehículo

– Backups: Automáticos via pg_dump

Grafana 11.x

– Puerto: 3000

– Dashboards: 19 preconstruidos

– Data source: PostgreSQL (TeslaMate DB)

Mosquitto MQTT 2.x

– Puerto: 1883 (MQTT), 9001 (WebSockets)

– QoS: 1 (at least once)

– Retención: Últimos valores persistentes

n8n (opcional)

– Puerto: 5678

– Workflows: Alertas, backups, integraciones

– Triggers: MQTT, Webhook, Cron

—

Requisitos previos

Hardware (Homelab)

CPU: 2 cores mínimo (4 cores recomendado)
RAM: 2GB mínimo (4GB recomendado para Grafana + n8n)
Disco: 10GB iniciales + ~500MB/año por vehículo
Red: 100Mbps estables, puerto 4000 expuesto

Software

Docker: 24.0+ con Docker Compose v2
SO: Linux (Ubuntu 22.04/24.04, Debian 12, Rocky Linux 9)
Reverse proxy: Nginx Proxy Manager, Traefik o Caddy (recomendado para HTTPS)
Dominio: Opcional pero recomendado para OAuth redirect

Tesla

Vehículo: Cualquier Tesla con conectividad premium
Cuenta: Acceso a la app móvil de Tesla
API: OAuth token (se genera durante setup)
Ubicación: Vehículo debe estar «despierto» para primer setup

Conocimientos

Comandos básicos de Linux (ssh, docker, nano/vim)
Conceptos de Docker Compose
Nociones de MQTT (opcional, para integraciones)

—

Instalación paso a paso

PASO 1: Crear estructura de directorios

# Crear carpeta base
sudo mkdir -p /opt/teslamate
cd /opt/teslamate

# Crear subdirectorios para datos persistentes
sudo mkdir -p {postgres-data,grafana-data,mosquitto-data,import}

# Permisos correctos
sudo chown -R $USER:$USER /opt/teslamate
chmod 755 /opt/teslamate

Explicación:

postgres-data/: Base de datos PostgreSQL (crítico para backups)
grafana-data/: Configuración y dashboards de Grafana
mosquitto-data/: Configuración MQTT y retención de mensajes
import/: Archivos CSV/JSON para importar datos históricos

PASO 2: Crear docker-compose.yml

version: "3"

services:
  teslamate:
    image: teslamate/teslamate:latest
    restart: unless-stopped
    environment:
      - ENCRYPTION_KEY=${TM_ENCRYPTION_KEY}
      - DATABASE_USER=${TM_DB_USER}
      - DATABASE_PASS=${TM_DB_PASS}
      - DATABASE_NAME=${TM_DB_NAME}
      - DATABASE_HOST=database
      - MQTT_HOST=mosquitto
      - VIRTUAL_HOST=${FQDN_TM}
      - CHECK_ORIGIN=true
      - TZ=${TM_TZ}
    ports:
      - 4000:4000
    volumes:
      - ./import:/opt/app/import
    cap_drop:
      - all
    depends_on:
      - database
      - mosquitto

  database:
    image: postgres:16
    restart: unless-stopped
    environment:
      - POSTGRES_USER=${TM_DB_USER}
      - POSTGRES_PASSWORD=${TM_DB_PASS}
      - POSTGRES_DB=${TM_DB_NAME}
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
      - ./backups:/backups
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${TM_DB_USER}"]
      interval: 10s
      timeout: 5s
      retries: 5

  grafana:
    image: teslamate/grafana:latest
    restart: unless-stopped
    environment:
      - DATABASE_USER=${TM_DB_USER}
      - DATABASE_PASS=${TM_DB_PASS}
      - DATABASE_NAME=${TM_DB_NAME}
      - DATABASE_HOST=database
      - GRAFANA_PASSWD=${GRAFANA_PW}
      - GF_SECURITY_ADMIN_USER=${GRAFANA_USER}
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PW}
      - GF_AUTH_BASIC_ENABLED=true
      - GF_AUTH_ANONYMOUS_ENABLED=false
      - GF_SERVER_ROOT_URL=https://${FQDN_GRAFANA}
    ports:
      - 3000:3000
    volumes:
      - ./grafana-data:/var/lib/grafana
    depends_on:
      - database

  mosquitto:
    image: eclipse-mosquitto:2
    restart: unless-stopped
    command: mosquitto -c /mosquitto-no-auth.conf
    ports:
      - 1883:1883
    volumes:
      - ./mosquitto-data:/mosquitto/data
      - ./mosquitto-logs:/mosquitto/log

Configuración importante:

cap_drop: all: Security best practice (drop capabilities innecesarias)
healthcheck: PostgreSQL con retry logic
depends_on: Orden de inicio correcto
restart: unless-stopped: Reinicio automático tras reboot

PASO 3: Configurar variables de entorno

Crea .env en /opt/teslamate/:

# Generales
TM_TZ=Europe/Madrid
FQDN_TM=teslamate.tudominio.com
FQDN_GRAFANA=grafana-teslamate.tudominio.com

# Base de datos
TM_DB_USER=teslamate
TM_DB_PASS=$(openssl rand -base64 32)  # Genera password seguro
TM_DB_NAME=teslamate

# Encryption key (CRÍTICO: backupear esto)
TM_ENCRYPTION_KEY=$(openssl rand -base64 32)

# Grafana
GRAFANA_USER=admin
GRAFANA_PW=$(openssl rand -base64 24)

⚠️ IMPORTANTE:

Backupea TM_ENCRYPTION_KEY en lugar seguro (necesario para decrypt tokens)
Cambia las passwords por defecto
Usa openssl rand -base64 32 para generar secrets fuertes

PASO 4: Iniciar servicios

cd /opt/teslamate

# Pull de imágenes
docker compose pull

# Iniciar en background
docker compose up -d

# Verificar logs
docker compose logs -f teslamate

Salida esperada:

teslamate  | [info] Running TeslaMate.Web.Endpoint with cowboy 2.12.0 at :::4000 (http)
teslamate  | [info] Access TeslaMate at http://localhost:4000
database   | LOG:  database system is ready to accept connections
grafana    | logger=settings t=2025-11-09T14:00:00.000Z level=info msg="Starting Grafana"

PASO 5: Configuración inicial (Web UI)

Abre http://tu-ip:4000
Sign in with Tesla:

– Click en «Sign in»

– Inicia sesión con tu cuenta Tesla

– Autoriza permisos (read-only, no puede controlar el coche)

Configuración inicial:

– Unidad de distancia: km o mi

– Unidad de temperatura: °C o °F

– Idioma: Español

– Zona horaria: Europe/Madrid

Geo-fencing:

– Añadir «Casa» con radio de 50m

– Añadir «Trabajo» con radio 100m

– Opcional: Supercargadores frecuentes

Token de acceso:

TeslaMate obtiene un OAuth token que expira en 45 días
Renovación automática vía refresh token
Tokens encriptados con TM_ENCRYPTION_KEY en PostgreSQL

—

Configuración avanzada

Configurar Mosquitto con autenticación

Por defecto, MQTT no tiene auth. Para producción:

# Crear archivo de configuración
cat > /opt/teslamate/mosquitto.conf << 'EOF'
persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

# Autenticación
allow_anonymous false
password_file /mosquitto/config/passwd

# Listeners
listener 1883
protocol mqtt

listener 9001
protocol websockets
EOF

# Crear usuario y password
docker run --rm -v /opt/teslamate/mosquitto-data:/mosquitto/config eclipse-mosquitto:2 \
  mosquitto_passwd -c /mosquitto/config/passwd teslamate

# Reiniciar con nueva config
docker compose restart mosquitto

Actualiza docker-compose.yml:

mosquitto:
  image: eclipse-mosquitto:2
  restart: unless-stopped
  command: mosquitto -c /mosquitto/config/mosquitto.conf
  volumes:
    - ./mosquitto-data:/mosquitto/data
    - ./mosquitto-logs:/mosquitto/log
    - ./mosquitto.conf:/mosquitto/config/mosquitto.conf:ro
  ports:
    - 1883:1883
    - 9001:9001

Configurar HTTPS con Nginx Proxy Manager

Si usas NPM en tu homelab:

Proxy Host para TeslaMate:

– Domain: teslamate.tudominio.com

– Scheme: http

– Forward Hostname: tu-ip-homelab

– Forward Port: 4000

– Websockets: ✅ Enable

– SSL Certificate: Let’s Encrypt

Proxy Host para Grafana:

– Domain: grafana-teslamate.tudominio.com

– Forward Port: 3000

– SSL: Let’s Encrypt

Actualizar .env:

FQDN_TM=teslamate.tudominio.com
   FQDN_GRAFANA=grafana-teslamate.tudominio.com

Backups automáticos de PostgreSQL

Script de backup diario:

#!/bin/bash
# /opt/teslamate/backup.sh

BACKUP_DIR="/opt/teslamate/backups"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Backup
docker exec teslamate-database-1 pg_dump -U teslamate teslamate | \
  gzip > "$BACKUP_DIR/teslamate_$DATE.sql.gz"

# Limpieza de backups antiguos
find "$BACKUP_DIR" -name "teslamate_*.sql.gz" -mtime +$RETENTION_DAYS -delete

# Notificación (opcional)
echo "Backup TeslaMate completado: teslamate_$DATE.sql.gz"

Cron job:

sudo crontab -e
# Añadir:
0 3 * * * /opt/teslamate/backup.sh >> /var/log/teslamate-backup.log 2>&1

Importar datos históricos desde TeslaFi

Exportar datos de TeslaFi (formato CSV)
Copiar a /opt/teslamate/import/
Ejecutar import desde Web UI:

Settings > Import > TeslaFi > Select CSV > Import

Proceso puede tardar 10-30 min según volumen de datos

Optimización de consumo de batería

TeslaMate implementa lógica inteligente de sleep:

Configuración recomendada:

Sleep mode: Never (confía en la lógica de TeslaMate)
Polling interval: 60s (reduce de 10s a 60s si no necesitas datos en tiempo real)
Suspend after idle: 15 minutes

Vampire drain esperado:

Con TeslaMate: ~0.5-1% por día
Sin TeslaMate: ~0.3-0.5% por día
Incremento: 0.2-0.5% diario (aceptable para la funcionalidad)

—

Los 19 dashboards de Grafana

TeslaMate incluye 19 dashboards preconstruidos optimizados para análisis de Tesla.

Dashboard 1: Overview (Vista general)

Métricas principales:

Estado actual: Charging/Driving/Asleep/Online
Ubicación en tiempo real (mapa OSM)
Batería (% y kWh disponibles)
Odómetro total
Eficiencia promedio (Wh/km)
Temperatura interior/exterior

Casos de uso:

Monitorización rápida del estado del vehículo
Ver dónde está el coche desde Home Assistant

Dashboard 2: Charge Level (Nivel de carga)

Gráfico temporal:

Nivel de batería (%) en últimas 24h/7d/30d
Eventos de carga marcados
Líneas de alerta (80%, 20%)
Previsión de autonomía (km restantes)

Útil para:

Identificar patrones de carga
Detectar degradación anómala

Dashboard 3: Charges (Cargas)

Tabla detallada:

Fecha/hora inicio y fin
Ubicación (casa, trabajo, supercargador)
kWh añadidos vs consumidos (net)
Coste total de carga
Tiempo de carga
Potencia pico (kW)

Filtros:

Por ubicación
Por rango de fechas
Por tipo de cargador (AC/DC)

Dashboard 4: Charge Details (Detalles de carga)

Gráfico de potencia:

Curva de carga completa (kW vs tiempo)
Temperatura de batería durante carga
Voltaje y amperaje
Throttling events (reducción de potencia)

Análisis:

Eficiencia del cargador
Detección de problemas en Supercharger
Comparativa entre ubicaciones

Dashboard 5: Charging Stats (Estadísticas de carga)

Agregados:

Total kWh cargados (lifetime)
Coste total acumulado
Promedio kW por sesión
Top 10 ubicaciones de carga
Distribución AC vs DC (%)

Dashboard 6: Drive Stats (Estadísticas de conducción)

Métricas:

Distancia total recorrida
Tiempo total conduciendo
Velocidad promedio
Eficiencia promedio (Wh/km)
Top 10 rutas más frecuentes

Dashboard 7: Drives (Viajes)

Listado de viajes:

Origen → Destino (direcciones)
Distancia recorrida
Duración
Consumo neto (kWh)
Eficiencia (Wh/km)
Velocidad promedio

Filtros:

Por origen/destino
Por consumo (viajes más eficientes)

Dashboard 8: Drive Details (Detalles de viaje)

Visualización en mapa:

Ruta completa con polyline
Puntos de inicio y fin
Paradas intermedias
Velocidad a lo largo de la ruta (colormapped)
Elevación del terreno

Dashboard 9: Efficiency (Eficiencia)

Comparativas:

Consumo bruto vs neto (regeneration)
Eficiencia por temperatura exterior
Eficiencia por velocidad promedio
Eficiencia por tipo de ruta (autopista/ciudad)

Gráficos:

Scatter plot: velocidad vs consumo
Heatmap: temperatura vs eficiencia

Dashboard 10: Locations (Ubicaciones)

Listado:

Todas las ubicaciones visitadas
Tiempo total en cada ubicación
Número de visitas
Última visita
Coordenadas GPS

Geo-fencing:

Definir ubicaciones custom con radio
Alertas cuando entra/sale de geo-fence

Dashboard 11: Mileage (Kilometraje)

Gráficos:

Odómetro total vs tiempo
km recorridos por día/semana/mes
Proyección anual de kilometraje
Comparativa con años anteriores

Dashboard 12: Battery Health (Salud de batería)

Métricas críticas:

Capacidad nominal vs real (kWh)
Degradación acumulada (%)
Curva de degradación temporal
Autonomía máxima (EPA range)
Ciclos de carga estimados

Alertas:

Degradación anómala (>5% en 6 meses)
Capacidad bajo umbral crítico

Dashboard 13: Projected Range (Autonomía proyectada)

Cálculos:

Range a 100% (km reales)
Range a 90% (carga diaria recomendada)
Comparativa con EPA rating
Ajuste por temperatura (-10°C a 30°C)

Dashboard 14: States (Estados)

Timeline:

Asleep (verde)
Online idle (amarillo)
Driving (azul)
Charging (naranja)
Updating (púrpura)

Análisis:

% tiempo en cada estado
Detección de «zombie mode» (online idle prolongado)

Dashboard 15: Timeline (Línea de tiempo)

Vista completa:

Todos los eventos del día en una línea temporal
Viajes, cargas, actualizaciones, estados
Drill-down a detalles por evento

Dashboard 16: Trip (Viaje actual)

En tiempo real:

Mapa live con posición actual
Consumo instantáneo (kW)
Autonomía restante
ETA basado en consumo actual

Dashboard 17: Updates (Actualizaciones)

Historial:

Versión de software instalada
Fecha de instalación
Changelog de Tesla (si disponible)
Tiempo de instalación

Dashboard 18: Vampire Drain (Consumo vampírico)

Análisis:

Pérdida de batería en modo sleep
Comparativa por ubicación (casa vs trabajo)
Impacto de temperatura
Eventos de wake-up inesperados

Dashboard 19: Visited (Mapa de vida)

Visualización épica:

Mapa con TODAS las ubicaciones visitadas (lifetime)
Polylines de todos los viajes
Heatmap de zonas más transitadas
Exportable como imagen para social media

—

Integración con MQTT

TeslaMate publica ~50 topics MQTT en tiempo real.

Topics principales

Estructura: teslamate/cars/{car_id}/{metric}

Ejemplos:

teslamate/cars/1/display_name        → "Model 3"
teslamate/cars/1/state              → "driving"
teslamate/cars/1/latitude           → 40.4168
teslamate/cars/1/longitude          → -3.7038
teslamate/cars/1/speed              → 120
teslamate/cars/1/battery_level      → 82
teslamate/cars/1/usable_battery_level → 79
teslamate/cars/1/charge_energy_added → 45.2
teslamate/cars/1/charger_power      → 11
teslamate/cars/1/est_battery_range_km → 312
teslamate/cars/1/inside_temp        → 21.5
teslamate/cars/1/outside_temp       → 15.2
teslamate/cars/1/odometer           → 25432.8
teslamate/cars/1/sentry_mode        → "false"
teslamate/cars/1/locked             → "true"
teslamate/cars/1/is_climate_on      → "false"

Integración con Home Assistant

configuration.yaml:

mqtt:
  sensor:
    - name: "Tesla Model 3 Battery"
      state_topic: "teslamate/cars/1/battery_level"
      unit_of_measurement: "%"
      icon: mdi:battery-80
      
    - name: "Tesla Model 3 Range"
      state_topic: "teslamate/cars/1/est_battery_range_km"
      unit_of_measurement: "km"
      icon: mdi:map-marker-distance
      
    - name: "Tesla Model 3 Location"
      state_topic: "teslamate/cars/1/display_name"
      icon: mdi:map-marker
      
  binary_sensor:
    - name: "Tesla Model 3 Charging"
      state_topic: "teslamate/cars/1/plugged_in"
      payload_on: "true"
      payload_off: "false"
      device_class: plug
      
  device_tracker:
    - name: "Tesla Model 3"
      state_topic: "teslamate/cars/1/latitude"
      json_attributes_topic: "teslamate/cars/1/longitude"
      
  switch:
    # Nota: Solo read-only, TeslaMate no puede controlar el coche

Dashboard de Home Assistant:

type: entities
title: Tesla Model 3
entities:
  - entity: sensor.tesla_model_3_battery
    name: Batería
    icon: mdi:battery
  - entity: sensor.tesla_model_3_range
    name: Autonomía
  - entity: binary_sensor.tesla_model_3_charging
    name: Cargando
  - entity: device_tracker.tesla_model_3
    name: Ubicación
  - type: divider
  - entity: sensor.tesla_model_3_inside_temp
    name: Temp. interior
  - entity: sensor.tesla_model_3_outside_temp
    name: Temp. exterior

—

Automatizaciones con n8n

TeslaMate + MQTT + n8n = automatizaciones infinitas.

Workflow 1: Alerta de carga completa

Trigger: MQTT teslamate/cars/1/battery_level = 80%

Action: Enviar notificación Telegram

{
  "nodes": [
    {
      "parameters": {
        "topics": "teslamate/cars/1/battery_level",
        "options": {}
      },
      "name": "MQTT Trigger",
      "type": "n8n-nodes-base.mqttTrigger",
      "position": [250, 300]
    },
    {
      "parameters": {
        "conditions": {
          "number": [
            {
              "value1": "={{$json.payload}}",
              "operation": "equal",
              "value2": 80
            }
          ]
        }
      },
      "name": "If Battery = 80%",
      "type": "n8n-nodes-base.if",
      "position": [450, 300]
    },
    {
      "parameters": {
        "chatId": "YOUR_CHAT_ID",
        "text": "🔋 Tu Tesla ha alcanzado 80% de carga. ¡Desconecta el cargador!"
      },
      "name": "Telegram",
      "type": "n8n-nodes-base.telegram",
      "position": [650, 300]
    }
  ]
}

Workflow 2: Tracking de costes de carga

Trigger: Fin de carga (MQTT plugged_in = false)

Action: Calcular coste y guardar en Google Sheets

// Function node: Calcular coste
const kWhAdded = $json.charge_energy_added;
const pricePerKWh = 0.15; // €/kWh (tu tarifa)
const cost = (kWhAdded * pricePerKWh).toFixed(2);

return {
  date: new Date().toISOString(),
  location: $json.geofence,
  kWhAdded: kWhAdded,
  cost: cost,
  currency: 'EUR'
};

Workflow 3: Backup automático a Google Drive

Trigger: Cron (diario a las 3 AM)

Actions:

Ejecutar pg_dump via SSH
Comprimir SQL dump
Upload a Google Drive
Eliminar dumps locales >30 días

Workflow 4: Alerta de vampire drain anómalo

Trigger: Cron (cada 6 horas)

Logic:

Query PostgreSQL: pérdida de batería en últimas 24h en modo sleep
Si pérdida >2%: enviar alerta
Incluir gráfico de Grafana en notificación

—

Optimización y troubleshooting

Problema: TeslaMate no detecta el coche

Síntomas:

Web UI muestra «No vehicles found»
Logs: [error] Failed to fetch vehicles

Soluciones:

Verificar que el coche está despierto (abrir app de Tesla)
Revisar token OAuth (Settings > Sign out y re-login)
Comprobar conectividad a API de Tesla:

curl -H "Authorization: Bearer YOUR_TOKEN" \
     https://owner-api.teslamotors.com/api/1/vehicles

Problema: Vampire drain excesivo (>2%/día)

Causas comunes:

Polling interval muy bajo: Configurar a 60s en lugar de 10s
Sentry mode activo: Consumo de ~400W cuando está on
Climate control en schedule: Revisar configuración de preclimatización
Apps de terceros: Otras apps consultando API simultáneamente

Diagnóstico:

Dashboard «Vampire Drain» en Grafana
Comparar con baseline (sin TeslaMate)
Revisar logs de wake-up events

Problema: Datos de ubicación incorrectos

Síntomas:

Direcciones geocoded erróneas
Coche aparece en ubicación incorrecta

Soluciones:

Verificar conexión a OpenStreetMap (TeslaMate usa OSM Nominatim)
Configurar API key de Google Maps (opcional):

environment:
     - GOOGLE_API_KEY=tu-api-key

Ajustar precisión GPS mínima (Settings > 50m)

Problema: PostgreSQL se queda sin espacio

Síntomas:

Error: disk full
TeslaMate no registra nuevos datos

Soluciones:

Limpieza de datos antiguos:

-- Eliminar positions >1 año
   DELETE FROM positions WHERE date < NOW() - INTERVAL '365 days';
   
   -- Vacuum para liberar espacio
   VACUUM FULL;

Configurar retención automática:

-- Crear función de limpieza
   CREATE OR REPLACE FUNCTION cleanup_old_data()
   RETURNS void AS $$
   BEGIN
     DELETE FROM positions WHERE date < NOW() - INTERVAL '365 days';
     DELETE FROM charges WHERE date < NOW() - INTERVAL '730 days';
   END;
   $$ LANGUAGE plpgsql;
   
   -- Programar ejecución mensual
   SELECT cron.schedule('cleanup-teslamate', '0 0 1 * *', 'SELECT cleanup_old_data()');

Problema: Grafana no muestra datos

Síntomas:

Dashboards vacíos o con mensaje «No data»

Soluciones:

Verificar data source:

Grafana > Configuration > Data Sources > PostgreSQL
   Host: database:5432
   Database: teslamate
   User: teslamate

Comprobar conectividad:

docker exec teslamate-grafana-1 nc -zv database 5432

Reiniciar Grafana:

docker compose restart grafana

Problema: MQTT no publica mensajes

Síntomas:

Home Assistant no recibe actualizaciones
mosquitto_sub no muestra topics

Diagnóstico:

# Suscribirse a todos los topics
docker exec -it teslamate-mosquitto-1 \
  mosquitto_sub -h localhost -t "teslamate/#" -v

# Verificar que TeslaMate publica
docker compose logs teslamate | grep MQTT

Soluciones:

Verificar que Mosquitto está running:

docker ps | grep mosquitto

Comprobar configuración en TeslaMate:

environment:
     - MQTT_HOST=mosquitto
     - MQTT_PORT=1883  # Default

Revisar logs de Mosquitto:

docker compose logs mosquitto

—

Comparativa con alternativas

TeslaMate vs TeslaFi

Aspecto	TeslaMate	TeslaFi
Coste	Gratis (hosting propio)	$50/año ($4.17/mes) o $60/año anual
Privacidad	✅ Datos en tu servidor	❌ Cloud de TeslaFi
Latencia	✅ <10ms (local)	⚠️ 500-2000ms (cloud)
Personalización	✅ Open source, fork posible	❌ Cerrado
Grafana	✅ 19 dashboards	❌ UI propietaria
MQTT	✅ Nativo	❌ No soportado
API pública	⚠️ Acceso directo a PostgreSQL	✅ REST API documentada
Soporte multi-cuenta	⚠️ 1 cuenta Tesla por instancia	✅ Múltiples cuentas
Mobile app	❌ Solo web responsive	✅ App iOS/Android
Importación de datos	✅ Desde TeslaFi, tesla-apiscraper	✅ Desde otros servicios
Alertas	⚠️ Via MQTT + n8n/Home Assistant	✅ Integradas (email, push)
Mantenimiento	⚠️ Responsabilidad propia	✅ Gestionado por TeslaFi

Recomendación:

TeslaMate si: Tienes homelab, valoras privacidad, quieres personalización
TeslaFi si: No tienes servidor, prefieres app móvil nativa, quieres soporte oficial

TeslaMate vs Teslascope

Aspecto	TeslaMate	Teslascope
Coste	Gratis	$4/mes o $40/año
Privacidad	✅ Local	❌ Cloud
Features avanzadas	⚠️ Requiere setup MQTT	✅ Integradas
Comparativas de flota	❌ No	✅ Sí (community)
Estadísticas regionales	❌ No	✅ Sí
Widgets web	❌ No	✅ Sí (embeddable)

—

Casos de uso reales

Caso 1: Análisis de degradación de batería

Usuario: Propietario de Model 3 LR 2021 con 80,000 km

Objetivo: Monitorizar degradación de batería en tiempo real

Setup:

Dashboard «Battery Health» en Grafana
Alerta n8n si degradación >3% en 3 meses
Export mensual de datos a CSV para análisis externo

Resultados:

Degradación 4.2% en 3 años (dentro de normal)
Detección de spike anómalo tras actualización SW (recuperado en 2 semanas)
Correlación: degradación más rápida en meses de verano (30°C+)

Caso 2: Optimización de costes de carga

Usuario: Propietario de Model Y con tarifa eléctrica nocturna

Objetivo: Maximizar carga en horas valle (23:00-07:00)

Setup:

Home Assistant automation: empezar carga a las 23:00
TeslaMate tracking de costes por ubicación
Grafana dashboard personalizado con comparativa tarifas

Resultados:

Ahorro de €420/año vs carga en horas pico
Identificación de supercargadores más económicos (€0.35/kWh vs €0.52/kWh)

Caso 3: Integración con sistema de energía solar

Usuario: Homelab con paneles solares 10kW + batería 13.5kWh

Objetivo: Cargar Tesla con excedente solar

Setup:

Home Assistant: sensor de producción solar (MQTT)
n8n workflow: si excedente >7kW → empezar carga Tesla
TeslaMate: registrar kWh añadidos vs producción solar

Resultados:

65% de cargas con energía solar (vs 0% previo)
ROI de instalación solar mejorado en 18%

—

Preguntas frecuentes (FAQs)

¿TeslaMate puede controlar mi Tesla (abrir puertas, encender clima)?

No. TeslaMate es read-only por diseño. Solo lee datos de la API de Tesla, no puede enviar comandos. Esto es una decisión de seguridad del proyecto.

Si necesitas control, puedes usar Tesla HTTP Proxy o TeslaMateAgile (fork con comandos), pero asumes riesgos de seguridad.

¿TeslaMate consume batería de mi coche?

Sí, pero muy poco. El incremento de vampire drain es de 0.2-0.5% diario (~1.5-3.5% semanal). TeslaMate implementa lógica inteligente para dejar que el coche entre en modo sleep lo antes posible.

Comparado con otros servicios (TeslaFi también ~0.5%), TeslaMate es igual de eficiente.

¿Qué pasa si Tesla cambia su API?

Problema conocido. Tesla no tiene API pública oficial, puede cambiar en cualquier momento.

Mitigación:

TeslaMate usa tesla-info library (actualizada por comunidad)
Cuando Tesla rompe algo, comunidad lo arregla en 24-48h
Puedes pausar TeslaMate temporalmente sin perder datos históricos

¿Puedo usar TeslaMate con múltiples Teslas?

Sí, pero una instancia por cuenta de Tesla. Si tienes 2 Teslas en la misma cuenta, TeslaMate los detectará automáticamente.

Si tienes 2 cuentas de Tesla separadas, necesitas 2 instancias de TeslaMate (2x PostgreSQL, 2x Grafana).

¿TeslaMate funciona en Raspberry Pi?

Sí, pero con limitaciones:

Raspberry Pi 4 (4GB RAM): ✅ Funciona bien
Raspberry Pi 4 (2GB RAM): ⚠️ Funciona, pero slow Grafana
Raspberry Pi 3: ❌ No recomendado (Elixir consume ~500MB RAM)

Recomendación: Usa un mini PC x86 (Intel N100, ~€120) para mejor experiencia.

¿Cómo migro de TeslaFi a TeslaMate?

Exportar datos de TeslaFi:

– Settings > Data Export > Download CSV (drives + charges)

Copiar CSVs a TeslaMate:

cp teslaFi-drives.csv /opt/teslamate/import/
   cp teslaFi-charges.csv /opt/teslamate/import/

Importar desde Web UI:

– Settings > Import > TeslaFi

– Select CSVs > Import

Tiempo: 10-30 min según volumen (TeslaMate valida cada registro)

¿TeslaMate es compatible con otros coches eléctricos?

No. TeslaMate está específicamente diseñado para Tesla. Usa la API propietaria de Tesla que no es compatible con otros fabricantes.

Para otros EVs, alternativas:

EVNotify: Soporta Nissan Leaf, BMW i3, Renault Zoe
ABRP (A Better Route Planner): Multi-marca con telemetría limitada

¿Qué requisitos legales hay para registrar datos del coche?

En España/UE (GDPR):

✅ Registrar datos de TU PROPIO coche: Legal
❌ Registrar datos de coche de OTRA persona sin consentimiento: Ilegal
⚠️ Si compartes coche (empresa, familia): Informar a otros usuarios

Recomendación: Si el coche es corporativo o compartido, notifica a otros conductores sobre TeslaMate.

¿Puedo vender mi Tesla sin perder datos históricos?

Sí. Los datos están en PostgreSQL, no vinculados al VIN del coche.

Proceso:

Backup de PostgreSQL antes de vender
Desconectar TeslaMate (Sign out)
Al comprar nuevo Tesla: Sign in con nueva cuenta
(Opcional) Crear nueva instancia TeslaMate para separar datos

¿TeslaMate puede causar que Tesla me bloquee la cuenta?

Riesgo muy bajo. Tesla no ha bloqueado cuentas por usar TeslaMate (o TeslaFi).

Buenas prácticas para minimizar riesgo:

Polling interval ≥60s (no 10s)
No uses múltiples servicios simultáneamente (TeslaMate + TeslaFi = doble polling)
Respeta rate limits de API (TeslaMate lo hace automáticamente)

¿Cómo actualizo TeslaMate a nueva versión?

cd /opt/teslamate

# Pull nueva imagen
docker compose pull teslamate

# Recrear contenedor (PostgreSQL no se toca)
docker compose up -d teslamate

# Verificar logs
docker compose logs -f teslamate

Breaking changes: Revisar CHANGELOG antes de actualizar.

¿Puedo acceder a TeslaMate desde fuera de casa (4G)?

Sí, con HTTPS + reverse proxy:

Configura Nginx Proxy Manager / Traefik
Usa DuckDNS o Cloudflare Tunnel para DNS dinámico
Expón puerto 443 en router (port forwarding)
IMPORTANTE: Activa autenticación básica en Nginx

Alternativa más segura: VPN (WireGuard / Tailscale) para acceso remoto al homelab.

¿TeslaMate guarda mi password de Tesla?

No. TeslaMate usa OAuth tokens, no passwords.

Flujo:

Redirección a login.tesla.com (oficial)
Autorizas app «TeslaMate» (read-only)
Tesla devuelve access token (expira en 45 días)
TeslaMate almacena token encriptado con TM_ENCRYPTION_KEY

Tu password nunca pasa por TeslaMate.

¿Qué hago si pierdo el encryption key?

Mal: Pierdes acceso a tokens OAuth encriptados en PostgreSQL.

Solución:

Sign out desde Web UI (invalida tokens)
Sign in de nuevo (genera nuevos tokens)
Backupea el nuevo TM_ENCRYPTION_KEY

Prevención: Guarda TM_ENCRYPTION_KEY en gestor de passwords (1Password, Bitwarden).

¿TeslaMate soporta Tesla Semi o Cybertruck?

Cybertruck: ✅ Soportado (desde 2024)

Tesla Semi: ❌ API de Tesla no lo soporta públicamente

—

Conclusiones

TeslaMate es la solución definitiva para propietarios de Tesla con homelab. Por el precio de cero euros (más costes de hosting), obtienes:

✅ Privacidad total: Tus datos nunca salen de tu servidor

✅ 19 dashboards de Grafana: Análisis profesional de telemetría

✅ MQTT: Integración perfecta con Home Assistant y n8n

✅ Open source: Código auditable, fork si quieres modificar

✅ Comunidad activa: 5,000+ estrellas en GitHub, actualizaciones frecuentes

Recomendado para:

Entusiastas de homelabs que ya tienen infraestructura Docker
Usuarios preocupados por privacidad de datos
Quienes quieren análisis profundo de eficiencia y degradación
Integradores con Home Assistant, n8n, Node-RED

NO recomendado para:

Usuarios sin experiencia en Docker (considera TeslaFi)
Quienes prefieren app móvil nativa (TeslaFi tiene mejor UX móvil)
Empresas que necesitan soporte oficial (TeslaFi ofrece SLA)

Próximos pasos

Deploy básico: Sigue pasos de instalación (30 min)
Configura geo-fencing: Añade casa, trabajo, supercargadores (10 min)
Explora Grafana: Revisa los 19 dashboards (1 hora)
Setup MQTT: Integra con Home Assistant (30 min)
Crea automatización n8n: Alerta de carga completa (15 min)
Backup PostgreSQL: Script cron diario (10 min)

Tiempo total de setup completo: 2-3 horas

—

Enlaces útiles

Documentación oficial: https://docs.teslamate.org
Repositorio GitHub: https://github.com/teslamate-org/teslamate
Community Forum: https://community.teslamate.org
Docker Hub: https://hub.docker.com/r/teslamate/teslamate
Dashboards adicionales: https://github.com/teslamate-org/grafana-dashboards

—

🎉 ¡Disfruta de tu Tesla telemetría completa en tu homelab!

¿Tienes dudas o problemas? Déjalas en los comentarios o únete al foro de la comunidad.