\section{Funktioner och filer}

\subsection{System}

choose\_position(position, segment, track, track\_len)

Körs när en givare passerats. Gör en bedömning om en givare (eller flera) har
missats genom att kontrollera vilken givare som är närmast den nuvarande
uppskattade position och kompenserar om en givare bedöms ha missats.

clamp(n, m, M)

En hjälpfunktion som returnerar n om $m < n < M$, annars m om $n < m$, annars M
om $n > M$.

detect\_missed(position, segment, track, track\_len)

Returnerar true om position ligger utanför det nuvarande segmentet.

do\_boot(car, boot)

Anropas en gång per programcykel i den så kallade boostrap-fasen. Se ANNAN DEL
AV TEXTEN för information.

do\_car(car, t, displa\_data, boot)

Anropas en gång per programcykel. Se ANNAN DEL AV TEXTEN och EN ANNAN DEL
AV TEXTEN för information om hur en programcykel ser ut och NÅGOT MER.

do\_gov(car)

Anropas varje gång en givare passerats. Vid målgivaren jämförs referenstiden och
den förra varvtiden och car.constant anpassas efter differensen mellan dem. Om
differensen är högre ändras car.constant mer, och vice versa om differensen är
låg. Vid givare 5 och 8 jämförs referenstiden och en uppskattning av hur lång
tid det nuvarande varvet troligen kommer ta. Se EN ANNAN DEL AV TEXTEN för
mer information.

fit\_percents(percents, lap\_time, seg\_times)

Anropas vid varje nytt varv. Räknar ut den procentuella tiden varje segment tog
det förra varvet och sparar medelvärdet mellan den förra procentsatsen och den
nya, uträknade procentsatsen. Procentsatsen normeras sedan så summan är 1
(100%).

format\_seg\_times(car)

Anropas när körningen avslutas. Returnerar den genomsnittliga tiden för varje
segment.

get\_aprox\_v(cur\_seg, car)

Anropas varje programcykel. Uppskattar bilens nuvarande hastighet genom att
dividera den senast uppmätta segmentstiden med segmentets längd.

get\_new\_u(new\_v, seg\_constant

FLYTTA BERÄKNINGEN TILL DO\_CAR, BEHÖVER INTE VARA EN EGEN FUNKTION

get\_new\_v(position, list)

Anropas varje programcykel. Söker igenom bankartan och returnerar värdet v som
matchar position.

get\_position(aprox\_v, prev\_p, delta\_t)

Anropas varje programcykel. Räknar ut hur långt bilen rört sig sedan senaste
programcykeln.

get\_seg\_constant(position, lap\_constants, track, track\_len)

TA BORT

get\_time\_as\_string(millis)

Omvandlar en mängd millisekunder till formatet "mm:ss.s". Till exempel omvandlas 1250
ms till "00:01.3" och 11240 till "00:11.2".

main.m

Huvudskriptet som startar hela systemet.

\subsection{Display}

bar\_graph(direction, no, x1, x2, y1, y2, start\_value, end\_value, type, pattern):

Skapar ett stapeldiagram med ett hörn i (*x1*, *y1*) och ett diagonellt
hörn i (*x2*, *y2*). *direction* är en av 'O', 'U', 'L' och 'R' och
bestämmer åt vilket håll "upp" är på stapeln. 'O' står för upp ('oben'
på tyska), 'U' står för ner ('unter' på tyska), 'L' står för vänster
('links') och 'R' står för höger ('rechts'). Värdet stapeldiagrammet ska
visa specifieras med *update\_bar\_graph*. *start\_value* och
*end\_value* bestämmer vad som ska vara noll- respektive maxvärde för
stapeldiagrammet. *no* är stapeldiagrammets nummer och behöver
specifieras när stapeldiagrammets värde ska uppdateras. *type* sätts
till 0 för en enkel stapel och 1 för en stapel inuti en ram.

box(x1, y1, x2, y2, n1)

Ritar en rektangel med diagonella hörn i (*x1*, *y1*) och (*x2*, *y2*)
och mönster-nummer *n1*.

clear\_display()

Rensa displayen.

continue\_line(x2, y2)

Fortsätt en linje från den senast specifierade linjens slut till (*x2*,
*y2*).

delete\_area(x1, y1, x2, y2)

Ta bort (släck) alla pixlar i det rektangulära området mellan (*x1*,
*y1*) och (*x2*, *y2*).

draw\_line(x1, y1, x2, y2)

Rita en linje mellan (*x1*, *y1*) och (*x2*, *y2*).

draw rectangle(x1, y1, x2, y2)

Rita en rektangel (ej ifylld) mellan (*x1*, *y1*) och (*x2*, *y2*).

fill\_area(x1, y1, x2, y2)

Tänd alla pixlar i det rektangulära området mellan (*x1*, *y1*) och
(*x2*, *y2*).

fill\_area\_with\_pattern(x1, y1, x2, y2, n1)

Fyll det rektangulära området mellan (*x1*, *y1*) och (*x2*, *y2*) med
mönster *n1*.

fill\_display()

Tänd alla pixlar på displayen.

flashing\_area(x1, y1, x2, y2)

Fyll det rektangulära området mellan (*x1*, *y1*) och (*x2*, *y2*) med
blinkande pixlar. Blinkintervallet kan sättas med *set\_flashing\_time*.

flashing\_area\_with\_pattern(x1, y1, x2, y2)

Fyll det rektangulära området mellan (*x1*, *y1*) och (*x2*, *y2*) med
blinkande pixlar i ett mönster. Blinkintervallet kan sättas med
*set\_flashing\_time*.

invert\_area(x1, y1, x2, y2)

Tänd alla släckta pixlar och släck alla tända pixlar i det rektangulära
området mellan (*x1*, *y1*) och (*x2*, *y2*).

invert\_display()

Tänd alla släcka pixlar och släck alla tända pixlar på hela displayen.

key(x1, y1, x2, y2, down\_code, up\_code, just, text)

Skapa en tryckbar knapp (till skillnad från en omkopplare, se
*toggle(...)*) med diagonella hörn i (*x1*, *y1*) och (*x2*, *y2*) och
texten *text*. Hur texten justeras beror på *just* där 'R' gör texten
högerjusterad ('right'), 'C' gör texten centerjusterad och 'L' gör
texten vänsterjusterad ('left'). Om knappen trycks ned läggs
*down\_code* i displayens interna minne och om knappen släpps läggs
*up\_code* i displayens interna minne.

point(x1, y1)

Rita en punkt i (*x1*, *y1*). Punktens storlek kan anpassas med
*set\_point\_size*.

put\_text(x, y, justification, text)

Skriv ut texten *text* i (*x*, *y*). Hur texten justeras beror på
*justification* där 'R' gör texten högerjusterad ('right'), 'C' gör
texten centerjusterad och 'L' gör texten vänsterjusterad ('left'). Om
*justification* är 'R' bestämmer *x* och *y* textens övre högra
koordinat, om *justification* är 'C' bestämmer *x* och *y* textens
mittre koordinat och om *justification* är 'L' bestämmer *x* och *y*
textens övre vänstra koordinat.

redraw\_bar\_graph(num)

Tvinga stapeldiagram *num* att ritas om.

remove\_flashing\_area(x1, y1, x2, y2)

Ta bort blinkade pixlar i det rektangulära området mellan (*x1*, *y1*)
och (*x2*, *y2*).

request\_bar\_graph\_value(num)

Lägg nuvarande värdet för stapeldiagram *num* i displayens interna
minne.

restore\_display\_from\_clipboard()

Flytta innehållet från displayens urklipp till displayen.

restore\_display\_from\_clipboard\_to\_point(x1, y1)

Flytta innehållet från displayens urklipp till displayen med övre
vänstra hörn i (*x1*, *y1*). Spara ett område med
\_save\_area\_to\_clipboard(...).

save\_area\_to\_clipboard(x1, y1, x2, y2)

Kopiera innehållet i den rektangel mellan (*x1*, *y1*) och (*x2*, *y2*)
till displayens urklipp. Återställ med
*restore\_display\_from\_clipboard\_to\_point(...)*.

save\_display\_to\_clipboard()

Kopiera displayens nuvarande innehåll till displayens urklipp. Återställ
med *restore\_display\_from\_clipboard()*.

set\_display\_visible(visible)

Sätt om displayen ska vara synlig (*visible* = true) eller om displayen
ska vara osynlig (*visible* = false). Att displayen är osynlig innebär
att innehållet inte syns men finns kvar i bakgrunden och kan visas igen
om *set\_display\_visible(true)* skickas.

set\_drawing\_mode(n1)

Sätt displayens ritläge. *n1* = 1 innebär att pixlar slås på eller av
(som vanligt) enligt kommandot som skickas, *n1* = 2 innebär att pixlar
enbart slås av (som ett suddgummi) och *n1* = 3 innebär att pixlar
inverteras (släckta pixlar slås på och tända pixlar stängs av)

set\_flashing\_time(n1)

Sätt intervallet blinkande objekt blinkar i. *n1* är ett intervall i
tiondelar av en sekund mellan 0,1 sekunder och 1,5 sekunder.

set\_line\_pattern(n1)

Sätt mönstret linjer ritas ut med.

set\_point\_size(n1, n2)

Sätt storleken på punkter och linjer som ritas ut. *n1* är storleken i
x-led (mellan 1 och 15 pixlar) och *n2* är storleken i y-led (mellan 1
och 15 pixlar).

set\_text\_flashing(n1)

Sätt om ny text som skrivs ut ska blinka eller inte. *n1* = 1 slår på
blinkande och *n1* = 2 stänger av blinkande.

set\_text\_font(font\_num)

Sätt typsnittet på ny text som skrivs ut. Se *REF* för information om de
olika typsnitten.

set\_text\_zoom(x\_scale, y\_scale)

Sätt skalfaktorn för ny text som skrivs ut. *x\_scale* är skalfaktorn i
x-led (mellan x1 och x8) och *y\_scale* är skalfaktorn i y-led (mellan
x1 och x8).

set\_touch\_sound\_response(state)

Sätt om displayen ska göra ljud när knappar trycks ned. *state* = 1 slår
på ljudet och *state* = 0 stänger av ljudet.

toggle(x1, y1, x2, y2, down\_code, up\_code, just, text)

Skapa en tryckbar omkopplare (till skillnad från en knapp, se
*key(...)*) med diagonella hörn i (*x1*, *y1*) och (*x2*, *y2*) och
texten *text*. Hur texten justeras beror på *just* där 'R' gör texten
högerjusterad ('right'), 'C' gör texten centerjusterad och 'L' gör
texten vänsterjusterad ('left'). Om knappen aktiveras läggs *down\_code*
i displayens interna minne och om knappen avaktiveras läggs *up\_code* i
displayens interna minne.

update\_bar\_graph(num, val)

Skicka värdet *val* till stapeldiagram *num*.