physical computing - goahead.classy.begoahead.classy.be/wp-content/uploads/bundel2.pdf · ardublock...

versie: 2017-01-08

PHYSICAL COMPUTING

OP VERKENNING

PHYSICAL COMPUTING: OP VERKENNING

Inhoudstafel

Inhoudstafel .................................................................................................................................................. 2

Doel van deze bundel .................................................................................................................................... 3

Een overzicht van physical computing hard- en software ............................................................................ 3

Centrale probleemstelling ............................................................................................................................. 9

Enkele vragen ................................................................................................................................................ 9

Algoritme ..................................................................................................................................................... 11

Van algoritme naar programma .................................................................................................................. 11

Welk leerpad volg je best? .......................................................................................................................... 12

Demo: simulatie in Scratch .......................................................................................................................... 13

Demo: simulatie in Scratch in combinatie met een Picoboard ................................................................... 14

Demo: simulatie in Scratch in combinatie met een webcam ...................................................................... 15

Demo: simulatie met een LEGO EV3-robot in combinatie met een LEGO Labview .................................... 16

Demo: simulatie met een LEGO EV3-robot in combinatie met Small Basic ................................................ 19

Demo: simulatie met een LEGO EV3-robot in combinatie met Open Roberta ........................................... 20

Demo: simulatie met PiStorms, Raspberry Pi en LEGO EV3-onderdelen in combinatie met Blockly ......... 22

Demo: simulatie met PiStorms, Raspberry Pi en LEGO EV3-onderdelen in combinatie met Python ......... 24

Demo: simulatie via de Makeblock inventor electronic kit in combinatie met mBlock ............................. 25

Demo: simulatie via de Makeblock inventor electronic kit in combinatie met Arduino IDE (C++) ............. 26

Demo: simulatie met Dwenguino in combinatie met Blockly ..................................................................... 28

Demo: simulatie met Dwenguino in combinatie met Ardublock ................................................................ 30

Demo: simulatie met Dwenguino in combinatie met Arduino IDE (C++) .................................................... 31

Demo: simulatie met mCookie in combinatie met Arduino IDE (C++) ........................................................ 33

Demo: simulatie met Arduino UNO in combinatie met mBlock ................................................................. 37

Demo: online simulatie van Arduino UNO via circuits.io ............................................................................ 39

Demo: simulatie met Sam Labs ................................................................................................................... 43


pagina 3/46 © 2016 - Tony Opsomer

Doel van deze bundel

Het doel van deze bundel is je wegwijs te maken in het overweldigende aanbod aan physical

computing tools. Deze bundel mag dus niet verward worden met een overzicht van alle bestaande

tools, een volwaardige cursus programmeren of een complete handleiding voor een specifieke tool!

Opmerkingen omtrent deze bundel mag je gerust sturen naar [email protected].

Een overzicht van physical computing hard- en software

Grosso modo kan je de beschikbare hardwareplatformen indelen in twee groepen:

Microcontroller Microprocessor

Verwerkings-kracht:

Relatief laag (XY MHz) Relatief snel (XYZ MHz of X GHz)

Intern geheugen:

Klein Groot

Doel: Via sensoren en actuatoren interageren met de buitenwereld

Interactie met de buitenwereld is niet het belangrijkste

Programmeren via:

Bare-metal coding: je programmeert rechtstreeks voor de betrokken hardware. Hierdoor kan de hardware quasi in ware tijd reageren op de buitenwereld

De programma’s die je maakt draaien binnen een besturingssysteem (vb. Linux). Hierdoor kan de hardware niet gegarandeerd in ware tijd reageren op de buitenwereld1

Voorbeelden: Arduino, Dwenguino, mCookie, Makeblock electronic inventor kit, …

Raspberry Pi, LEGO EV3-robot, …

1 Een mooi voorbeeld hiervan is het gebruik van het wachtblok (zie bundel “physical computing: introductie -> EXTRA” op pag. 29. Zonder dit wachtblok neemt het besturingssysteem van de robot niet steeds de tijd om de geresette waarde van de gyroscoop op te pikken…

mailto:[email protected]



Grootste uitdaging:

Voor Arduino heb je elektronicakennis nodig om de nodige elektronische schakelingen te kunnen bouwen. Bij sommige afgeleide producten zoals bvb. Dwenguino stelt dit probleem zich minder omdat een aantal elektronicacomponenten (LCD-scherm, LED’s, drukknoppen, motoraansturing, …) reeds vooraf ingebouwd werden. Heb je echter nood aan andere componenten, moet je nog steeds over elektronicakennis beschikken. Tot slot zijn er ook producten als mCookie, Makeblock electronic inventor kit, enz. Deze producten zijn eveneens afgeleid van Arduino maar bevatten heel wat “prefab” elektronicacomponenten en laten de gebruiker toe om snel en foutloos eenvoudige schakelingen te bouwen. Jammer genoeg is de documentatie nodig om alles te programmeren niet altijd even sterk uitgebouwd…

Voor LEGO EV3-robots heb je geen elektronicakennis nodig. Je kan dus niets fout doen. Dit systeem werkt echter enkel met LEGO-compatibele sensoren en motoren. Bovendien kan je slechts max. 4 motoren en max. 4 sensoren tegelijk aansluiten. Via een Raspberry Pi haal je eigelijk een mini-computer in huis. Deze mini-computer kan ook communiceren met sensoren en motoren al vereist dit opnieuw elektronicakennis om deze correct te schakelen. Wie wil kan bestaande LEGO EV3-sensoren en -motoren probleemloos aansluiten op een Raspberry Pi middels een extra PiStormsmodule.



Het programmeren van elk van deze systemen kan op verschillende manieren:

Grafische programmeertools Tekstuele programmeertools

Op de computer waarna de gemaakte code omgezet wordt naar code die daarna zelfstandig door de hardware uitgevoerd kan worden (maw de computer hoeft dan niet meer verbonden te zijn met de hardware)

Microcontroller:

Ardublock

Blockly for Dwenguino

mBlock for Makeblock

Mixly for mCookie

… Microprocessor: quasi oneindig veel mogelijkheden

Blockly for PiStorms

LEGO LabView

…

Microcontroller:

Arduino IDE (C++)

…

Microprocessor: quasi oneindig veel mogelijkheden

Python

LEJOS (Java)

Small Basic

…

Op de computer waarbij de code naar de hardware gestuurd wordt maar waarbij de computer wél verbonden moet blijven met de hardware

Microcontroller:

Scratch for Arduino (S4A)

… Microprocessor:

LEGO Wedo

Microcontroller:

Python

… Microprocessor:

Op de hardware zelf Microcontroller:

nvt Microprocessor: afhankelijk van de geïnstalleerde tools binnen het besturingssysteem

Blockly for PiStorms

LEGO on-the-brick programming

…

Microcontroller:

nvt Microprocessor: afhankelijk van de geïnstalleerde tools binnen het besturingssysteem

Python

Java

…



Natuurlijk vormt ook de kostprijs van de opgesomde platformen een belangrijk punt. Hieronder vind

je de prijzen van november 2016:

Arduino UNO starterskit http://www.robotshop.com/eu/en/arduino-starter-kit.html

ong 90 EUR incl. btw

Dwenguino starterskit http://shop.dwengo.org/products/dwenguino-kit

121 EUR incl. btw

PiStorms express kit: Raspberry Pi 3 + PiStorms + micro SD-kaart met PiStorms OS http://www.mindsensors.com/content/78-pistorms-lego-interface Let wel: er worden géén LEGO-sensoren en -motoren meegeleverd (reken hiervoor aanvullend ongeveer 280 EUR incl. btw – zie: http://www.ratoeducation.be/index.php?route=product/category&path=83 )!

164 US Dollar

mCookie advanced kit http://www.robotshop.com/eu/en/microduino-mcookie-advanced-kit.html

ong. 215 EUR incl. btw

Makeblock electronic inventor kit http://www.robotshop.com/eu/en/makeblock-inventor-electronic-kit.html


LEGO EV3 educatieve basisset http://www.ratoeducation.be/index.php?route=product/product&path=83_84&product_id=346 Tip: bestel zeker ook de batterijlader (bijkomende kostprijs: ong. 30 EUR incl. btw – http://www.ratoeducation.be/index.php?route=product/product&path=83_86&product_id=400)


Sam Labs – curious kit https://www.samlabs.com/shop

ong. £ 150

http://www.robotshop.com/eu/en/arduino-starter-kit.html

http://shop.dwengo.org/products/dwenguino-kit

http://www.mindsensors.com/content/78-pistorms-lego-interface

http://www.ratoeducation.be/index.php?route=product/category&path=83

http://www.robotshop.com/eu/en/microduino-mcookie-advanced-kit.html

http://www.robotshop.com/eu/en/makeblock-inventor-electronic-kit.html

http://www.ratoeducation.be/index.php?route=product/product&path=83_84&product_id=346




https://www.samlabs.com/shop



Voor de volledigheid staan ook de prijzen van de eerder beperkte platformen uit de vorige bundel

hieronder vermeld:

Sphero Ollie ifv gebruik met Tickle (iOS: https://tickleapp.com/) of Tynker (iOS/Android) https://www.coolblue.be/zoeken?query=ollie

99 EUR incl. btw

Sphero 2.0 bal ifv gebruik met Tickle (iOS: https://tickleapp.com/) of Tynker (iOS/Android) http://www.pdashop.be/product/390499/orbotix-sphero-2-0.html?_ga=1.221951836.573394729.1478685120

125 EUR incl. btw

Parrot rolling spider drone ifv gebruik met Tynker (iOS/Android)2 https://www.bol.com/nl/f/parrot-minidrones-rolling-spider-drone/9200000032163083/index.html?country=BE Tip: bestel zeker ook extra batterijen + een batterijlader. De vliegduur per batterij bedraagt immers slechts zo’n 6 minuten…

89 EUR incl. btw

Picoboard ifv gebruik binnen Scratch of mBlock http://www.robotshop.com/eu/en/sparkfun-picoboard-scratch-microcontroller.html


2 Opgelet: Jammer genoeg ondersteunt Tickle (https://tickleapp.com/), de grafische

programmeeromgeving voor iOS, sinds eind 2016 niet langer het gebruik van (Parrot) drones. Meer

info omtrent omtrent het schrappen van de aansturing van drones vind je op de website van Tickle:

http://feedback.tickleapp.com/knowledgebase/articles/1098247-parrot-drones.

De toestellen die wél nog ondersteund worden, vind je op https://tickleapp.com/devices/.

Wil je echter graag je (Parrot) drones blijven gebruiken? Dan wijk je best uit naar Tynker. Deze app

biedt gelijkaardige mogelijkheden als Tickle en bestaat zowel voor iOS

(https://itunes.apple.com/us/app/tynker-learn-to-code.-games/id805869467?mt=8) als voor Androïd

(https://play.google.com/store/apps/details?id=com.tynker.Tynker)…

https://tickleapp.com/

https://www.coolblue.be/zoeken?query=ollie


http://www.pdashop.be/product/390499/orbotix-sphero-2-0.html?_ga=1.221951836.573394729.1478685120

http://www.pdashop.be/product/390499/orbotix-sphero-2-0.html?_ga=1.221951836.573394729.1478685120

https://www.bol.com/nl/f/parrot-minidrones-rolling-spider-drone/9200000032163083/index.html?country=BE

https://www.bol.com/nl/f/parrot-minidrones-rolling-spider-drone/9200000032163083/index.html?country=BE

http://www.robotshop.com/eu/en/sparkfun-picoboard-scratch-microcontroller.html


http://feedback.tickleapp.com/knowledgebase/articles/1098247-parrot-drones

https://tickleapp.com/devices/

https://itunes.apple.com/us/app/tynker-learn-to-code.-games/id805869467?mt=8

https://play.google.com/store/apps/details?id=com.tynker.Tynker



Tot slot een (persoonlijke) vergelijking van de gebruikte platformen op vlak van:

1 = beperkt -> 5 = hoog

benodigde elektronica

kennis

kostprijs documentatie uitbreidbaarheid

Arduino UNO 5 1 5 5

Dwenguino 4 2 3 5

mCookie 2 4 1 3

Makeblock inventor kit

1 3 1 4

LEGO EV3 1 5 5 3

PiStorms 2 5 3 4

Sam Labs 1 3 1 3

0

1

2

3

4

5benodigde elektronica kennis

kostprijs

documentatie

uitbreidbaarheid

Arduino UNO Dwenguino mCookie Makeblock inventor kit

LEGO EV3 PiStorms Sam Labs



Centrale probleemstelling

We willen een alarm bouwen met een drukknop (≠ klassieke schakelaar!). Via de drukknop wordt het

alarm aan- of uitgezet. Staat het alarm aan dan zoekt het indringers. Er is een vooraf bepaalde

gevoeligheid waarmee je de snelheid van reageren kan regelen. Staat het alarm uit, reageert het op

niets.

Enkele vragen

Welke toestanden kan het alarm hebben?

AAN / UIT

Wat gebeurt er bij AAN?

Het zoekt indringers

Hoe verloopt het zoeken naar indringers?

Het alarm meet bvb. beweging, geluid, licht en/of afstand en vergelijkt dit met de ingestelde

gevoeligheid. Is de gemeten waarde groter dan de ingestelde gevoeligheid, gaat het alarmsignaal af

anders niet

Wat gebeurt er bij UIT?

Het stopt met zoeken naar indringers

Hoe weet het alarm of het AAN/UIT staat?

Via de drukknop

Hoe werkt een klassieke schakelaar?

Je drukt op de 1-kant en schakelt hierdoor het toestel in

Je drukt op de 0-kant en schakelt hiermee het toestel uit

Hoe werkt een drukknop?

Erop drukken wisselt de toestand: AAN wordt UIT en UIT wordt AAN

Hoe kunnen we de toestand bijhouden?

Via een variabele die twee waarden kan aannemen (boolean)

Wat wordt er eerst getest: het alarmsignaal aan/uit zetten of het alarm via de drukknop aan- of

uitzetten?



Eerst test je of de drukknop ingedrukt werd en daarna test je of de toestand van het alarm aan

staat…

Hoeveel keer wordt het bovenstaande getest/doorlopen?

Oneindig veel keer zou een eerste antwoord kunnen zijn als je het programma bekijkt als iets dat

gestart en gestopt wordt zoals een apparaat stroom nodig heeft om te functioneren. Helaas zorgen

oneindige lussen ervoor dat je niet meer uit het programma geraakt (sommige

programmeeromgevingen voorzien gelukkig een noodstop voor dat soort situaties, andere

omgevingen hebben die mogelijkheid dan weer niet). Het is dus beter/veiliger om sowieso een

eindige lus te voorzien. Stellen dat we het bvb. 5 keer doorlopen, is echter geen optie. Na die 5 keer

zou het alarmprogramma stoppen met werken en dat is niet de bedoeling. Het alarm mag immers

alleen maar uitgezet worden indien men het programma stopt (te vergelijken met het verwijderen

van de stekker uit een apparaat)

Anderzijds zou je het programma ook kunnen bekijken als iets dat gestart wordt wanneer op de

aan/uit-knop gedrukt wordt. Deze manier van werken wordt echter niet door alle gebruikte

programmeeromgevingen ondersteund en volgen we daarom niet.



Algoritme

Start het programma

Definieer variabele intGevoeligheid van het type integer en stel deze in op 50

Definieer variabele blnSchakelaar van het type Boolean en stel deze in op ONWAAR/UIT/FALSE/0

Herhaal oneindig (of beter: herhaal zolang NIET op de programma stopknop gedrukt werd)

Drukknop ingedrukt ?

JA NEE

Wacht een halve seconde3

blnSchakelaar = ONWAAR ?

JA NEE

Maak blnSchakelaar = WAAR

Maak blnSchakelaar = ONWAAR

blnSchakelaar = WAAR ?

JA NEE

Signaleer de gebruiker dat het alarm AAN staat (LED, boodschap op scherm, geluidje, …)

Signaleer de gebruiker dat het alarm UIT staat (LED, boodschap op scherm, geluidje, …)

Gemeten sensorwaarde > ingestelde gevoeligheid ?

JA NEE

Schakel alarmgeluid, -licht en/of -boodschap in

Stop alarmgeluid, -licht en/of -boodschap

Van algoritme naar programma

Op de volgende pagina’s zie je het voorgaande algoritme uitgewerkt mbv diverse physical computing

hardware en software. Hoewel af en toe noodgedwongen met andere sensoren gewerkt diende te

3 Het doorlopen van dit algoritme en de bijhorende detectie van indrukken gebeurt razendsnel door de elektronica. Zelfs al zou je de drukknop bliksemsnel loslaten, dan nog zou er razendsnel gewisseld worden van toestand: AAN -> UIT -> AAN -> UIT enzovoort. Hierdoor zou het moeilijk worden om het alarm in- en uit te schakelen. Door een halve seconde vertraging in te bouwen, vermijd je dit probleem (tenzij iemand langer dan een halve seconde de knop ingedrukt houdt)…



worden, is de globale gedachtegang steeds dezelfde. Hierdoor kan je de code met elkaar vergelijken

én leer je hoe diverse elementaire programmeerstructuren (opeenvolging, keuze, herhaling) en -

begrippen (variabele, constante, functie, …) opgebouwd worden in de gebruikte programmeertalen.

Laat je echter niet afschrikken door de hoeveelheid en/of complexiteit van de afgebeelde

programmeercode! Het opstellen van code nam heel wat tijd in beslag. Het spreekt dan ook voor zich

dat niet verwacht wordt dat je na deze bundel alle vermelde platformen en

programmeeromgevingen beheerst.

Wil je graag verder gaan met één of meerdere platformen, neem dan zeker de tijd om het

startersboekje dat bij het betrokken platform hoort uit te proberen. Hoewel je er zeker niet alle

mogelijkheden mee zult ontdekken, biedt het doorgaans een succesvolle start.

Meer informatie vind je doorgaans ook in de meegeleverde voorbeelden (bvb. ingeval je de Arduino

IDE gebruikt) of op de website van de hardwaremaker. Soms moet je echter ook eens zoeken in

documentatie van verwante platformen. Volhardend zijn is de boodschap want niet alle

documentatie is even helder/correct/makkelijk te vinden!

Werk echter steeds vanuit een uitgeschreven algoritme. Zoniet verval je al snel in gissen en missen

en wordt programmeren een bijzonder tijdrovende en weinig aantrekkelijke bezigheid…

Welk leerpad volg je best?

Als beginner start je bij voorkeur met een grafische, blokgebaseerde programmeermethode. Pas

nadat je voldoende vertrouwd bent met het ontwerpen van een algoritme, het toepassen van

elementaire programmeerstructuren & -begrippen en het gebruik van een grafische

programmeeromgeving, kan je geleidelijk overschakelen naar het gebruik van een tekstuele

programmeermethode. Je hoeft hiermee zeker niet te wachten tot alle lessen grafisch

programmeren voorbij zijn. Reeds bij de start van het grafisch programmeren kan je af en toe stil

staan bij de tekstuele versie van deze code. Sommige programmeertools kunnen de gemaakte

grafische code zelfs automatisch omzetten naar tekstuele code, bij andere programmeertools zal je

zelf de tekstuele versie moeten opstellen… Aangezien het achterliggende algoritme niet verandert, is

het omschakelproces vooral een kwestie van syntax leren.

Wil je aan de slag gaan met op Arduino gebaseerde tools (bvb. Dwenguino, mCookie, Makeblock

inventor kit, enz.)? In dat geval doe je er goed aan eerst een basiskennis programmeren te verwerven

én enkele basisconcepten van elektronica te leren met een “pure” Arduino UNO. Eenmaal je die beet

hebt, zal je eenvoudiger je weg vinden in de afgeleide producten!



Demo: simulatie in Scratch



Demo: simulatie in Scratch in combinatie met een Picoboard

Meer weten over een Picoboard?

https://wiki.scratch.mit.edu/wiki/PicoBoard

https://wiki.scratch.mit.edu/wiki/PicoBoard



Demo: simulatie in Scratch in combinatie met een webcam



Demo: simulatie met een LEGO EV3-robot in combinatie met een LEGO Labview



Demo: simulatie met een LEGO EV3-robot in combinatie met Small Basic

Meer weten over het aansturen van een

EV3-robot via Small Basic?

http://www.ev3basic.com

http://www.ev3basic.com/



Demo: simulatie met een LEGO EV3-robot in combinatie met Open Roberta

Via Open Roberta kan je de gemaakte grafische code ook bekijken in tekstvorm. De code wordt dan

in aangepaste LEJOS-syntax getoond. LEJOS is een op JAVA gebaseerde programmeertaal waarmee je

een EV3-robot kan aansturen…

Meer weten over Open Roberta?

https://www.open-roberta.org

Nog meer alternatieven nodig om te

programmeren met LEGO EV3-robots ?

LEJOS: http://www.lejos.org/

EV3DEV: http://www.ev3dev.org/

ROBOTC: http://www.robotc.net/

De bovenstaande alternatieven werden

https://www.open-roberta.org/

http://www.lejos.org/

http://www.ev3dev.org/

http://www.robotc.net/



1. float intGevoeligheid = 50; 2. boolean blnSchakelaarStand = false; 3. 4. public void run() throws Exception { 5. hal.startLogging(); 6. if ( true ) { 7. while ( true ) { 8. if ( hal.isPressed(SensorPort.S1) ) { 9. hal.waitFor(500); 10. if ( blnSchakelaarStand == false ) { 11. blnSchakelaarStand = true; 12. } else { 13. blnSchakelaarStand = false; 14. } 15. } 16. if ( blnSchakelaarStand == true ) { 17. hal.drawText("Alarm AAN", 0, 0); 18. if ( hal.getGyroSensorAngle(SensorPort.S2) > intGevoeligheid ) { 19. hal.setVolume(100); 20. hal.playTone(500, 400); 21. } 22. } else { 23. hal.drawText("Alarm UIT", 0, 0); 24. hal.resetGyroSensor(SensorPort.S2); 25. } 26. } 27. }



Demo: simulatie met PiStorms, Raspberry Pi en LEGO EV3-onderdelen in combinatie met Blockly

Tastsensor op poort BBS1 en ultrasone afstandssensor op poort BAS1.

Je kan de programmeeromgeving (Blockly of Python) rechtstreeks op de PiStorms benaderen door

vanuit een webbrowser te surfen naar het IP-adres van de Raspberry Pi. Je kan aanmelden met

gebruikersnaam: pi en wachtwoord raspberry



Meer weten over PiStorms?

http://www.mindsensors.com/stem-with-

robotics/13-pistorms-v2-base-kit-raspberry-

pi-brain-for-lego-robot

Meer weten over Blockly voor PiStorms?

http://www.mindsensors.com/blog/pistorm

s/visual-programming-for-pistorms-robots

http://www.mindsensors.com/stem-with-robotics/13-pistorms-v2-base-kit-raspberry-pi-brain-for-lego-robot



http://www.mindsensors.com/blog/pistorms/visual-programming-for-pistorms-robots

http://www.mindsensors.com/blog/pistorms/visual-programming-for-pistorms-robots



Demo: simulatie met PiStorms, Raspberry Pi en LEGO EV3-onderdelen in combinatie met Python

Meer weten over Python voor PiStorms?

http://www.mindsensors.com/blog/how-

to/pistorms-python-programming-tutorial

http://www.mindsensors.com/blog/how-to/pistorms-python-programming-tutorial

http://www.mindsensors.com/blog/how-to/pistorms-python-programming-tutorial



Demo: simulatie via de Makeblock inventor electronic kit in combinatie met mBlock

Meer weten over de MakeBlock inventor

kit?

http://learn.makeblock.com/en/inventor-

electronic-kit/

Meer weten over mBlock voor MakeBlock?

http://learn.makeblock.com/en/getting-

started-programming-with-mblock/

Wist je dat?

mBlock ook een Arduino UNO en Picoboard

kan aansturen?

Potentiometer op poort 8

PIR-sensor op poort 6

LED op poort 3

http://learn.makeblock.com/en/inventor-electronic-kit/

http://learn.makeblock.com/en/inventor-electronic-kit/

http://learn.makeblock.com/en/getting-started-programming-with-mblock/

http://learn.makeblock.com/en/getting-started-programming-with-mblock/



Demo: simulatie via de Makeblock inventor electronic kit in combinatie met Arduino IDE (C++)

#include <Makeblock.h>

#include <Wire.h>

#include <SoftwareSerial.h>

MePotentiometer potentiometer(PORT_8);

MeRGBLed led(PORT_3);

MePIRMotionSensor pir(PORT_6);

int blnSchakelaar = 0;

void setup(){

}

void loop(){

if(potentiometer.read() >= 500){

if(blnSchakelaar==0){

blnSchakelaar = 1;

led.setColorAt(0,0,0,255);

led.show();

}else{

blnSchakelaar = 0;


led.show();

}

}else {

blnSchakelaar = 0;

led.clear();

}



if(blnSchakelaar==1){

if(pir.isPeopleDetected()){


led.show();

}else{


led.show();

}

}

}

Meer weten over Arduino IDE voor

MakeBlock?

http://learn.makeblock.com/en/learning-

arduino-programming/

http://learn.makeblock.com/en/learning-arduino-programming/

http://learn.makeblock.com/en/learning-arduino-programming/



Demo: simulatie met Dwenguino in combinatie met Blockly

Ultrasone sensor:

TRIG -> pin 12

ECHO -> pin 11



Meer weten over Blockly voor Dwenguino?

http://www.dwengo.org/blockly

Meer weten over Dwenguino?

http://www.dwengo.org/new-tutorials

http://www.dwengo.org/blockly

http://www.dwengo.org/new-tutorials



Demo: simulatie met Dwenguino in combinatie met Ardublock

Meer weten over Ardublock voor

Dwenguino?

http://www.dwengo.org/ArduBlock

http://www.dwengo.org/ArduBlock



Demo: simulatie met Dwenguino in combinatie met Arduino IDE (C++)

#include <Wire.h>

#include <Dwenguino.h>

#include <LiquidCrystal.h>

#include <NewPing.h>

#define TRIGGER_PIN 12

#define ECHO_PIN 11

#define MAX_DISTANCE 200

int intGevoeligheid = 50;

boolean blnSchakelaar = false;

NewPing sonar1211(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {

// de setup-routine loopt slechts 1 keer

initDwenguino();

dwenguinoLCD.clear();

}

void loop() {

// de loop-routine wordt eindeloos herhaald

if (digitalRead(SW_C) == PRESSED) { //PRESSED wordt gedefinieerd als 0 in de Dwenguino.h-bibliotheek. SW_C wordt via initDwenguino dmv pinMode(SW_C, INPUT_PULLUP) kenbaar gemaakt aan de hardware

delay(500);

if (blnSchakelaar == false) {

blnSchakelaar = true;

} else {

Meer weten over de Arduino IDE?

https://www.arduino.cc/en/Guide/Environ

ment

Meer weten over de Arduino syntax?

https://www.arduino.cc/en/Reference/Hom

ePage

Opgepast: Dwenguino gebruikt aangepaste

bibliotheken. Je doet er dus goed aan om

ook de meegeleverde voorbeelden

aandachtig te bekijken!

https://www.arduino.cc/en/Guide/Environment


https://www.arduino.cc/en/Reference/HomePage




blnSchakelaar = false;

}

}

if (blnSchakelaar == true) {

digitalWrite(SCK,HIGH); //SCK = ingebouwde LED op pin 13, deze wordt hier ingeschakeld (HIGH)

dwenguinoLCD.setCursor(0,0);

dwenguinoLCD.print("Alarm AAN");

if (sonar1211.ping_cm() < intGevoeligheid) {

tone(BUZZER,400); //BUZZER = ingebouwde buzzer op pin 46, het woord BUZZER wordt via initDwenguino dmv pinMode(BUZZER, OUTPUT) kenbaar gemaakt aan de hardware

} else {

noTone(BUZZER);

}

} else {

digitalWrite(SCK,LOW);

dwenguinoLCD.setCursor(0,0);

dwenguinoLCD.print("Alarm UIT");

noTone(BUZZER);

}

}



Demo: simulatie met mCookie in combinatie met Arduino IDE (C++)

#define PIRSENSOR_PIN 10 //PIR

#define COLORLED_PIN 8

#define PIR_PIN 10

#define BUZZER_PIN 6

#define CRASHSENSOR_PIN 4

//ifv Crash-schakelaar

#include "key.h"

Meer weten over mCookie?

https://www.microduino.cc/gettingStarted

Meer weten over de Arduino IDE?

https://www.arduino.cc/en/Guide/Environ

ment

Meer weten over de Arduino syntax?

https://www.arduino.cc/en/Reference/Hom

ePage

Opgepast: mCookie gebruikt heel wat

aangepaste bibliotheken. Je doet er dus

goed aan om ook de meegeleverde

voorbeelden aandachtig te bekijken!

BUZZER -> poort 6/7

CRASH SENSOR -> poort 4/5

COLOR LED -> poort 8/9

PIR-sensor -> poort 10/11

OLED-scherm -> poort IIC

https://www.microduino.cc/gettingStarted







#include <Adafruit_NeoPixel.h> //ifv de kleurenLED

Adafruit_NeoPixel strip = Adafruit_NeoPixel(1, COLORLED_PIN, NEO_GRB + NEO_KHZ800);

#include "I2Cdev.h" //ifv het aansturen van het OLED-scherm

#include "Wire.h" //dit is nodig om met I2C-devices, in dit geval het OLED-scherm, te kunnen praten

#include "U8glib.h" //ifv het OLED-scherm

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);

bool blnPIRStatus = false; //In deze oefening met de PIR-sensor hoeven we geen gevoeligheid te definiëren. De PIR-sensor ziet iemand (= 1) of ziet niemand (= 0).

bool blnSchakelaar = false;

void setup() {

Serial.begin(9600);

pinMode(PIR_PIN, INPUT);

pinMode(CRASHSENSOR_PIN, INPUT);

pinMode(BUZZER_PIN, OUTPUT);

Wire.begin();

key_init();

strip.begin();

strip.show(); // Zet alle pixels van de kleurenLED uit

// Draai het scherm indien nodig

// u8g.setRot180();

}

void loop() {

if (key_get(CRASHSENSOR_PIN, 0))

{



// delay(500); Het registreren van ingedrukt/losgelaten zit in de key.h-bibliotheek vervat ... Maw hoe lang je iets indrukt maakt niet uit vandaar dat hier geen nood is aan delay



} else {


}

}


blnPIRStatus= digitalRead(PIRSENSOR_PIN);

// Toon de status van de PIR-sensor via de serial monitor

//Serial.println(blnPIRStatus);

// Gebruik je de serial monitor om sensordata uit te lezen, voeg dan steeds 500 ms delay toe om te vermijden dat je Core USB gelocked geraakt (!!)

//delay(500);

u8g.firstPage();

do {

textOLED("Alarm AAN");

} while(u8g.nextPage());

if (blnPIRStatus) {

colorWipe(strip.Color(255, 0, 0));

tone(BUZZER_PIN, 400);

} else {


noTone(BUZZER_PIN);

}

} else {



u8g.firstPage();

do {

textOLED("Alarm UIT");

} while(u8g.nextPage());


noTone(BUZZER_PIN);

}

}

// Vul de pixels van de kleurenLED met het gewenste kleur

void colorWipe(uint32_t c) {

for (uint16_t i = 0; i < strip.numPixels(); i++) {

strip.setPixelColor(i, c);

strip.show();

}

}

void textOLED(String strTekst) {

u8g.setFont(u8g_font_unifont);

u8g.setPrintPos(0, 20);

u8g.print(strTekst);

}



Demo: simulatie met Arduino UNO in combinatie met mBlock

Eerst bouw je de schakeling. De ultrasone sensor heeft 4 pinnen. Deze sluit je aan als volgt:

Vcc -> 5V (rode kabel)

TRIG -> pin 12 (bruine kabel)

ECHO -> pin 11 (witte kabel)

GND -> GND (zwarte kabel)

Nu ben je klaar om het geheel te programmeren via mBlock:

Vroeger werd Scratch 4 Arduino (S4A,

http://s4a.cat/) gebruikt om grafisch te

programmeren met een microcontroller.

S4A is echter gebaseerd op een oude

Scratch-versie. mBlock is gebaseerd op

Scratch 2.0 en krijgt daarom de voorkeur…

Let op: in beide gevallen moet je de

firmware van het bord aanpassen. Dit kan je

echter rechtstreeks vanuit mBlock: menu

Connect -> Upgrade Firmware…

http://s4a.cat/



In dit-programma wordt gewerkt met

en niet met

zoals in het vorige mBlock-programma (zie

demo met Makeblock inventor electronic kit).

Door het vlaggetje te gebruiken blijft het

programma op de pc lopen en wordt het niet

naar de microcontroller gestuurd waardoor

deze niet zelfstandig kan werken…

Mocht je gebruik maken van

dan zou dit wél kunnen…

en zijn dus

equivalenten van elkaar en worden

respectievelijk door Makeblock Inventor kit en

Arduino UNO gebruikt….



Demo: online simulatie van Arduino UNO via circuits.io

Eerst bouw je de schakeling:

Meer weten over circuits.io?

https://circuits.io/

https://circuits.io/



Daarna gebruik je de ingebouwde Arduino IDE om de Arduino UNO te programmeren:

// Definieer pin 13 als intLED. Op de meeste Arduino-bordjes is pin 13 een LED.

const int intLED = 13;

// Geef het pinnummer op waarmee het SIG-signaal van de PING)))-sensor verbonden is

const int intPingPin = 11;

// Met pin nummer 2 is de drukknop verbonden

const int intPushButtonPin = 2;

//Stel de alarmafstand/gevoeligheid in op 50 cm

const int intGevoeligheid = 50;

//definieer variabelen om de schakelaarwaarde (=hetgeen de knop fysiek meet) en de schakelaarstand (= AAN of UIT) bij te houden

int intSchakelaarWaarde = 0;

boolean blnSchakelaar = false;

void setup() {

// initialiseer seriële communicatie (die we via de serial monitor kunnen uitlezen op het computerscherm). We hebben immers geen LCD-scherm verbonden met de Arduino...

Serial.begin(9600);

// initialiseer de digitale intLED-pin als output...

pinMode(intLED, OUTPUT);

//initialiseer de digitale intPushButtonPin als input...

pinMode(intPushButtonPin, INPUT);

}

void loop() {

//lees de schakelaarwaarde uit

intSchakelaarWaarde = digitalRead(intPushButtonPin);



if (intSchakelaarWaarde == HIGH) {

delay(500);



} else {


}

}


digitalWrite(intLED, HIGH); // zet de LED aan

Serial.println("Alarm AAN");

Serial.println();

// definieer variabelen voor duur en afstand van de afstandssensor

long lngDuration, lngCM;

// The PING)))-sensor wordt geïnitialiseerd door een HIGH-puls van min. 2 microseconden.

// We geven eerst een korte LOW-puls om daarna een nette HIGH-puls te bekomen

pinMode(intPingPin, OUTPUT);

digitalWrite(intPingPin, LOW);

delayMicroseconds(2);

digitalWrite(intPingPin, HIGH);

delayMicroseconds(5);

digitalWrite(intPingPin, LOW);

// Via dezelfde pin wordt het signaal van de PING)))-sensor terug ingelezen. Dit is een HIGH

// puls waarvan de duur de tijd in microseconden is vanaf het zenden van het signaal tot en met het ontvangen (nadat het op een object gebotst is)



pinMode(intPingPin, INPUT);

lngDuration = pulseIn(intPingPin, HIGH);

// converteer de tijdsduur naar een afstand

lngCM = microsecondsToCentimeters(lngDuration);

if (lngCM < intGevoeligheid) {

Serial.println("Alarm AAN");

Serial.println("INDRINGER!");

}

} else {

digitalWrite(intLED, LOW); // zet de LED uit

Serial.println("Alarm UIT");

Serial.println();

}

}

long microsecondsToCentimeters(long lngMicroseconds) {

// De snelheid van geluid is 340 m/s. Ofwel 29 microseconden per centimeter.

// Aangezien zo'n ping heen en weer gaat, moeten we de afstand nog eens delen door 2...

return lngMicroseconds / 29 / 2;

}



Demo: simulatie met Sam Labs

SAM labs (https://www.samlabs.com/) werkt mbv functieblokken die via Bluetooth communiceren met pc, tablet4 of cloud module (dit is een aangepaste Raspberry Pi) waarop je programma loopt. Het programmeren gebeurt visueel maar in tegenstelling tot de vorige oplossingen, verloopt dit eerder op vereenvoudigde manier (invoer -> verwerking -> uitvoer). Je zal er dus niet alle gekende programmeerstructuren expliciet in herkennen.

Om het alarm uit de voorgaande oefeningen te creëren, gebruik je volgende fysieke functieblokken:

1 knop (button)

1 RGB Led

1 zoemer (buzzer)

1 nabijheidssensor (proximity sensor)

Schakel eerst de vier blokken in door hun aan/uit-knoppen in te drukken zodat de blokken rood oplichten

Via de SAM-software op je pc (gebruik hierbij de bijhorende, speciale Bluetooth-dongle) of tablet kan je de functieblokken programmeren. Je dient echter wel in te loggen met je SAM-account. Je programma’s worden immers in de cloud bewaard… Indien je dat wenst, kan je deze programma’s nadien ook naar de cloud module pushen…

De vier gedetecteerde blokken dienen in de programmeerruimte (midden) gesleept.

4 Opgelet: de mogelijkheden op tablet zijn minder uitgebreid dan deze op pc!

https://www.samlabs.com/



Daarna verbind je de blokken zoals hieronder weergegeven.

In de bovenstaande code zet de drukknop het alarm aan of uit (via de TOGGLE-functie).

Indien het aan staat, blijft de LED paars branden.

Als het alarm aan staat én (AND) de nabijheidssensor geeft een waarde van > 50 weer (via de COMPARE-functie) dan weerklinkt enerzijds een alarmtoon en wordt anderzijds na 5 seconden (via de DELAY-functie) een signaal verstuurd naar IFTTT (https://ifttt.com/). Via deze website kan je heel wat dingen automatiseren. Zo zal in dit geval een mail (zie hieronder) verstuurd worden om te melden dat het alarm afging.

https://ifttt.com/



De instellingen van de COMPARE-, DELAY-, IFTTT-, buzzer- en LED-blokken pas je aan door er op te dubbelklikken.



Via de gratis webtool IFTTT (https://ifttt.com/) werd een applet gemaakt die een e-mail stuurt zodra de Maker-service getriggerd wordt.

https://ifttt.com/

physical computing - goahead.classy.begoahead.classy.be/wp-content/uploads/bundel2.pdf · ardublock...

Documents