Tot nu toe hebben we de Arduino alleen verbonden met simpele sensoren. Echter bestaan er ook geavanceerdere sensoren waar we mee willen communiceren. Dat is precies wat we in deze track gaan doen. Je leert hoe geavanceerde sensoren werken en wat de twee communicatie protocollen zijn die vaak worden gebruikt om met geavanceerde sensoren te communiceren. Deze drie onderdelen zullen vooral veel theorie zijn om zo meteen de praktijk te helpen begrijpen. Negen van de tien keer hoef je deze kennis niet zelf toe te passen, maar kun je veel oplossen met libraries. Speciaal voor die ene keer dat dit niet lukt, heb je hier wat naslag materiaal.
Geavanceerde sensoren
Met de kennis die je tot nu toe hebt vergaard, kun je alleen nog maar simpele sensoren in je project gebruiken. Hiermee doelen we op sensoren die met 1 kabeltje uit te lezen zijn. Denk daarbij aan een knopje, een potmeter of een lichtsensor. Deze sensoren hebben maar 1 kabel nodig om de data van de sensor uit te lezen. Echter zijn er ook sensoren die veel geavanceerder zijn. Een voorbeeld van een dergelijke sensor is een gyroscoop en acceleratie meter. Dit is een sensor die de positionering van de sensor meet, dus hoeveel graden een sensor over een bepaalde as is gekanteld en met welke snelheid de sensor in een bepaalde richting versneld. Een dergelijke sensor wordt vaak gebruikt in bewegende objecten om te kunnen bepalen hoe het object beweegt, om vervolgens een tegenactie op uit te voeren. Een voorbeeld hiervan is bij drones om te bepalen hoe ze in de lucht hangen en die beweging te kunnen reguleren. Wanneer we de positie namelijk niet kunnen bijsturen, vallen ze als een baksteen uit de lucht. In Figuur 5.2 is een dergelijke gyroscoop en acceleratie meter te zien.
Zoals je zelf hopelijk al een beetje aanvoelt, is dit type sensor niet meer uit te lezen met slechts één simpel draadje. Daarnaast kunnen we bij dergelijke sensoren ook vaak instellen hoe nauwkeurig ze meten. Willen we grote bewegingen kunnen meten, zoals bij schepen, of kleinere bewegingen, zoals bij drones. Als een schip een halve graad uit het lood ligt merken we dit niet zo snel, maar als dat bij een drone gebeurd hebben we de kans dat hij al onbestuurbaar wordt.
Om de sensor te kunnen instellen en de verschillende meetwaarden te kunnen registreren, heeft een dergelijke sensor zelf ook al flink wat ingebouwde intelligentie. Deze sensoren beschikken zelf over een aantal registers waar de meetwaarden in opgeslagen worden en waar de instellingen in kunnen worden vastgelegd. Deze registers zijn altijd een byte groot en genummerd van 0 t/m maximaal 127 (7 bytes). Om met deze registers te kunnen communiceren moeten we het nummer van het register kunnen doorsturen (7 bytes) en kunnen aangeven of we de opgeslagen waarde willen uitlezen of overschrijven (1 byte). Tot slot moeten we respectievelijk luisteren naar de byte die de sensor terugstuurt of zelf een byte naar de sensor sturen.
Om dit voor elkaar te krijgen zijn er twee communicatie protocollen ontwikkeld die vaak in de hardware wereld gebruikt worden: SPI en I2C. Bij beide protocollen komen de termen Master en Slave voor. De master is het component dat de baas is bij de communicatie. In de meeste gevallen zal dit de Arduino zijn die aan de sensor om gegevens vraagt of instellingen doorstuurt. In dit geval is de sensor dus de slave. De sensor communiceert namelijk alleen maar als de master daar om vraagt. Met deze protocollen kunnen we echter ook twee Arduino's op elkaar aansluiten, of een Raspberry Pi op een Arduino. In dat geval is het noodzakelijk dat je voor jezelf beslist hebt wie de master is en wie de slave is in je schakeling.
We willen je met klem aanraden dat wanneer je met geavanceerde sensoren werkt, je eerst opzoek gaan naar een library voor deze sensor. In dat geval hoef je niet zelf met registers te stoeien, maar wanneer dit een keer wel moet, heb je nu de onderliggende kennis die hiervoor nodig is.
SPI
SPI staat voor Serial Peripheral Interface. Dit protocol maakt gebruik van de volgende pinnen:
- MOSI: Dit is de Master Output Slave Input pin. Over deze pin stuurt de Master zijn gegevens naar de slave.
- MISO: Dit is de Master Input Slave Output pin. Over deze pin stuurt de Slave zijn gegevens naar de Master.
- SCLK: Dit is de clock pin. Over deze pin wordt het kloksignaal gestuurd om de snelheid van de communicatie te regelen.
- SS: Dit is de Slave Select pin. Wanneer er op deze pin een laag signaal staat, wordt de respectievelijke sensor geselecteerd en kan er met deze sensor gecommuniceerd worden.
Op een SPI verbinding kunnen meerdere sensoren worden aangesloten en de Slave Select pin maakt het mogelijk om de specifieke Slave te selecteren waar op dat moment mee gecommuniceerd word. Zo kun je alle SPI sensoren parallel aansluiten op dezelfde MOSI, MISO en SCLK pinnen en door alle Slave Select pinnen op je Arduino op een unieke pin aan te sluiten, kun je vervolgens door middel van dezelfde kabels ineens een andere sensor aanspreken.
Daarnaast kent dit protocol in totaal vier verschillende instellingen. We kunnen namelijk de CPOL (Clock POLarity) en de CPHA (Clock PHAse) op 0 of 1 zetten, waardoor we vier verschillende mogelijkheden krijgen. Bij de CPOL is het mogelijk te definiëren wat het standaard signaal van de klok is. Zetten we deze op 0, dan geeft de klok een laag signaal als er niet gecommuniceerd wordt, maar zetten we deze op 1, dan geeft de klok een hoog signaal als er niet gecommuniceerd word.
Met de CPHA kunnen we vervolgens instellen wanneer de bits op de MISO en MOSI kabel klaargezet worden en wanneer deze worden gelezen. Als we de CPHA op 0 instellen wordt de bit op de rising edge (als het signaal van laag naar hoog gaat) uitgelezen en op de falling edge (als het signaal van hoog naar laag gaat) wordt het volgende bit klaar gezet. Om dit allemaal visueel te maken, hebben we hieronder het timing diagram van een SPI verbinding opgenomen.
I2C
I2C staat voor Inter-Integrated Circuit. Dit protocol maakt gebruikt van slecht twee pinnen, dit zijn:
- SDA: Dit is de Serial DAta pin. Over deze pin worden de gegevens van de Master naar de Slave gestuurd, maar ook van de Slave naar de Master.
- SCL: Dit is de Serial CLock pin. Over deze pin gaat het klok signaal om de snelheid van de communicatie te regelen.
Bij I2C kunnen we niet bepalen wanneer een signaal gelezen wordt. Dit gebeurd altijd wanneer het klok signaal hoog is. Wanneer het klok-signaal laag is, wordt de volgende bit klaar gezet, die weer wordt uitgelezen op het moment dat de klok hoog is. Omdat we in dit geval maar de beschikking hebben over 1 data kabel, zijn er bij I2C iets meer afspraken gemaakt hoe de communicatie tussen master en slave verloopt. Eén gegevensoverdracht volgt altijd de volgende vijf stappen:
- Stuur 1 start bit
- Stuur 7 address bits
- Stuur een schrijf of lees bit
- Stuur 8 databits
- Stuur een stop bit
Als eerste wordt er dus een startbit van de master naar de slave gestuurd. Dit is een bijzonder signaal, omdat dit de enige keer is dat terwijl het klok-signaal hoog is de data pin van hoog naar laag gaat. Deze verandering wordt door de slave waargenomen, waardoor deze weet dat de communicatie start. Vervolgens stuurt de master 7 address bits door. Dit is het address van het specifieke register dat we willen aanspreken. Vervolgens sturen we een bit door om aan te geven wat we met dit register willen doen. Willen we een waarde naar het register schrijven (0) of het register uitlezen (1). Vervolgens worden er 8 bytes gestuurd die respectievelijk door de master worden verzonden om in het register te zetten, of door de slave worden verzonden om de inhoud van het register door te geven. Tot slot wordt het stopsignaal gegeven. Dit is wederom een bijzonder signaal, omdat dit de enige keer is dat terwijl het klok-signaal hoog is de data pin van laag naar hoog gaat. Het tegenover gestelde van de start bit.
Om dit allemaal weer te visualiseren, hebben we hieronder het timing diagram van I2C getoond.
Track 2 eindopdracht
In tegenstelling tot andere tracks is er voor deze track geen grote opdracht. Deze track was vooral bedoeld om je achterliggende informatie te geven om beter te kunnen begrijpen waar je in het project wellicht gebruik van gaat maken. Om jezelf uit te dagen kun je opzoek gaan naar een geavanceerde sensor en deze aan de praat te krijgen. Probeer dan altijd eerst een library te zoeken op internet en kijk deze library eens door om te kijken wat er allemaal gebeurd in de code.