# Moxa i parser rekordów wagi

Strona opisuje, jak według nas Moxa przekazuje odczyty wagi, i jak parsujemy strumień bajtów na nasz model. Jest dla programistów `tcp-service`, `admin` i `mock` i testerów, którzy symulują działanie wagi. Założenia o Moxie wynikają z obserwacji działania wagi, a nie z dokumentacji producenta, dlatego strona ma znacznik.

## Jak zakładamy, że działa Moxa

Moxa to sterownik urządzeń szeregowych. Odbiera bajty z portu szeregowego wagi i wysyła je nieprzetworzone przez połączenie TCP. Nie zna formatu wagi, nie dodaje nagłówków i nie dzieli strumienia na wiadomości.

Z tego wynikają trzy skutki, które musimy obsłużyć.

1. Granice odczytów trzeba odtworzyć samemu, na podstawie znaków końca linii (CRLF).
2. TCP może przeciąć strumień w dowolnym miejscu, także między CR a LF.
3. Strumień może zawierać śmieci, jeśli coś innego pisze na ten sam port szeregowy.

## Co wiemy na podstawie testów

Plik `weight-protocol/src/test/resources/moxa-data.bin` zawiera bajty z przeprowadzonych testów. Test `RecordParserTest` używa go jako wzorca.

- Koniec linii to zawsze CR LF
- Zdarzają się puste linie
- Zdarzają się linie zaczynające się od `-`
- Zdarzają się linie dłuższe niż 6 bajtów (np. `ToolBar1`, `wybór`)
- Waga komunikuje się cały czas, nawet wtedy gdy waga jest pusta (rekordy `0`)

Typowa waga to liczba całkowita zapisana cyframi ASCII, bez znaku i bez jednostki. Zakładamy kilogramy, bo gdy Mateusz Szopa wszedł na wagę to pokazało `60`. Pusta waga wysyła `0`.

Linie `ToolBar1`, `wybór`, `-` i `-20` nie wyglądają jak odczyty wagi. Nie wiemy, skąd się biorą.

## Algorytm parsera

Klasa `RecordParser` jest automatem skończonym, który czyta strumień bajt po bajcie. Przyjmuje dane w dowolnych porcjach i pamięta stan między wywołaniami `parse`. Dla każdej kompletnej linii przekazuje do odbiorcy jeden `Record`.

### Zbieranie

Dla każdego bajtu `b` parser wykonuje te kroki.

1. Jeśli `b` to LF, a ostatni bajt w buforze to CR, linia jest kompletna.
2. Parser wywołuje `RecordClassifier.classify` dla bajtów od 0 do `len - 1`, czyli bez końcowego CR.
3. Wynik trafia do odbiorcy, `len` wraca do 0 i parser czyta następny bajt.
4. W przeciwnym razie `b` trafia do bufora i `len` rośnie o jeden.
5. Jeśli `len` osiągnie `maxRecordBytes`, parser przechodzi do przepełnienia.

CR trafia do bufora, bo parser nie wie jeszcze, czy po nim przyjdzie LF. Dlatego bufor musi pomieścić linię razem z CR. Poprawna waga o sześciu cyfrach potrzebuje siedmiu bajtów.

### Przepełnienie

Linia, która nie skończyła się przed zapełnieniem bufora, jest za długa, żeby być odczytem wagi.

1. Parser wysyła `Record.invalid` z bajtami, które zdążył zebrać, czyli z `maxRecordBytes` bajtami.
2. Ustawia `discarding` na `true`.
3. Ustawia `len` na `1`, jeśli ostatni bajt to CR, a w przeciwnym razie na `0`.

Od tej chwili parser odrzuca bajty, aż zobaczy LF bezpośrednio po CR. Wtedy wraca do zbierania z pustym buforem. Jedna zbyt długa linia daje dokładnie jeden rekord `INVALID`, niezależnie od jej długości.

Pole `len` pamięta, czy poprzedni bajt był CR, więc para CR LF jest rozpoznawana także wtedy, gdy trafi na granicę dwóch porcji danych.

### Przykład

Strumień `12\r\n7\r\n` przychodzi w trzech porcjach: `1`, `2\r` i `\n7\r\n`.

```
porcja 1:  '1'            buf="1"        len=1
porcja 2:  '2'            buf="12"       len=2
           CR             buf="12\r"     len=3
porcja 3:  LF po CR       classify("12") -> OK 12, len=0
           '7'            buf="7"        len=1
           CR             buf="7\r"      len=2
           LF po CR       classify("7")  -> OK 7, len=0
```

## Klasyfikator

`RecordClassifier.classify` dostaje bajty jednej linii bez CR LF i sprawdza je po kolei. Pierwszy pasujący warunek wygrywa.

| Krok | Warunek | Klasa |
| --- | --- | --- |
| 1 | linia ma zero bajtów | `EMPTY_LINE` |
| 2 | pierwszy bajt to `-` | `NEGATIVE` |
| 3 | linia ma więcej niż `MAX_DIGITS` bajtów, czyli 6 | `OVERWEIGHT` |
| 4 | któryś bajt nie jest cyfrą ASCII | `NON_DIGIT` |
| 5 | w pozostałych przypadkach | `OK` z wartością liczbową |

Kolejność ma znaczenie. Linia `1234567X` jest `OVERWEIGHT`, a nie `INVALID`, bo długość sprawdzamy przed cyframi. Linia `-abc` jest `NEGATIVE`, bo znak minus rozstrzyga od razu.

Klasyfikator liczy bajty, a nie cyfry. Dlatego tekst dłuższy niż 6 bajtów, jak `ToolBar1`, dostaje klasę `OVERWEIGHT`.
