Dan ga me eens afvragen of de led draaien op een variable led kan beginnen.
Zodat als de draairichting verandert, het verandert op de laatste led die brandde in plaats van de eerste led op dit moment.
Zou ik om dit op te lossen , de beginvariable van de loop variabel kunnen maken en dan na de loop het terug zetten naar de standaardwaarde ?
void turnRight() {
for (uint8_t cnt = 0; cnt < sizeof(ledPins); cnt++)
{
digitalWrite(ledPins[cnt], LOW);
if (cnt == 0) {
digitalWrite(ledPins[sizeof(ledPins) -1] , HIGH);
} else {
digitalWrite(ledPins[cnt -1], HIGH);
}
delay(500);
}
}
of ik ga ik dan zaken in de war brengen voor de compiler ?
Zou je dezelfde code nog eens willen posten, maar dan met bij elke regel een commentaar erbij welke laat zien wat jij denkt dat daar gebeurt.
Ik heb een reden voor deze vraag, maar die zal ik voor nu nog even niet verklappen.
Je bedoeld de huidige code?
IK kan die posten met uitleg.
''''
void turnRight() { // functie turnRight zodat de led rechtsom draaien,
for (uint8_t cnt = 0; cnt < sizeof(ledPins); cnt++) // loop om te bepalen welke led aan of uit gaat.
{
digitalWrite(ledPins[cnt], LOW); // zet de led op die op positie led[cnt] op aan
if (cnt == 0) { // als de counter 0 is.
digitalWrite(ledPins[sizeof(ledPins) -1] , HIGH); // zet de led op positie ledPins[sizeof(LedPins) - 1 op uit.
} else { // en anders
digitalWrite(ledPins[cnt -1], HIGH); // zet de vorige led uit
}
delay(500); // wacht 500 ms oftwel een halve seconde
}
}
@MAS3 Ik hoop dat dit is wat je bedoeld
Dat is ongeveer wat ik vroeg, ja.
De vraag werd gesteld, omdat wanneer je commentaar bij je code voegt (zeker wanneer je dat achteraf doet), je nog eens na moet denken over wat er daar gebeurt.
Jouw commentaren bij de regels zijn anders dan hoe ik ze zou maken, maar dat mag niet veel uitmaken.
Uit jouw commentaren kan ik niet veel halen waar je tijdens het maken ervan ook al aan de toekomstige uitbreidingen hebt gedacht.
Nu een aanwijzing voor wat je wil bereiken.
Je hebt vast al door dat ik vaak op "onthouden" timmer.
Je kunt niet zomaar met een variabele aan de gang.
Dat komt omdat je in de functie de variabele cnt definieert.
Zodra je de functie verlaat, vervliegt deze variabele.
Daarom denk ik dat je complete sketch die je in post #35 hebt staan, niet zal werken.
Maar wat je wel kunt doen, is een aantal zaken verwerken tijdens je code.
Een for loop is net zoals blink een blokkerende code.
Die loop doet tijdens het uitvoeren niets anders dan die for loop.
Tijdens loop() (het begint al verwarrend te worden), roep je alleen turn left aan, dus dat werkt prima maar je komt daar nooit meer uit.
Voeg in loop() maar eens een delay toe (debuggen is een van de weinige goede redenen om delay te gebruiken).
Dan zie je dat er een ronde gedraaid wordt, en daarna die delay optreedt.
Dat moet dus anders.
Om dit te doen, kun je dan je count waarde globaal maken, zodat deze niet zal vervliegen.
Daarna kun je dus gaan controleren (hoe je dat ook zou willen implementeren) of de richting al met veranderen.
En dan roep je de betreffende richting functie aan om 1 enkele stap te zetten.
Want je wil wel kunnen blijven controleren of er niet iemand de hele tijd aan die knop zit te friemelen.
Dat werkt dan dus omdat de variabele globaal is en daarmee niet vergeten zal worden.
Maar het betekent wel dat je de code toch wel stevig zal moeten aanpassen, want hoe ga je anders de juiste pinnen aansturen ?
Voor het antwoord op die laatste vraag ben je al een heel eind onderweg, want een deel van de oplossing heb je al getoond in deze thread (en dat heeft te maken met een overflow, welke je aan 2 kanten kunt krijgen en dus ook 2 keer moet afvangen).
Ik hoop dat je hiermee verder kunt en ik niet teveel maar ook niet te weinig heb verteld.
Toen ik het commentaar deed, dacht ik al te zien dat ik een globale variable nodig had.
Enigste waar ik goed over moet nadenken is dit
Laten we zeggen dat de gebruiker het op rechts naar links heeft gezet toen de 4e led brandde.
Dan moet de volgende keer het naar links draaien ook op de 4e beginnen.
Daar zie ik geen probleem. Globale variable op 4 zetten en de loop daarmee laten beginnen.
maar de volgdende "ronde" moeten de leds weer gewoon beginnen bij het begin dus bij 0 of 6 behalve als de gebruiker de richting weer verandert.
Hier moet ik even goed over nadenken hoe dat in code te krijgen.
Edit 1 :
Misschien een idee om een globale variable te gebruiken om bij te houden of de richting verandert is.
En de delay te veranderen in de millis() functie ?
Je hebt niet alles wat ik verteld heb, begrepen zoals ik het bedoelde denk ik.
Dus dan ben ik niet voldoende duidelijk geweest.
De delay() die hier hebt staan mag je gewoon behouden want dat gaat hier het probleem niet vormen omdat de sketch alleen beperkt is tot het mooi aansturen van de LED's.
Ik denk wel dat een halve seconde een beetje een grote delay is, maar daar kun je gerust mee spelen en het geeft je letterlijk meer tijd om te zien wat er gebeurt met je LEDs.
Ik had het over blokkerende code, en dat daar meer varianten van zijn dan delay().
In dit geval is dat de for ... next loop.
Ik raadde je ook aan om 1 seconde delay() in te bouwen, zodat je kunt herkennen wat er gebeurt.
Maar omdat de delay() in turnLeft al 500 milliseconden is, raad ik je nu aan om in loop() 4 of 5 seconden toe te voegen.
Dan zul je dus zien dat turnLeft altijd 3 seconden doet om een rondje te draaien, en dan die 5 seconden hangt om daarna nog een rondje te doen.
Je wil tijdens loop() kijken of er aan de de knop gedraaid is, en of je daar dan ook nog wat mee moet doen.
Dat kun je in loop() doen, maar jouw voorkeur gaat uit naar overzichtelijke bouwblokken, dus dan kun je daar ook een aparte functie voor bouwen.
Ook hier moet je dan wel weer bedenken dat je meerdere dingen moet onthouden en verwerken of aanpassen.
Wanneer je je teller globaal gemaakt hebt, dan maak het niet meer uit wat de inhoud van de teller is en op welk moment dat is.
Maar dit betekent ook dat je niet (zoals je nu wel doet) in turnLeft of turnRight een heel rondje moet draaien, maar slechts 1 enkele stap moet zetten.
Daarna kijk je of er nog steeds naar dezelfde kant gedraaid moet worden en zet je aan de hand daarvan, de volgende stap (in welke richting dat dan ook is).
Wanneer je duizelig wordt van dit gedraai (een poging tot een grapje van mij), kun je eens proberen om de stappen te visualiseren.
Bijvoorbeeld door een stapeltje post it memo's te pakken en daar dan per stuk je functies in te zetten.
En dan bedoel ik alle functies, dus ook setup() en loop().
Misschien kun je nu door die post it's een beetje te shuffelen, wat meer inzicht krijgen in wat je wel en niet zou kunnen doen.
Je mag hierbij voor bepaalde functies ook een aantal kopieën maken, wanneer deze functies op verschillende moment zouden worden aangeroepen.
Gewoon old school tech dus.
Dank je.
Moet even alles op me laten inwerken.
jij denkt op een hele andere manier als ik
Oke
Als ik je goed begrijp, "moet" ik gaan bijhouden welke led brandt.
Dan kijken welke richting ik op wil en daarmee besluiten welke led het volgende is die moet branden en welke dan uit moet.
Dan vraag ik me af of ik dan nog turnLeft en Turnright nodig heb , maar dat zullen we dan zien,
Als ik jouw goed snap, is jouw oplossing veel simple dan de mijne.
Oud probleem dat ik altijd ga voor een complexe oplossing en zaken overdenk.
Ik ben het met je eens over de noodzaak van de aparte functies voor een richting.
Misschien kun je daarvoor in de plaats een functie maken die de volgende stap in het oplichten van je cirkel zet.
En je moet van mij helemaal niets hoor, ik doe alleen wat voorstellen (wellicht ben ik dan wat stellig dat dat dan de beste aanpak is).
Het is helemaal prima als jij een eigen aanpak bedenkt die uiteindelijk ook werkt en wie weet is dat wel slimmer en/of overzichtelijker.
Slimmer / overzichtelijker zeker niet.
Zou ook kunnen. Een functie die de volgende stap zet in het oplichten.
Ben altijd jaloers op dat jij en @sterretje veel makkelijker oplossingen kunnen bedenken als ik.
Denk dat ik langzamerhand eens moet gaan beginnen om jouw idee werkend te krijgen.
En kijken waar het schip strandt. Hopelijk als ik dit werkend krijg , wordt het ook makkelijker om het "nagloeien" te implementeren.
En ik zat te denken om later de snelheid ook variabel te maken.
Zo dichter bij de 0 of 1023 hoe sneller het draaien gaat. Denk te samen met het "nagloeien" dit een mooi effect geeft.
Chips
Code werkt niet zoals ik het geschreven heb na jouw uitleg.
Wat doe ik hier verkeerd :
const uint8_t ledPins[] = {9, 11, 10, 6, 3, 5};
byte Potpin = A3;
int Potvalue ;
int currentLed = 0;
void setup() {
Serial.begin(115200);
for (uint8_t cnt = 0; cnt < sizeof(ledPins); cnt++)
{
digitalWrite(ledPins[cnt], HIGH);
pinMode(ledPins[cnt], OUTPUT);
}
}
void loop() {
Potvalue = analogRead(Potpin);
if (Potvalue < 512) {
digitalWrite(ledPins[currentLed - 1], LOW);
if (currentLed == sizeof(ledPins)) {
digitalWrite(ledPins[0] , HIGH);
currentLed== 6;
} else {
digitalWrite(ledPins[currentLed], HIGH);
--currentLed ;
}
Serial.println(currentLed);
delay(500);
}
}
currentLed gaat nu alleen van 6 naar 5 naar 6.
Maak ergens een denkfout maar zelfs met debuggen die ik niet hoe het op te lossen.
Wat zeggen de afdrukken in de seriële monitor? Ik denk zoals hieronder
De eerste keer is de waarde van currentLed 0 en als de potmeter onder de 512 blijft wordt dat nummer verlaagd.
-1
-2
-3
...
...
-32768
0
+1
+2
...
Het zal ongeveer 64000 x 500 ms duren voordat je ergens in de buurt van currentLed == sizeof(ledPins) komt.
Ik heb dat al gemerkt.
Dit gaat de goede richting op qua werking alleen draairen de leds nu de verkeerde kant op
En de currentLed blijft 6
Zo verder debuggen hoe dit nu kan.
Code ;
void loop() {
Potvalue = analogRead(Potpin);
if (Potvalue < 512) {
digitalWrite(ledPins[currentLed - 1], LOW);
if (currentLed == sizeof(ledPins)) {
digitalWrite(ledPins[currentLed] , HIGH);
currentLed== 0;
} else {
digitalWrite(ledPins[currentLed -1 ], HIGH);
++currentLed ;
}
Serial.println(currentLed);
delay(500);
}
}
Dit doet niets. == is een vergelijking, = is een toekenning.
Ik denk dat ik al eens eerder had voorgesteld om ook in de IDE te compileren. Het resultaat (warning level op all gezet).
C:\Users\bugge\AppData\Local\Temp\.arduinoIDE-unsaved202544-6444-gy84aw.tw3s6\sketch_may4b\sketch_may4b.ino: In function 'void loop()':
C:\Users\bugge\AppData\Local\Temp\.arduinoIDE-unsaved202544-6444-gy84aw.tw3s6\sketch_may4b\sketch_may4b.ino:28:17: warning: statement has no effect [-Wunused-value]
currentLed== 0;
~~~~~~~~~~^~~~
klopt.
Kun je dan in de ide compileren zonder een board te hebben ??
Bijna klaar met dit gedeelte
Alleen slaat die nu de laatste led over
void loop() {
Potvalue = analogRead(Potpin);
if (Potvalue < 512) {
digitalWrite(ledPins[currentLed - 1], LOW);
if (currentLed == sizeof(ledPins)) {
digitalWrite(ledPins[sizeof(ledPins) -1] , HIGH);
currentLed= 0;
} else {
digitalWrite(ledPins[currentLed - 2 ], HIGH);
++currentLed ;
}
Serial.println(currentLed);
delay(500);
}
}
Ja
Er gaat meer fout 
Denk even na wat er gebeurt als currentLed nul is.
In dat stukje zou currentLed negatief worden en die bestaat niet.
Ik dacht dat op te lossen door currentLed op 1 te zetten dan , maar dat lost het probleem ook niet op.
Lijkt erop dat led 6 aan gaat en direct weer uit.
pfff, gebruik de code van de oude Turn functies die werkte maar nu met maar 1 led het probleem niet oplossen. 