lift_opgave.tex

\documentclass[a4paper, 10pt]{article}

\usepackage[a4paper,left=3cm,right=2cm,top=2.5cm,bottom=2.5cm]{geometry}
\usepackage{amsmath}
\usepackage{booktabs}


\usepackage{hyperref}
\usepackage{graphicx}

% defaults voor code
\usepackage{listings}
\usepackage{color}
\definecolor{mygray}{rgb}{0.5,0.5,0.5}
\lstset{
    numbers=left,
    numberstyle=\small\color{mygray},
    keywordstyle=\color{blue},
    stringstyle=\color{green},
    commentstyle=\color{mygray},
    numbersep=10pt,
}

% Een deftig font dat geen zeer doet aan de oogjes
\usepackage{fontspec}
\setmainfont{Helvetica Neue Light}[
  ItalicFont=Helvetica Neue Light Italic,
]


\usepackage[parfill]{parskip}

% We spreken Nederlands.
\usepackage[dutch]{babel}


\begin{document}

\title{We bouwen een lift met Dwengo}
\author{CoderDojo's Bredene - Oostende}
\maketitle

//-------------------------------------------------------------------------------------------
\section{Introductie}

We zullen in dit project een lift bouwen die we kunnen aansturen met behulp van een elektronica-bordje, in dit
geval een {\em dwenguino}. Hiervoor hebben we de volgende componenten nodig:

\begin{itemize}
\item een dwenguino,
\item een computer met daarop de Arduino IDE software waarin we ons programma kunnen schrijven,
\item de dwengo-bibliotheken voor de Arduino IDE\footnote{\url{http://www.dwengo.org/install}}
\item een liftkoker,
\item een lift, die bij voorkeur niet kan ronddraaien terwijl ze verplaatst wordt,
\item een motor die kan aangestuurd worden door de dwenguino
\item kabels om de motor van stroom te voorzien
\item een stroombron die de motor van voldoende spanning kan voorzien om snel genoeg te draaien
\end{itemize}

De liftkoker en de lift zijn reeds gebouwd voor gebruik in onze Dojo, maar als je zelf een koker wil bouwen, waarop
we een van onze motoren kunnen plaatsen, dan mag dat natuurlijk ook.

We hebben dit project opgesplitst in een aantal deeltaken, die normaal van makkelijk of vrij eenvoudig naar redelijk
moeilijk en vrij ingewikkeld evolueren. Op dit moment zijn nog niet al die taken volledig uitgewerkt :)

Vooraleer we kunnen starten, moeten we nog een aantal begrippen leren kennen.

\begin{itemize}
\item
    Een {\em variabele} is een stukje geheugen dat we een naam geven om de gegevens die we erin stoppen te kunnen gebruiken.
    Zoals de naam aangeeft, is deze inhoud niet vast, maar kan ze veranderen doordat we een nieuwe waarde aan de variabele toekennen.
    In ons programma moeten we alle variabelen defini\"eren voor we ze kunnen gebruiken. Bij zo'n definitie hoort ook een {\em type}.
    Een variabele gebruiken we bijvoorbeeld om bij te houden of een knop werd ingedrukt en zo ja, welke knop precies. Dan kunnen
    we de waarde van die variabele later gebruiken om ons programma te sturen.
\item
    Een {\em type} vertelt de computer welke soort gegevens we in een variabele kunnen (en mogen) bijhouden. Een voorbeeld
    van een type is bijvoorbeeld \texttt{int}, wat een verkorting is van {\em integer} hetgeen op zijn beurt dan weer
    een Engels woord is voor geheel getal. Een ander type is \texttt{char*} wat we typisch gebruiken om stukjes tekst op
    te slaan\footnote{Eigenlijk is het een verwijzing (met een moeilijk woord een {\em pointer}) naar een stukje tekst, maar dat is
    op dit moment niet zo belangrijk.} Een \texttt{char} stelt dan 1 enkel karakter of letterteken voor.
\item
    Een {\em functie} is een stukje code die we kunnen hergebruiken. Je kunt dit vergelijken met een blok in scratch dat je zelf
    defini\"eert. Een functie bestaat uit twee onderdelen: de hoofding en het lichaam. De hoofding beschrijft de naam van
    de functie, de argumenten (en hun types) die we aan de functie moeten meegeven en het type van de functiewaarde. Meestal,
    maar niet altijd, zal een functie iets berekenen en het uitgerekende resultaat terug bezorgen aan de code die de functie
    heeft opgeroepen. Maak je geen zorgen als dat nu nog een beetje ingewikkeld lijkt, hopelijk wordt het snel duidelijk
    als we een voorbeeldje hebben gezien.
\end{itemize}


//-------------------------------------------------------------------------------------------
\section{Aankoppelen van de dweguino aan de motor en de lift verplaatsen}

In deze eerste taak zullen we ervoor zorgen dat we de lift eenvoudig op en neer kunnen verplaatsen over een zelfde
afstand. Hiervoor hebben we een programma of een {\em sketch} nodig die we schrijven in een gewone tekstgebaseerde
programmeertaal (dus niet in Scratch). We kunnen deze sketch schrijven in onder andere de Arduino IDE die we op de
computer hebben ge\"\i nstalleerd.

Als je de Arduino IDE start, zie je onmiddellijk de standaard sketch met daarin twee functies: \texttt{setup()} en \texttt{loop()}.
De nummers van de lijnen maken geen deel uit van de programmacode die je ziet op je scherm, we drukken ze hier af
omdat we dan makkelijk kunnen spreken over bijvoorbeeld {\em lijn 6}.

\begin{lstlisting}[language=C++]
void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}
\end{lstlisting}

De code die nodig is om alles in te stellen, plaatsen we typisch in de \texttt{setup()} functie, de code die telkens weer moet worden
uitgevoerd om bijvoorbeeld te reageren op gebeurtenissen zoals het indrukken van een knop, een sensor die iets opmerkt,
\ldots, plaatsen we in de \texttt{loop()} functie.

De tekens \texttt{//} geven aan dat de rest van de lijn commentaar is. Dat maakt dus geen deel uit van het eigenlijke
programma.

Variabelen die we in meerdere functies zullen gebruiken, plaatsen we buiten elke functie. Dit zijn dan zogenaamde globale
variabelen. Je kunt dit een beetje vergelijken met een variabele in Scratch die bruikbaar is door alle sprites.

In onze eerste taak hebben we zo'n variabele nodig om de motor te kunnen gebruiken. Omdat de computer moet weten wat we
bedoelen met onze variabele, geven we ze ook een {\em type}. Dit bepaalt o.a. wat we verder kunnen aanvangen met onze
variabele. In ons geval heeft de variabele het type \texttt{DCMotor}. Opdat de computer zou weten wat dit precies is,
moeten we in ons programma ook vertellen waar de definitie van die \texttt{DCMotor} staat. Dit doen we door stukjes code
in te laden in onze broncode. Om te vermijden dat we alles meermaals moeten typen bestaat hier een handig statement voor
in C of C++, namelijk:

\begin{lstlisting}
#include <Dwenguino.h>
#include <DwenguinoMotor.h> // de bibliotheek met motorfuncties
\end{lstlisting}

Typisch plaatsen we deze statements bovenaan ons programma zodat alle code die volgt tevens de definities kan gebruiken
die we hier in ons programma hebben geladen.

Jouw eerste opdracht is nu de voorbeelden in de Arduino IDE te bekijken en na te gaan op welke manier we een
\texttt{DCMotor} kunnen defini\"eren en aansturen. Zorg er vooral voor dat je probeert de code te begrijpen en ze
niet gewoon overtypt of kopieert.

Denk ook eens na over de volgende vragen:

\begin{enumerate}
\item hoe snel kan de motor draaien?
\item hoe laat je de motor in de andere richting draaien?
\end{enumerate}

Probeer de motor een tijdje in de ene richting en een tijdje in de andere richting te laten draaien. Je zult zien dat
de motor niet onmiddellijk van richting verandert, maar dat ze eerst stopt. Dit is ingebouwd in de Dwengo bibliotheek
die we gebruiken in ons programma om te vermijden dat de motor snel stuk gaat. {\em Zorg er in deze fase voor dat de motor de
lift nog niet verplaatst door het tandwiel van de katrolas een beetje te verplaatsen.}

\subsection{Verband tussen geleverde spanning en draaisnelheid van de motor}

Als het dwengo bordje enkel via de USB-kabel met de computer verbonden is, dan is de elektrische spanning die aan de motor
geleverd wordt, beperkt tot 2.5V -- V staat voor Volt, de eenheid van spanning -- (of -2.5V als de motor in de andere
richting draait). Op welke snelheid moet je de motor instellen om dit te bereiken?

Als de dwenguino echter stroom krijgt van een sterkere spanningsbron, kan er een hogere elektrische spanning aan de
motor worden geleverd. Heb je een idee wat dit zou betekenen voor de snelheid waarmee de motor ronddraait?

In dit experiment zullen we proberen nagaan wat de invloed is van de snelheid die we opgeven in onze sketch en de spanning
die geleverd wordt aan de motor. Hiervoor moeten we een aantal metingen uitvoeren.

Om de gegevens netjes bij te houden open je best een spreadsheet-applicatie zoals Excel, Numbers (op de Mac), of Google
docs als je een netwerkverbinding hebt. We hebben twee kolommen nodig: eentje voor de opgegeven snelheid en eentje voor
de gemeten spanning. De spanning meten we met een voltmeter, waarbij we zogenaamde gelijkspanning meten. Dit wil zeggen
dat de spanning niet schommelt als een golf.

Kies een aantal snelheden waarvan je denkt dat ze je nuttige informatie zullen opleveren en vul de tabel in. Als de tabel
is ingevuld kunnen we een grafiek maken waarop we een duidelijk beeld kunnen krijgen van het invloed van de snelheid op
de spanning en dus op de snelheid waarmee de motor draait.

Extra vraag: wat is de minimale snelheid die je als argument moet opgeven opdat de motor effectief draait?


//-------------------------------------------------------------------------------------------
\section{De lift bewegen met twee drukknoppen op de dwenguino}

Nu we weten hoe we de motor kunnen bewegen in beide richtingen, is het tijd om de volgende stap te zetten. We zullen
de lift laten bewegen door op een knop te drukken die aangeeft dat we omhoog willen en door op een knop te drukken
die aangeeft dat we de lift omlaag willen verplaatsen.

We hebben hiervoor enkele nieuwe functies en constanten nodig:

\begin{itemize}
\item \texttt{digitalRead()} leest de waarde uit van een drukknop,
\item \texttt{delay()} pauzeert de uitvoering van het programma gedurende het opgegeven aantal milliseconden,
\item de constanten die de knoppen defini\"eren: \texttt{SW\_E} (oost), \texttt{SW\_W} (west), \texttt{SW\_S} (zuid), \texttt{SW\_N} (noord) en \texttt{SW\_C} (centrum),
\item de constante die aangeeft dat een knop is ingedrukt: \texttt{PRESSED},
\item een statement dat overeenkomt met het {\em Als ... Dan} blok uit Scratch: \texttt{if (voorwaarde) \{ /* doe iets */\}}.
\end{itemize}

Definieer ook zelf een functie om de lift een stukje omhoog te laten gaan en een gelijkaardige functie om ze (evenveel)
omlaag te laten gaan. Zorg er vervolgens voor dat je deze functie oproept op het ogenblik dat er op de knop wordt
gedrukt.

\textbf{Let op!} Om te vermijden dat het mogelijk is te snel te wisselen van richting door de knoppen afwisselend in te
drukken, is het belangrijk dat de \texttt{loop()}-functie telkens wacht nadat een knop is ingedrukt. Daarvoor gebruik je
de \texttt{delay()}-functie.

//-------------------------------------------------------------------------------------------
\section{Bepalen van de bewegingssnelheid van de lift}

Voor we de lift per verdieping kunnen verplaatsen, moeten we eerst achterhalen hoe ver de lift zich verplaatst voor
een gegeven motorsnelheid en de tijd die we de motor laten draaien. Er zijn verschillende manieren om dit te bepalen,
en in dit onderdeel zullen we experimenteel bepalen hoe ver de lift kan bewegen voor een aantal snelheden. We laten
de motor telkens 1s draaien. Let op! Zodra je merkt dat de verplaatsing te groot wordt en de lift dus te ver omhoog
komt, kun je de snelheid niet meer verhogen.

Beweegt de lift trouwens even ver omhoog als omlaag als we de motor op
dezelfde snelheid zetten en evenlang laten draaien? Hoe zou dat komen, denk je? Zouden we daar rekening mee moeten houden
in ons programma, of maakt dat niet veel uit?

Welke snelheden zou je kiezen als je zo snel mogelijk een idee wil hebben van het verband tussen de snelheid
en de verplaatsing?

Als je de metingen in de tabel plaatst kun je er ook een grafiek van maken. Kun je uit die grafiek afleiden welke
snelheid en welke tijd de motor moet aan staan  vereist zijn om de lift \'e\'en verdieping te verplaatsen?
Zorg ervoor dat de lift niet te snel moet bewegen.

Hou deze grafiek ook bij, we zullen later de liftsnelheid een beetje laten varie\"eren zodat de lift sneller zal
bewegen als er een verplaatsing over meer dan 1 verdieping nodig is.

\subsection{Bepalen van het aantal omwentelingen van de motoras per seconde}

Nu we weten hoe ver de lift verplaatst wordt voor een gegeven snelheid van de motor, kunnen we ook bepalen
hoe vaak de motor een volledige omwenteling van de as maakt per seconde in functie van de snelheid die wij
opgeven in ons programma. Hiervoor hebben we een beetje wiskunde nodig.

De omtrek van de cirkel wordt gegeven door
\begin{equation}
\mathrm{omtrek} = 2 \times \mathrm{straal} \times \pi
\end{equation}
waarbij we $\pi$ kunnen benaderen door de waarde 3.1415269 (dat volstaat wel voor alle praktische berekeningen).

Met de regel van 3 bepalen we makkelijk hoeveel omwentelingen de katrolas moet maken om de lift 1 cm te verplaatsen:
\begin{alignat}{4}
\mathrm{omtrek}\ \mathrm{cm} & \rightarrow & 1\  & \mathrm{omwenteling}\\
1\ \mathrm{cm}               & \rightarrow & \frac{1}{\mathrm{omtrek}}\  & \mathrm{omwentelingen}
\end{alignat}

Vervolgens moeten we uitrekenen hoeveel cm per seconde de lift bewoog voor onze gekozen snelheden.

De volgende informatie die we kunnen gebruiken is het aantal tanden aan de twee tandwielen: (i) het tandwiel op de
motoras en (ii) het tandwiel op de katrolas. De verhouding van deze twee waarden bepaalt hoe vaak de motoras zal
omwentelen per omwenteling van de katrolas, als volgt:
\begin{equation}
v = \frac{\mathrm{aantal\ tanden\ op\ tandwiel\ katrolas}}{\mathrm{aantal\ tanden\ op\ tandwiel\ motoras}}\ = \frac{\hspace{2cm}}{} = \ldots
\end{equation}

Als we dit allemaal samen brengen, dan vinden we dat voor een verplaatsing van $k$ cm per seconde, onze motor
\begin{equation}
\frac{k}{\mathrm{omtrek}} \times v = \frac{k}{\mathrm{omtrek}} \times
\frac{\mathrm{aantal\ tanden\ op\ tandwiel\ katrolas}}{\mathrm{aantal\ tanden\ op\ tandwiel\ motoras}}
\end{equation}

Als je deze formules invult in je spreadsheet, dan vind je het aantal omwentelingen per seconde voor de verschillende
snelheden die we hebben.

De werkelijke omwentelingssnelheden staan in Tabel~\ref{table:legomotorxl}.

\begin{table}
\begin{center}
\begin{tabular}{lcc}
    \toprule
    Spanning & Omwentelingen (per minuut) & Omwentelingen (per seconde)\\
    \midrule
    4.5V & 43  & 0.72\\
    7V   & 100 & 1.67\\
    9V   & 146 & 2.43\\
    12V  & 214 & 3.57\\
    \bottomrule
\end{tabular}
\end{center}
\caption{De opgegeven omwentelingssnelheden van de Lego XL Motor.}
\label{table:legomotorxl}
\end{table}

Komen deze waarden overeen met wat je zelf hebt gemeten? Waarom zou dat het geval zijn?


//-------------------------------------------------------------------------------------------
\section{Bewegen van de lift naar de verschillende verdiepingen}

In de vorige taak hebben we bepaald hoe lang we de motor moeten laten draaien op een gegeven snelheid om de lift 1 cm te
verplaatsen.

Zorg er nu voor dat je programma de lift (ongeveer) \'e\'en verdieping kan verplaatsen als je op een van de
drukknoppen drukt. Hou er rekening mee dat de snelheid omhoog en de snelheid omlaag licht verschillend kunnen zijn.

\subsection{Optioneel: beperk de lift tot de verdiepingen tussen 0 en 4}

Het doel hiervan is ervoor te zorgen dat de draad niet van de katrol raakt. Dit probleem kan ook worden
opgelost door verdiepingen toe te kennen aan elke van de knoppen, maar dit is ook wel een fijne uitdaging.


\subsection{Schrijven van hulp-functies}

Je kunt twee functies schrijven: (1) \texttt{void verdieping\_omhoog() \{ /*
\ldots */\}} en (2) \texttt{void verdieping\_omlaag() \{ \* \ldots *\ \}}. Deze
functies zullen we dan oproepen in de \texttt{loop} functie om de lift te bewegen.

\subsection{Bedienen van de verschillende drukknoppen}

Zoals eerder vermeld, staan er op de Dwenguino 5 drukknoppen, die we als volgt zullen gebruiken:

\begin{itemize}
        \item \texttt{SW\_S}: de onderste knop (zuid): verdieping 0 (gelijkvloers)
        \item \texttt{SW\_E}: de rechtse knop (oost): verdieping 1
        \item \texttt{SW\_N}: de bovenste knop (noord): verdieping 2
        \item \texttt{SW\_W}: de linkse knop (west): verdieping 3
        \item \texttt{SW\_C}: de centrale knop (zuid): verdieping 4
\end{itemize}

Je zult moeten bijhouden op welke verdieping de lift zich bevindt. Definieer hiervoor bijvoorbeeld een 
nieuwe variable \texttt{int huidige\_verdieping = 0;}. Je moet de waarde van deze variabele aanpassen telkens
de lift zijn nieuwe bestemming heeft bereikt.

Gebruik hier ook de \texttt{verdieping\_omhoog} en \texttt{verdieping\_omlaag} functies die je
eerder hebt gedefinieerd.


//-------------------------------------------------------------------------------------------
\section{Gebruik van sensoren om de positie van de lift te detecteren}

De lift bewegen door de motor een bepaalde tijd te laten draaien is ok, en we slagen er wel in om de juiste verdieping min of meer te bereiken,
maar bij elke beweging neemt de fout op de positie toe. Het zou beter zijn niet af te gaan op de metingen die we hebben gedaan, want het
sleutelgegeven -- het aantal rotaties in elke seconde -- hebben we niet op de meest nauwkeurige manier gemeten.

We kunnen echter gebruik maken van de sensorpoorten van de dwenguino en aan elke poort de stroom te meten die niet door een 
fotosensor wordt tegengehouden. Hiervoor hebben we echter een nieuwe toren nodig, waarbij we op elk verdiep een led-lichtje aan de
ene kant plaatsen en een sensor aan de andere kant. 

TBC.


\end{document}