Live_RC/docs/decoder-setup.sv.md

# Decoder-, IP- och AMMC-konfiguration

Den här guiden beskriver hur fysiska MyLaps/AMB-decoders kopplas till RC RaceCore. Exemplen använder följande nätverk:

| Enhet | Exempeladress | Uppgift |
|---|---:|---|
| RC RaceCore/backend | `192.168.1.100` | Kör Node.js, AMMC-processerna, webb och API |
| Operatörens laptop | `192.168.1.50` | Öppnar webbgränssnittet, kör inte AMMC |
| Main-decoder | `192.168.1.10` | Start/mål och varvräkning |
| Mellantidsdecoder | `192.168.1.11` | Valfri split/mellantid |
| Depå in-decoder | `192.168.1.12` | Öppnar depåstopp |
| Depå ut-decoder | `192.168.1.13` | Stänger depåstopp |

Byt adresserna mot adresserna i ditt nätverk.

## Tre olika adresstyper

De här värdena får inte blandas ihop:

| Värde | Exempel | Vem använder det? |
|---|---|---|
| Decoder-IP | `192.168.1.10` | AMMC ansluter till fysisk decoder |
| AMMC WebSocket | `ws://192.168.1.100:9000` | Webbläsaren ansluter till AMMC på backend-hosten |
| Backend URL | `http://192.168.1.100:8081` | Webbläsaren använder webb, API och sparning |

`127.0.0.1` betyder alltid "den här maskinen". Använd därför bara `ws://127.0.0.1:9000` när webbläsaren kör på samma dator som backend. Från en laptop ska du använda backend-datorns LAN-IP, till exempel `ws://192.168.1.100:9000`.

## Dataflödet

```text
Bilens transponder
  -> fysisk loop i banan
  -> fysisk decoder med egen IP
  -> AMMC-process på backend-datorn
  -> unik WebSocket-port på backend-datorn
  -> webbläsaren/RC RaceCore
  -> aktiv session, resultat och statistik
```

Komplett exempel:

```text
Main:      decoder 192.168.1.10 -> AMMC på backend :9000 -> main/start/mål
Split:     decoder 192.168.1.11 -> AMMC på backend :9001 -> mellantid
Depå in:   decoder 192.168.1.12 -> AMMC på backend :9002 -> öppna stopp
Depå ut:   decoder 192.168.1.13 -> AMMC på backend :9003 -> stäng stopp

Laptop 192.168.1.50 öppnar:
  http://192.168.1.100:8081
och ansluter till:
  ws://192.168.1.100:9000
  ws://192.168.1.100:9001
  ws://192.168.1.100:9002
  ws://192.168.1.100:9003
```

## Välj antal decoders

| Installation | Fysiska decoders | Aktivera |
|---|---:|---|
| Vanlig tidtagning | 1 | Main |
| Tidtagning + mellantid | 2 | Main + Split |
| Tidtagning + depåstopp | 3 | Main + Depå in + Depå ut |
| Komplett endurance | 4 | Main + Split + Depå in + Depå ut |

Depåtid kräver alltid både Depå in och Depå ut. En enda depådecoder kan inte beräkna stopptiden.

## Roller och standardportar

| Roll | Decoder-IP i exemplet | AMMC-port | Påverkar varv? | Sparad data |
|---|---:|---:|---|---|
| Main start/mål | `192.168.1.10` | `9000` | Ja | Passering, varv och varvtid |
| Mellantid | `192.168.1.11` | `9001` | Nej | Split från senaste main-passering |
| Depå in | `192.168.1.12` | `9002` | Nej | Tidpunkt och aktiv förare/bil vid infart |
| Depå ut | `192.168.1.13` | `9003` | Nej | Tidpunkt och färdig depåstopptid |

Varje fysisk decoder ska ha en unik IP. Varje aktiverad AMMC-process ska ha en unik WebSocket-port. Använd aldrig samma port för två roller.

## Rekommenderad konfiguration: Managed AMMC

AMMC körs på samma dator som startats med `npm start` eller `npm.cmd start`. Webbläsaren kan köras på en annan dator.

På Linux x86-64 kräver alla bundlade program i `AMMC/linux_x86-64` GLIBC 2.39 eller senare. Kontrollera med `ldd --version` eller `npm run verify`. RC RaceCore kan köras på en äldre host, men dessa bundlade AMMC-program fungerar då inte.

1. Starta backend.
2. Öppna `Inställningar`.
3. Kontrollera `Backend URL`: `http://192.168.1.100:8081` från andra datorer.
4. Aktivera `Hanterad AMMC`.
5. Fyll i de roller som finns fysiskt.

Exempel på fälten under `Hanterad AMMC`:

| Fält | Värde |
|---|---|
| Main decoder IP / host | `192.168.1.10` |
| Main WebSocket-port | `9000` |
| Aktivera mellantidsdecoder | På om decoder `.11` finns |
| Mellantid decoder IP / host | `192.168.1.11` |
| Mellantid WebSocket-port | `9001` |
| Aktivera depådecoders | På endast om både `.12` och `.13` finns |
| Depå in decoder IP / host | `192.168.1.12` |
| Depå in WebSocket-port | `9002` |
| Depå ut decoder IP / host | `192.168.1.13` |
| Depå ut WebSocket-port | `9003` |

6. Klicka `Spara AMMC`.
7. Klicka `Starta AMMC`.
8. Kontrollera att varje aktiverad process står som `Kör` och inte visar fel.
9. Klicka `Använd serverns WS-url`. Detta fyller klientfälten med backend-IP, inte decoder-IP.
10. Gå till `Tidtagning` och klicka `Anslut decoder`.
11. Kontrollera att Main och valfria roller står som `Ansluten`.

## Klientens WebSocket-fält

När backend är `192.168.1.100` ska klientinställningarna vara:

| Klientfält | Värde |
|---|---|
| Main WebSocket-url | `ws://192.168.1.100:9000` |
| Mellantid WebSocket-url | `ws://192.168.1.100:9001` |
| Depå in WebSocket-url | `ws://192.168.1.100:9002` |
| Depå ut WebSocket-url | `ws://192.168.1.100:9003` |

Skriv inte decoder-IP i WebSocket-url. `ws://192.168.1.10:9000` är normalt fel eftersom AMMC-porten finns på backend-datorn, inte på decodern.

## Manuell AMMC-start

Använd manuell start endast när backend inte ska hantera processerna. Kör en process per roll:

```powershell
ammc-amb.exe -w 9000 192.168.1.10
ammc-amb.exe -w 9001 192.168.1.11
ammc-amb.exe -w 9002 192.168.1.12
ammc-amb.exe -w 9003 192.168.1.13
```

Syntaxen är:

```text
ammc-amb -w <WebSocket-port på backend> <fysisk decoder-IP>
```

Starta bara processerna för de roller som används. Stäng av `Hanterad AMMC` om processerna startas manuellt, annars kan två processer försöka använda samma portar.

## Fake decoder med AMMC Simulator

`ammc-sim` simulerar en fysisk decoder. Den ersätter inte AMMC:s WebSocket-konverterare: starta först simulatorn och låt sedan `ammc-amb` ansluta till simulatorns dator. Håll testuppsättningen borta från det skarpa decodernätet under ett officiellt race.

Linux-exempel med fyra simulerade förare och en passering var 15:e till 22:a sekund:

```bash
./AMMC/linux_x86-64/ammc-sim \
  --transponder 1111111,2222222,3333333,4444444 \
  --passing-delay 15000-22000 \
  --my_ip 192.168.1.100 \
  --skip_telemetry_upload \
  AMB

./AMMC/linux_x86-64/ammc-amb -w 9000 192.168.1.100
```

På Windows används samma argument med `ammc-sim.exe` och `ammc-amb.exe`. Byt `192.168.1.100` till adressen för datorn som kör simulatorn. RC RaceCore ansluter fortfarande till `ws://<AMMC-host>:9000`. Använd transpondernummer som är registrerade i RaceCore, eller kör Open Practice för att visa okända nummer direkt.

Användbara simulatorval:

| Val | Funktion |
|---|---|
| `--transponder 123,456` | ID:n som fake decodern skickar |
| `--passing-delay 15000-22000` | Slumpad tid mellan passeringar i millisekunder |
| `--passing-numbers 1-500` | Stoppa efter angivet intervall av passeringsnummer |
| `--startup_delay_secs 5` | Vänta innan passeringarna börjar |
| `--my_ip <adress>` | Adress som returneras vid decoder-autodiscovery |

Kör `ammc-sim --help` för valen i den bundlade versionen. Simulatorn är bara en testkälla; varvvalidering, stintlogik, leaderboard och lagring går fortfarande genom RaceCores vanliga eventflöde.

## Brandvägg

Portarna öppnas på backend-datorn, inte på operatörens laptop.

Linux/UFW:

```bash
sudo ufw allow 8081/tcp
sudo ufw allow 9000:9003/tcp
```

Windows, kör installationsskriptet som administratör:

```powershell
Start-Process powershell -Verb RunAs -ArgumentList '-ExecutionPolicy Bypass -File .\windows\setup.ps1 -OpenFirewall -StartServer'
```

Det öppnar TCP `8081` och `9000-9003`. Öppna endast portarna på ett betrott LAN. Exponera inte admin-UI, API eller AMMC-portar direkt mot internet.

## Start- och testordning

1. Pinga varje fysisk decoder från backend: `ping 192.168.1.10` och motsvarande extradecoders.
2. Starta backend och kontrollera `npm run status` eller `npm.cmd run status`.
3. Starta Managed AMMC.
4. Läs AMMC-loggen i `Inställningar`. Fel mot decoder-IP ska lösas innan webbläsaren felsöks.
5. Anslut rollerna i `Tidtagning`.
6. Kör en transponder över Main. Antal varv ska öka.
7. Kör över Split. Mellantiden ska uppdateras men varvantalet ska vara oförändrat.
8. Kör över Depå in. Status ska bli `I DEPÅ`.
9. Kör över Depå ut. Ett depåstopp med tid ska skapas.

## Var data visas

- `Tidtagning`: live leaderboard, split och aktiv/fullständig depålogg.
- `Overlay`: senaste split och depåstatus för aktiv session.
- `Race Setup -> Hantera -> Live / resultat`: sammanställning per heat.
- Resultat/PDF: split-/depåsammanställning och full depålogg.
- `Träning -> Mer statistik`: statistik per personlig profil och vald klass.
- Personlig mobilprofil: endast sanerade aggregat, aldrig transponder eller rå depålogg.

## Felsökning

| Symptom | Trolig orsak | Kontroll |
|---|---|---|
| `Decoder offline` | Main WebSocket kan inte nås | AMMC main kör, port `9000`, brandvägg |
| AMMC startar men stannar | Fel decoder-IP, binär eller bibliotek | AMMC-logg och ping från backend |
| `GLIBC_2.39 not found` | Bundlad Linux-AMMC är nyare än hostens GLIBC | Använd GLIBC 2.39+ eller kompatibel AMMC-build; byt aldrig systemets GLIBC manuellt |
| Laptop når sidan men inte tider | WS-url använder `127.0.0.1` | Byt till `ws://<backend-IP>:9000` |
| Main fungerar men split saknas | Split ej aktiverad eller port blockerad | `.11`, port `9001`, status i Tidtagning |
| Depå in visas men inget stopp skapas | Depå ut saknas eller använder fel roll | `.13`, port `9003`, separat fysisk loop |
| Varv ökar vid mellantid | Samma feed/roll används fel | Main och Split ska ha separata decoder-IP/portar |
| `EADDRINUSE` | Två processer använder samma port | Stoppa manuell AMMC eller byt unik port |
| Ingen anslutning efter kopierade filer | Backend kör gammal kod | `npm restart` eller `npm.cmd restart` |

## Regler som inte får ändras

- Endast Main får räkna varv.
- Split och depå får aldrig läggas in som vanliga passeringar.
- Depå in och Depå ut måste vara två separata roller.
- Ett depåstopp kopplas till förare/bil vid depåinfarten även om laget byter förare innan utfarten.
- Olika klasser hålls separerade i förarstatistik.