Arduino, iets waar veel over gepraat wordt maar waar duidelijk ook veel mee "gespeeld" wordt.
Voor zij die er nog aan twijfelen, de instap is zeer simpel, en als voorbeeld geef ik het volgende programma'tje dat maar 2 commando's gebruikt :
Ik ben er steevast van overtuigd dat de "kenners" direct een oplossing zullen vinden om een ander programma te schrijven dat net hetzelfde doet.
Je koopt een Arduino en je installeert de gratis Arduino-software op je PC. Je doet dan de moeite om de "beginselen" van het Arduino-gebeuren te lezen zodat je beseft dat er wel enkele regeltjes zijn zoals bijvoorbeeld het gebruik van verschillende tekens.
Je opent de file die ik als voorbeeld geef en je kan die uploaden naar je Arduino.
Wat zegt die file:
In een eerste lijst wordt bepaald wat je met de "poorten" wil doen en je geeft hier eenvoudig aan dat je elke pin wil beschouwen als digitale uitgang. Aan of uit dus. Meer niet...
void setup() { // initialize digital pins as an output.
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
}
// the loop function runs over and over again forever
En nu begint het spelleke: Je geeft aan wat je verwacht van die "outputs".
Eerste lijn zegt: Zet uitgang 1 hoog (aan)
Tweede lijn zegt: wacht 10000 millisekonden (10 seconden)
Enz...
En als ie op 't einde komt, herbegint die gewoon weer.
Voor alle duidelijkheid; als je het programma er in pomp hangt de Arduino aan je PC (+5V). Als je hem op je baan gebruikt geef je hem een aparte voeding van 7-12V. Van zodra er spanning opkomt begint de cyclus
void loop() {
digitalWrite(1, HIGH);
delay(10000);
digitalWrite(2, HIGH);
delay(10000);
digitalWrite(8, HIGH);
delay(5000);
digitalWrite(4, HIGH);
delay(10000);
digitalWrite(7, HIGH);
delay(10000);
digitalWrite(10, HIGH);
delay(8000);
digitalWrite(3, HIGH);
delay(12000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(9, HIGH);
delay(15000);
digitalWrite(8, LOW);
delay(18000);
digitalWrite(5, HIGH);
delay(10000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(11, HIGH);
delay(18000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(4, HIGH);
delay(15000);
digitalWrite(10, HIGH);
delay(12000);
digitalWrite(3, LOW);
delay(15500);
digitalWrite(9, LOW);
delay(18000);
digitalWrite(5, LOW);
delay(10000);
digitalWrite(11, LOW);
delay(12000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(2, HIGH);
delay(12000);
digitalWrite(5, HIGH);
delay(15000);
digitalWrite(11, HIGH);
delay(5000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(8, HIGH);
delay(18000);
digitalWrite(1, LOW);
delay(15000);
digitalWrite(5, LOW);
delay(5000);
digitalWrite(11, LOW);
delay(16000);
digitalWrite(8, LOW);
delay(20000);
digitalWrite(7, LOW);
delay(12000);
digitalWrite(6, HIGH);
delay(12000);
digitalWrite(12, HIGH);
delay(18000);
digitalWrite(6, LOW);
delay(5000);
digitalWrite(12, LOW);
delay(20000);
}
Ik heb me dus in Excel een grafiekje gemaakt om de sequences in beeld te brengen.
(https://live.staticflickr.com/65535/51000834917_1b624b1118_c.jpg) (https://flic.kr/p/2kGLBnX)sequences (https://flic.kr/p/2kGLBnX) by Dirky dyniMo (https://www.flickr.com/photos/144623334@N05/), on Flickr
Het leuke is dat je meteen een werkende toepassing hebt voor het ding dat onbekend was. Nu kan je jezelf verder verdiepen en zaken aanpassen, uitbreiden,...
Ik post straks nog een foto van het printje dat ik me samengebokst heb om de LED's aan te sluiten.
Prachtig werk, Dirk. Vooral kan het helpen om de instapdrempel te verlagen voor lieden die twijfelen. Proficiat!
Top Dirk! Dit is ook het soort zaken waar wij als club naar op zoek zijn, voor onze artikels rond Arduino. Je kan heel veel vinden op het net, maar het verstaanbaar maken voor iederen? Dat is helaas andere koek. Wat jij hier juist post is heel duidelijk en goed verstaanbaar.
Citaat van: Dirky op 04 maart 2021, 11:55:03 AM
Arduino, iets waar veel over gepraat wordt maar waar duidelijk ook veel mee "gespeeld" wordt.
Voor zij die er nog aan twijfelen, de instap is zeer simpel, en als voorbeeld geef ik het volgende programma'tje dat maar 2 commando's gebruikt :
Ik ben er steevast van overtuigd dat de "kenners" direct een oplossing zullen vinden om een ander programma te schrijven dat net hetzelfde doet.
Je koopt een Arduino en je installeert de gratis Arduino-software op je PC. Je doet dan de moeite om de "beginselen" van het Arduino-gebeuren te lezen zodat je beseft dat er wel enkele regeltjes zijn zoals bijvoorbeeld het gebruik van verschillende tekens.
Je opent de file die ik als voorbeeld geef en je kan die uploaden naar je Arduino.
Ok, ik heb hier nu al bijna 1 jaar een koppel Arduino's liggen. En heb er nog niks mee gedaan. Maar als je mensen er toe wil aanzetten om het te proberen, kan je dan aub nog de volgende dingen aangeven:
- welk bordje gebruik je? Er zijn er zoveel ...
- die file, ik veronderstel dat daar dan het volgende instaat. Ik ken van arduino zelf echt niks maar ik heb gewoon je stukjes bij elkaar geplakt en een stukje van je uitleg er als commentaar in gelaten Dus ik hoop dat het klopt.:
void setup() { // initialize digital pins as an output.
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
}
// the loop function runs over and over again forever
// En nu begint het spelleke: Je geeft aan wat je verwacht van die "outputs".
// Eerste lijn zegt: Zet uitgang 1 hoog (aan)
// Tweede lijn zegt: wacht 10000 millisekonden (10 seconden)
// Enz...
void loop() {
digitalWrite(1, HIGH);
delay(10000);
digitalWrite(2, HIGH);
delay(10000);
digitalWrite(8, HIGH);
delay(5000);
digitalWrite(4, HIGH);
delay(10000);
digitalWrite(7, HIGH);
delay(10000);
digitalWrite(10, HIGH);
delay(8000);
digitalWrite(3, HIGH);
delay(12000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(9, HIGH);
delay(15000);
digitalWrite(8, LOW);
delay(18000);
digitalWrite(5, HIGH);
delay(10000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(11, HIGH);
delay(18000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(4, HIGH);
delay(15000);
digitalWrite(10, HIGH);
delay(12000);
digitalWrite(3, LOW);
delay(15500);
digitalWrite(9, LOW);
delay(18000);
digitalWrite(5, LOW);
delay(10000);
digitalWrite(11, LOW);
delay(12000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(2, HIGH);
delay(12000);
digitalWrite(5, HIGH);
delay(15000);
digitalWrite(11, HIGH);
delay(5000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(8, HIGH);
delay(18000);
digitalWrite(1, LOW);
delay(15000);
digitalWrite(5, LOW);
delay(5000);
digitalWrite(11, LOW);
delay(16000);
digitalWrite(8, LOW);
delay(20000);
digitalWrite(7, LOW);
delay(12000);
digitalWrite(6, HIGH);
delay(12000);
digitalWrite(12, HIGH);
delay(18000);
digitalWrite(6, LOW);
delay(5000);
digitalWrite(12, LOW);
delay(20000);
// En als ie op 't einde komt, herbegint die gewoon weer.
}
Dus moest je dat in de online omgeving plakken en in je arduino bordje downloaden, zonder iets in die omgeving in te stellen dan werkt het?
Citeer
Ik post straks nog een foto van het printje dat ik me samengebokst heb om de LED's aan te sluiten.
Dat gaat ook helpen.
PS: begrijp me niet verkeerd hé. Ik vind het goed dat zoiets eens op het forum komt. Zelf heb ik leren "programmeren" 35 jaar geleden en het daarna nooit gedaan. Dus ik snap je programma wel. Maar eerlijk gezegd, ik zou dit niet in een arduino krijgen. Zou eerst eens zo'n step-by-step willen kunnen doorlopen.
Citaat van: Havoc op 04 maart 2021, 13:20:09 PM
Ok, ik heb hier nu al bijna 1 jaar een koppel Arduino's liggen. En heb er nog niks mee gedaan. Maar als je mensen er toe wil aanzetten om het te proberen, kan je dan aub nog de volgende dingen aangeven:
- welk bordje gebruik je? Er zijn er zoveel ...
Nano, Uno... maakt voor dit eigenlijk niet zoveel uit.
2 tips :
1. gebruik eens een "for" lus voor opeenvolgende dingen zoals de pinMode commando's
2. maak een subroutine "aan" en "uit" en stur die dan met parameters aan (1 voor de pin nr en 1 voor de brandduur)
Inderdaad correct Johan, zo zou het moeten werken!
Het printje dat bijna de naam print niet waardig is:
(https://live.staticflickr.com/65535/51002343618_92dddb2b18_c.jpg) (https://flic.kr/p/2kGUkS3)IMG_20210304_140932_resized_20210304_020953931 (002) (https://flic.kr/p/2kGUkS3) by Dirky dyniMo (https://www.flickr.com/photos/144623334@N05/), on Flickr
(https://live.staticflickr.com/65535/51003162632_77c3cec917_c.jpg) (https://flic.kr/p/2kGYxjY)IMG_20210304_141024_resized_20210304_021044341 (002) (https://flic.kr/p/2kGYxjY) by Dirky dyniMo (https://www.flickr.com/photos/144623334@N05/), on Flickr
Ik gebruik 3K9 weerstanden omdat naar mijn mening, de meeste huisjes die verlicht worden op modelbanen, de indruk geven dat de eigenaar met een supertrooper aan 't verlichten is.
De bovenste rij van de header waar ik de LED's in plug is de gemeenschappelijke GND.
Is hier dus idd een UNO.
En Dani:
Toen ik zowat een jaar geleden mijn eerste Arduino kocht - je hebt me toe ook de nodige tips gegeven - ben ik als een zot in de boeken gedoken en kon ik, voor mezelf althans, al serieuze dingen programmeren. Nu, na een jaar stilte ben ik meer dan de helft vergeten en zakt de moed in mijn schoenen als ik een fout moet zoeken.
En da's nu het leuke aan dit heeeeel simpel programma'tje. 2 commando's, meer niet, en 't werkt. Iedereen verstaat het en in ons wereldje kan je het voor heel veel zaken gebruiken. Verlichting in huisjes, verkeerslichten, spoorwegovergangen,...
Ik zou heel graag jouw kennis hebben ivm programmeren maar vrees dat het voor een ander leven zal zijn.
Desalniettemin probeer ik in 't korte wel weer eens met een "for" lus...
for (int x=1;x<13;x++) {pinMode(x,OUTPUT);}
De skech van Johan werkte de eerste keer, Top, Dirk! Werkt goed 8)
Citaat van: dani op 04 maart 2021, 14:05:14 PM
2 tips :
1. gebruik eens een "for" lus voor opeenvolgende dingen zoals de pinMode commando's
2. maak een subroutine "aan" en "uit" en stur die dan met parameters aan (1 voor de pin nr en 1 voor de brandduur)
Ook een optie, maar dan moet je je al zekerder voelen. Ik vind het hele simpele programma van Dirky perfect om iemand die nog nooit zo'n ding vastgepakt heeft de moed te geven te beginnen. Eenmaal dat kan je verder gaan.
Als je met zo'n aparte routines begint ga je ook de data anders moeten schikken (welke output en welke brandduur). Moest ik nu met dat basis programma van Dirky voortgaan, het eerste dat ik zou proberen is om de tijden een random stuk te geven. Dus ipv een vaste "delay(xxxx)" iets zoals "delay (xxxxx +/- iets random)". Wat variatie in het patroon zonder dat je dat moet programmeren als een ander patroon.
Als je met aan/uit routines werkt, dan kan je naar random lichtjes gaan. En zo verder...
Citaat van: Dirky op 04 maart 2021, 14:23:15 PM
Ik gebruik 3K9 weerstanden omdat naar mijn mening, de meeste huisjes die verlicht worden op modelbanen, de indruk geven dat de eigenaar met een supertrooper aan 't verlichten is.
De bovenste rij van de header waar ik de LED's in plug is de gemeenschappelijke GND.
Zelf gebruik ik 3k3 voor witte leds op 5V, inderdaad meer dan genoeg. Ik zal eens een Uno of Nano moeten bestellen. Wat ik hier heb zijn Himalaya (Mini Leonardo). Ergens vanachter in een schuif liggen nog ATMega128A1U's. Of eens voortdoen met mijn IO borden voor de pc... :-[
Er is iets vreemd met de random functie van Arduino. Blijkbaar kiest hij een random-lijst bij de eerste opstart en bij elke nieuwe start loopt hij diezelfde lijst af. Dus niet echt super random...
Een andere reden dat ik het op die simpele manier gedaan heb is om er ergens wat logica achter te steken; als het donker wordt gaat er in de meeste huizen beneden wel een licht aan. Dan volgt een wisseling beneden/boven. In het station gaat het licht eerst aan in de wachtzaal... en fantaseer maar verder... :-)
en b.t.w., ik schrijf het programma via excel. Daar kan je gemakkelijk een input veld maken en via "tekst samenvoegen" het geheel juist schrijven...
Citaat van: Havoc op 04 maart 2021, 16:47:49 PM
Moest ik nu met dat basis programma van Dirky voortgaan, het eerste dat ik zou proberen is om de tijden een random stuk te geven. Dus ipv een vaste "delay(xxxx)" iets zoals "delay (xxxxx +/- iets random)". Wat variatie in het patroon zonder dat je dat moet programmeren als een ander patroon.
Als je met aan/uit routines werkt, dan kan je naar random lichtjes gaan. En zo verder...
Random zou ik ook gebruiken, maar gecombineerd met een patroon:
- als het begint te duisteren gaat hier en daar een lampje aan, meestal in de woonkamer/keuken
- af en toe gaan er ook lichtjes aan in andere ruimtes, de hal, de berging, toilet of een of meerdere kamer 'boven'
- vaak blijven die minder constant aan dan in de woonkamer.
- in veel huizen zal het redelijk donker worden terwijl men tv kijkt. Je ziet dan gekleurd geflikker...
- als de nacht valt gaan de lichten in slaapkamer(s) en badkamers even aan terwijl beneden alles donker wordt
- en dan gaat zo goed als iedereen slapen en wordt het donker.
- en dan komt de zon weer op... en is er weer een ander patroon.
Je ziet, er kan heel veel met het aansturen van lichten gedaan worden. :)
Dat is niet zo vreemd.
Rond 1980 was vooral BASIC populair. De functie RANDOM() bestond ook. Om te vermijden dat na elke opstart telkens eenzelfde volgorde werd afgewerkt bestond ook RANDOMIZE(), waarbij de lijst van de RANDOM() getallen willekeurig herschikt werd...
Zo bekwam men een echte willekeurige volgorde.
Misschien zit er voor de ARDUINO ook ergens zoiets in.
Mvg, Erik
@Dirk: een Arduino bevat (van huis uit, toch) geen klok, waar kan hij dan al van uitgaan om een toeval te genereren? [toevoeging: maar de opmerking van Erik @eve hierboven klinkt wel erg zinnig - te bekijken!)
@Luc Dooms: in die richting gingen mijn gedachten ook, maar ze waren nog niet zozeer gecondenseerd :)
Random: https://www.arduino.cc/reference/en/language/functions/random-numbers/random/ het kan. ;)
Citaat van: doomslu op 04 maart 2021, 18:20:28 PM
Random: https://www.arduino.cc/reference/en/language/functions/random-numbers/random/ het kan. ;)
Ik herinner me van Turbo-C ook zoiets als "seed()". Maar ik ben het eerste boek kwijt om het na te kijken :) (ok, zegt iets over mijn leeftijd)
Ok, GIYF: http://www.softwareandfinance.com/Turbo_C/random_numbers.html (http://www.softwareandfinance.com/Turbo_C/random_numbers.html)
Ik heb het ooit gebruikt in C++ als generator voor het willekeurig starten van een trein uit het schaduwstation als de vaste dienstregeling begon te vervelen...
Mvg, Erik
geen arduino maar een pic
ok je hebt wat meer hardware nodig om het in de processor te krijgen maar programmeren is in basic
ik doe per huisje een processor omdat een pic bijna niets kost
de 16f628 kost 1 euro en dan nog de 7805 en een paar condensatoren er bij en klaar
alle ledjes hangen met de positief aan elkaar aan de 5 volt per huisje
dan van de processor komt een 3,9 weerstand naar de min van de led
oorzaak voor dit is dat er een verschil is in positief en negatief schakelen wat de dysispatie in de processor aan gaat .
ik gebruik 1 poot om de dag nacht aan of uit te zetten van alle processoren op heel de baan .de rest zijn allemaal uitgangen
de 16f628 heeft er 16 dus 15 uitgangen beschikbaar poort A5 kan alleen maar ingang zijn dat is vast gelegd in de processor structuur
dus elk huisje doet zijn eigen routine na dat pen A5 aan de massa ligt .
als het terug morgen word dan ligt pen A5 terug aan de positief en doet de processor nog zijn laatste serie commando's of geprogrammeerde commando's afwerken .
de rnd functie heeft het zelfde probleem als de arduino dat de rnd bij het opstarten een vaste reeks cijfers bepaald en deze in die volg orde afspeelt
je kunt het om zeilen maar het is niet gemakkelijk .
gr raf
random initialisatie : een losgekoppelde analoge ingang inlezen als seed variabele.
GOOGLE IT
Het begin was nog te volgen, maar nu wordt het stilaan chinees.
eigen aan een forum... je plaatst iets wat eenvoudig is voor een beginner en een paar dagen later is het compleet ontspoort. Ik verlies alle zin om iets te plaatsen, het loopt tegenwoordig altijd spaak!
Als de Admins het verstaanbaar gedeelte kunnen afkoppelen, voor mij niet gelaten!
Ofwel verander ik de titel in "verlichting huisjes aansturen met Arduino, hoe maak ik het wat minder verstaanbaar voor de beginner?"
It's just random talk ;D
@Dirky: de frustratie in uw reactie kan ik me goed voorstellen maar ik vind ze toch niet helemaal terecht. Van meerdere kanten is er waardering en applaus gekomen voor uw inbreng! Terecht, trouwens, uw voorstel is simpel te begrijpen en duidelijk gedocumenteerd.
Dat er dan lieden zijn die op de kar springen van een degelijk (ofschoon misschien beperkt) basisontwerp en er allerlei toeters en bellen willen bijplakken, zonder zich af te vragen voor wie dat nu allemaal nuttig zou kunnen zijn, dat is een beetje spijtig maar inderdaad niet te vermijden. Laat het aan u voorbijwaaien!
Ik heb zelf gesuggereerd om de leds te dimmen voor meer sfeereffecten, maar daarmee werd echt niet meer bedoeld dan het aanstippen van een mogelijkheid. Neem het vooral niet op als kritiek, althans niet als negatieve kritiek. Wie dat niet kan of wil begrijpen, die mag er gerust overheen kijken, mij stoort dat niet. Maar ik denk dat het een nuttige suggestie kan zijn voor diegenen die de eerste stap gezet hebben; en wilde het dus toch maar even vermelden. In de marge, uiteraard.
Citaat van: Dirky op 05 maart 2021, 17:44:38 PM
je plaatst iets wat eenvoudig is voor een beginner
Waarvoor nogmaals hartelijk dank, U hebt pm, met permissie Dirk ;)
Citaat van: Dirky op 05 maart 2021, 17:44:38 PMeigen aan een forum... je plaatst iets wat eenvoudig is voor een beginner en een paar dagen later is het compleet ontspoort.
Ik vind dat in dit draadje nog best meevallen.
- Je lanceert een idee, en er komen wat technische en inhoudelijke reacties en suggesties op
- Arduino gaat over het gebruik van microcontrollers, en dat is op zich al iets meer technisch / complex
- Je vraagt je af hoe "random" meer willekeurig kan, en ook daar komen wat (uiteraard meer technische) ideeën op
- Nu gaat het over "het wordt hier te ingewikkeld" - en tja ... uiteraard weer reacties
Als je (zoals ik) alle draadjes op het forum opvolgt, dan merk je dat het hier nog héél kalm is ;)
Ik moet toegeven, ik was gisteren in "a bad mood"... sorry daarvoor!
Voor zulke dingen zouden we beter iets opzetten zoals de "stl-file" rubrieken van Piet. Ergens de file met uitleg zetten, draadje op slot, en een bijkomend draadje voor discussies. Want, geef toe, had mijn reactie van gisteren er niet geweest, dan zou binnen een paar weken het draadje volledig onbruikbaar geworden zijn.
Gerolf,
op zich is dat technische het probleem niet, als er naar de voor de leek 'moeilijkere' zaken naar toe wordt gewerkt.
Het begint bij een vrij simpel ontwerp, perfect te begrijpen voor een leek of beginner en dan springt men naar een aantal technische uitbreidingen, alsof dit voor iedereen meteen duidelijk is. Men vergeet hierbij maar al te dikwijls dat niet iedereen 'alles' kent en gaat op die manier gemakshalve voorbij aan de voorkennis die de aanbrenger heeft, maar die bij de leek of de vraagsteller ontbreekt.
Goed bedoeld allemaal, maar sommige mensen hebben het nodig om met (kleine(re)) stappen te werken, gewoon omdat ze noch de kennis, noch de ervaring bezitten.
Het onderwerp verderzetten in wat ik dan 'het chinees' noem, is op dat moment de beste weg voor de leek om te zeggen laat maar zitten, hoeft voor mij niet meer.
Uiteraard zullen al die tips en oplossingen een meerwaarde betekenen voor het project, maar soms willen de ervaren leden te snel gaan naar een compleet ontwerp, terwijl de minder ervaren bouwers graag (veel) meer tussenstappen en uitleg krijgen, net omdat ze niet vertrouwd zijn met de materie.
Of hoe men van een eenvoudige start een onbegrijpbaar item maakt. Men start ment ontwerp A op bord B, waarop iemand al meteen stap M en N voorstelt op bord A en een derde zegt dat hij liever werkt met bord C en meteen hiervan de stappen P tot Q gaat verduidelijken.
Op deze manier mist de beginner het halve alfabet.
Mij lijkt het logischer om uit te gaan van het oorspronkelijk gegeven voorbeeld, wat inderdaad zeer simpel en laagdrempelig is en daar een volgende stap aan te breien, die dan ook voldoende wordt uitgelegd en gedocumenteerd. En dus niet in de zin van 'google is je vriend'
Maar dan zijn we al een beperkte cursus aan het schrijven zeker? Misschien voer voor een artikel?
In ieder geval hoop ik dat niemand zich aangevallen voelt door deze post, men doet immers om goed te doen, al wat ik vraag is beeld je ff in dat je zelf 0 kennis hebt van het onderwerp en ga daar van uit als je iemand wil helpen. Zo hebben we er meer aan en haakt men niet zo snel af.
Ik volg Gerolf toch wel wat. Het begint met iets simpel, er komen enkele ideeën later. Iemand die met dat eerste begint krijgt ideeën om te verbeteren. Toch ook wel zo'n beetje als wanneer je leer programmeren. Je begint met iets star sequentieel, leert procedures/functies, maakt het gemakkelijker uitbreidbaar, voegt iets van "random" toe (hier wel belangrijker dan bij betalingen verwerken ::) ) en verbetert dat opnieuw. Voor je het weet voel je je wat vertrouwd en ben je vertrokken.
Geen slecht idee dat "stl equivalent". Er zou een mogelijkheid moeten zijn om een soort draden te hebben waar iemand iets start en hij de enige is die kan toevoegen. Commentaar zou dan bvb in een apart veld kunnen komen dat je kan open/dicht klappen voor de leesbaarheid maar de commentaar blijft tenminste bij de draad. Zou voor bouwverslagen ook handig zijn. (ok, ik ben nu ook aan het afwijken en vervuilen)
Citaat van: gardevil op 06 maart 2021, 09:41:27 AM
Gerolf,
op zich is dat technische het probleem niet, als er naar de voor de leek 'moeilijkere' zaken naar toe wordt gewerkt.
Het begint bij een vrij simpel ontwerp, perfect te begrijpen voor een leek of beginner en dan springt men naar een aantal technische uitbreidingen, alsof dit voor iedereen meteen duidelijk is. Men vergeet hierbij maar al te dikwijls dat niet iedereen 'alles' kent en gaat op die manier gemakshalve voorbij aan de voorkennis die de aanbrenger heeft, maar die bij de leek of de vraagsteller ontbreekt.
Goed bedoeld allemaal, maar sommige mensen hebben het nodig om met (kleine(re)) stappen te werken, gewoon omdat ze noch de kennis, noch de ervaring bezitten.
(knip)
Mij lijkt het logischer om uit te gaan van het oorspronkelijk gegeven voorbeeld, wat inderdaad zeer simpel en laagdrempelig is en daar een volgende stap aan te breien, die dan ook voldoende wordt uitgelegd en gedocumenteerd. En dus niet in de zin van 'google is je vriend'
Maar dan zijn we al een beperkte cursus aan het schrijven zeker? Misschien voer voor een artikel?
In ieder geval hoop ik dat niemand zich aangevallen voelt door deze post, men doet immers om goed te doen, al wat ik vraag is beeld je ff in dat je zelf 0 kennis hebt van het onderwerp en ga daar van uit als je iemand wil helpen. Zo hebben we er meer aan en haakt men niet zo snel af.
Kruisende berichten: Misschien is het inderdaad geen slecht idee om zoiets op te zetten als het .STL sub-forum. En daar zo'n soort "cursus" op te zetten. Beginnend met dit voorbeeld en dan enkele van die ideeën uitwerken.
Citaat van: gardevil op 06 maart 2021, 09:41:27 AM
Gerolf,
op zich is dat technische het probleem niet, als er naar de voor de leek 'moeilijkere' zaken naar toe wordt gewerkt.
Het begint bij een vrij simpel ontwerp, perfect te begrijpen voor een leek of beginner en dan springt men naar een aantal technische uitbreidingen, alsof dit voor iedereen meteen duidelijk is. Men vergeet hierbij maar al te dikwijls dat niet iedereen 'alles' kent en gaat op die manier gemakshalve voorbij aan de voorkennis die de aanbrenger heeft, maar die bij de leek of de vraagsteller ontbreekt.
Goed bedoeld allemaal, maar sommige mensen hebben het nodig om met (kleine(re)) stappen te werken, gewoon omdat ze noch de kennis, noch de ervaring bezitten.
Het onderwerp verderzetten in wat ik dan 'het chinees' noem, is op dat moment de beste weg voor de leek om te zeggen laat maar zitten, hoeft voor mij niet meer.
Uiteraard zullen al die tips en oplossingen een meerwaarde betekenen voor het project, maar soms willen de ervaren leden te snel gaan naar een compleet ontwerp, terwijl de minder ervaren bouwers graag (veel) meer tussenstappen en uitleg krijgen, net omdat ze niet vertrouwd zijn met de materie.
Of hoe men van een eenvoudige start een onbegrijpbaar item maakt. Men start ment ontwerp A op bord B, waarop iemand al meteen stap M en N voorstelt op bord A en een derde zegt dat hij liever werkt met bord C en meteen hiervan de stappen P tot Q gaat verduidelijken.
Op deze manier mist de beginner het halve alfabet.
Mij lijkt het logischer om uit te gaan van het oorspronkelijk gegeven voorbeeld, wat inderdaad zeer simpel en laagdrempelig is en daar een volgende stap aan te breien, die dan ook voldoende wordt uitgelegd en gedocumenteerd. En dus niet in de zin van 'google is je vriend'
Maar dan zijn we al een beperkte cursus aan het schrijven zeker? Misschien voer voor een artikel?
In ieder geval hoop ik dat niemand zich aangevallen voelt door deze post, men doet immers om goed te doen, al wat ik vraag is beeld je ff in dat je zelf 0 kennis hebt van het onderwerp en ga daar van uit als je iemand wil helpen. Zo hebben we er meer aan en haakt men niet zo snel af.
+1 goed gesproken, ik ben ook volledig leek en zou iets willen leren.
Echter als ze met al die onbekende ( Engelstalige ) termen beginnen te zwaaien , zonder verstaanbare uitleg , moet ik helaas ook afhaken . :-\
Ik ben ook nog van die generatie , dat de PC een teletijdmachine was. :(
Dirky,
doe zo voort zou ik zeggen ;)
!
Met alle respect voor uw ergernis, @Frank "gardevil", ik begrijp dat toch niet zo goed. Om op uw eigen lettervoorbeeld verder te gaan:
Als men op zoek is naar wat in A wordt aangeboden, dan is het nergens voor nodig om verder te kijken. Einde verhaal.
Is men op zoek naar F, maar kan men vanaf C al niet meer volgen, dan is het de moment om uitleg te vragen.
Is men op zoek naar ZZF, en men kan vanaf B niet meer volgen, dan is het misschien het moment om de objectieven te herbekijken.
Vergelijk het met het consumeren van de media: ik weet bv. graag wat er in de wereld omgaat, en volg dus aandachtig het nieuws op de radio. Maar sport interesseert me niet, dus daaraan geef ik geen aandacht. En wie kent niet het trucje om naar toilet te gaan, of een drankje te halen, terwijl op TV de reclame loopt? Ik vind reclame zeer hinderlijk, zelfs op de radio wordt ze weggezapt; dat belet me niet volop naar de radio te luisteren.
Zo ook op een forum: wat u niet aanspreekt en/of uw petje te boven gaat, sla dat over, zo simpel is het. Of, als ge het echt wilt weten, stel dan gerichte vragen. Daar is niks verkeerd mee, iedereen heeft het ooit moeten leren.
En nu hoop ik maar dat ik niemand in de gordijnen jaag :)
Citaat van: Karel A.J. op 06 maart 2021, 10:39:23 AM
Met alle respect voor uw ergernis, @Frank "gardevil", ik begrijp dat toch niet zo goed. Om op uw eigen lettervoorbeeld verder te gaan:
Als men op zoek is naar wat in A wordt aangeboden, dan is het nergens voor nodig om verder te kijken. Einde verhaal.
Is men op zoek naar F, maar kan men vanaf C al niet meer volgen, dan is het de moment om uitleg te vragen.
Is men op zoek naar ZZF, en men kan vanaf B niet meer volgen, dan is het misschien het moment om de objectieven te herbekijken.
Vergelijk het met het consumeren van de media: ik weet bv. graag wat er in de wereld omgaat, en volg dus aandachtig het nieuws op de radio. Maar sport interesseert me niet, dus daaraan geef ik geen aandacht. En wie kent niet het trucje om naar toilet te gaan, of een drankje te halen, terwijl op TV de reclame loopt? Ik vind reclame zeer hinderlijk, zelfs op de radio wordt ze weggezapt; dat belet me niet volop naar de radio te luisteren.
Zo ook op een forum: wat u niet aanspreekt en/of uw petje te boven gaat, sla dat over, zo simpel is het. Of, als ge het echt wilt weten, stel dan gerichte vragen. Daar is niks verkeerd mee, iedereen heeft het ooit moeten leren.
En nu hoop ik maar dat ik niemand in de gordijnen jaag :)
Alleen vergeet je erbij te zeggen dat A wordt aangeboden en dat daarna wordt overgestapt naar E of F en gemakshalve wordt gezwegen over B-C en D omdat dit voor de gevorderde logisch is maar niet voor de beginners.
Het stellen van gerichte vragen kan hierbij inderdaad helpen, ware het niet dat ook hier hetzelfde gebeurd. Sommigen zijn zo vertrouwd met een onderwerp dat een aantal tussenstappen niet genoemd worden omdat het voor hen 'logisch' is.
Ik persoonlijk en met mij nog velen denk ik aan al de tussenstappen of een meer uitgebreide uitleg. De topicstarter is inderdaad zeer simpel begonnen, na de vierde post was er van simpel al geen sprake meer.
Ik begrijp de commentaren, dus stel ik het volgende voor: Dirk, je kopieert je eerste post en maakt een nieuw draadje aan met die post.
En dit draadje noemen we dan zoiets als: Doorbomen over verlichting huisjes op de modelbaan aansturen met Arduino.
Ok? Dan wijzig ik eerst de titel van dit draadje...
bij deze.... ander draadje gemaakt.
Ok, dan kan klap ik hier verder met Frank...
Citeerna de vierde post was er van simpel al geen sprake meer.
De suggestie voor subroutines en for-lussen was inderdaad heel wat ingewikkelder, en wel buitengewoon summier. Misschien bedoeld om mensen nieuwsgierig te maken, tot leren aan te zetten... Ik kan me wel voorstellen dat dat afschrikt.
Toch herhaal ik graag:
*/ men heeft dat helemaal niet nodig om ledjes te doen aan- en uitgaan
*/ het staat eenieder vrij om uitleg te vragen over subroutines of interrupts of over wat dan ook
*/ wie geen uitleg vraagt, die moet niet klagen dat het niet begrijpelijk is
(sorry, die laatste zin klinkt misschien wat hard, is echt niet zo bedoeld)
Zal ik misschien een andere vergelijking maken: leren autorijden. Er is toch niemand die begint met de theorieboeken van buiten te leren, of met onder de motorkap ieder boutje en draadje te begrijpen? Welnee, men stapt achter het stuur en begint eraan. Dat is wat knoeien en sukkelen in het begin, de meesten komen er wel doorheen. En ik weet er genoeg die prima rijden zonder ooit een theorieboek te hebben geopend, of zonder ook maar eenmaal onder de kap te hebben gekeken. Zo mag men de Arduino ook benaderen, hoor, het lijkt mij veruit de beste manier: gewoon aan beginnen, het internet staat vol met voorbeelden, en men kan altijd iets vragen, hier en elders.
daarom post ik niet meer....
Met goede bedoelingen en HEEL SIMPEL, maar ja, te moeilijk.
Als het te moeilijk word, stop dan met lezen en doe verder op eht niveau dat je WEL nog begreep.
En laat mensen die zich verder willen verdiepen in de materie dat dan ook doen.
Als je voelt dat je draadje "gekaapt" xwordt vraag de mods er een slot op te zetten.
Alweer een reden om NIET meer te reageren op pmosts.
JAMMER voor de mensen die wel willen LEREN.
Citaat van: dani op 06 maart 2021, 12:03:50 PM
daarom post ik niet meer....
Met goede bedoelingen en HEEL SIMPEL, maar ja, te moeilijk.
Als het te moeilijk word, stop dan met lezen en doe verder op eht niveau dat je WEL nog begreep.
En laat mensen die zich verder willen verdiepen in de materie dat dan ook doen.
Als je voelt dat je draadje "gekaapt" xwordt vraag de mods er een slot op te zetten.
Alweer een reden om NIET meer te reageren op pmosts.
JAMMER voor de mensen die wel willen LEREN.
Jammer dat mensen zo reageren ipv. wat meer uitleg te geven en een ander op weg te helpen.
Ik heb blijkbaar het idee dat het forum de bedoeling had om elkaar te helpen, Niet dus.
Citaat van: Karel A.J. op 06 maart 2021, 11:54:52 AM
Ok, dan kan klap ik hier verder met Frank...
Citeerna de vierde post was er van simpel al geen sprake meer.
De suggestie voor subroutines en for-lussen was inderdaad heel wat ingewikkelder, en wel buitengewoon summier. Misschien bedoeld om mensen nieuwsgierig te maken, tot leren aan te zetten... Ik kan me wel voorstellen dat dat afschrikt.
Toch herhaal ik graag:
*/ men heeft dat helemaal niet nodig om ledjes te doen aan- en uitgaan
*/ het staat eenieder vrij om uitleg te vragen over subroutines of interrupts of over wat dan ook
*/ wie geen uitleg vraagt, die moet niet klagen dat het niet begrijpelijk is
(sorry, die laatste zin klinkt misschien wat hard, is echt niet zo bedoeld)
Zal ik misschien een andere vergelijking maken: leren autorijden. Er is toch niemand die begint met de theorieboeken van buiten te leren, of met onder de motorkap ieder boutje en draadje te begrijpen? Welnee, men stapt achter het stuur en begint eraan. Dat is wat knoeien en sukkelen in het begin, de meesten komen er wel doorheen. En ik weet er genoeg die prima rijden zonder ooit een theorieboek te hebben geopend, of zonder ook maar eenmaal onder de kap te hebben gekeken. Zo mag men de Arduino ook benaderen, hoor, het lijkt mij veruit de beste manier: gewoon aan beginnen, het internet staat vol met voorbeelden, en men kan altijd iets vragen, hier en elders.
Het gaat hier niet over vragen, het gaat hier over het overslaan van stappen en dan diegene die niet meer kan volgen dat te verwijten. Maar nogmaals begrijpelijk dat voor een gevorderde gebruiker het misschien logische stappen zijn. Voor de leek echter niet.
?? Wie heeft er u iets verweten? Dat ware inderdaad onaanvaardbaar - maar ik heb niks gezien.
Ik snap Gardevil best wel. En het is heel gemakkelijk om je schuldig te maken aan stappen overslaan als je al iets verder staat. Ik merk dat ook op het werk. Ik ben met iets al 5 jaar bijna elke dag bezig en als ik dan iemand anders op weg moet zetten dan slaag ik dingen wel eens over. Voor mij NU te evident en ik ben vergeten dat ik daar vroeger ook tegen de lamp gelopen ben met die stappen over te slaan.
Eerlijk gezegd, ik kan de meeste ideeën wel volgen omdat ik lang geleden zo'n basiscursus programmeren gekregen heb. Heb er nooit nog iets mee gedaan. En ja, ik heb hier 3 arduino bordjes liggen en weet je wat? Ik krijg ze niet aan de praat en herkend door de pc. Dus ik begrijp het programma, zou daar die lussen en andere wel inkrijgen. Maar ik krijg dat gewoon niet op het bordje. Heb een UNO besteld, we zullen zien wat dat geeft.
Dus, moraal van het verhaal:
- de leraar moet niet te snel willen gaan en dingen overslaan. Ook de zaken die "te simpel" lijken moeten ooit eens uitgelegd worden.
- de leerling moet niet direct verder gaan totdat hij de basis doorheeft. Het is niet omdat de ideeën hier verder gespuwd worden dan je niet rustig bij het begin mag blijven en daarover vragen stellen. En voorlopig de rest overslaan.
Langs de andere kant... cpu power is zo goedkoop deze dagen dat zelfs een simpel sequencieel programma zoals in dat eerste voorbeeld van Dirky, op zo'n processor geen ramp is. Ja, je kan dat verfijnen, je kan die code optimaliseren, etc etc. Maar zo'n UNO kost nog geen 10 euro aan je deur geleverd!
ditto
Dirk
Alsmaar zoekend naar vergelijkingen die kunnen verduidelijken: ik bedacht me dat
Iemand die vragen heeft bij het vermenigvuldigen van 7 maal 24
weinig gebaat is met suggesties over logaritmes of over cosinussen of zo.
Nu kan men aanvoeren dat logaritmes best wel relevant kunnen zijn als het over vermenigvuldigen gaat - wie weet nog met een rekenlineaal om te gaan :) ? - maar waar het eigenlijk op aan komt:
Zal men antwoorden aan de vraagsteller?
Of zal men antwoorden aan allen die, nu of later, belang stellen in het onderwerp?
In het tweede geval kan een antwoord dat verder gaat dan de neuslengte van de vraagsteller zinnig en verantwoord zijn.
De tenen steken weer ver uit de schoenen ;D
En heb ik gelijk? we zijn nog geen bladzijde ver en er begint al eenen over cosinussen te rammelen. Het oorspronkelijke onderwerp is al heeeeeeeel ver weg.
Citaat van: Karel A.J. op 07 maart 2021, 12:13:39 PM
Alsmaar zoekend naar vergelijkingen die kunnen verduidelijken: ik bedacht me dat
Iemand die vragen heeft bij het vermenigvuldigen van 7 maal 24
weinig gebaat is met suggesties over logaritmes of over cosinussen of zo.
Nu kan men aanvoeren dat logaritmes best wel relevant kunnen zijn als het over vermenigvuldigen gaat - wie weet nog met een rekenlineaal om te gaan :) ? - maar waar het eigenlijk op aan komt:
Zal men antwoorden aan de vraagsteller?
Of zal men antwoorden aan allen die, nu of later, belang stellen in het onderwerp?
In het tweede geval kan een antwoord dat verder gaat dan de neuslengte van de vraagsteller zinnig en verantwoord zijn.
Ik denk, maar wie ben ik, antwoorden op de vraagsteller, want dat is de reden dat hij de vraag stelde.Verder uitweiden kan daarna nog altijd, zolang men maar in gedachte houdt dat de vraagsteller misschien niet hetzelfde kennisniveau heeft als diegene die de vraag beantwoord.
Citaat van: Dirky op 07 maart 2021, 16:17:57 PM
En heb ik gelijk? we zijn nog geen bladzijde ver en er begint al eenen over cosinussen te rammelen. Het oorspronkelijke onderwerp is al heeeeeeeel ver weg.
Het is lastig om zich in de denkwereld van een ander te verplaatsen. Men reageert soms op iets totaal irrelevant en dan ontspoort het. Bij de zaak blijven op een forum is lastig. In een klas is er de leraar die alles in goede banen kan lij(ei)den. Op een forum heb je de moderator(s), maar ja, wie heeft daar tijd voor. Tegen dat die kan ingrijpen is het kwaad geschied. En als de (on)bewuste zondaar dan last heeft van het lange tenen syndroom is het mot, zoals ze in het noorden zeggen.
Ik heb me trouwens een tijd geleden ook in de Arduinowereld gestort, geleidt door het internet, want daar zijn heel goede voorbeelden en richtlijnen te vinden. Ergens op dit forum zijn mijn prestaties misschien nog terug te vinden, en het ging om een digitale besturing zonder Ecossen en andere dure dingen.
Je kunt het eenvoudig houden, maar voor sommigen zijn begrippen als compileren en uploaden al te veel.
Met mijn sorry aan Dirk voor de vervuiling ;)
Probleem is de vorm van het forum (nu wijken we wel ver af). Als je 1-op-1 met iemand zo bezig bent, dan kan je de snelheid van vooruitgaan aanpassen aan wie je voor jou hebt. "De leraar" in de post van Hugo hierboven. Maar hier op het forum gaat dat niet want iedereen stuurt maar een antwoord op wat hij ziet ifv wat hij weet/wil weten, zonder dat hij rekening kan houden met de anderen. Dat legt ook wat bij diegene die meeleest. Je moet gewoon nog geen rekening houden met de gevorderde uitleg en de vragen op jouw tempo stellen en verder gaan op jouw tempo. Probleem is dat het overzicht snel zoek is. En eerlijk gezegd ik weet daar ook geen oplossing voor.
Om even terug te gaan op het begin: er is de simpele sketch van Dirky. Dan komt er de post van Dani met de tips "waarom niet met een "for" lus? en je kan ook een functie aan/uit gebruiken". Er is niets mis mee met die opmerking/vraag/tips. Als je als lezer nog met die eerste sketch bezig bent, doe rustig voort tot je daar door bent. Laat de rest maar gaan. Als je daar door bent kan je ofwel zelf naar die "for lus" gaan, of er vragen over stellen. En je moet dat zelfs niet doen, er is geen examen op het einde.
CiteerEn heb ik gelijk? we zijn nog geen bladzijde ver en er begint al eenen over cosinussen te rammelen.
Okee, heb dan maar gelijk, als ge daar op uit zijt. (volgens mij kan men "gelijk" niet tussen zijn boterham leggen, en is het dus niet veel waard - maar ik weet wel dat er ook dikkere ego's rondgaan in de wereld).
@Dirky, ik heb u vanaf de eerste reactie alle lof en steun gegeven, het stemt me bijzonder bitter om zo laffelijk te worden aangevallen op de cosinus die ik enkel als voorbeeld aanhaalde.
Salut en de kost.
Soit, waarom dan niet gewoon wat verder doen...
We hadden de simpele sketch van Dirky:
void setup() { // initialize digital pins as an output.
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
}
// the loop function runs over and over again forever
// En nu begint het spelleke: Je geeft aan wat je verwacht van die "outputs".
// Eerste lijn zegt: Zet uitgang 1 hoog (aan)
// Tweede lijn zegt: wacht 10000 millisekonden (10 seconden)
// Enz...
void loop() {
digitalWrite(1, HIGH);
delay(10000);
digitalWrite(2, HIGH);
delay(10000);
digitalWrite(8, HIGH);
delay(5000);
digitalWrite(4, HIGH);
delay(10000);
digitalWrite(7, HIGH);
delay(10000);
digitalWrite(10, HIGH);
delay(8000);
digitalWrite(3, HIGH);
delay(12000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(9, HIGH);
delay(15000);
digitalWrite(8, LOW);
delay(18000);
digitalWrite(5, HIGH);
delay(10000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(11, HIGH);
delay(18000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(4, HIGH);
delay(15000);
digitalWrite(10, HIGH);
delay(12000);
digitalWrite(3, LOW);
delay(15500);
digitalWrite(9, LOW);
delay(18000);
digitalWrite(5, LOW);
delay(10000);
digitalWrite(11, LOW);
delay(12000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(2, HIGH);
delay(12000);
digitalWrite(5, HIGH);
delay(15000);
digitalWrite(11, HIGH);
delay(5000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(8, HIGH);
delay(18000);
digitalWrite(1, LOW);
delay(15000);
digitalWrite(5, LOW);
delay(5000);
digitalWrite(11, LOW);
delay(16000);
digitalWrite(8, LOW);
delay(20000);
digitalWrite(7, LOW);
delay(12000);
digitalWrite(6, HIGH);
delay(12000);
digitalWrite(12, HIGH);
delay(18000);
digitalWrite(6, LOW);
delay(5000);
digitalWrite(12, LOW);
delay(20000);
// En als ie op 't einde komt, herbegint die gewoon weer.
}
We kunnen nu voor dat eerste stuk een "for" lus gebruiken. Dan wordt de sketch:
void setup() { // initialize digital pins as an output.
int x; // we gaan een teller gebruiken die enkel gehele getallen voorstelt en die we x noemen
for (x=1;x<13;x++) {
// deze lus begint met x=1 en gaat door de lus, aan het einde wordt x eentje groter gemaakt (x++) en we doen dat zolang x kleiner dan 13 is
pinMode(x,OUTPUT); // zet pin met nummer x als OUTPUT
}
}
// the loop function runs over and over again forever
// En nu begint het spelleke: Je geeft aan wat je verwacht van die "outputs".
// Eerste lijn zegt: Zet uitgang 1 hoog (aan)
// Tweede lijn zegt: wacht 10000 millisekonden (10 seconden)
// Enz...
void loop() {
digitalWrite(1, HIGH);
delay(10000);
digitalWrite(2, HIGH);
delay(10000);
digitalWrite(8, HIGH);
delay(5000);
digitalWrite(4, HIGH);
delay(10000);
digitalWrite(7, HIGH);
delay(10000);
digitalWrite(10, HIGH);
delay(8000);
digitalWrite(3, HIGH);
delay(12000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(9, HIGH);
delay(15000);
digitalWrite(8, LOW);
delay(18000);
digitalWrite(5, HIGH);
delay(10000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(11, HIGH);
delay(18000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(4, HIGH);
delay(15000);
digitalWrite(10, HIGH);
delay(12000);
digitalWrite(3, LOW);
delay(15500);
digitalWrite(9, LOW);
delay(18000);
digitalWrite(5, LOW);
delay(10000);
digitalWrite(11, LOW);
delay(12000);
digitalWrite(4, LOW);
delay(15000);
digitalWrite(10, LOW);
delay(18000);
digitalWrite(2, HIGH);
delay(12000);
digitalWrite(5, HIGH);
delay(15000);
digitalWrite(11, HIGH);
delay(5000);
digitalWrite(2, LOW);
delay(15000);
digitalWrite(8, HIGH);
delay(18000);
digitalWrite(1, LOW);
delay(15000);
digitalWrite(5, LOW);
delay(5000);
digitalWrite(11, LOW);
delay(16000);
digitalWrite(8, LOW);
delay(20000);
digitalWrite(7, LOW);
delay(12000);
digitalWrite(6, HIGH);
delay(12000);
digitalWrite(12, HIGH);
delay(18000);
digitalWrite(6, LOW);
delay(5000);
digitalWrite(12, LOW);
delay(20000);
// En als ie op 't einde komt, herbegint die gewoon weer.
}
Dit is identiek het zelfde als de hele simpele versie. Wat zijn de voordelen:
- je moet minder schrijven
- als je de volgende versie er maar 10 nodig hebt, dan moet je 1 getal veranderen (13 wordt 11)
- als je volgende keer er 24 nodig hebt moet je ook 1 getal veranderen (13 wordt 25)
Maar er zijn ook nadelen:
- dit werkt enkel als je alle opeenvolgende pinnen dezelfde functie wil geven. Als pin 5, 7 en 9 een INPUT zijn dan werkt dit niet.
- je moet goed opletten dat het begin en einde goed zit. Je wil alle pinnen van 1 tot en met 12 configureren. Dus tel je van 1 tot (kleiner dan 13) want de test gebeurt bovenaan en de teller x een verhogen aan het einde van de lus.
in de mate dat dit nog relevant is ...
---
ik wil niet beleerd overkomen maar heb toch een paar opmerkingen die interessant kunnen zijn voor iedereen.
Ik raad je ten stelligste het gebruik van 'delay' af in deze context. Met die functie stopt je arduino voor een momentje en wacht... ondertussen kan je niets meer doen. Dus ook geen andere led meer opzetten of afzetten. Pas je ergens 1 delay aan, rimpelt het de rest van je timers in de 'soep'.
Veel beter is een soort timer te maken met start en eind momenten, te checken voor elke led of je daar tussen valt en actie te nemen.
Dit kan je in een loop doen, kost een fractie van een secondje en daarna kan je iets anders doen. Vb, een input van een schakelaar lezen.
een voorbeeld van een soort timer :
if (millis()-lastchangeblink >= blinkinterval)
{
led_out=!led_out; // invert blink status -> time to change LEDs if they need to be blinking
Driveleds();
lastchangeblink=millis();
}
dit inverteert de output (dus een led) na een bepaalde tijd. Je kan dit gewoon aanpassen naar het op/af zetten van leds.
Het is een fractie van een sec om hierdoor te lopen voor een arduino en direct daarna kan je andere stukjes van programma zetten. Met een array kan je meerdere leds in 1 keer doen.
je neemt het moment 'nu' (=millis()) en vergelijkt dat met je laatste actie, is die groter dan een interval, doe je iets.
Maar even makkelijk kan je tijden vergelijken door start / stop momenten PER led.
ik heb dit ook gebruikt om 1 keer per aantal seconden de temperatuur te meten :
// take temp every set interval + display on tft
if (millis()-lasttemptaken >= temptakeninterval)
{
sampletemp();
lasttemptaken=millis();
}
Nog een andere manier om een hele hoop leds aan te sturen is door gebruik te maken van speciale leds : neopixels.
Mijn oude controlepaneel was zo gemaakt : https://www.youtube.com/watch?v=vXrFzWfWMDM
Dit zijn een 3 tal series van leds in lijn gezet.
Met neopixels kan je met 1 pin en 1 commando een hele hele lange lijn LEDS gaan aansturen. En elke LED een aparte kleur geven.
De kring is in 1 keer te dimmen (niet individueel) zonder telkens een andere weerstand te moeten solderen. Gewoon in software.
https://www.tweaking4all.nl/hardware/arduino/adruino-led-strip-effecten/
Dit klinkt moeilijker dan het is, denk gewoon aan een effect dat je elke huisje een lichtjes andere kleur kan geven en elk ledje indivudueel kan afzetten met paar 1 draadje uit je arduino. Allemaak in een fractie van een seconde voor de hele lijn aan te passen.
EN ... in dit soort schakelingen haal je de voeding van de leds niet uit de arduino maar uit een aparte simpele voeding. Want je moet ook opletten dat je de arduino niet overbelast, vooral als je veel leds gaat doen om een MEGA gebruikt met veel pinnen.
Er zijn trouwens ook andere libraries die toelaten meerdere pinnen van de arduino te gebruiken voor leds en te dimmen.
Ik vind je printje dat je gesoldeerd hebt trouwens heel netjes, ik zou het niet zo proper kunnen. Ik klodder meestal maar wat aan.
Patrick
maar hoe bepaal je dan hoe lang een bepaalde LED aan blijft? Ik wil de volgorde en de tijden respecteren van het grafiekje dat ik in excel heb gemaakt...
Dirk in basic zou het eenvoudig zijn
PORTB = %11111111 'nu staan alle leds uit
for a = 1 to b :next 'waarvan b bepaald word in je setup
PORTB = %11111110 'je tweede regel
for a = 1 to 1000 +b :next
PORTB = %01111100 'je derde regel
for a = 1 to 1500 + b :next
PORTB = %11011101 zo maar een regel
door nu steeds de het bit van een poort terug 1 te maken gaat de led terug uit terwijl je met een bit 0 te maken een andere terug aan zet
onder elk huisje zit van mij een processor die zich alleen met de ledjes bezig houd
alle processoren zitten aan een dag nacht schakeling maar het kan even goed een schakelaar zijn die manueel je op een bord bedient
je kunt max 15 ledjes sturen met een 16f628 processor omdat er een poort alleen maar ingang kan zijn (door ingeniering bepaald kun je niets aan veranderen)
zolang die poort 0 (massa)krijgt blijft de verlichting werken
staat er op die poort 5 volt (een 1) dan stoppen alle verlichting processors met wat ze bezig zijn
of die truk ook met een arduino kan gedaan worden met zo een volledige poort te schakelen heb ik geen idee
dus al je gele vlakjes worden een 0 en de rest een 1
Ik ben er echt niet van overtuigd dat wat ik wil, sneller kan geschreven worden dan hoe ik het nu doe:
Excel is voor mij zo een beetje "het" programma waarmee ik dingen "automatisch" schrijf.
Wat ik nu laat lopen op die Arduino wordt geschreven aan de hand van een tabel die bestaat uit "LEDNUMMER", "DELAY AAN", "DUUR AAN", "DELAY2 AAN", "DUUR2 AAN".
Met een beetje rekenwerk en de functie "TEKST.SAMENV" laat ik alle lijntje schrijven en met copy/paste gaan die in de sketch. Moet ik iets aanpassen, dan verander ik een cijfertje en her-copy/paste...
Het probleem voor de beginner is dat er direct met woorden gegooid wordt die wij gewoon niet begrijpen wat ze in het programma betekenen.
@Patrick; mocht je eens op jouw manier een volledige sketch schrijven die ervoor zorgt dat een Arduino doet wat wij willen zou het misschien duidelijker zijn... of kunnen we gerichtere vragen stellen.
Ik sluit me graag aan bij Patrick @perk : om het echt proper te doen in Arduino is de functie "millis" de grote max. Maar het is niet zo eenvoudig te doorgronden, vooral moet men er het voordeel van inzien. Ik doe maar een poging:
{{ voorbeeld zo moet het niet }}
[ check voorwaarde1 ] [actie1] [vertraag tijd 1]
[ check voorwaarde2 ] [actie2] [vertraag tijd 2]
...
{{ voorbeeld dit is beter }}
[check voorwaarde 1] [actie 1]
[check voorwaarde 2] [actie 2]
...
[vertraag (zoveel milli's als er nog overschieten)
Met alle respect Karel maar daar leer ik niets mee bij.
Je schrijft enkele lijntjes uit een geheel waarnaar we allemaal moeten gissen wat het zou kunnen zijn. Dat zegt dus helemaal niets!
Schrijf eens een complete werkende sketch, desnoods voor "maar" 3 LEDjes, zodat we het geheel zien.
Dirk, evenzeer met alle respect, maar is dit forum daarvoor de aangewezen plaats?
Gaat het hier over treintjes of gaat het hier over arduino's?
Nu, er is niks verkeerds aan om alhierover Arduino's te klappen, maar het moet (nmbm) een nevenzaak blijven.
Zeer opzettelijk wilde ik, nu we toch niet meer in het "eenvoudig"-draadje zitten, een aanzet geven tot eigen onderzoek.
Als ik ooit motivatie heb om hapklare brokken te posten dan zal ik dat wel in het "eenvoudig"-draadje doen - die opsplitsing is er niet zomaar gekomen. Want "eenvoudig" en "anders/beter" gaan niet zo licht samen.
Citaat van: Dirky op 15 maart 2021, 16:59:47 PM
Met alle respect Karel maar daar leer ik niets mee bij.
Je schrijft enkele lijntjes uit een geheel waarnaar we allemaal moeten gissen wat het zou kunnen zijn. Dat zegt dus helemaal niets!
Schrijf eens een complete werkende sketch, desnoods voor "maar" 3 LEDjes, zodat we het geheel zien.
Dirky, sluit me hierbij volledig aan.
't is ik niet die het ingewikkeld wou maken. Ik heb het draadje in twee gesplitst omdat er enkele mensen die het veel beter weten hun ding wouden doen omdat het mijne te eenvoudig was en veeeeeeel beter kon. >:( Ge wou mij wijsmaken dat het beter kon! Maar blijkbaar is jullie oplossing ook niet zo gemakkelijk. Het mijne werkt en ik ben tevreden. Mijn klant ook!
Van mij mag heel dienen boel op slot...
en ik denk echt dat ik hier in alle stilte ga verdwijnen en alles ga overlaten aan "de specialisten"!
Bennekik content dak mi alleen mor schaokeleirtjes waerk, geen punthoofd en een zachte nachtrust. 8)
En gelukkig bennekik oak genen specialist.
Den Eric.
Citaat van: Karel A.J. op 15 maart 2021, 17:13:57 PM
Dirk, evenzeer met alle respect, maar is dit forum daarvoor de aangewezen plaats?
Gaat het hier over treintjes of gaat het hier over arduino's?
Nu, er is niks verkeerds aan om alhierover Arduino's te klappen, maar het moet (nmbm) een nevenzaak blijven.
...
Sorry Karel, maar hier ben ik het toch niet mee eens.
Arduino is aan een opmars bezig in onze hobby, net als lasersnijden en 3D-printen, welke we hier ook regelmatig op dit forum zien passeren.
En dan vind ik de vraag van Dirk terecht. Je leert het meest als er een volledige 'sketch' wordt gepost.
Citaat van: Dirky op 15 maart 2021, 17:25:20 PM
't is ik niet die het ingewikkeld wou maken. Ik heb het draadje in twee gesplitst omdat er enkele mensen die het veel beter weten hun ding wouden doen omdat het mijne te eenvoudig was en veeeeeeel beter kon. >:( Ge wou mij wijsmaken dat het beter kon! Maar blijkbaar is jullie oplossing ook niet zo gemakkelijk. Het mijne werkt en ik ben tevreden. Mijn klant ook!
Van mij mag heel dienen boel op slot...
en ik denk echt dat ik hier in alle stilte ga verdwijnen en alles ga overlaten aan "de specialisten"!
neenee, blijf maar hier.
Dit is tenminste bruikbaar en interessant; er zijn al genoeg van die eindeloze zeurdraadjes waar niemand iets aan heeft behalve de bezitters van een peperdure loc (om een voorbeeld te geven ;) )
CiteerJe leert het meest als er een volledige 'sketch' wordt gepost.
En daarmee ben ik het dan weer helemaal oneens, beste Luc. Nog steeds met alle respect, uiteraard :)
Een volledige sketch die wordt alleen maar overgenomen, knip & plak & uit.
Als het werkt dan hoort men niets meer.
Werkt het voor iemand niet dan komt er "dat werkt niet" - waarmee niemand iets vooruit kan, uiteraard.
Ik sta helemaal achter de opsplitsing "basis" vs. "ten gronde" - maar in een "ten gronde" moet men bereid zijn tot eigen inzet, en dus geen hapklare brokken verlangen. In het "basis"-draadje zijn er die al aangeboden, en ik heb er mijn volle steun bij betuigd.
Wie echt wil leren, die begint met iets uitermate simpels, breit daarop verder naar beste godsvrucht en vermogen, en naar eigen inzicht; en post hier (of elders, uiteraard) vragen en resulaten en problemen. Lieden die zoveel inzet betonen zal ik graag ondersteunen.
En verder begin ik ook te overwegen om het hier maar voor bekeken te houden - ook om andere redenen, overigens.
Een mogelijke variant waarbij LEDs willekeurig aan en uit gaan volgens een willekeurige tijd. De tijd bevindt zich steeds tussen mintijd en maxtijd.
// vrij aan te passen parameters
unsigned long mintijd = 3000; // in milliseconden
unsigned long maxtijd = 10000; // in milliseconden
int aantalLEDs = 12; //max 12 LEDS op een Arduino UNO, nl pin 2 tem pin 13. Pin 0 en 1 kunnen niet gebruikt worden als output.
// hulpvariabelen, niet aanpassen
unsigned long timer;
int pinLED;
void setup() {
// overloopt alle pins die zullen gebruikt worden en zet deze als output. Bvb bij 12 LEDS dus tellen vanaf 2 zolang de waarde van i kleiner is dan 2 + 12.
for (int i=2; i < aantalLEDs+2; i++){
pinMode(i, OUTPUT);
}
// dit is nodig voor de random functie omdat de Arduino geen random generator aan boord heeft. Een zwevende ingang (analoge pin 0 inlezen levert steeds een willekeurige waarde op.
randomSeed(analogRead(0));
}
void loop() {
// als de timerwaarde kleiner wordt dan de millis()-waarde, alles binnen de accolades uitvoeren.
if (timer <= millis()){
// willekeurige pin nemen. Random-Functie heeft 2 parameters: min waarde (dit is inclusief) en een max waarde (deze is exclusief) en geeft een waarde in dat interval terug
pinLED = random(2,aantalLEDs+3);
// de waarde van de pin inlezen en het omgekeerde van de waarde uitsturen dmv '!'
digitalWrite(pinLED,!digitalRead(pinLED));
// nieuwe waarde voor timer zetten
timer = millis() + random(mintijd,maxtijd+1);
}
}
Citaat van: Karel A.J. op 15 maart 2021, 18:26:54 PM
CiteerJe leert het meest als er een volledige 'sketch' wordt gepost.
En daarmee ben ik het dan weer helemaal oneens, beste Luc. Nog steeds met alle respect, uiteraard :)
Een volledige sketch die wordt alleen maar overgenomen, knip & plak & uit.
Als het werkt dan hoort men niets meer.
Werkt het voor iemand niet dan komt er "dat werkt niet" - waarmee niemand iets vooruit kan, uiteraard.
Ik sta helemaal achter de opsplitsing "basis" vs. "ten gronde" - maar in een "ten gronde" moet men bereid zijn tot eigen inzet, en dus geen hapklare brokken verlangen. In het "basis"-draadje zijn er die al aangeboden, en ik heb er mijn volle steun bij betuigd.
Wie echt wil leren, die begint met iets uitermate simpels, breit daarop verder naar beste godsvrucht en vermogen, en naar eigen inzicht; en post hier (of elders, uiteraard) vragen en resulaten en problemen. Lieden die zoveel inzet betonen zal ik graag ondersteunen.
En verder begin ik ook te overwegen om het hier maar voor bekeken te houden - ook om andere redenen, overigens.
Probleem met zo'n stukje code zoals perk hierboven heeft geschreven is dat het op zich niet bruikbaar is. Je moet ook aangeven dat je al die variabelen bvb ergens moet declareren. Wat deevie hier net boven schrijft is al heel wat bruikbaarder EN het legt ook nog uit wat alles doet. Zo leer je bij.
Bedankt Davy,
Voor zover ik het (al) begrijp overlappen de "aan" periodes van de ene LED niet die van andere? Het is elk om beurt, niet?
volledig akkoord met het commentaar van Havoc, mijn stukje was maar om aan te geven dat ik het niet met delay zou doen maar met timers.
Ik had geen tijd deze middag om het verder uit te werken.
Je kan dit ongelofelijk 'moeilijker' maken met de lengte van de dag, uren voor stop en start en allemaal herschalen naar modeltijd.
Dirky, als de klant tevreden is - dan is het toch prima? Vele wegen leiden naar Rome, zoals sommigen onder ons (ikke) dus tevreden zijn met een groen treintje dat wat Belgisch lijkt en sommige anderen het laatste detail juist willen. Niks mis mee.
Ik heb ook Arduino code met delays voor simpele dingen, maar echt simpel blijft het meestal niet. Want met die ene arduino die je nu hebt kan ook een deur laten opengaan, en een geluidje maken, en een laspost laten bliksemen, de sequentie laten veranderen of pauzeren met een knopje ... allemaal met dezelfde arduino maar dan niet meer met 'delay'. En zo bouw je stukje voor stukje verder en na een tijdje zitten alle pinnen vol :-)
Het is ook een stukje hobby op zich, zoals sommigen zich laten gaan met 3D printers ook.
Ik vind het allemaal wel leuk, niet als doel op zich maar ter ondersteuning van onze hobby.
Citaat van: perk op 15 maart 2021, 21:05:42 PMWant met die ene arduino die je nu hebt kan ook een deur laten opengaan, en een geluidje maken, en een laspost laten bliksemen, de sequentie laten veranderen of pauzeren met een knopje ... allemaal met dezelfde arduino maar dan niet meer met 'delay'. En zo bouw je stukje voor stukje verder en na een tijdje zitten alle pinnen vol :-)
Hierbij heb ik zoiets van: KISS. Niemand lijkt de post van raf gelezen te hebben? "Onder elk huisje zit een processor". Als je ziet van die dingen kosten waarom dan elke pin willen gebruiken? Waarom niet iets simpel doen doen en dan hop, een volgende voor het volgende effect? Ok, onder elk huisje een processor is misschien overdreven, maar onder een rijtje een processor voor de lichtjes. En dan een andere om de rolluiken te bedienen... (ok, maar een voorbeeld).
Citaat van: Dirky op 15 maart 2021, 20:58:24 PM
Voor zover ik het (al) begrijp overlappen de "aan" periodes van de ene LED niet die van andere? Het is elk om beurt, niet?
Ze overlappen eigenlijk. De eerste random-functie binnen de loop selecteert een willekeurige pin. Die willekeurige pin wordt getoggled (dus als die uit is, wordt die aan gezet of omgekeerd). Als laatste wordt dan via de random-functie een bepaalde wachttijd bepaald. Eenmaal de wachttijd voorbij is (via die if statement) begint de routine opnieuw met random pin.
Het is dus mogelijk dat pin2 eerst wordt ingeschakeld, daarna pin 3 en misschien vervolgens wordt pin2 terug uitgeschakeld.
Citaat van: Havoc op 15 maart 2021, 21:09:38 PM
Citaat van: perk op 15 maart 2021, 21:05:42 PMWant met die ene arduino die je nu hebt kan ook een deur laten opengaan, en een geluidje maken, en een laspost laten bliksemen, de sequentie laten veranderen of pauzeren met een knopje ... allemaal met dezelfde arduino maar dan niet meer met 'delay'. En zo bouw je stukje voor stukje verder en na een tijdje zitten alle pinnen vol :-)
Hierbij heb ik zoiets van: KISS. Niemand lijkt de post van raf gelezen te hebben? "Onder elk huisje zit een processor". Als je ziet van die dingen kosten waarom dan elke pin willen gebruiken? Waarom niet iets simpel doen doen en dan hop, een volgende voor het volgende effect? Ok, onder elk huisje een processor is misschien overdreven, maar onder een rijtje een processor voor de lichtjes. En dan een andere om de rolluiken te bedienen... (ok, maar een voorbeeld).
...en daarom was ik op zoek naar dat item over die bouwdoos van Modelbouwled. Moet ge zelfs niet voor kunnen solderen als ge de geassembleerde versie koopt.
Citaat van: deevie op 15 maart 2021, 20:19:43 PM
Een mogelijke variant waarbij LEDs willekeurig aan en uit gaan volgens een willekeurige tijd. De tijd bevindt zich steeds tussen mintijd en maxtijd.
// vrij aan te passen parameters
// als de timerwaarde kleiner wordt dan de millis()-waarde, alles binnen de accolades uitvoeren.
if (timer < millis()){
// willekeurige pin nemen. Random-Functie heeft 2 parameters: min waarde (dit is inclusief) en een max waarde (deze is exclusief) en geeft een waarde in dat interval terug
......
// nieuwe waarde voor timer zetten
timer = millis() + random(mintijd,maxtijd+1);
De code in het voorbeeld heeft toch een vervelend neveneffect dat deze na enige tijd tot gevolg heeft dat het heel lang zal duren vooraleer de LED's nog eens toggle.
Het moment dat dit optreed is namelijk als na het berekenen van een nieuwe waarde voor "timer", millis() overgaat van maximale waarde naar minimale waarde ( een zogenaamde overflow).
Op te lossen door de berekening even te herschikken zoals correct gedaan een paar antwoorden terug (antwoord van Perk/Patrick) maar nu met een variant.
Ik ben geen Arduino expert noch gebruiker maar de variabelen moeten unsigned / unsigned long zijn (kan zijn dat dit zo is op dit platform)
...ergens in setup
starttijd = millis();
randomtijd = random(mintijd,maxtijd+1);
....
... in loop()
// als de timerwaarde kleiner wordt dan de millis()-waarde, alles binnen de accolades uitvoeren.
if (millis()-starttijd > randomtijd){
// willekeurige pin nemen. Random-Functie heeft 2 parameters: min waarde (dit is inclusief) en een max waarde (deze is exclusief) en geeft een waarde in dat interval terug
......
// nieuwe waarde voor timer zetten
starttijd = millis();
randomtijd = random(mintijd,maxtijd+1);
Onder het motto, hoe kan het anders ;) ...
Een nog universelere aanpak is om alle data in arrays of structs te zetten, zowel patroon, schakeltijden, de te gebruiken uitgangen, state, starttijd en duurtijd. (1 array of structs per kanaal voor het patroon binnen één kanaal en 1 array of pointers to arrays of structs om over de kanalen te itereren)
Het voordeel van deze datadriven aanpak is dat je enkel maar tabellen moeten editeren om patronen aan te passen en de code universeel is.
Maakt niet uit welke uitgang je wil schakelen en in welke volgorde en /of duurtijd. Alles info zit in de data/tabellen.
Op dat ogenblik ben je aan het configureren i.p.v. programmeren en tabellen kan je ook automatisch aanmaken / opladen via seriële poort/usb poort etc.
Jammer genoeg heb ik geen Arduino bij de hand maar ongetwijfeld is hier wel een Arduino expert die een voorbeeld(je) kan posten.
mvg, Patrick Smout
De overflow doet zich voor na ongeveer 50 dagen. Het effect dat beschreven wordt waarbij heel lang zal moeten gewacht worden klopt eigenlijk niet. Integendeel zelfs want na ongeveer 50 dagen zal er uitzonderlijk iets sneller een LED getoggled worden. De reden is eigenlijk heel simpel. De tijd die de Arduino nodig heeft om na de laatste statement in de IF-statement terug de IF-statement zelf te valideren is veeeeeeel korter dan de min tijd die normaal ingesteld wordt. Ook de timer-variabele zal overflowen.
De opmerking ivm unsigned variabelen begrijp ik niet?
Heb je dat getest ? ;)
Wat als millis + random ( timer) bijna op max waarde staat en de volgende keer de loop doorlopen wordt millis terug naar de min waarde gevallen is. Kan voorkomen als ergens in de loop iets langer duurt en random kleine waarden geeft.
In dat geval gebeurt er 50 dagen niets meer ... Of je moet de spanning uitzetten.
Unsigned .... Variabele zonder tekenbit om de berekening te doen in de gewijzigde code.
Mvg, Patrick
en nu kunnen we helemaal niet meer volgen >:(
Tip voor de beginner en leek, die nog geen of weinig kennis heeft van Arduino: laat dit draadje nog even voor wat het is. Begin bij basis zaken die je op het net kan vinden (of op de website van VMSC De Locloods Arduino (https://www.de-locloods.be/kopie-van-arduino/) bijvoorbeeld).
Het hoeft ook absoluut niet heel duur te zijn. Bij de Chinees (Ali), kan je al een kitje kopen met enkele basiszaken om aan de slag te gaan voor rond de €10 (Ali (https://nl.aliexpress.com/item/1005001886465210.html?spm=a2g0o.productlist.0.0.1e3f42ddwdLDsm&algo_pvid=8da65b23-a60a-48e5-b971-83fda3aef23a&algo_expid=8da65b23-a60a-48e5-b971-83fda3aef23a-39&btsid=0bb0623d16158732771252797e5d85&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_) ) of als je weet wat je allemaal nodig hebt, kan je een losse UNO kopen voor nog geen €4 (nog eens Ali (https://nl.aliexpress.com/item/32803501325.html?spm=a2g0o.productlist.0.0.1c044623pY9aQD&algo_pvid=fce8fb2c-82c7-4570-b2a5-5bda383bad52&algo_expid=fce8fb2c-82c7-4570-b2a5-5bda383bad52-3&btsid=0bb0600116158734184405853e82fd&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_)), een breadboard (https://nl.aliexpress.com/item/4000301371545.html?spm=a2g0o.productlist.0.0.cb4c532enavtpN&algo_pvid=261b889f-2606-4494-9905-f1b96b8ce820&algo_expid=261b889f-2606-4494-9905-f1b96b8ce820-6&btsid=0bb0623916158736170486924ecef4&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_)voor €0,90, de jumpers (https://nl.aliexpress.com/item/1005002000655439.html?spm=a2g0o.productlist.0.0.65d06639j13ihq&algo_pvid=null&algo_expid=null&btsid=0bb0623916158737275017846ecef4&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_) €2,5 , de LEDS (https://nl.aliexpress.com/item/1005001976801604.html?spm=a2g0o.detail.1000060.2.41cc70760mAK3A&gps-id=pcDetailBottomMoreThisSeller&scm=1007.13339.169870.0&scm_id=1007.13339.169870.0&scm-url=1007.13339.169870.0&pvid=d23fc1fb-2718-4f42-acd5-1572a46bce82&_t=gps-id:pcDetailBottomMoreThisSeller,scm-url:1007.13339.169870.0,pvid:d23fc1fb-2718-4f42-acd5-1572a46bce82,tpp_buckets:668%230%23131923%2362_668%230%23131923%2362_668%23888%233325%234_668%23888%233325%234_668%232846%238114%231999_668%232717%237559%2384_668%231000022185%231000066058%230_668%233468%2315613%23412_668%232846%238114%231999_668%232717%237559%2384_668%233164%239976%23647_668%233468%2315613%23412) €6,5 (100 stuks) en de weerstandjes (https://nl.aliexpress.com/item/1005002275520555.html?spm=a2g0o.productlist.0.0.2c3a2f22xHQc7M&algo_pvid=null&algo_expid=null&btsid=0b0a556516158739725651281e41a2&ws_ab_test=searchweb0_0,searchweb201602_,searchweb201603_) €5,5 (Allen verzending inbegrepen). Uren leer- en speelplezier
Het leuke is dat het relatief eenvoudig is en dat je er heel veel mee kan. Het meeste is zo terug te vinden op het internet en met een beetje oefening geraak je heel ver.
Veel succes ermee.
@ Saskia ,
Begrijp ik,het gaat nu wel heel snel.ook. Je zal merken dat met een extra woordje uitleg het niet zo moeilijk te volgen is.
Ik zal vanavond na het werk, als een collega modelspoorder er vandaag al niet aan aan begonnen is, een voorbeeldstukje code posten "hoe het anders kan". Beter is een woord dat ik niet in de mond durf nemen ;). Dat moet ieder voor zich maar uitmaken.
Citaat van: patrick smout op 15 maart 2021, 23:33:13 PM
Heb je dat getest ? ;)
Wat als millis + random ( timer) bijna op max waarde staat en de volgende keer de loop doorlopen wordt millis terug naar de min waarde gevallen is. Kan voorkomen als ergens in de loop iets langer duurt en random kleine waarden geeft.
Een Arduino draait op 16Mhz en bevat een RISC processor en dus iedere instructie duurt 1 / 16 000 000 seconden. Uitvoeren van 16 instructies duurt dus 1 MICROseconde. Enige mogelijkheid is dat die millis + randomwaarde de max waarde krijgt wat al 1 kans is op een paar duizend. Daarnaast moet zijn interne teller voor de millis ook al bijna de maximum waarde hebben (rekeninghoudend dat die nog een jump naar de cmp en de cmp zelf moet doen), wat één kans is op een paar tienduizend. De kans dat die effectief na 50 dagen, 50 dagen niks doet is 1 op 1 miljoen en dus eigenlijk onbestaande. Als je dat wil testen zal dat heel lang duren.
Citaat van: stoomlokje op 16 maart 2021, 01:37:44 AM
en nu kunnen we helemaal niet meer volgen >:(
Hiervoor moet je meer van de interne werking van een processor kennen. Ik zal trachten een héél simpel voorbeeldje te geven.
Elke waarde in een processor is begrensd door hoeveel bits er in kunnen. Laat ons om het simpel te houden dat er 8 bits zijn. Dus zo'n teller kan alle waarden van 0 t/m 255 bevatten. Als je die teller elke seconde met 1 verhoogt, dan zal die na 256 seconden van 255 naar 0 gaan. Dus als je dan elke keer er een random waarde bijtelt dan kan je hebben dat hierdoor de teller "ronddraait".
Nu kan je ofwel die teller groter maken (maar daar zijn grenzen aan) of je kan de code zo aanpassen dat het geen probleem is. Of je kan bekijken wat het gevolg is en beslissen dat je met het gevolg kan leven.
Hier loopt die teller dus na 50 dagen rond. Nu of dat van die 50 dagen een probleem is, is een andere vraag. Wie laat er hier 50 dagen de spanning op zijn baan staan?
"In het echt" zijn die tellers groter waardoor hier kennelijk het probleem optreedt na 50 dagen. Maar het is iets waar je bij programmeren altijd rekening mee moet houden. Als je gaat googlen naar "year 2038" dan kan je lezen dat zo'n problemen niet zeldzaam zijn. In het jaar 2038 zal de secondenteller overlopen.
Timers kan je met software maken (tellers, en inderdaad liefst zonder delay)
Ik verkies het om een hardware-timer te gebruiken, en interrupts. Zo heb je een betrouwbaar basis-interval van bvb 10 of 100 milliseconden.
Maar het gebruikt van een timer en interrupt vraagt natuurlijk wel wat extra programmeerwerk ...
Citaat van: stoomlokje op 16 maart 2021, 01:37:44 AM
en nu kunnen we helemaal niet meer volgen >:(
Het gaat inderdaad snel, en wat door elkaar heen. Als er iets meer citaten worden gebruikt, kunnen de verhaallijnen beter gevolgd worden
Citaat van: patrick smout op 15 maart 2021, 22:14:08 PMOnder het motto, hoe kan het anders ;) ...
Een nog universelere aanpak is om alle data in arrays of structs te zetten, zowel patroon, schakeltijden, de te gebruiken uitgangen, state, starttijd en duurtijd. (1 array of structs per kanaal voor het patroon binnen één kanaal en 1 array of pointers to arrays of structs om over de kanalen te itereren)
Het voordeel van deze datadriven aanpak is dat je enkel maar tabellen moeten editeren om patronen aan te passen en de code universeel is.
Maakt niet uit welke uitgang je wil schakelen en in welke volgorde en /of duurtijd. Alles info zit in de data/tabellen.
Dat doe ik de laatste tijd vaak. Die tabellen maak ik dan aan in Excel, en daar genereer ik data-teksten mee.
Belofte maakt schuld dus ...
Even vooraf. Zoals eerder aangegeven, ik heb geen arduino's. De code compileert (voor ander platform) maar kleine aanpassingen voor arduino kunnen noodzakelijk zijn. Ik ben bv. niet zeker of digitalWrite() een variabele van type bool aanneemt als 2e parameter dus werk ik even via een tussenfunctie die dat oplost. Code kan ook aangepst worden dat in de tabellen ineens HIGH/LOW staat maar dat kon ik niet testen.
Ik heb links en rechts wat commentaar bij gezet. In het voorbeeld zijn er 3 kanalen die elk hun eigen scenario afspelen. Per stap kan je kiezen of een uitgang aan/uit moet zijn en voor hoe lang. Een kanaal koppel je aan een fysieke uitgang.
Initialisatie van de uitgangen staat niet in de code, kan men uit eerdere voorbeelden halen.
Het gedrag vn de uitgangen zit hier in data, niet in code (en is per kanaal onafhankelijk van elkaar instelbaar)
Dit voorbeeld kan nog verder opgekuist worden voor bv RAM geheugen te besparen maar dat gaat nu even te ver.
Vragen uiteraard altijd welkom, we zijn hier om te leren.
struct Scenes {
unsigned long tijd; // Tijd dat een uitgang actief/inactief is in deze stap
bool status; // Uitgang aan of uit
};
struct Kanaal {
struct Scenes *pScene; // Scenario voor dit kanaal
int scenariolengte; // Lengte van de scenario data
int uitgang; // Fysieke uitgang voor dit kanaal
unsigned long starttijd; // Moment dat de huidige stap actief is geworden
int huidigescene; // Huidige scene in scenario
bool tijdloopt; // true als we aan het wachten zijn tot de tijdverstreken is
};
// Scenario 1 bestaat uit 4 stappen
struct Scenes Scene_1[] = {
{ 1000, true }, // Uitgang x gedurende 1 seconde aan
{ 2000, false }, // Uitgang x gedurende 2 seconden uit
{ 3000, true }, // Uitgang x gedurende 3 seconden aan
{ 4000, false } // Uitgang x gedurende 4 seconden uit
};
// Scenario 2 bestaat uit 2 stappen
struct Scenes Scene_2[] = {
{ 200, true }, // Uitgang x gedurende 0,2 seconde aan
{ 200, false } // Uitgang x gedurende 0,2 seconde uit
};
// Scenario 3 bestaat uit 4 stappen
struct Scenes Scene_3[] = {
{ 100, true }, // Uitgang x gedurende 0,1 seconde aan
{ 200, false }, // Uitgang x gedurende 0,2 seconden uit
{ 500, true }, // Uitgang x gedurende 0,5 seconden aan
{ 200, false } // Uitgang x gedurende 0,2 seconden uit
};
// We hebben 3 afzonderlijke kanalen met elk een eigen scene
struct Kanaal Kanalen[] = {
{ Scene_3, sizeof(Scene_3), 1, 0, 0, false }, // Scene 3 op uitgang 1 (de 3 laatste velden zijn altijd "0, 0, false")
{ Scene_2, sizeof(Scene_2), 2, 0, 0, false }, // Scene 2 op uitgang 2 (de 3 laatste velden zijn altijd "0, 0, false")
{ Scene_1, sizeof(Scene_1), 3, 0, 0, false } // Scene 1 op uitgang 3 (de 3 laatste velden zijn altijd "0, 0, false")
};
void zetuitgang(int uitgang, bool status)
{
if(status)
{
digitalWrite(uitgang, HIGH);
}
else
{
digitalWrite(uitgang, LOW);
}
}
void loop()
{
int HuidigKanaal;
// Voor kanaal 0 t.e.m. het aantal kanalen
for (HuidigKanaal = 0; HuidigKanaal<sizeof(Kanalen)/sizeof(struct Kanaal); HuidigKanaal++)
{
// Loopt de tijd al voor dit kanaal?
if(Kanalen[HuidigKanaal].tijdloopt==false)
{
// Zet uitgang x overeenkomstig stapwaarde
zetuitgang(Kanalen[HuidigKanaal].uitgang,Kanalen[HuidigKanaal].pScene[Kanalen[HuidigKanaal].huidigescene].status);
// Volgende stap is wachten ...
Kanalen[HuidigKanaal].starttijd = millis();
Kanalen[HuidigKanaal].tijdloopt = true;
}
else
{
if(millis() - Kanalen[HuidigKanaal].starttijd > Kanalen[HuidigKanaal].pScene[Kanalen[HuidigKanaal].huidigescene].tijd)
{
// tijd is vertreken
Kanalen[HuidigKanaal].tijdloopt = false;
// Volgende scene - Indien einde van de reeks begin dan opnieuw
if( ++Kanalen[HuidigKanaal].huidigescene >= Kanalen[HuidigKanaal].scenariolengte/sizeof(struct Scenes))
{
// begin terug met scenario 0 voor dit kanaal
Kanalen[HuidigKanaal].huidigescene = 0;
}
}
}
}
}
Citaat van: deevie op 16 maart 2021, 09:12:50 AM
Als je dat wil testen zal dat heel lang duren.
unsigned long MyMillis()
{
return millis()+ (0xffffffff - 5000);
}
50 dagen wachten kost teveel geld en is ook saai. Tussen 1 en 0xffffffff gebeurt er niets interessant. We focussen dus op boundary testing.
Vervang de aanroepen naar millis() door mymillis() en 5 seconden na opstart kan je eventuele sideeffects zien.
Bij "Timertick" tellers in een interrupt routine initialiseer je de beginwaarde ook op MAX-5000 en niet op 0. Zo krijg je gratis en voor niks interessante overgangen tijdens het ontwikkelen zonder dat je hoeft te wachten.
Overigens kost het geen moeite om dingen ineens goed te coderen. Bespaart je de kopzorgen of een besturing wel/niet 50 dagen of een andere onbekende periode ingeschakeld moet blijven.
Woha! Pointers, structs en bewerkingen daarop. Hier heb ik een dagje nodig om er terug in te komen. Enige die ik mis is "->" ... En dat is te lang geleden zonder terug in de boeken te duiken en tekeningskes te maken, hier gaan er veel op afhaken.
En als ik nu echt eerlijk moet zijn... Voor wat ik van plan ben ga ik naar zo'n dingen terug moeten gaan. Maar voor een Arduino die in enkele huisjes licht aan en uit moet laten gaan...
Voor mij gaat het in alle geval stukken te rap maar er staat begrijpbare uitleg bij, waarvoor dank, dus kan ik wellicht later bijbenen :-)!
CiteerOverigens kost het geen moeite om dingen ineens goed te coderen.
Patrick sorry hoor, maar dat klinkt toch een beetje elitair, al zal het zo wel niet bedoeld geworden geweest zijn.
Het kost
iedereen moeite om voor zichzelf uit te maken wat
goed is. Dan mag het over coderen gaan of over het lasersnijden van styreenplaat of over het spuiten van de make-up van een hoerke in de Aarschotstraat of over het 3d-printen van een TGV-koppeling.
Maar wat men ook voor zichzelf vastlegt als
goed het zal altijd moeite kosten om te bereiken.
Dag Karel,
kleine toelichting, mijn opmerking "dingen ineens goed te coderen." kadert binnen de opmerkingen rond de overflow van millis().
Daar waren oplossingen met functionele problemen en dat kan je beter ineens goed doen.
Dat had ik beter kunnen duiden - bij deze misverstand uit de wereld ;).
Top, Patrick. Pintje? ;)
Slagen we zeker niet af - schol ;D
Citaat van: Karel A.J. op 16 maart 2021, 21:53:07 PM
CiteerOverigens kost het geen moeite om dingen ineens goed te coderen.
Patrick sorry hoor, maar dat klinkt toch een beetje elitair, al zal het zo wel niet bedoeld geworden geweest zijn.
Waarschijnlijk niet, en ik kan Patrick geen ongelijk geven. Maar toch wel enkele bedenkingen:
- om op dat detail te gaan programmeren moet je al verdomd veel weten over de hardware. Meer dan 75% van diegenen die een arduino of andere processor
als bijzaak in hun hobby gaan gebruiken weten dat niet. En hebben er ook geen interesse of noodzaak aan.
- alhoewel het principe ongetwijfeld correct is, blijft de vraag hoe belangrijk het is voor een LED sturing van huisjes op een treinbaan... Moesten we hier nu over iets bezig zijn zoals een machinesturing, medisch toestel, een raket... ja, dan ongetwijfeld. Maar de vraag is of er iemand ooit iets van zal merken als dit niet 100% is. en zelfs dan of er ooit iemand meer zal zeggen dan "dat is raar....".
- laat ons niet het doel uit het oog verliezen. Ergens is er een "return on investment". Ik kan begrijpen dat mensen die professioneel met software bezig zijn dit correct willen. Maar er zijn er ook die alleen wat lichtjes in een huisje willen zien aan en uit gaan.
Helemaal akkoord Johan en dat is het leuke aan deze hobby. Iedereen beleeft die op zijn manier.
Ik krab me wel eens in de haren als ik opmerkingen lees of ruitenwissers van een loc nu bovenaan of onderaan horen vastgemaakt te zijn maar verder geef ik de ruimte aan iedereen om daar anders over te denken. Ondertussen leer ik wat bij en dat is ook mooi meegenomen (al wil dat niet zeggen dat ik het allemaal onthoud ;) ).
Citaat van: Dirky op 16 maart 2021, 21:24:02 PM
Voor mij gaat het in alle geval stukken te rap maar er staat begrijpbare uitleg bij, waarvoor dank, dus kan ik wellicht later bijbenen :-)!
Dag Dirk, herkenbaar voor mij maar dan op een ander vlak. Scenery is voor mij volledig buiten mijn comfortzone en enige vooruitgang bij mij gaat tergend langzaam (en regelmatig ook achteruit). Als ik dan zie wat jij en anderen uit hun hoed toveren, daar kan ik enkel maar van dromen.
Neemt niet weg dat ik op eigen tempo mijn grenzen wat probeer te verleggen maar wat voor de één een molshoop is, is voor de ander een berg. ;)
Ik wil de code zeker nog wel verder in detail toelichten mocht het je (of iemand anders) interesseren.
Citaat van: Havoc op 16 maart 2021, 22:13:35 PM
Citaat van: Karel A.J. op 16 maart 2021, 21:53:07 PM
CiteerOverigens kost het geen moeite om dingen ineens goed te coderen.
Patrick sorry hoor, maar dat klinkt toch een beetje elitair, al zal het zo wel niet bedoeld geworden geweest zijn.
Waarschijnlijk niet, en ik kan Patrick geen ongelijk geven. Maar toch wel enkele bedenkingen:
- om op dat detail te gaan programmeren moet je al verdomd veel weten over de hardware. Meer dan 75% van diegenen die een arduino of andere processor als bijzaak in hun hobby gaan gebruiken weten dat niet. En hebben er ook geen interesse of noodzaak aan.
- alhoewel het principe ongetwijfeld correct is, blijft de vraag hoe belangrijk het is voor een LED sturing van huisjes op een treinbaan... Moesten we hier nu over iets bezig zijn zoals een machinesturing, medisch toestel, een raket... ja, dan ongetwijfeld. Maar de vraag is of er iemand ooit iets van zal merken als dit niet 100% is. en zelfs dan of er ooit iemand meer zal zeggen dan "dat is raar....".
- laat ons niet het doel uit het oog verliezen. Ergens is er een "return on investment". Ik kan begrijpen dat mensen die professioneel met software bezig zijn dit correct willen. Maar er zijn er ook die alleen wat lichtjes in een huisje willen zien aan en uit gaan.
En daarom opnieuw mijn vraag over dat item van Modelbouwled dat intussen spoorloos is. Met die post is het hele gedoe hier begonnen. Het ding kost minder dan een Arduino en doet wat het moet: het licht willekeurig laten aangaan, op acht verschillende plaatsen. Al wat je moet kunnen is stekkertjes versteken.
Minder dan €7?
Citaat van: svvander op 17 maart 2021, 08:33:05 AM
Minder dan €7?
Hangt er vanaf waar ge uwe Arduino koopt hé. Als ge de Chinese industrie wil steunen komt ge er soms zelfs goedkoper vanaf.
Citaat van: svvander op 17 maart 2021, 08:33:05 AM
Minder dan €7?
Ik heb daar geen aandelen in hé, om duidelijk te zijn! ;D
https://www.modelbouwled.nl/contents/nl/d14_led_verlichting_huijes_schraal_n_h0_modelspoor.html
Citaat van: Karel A.J. op 16 maart 2021, 21:53:07 PM
CiteerOverigens kost het geen moeite om dingen ineens goed te coderen.
Patrick sorry hoor, maar dat klinkt toch een beetje elitair, al zal het zo wel niet bedoeld geworden geweest zijn.
Het kost iedereen moeite om voor zichzelf uit te maken wat goed is. Dan mag het over coderen gaan of over het lasersnijden van styreenplaat of over het spuiten van de make-up van een hoerke in de Aarschotstraat of over het 3d-printen van een TGV-koppeling.
Maar wat men ook voor zichzelf vastlegt als goed het zal altijd moeite kosten om te bereiken.
Ik vind het alvast héél hautain overkomen. Mensen willen een positieve bijdrage leveren met zo weinig mogelijk code om begrijpbaar te zijn voor iedereen en die in praktijk eigenlijk perfect werkt voor het doel. Ik vind ook als je kritiek hebt ivm goed coderen dat je bvb zelf steeds het goede voorbeeld moet geven en dus de moeite moet doen om bij voorbeeld te kijken of de digitalWrite-functie boolean-waarden accepteert. Dat gedrocht met die zetuitgang-functie is dus absoluut not done.
Bedankt voor de constructieve bijdrage.
Ik neem het mee in mijn volgend progamma voorbeeld.
Ok... ik ben verder aan het prullen om licht in mijn station te krijgen. En vermits de manier waarop ik mijn baan wil aansturen nog lang niet af is EN ik voor een ander projectje een arduino wil gebruiken heb ik iets ineen geprutst om wat random licht te hebben.
Omwille van wat ik nodig heb voor het andere (niet-trein) projectje ben ik vertrokken met een Arduino Nano Every. Die heeft maximaal 20 uitgangen. Dus heb ik er iets van gemaakt dat gewoon die 20 uitgangen aan en uit zet in een relatief random patroon. Het is al wat ingewikkelder dan de allereerste simpele sketch maar nog wel begrijpelijk denk ik. Er is ook overvloedig commentaar in gezet. Hier is de hele zooi:
// geef aan hoeveel uitgangen gebruikt worden, er wordt verondersteld in volgorde gebruikt worden
#define aant_lichtptn 6
// stel in hoelang een timer_tick is in milliseconden
#define timer_tick 1000
// de maximale aantal ticks dat een timer kan lopen
#define max_ticks 30
// de minimale aantal ticks dat een teller kan lopen
#define min_ticks 5
/*
gebruik van de uitgangen:
D2= bureau_chef
D2= bureau;
D4= wachtzaal;
D5= gang
D6= dortoir
D7= badkamer
*/
int x; //teller voor alle werk
int lichtpunten[] = {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21}; //alle 20 bruikbare IO uitgangen van de Audiono Nano Every
int status_lamp[aant_lichtptn]; //houdt bij of de lamp aan (=1) of uit (=0) is
int timer[aant_lichtptn]; //voor elke lamp loopt een timer (in timer_ticks)
void setup() {
// put your setup code here, to run once:
for(x=0;x<aant_lichtptn;x++){ //zet alle gebruikte uitgangen in een gekende begintoestand
pinMode(lichtpunten[x],OUTPUT); //zet de pin als uitgang
digitalWrite(lichtpunten[x],LOW); //zet de lamp uit
status_lamp[x]=0; //zet de staus van de lamp op uit (=0)
timer[x]=random(1,max_ticks); //geef de lamp een starttimer tussen 1 en max_tick timer ticks
}
}
void toggle(int lamp){ //bedien de lampschakelaar
if(status_lamp[lamp]==0){ //als de lamp uit is
digitalWrite(lichtpunten[lamp],HIGH); //zet ze aan
status_lamp[lamp]=1; //zet de status op 1 (=aan)
}
else{ //als de lamp niet uit is (dus is ze aan)
digitalWrite(lichtpunten[lamp],LOW); //zet de lamp uit
status_lamp[lamp]=0; //zet de status op 0 (=uit)
}
}
void loop() {
// put your main code here, to run repeatedly:
delay(timer_tick); //wacht 1 timer_tick en handel de timers af
for(x=0;x<aant_lichtptn;x++){
timer[x]=timer[x]-1; //verlaag de timer voor de lamp met 1 tick
if(timer[x]<0){ //test of de teller is afgelopen
toggle(x); //als de timer afgelopen is, schakel de lamp om
timer[x]=random(min_ticks,max_ticks); //en stel een nieuwe teller in tussen min en max aantal ticks
}
}
}
Wat bijkomende uitleg:
- "#define aant_lichtptn 6": een #define is eigenlijk iets dat de compiler vertelt dat vòòr de compilatie moet beginnen alles waar de tekst "aant_lichtptn" voorkomt dit moet vervangen worden door de tekst "6". Daarom ook dat er geen commentaar achter staat want al wat er achter komt wordt er vervangen. Dus voor de veiligheid, niets erachter maar de commentaar erboven. Ik ga maar 6 van de 20 uitgangen gebruiken. Maar ze zijn wel allemaal gedefinieerd. Je zou dat ook kunnen doen door een variabele te definiëren en die de waarde 6 te geven. Maar deze manier gebruikt gaan geheugen voor die variabele op te moeten slaan.
- ik werk met "timer_ticks". Elke keer dat de hoofdlus van het programma doorlopen wordt is 1 timer tick. Dit vermiijdt het probleem van de milliseconden teller die "overloopt". Door nu te zeggen hoelang een timer_tick duurt en hoelang een timer maximaal en minimaal mag zijn kan je de werking aan je smaak aanpassen. In mijn geval is dat om de seconde is er 1 tick (1000 milliseconden). En een timer moet minimaal 5 ticks zijn en maximaal 30 ticks. Dus een lamp moet minimaal 5x1000 milliseconden aan of uit zijn en kan maximaal 30x1000 milliseconden aan of uit zijn.
- er is een blok commentaar dat me er aan herinnert welke uitgang waar naartoe moet.
- alle 20 uitgangen zijn te gebruiken, je moet maar zeggen hoeveel je er echt gebruikt. Hoeft eigenlijk niet, die cpu is snel genoeg maar voor de volledigheid toch maar gedaan.
- de functie "toggle" heeft als enige doel te kijken of een lamp aan of uit staat en die dan uit of aan te zetten. Hij "togglet" de lamp. Net zoals je een schakelaar bedient: als de lamp uit is en je bedient de schakelaar, dan is de lamp uit. En omgekeerd. En tegelijk zet je in de lijst "status_lamp" of de lamp nu aan of uit is.
- de tellers van de for-lus lopen van 0 tot (aantal_lichtptn-1). Dit is een gevolg van het gebruik van arrays in de de programmeertaal C. Arrays beginnen altijd te tellen bij 0.
De werking is simpel:
- in een lijst (array "status_lamp") houden we bij of de lamp aan of uit is.
- in een andere lijst (array "timer") houden we voor elke lamp een teller bij. De rest van de uitleg is voor 1 teller/timer maar alle uitgangen werken op hetzelfde principe
- bij het begin zetten we alle lampen uit en we zetten voor elke lamp een timer in met een waarde ergens tussen het 1 en maximum. Waarom 1 en niet het minimum (5 in het voorbeeld)? Wel, dan kunnen we hebben dat er misschien lampen direct aangaan, anders moeten we steeds het minimum wachten.
- vermits de cpu toch niets anders te doen heeft laten we die gewoon wachten tot er een nieuwe timer_tick is.
- we verlagen de teller en kijken of die af gelopen is
- als die afgelopen is dan zetten we de schakelaar om (roepen de functie "toggle" aan voor die lamp) en stellen een random nieuwe timer in
Bekijk het als een hele reeks schakelaars (array "staus_lamp") waar boven elke schakelaar een keukentimer staat. Alle schakelaars staan uit en we geven aan elke keukentimer een draai. En dan wachten we.... telkens als een timer afloopt, dan zetten we de schakelaar om en geven een nieuwe draai aan de keukentimer.
Oh ja, nog een late bedenking: door het gebruik van die timer_ticks kunnen we de algemene "klok" van onze modelwereld sneller of trager laten lopen zonder overal tijden (in milliseconden) te moeten gaan aanpassen.
Pas op met #define, die vervangt letterlijk overal tekst. Dus als je schrijft "#define a 5", dan wordt "int aantal" vervangen door "int 55nt5l". Verschiet niet als je dan rare dingen krijgt. Daarom dat normaliter bij een #define de te vervangen tekst in hoofdletters geschreven wordt. Maar ik ben tegenwoordig te lui.... Dus eerder "#define AANT_LICHTPTN 6". Kwestie van de aandacht erop te trekken dat dit een tekst is die vervangen zal worden.
En ik haat die lower camelcase die ze gebruiken voor hun voor gedefinieerde functies!
Die toggle functie heb je eigenlijk niet nodig. Als je een pin als output definieert kan je de status ervan inlezen via digitalRead. Daarnaast zijn de outputs altijd low wanneer de Atmel van stroom voorzien wordt, dus eigenlijk niet nodig om die LOW te schrijven.
Citaat van: deevie op 21 maart 2021, 22:10:58 PM
Die toggle functie heb je eigenlijk niet nodig. Als je een pin als output definieert kan je de status ervan inlezen via digitalRead. Daarnaast zijn de outputs altijd low wanneer de Atmel van stroom voorzien wordt, dus eigenlijk niet nodig om die LOW te schrijven.
Heb het snel eens geprobeerd. Als ik de status_lamp array weglaat, de toggle functie weglaat en vervang door digitalWrite(x,!digitalRead(x)) dan gebruik ik 12 bytes minder geheugen voor variabelen (de array die weg is). Maar wel 28 bytes meer programma geheugen (de functie digitalRead moet erbij komen).
Het meer bijzondere is als je de digitalWrite(x,LOW) weglaat in de setup. Dan worden er plots 86 bytes minder programma geheugen gebruikt! Dit is heel eigenaardig want de digitalWrite wordt verderop nog gebruikt dus de functie moet in het eindprogramma zitten. Kennelijk is die setup niet zo efficiënt. Zelf heb ik de neiging om die er te laten staan. In princiepe kan je dan de setup zelf aanroepen om de boel ergens in je programma te resetten.
Nu ja, allemaal nogal accademisch, Elke variant gebruikt maar 4% van het programma geheugen en 0% van het dynamisch geheugen (voor variabelen). Leesbaarheid en onderhoudbaarheid hebben ook belang vind ik.