Drive the bench CAM beacon round a street loop in St. Georg

The bench transmitter sent a parked car: one fixed position, speed 0,
no heading, a CAM every second. It now simulates a car driving a loop
through six waypoints around Berliner Tor on the real streets, which
makes it a moving target for the app's map and the use case detection
without taking a car out.

The route is generated, not hand-traced. tools/make_route.py asks the
OSRM demo server for a driving route through the waypoints and back to
the first, thins the 371 street points to 103 (none more than 1.5 m off
the line), and writes main/route_points.h. It also saves OSRM's answer
(--offline rebuilds from it) and a map page to check the route before
flashing. Each waypoint is sent with the direction towards the next one:
without it, points on divided roads such as Beim Strohhause snapped to
the opposite carriageway and the loop came out at 8.4 km of U-turns.
With it the loop is 5.2 km, still including two turn-round detours
that OSRM needs to reach the waypoints legally (Borgfelder Strasse /
Anckelmannsplatz, and Nagelsweg / Norderstrasse / Repsoldstrasse).
Route data (c) OpenStreetMap contributors, ODbL.

main/route.c moves the car along the points. It cruises at 50 km/h and
limits each bend to the speed that keeps sideways acceleration at
2 m/s^2, so a junction turn is taken at about 15 km/h and a gentle curve
barely slows it; braking (2 m/s^2) and acceleration (1.5 m/s^2) are
planned across as many points as a bend needs. A simulated lap on the
host is 5.16 km in 7.7 min, averaging 40 km/h.

CAMs now follow the EN 302 637-2 generation rules instead of a fixed
1 Hz: checked every 100 ms, sent on a heading change over 4 degrees, a
move over 4 m, a speed change over 0.5 m/s, or after 1 s - about 3 Hz
at 50 km/h. generationDeltaTime is milliseconds since boot. The
GeoNetworking source position vector now carries the same speed and
heading as the CAM instead of zeros.

NOTES.md gains build and flash steps (including reading a board's app
descriptor first, since both firmwares name their image
obu_firmware.bin) and a section on the simulated drive. The pointer to
docs/04-transmit-setup.md is corrected: that file is not in the repo.

Flashed to the COM8 board and checked on its console: it starts driving
on power-up and sends CAMs with changing position, speed and heading.
Not yet received over the air.

obu-cam-transmistter/main/geonet.c

@@ -4,6 +4,7 @@
 int geonet_wrap_shb(const uint8_t *its_payload, int its_len,
                      const uint8_t mac[6], uint8_t station_type,
                      int32_t latitude_tenmicrodeg, int32_t longitude_tenmicrodeg,
+                     uint16_t speed_cm_s, uint16_t heading_ddeg,
                      uint16_t btp_dest_port,
                      uint8_t *out, size_t out_len)
 {
@@ -68,12 +69,12 @@ int geonet_wrap_shb(const uint8_t *its_payload, int its_len,
     uint32_t lon_u = (uint32_t)longitude_tenmicrodeg;
     *p++ = (uint8_t)(lon_u >> 24); *p++ = (uint8_t)(lon_u >> 16);
     *p++ = (uint8_t)(lon_u >> 8);  *p++ = (uint8_t)(lon_u);
-    // PAI(1 bit) + Speed(15 bits), packed into 2 bytes: 0 = PAI false,
-    // speed 0 - which is actually correct semantics for a STATIONARY
-    // vehicle beacon, not just a placeholder.
-    *p++ = 0x00; *p++ = 0x00;
-    // Heading (16 bits, 0.1 degree units): 0 = due north / unavailable
-    *p++ = 0x00; *p++ = 0x00;
+    // PAI(1 bit) + Speed(15 bits, signed, 0.01 m/s), packed into 2 bytes. PAI stays 0: the
+    // position has no accuracy estimate behind it.
+    uint16_t spd = speed_cm_s > 0x7FFF ? 0x7FFF : speed_cm_s;
+    *p++ = (uint8_t)(spd >> 8); *p++ = (uint8_t)(spd & 0xFF);
+    // Heading (16 bits, 0.1 degree units, clockwise from north)
+    *p++ = (uint8_t)(heading_ddeg >> 8); *p++ = (uint8_t)(heading_ddeg & 0xFF);
     // Reserved (4 bytes) - clause 9.8.4: the SHB extended header is the 24-byte Source Position
     // Vector FOLLOWED BY a 4-byte reserved field (media-dependent data), 28 bytes in total. These
     // four bytes were missing, which is why a standards-compliant receiver read our CAM payload's