Första utkast

1 files changed, 611 insertions, 11 deletions

diff --git a/Dokument/Teknisk Dokumentation/root.tex b/Dokument/Teknisk Dokumentation/root.tex
index 89fa89c..55bf363 100644
--- a/Dokument/Teknisk Dokumentation/root.tex
+++ b/Dokument/Teknisk Dokumentation/root.tex
@@ -2,6 +2,7 @@
 
 %\usepackage[square]{natbib}\bibliographystyle{plainnat}\setcitestyle{numbers}
 \usepackage[round]{natbib}\bibliographystyle{plainnat}
+\usepackage{parskip}
 
 % Configure the document
 \title{Teknisk dokumentation}
@@ -67,7 +68,7 @@
   \multicolumn{1}{|c}{\bfseries Granskad}\\
   \hline
   \hline
-  0.1 & 2019-11-26 & Förberedande struktur & Albin & \\
+  0.1 & 2019-11-30 & Första utkast & Alla & \\
   \hline
 \end{tabular}
 
@@ -79,20 +80,619 @@
 \tableofcontents
 \cleardoublepage
 
-\input{text/01-inledning}
-\input{text/02-metod}
-\input{text/03-system}
-\input{text/04-resultat}
-\input{text/05-diskussion}
+\section{Inledning}
+\subsection{Bakgrund}
+\subsection{Syfte och mål}
+
+\section{Begrepp och systemöversikt}
+\section{Systembeskrivning}
+
+\subsection{Innan start}
+
+Vid uppstart ritas knappar ut på displayenm se figur x. Med dessa knappar går
+det att välja om en eller två banor ska vara aktiva och om de ska styras
+autonomt av systemet eller manuellt med handkontroll. Det går också att ställa
+in en referenstid mellan 12 och 15 sekunder med 0,5 sekunders intervall genom
+att trycka på + och - på displayen. Varje 0,x sekunder skickas ett kommando till
+displayen som skickar information om alla knapptryck som skett sedan minnet
+efterfrågades senast. Händelserna bearbetas i den kronologiska ordning de
+trycktes i och ändrar på variabler enligt de knapptryck som skett.
+
+\subsection{Uppstart} 
+
+Vid automatisk körning körs funktionen "do\_boot" vars syfte är att få fram en
+initierande konstant ("car\_constant") för den bil som står på banan. då bilen är
+positionerad framför målbågen höjer funktionen konstanten kontinuerligt i ett
+tidsintervall på 0.7 sekunder. när väl konstanten är tillräckligt stor för att
+bilen ska kunna rulla och passera målbågen så höjs inte konstanten lika mycket
+och gör det desto mer sällan. vid passering av den andra givaren så slutar
+funktionen tillfälligt att förändra konstanten och låter bilen, med den
+tilldelade konstanten, åka igenom segment 3 för att få en uträknad tid. med
+tiden det tagit för bilen att ta sig igenom segment 3 räknar funktionen ut
+vilken förväntad varvtid bilen skulle få med just den konstanten den hade i
+segmentet.  (beskriva forecastsuträkningen?) det sista funktionen gör är att
+återigen justera konstanten. om den förväntade varvtiden är större än 15
+sekunder, som är referensvarvtiden för första varvet, så ökar konstanten och är
+den förväntade varvtiden mindre än 15 sekunder så sänks konstanten. 
+
+\subsection{Körning}
+
+Huvudloopen körs åtminstonde 10 gånger i sekunden. Den beräknar först var bilen
+befinner sig, sedan väljer den hur snabbt bilen ska köra och slutligen sätts den
+hastigheten till banan.
+
+Den viktigaste delen av huvudloopen är funktionen \emph{do\_car}. Funktionen
+beräknar de ändrinar som skall göras i matlab-structen \emph{car} och är indelad
+i många delar.
+
+\subsubsection{Position}
+
+Det finns två fall när positionen ska beräknas. När en givare har passerats och
+när en givare inte har passerats. Under första varvet görs endast det första och
+från varv 2 och frammåt görs båda paralellt. 
+
+Om en ny givare har passerats, \emph{car.new\_check\_point == true}, ökar
+programmet nuvarande segment (\emph{car.segment}) med 1. emp{car.segment}, som
+alltid ligger mellan 1 och 9, används som index för att välja position i en
+lista (\emph{car.pos\_at}). 
+
+Om ingen givare har passerars och bilen har avslutat första varvet, alltså
+oftast, görs lite mer avancerade beräkningar. För att beräkna positionen
+använder proggrammet först en funktion \emph{get\_aprox\_v}. Denna utgår ifrån
+förra varvets segmentstider (\emph{car.seg\_times}) och segmentslängder
+(\emph{car.seg\_len}) och beräknar med v = s/t medelhastigheten för nuvarnade
+segment, men förra varvet. Denna antas vara ungefär samma sak som nuvarande
+hastiget. 
+
+Sedan beräknas den fakiska positionen, i meter från målgivaren, med funktionen
+\emph{get\_position}. Den använder den ungefärliga hastigheten beräknad av
+\emph{aprox\_v} och tiden sedan denna beräkning gjordes senast (en programcykel)
+och beräknar med s = v * t den sträcka som bilen har äkt. Sedan adderas denna
+med förra kända postionen och retuneras i \emph{car.position}. 
+
+Sedan beräknas det gaspådrag som skall sättas till banan. Detta görs i två
+funktioner, \emph{get\_new\_v}) och \emph{get\_new\_u}.
+ 
+I \emph{get\_new\_v} används bilens nuvarande postition (\emph{car.postition})
+och hastihetskartan (\emph{car.map}). I (\emph{car.map}) finns en
+hastighetsparameter för varje \emph{car.position}, denna retuneras av funktionen
+och sparas i \emph{car.v}.
+ 
+I \emph{get\_new\_u} används denna hastighetsparameter tillsammans med
+\emph{car.constant}. Dessa multipliceras och deras produkt retuneras och sparas
+i \emph{car.u}.
+
+\subsubsection{Governor}
+
+Sedan, om bootstrap är avslutad, körs den del av koden vars ända uppgift är att 
+anpassa \emph{car.constant}. 
+
+Detta görs med funktionen \emph{do\_gov}. 
+
+Först görs en uppskattning av varvtiden utifrån hur lång tid varvet har tagit än
+så länge. Om bilen är inne på sitt första varv görs uppskattningen endast
+utifrån förra segmentet \emph{car.forcasts\_naive} och om första varvet är
+avslutat använder den i stället \emph{car.forcasts} som kollar på hela varvtiden
+fram till och med nu. Detta görs efter segment 4 och 8. Desutom används den
+faktiska varvtiden när bilen passerar mål (från varv 2 och frammåt).
+ 
+Sedan jämförs den uppskattade varvtiden med referenstiden \emph{car.ref\_time}.
+Om den uppskattade varviden är högre än referenstiden höje \emph{car.constant}
+och om den är lägre sänks \emph{car.constant}.
+
+\subsubsection{Display}
+
+I varje programcykel skickas nuvarande värdet på u till två stapeldiagram på
+displayen för vardera bil. Se appendix N för mer information om displayens
+stapeldiagram. Om ett nytt varv har inletts skrivs dessutom varvnumret och
+varvtiden ut på displayen.
+
+\subsection{Avslut}
+
+När körningen avslutas så får banan ingen mer spänning och bilarna stannar.
+Ifall en bil har kört fler än 2 varv så sparas statistik från körningen. 
+
+\section{Händelser}
+
+\subsection{Avslutning av körning}
+
+För att avbryta programmet manuellt kan användaren när som helst trycka på s
+eller q på datorns tangentbord. Trycker användaren på q avslutas programmet
+direkt. Trycker användaren på s stoppas varje bil var för sig när de är 80 cm
+från målgivaren och programmet avslutas när båda bilarna står stilla.
+
+Om det har gått mer än nio sekunder sedan en givare passerades pausas programmet
+och användaren informeras på styrdatorn att en bil misstänkts ha fastnat eller
+åkt av banan. 
+
+Vid programslut visas statistik om varvtid och genomsnittlig segmenttid på
+displayen. Se figurer xx-xx.
+
+\subsection{Missade givare}
+
+\section{Programslut}
+
+display\_post\_race\_graphs(seg\_times1, seg\_times2, lap\_times1, lap\_times2,
+ref\_time) hanterar knapptryck för att byta mellan de två vyerna. Varje 0,4
+sekunder skickas ett kommando till displayen som kopierar det interna minnet
+till minnet som delas med styrdatorn. Minnet som delas med styrdatorn läses av
+och eventuella knapptryck hanteras genom anrop till antingen
+draw\_lap\_graph(...) eller draw\_segment\_graph(...).
+
+draw\_lap\_graph(lap\_times1, lap\_times2, ref\_time) ritar varvtider för
+ena bilen i taget och skriver ut medelvärde och standardavvikelse, se figur xx.
+
+Hur mycket ska jag skriva om implementationen här?
+
+draw\_segment\_graph(seg\_times1, seg\_times2)
+
+Samma fråga här som raden ovanför.
+
 
 \bibliography{references}
 
 \cleardoublepage
 \appendix
-\input{appendix/01-handhavande}
-\input{appendix/02-funktion}
-\input{appendix/03-testprocedur}
-\input{appendix/04-testprotokoll}
-\input{appendix/05-kravbeskrivning}
+\section{Handhavande}
+Proceduren till handhavande för Matlab:
+
+Starta Matlab 2015b. Observera att användaren måste använda datorn som finns
+inne i bilbanerummet och som är inkopplade till bilbanan. Väl inne i Matlab
+öppna filvägen för hårdisk X: och hitta sökvägen till yc4\_2019.
+
+Därefter markera och högerklicka på mappen kod och där kommer ett alternativ som
+heter Add To Path. Välj sedan Select Folders And Subfolders som dyker upp när
+musen pekar på Add To Path. Därefter expandera bilbana mappen följt av yc4
+mappen. Öppna sedan main.m och starta systemet genom att klicka på Run i Editorn
+i Matlab.
+
+När koden körs i Matlab är dags att starta bilarna detta görs genom att via den
+externa touch displayen. Där finns möjligheterna att välja antalet banor som ska
+köras samt möjligheten att justera referenstiden. Kryssa även i om någon av
+banorna ska köras manuellt. Därefter starta genom att trycka på knappen nere i
+det högra hörnet på displayen.
+
+När programmet ska avslutas klickar användaren i kommentar fönstret i Matlab och
+klickar på q om bilen ska stanna direkt. Om användaren istället vill att
+bilen/bilarna ska stanna precis innan målgivaren klickar användaren på s
+(observera att detta fungerar endast efter varv ett).
+
+När programmet avslutas finns möjligheterna att se varvtiden/varvtiderna,
+segmentstiden/segmentstiderna samt att avsluta. Detta väljs utifrån de tre
+knapparna längst ner på displayen. Dessa knappar är Varv för att se varvtid,
+Segment för att se segmentstider. Samt knappen Avsluta.
+
+Om knappen Varv väljs kommer information såsom “target” vilket är vald varvtid.
+“Mean” som är genomsnittlig varvtid och “Stdev” är standardavvikelsen. För att
+se varvtiden för den andra banan klicka på knappen uppe i högra hörnet.
+
+Om programmet kraschar: Om programmet kraschar öppna main.m. Därefter skriv in
+ctrl och enter i avgränsningen som heter "\%\% END OF RACE" som finns i slutet av
+koden main.m.
+
+\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*.
+
+\section{Material}
+
+Projektgruppen har av beställaren tillhandahållits ett lab med följande utrustning:
+
+\begin{itemize}
+	\item En bilbana utrustad med givare vars funktion är att detektera passerade bilar.
+	\item Två datorer
+	\item En display med touchfunktionallitet. 
+	\item Ett antal bilar 
+\end{itemize}
+
+\section{Sluttest}
+
+\section{Kravbeskrivning}
+
+Krav 1. Systemet är helt skrivet i matlab.
+
+Krav 2. Systemet kan startas oavsett bil på banan.. 
+
+Krav 3. Systemet klarar av att missa givare. 
+
+Krav 4. När ett varv har körts så uppdaterar displayen vilket varv som nyss
+genomfördes samt varvtiden. 
+
+Krav 5. Under programmets gång visas det nuvarande gaspådraget. 
+
+Krav 6. Efter att programmet avslutats visas information på displyen.
+
+Krav 7. Systemet kan köras oavsett vilken bil som placeras på banan. 
+
+Krav 8. Programmet hanterar driftsfall genom att kompensera en större eller
+mindre styrsignal. 
+
+Krav 9. Om systemet inte får en nt insignal i form av en passerad givare inom
+tio sekunder pausas systemet och användaren får frågan om denne vill fortsätta
+eller avsluta. 
+
+Krav 10. Användaren har alternativet att köra en eller båda banorna samt hur
+banorna ska köras, autonomnt eller manuellt. Det manuella alternativet uppfyller
+inte krav 8 på beslut av beställaren. 
+
+Krav 11. Kravet struket från beslut av beställare. 
+
+Krav 12. Tillsammans med frågan om bana ett eller två ska köras frågar
+programmet systemet om banan ska köras manuellt eller autonomt. 
+
+Krav 13. För att starta programmet krävs att man kan öppna matlab och starta
+programmet. Därefter kan användaren starta med hjälp av displayen.  
+ 
+Krav 14. När systemet startar frågar programmet användaren vilka banor som skall
+köras samt vilken referenstid de ska ha. 
+
+Krav 15. Systemet ställer de frågor till användaren via touch displayen.
+
+Krav 16. Enligt de två givna testerna åkte bilarna inte av banan.
+
+Krav 17. När programmet startas frågar programmet användaren vilken referenstid
+som ska strävas efter, detta görs i ett intervall ]12,15[ med justeringar på 0,5
+sekunder upp eller ner. 
+
+Krav 18. Enligt de två visade körningarna stannade inte bilarna under något
+tillfälle. 
+
+Krav 19. 
+
+Krav 20. De två testkörningarna resulterade i en standardavvikelse på 0,22
+respektive 0,24. Kravet är delvis uppnått. 
+
+Krav 21. De två testkörningarna resulterade i att bilarna överskred gränsen på
+0.5 ett fåtal gånger, kravet delvsi uppnått. 
+
+Krav 22. Kraven var delvis uppfyllda efter 5 varv. 
+
+Krav 23. Kravet struket av beställaren. 
+
+Krav 24. Resultaten sparades och delades med beställaren via email.  
+
+Krav 25. Efter avslutad körning visas statistik i form av de plottar som önskas
+i kravspecifikationen. 
+
+Krav 26. Efter avslutad körning sparas alla data i en fil.  
+
+Krav 27. Längre upp i dokumentet beskrivs hur tidtagningen gick till och hur den
+validerades.
+
+Krav 28. 
+
+Krav 29. Deltagande i projektet har angett den tid de jobbat efter varje moment. 
+
+Krav 30. Handledaren har inte bidragit med hjälp i mer än 25h.
+
+Krav 31. Efter att programmet avslutas visas den cykel som tog längst tid, då
+den inte passerar 0,1 sekunder. 
+
+Krav 32. Efter två veckor av projektet godkänndes projektplanen. 
+
+Krav 33. Under projektvecka fyra godkändes designspecifikationen av beställaren. 
+
+Krav 34. Under projektvecka fem redovisade projektgruppen kraven 2, 4, 31 samt 25. 
+
+Krav 35. Under projektvecka sju redovisade projektgruppen kraven 3, 5, 10, 17
+samt 18. Även de krav som uppfylldes under bp.4a visades. 
+
+Krav 36. Under projektvecka nio redovisade projektgruppen samtliga Lrav som
+uppfyllts tidigare samt alla krav i avsnitt 3.2.
+
+Krav 37. Programvaran levererades under projektvecka 10. 
+
+Krav 38. Den tekniska dokumentationen levererades under projektvecka 10. 
+
+Krav 39. Under projektvecka tio hölls en slutleverans där gruppen visade upp
+samtliga krav och höll en presentation över vad hur arbetet har sett ut. 
+
+Krav 40. Inför varje beslutspunkt har önskade dokument varit beställaren
+tillhandahållna innan 09:00 arbetsdagen innan mötet. 
+
+Krav 41. Projektledaren har delat tidsrapportering samt eventuella
+mötesprotokoll vid rätt tid de flesta av projektveckorna, kravet är därför
+delvis uppnått.
+
+Krav 42. Alla dokument samt all programvara har samlats i gitlab minst en gång i
+veckan sedan projektvecka 2. 
+
+Krav 43. Projektplan, designspecifikation, mötesprotokoll, teknisk
+dokumentation, testprotokoll samt efterstudie har gjorts. 
+
+Krav 44. Dokument samt programvaran har bearbetats samt lagrats på
+http://gitlab.ida.liu.se/.  
+
+Krav 45. Alla dokument framtagna av projektgruppen har levererats i pdf-format. 
+
+Krav 46. Alla dokument skrivna av projektgruppen är är skrivet på formell
+korrekt svenska.
+
+Krav 47. Dokumentationen innehåller, 
+
+Krav 48. Programmet är uppdelat i funktioner. 
+
+Krav 49. Projektgruppen har samtlats på mint ett möte i veckan där alla
+medlemmar har närvarat. Handledaren har inte närvarat vilket resulterar i ett
+delvis uppnått krav. 
+
 \end{document}