Feature Request: Show charge locations on map in Trip dashboard

[jaypark0006]

Is there an existing issue for this?

• I have searched the existing issues

What happened?

The Trip dashboard has a nice map showing the drives, and a list of charges. But, the map does not show the charges

Expected Behavior

Add icons on the map to show the locations of the charges. For extra points, have different icons for DC charging and AC charging. For full marks, allow the user to provide custom icons if he/she desires and also allow the charge icons on the map to be enabled or disabled using the Settings.

Steps To Reproduce

Display Trip dashboard

Relevant log output

None

Type of installation

Docker

Version

v1.27.3

Originally posted by @khorton in #3415

[jaypark0006]

I have an idea to enhance the Trip view — while displaying the driving path, I’d also like to visualize two additional types of events: Park and Charge.

In my mind, it would look something like this:

• Park means the vehicle has stopped.

• Charge means the vehicle is currently charging.

• Conceptually, Charge ⊂ Park.

Logic Overview

To make the data cleaner and avoid noise from very short stop/start events, I propose introducing two thresholds:

• micro_drive_threshold_min – the minimum drive duration.
  Drives shorter than this threshold should be merged into the surrounding Park (to handle temporary vehicle movement, e.g. “micro-movements” while parking).

• min_park_min – the minimum park duration.
  Parks shorter than this threshold can be merged into the adjacent drive (to filter out brief “P-gear” stops during a trip).

Corner Cases

There are special scenarios we probably can’t handle well — for example, the car being on a ferry or trailer.
In such cases, using the last position of the previous drive as the Park location should be sufficient and simple.

and about sql:

-- find charge times
SELECT count(*) AS charge_sessions
FROM charging_processes cp
WHERE cp.car_id = '1'
  AND cp.start_date < '2025-10-08T03:29:46.58Z'
  AND coalesce(cp.end_date, now()) > '2025-10-01T03:29:46.58Z';

-- charge detail(start-end time; duration_min, knw_added, lat, lon)
SELECT cp.id,
       cp.start_date,
       cp.end_date,
       round(EXTRACT(EPOCH FROM (coalesce(cp.end_date, now()) - cp.start_date)) / 60.0, 1) AS duration_min,
       round(cp.charge_energy_added::numeric, 2)                                           AS kwh_added,
       p.latitude,
       p.longitude
FROM charging_processes cp
         LEFT JOIN positions p ON p.id = cp.position_id
WHERE cp.car_id = '1'
  AND cp.start_date < '2025-10-08T03:29:46.58Z'
  AND coalesce(cp.end_date, now()) > '2025-10-01T03:29:46.58Z'
ORDER BY cp.start_date;


-- park detail
WITH drives_in_window AS (SELECT d.*,
                                 LAG(d.end_date) OVER (PARTITION BY d.car_id ORDER BY d.start_date) AS prev_end
                          FROM drives d
                          WHERE d.car_id = '1'
                            AND d.start_date < '2025-10-08T03:29:46.58Z'
                            AND COALESCE(d.end_date, now()) > '2025-10-01T03:29:46.58Z'),
     clustered AS ( --   drive  merge to cluster
         SELECT *,
                CASE
                    WHEN prev_end IS NULL
                        OR (d.start_date - prev_end) >= make_interval(mins => 15) --micro_drive_threshold_min
                        THEN 1
                    ELSE 0
                    END AS is_new_cluster
         FROM drives_in_window d),
     tagged AS (SELECT *,
                       SUM(is_new_cluster) OVER (PARTITION BY car_id ORDER BY start_date) AS cluster_id
                FROM clustered),
     clusters AS ( --  every cluster
         SELECT car_id,
                cluster_id,
                MIN(start_date) AS cluster_start,
                MAX(end_date)   AS cluster_end
         FROM tagged
         GROUP BY car_id, cluster_id),
     cluster_last_end_pos AS ( -- get last drive end_position_id as park position
         SELECT DISTINCT ON (t.car_id, t.cluster_id) t.car_id,
                                                     t.cluster_id,
                                                     t.end_position_id
         FROM tagged t
         ORDER BY t.car_id, t.cluster_id, t.end_date DESC),
     parks_raw AS ( --  parks
         SELECT c.car_id,
                c.cluster_id,
                c.cluster_end                                                               AS park_start,
                LEAD(c.cluster_start) OVER (PARTITION BY c.car_id ORDER BY c.cluster_start) AS park_end,
                lep.end_position_id
         FROM clusters c
                  LEFT JOIN cluster_last_end_pos lep
                            ON lep.car_id = c.car_id AND lep.cluster_id = c.cluster_id),
     parks_clipped AS (SELECT GREATEST(park_start, '2025-10-01T03:29:46.58Z')             AS s,
                              LEAST(COALESCE(park_end, now()), '2025-10-08T03:29:46.58Z') AS e,
                              end_position_id
                       FROM parks_raw
                       WHERE park_start < '2025-10-08T03:29:46.58Z'
                         AND COALESCE(park_end, now()) > '2025-10-01T03:29:46.58Z'),
     parks_final AS ( -- filter little park
         SELECT s                                  AS park_start,
                e                                  AS park_end,
                EXTRACT(EPOCH FROM (e - s)) / 60.0 AS park_duration_min,
                end_position_id
         FROM parks_clipped
         WHERE e > s
           AND EXTRACT(EPOCH FROM (e - s)) / 60.0 >= 15 -- min_park_min
     )
SELECT park_start,
       park_end,
       ROUND(park_duration_min, 1) AS park_duration_min,
       p.latitude,
       p.longitude
FROM parks_final f
         LEFT JOIN positions p ON p.id = f.end_position_id
ORDER BY park_start;

[khorton]

I would be very happy to test this once a beta is available.

[JakobLichterfeld]

Thanks for your idea.

Do you mean something similar to Charging Stats dashboard with the Charging heat map by kWh?

[jaypark0006]

@JakobLichterfeld Thanks for the reply!

After thinking further about how I usually analyze my trips, I realized the current Geomap and Trip dashboards mainly show where I drove within a selected time range, and selecting a specific drive requires switching to a list and manually choosing an item.

The feature I’m imagining is a different workflow:

• A timeline-based dashboard where each Trip is represented as a visible segment

• I can click one or multiple trips directly on the timeline

• The selected trips will be rendered on the Geomap as separate colored layers

• And the map will also display related Park / Charge events of those trips

• Making it easy to visually explore where I went, where I stopped,
  and how long I stayed for each trip

So the focus is on interactive trip-level exploration, rather than heatmap aggregation.

From my investigation, this interaction (clickable trip-based timeline → dynamic Geomap layers per trip) isn’t achievable with the existing dashboards alone, so I plan to experiment with a small custom panel plugin.

If it works well and proves useful, we can then discuss integrating it as an optional dashboard feature in TeslaMate.

I’ll start with a proof-of-concept and share progress when I have something to show.

[jaypark0006]

I’m experimenting with a PostgreSQL Materialized View mv_car_event to precompute a unified event stream (DRIVE / CHARGE / PARK) so Grafana queries can read from a single table and avoid heavy subqueries / window logic at query time.

On my dataset (positions ~ 9,401,034 rows, 1 car), creating the MV takes ~6.812s.

I think it will helpful

DROP MATERIALIZED VIEW IF EXISTS mv_car_event;

CREATE MATERIALIZED VIEW mv_car_event AS
WITH
    -- ========== DRIVE (completed) ==========
    drive_base AS (SELECT d.id                                                               AS drive_id,
                          d.car_id,
                          d.start_date                                                       AS start_time,
                          d.end_date                                                         AS end_time,
                          round(EXTRACT(EPOCH FROM (d.end_date - d.start_date)) / 60.0, 1)   AS duration_min,
                          d.distance,
                          d.start_position_id,
                          d.end_position_id,
                          LAG(d.end_date) OVER (PARTITION BY d.car_id ORDER BY d.start_date) AS prev_end
                   FROM drives d
                   WHERE d.end_date IS NOT NULL),

    drive_event AS (SELECT ('DRIVE:' || b.drive_id::text) AS event_uid,
                           b.car_id,
                           'DRIVE'::text                  AS event_type,
                           start_time,
                           end_time,
                           duration_min,
                           p.latitude,
                           p.longitude,
                           start_time                     AS event_time,
                           jsonb_build_object(
                                   'drive_id', b.drive_id,
                                   'distance_km', b.distance,
                                   'gap_from_prev_min',
                                   CASE
                                       WHEN prev_end IS NULL THEN NULL
                                       ELSE round(EXTRACT(EPOCH FROM (start_time - prev_end)) / 60.0, 1)
                                       END,
                                   'start_position_id', start_position_id,
                                   'end_position_id', end_position_id
                               )                          AS attrs,
                           NULL::text                     AS path
                    FROM drive_base b
                             LEFT JOIN positions p ON p.id = b.start_position_id),

    -- ========== CHARGE (completed) ==========
    charge_event AS (SELECT ('CHARGE:' || cp.id::text)                                         AS event_uid,
                            cp.car_id,
                            'CHARGE'::text                                                     AS event_type,
                            cp.start_date                                                      AS start_time,
                            cp.end_date                                                        AS end_time,
                            round(EXTRACT(EPOCH FROM (cp.end_date - cp.start_date)) / 60.0, 1) AS duration_min,
                            p.latitude,
                            p.longitude,
                            cp.start_date                                                      AS event_time,
                            jsonb_build_object(
                                    'charge_id', cp.id,
                                    'charge_type', c2.conn_charge_cable,
                                    'kwh_added', round(cp.charge_energy_added::numeric, 2),
                                    'km_added', round(cp.end_ideal_range_km - cp.start_ideal_range_km, 2),
                                    'position_id', cp.position_id
                                )                                                              AS attrs,
                            NULL::text                                                         AS path
                     FROM charging_processes cp
                              LEFT JOIN LATERAL (  SELECT c.* FROM charges c  WHERE c.charging_process_id = cp.id  ORDER BY c.id DESC  LIMIT 1 ) as c2 on true
                              LEFT JOIN positions p ON p.id = cp.position_id
                     WHERE cp.end_date IS NOT NULL),

    -- ========== PARK (derived, completed) ==========
    drives_in_window AS (SELECT d.*,
                                LAG(d.end_date) OVER (PARTITION BY d.car_id ORDER BY d.start_date) AS prev_end
                         FROM drives d
                         WHERE d.end_date IS NOT NULL),
    clustered AS (SELECT d.*,
                         CASE
                             WHEN prev_end IS NULL
                                 OR (d.start_date - prev_end) >= make_interval(mins => 15) -- micro_drive_threshold_min
                                 THEN 1
                             ELSE 0
                             END AS is_new_cluster
                  FROM drives_in_window d),
    tagged AS (SELECT *,
                      SUM(is_new_cluster) OVER (PARTITION BY car_id ORDER BY start_date) AS cluster_id
               FROM clustered),
    clusters AS (SELECT car_id,
                        cluster_id,
                        MIN(start_date) AS cluster_start,
                        MAX(end_date)   AS cluster_end
                 FROM tagged
                 GROUP BY car_id, cluster_id),
    cluster_last_end_pos AS (SELECT DISTINCT ON (t.car_id, t.cluster_id) t.car_id,
                                                                         t.cluster_id,
                                                                         t.end_position_id
                             FROM tagged t
                             ORDER BY t.car_id, t.cluster_id, t.end_date DESC),
    parks_raw AS (SELECT c.car_id,
                         c.cluster_id,
                         c.cluster_end                                                               AS park_start,
                         LEAD(c.cluster_start) OVER (PARTITION BY c.car_id ORDER BY c.cluster_start) AS park_end,
                         lep.end_position_id
                  FROM clusters c
                           LEFT JOIN cluster_last_end_pos lep
                                     ON lep.car_id = c.car_id AND lep.cluster_id = c.cluster_id),
    parks_final AS (SELECT car_id,
                           cluster_id,
                           park_start,
                           park_end,
                           round(EXTRACT(EPOCH FROM (park_end - park_start)) / 60.0, 1) AS duration_min,
                           end_position_id
                    FROM parks_raw
                    WHERE park_end IS NOT NULL -- completed park only
                      AND park_end > park_start
                      AND EXTRACT(EPOCH FROM (park_end - park_start)) / 60.0 >= 15 -- min_park_min
    ),
    park_event AS (SELECT ('PARK:' || f.car_id::text || ':' || cluster_id::text) AS event_uid,
                          f.car_id,
                          'PARK'::text                                           AS event_type,
                          park_start                                             AS start_time,
                          park_end                                               AS end_time,
                          duration_min,
                          p.latitude,
                          p.longitude,
                          park_start                                             AS event_time,
                          jsonb_build_object(
                                  'cluster_id', cluster_id,
                                  'end_position_id', end_position_id
                              )                                                  AS attrs,
                          NULL::text                                             AS path
                   FROM parks_final f
                            LEFT JOIN positions p ON p.id = f.end_position_id)

SELECT *
FROM drive_event
UNION ALL
SELECT *
FROM charge_event
UNION ALL
SELECT *
FROM park_event