Arduino programmeren voor beginners

blackdog

Golden Member

Hi peterzoetermeer, :-)

Het eerste wat je zal moeten leren is een aantal zaken weg te laten en daar geen denkprocessen aan besteden :-)
En nu denk jij: maar wat dan allemaal!

Opmerkingen in de code
Een van de eerste dingen die ik doe, als ik een library of een voorbeeld stukje code gebruik is alle Blah, Blah er uit editen,
eindelijk rust voor mijn oogies en brein!
Kijk daar later maar eens naar als je een stuk verder bent, voor nu, weg er mee.

Dit betekend een regel met een opmerking en dat gaat niet naar de Microcontroler.
// Wat je hier ook schrijft, is alleen ter verduidelijking voor de code lezers en worden tijdens het omzetten van de code genegeert.

Heb je veel te zeggen dan doen ze het op de onderstaande manier, om de twee "//" caracters per regel te besparen.
Ik vind het echter hierdoor minder leesbaar worden, als ik door de code scroll.

/*
Deze regels beginnen allemaal zonder de twee // en worden tijdens het omzetten van de code genegeert,
net als wat ik hierboven heb aangegeven met de regels die beginen met //
Je kan zo uren doorgaan maar er wordt echt geen bitje in de microcontoler omgezet.
Je zet hier opmerkingen in voor jezelf of anderen die de code gaan lezen.
*/

Vreemde manier omschrijving van een doel van de code
Waar ik tegen aan liep is b.v. deze twee die je in bijna ieder stukje Arduino code tegenkomt: void setup() en void loop()
Wat nou "lege" loop en "lege" setup, dit ging er in mijn brein echt niet in, dus de enige manier is dan te accepteren dat men het op deze manier heeft vormgegeven.
Dit heb ik als volg begrepen, dat het een label is en dat het label zelf verder niets doet, dus geen data in of uit.
(Heren, als het anders is corect me!)

Arduino type
De beste manier om te beginnen is denk ik toch een Arduino Uno, lekker groot, geen gedonder met comm poort instellingen,
makkelijk de experimenteer draadjes op aan te sluiten en er is zeer veel info over te vinden.
En start met de knipperende L.E.D. code, om deze aan te passen zodat je direct feedback krijgt van je acties.

Grote en kleine letters
Oja dan deze nog even =>

c code:

adc->setReference(ADC_REFERENCE::REF_EXT, ADC_0);

Met opset wordt er in dit stukje voorbeeldcode hoofd en kleine letters gebruikt.
Maak ik hier allemaal kleine letters van, dan gaat het echt net werken.

Variabelen
Zelfs bij de eerste code worden al variabelen gebruikt...
Zie het stukje code van de knipperende L.E.D.

Als je goed kijkt passen ze hier twee manieren toe, voor het maken van opmerkingen in de code, precies zoasl ik het beschreven heb.
Maar terug naar de variabelen, dat zijn geheugenplekjes met verschillende grote en eigenschappen om vaste en/of tijdelijk data in op te slaan.

Dit is een plaatje geleend van deze website: https://www.tweaking4all.nl/hardware/arduino/arduino-programmeer-cursu…
http://www.bramcam.nl/Diversen/Variabelen-Tweaking4all.png

Waarom niet gewoon "1" variabelen voor alles toepassen? dat zou te veel ruimte in nemen in de code.
De microcontrolers zijn geen gewone computers waar je even 8GB memory bij prikt...
Dus je zal vooral bij wat langere code zuinig moeten omgaan met de beschikbare ruimte hiervoor.

Print het lijstje uit als je met de Arduino gaat werken, hou het bij de hand totdat je het kan dromen :-)

c code:


/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.
*/
 
// Pin 13 has an LED connected on most Arduino boards.
// Pin 11 has the LED on Teensy 2.0
// Pin 6  has the LED on Teensy++ 2.0
// Pin 13 has the LED on Teensy 3.0
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {                
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);     
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}

Je kan als je dat wilt alle opmerkingen uit de code halen als dit je teveel afleid, doe ik regelmatig nadat ik ze eenmaal heb gelezen.
In bovenstaande code is het heel duidelijk wat er allemaal gedaan wordt,
juist voor de beginner staat er wat extra opmerkingen in.

c code:


  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

Alles wat achter de twee // staat hoef ik nu niet meer te weten omdat de code die er voor staat voor mij nu duidelijk is.
Kleine stapjes tegelijk, laat je niet te snel ontmoedigen.
Ga er mee spelen als je fris bent en een open mindset hebt.

Lambiek
Ik ga hier geen PIC, Arduino of de TI Microcontroler oorlog starten.
Mijn brein voelt zich iets beter thuis in de Arduino omgeving, heeft te maken met hoeveel tijd ik beschikbaar heb voor coderen.
Ik gebruik Teensy's als ik meer geheugenruimte, snelheid of een betere ADC nodig heb.
Ieder mag voor zichzelf uitzoeken wat hij prettig vind in de hobby omgeving.
Doe je het voor je werk, dan kies je meestal voor andere controlers en programmeer omgevingen, maar voor hobby mag iedereen van mij met Prof spul werken, jullie feestje.

Groet,
Bram

You have your way. I have my way. As for the right way, the correct way, and the only way, it does not exist.
big_fat_mama

Zie Paulinha_B

@Bram: de void bij de functiedeclaraties van setup en loop hebben een betekenis: ze geven aan - zoals bij elke functiedeclaratie - wat de betreffende functie teruggeeft als resultaatwaarde. void betekent dan dat de functie volstrekt niets teruggeeft - een beetje onverwacht, vanuit het standpunt van een functie bekeken. Nogal wat functies geven een return code terug, met als conventie dat 0 betekent "het is gelukt" - dan is het dus int mijn_functie en niet meer void mijn_functie.

Voor het overige ga ik grif akkoord dat er veel ruimte is voor persoonlijke stijl in de keuze én in de aankleding van de ontwikkelomgeving. Het is maar waar men zich goed mee voelt. Zelf vind ik de editor van de Arduino-IDE maar niks, ik ben een aloude vi-gebruiker en gebruik dus ook graag vi om mijn Arduinocode te bewerken. Compileren en uploaden doe ik dan meestal binnen de Arduino-IDE, al kan het ook wel vanaf de command line, wat eigenlijk wel konsekwenter zou zijn.

Jij lijkt het moeilijk te hebben met taal, en vooral met de vormgeving derzelve, dus dan kan het belangrijk zijn om jouw eigen "modus vivendi" te vinden, en dan erg konsekwent toe te passen. Daar is volstrekt niks mis mee.

[Bericht gewijzigd door big_fat_mama op zondag 30 december 2018 12:58:10 (11%)

hoe beter de vraag geschreven, zoveel te meer kans op goed antwoord
big_fat_mama

Zie Paulinha_B

black_dog

c code:

/*
Deze regels beginnen allemaal zonder de twee // en worden tijdens het omzetten van de code genegeert,
net als wat ik hierboven heb aangegeven met de regels die beginen met //
Je kan zo uren doorgaan maar er wordt echt geen bitje in de microcontoler omgezet.
Je zet hier opmerkingen in voor jezelf of anderen die de code gaan lezen.
*/

Doe dan maar eens

c code:

/*
   Deze regels beginnen allemaal zonder de twee // en worden tijdens het omzetten van de code genegeert,
   net als wat ik hierboven heb aangegeven met de regels die beginen met //
   Je kan zo uren doorgaan maar er wordt echt geen bitje in de microcontoler omgezet.
   Je zet hier opmerkingen in voor jezelf of anderen die de code gaan lezen.
*/
hoe beter de vraag geschreven, zoveel te meer kans op goed antwoord
Lambiek

Special Member

Op 30 december 2018 12:25:28 schreef blackdog:
Ik ga hier geen PIC, Arduino of de TI Microcontroler oorlog starten.

Dat is ook zeker mijn bedoeling niet.

Mijn brein voelt zich iets beter thuis in de Arduino omgeving, heeft te maken met hoeveel tijd ik beschikbaar heb voor coderen.

Dat kan, en is ook zeker je goed recht. Maar dan haal je denk veel van internet qua voorbeelden, en die pas je dan aan?

Ieder mag voor zichzelf uitzoeken wat hij prettig vind in de hobby omgeving.

Dat is ook zo, dat spreek ik ook niet tegen. :)

Als je haar maar goed zit, GROETEN LAMBIEK.
bprosman

Golden Member

Maak ik hier allemaal kleine letters van, dan gaat het echt net werken.

"C" is itt Basic of andere talen dan ook "Case sensitive".

Waarom niet gewoon "1" variabelen voor alles toepassen? dat zou te veel ruimte in nemen in de code.
De microcontrolers zijn geen gewone computers waar je even 8GB memory bij prikt...
Dus je zal vooral bij wat langere code zuinig moeten omgaan met de beschikbare ruimte hiervoor.

Dat is het verschil denk ik met een "Old school" programmeur die nadenkt over zijn code en Visual studio cowboys (Senior programmers omdat de 21 geworden zijn :+) die overal "Varchar(256) inpleuren".

De jongere generatie loopt veel te vaak zijn PIC achterna.

@blackdog: ik waardeer je inzet om een cursus Arduino te geven, maar de links die eerder gegeven zijn leggen dat allemaal al haarfijn uit, beginnend bij "di bodem". Ik zou zeggen, bespaar je de moeite :-)

@pieter: die "include files" zorgen ervoor dat er (via een een .h file) library functies beschikbaar komen in jouw programma. Stel je wilt een bepaalde sensor uitlezen, dan heb je functies nodig die dat doen, die je kunt aanroepen. Libraries zijn er enorm veel voor Arduino.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

@Blackdog
Ja, dit voorbeeld kende ik natuurlijk al, staat in zowat alle programma's voor beginners en dit begrijp ik ook wel, alles staat goed uitgelegd. Hiermee wat te spelen door tijden te veranderen lukt natuurlijk ook, de tijd dat het ledje brandt en de tijd dat het ledje uit is, is in te stellen.
Maar nu komt het, er is een vervolg hierop: Blink without delay. Bij velen ongetwijfeld bekend.
Hierin wordt duidelijk uitgelegd wat het nadeel is van "delay" en wat daaraan te doen valt.
De sketch die hierbij hoort is ook duidelijk.
Voor mij is dit dus duidelijk een geval van appels met peren vergelijken want ook hier wordt een variabele ingesteld voor de tijd, in dit geval "interval=1000".
Alleen deze tijd wordt gebruikt voor zowel de tijd dat het ledje brandt en de tijd dat het ledje uit is.
Daar kun je dus niet zomaar verschil in maken, daar is dus een ander programma voor nodig. Slecht voorbeeldje dus.
En dan houdt het bij mij al weer op, ik kom hier niet uit, ik weet, dit heeft nu met programmeren te maken en ik niet weet hoe zoiets aan te pakken. Ook nergens iets kunnen vinden wat een oplossing zou kunnen zijn.
Heb deze vraag ook al eens gesteld op het Nederlandse Arduino forum, nooit antwoord op gehad.
Kennelijk te simpel.
@flipflop
ik had al zo'n idee, maar nogmaals, logisch voor iemand die het weet, voor de beginner blabla als er zoiets niet bij staat, daar kun je dus ook niets van leren.

Is het niet logisch dat je vanaf dag 1 niet alles weet. Kennis moet je opbouwen. Dmv voorbeelden een idee krijgen je "men" zoiets doet, en dan borduur je daar zelf op voort. Je mag zelf natuurlijk wel een beetje nadenken en zelf oplossingen bedenken. Dat is de basis van engineering. Je kunt niet alles copieren.

Over die timer: in de basis Blink staan steeds wait() statements. Wat dat doet is wachten, wachten, wachten, wachten, wachten, wachten, wachten, wachten, wachten totdat de tijd voorbij is. Dat is natuurlijk erg ongunstig omdat je micro soms seconden lang niets anders doet dan wachten. In die tijd ziet ie niet dat je een knop gedrukt hebt, of wil je een motor uit zetten. Daarom gebruik je een timer die op de achtergrond doorloopt (zit in bijna alle micros). Je checked dan regelmatig of jouw seconde al voorbij is, zo ja dan doe je iets. Ondertussen doe je gewoon je andere dingen. Als je je voorbeeldje post dan zien we zo wat je kunt doen om dat ledje anders te laten knipperen.
Maar ehm, je kaapt eigenlijk wel het topic, nieuwe maken misschien?

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
blackdog

Golden Member

Hi peterzoetermeer

De Blink Without Delay sketch zorgt er voor dat het programma niet hoeft te wachten en ondertussen andere taken kan gaan uitvoeren...

Deze sketch maakt gebruik van "Timers" in de Arduino die draaien op de achtergrond.
Even in het kort, deze hebben twee versies, de gene die je in duizendsten van een seconde kan uitlezen en heet Millis.
En wil je het nauwkeuriger dan heb je de "Micros" die dus in miljoenste stapjes gaat.

Dat is geen appels en peren probleem! ja het gaat beide om tijdmeting, maar de manier van opset is anders, Millis en Micros blokkeren de andere code niet.
Het komt hier op neer, je neemt een sample van de tijd die in de Arduino loopt sinds het opstarten en plaatst dit in een variabel.
En dan kijk je met een klein stukje code of er b.b. al 1000 Millis (1 Seconde) is verstreken, is dit niet zo dan kan de Arduino nog wat andere klusjes afhandelen.

Je kan voor de "aan" en de "uit" tijd twee timers gebruiken, zodat je de aan en uit tijd afzonderlijk kan instellen.
En let op, jij kan als programmeur dingen er in zetten die de Arduino niet kan,
zeg een LED moet 3x per seconde knipperen met twee 2x een pause van 0,6 seconde binnen die seconde => obey the law of physics :-)

Dit maakt een variabele aan en maakt hem leeg, dat is de: "0"

c code:


long previousMillis = 0;

Hier wordt de waarde van de timer (millis) die loopt sinds je de arduino hebt aangezet in de variabel gezet die "currentMillis" heet.

c code:


  unsigned long currentMillis = millis();

Dan volgt er een vergelijker, als deze vergelijking waar is => currentMillis - previousMillis > interval, verander dan de LED van uit naar aan of anders om.
De variabele "Interval" is de frequentie waarmee de led knippert, hier omdat Interval 1000 millis groot is, gaat de LED 1 seconde aan en 1 seconde uit.
Dus als currentMillis - previousMillis een waarde heeft de groter is dan 1000 schakel dan de LED om, dat kan dus ook 1023 millis zijn als je b.v. nog andere code hebt lopen in je loop die tijd kost.
Het hangt helemaal van je toepassing en je code af of die "1023" millis een probleem is, voor jouw LED probeersel denk ik niet.

c code:


  if(currentMillis - previousMillis > interval)

Heeft dit stukje code voor deze LED sturing nu veel zin t.o.v. de eerste code die je al geprobeert hebt, nee :-)
Want er loopt geen andere code in de loop die voordeel kan hebben bij het blokkeren van de loop door het "delay" commando.

Jij zal misschien de versie die gebruikt maakt van millis slechter vinden, dit omdat je de aan en uit tijd met deze code niet afzonderlijk kan instellen.
Het gaat er om dat ze je proberen te leren niet te snel de "delay" functie te gebruiken, omdat je hierdoor als je code groter wordt het echt te traag wordt om te kunen worden uitgevoerd.

Nogmaals, voor beide functies, dus "aan" en ook "uit" kan je de timers gebruiken en ja dat kost wat meer code, maar zoals gezegt blokkeren deze functies niet je loop.

Verder helpt het als je wat losser wordt, wat je in je hoofd hebt zitten zoals jij denkt dat het zou moeten worden/zijn is niet zoals het is. live sucks *grin*
Ga gewoon spelen met diverse stukjes code, kijk bij de Nederlandse websites die ondermeer flipflop ook al heeft aangegeven.
Veel doen, veel vallen en opstaan, en ja je zal zeker een keer een Arduino slopen of andere onderdelen, dat hoort bij het leren.
Vlak voor ik dit type was ik ana het meten aan een voeding met een LM723 en mijn meetprobe schoot uit en maakte verbinding tussen pin 13 en pin 12,
de LM723 ling nu in het ronde archief en er zit weer een nieuwe in de en de voeding werkt weer uitstekend.
Als ik dan merk dat het kapot gegaan is, en pak een nieuw IC, zonde van de Breintijd om me daar druk om te maken.

Dat uitschieten met een probe of een draadje verkeert prikken hoort er bij, ook het vergeten van een ; aan het einde van een regel in de code hoort bij de door mij
zeer veel gemaakte "fouten".

Lambiek
Ik weet wat ik wil als ik aan de code begin, maak ook een afweging of ik het snel met wat dioden of zeg CMOS IC kan oplossen (doe het steeds minder)
En kijk dan wat ik al aan code kennis heb, welke sensoren ik denk te gaan gebruiken, en welke library's.

Bij mijn project waar ik nu mee bezich ben, dat is het Display van de Reisreferentie, kwam ik er dus achter dat een paar Library's niet met elkaar samenwerken op de Teensy LC.
Na een uurtje stoeien om dit uit te zoeken ben ik overgestapt op een andere sensor voor de temperatuur/luchtvochtigheid, en toen werkte mijn code wel.
Ik ben in coderen niet goed genoeg om het op een andere manier op te lossen en de tijd moet beperkt blijven anders komt het niet af. :-)
Dat ik door mijn zeg knip/plak werk 2x zo veel code nodig heb, zal mij worst wezen als het verder goed werkt, grotere Teensy nodig omdat de code niet past,
dan is een duurder model met meer ruimte voor mij veel goedkoper ,dan veel tijd aan de code te besteden om hem compacter te maken.
De meeste dingen die ik doe zijn enkel stuks meet apparaatjes, dat is iets anders dan zakelijke toepassingen of dat je het leuk vind je code tot het summum te optimaleseren
zoals ik dat b.v. doe op analoog gebied :-)

Groet,
Bram

You have your way. I have my way. As for the right way, the correct way, and the only way, it does not exist.
bprosman

Golden Member

Zoals Bram/Blackdog het al uitgelegd heeft maar nog even een vergelijking. Als je iets lijmt en dat moet drogen, dan moet je wachten, dat kun je op 2 manieren doen : Er naast gaan zitten wachten, duimen draaien (Delay), of je zet de kookwekker, gaat in die tijd de vaatwasser of iets anders doen en kom pas terug als die kookwekker afgaat (de timer). Dan kun je die "wachttijd" toch nog nuttig besteden.

De jongere generatie loopt veel te vaak zijn PIC achterna.

bedankt voor het uitleggen, maar zover was ik inmiddels (met veel moeite) ook al ongeveer.
In de sketch wordt dit ook redelijk uitgelegd.
Ik heb alleen moeite met het feit dat er net gedaan wordt of dit de oplossing is voor een probleem wat er mogelijk ontstaat, maar tegelijkertijd het programma verandert.
Het eerste programma (Blink), laat een ledje voor een bepaalde tijd (A) branden, zet 'm uit, wacht een bepaalde tijd (B)en begint weer overnieuw.
Het tweede programma (Blink without delay) berekent een tijdstip waarop de arduino iets moet gaan doen, en dat is heel simpel, als de led brandt, zet-ie 'm uit, als de led uit is, zet-ie 'm aan.
Komt bij mij toch over als: je hebt patat (blijkbaar met mayonaise) en je hebt patat zonder mayonaise en als je dat wilt, krijg je wat anders (in ieder geval geen patat) en daarom vindt ik het een slecht voorbeeld. Natuurlijk heb ik hier wel van geleerd.
Ik begrijp ook wel dat het programma gewijzigd moet worden als ik de 2 variabelen A en B weer terug wil zien.
En dat heeft te maken met programmeren, iets wat ik niet kan en ook nooit geleerd heb.
Vaak oefenen helpt dan niet, overschrijven of kopiëren ook niet.
Daarom kom ik niet verder en @flipflop, ik denk dat de TS tegen hetzelfde probleem aan loopt.

blackdog

Golden Member

Hi peterzoetermeer,

Het blijven herhalen van het zelfde gaat het probleem dat je hebt niet oplossen...

Zelf zelf initiatief nemen gaat je echt helpen samen met mijn opmerking die ik hiervoor al heb gezegt,
je hebt een verandering van state of mind nodig om verder te komen.

Waarom vraag je hier niet om te laten zien hoe je het met twee timers zou kunen oplossen?
Dan laat je zien dat je met de oplossing bezig bent en niet met het probleem.

Groet,
Bram

You have your way. I have my way. As for the right way, the correct way, and the only way, it does not exist.

Het voorbeeld is een prima voorbeeld (denk ik, ik heb de sketch nog niet gezien). Het legt je uit, en laat je zien hoe je het probleem dat je hebt kunt oplossen. Dat het ledje net iets anders knippert doet niet ter zake, daar gaat het voorbeeld niet over. Het gaat erover dat je die delay() vervangt door iets wat je programma niet blokkeert. Het is aan de programmeur om dat in zijn programma toe te passen, te maken hoe je het hebben wilt. Je moet een beetje doordenken. Als je het mechanisme snapt kun je er zelf op verder borduren.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
Lambiek

Special Member

Op 30 december 2018 16:10:19 schreef peterzoetermeer:
Het eerste programma (Blink), laat een ledje voor een bepaalde tijd (A) branden, zet 'm uit, wacht een bepaalde tijd (B)en begint weer overnieuw.

Als je dat met die timers "nog niet" begrijpt, blijf je toch gewoon je wacht/delay gebruiken. Dat met die timers komt vanzelf als je wat verder bent, en als je het nog niet nodig hebt hoef je het ook nog niet te gebruiken.

Vaak oefenen helpt dan niet, overschrijven of kopiëren ook niet.

Van vaak oefenen wordt je niet dommer, overschrijven of kopiëren leer je inderdaad niet veel van, of je moet dan uit gaan pluzen hoe het zou kunnen werken.

Daarom kom ik niet verder en ik denk dat de TS tegen hetzelfde probleem aan loopt.

Gewoon door blijven gaan en veel oefenen. :) Je kon toch ook niet lopen toen je net geboren was.

Als je haar maar goed zit, GROETEN LAMBIEK.

Op 30 december 2018 13:47:35 schreef peterzoetermeer:
@Blackdog
........
Voor mij is dit dus duidelijk een geval van appels met peren vergelijken want ook hier wordt een variabele ingesteld voor de tijd, in dit geval "interval=1000".
Alleen deze tijd wordt gebruikt voor zowel de tijd dat het ledje brandt en de tijd dat het ledje uit is.
Daar kun je dus niet zomaar verschil in maken, daar is dus een ander programma voor nodig. Slecht voorbeeldje dus.
En dan houdt het bij mij al weer op, ......

Onafhankelijke aan/uit tijd van een led staat hier toegelicht: https://www.baldengineer.com/millis-ind-on-off-times.html

Take care to get what you like or you will be forced to like what you get

Dank je,
ik denk dat ik dit zoek.
En nu nog proberen te begrijpen wat er gebeurd, dit is wel een goed voorbeeld voor het aanpakken van een dergelijk probleem.

Vrij duidelijk toch? Als de huidige tijd - vorige tijd groter is dan een -bepaald getal, dan schakel je de led om. Dat bepaalde getal is anders als de led aan is of uit. Kind kan de was doen :-)

Nah, beetje flauw misschien. Gewoon even rustig naar kijken. Niet te ingewikkeld over doen, het staat er bijna letterlijk zoals ik het hierboven in schrijftaal heb staan.

[Bericht gewijzigd door flipflop op maandag 31 december 2018 10:40:20 (31%)

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
Lambiek

Special Member

Voor ons is dat misschien logisch, maar als je het aan het leren bent niet natuurlijk. :)

Als je haar maar goed zit, GROETEN LAMBIEK.
GJ_

Moderator

Op 31 december 2018 10:32:12 schreef peterzoetermeer: ik denk dat ik dit zoek.

Nou zie ik ook wel dat dit zonder kwade opzet zo gegroeid is, maar als je nog eens wat zoekt graag in een eigen topic en niet in dat van een ander ;-)

De rest van het topic is weer voor Hans1971

Ik hoop dat ik het weer een beetje ontrack kan krijgen.
Alsik Hans goed begreep waren we beiden een beetje aan het snuffelen aan Arduino, nadat we wat ervaring hadden opgedaan met de PIC (al dan niet met PICbasic).

Vandaag daarom even wat code geschreven en wat me meteen opvalt en wat daarbij meteen ook een ergernis is, is dat wanneer ik code overschrijf (uit een gepauzeerd Youtube fimpje :-) ), ik plots moet letten op hoofdletters in bepaalde codewoorden. Keyboard kun je niet als keyboard schrijven. Wantdatsliktieniet. OK... Daar wil ik dan wel rekening mee houden.
Maar als ik dan het woord digitalread keurig met een hoofdletter schrijf, wat hij óók niet slikt, maar zonder ook niet, waarna ik er achter moet komen dat "Read" met een hoofdletter is, zakt bij mij de broek af.

Kijk... If you can't beat them, join them...
Het is gewoon zo dat ik nogal eens vast liep met de PIC, wanneer ik die wilde integreren met andere applicaties. Ongetwijfeld kan de PIC dat, maar het gaat even boven mijn pet en dat wordt alleen maar erger naarmate ik meer zou willen.
Als ik dan met een scheef oog zie wat de Arduino kan, kan ik me een tijdje groot houden, maar uiteindelijk moet ik mijn hoofd laten hangen en heb ik de keuze gemaakt om over te stappen.

Van snuffelen komt proeven.
Met de achtergrond in PICbasic, begrijp ik veel, maar ontgaat me de logica van veel andere zaken. Ik moet nog even de balans vinden. :-)

Nog meer ontrack...
Van al die cursussen waar ik ook in gebladerd heb, haal ik veel goed bedoeld lesmateriaal. Toch schrijft men vaak vanuit een zekere vanzelfsprekendheid alsof men er onbewust van uit gaat dat dat wel logisch is. Dan moet je zaken 3x lezen. Proberen welke achterliggende reden van een handeling er is en of dat klopt...
Dat leest/leert niet lekker.

Ik ben nog steeds op zoek naar een Goede Aruino cursus van het kaliber PICbasic van Frits Kieftelbelt.

Ik moet hier weer vaker komen... Wat kun je zo'n forum als deze gaan missen. :-)

Op 31 december 2018 11:19:48 schreef GJ_:
[...]Nou zie ik ook wel dat dit zonder kwade opzet zo gegroeid is, maar als je nog eens wat zoekt graag in een eigen topic en niet in dat van een ander ;-)

De rest van het topic is weer voor Hans1971

Haha ! Ik ben hier eventjes afwezig geweest, wat een topic is dit geworden zeg !
De Electronica heeft even stilgelegen vanwege andere projecten met motoren.
Maar hou jullie vooral niet in...?

Read() is iets anders dan read(). Dat komt omdat Arduino-taal "C" is. En C is case-sensitive. Een C compiler voor PIC is precies zo.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

Op 6 januari 2019 21:59:27 schreef flipflop:
Read() is iets anders dan read(). Dat komt omdat Arduino-taal "C" is. En C is case-sensitive. Een C compiler voor PIC is precies zo.

Dat is dan iig verklaarbaar. :-)

Ik moet hier weer vaker komen... Wat kun je zo'n forum als deze gaan missen. :-)

Als je dit onder de knie wilt krijgen kan ik je aanraden een projectje voor jezelf te verzinnen. Een soort opdracht als het ware. Als je wilt kan ik wel even in mijn oude school opdrachten duiken. Wellicht zit daar wat leuks tussen.

PE2BAS