Overzicht van dit Hoofdstuk
Een volledig overzicht van de cursus vindt je hier: Cursus Overzicht.
Invoer via de Seriële Monitor
We hebben de Seriële Monitor al veel gebruikt om te kijken wat de output (uitvoer) van onze programma’s was. Maar ja, daar hebben we niet veel aan als het programma statisch is en we dus zelf geen gegevens kunnen invoeren.Wat hebben we immers aan een rekenmachine als we geen berekeningen kunnen opgeven?
De reden waarom ik dat deel heb overgeslagen is dat dit helaas wat voorkennis vereist, omdat we tekst (en nummers) teken voor teken moeten gaan inlezen. Beetje maffe aanpak als je het mij vraagt, maar ja, aan de andere kant was de Arudino nooit ontworpen met de gedachte dat een beeldscherm en een monitor aangesloten zouden worden.
De Arduino is niet ontworpen met toetsenbord en beeldscherm in gedachten,
daarom zijn simpele functies zoals invoer lezen en uitvoer weergeven wat lastiger.
De Seriële Monitor heeft echter wel een manier om invoer (input) terug te sturen naar de Arduino, wat de Arduino dus weer kan lezen en kan gebruiken in ons programma. Hieronder zie je een afbeelding waar we deze invoer kunnen doen. Hier typen we onze tekst en klikken we vervolgens op de “Send” knop om tekst naar de Arduino te sturen.
Arduino Seriële Monitor – Tekst invoer
Tip: Herstart jouw Arduino Programma m.b.v. de Seriële Monitor
Elke keer als we de Seriële Monitor openen, zal de Arduino herstarten en de het scherm leeg maken, zodat we een nette en schone output (uitvoer) van ons programma kunnen zien.
Je kunt dit dus ook gebruiken om een programma opnieuw te starten: Sluit de monitor en open de monitor opnieuw en jouw programma start netjes opnieuw op. Ideaal als je wat herhaaldelijk wilt testen.
Herstart een programma: Sluit en Heropen de Seriële Monitor
Ad Blocking Gedetecteerd Vriendelijk verzoek om te overwegen Ad Blocking uit te zetten voor onze website.
We zijn afhankelijk van inkomen uit Advertenties om de website te kunnen draaien.
Je kunt ons ook op andere manieren ondersteunen (zie Ondersteun ons links bovenin).
Lezen van een String van de Seriële Monitor
Laten we even vlug nog eens door het basis stappen voor het werken met de Arduino lopen.
Wanneer de Arduino start (door het te verbinden met de USB aansluiting of via een externe stroom adapter), dan start het meteen het programma dat op dat moment in het geheugen van de Arduino zit. Dit geheugen, in tegenstelling tot het geheugen van b.v. een PC, wordt NIET leeg gemaakt als we de stroom van de Arduino halen.
We weten dat de Arduino vervolgens eerst een enkele keer de “setup()” functie gaat uitvoeren en als dat gedaan is, eindeloos “loop()” blijft herhalen tot we de stroombron dus van de Arduino loskoppelen.
Dit is zeer logisch, want de Arduino (of beter: de Microcontroller) is speciaal bedacht om een programma te draaien zodra het aangaat, waarbij het dus de voorbedachte of taken gaat uitvoeren. Dit kan het lezen van sensoren zijn, aanzetten van motortjes, maar dus ook het lezen van de seriële poort, en dat laatste is waar we onze kleine nieuwe functie voor gaan gebruiken.
Meer geavanceerde methoden om informatie van de seriële poort te lezen, omvat het inlezen van individuele bytes, welke gezien kunnen worden als het lezen van individuele sensors of schakelaars (toets-aanslagen).
Ik heb deze kleine functie alleen maar in elkaar gezet voor deze kleine cursus.
Via de seriële monitor geeft het een vraag weer, en wacht tot de gebruiker iets intypt en met een druk op de ENTER toets de invoer afsluit.
1 2 3 4 5 6 7 8 9
| String WachtOpInvoer(String Vraag) {
Serial.println(Vraag);
while(!Serial.available()) {
// wacht op input
}
return Serial.readStringUntil(10);
} |
We hebben al eerder met functies gewerkt, en we zijn dus in staat zelf functies te maken. Laten we daarom even snel door de voorgaande code lopen om te kijken hoe en wat we doen in deze functie.
Als eerste geven we de functie dus een naam “WachtOpInvoer” welke een “String” terug geeft – vergeet dus niet dat dit het object String is, met een hoofdletter “S” – en de vraag als parameter aanneemt. De “vraag” parameter is ook een “String” object. Het antwoord, een String, is wat de gebruiker heeft ingetypt.
Dit wil dus zeggen dat we de functie als volgt kunnen aanroepen: Antwoord = WachtOpInvoer("Mijn vraag");
Omdat we de vraag leesbaar voor de gebruiker willen hebben, sturen we de vraag naar de Seriële Monitor, daarvoor heb ik de bekende “Serial.println” functie gebruikt, waarmee we de gebruiker dus de gestelde vraag presenteren welke we als parameter hebben meegegeven aan de functie.
Daarna zien we iets raars in de “while”-loop. Ik hoop dat je de “while”-loop nog kunt herinneren? De “while”-loop controleert eerst een conditie, indien de conditie waar is zal het code blok worden uitgevoerd, en de loop weer herhaald worden.
De conditie in de “while”-loop is “niet Serial.available”. “Serial.available()
” is een methode van het “Serial” object, welke terug geeft hoeveel bytes het heeft gelezen van de seriële input. Dus als er nog niets getypt is, zal de return dus 0 (nul) zijn.
Serial.available() geeft het aantal, van de seriële poort gelezen bytes terug.
Als er nog geen bytes gelezen werden dan is het antwoord nul.
Nu moeten we nog even terug grijpen op hoe een boolean als nummer wordt opgeslagen. Dus dat false als nul opgeslagen is, en dat de “while”-loop een true conditie wil.
De operator not ( ! ) gooit deze nul (= false) om naar een true.
Dus de “while”-loop blijft lopen, zolang er geen seriële input is, immers, dat geeft nul als antwoord, wat hetzelfde is als false, en met “not” ervoor wordt dat dus een true.
Omdat we hier alleen maar willen wachten en eigenlijk verder niets anders willen doen, laten we het code blok van de loop gewoon leeg. Ik heb er wel even een opmerking in gezet zodat we weten dat het bewust leeg is en waarom de loop hier bestaat.
Als een gebruiker eenmaal een karakter invoert (een char wat weer hetzelfde is als een byte), zal de “Serial.available()” een nummer terug geven welke niet gelijk is aan nul. De not operator maakt hiervan het tegenovergestelde wat resulteert in een “false” waardoor de “while”-loop wordt verlaten.
In regel 8 gebruiken we het “return” statement – wat, zoals je misschien nog weet, het antwoord van de functie terug zal sturen.
In deze zelfde regel zien we ook een methode van Serial die we aanroepen: Serial.readStringUntil(10);
.
Serial.readStringUntil() geeft de gelezen bytes van de seriële invoer en zal het lezen stoppen tot een bepaalde karakter ontvangen wordt of er te lang geen activiteit was (de gebruiker heeft te lang niets ingetypt).
Omdat deze functie meteen terug komt met “niks” als we geen bytes hebben gezien via de seriële invoer, kunnen we deze dus niet meteen aanroepen en zijn we dus genoodzaakt eerder beschreven “while”-loop te gebruiken om te wachten tot er werkelijk iets is om te lezen.
De parameter die we aan deze methode (functie) geven is een karakter (of char) welke we als “einde invoer” gaan zien. We willen dat het drukken op de ENTER toets dat doet, en de ASCII waarde hiervoor is nummer 10 (zie de ASCII tabel) en daarom gebruiken we dus nummer 10 als onze parameter.
Stel we zouden willen dat de invoer afgesloten wordt als men de A toets indrukt, dan zou dat nummer 97 (uitgaande van een kleine “a”, welke de ASCII code 97 heeft).
Het antwoord van “Serial.readStringUntil” wordt vervolgens meteen aan het “return” statement doorgegeven zodat ons programma er iets mee kan doen.
Even een klein demo programma:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
| void setup() {
// set the speed for the serial monitor:
Serial.begin(9600);
Serial.println("De Arduino is wakker ...");
String OntvangenAntwoord;
OntvangenAntwoord = WachtOpInvoer("Voer a.u.b. jouw voornaam in.");
Serial.print("Jouw voornaam is: ");
Serial.println(OntvangenAntwoord);
OntvangenAntwoord = WachtOpInvoer("Voer a.u.b. jouw achternaam in.");
Serial.print("Jouw achternaam is: ");
Serial.println(OntvangenAntwoord);
Serial.println("Jouw Arduino is nu klaar met de setup functie en gaat nu oneindig de loop functie uitvoeren ...");
}
void loop() {
// leave empty for now
}
String WachtOpInvoer(String Vraag) {
Serial.println(Vraag);
while(!Serial.available()) {
// wacht op input
}
return Serial.readStringUntil(10);
} |
Om te voorkomen dat we eindeloos dezelfde vraag krijgen, plaatsen we on code, zoals gebruikelijk, in de “setup()” functie.
We definiëren dus eerst een variabele, van het data type “String” object, omdat we hierin het antwoord willen opvangen.
Vervolgens zien we twee vergelijkbare delen van ieder 3 regels lang, waarin we eerst onze vraag stellen (om een naam vragen), en vervolgens het antwoord weergeven.
Dus elke keer als we een vraag stellen, gebruiken we onze “WachtOpInvoer()” functie.
Een maal ontvangen (dus de gebruiker heeft iets getypt en op ENTER gedrukt), geven we een stukje tekst weer, gevolgd door het antwoord van de gebruiker.
Als zowel voor- als achternaam afgehandeld zijn, geven we nog even een melding dat de “setup()” functie klaar is en de eindeloze herhaling van de (lege) “loop()” functie is begonnen.
Invoer van Gehele Nummers via de Seriële Monitor
We kunnen nu dus tekst invoer afhandelen, maar kunnen we ook nummers op die manier invoeren?
De uitdaging bij het lezen van nummers is dat onze invoer uit tekst bestaat. Zoals we al eens eerder hebben besproken bij Deel 3, tekst en nummers worden op een andere manier opgeslagen. Daarbij komt dan ook nog eens dat tekst niet alleen uit nummers bestaat, maar ook uit letters, speciale tekens, etc.
Laten we nog een keer door die uitleg lopen: Stel we hebben gebruiker die het nummer “3” invoert en op ENTER drukt.
Het antwoord van onze functie is dus een string welke slechts 1 karakter bevat. Als we in de ASCII tabel kijken dan zien we dat “3” het nummer 51 levert.
Dit moeten we dus omzetten naar een echt nummer. Laten we eens kijken wat er gebeurt als we ons beperken tot gehele nummers (int).
De lastige conversie van Tekst naar Nummer
Je mag dit stukje overslaan als je wilt, maar het is leuk om even door te lopen omdat het je helpt met de manier van denken, mocht je in de toekmst complexere programma’s gaan schrijven. Er zijn overigens efficientere methoden om tekst om te zetten naar een nummer!
Het omzetten van tekst naar nummer kan een beetje saai zijn; je leest een karakter, en converteert het naar een nummer, stap voor stap.
Stel we hebben het nummer “3456” als een string en we willen hier dus een int van maken.
We beginnen bij het einde van de tekst, en dus van rechts naar links gaan werken, dus beginnen met het karakter “6”, wat in ASCII het nummer 54 is.
Omdat de nummers in een ASCII tabel bij 48 begint, moeten we dus 48 aftrekken van 54 om het nummer 6 te krijgen.
“6” = ASCII 54, “0” = ASCII 48 => 54 (“6”) – 48 (“0”) = 6
Antwoord = 6
Omdat we van rechts naar links werken, is het volgende karakter een “5”. “5” heeft de ASCII waarde 53, dus daar gaan we weer, of toch niet?
Niet dus! Even terug denkende aan de manier hoe we tellen; het nummer “5” staat eigenlijk voor “50”!
Dus moeten we onze formule aanpassen zodat het voorziet in 10-tallen, 100-tallen, 1000-tallen etc.
Zie je hier al een patroon?
Als we van rechts naar links gaan, wordt er steeds een extra “0” toegevoegd aan een nummer. En als we beginnen te tellen met “0” (nul) dan zouden we het volgende kunnen zeggen met betrekking tot ons voorbeeld:
Voor de 6 voegen nul nullen toe, voor de 5 èèn nul (50), voor de 4 twee nullen (400) en voor de 3 drie nullen (3000).
Om het makkelijker te maken: laten we de tekst eens omdraaiden, dus “6543” wordt nu “3456”.
Herinner je nog dat arrays met tellen bij nul beginnen? Hetzelfde geldt hier, omdat we eigenlijk ook hier met een array werken.
Dus we definiëren een string (3456) en een integer (0) en draaien de string (6543).
Vervolgens maken we een loop waarbij wel elk element van de array gaan bekijken. Niet vergeten: we hadden de string omgedraaid!
Voor het eerste element (6) doen we de ASCII truc, dus 54 – 48, wat resulteert in 6.
Voor het tweede element, doen we ook weer de ASCII truc, maar vermenigvuldigen dat met 10, dus ( 53 – 48 ) * 10, wat dus 50 wordt, en tellen dit op bij het voorgaande nummer, dus: 50 + 6 = 56.
Voor het derde element doen we dit ook weer, maar dan keer 100, dus ( 52 – 48 ) * 100, wat dus 400 wordt, en tellen dit bij het vorige resultaat op: 400 + 56 = 456.
En weer voor het laatste element, maar dan keer 1000, dus ( 51 – 48 ) * 1000, en weer opgetelt: 3000 + 456 = 3456.
Nu hebben we nog een truc nodig om te voorzien in 10, 100 en 1000, en die is er ook, want we kunnen dat schrijven als “10 tot de macht”.
Ons eigenlijke rijtje is namelijk: 1, 10, 100, 1000 …
100 = 10 tot de macht 0, is hetzelfde als 1,
101 = 10 tot de macht 1, is hetzelfde als 10,
102 = 10 tot de macht 2, is hetzelfde als 10 × 10 (=100), en
103 = 10 tot de macht 3, is hetzelfde als 10 × 10 × 10 (=1000).
Je bent misschien niet, of niet zo, bekend met het werken met “tot de macht”, maar misschien herinner je nog dat we het hier eerder over gehad hebben. In dit geval is het super handig in een loop als we dus 1, 10, 100, 1000 etc. nodig hebben in onze loop. Onze loop begint namelijk bij nul en eindigt (in ons voorbeeld) met 3 – niet vergeten he: 0, 1, 2, 3 … in tegenstelling tot hoe mensen tellen: 1, 2, 3, 4.
Vergeet ook niet:
“Tot de macht” zegt hoe vaak een nummer gebruikt wordt in een vermenigvuldiging, of in andere woorden:
Hoe vaak we 1 moeten vermenigvuldigen met dit nummer.
10 tot de macht 3, wordt geschreven als 103.
En als we bovenstaande tekst lezen dan wil dat dus zeggen dat we “1” drie keer met 10 moeten vermenigvuldigen en dat wordt dus:
10 tot de macht 3 = 103 = 1 × 10 × 10 × 10 = 1000
Nog wat voorbeelden:
10 tot de macht 1 = 101 = 1 × 10 = 10
2 tot de macht 4 = 24 = 1 × 2 × 2 × 2 × 2 = 16
3 tot de macht 2 = 32 = 1 × 3 × 3 = 9
Als we met machten rekenen, dan hebben we een speciaal geval, en wel “tot de macht nul”. Welk getal je ook neemt, “tot de macht nul” levert altijd 1.
Als je nog even terug leest naar de regel die ik je heb gegeven dan klopt dit ook.
Lees het onderstaande als: vermenigvuldig “1” nul keer met “2”. Dus levert dat … “1” als antwoord:
2 tot de macht 0 = 20 = 1
OK nu we een beetje afgedwaald zijn … terug naar tekst naar nummer converteren.
De eenvoudige String naar Nummer Conversie
Het moge duidelijk zijn dat voorgaande methode een dikke ellende is als we dit iedere keer moeten doen als we een tekst naar een nummer gaan converteren, en daarbij komt ons String object weer als goede hulp uit de bus. Het object heeft namelijk een methode (functie) die dit allemaal voor ons doet.
Nogmaals: de belangrijkste reden waarom we eerst door de moeilijke methode gegaan zijn, is zodat je een manier van denken gaat ontwikkelen om zelf handige trucs in de toekomst te bedenken als je moeilijkere programma’s gaat schrijven. Het geeft echter aan waarom we functies en methoden hebben, waarbij we eerder geschreven code kunnen hergebruiken en onszelf dus veel werk kunnen besparen.
Dus het “String” object heeft een methode die “toInt()” heet, welke de string tekst omzet naar een integer (int).
De methode “toInt()” begint met het eerste teken in de tekst, als dit geen nummer is, dan stopt het meteen en geeft als antwoord nul terug. Mocht dit echter geen nul zijn, dan gaat het verder naar het volgende teken in de tekst, en blijft dit herhalen tot het een teken tegen komt welke geen nummer is, of tot de tekst op is. Vervolgens pakt de methode alle gevonden nummers en zet ze om en geeft het resultaat terug als antwoord. Niet vergeten dus: zodra een niet-nummer gevonden wordt, stopt de methode en converteert het wat het gevonden heeft aan nummers.
Een paar voorbeelden:
toInt() voorbeelden
String |
Geconverteerd naar int |
1234 |
1234 |
12Hallo34 |
12 |
Hallo1234 |
0 |
12.3 |
12 |
0123 |
123 |
Ik heb de nummers in de string voorbeelden expres dik gedrukt, zodat je beter ziet wat er wel en wat er niet omgezet gaat worden.
Hier een voorbeeld, waarbij we deze methode gebruiken, samen met onze eerder bedachte functie:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| void setup() {
// set the speed for the serial monitor:
Serial.begin(9600);
Serial.println("Jouw Arduino is wakker ...");
String OntvangenAntwoord;
OntvangenAntwoord = WachtOpInvoer("Voer een geheel nummer in.");
Serial.print("De tekst invoer was: ");
Serial.println(OntvangenAntwoord);
Serial.print("Geconverteerd naar een geheel nummer is dit: "); Serial.println(OntvangenAntwoord.toInt()); }
void loop() {
// leave empty for now
}
String WachtOpInvoer(String Vraag) {
Serial.println(Vraag);
while(!Serial.available()) {
// wacht op input
}
return Serial.readStringUntil(10);
} |
Dit voorbeeld lijkt natuurlijk veel op het voorgaande voorbeeld, maar een van de dingen die meteen zou moeten opvallen is dat we “String” object’s methode “toInt()” aanroepen. En dat doen we via de variabele “OntvangenAntwoord”, gevolgd door een punt ( . ) en vervolgens de naam van de methode “toInt()”. We hebben dit al eens eerder gedaan, zoals je kunt zien bij alles “Serial” aanroepen die we gedaan hebben met “begin” en “print”.
Een methode van een Object wordt aangeroepen door de variabele naam van het object, gevolgd door een punt en de methode naam, aan te roepen.
Ad Blocking Gedetecteerd Vriendelijk verzoek om te overwegen Ad Blocking uit te zetten voor onze website.
We zijn afhankelijk van inkomen uit Advertenties om de website te kunnen draaien.
Je kunt ons ook op andere manieren ondersteunen (zie Ondersteun ons links bovenin).
Invoer van Nummers, met Nummers achter de komma, via de Seriële Monitor
We hebben dus net gezien hoe we gehele nummers uit tekst kunnen omzetten, en je kunt je voorstellen dat dit met getallen et nummers achter de komma nog lastiger is. Overigens: niet vergeten dat bij het programmeren, we in het “Engels” werken en daarbij wordt er dus niet een komma maar een punt gebruikt voor cijfers achter de komma. Dus 1 en een half is dut niet 1,5 (Nederlands) maar 1.5 (Engels!).
Gelukkig hoeven we ook hier geen moeilijke dingen te doen, omdat het “String” object hiervoor een vergelijkbare methode heeft en wel “toFloat()“.
Vergeet dus niet dat nummers met cijfers achter de komma een “float” heet.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| void setup() {
// set the speed for the serial monitor:
Serial.begin(9600);
Serial.println("Jouw Arduino is wakker ...");
String OntvangenAntwoord;
OntvangenAntwoord = WachtOpInvoer("Voer een nummer in.");
Serial.print("De tekst invoer was: ");
Serial.println(OntvangenAntwoord);
Serial.print("Geconverteerd naar een float nummer is dit: ");
Serial.println(OntvangenAntwoord.toFloat());
}
void loop() {
// leave empty for now
}
String WachtOpInvoer(String Vraag) {
Serial.println(Vraag);
while(!Serial.available()) {
// wacht op input
}
return Serial.readStringUntil(10);
} |
Andere String object methoden (functies)
We hebben net twee methoden bekeken van het “String” object, maar er zijn we nog meer. Kijk zeker eens naar de Arduino Reference pagina van het String object waar nog meer methoden getoond worden. Helaas is deze pagina in het Engels, maar misschien snap je het e.e.a. wel.
We vinden op die pagina methoden om b.v. een string korter te maken door overbodige spaties weg te halen, of b.v. een string helemaal in hoofdletters of kleine letter te zetten.
De Arduino Reference pagina is een goede start voor het zoeken naar nog meer Arduino functies en methoden als je aan de slag gaat met Arduino Programmeren.
N.b.: Het Engelse woord “reference” wil zoiets zeggen als “naslagwerk”. Dus een “referentie” gids zeg maar. Deze worden door programmeurs vaak gebruikt om even snel te kijken hoe het ook al weer zat als we even vast lopen.
Ik zal hieronder een aantal van deze methoden laten zien, en wil je zeker aanmoedigen om met een aantal van deze methoden te gaan spelen.
Methoden
Ik heb hieronder de meest gebruikte methoden van het “String” object gezet, en er een link van gemaakt naar de betreffende Arduino Reference pagina.
- String() – Maak een String object
- charAt() – Benader een specifiek karakter in een string
- compareTo() – Vergelijk twee strings
- concat() – String aan een andere string plakken
- endsWith() – Kijk of een string eindigt met een specifiek stukje tekst
- equals() – Kijk of twee strings identiek zijn (hoofdletter gevoelig!)
- equalsIgnoreCase() -Kijk of twee strings identiek zijn (NIET hoofdletter gevoelig!)
- getBytes() – Kopieerd de individuele bytes van een string in een buffer
- indexOf() – Zoekt een karakter of string in een string en geeft de locatie terug
- lastIndexOf() – Zoekt het laatste voorkomen van een karakter of string in een string en geeft de locatie terug
- length() – Geeft de lengte terug van een string, maar zonder het NULL karakter mee te tellen!
- remove() – Verwijder 1 of meer karaketers van een string
- replace() – Vervang 1 of meer karakters in een string met een andere string
- setCharAt() – Verander een individueel karakter in een string, naar een ander karakter
- startsWith() – Kijk of een string met een bepaalde tekst begint
- substring() – Haal een stukje van de string op
- toCharArray() – Converteer een”String” object naar een “string” array van karakters
- toInt() – Converteer een string tekst naar een integer
- toFloat() -Converteer een string naar een string tekst naar een float
- toLowerCase() – Maak alle letters in een string, kleine letters
- toUpperCase() -Maak alle letters in een string, hoofdletters
- trim() – Verwijder alle spaties aan het begin en einde van een string.
Ad Blocking Gedetecteerd Vriendelijk verzoek om te overwegen Ad Blocking uit te zetten voor onze website.
We zijn afhankelijk van inkomen uit Advertenties om de website te kunnen draaien.
Je kunt ons ook op andere manieren ondersteunen (zie Ondersteun ons links bovenin).
Laatste gedachten …
We hebben nu 9 hoofdstukken doorlopen van onze mini cursus (bij gebrek aan betere woorden) voor het Arduino Programmeren voor beginners in de programmeertaal “C”, en daarbij hebben we het gratis Arduino IDE gebruikt en een eenvoudige Arduino Uno.
Ik hoop dat je er plezier aan gehad hebt, en dat je wat dingen geleerd hebt.
Je zou nu instaat moeten zijn om een simpel programa te schrijven voor jouw Arduino. De meeste dingen zitten vast nog niet goed in je hoofd, maar dat is een kwestie van veel doen en vaak opzoeken. Maar,… maak je niet ongerust. Dingen die je vaak gebruikt ga je vanzelf onthouden. En … het opzoeken van dingen is na jaren programmeren nog steeds heel normaal, ook voor mij. En ik schreef mijn eerste programma’s in 1978. Daarom zijn er ook zo veel referentie boeken en websites die je daarbij kunnen helpen.
Bedenk ook dat dit slechts het begin is van het werken met een Arduino en het programmeren in het algemeen …
Het werken met een Arduino bestaat uit twee aspecten: het programmeren en het werken met electronica. Beiden vereisen basis kennis om er mee aan de slag te gaan.
De volgende stap is het spelen met wat electronica natuurlijk, zoals sensoren, schakelaar, lampjes, motors, relays, en zelfs schermpjes.
Als je naar het Tweaking4All menu kijkt (links), kijk dan eens on “Hardware” “Arduino”, waar ik al wat eenvoudige voorbeelden heb gezet, maar ook complezere en mooie projecten zoals met LED strips werken.
Met wat fantasie en handigheid kun ook misschien ook een robot bouwen in de toekomst …
Als er ambitie voor is, dan zal ik nog een serie zoals deze starten voor het werken met basis electronica, laat het gerust horen in de opmerkingen onder ieder deel, en stel hier ook gerust vragen. Niet vergeten: er zijn geen domme vragen, alleen dom zijn door niet te vragen, we zijn allemaal een keer bij nul begonnen …
Omdat dit het, voorlopig, laatste deel is, kun je terug gaan naar het begin of naar het overzicht van de cursus.
Reacties
Er zijn 35 reacties welke je hieronder kunt lezen.
Je kunt jouw eigen opmerkingen plaatsen m.b.v. dit formulier, of een reactie op een bestaande opmerking plaatsen door op de "Beantwoorden" knop te klikken.
Nog even en de 75 jaar is gepasseerd.
Bijna mijn hele leven lang met techniek bezig geweest waarvan een groot deel met programmeren.
Desondanks voelt het lezen van o.a. deze (geweldige) minicursus als: “Wat heb ik eigenlijk gedaan in mijn leven” en “Vaak voel ik mij een kleuter bij al die mensen die zich al jaren met de Arduino-programma’s bezig houden en schrijven”.
Net als in 1967 de beste cursussen bij Dirksen te vinden waren, (vind ik) zo leest en voelt deze mini-cursus als een verademing vergeleken bij andere. (dit zijn mijn gedachten ! )
Wat mij betreft: Heel diep petje af !
Met vr. groet,
Multech
Multech
Hallo Multech!
Dank je wel voor dit geweldig mooie compliment!
Ik schrijf graag zoals ik dingen verbaal zou uitleggen, en het is altijd maar een gok of mensen dit natuurlijk waarderen. Dus ik ben bijzonder blij te horen dat de schrijf stijl bevalt, en dat je de moeite hebt genomen om het hier als opmerking te plaatsen.
Erg toevallig dat je 1967 vermeld, dat is namelijk mijn geboortejaar …
Mijn vader deed veel HAM Radio, dus zo kwam ik in de electronica terecht, de naam “Dirksen” klinkt nog bekend in de oren!
Nogmaals hartelijk dank! Het geeft nog meer motivatie om door te gaan met artikeltjes voor deze website.
hans
Dank je wel Hans voor deze minicursus.
Op een leuke manier leg je de basis uit en het nodigt uit om te experimenteren.
De lastigste liet je voor de laatste les, door het omzetten van tekst naar cijfers dmv een array of character niet uit te werken.
Als het dan toch lukt is het een grote overwinning. Dank je wel. m.vr.gr. Laurent
laurent
Dank je wel voor het compliment Laurent,
Ik zal proberen dat stukje een beetje beter uit te werken …
Maar zoals je zelfs al aangaf: het is toch leuk om zelf een overwinning te halen!
hans
ja hoi, ik krijg een foutmelding: collect2.exe: error: 1d returned 5 exit status na uw code beginnend met:
keith
Hoi Keith,
Dit probleem blijkt zich soms voor te doen en wijst naar problemen met de linker (LD).
Als eerste zou ik de Arduino IDE helemaal verwijderen, inclusief de directory waar de libraries en jouw eigen code staat.
Daarna de meest recent Arduino IDE downloaden en herinstalleren.
Welke Arduino IDE gebruik je en met welk besturingssysteem?
hans
p.s. op het Arduino Forum staan erg uitgebreide discussies hierover, mocht je interesse hebben.
hans
Dankjewel voor de verhelderende cursus, Hans !
Ik ga nog dikwijls moeten langskomen om even te spieken, maar ik heb er toch wel wat geleerd.
En nu op naar de praktijk :-)
Carlo
Dank je wel Carlo! Mooi om te horen en vooral bedankt voor het plaatsen van een bedankje, dat wordt zeer gewaardeerd!
Veel plezier met de Arduino!
hans
Mooie uitleg. Helder en verbeeldend uitgelegd.
Ben je inmiddels ook al zo ver voor een uitleg over de elektronica?
Zeker intresse…
Rik
Hoi Rik,
sorry voor het late antwoord, en hartelijk dank voor het compliment! De afgelopen is het wat druk geweest met andere projecten.
Ik heb wel een plan klaarliggen om met de elektronica aan de slag te gaan, maar ben er nog niet aan toegekomen.
Zoals het er nu uitziet (met werk e.d.) kan het nog even duren voor ik hier tijd voor ga krijgen.
Als ik van m’n website kon leven, dan zou het anders zijn haha … maar ik doe m’n best om dit onderdeel in de komende maanden te kunnen plaatsen.
hans
Haha, geen probleem..zoals je ziet kijk ik ook niet dagelijks…ik hou het in de gaten. Kan mijn zoontje eerst eens aan de slag gaan met programmeren en daar de beginselen van onder de knie krijgen (na sinterklaas wel eens waar )…
Rik
Haha, leuk!
Misschien is het leuk om de Sint een Arduino Starter Kit te laten bezorgen
Ik heb er ooit zelf ook een aangeschaft omdat het vaak een leuke verzameling van kleine elektronica is om mee te beginnen.
hans
Je kunt gedachten lezen…dat was inderdaad de planning
Rik
Geweldig!
hans
Hoi Hans,
Nog steeds intresse hier voor een uitleg van de elektronica.
Het programmeren begint langzaam goed door te dringen. Met dan aan je heldere uitleg
Rik
Hoi Rik!
Mooi om te horen dat het programmeren lekker begint te gaan.
Misschien een Tip voor beginners waar ik ook nog een stukje voor zou moeten schrijven:
Altijd je code “netjes” schrijven (dus correct inspringen, evt. commentaar plaatsen etc).
Dit maakt leesbaarheid (ook op een later tijdstip) stukken beter, en maakt het oplossen van problemen ook stukken beter.
Goed om te horen dat je interesse hebt in de elektronica.
Ik moet echter nog 2 andere grote projecten afmaken voor ik hier iets aan kan gaan doen.
Daar komt dan nog bij dat ik ook nog de nodige componenten in huis moeten halen.
Daarnaast ben ik geen elektronica expert, en zal ik dus ook wat research moeten doen, om er voor te zorgen dat ik geen “onzin” loop te verkopen .
En als laatste: Het schrijven van dergelijke artikelen kost vaak 2 hele dagen per “pagina” (uitzoeken, schrijven, vertalen, afbeeldingen, testen etc).
Dus in het kort: ik ben zeker van plan hier iets mee te gaan doen, maar het kan even duren …
Hans
Hallo Hans,
Heel erg bedankt voor deze cursus!
De uitleg in je moerstaal is erg fijn voor deze zware kost.
Nu aan de slag met wat ledjes en motortjes.
Nogmaals dank, Peter
Peter
Hoi Peter!
Kijk dat is nou mooi om te horen! Geweldig dat je er wat aan had, en veel plezier met de volgende stap
En natuurlijk; een geweldig nieuw jaar gewenst!
hans
Dag Hans,
Ben sinds een paar maanden aan het stoeien met de Arduino. Als gepensioneerde Wtb-er niet gewend aan programmeren in C en elektronica. Ik vind je cursus zeer verhelderend en duidelijk opgezet, waarvoor mijn Hartelijke Dank.
Wim
Wim
Hoi Wim!
Graag gedaan en hartelijk dank voor het nemen van de moeite om een mooi compliment te plaatsen – dat wordt zeer gewaardeerd!
hans
Hallo Hans,
hele fijne manier om met de Arduino te beginnen. Ik had het ding ooit eens gekregen, maar had er geen doel voor. Dus er heeft een stukje software op gedraaid waardoor een LED knipperde.
Nu ben ik bezig om een programma te ontwerpen wat het aantal omwentelingen van een windmolen kan meten. Zowel het momentele aantal omwentelingen als omwentelingen per jaar.
Met deze cursus ben ik lekker op gang geholpen.
Waarvoor dank!
Als er mensen naar de mogelijkheden van een Arduino vragen zal ik ze zeker hier naar toe verwijzen.
RonalT
Hi RonalT!
Dank je wel voor het compliment en dat je de moeite hebt genomen om dat hier te plaatsen – dit zorgt zeker voor extra motivatie om door te gaan met de website
Ook tof dat je mensen doorverwijst naar de mini cursus!
Succes met het windmolenproject – dat klinkt zeker als een interessant project!
hans
dag hans. bedankt voor deze cursus aan te bieden.
heel duidelijke verwoord allemaal .
ik ben nu zelf bezig met een cursus aan het volgen met ook de nodige bijhorende schriftelijke theorie .
deze lijkt toch voor mij onduidelijk en moeilijk te volgen..
maar nu ik deze van jou heb ,is het voor mij juist al heel wat duidelijker om alles te volgen.
ik ben totaal geen ervaren programmeur ofzo, maar dit is echt wat ik nodig heb om terug met veel plezier te leren over het programmeren van de arduino.
heel erg merci
Bart
Hallo Bart!
Hartelijk dank voor de fijne reactie!
Het is altijd leuk om te horen dat iemand er wat aan heeft, en al zeker als het leerplezier positief beïnvloed
Helemaal top, en nog veel plezier met de Arduino
Hans
Geweldig!
Groet Simon
Simon
Dank je wel Simon!
Mooi, en motiverend, om te horen dat je de mini cursus geweldig vindt!
Hans
Beste Hans,
Als nieuwkomer in de wereld van Arduino kwam ik er snel achter dat het belangrijk is eerst meer te weten over het programmeren. Er is veel informatie te vinden over de Arduino, maar die start altijd bij het aansluiten van allerlei sensoren LED’s en meer, terwijl juist het deel wat daaraan vooraf gaat enorm belangrijk is.
Daarover is weinig informatie te vinden (zeker niet in het Nederlands), totdat ik op deze website terecht kwam (na veel Googlen).
In de afgelopen periode heb ik menig uurtje doorgebracht op deze site en alle hoofdstukken doorlopen. Mijn welgemeende complimenten voor de zeer duidelijke uitleg en voorbeelden die je hebt beschreven. Hartelijk dank daarvoor!
Ik heb in voorgaande reactie gelezen dat er een kans is dat je een vervolg gaat maken wat zich toespitst op de elektronica in combinatie met de Arduino. Kun je daar al iets meer over vertellen? Zit dat “in de pen”?
Jan-Willem
Hoi Jan-Willem,
hartelijk dank voor het compliment
Ik probeer al even om tijd te vinden voor een vervolg (wat basis hardware), maar door persoonlijke omstandigheden zit ik al bijna 3 jaar “klem” (Covid heeft het e.e.a. alleen maar erger gemaakt). Ik zou hier dolgraag meteen aan willen beginnen, maar voorlopig hebben andere zaken dus voorrang (o.a. werk vinden).
Maar … het plan is echt wel om hier wat mee te doen!
Hans
Hallo Hans,
Begrijpelijk. Dat soort zaken gaan natuurlijk voor. Het loopt niet weg. Ik zal deze site met enige regelmaat bezoeken (alleen al om even terug te kijken in de “mini cursus”).
Sterkte met het verwijderen van de “klem” :-)
Jan-Willem Rommerts
De website met regelmaat bezoeken is zeker erg welkom!
Het lastige is dat bijna elke pagina 1 tot 2 dagen werk kost (schrijven, verifieren, vertalen, etc).
Als je overigens vragen hebt: stel ze gerust hier, of (beter) in het Arduino forum.
Hans
Dankjewel voor de heldere uitleg. Ik heb vele stukken meerdere keren moeten lezen om het te kunnen begrijpen, maar dat ligt meer aan mij dan aan je schrijfwijze .
Het heeft me menig avond, weekend gekost om er doorheen te komen, maar daar heb ik absoluut geen spijt van! Ik ben een beginner in programmeren. Veel simpele dingen kan ik wel aanpassen van een bestaand programma, maar de logica erachter is me nu een stuk duidelijker geworden.
Je uitleg geeft me zin om het e.e.a. verder uit te pluizen, terwijl ik hiervoor snel de hoop opgaf. Nogmaals dank voor je harde werk, meteen maar lid geworden .
Fred.
fredrossi
Hoi Fred,
Zag net jouw gulle koffie donatie voorbij komen – hartelijk dank (weet nu dan ook of je Nederlands of Frans spreekt ).
Leuk om te horen dat de cursus zinvol voor je was – altijd fijn en motiverend!
Mocht je vragen hebben, stel ze dan gerust.
Hans
Fantastisch Hans, je bent een kei! Verrukkelijk om in mn moerstaal te kunnen leren programmeren van de Arduino. Er is mij nu zoveel duidelijker geworden van de vele dingen die ik al heb ‘lopen’ in mijn eigen kleine IOT omgeving. Gedaan met behulp van MySensors welliswaar maar kan nu eindelijk meer de diepte in!
Ik woon zelf als gepensioneerde in Slowakije (eigen pension & Camping SOKOL) na een werkzaam leven als ICT projectmanager. Begonnen in 1973 als ‘buitendienst servicemonteur’ bij Ormas (o.a. SHARP calculators) en daarna WANG IJsselstein.
Zag ook dat je inmiddels met de ESP8266 / EPS32 een mooi stuk hebt geschreven! ALLE LOF Hans!! Bij mijn registratie staat mijn email als je daar een korte reactie geeft zal ik graag meer in contact komen om je te kunnen assisteren indien gewenst.
Harm Jeurink (HJ_SK)
hj_sk
Hoi Harm!
Leuk om zo’n leuke reactie te zien!
Ik zal je ook een reactie per email sturen
Hans