Hoe maak ik een staart met led ?

Vervolg op Cirkel of leds ? - #113 by roelofw

Waar ik tegenaan hang met de staart is dat als je bijvoorbeeld rechtsom draait , de index negatief kan worden op verschillende plaatsen.
Daarom denk ik dat ik een heleboel if then's nodig heb om dat te vermijden.

Ik denk dus aan 4 leds die hoe verder weg hoe "vager" ze branden.

dus zoiets als dit

ronde         led1       led2     led3         led4          led5           led6 
1             100%        75%      50%         25%          0%(uit)      0%(uit)
2             75%          50%      25%         0%(uit)     0%(uit)      100% 
3             50%          25%      0%(uit)    0%(uit)     100%          75%
4             25%          uit       uit        100%       75%            50%
5             uit          uit      100%        75%        50%            25%
6             uit          100%     75%          50%       25%            uit

Ga terug na ronde 1

met de percentages bedoel ik de brightness. Zo ik weet dat ik dan naar analogWrite moet gaan.

Ik hoop dat mijn idee duidelijk is.

Dit is niet relevant voor de vraag :wink: Ik had wat duidelijker moeten zijn. Je kunt het misschien vervangen door een andere tekst die je vraag wat duidelijker weergeeft.

De URL moet eigenlijk in de tekst en niet in de titel; als je deze in de tekst plaatst kunnen menser er op klikken.

Verandert. Hoop dat het nu goed is

1 Like

Een hele hoop if/then maakt je programma serieus onoverzichtelijk. Één van de beter oplossingen is vermoedelijk om een array te creëren met de intensiteiten (in bv. oplopende volgorde). Voor de currentLED kun je dan maximale intensiteit kiezen, voor de led ervoor (of erna) de iets lagere intensiteit enz.

Het is een gedachte, niks uitgewerkt.

PS
Op welk forum heb je het programma van Cirkel of leds ? - #110 by roelofw gekregen? Er is https://www.arduinoforum.nl/ maar dat is op sterven na dood :cry:

Oke

Daarom maak ik ook deze topic.
Brainstormen over een goede oplossing en leren hoe je dit aanpakt.

De verkorte code heb ik hier weg: Can this code be smaller - #29 by roelofw

Deze heb ik nu gesloten omdat ik in het Nederlands beter kan uitleggen wat ik bedoel .

OK, ik dacht dat het om een ander forum ging, niet om een andere categorie op dit forum.

Succes met puzzelen.

Dank je.

IK hoop dat @MAS3 nog goede ideeën heeft.
Maar jouw idee van een array gebruiken kan denk ik heel goed werken.
Wordt het wel gemakkelijker van om getallen te veranderen.

Laat het eens op me inwerken

@sterretje trek ik de goede conclusie dat jij me niet gaat helpen omdat ik op het Engels forum heb gevraagd ?

Verkeerde conclusie.

Dat succes toewensen was serieus.

Ik heb nu geen tijd om direct te antwoorden, maar ga een voorstel doen voor het vervolg.
Dat is zonder array omdat ik destijds nog helemaal niets wist van arrays, en het ook niet nodig had hiervoor
Zoveel if ... then is er ook niet voor nodig.
Maar moet er wel even de tijd voor nemen dus dat wordt later vandaag of morgen.
4 nagloei voor 6 LEDs vind ik wat veel maar het maakt verder niets uit.

Bedankt,

Het hoeft geen 4 leds te zijn maar het effect moet wel duidelijk zijn.
Net zoals de getallen die mogen ook veranderen.

Het gaat mij om het feit dat er een staart komt die langzaam vervaagt.
En hoeveel lampen en wat de brightness precies moet zijn is niet zo heel belangrijk.

Neem alle tijd die je nodig hebt om me zaken goed uit te leggen.

@MAS3

oke,

Wilde even zeker weten.
Vindt het in het normale leven al moeilijk om mensen te lezen en op een forum is het helemaal een crime met mijjn k*n autisme

Ok, hier komt een aardig lang verhaal.
Lees het eerst even helemaal door, en dan nog eens (een paar keer) en misschien in kleinere stappen.
Probeer niet alles wat ik hier noem in 1 keer te verwerken, want daarmee zou je eenvoudig het overzicht weer kunnen kwijtraken.

Jij neemt aan dat je erg veel if ... then regels moet maken om overflows te voorkomen, omdat je nu een helderheid wil maken voor 4 LEDs en de andere 2 uit wil zetten.
Die andere 2 uitzetten zal geen probleem zijn.
Maar voor de overigen begrijp ik wel waarom je dat denkt.
Ik vertel je nu dat je helemaal niet zoveel if ... then hoeft te doen.
Maar je moet wel wat onthouden (heb je 'm weer).
Wat je eerst gaat doen is de overflow aan de onderkant en aan de bovenkont voorkomen.
Omdat we in een cirkel gaan, wordt de overflow aan de bovenkant gereset naar de onderkant, en aan de onderkant gaat 'ie naar de bovenkant.
Dat hadden we al onder controle.
De rest doe je dan door dat onthouden.

Daarvoor heb je naast currentLed, wat meer variabelen nodig.
Ik noem die dan maar trail,trail1 en trail2 (trail als in nagloei spoor).
In het begin geef je currentLed een startwaarde mee, zeg maar 2 (ongeveer in het midden dus, maar daar mag jij van maken wat je wil).
Alle trails zet je daar op dezelfde waarde omdat je ergens moet beginnen.

Nu ga je bepalen weke uitgang er welke waarde moet krijgen.
Dat doe je door met de laatste waarde te beginnen, daar is een reden voor.

Eerder heb ik al eens genoemd dat je het menselijke lichaam met logarithmische waardes het best bedient.
Dat betekent dat wat je eerder voorstelde met 100 %, 75 %, 50 % en 25%, je wel een verloop ziet, maar dat je met die stappen niet mooi gelijkmatige toenames ziet.
Daarom denk ik eerder aan 100%, 46%, 21% en 10% (dat zijn natuurlijk geen willekeurige waardes, maar heb ik opgezocht).
Deze percentages zijn dus de helderheden die je dan zou aansturen.
Vertaald naar de analog outputs krijg je dan 255, 117, 54 en 25.
Wat je daar dan mee doet, is alle LEDs op 0 zetten, en meteen daarna trail2 op 25, trail1 op 54, trail op 117 en currentLed op 255.
In het begin zijn alle de inhouden allemaal gelijk en stuur je dus in werkelijkheid maar 1 LED aan en dat gaat dusdanig snel dat je de verschillen niet gaat zien.
Wanneer je alle LEDs hebt aangestuurd, ga je bekijken welke kant je op zal gaan, en eventueel hoe snel.

Nu kopieer je de waarde van currentLed naar trail, de waarde uit trail naar trail1 en de waarde uit trail1 naar trail2, en dus ook in deze volgorde.
Daarna geef je aan currentLed de nieuwe waarde (dus pinnummer) die je zojuist bepaald hebt.
Je gaat straks met het volgende rondje door loop() deze waardes gebruiken, en zo bouw je je nagloei spoor op.
Omdat je de overflows al onder controle houdt met currentLed, gaan de andere LEDs dus nooit overflowen en ga je jezelf een hele berg if ... then uitsparen.

Eerder had ik het ook al over basic wiskunde.
Dat kun je gebruiken voor de richting en voor de snelheid.
Ook hiervoor gebruiken we het geheugen.
We maken dus ook variabelen en ik zou dan spd voor snelheid en dir voor richting gebruiken, maar daar mag je zelf namen voor bedenken die jij handiger vind.
Je hoeft nu aan dir maar 2 waarden toe te kennen, te weten 1 of -1.
Vervolgens hoog je currentLed op met de waarde uit dir.

Daarna kun je nog een snelheid gaan verwerken.
Dat kun je doen door iets te bedenken (kan misschien wel op verschillende manieren) waardoor je niet alleen bepaalt of de knop links of rechts van het midden zit, maar ook hoe ver.
Het resultaat daaruit kun je schalen (dat heb je al eerder toegepast meen ik) naar bruikbare waardes en die vermenigvuldig je vervolgens met een basiswaarde waarvan dat resultaat dan weer in spd terecht komt.
spd bepaalt vervolgens de vertraging tussen tussen het eind van loop() en het begin van de volgende stap.

De uitdaging die daarna zou kunnen komen, is dit dan weer op de blink without delay manier te doen.

In dit verhaal heb ik je een stuk of 10 (zojuist nog even snel geteld) verschillende dingen aangevoerd die te samen de oplossing kunnen vormen voor de eerder opgegeven opgave.
Probeer die niet allemaal tegelijk uit te voeren, maar ze 1 voor 1 op te pikken en uit te werken.
Daar gaat wat tijd inzitten, maar het zal de moeite waard zijn.
Ik vind het zelf erg leuk om dit soort puzzels op te pikken en al helemaal wanneer me dat dan ook na wat zwoegen toch lukt.

Veel succes met het uitwerken hiervan, en schroom niet je vragen te stellen.

Ik zag nog een foutje en heb dat gewijzigd met rode tekst

Heb het even snel doorgelezen en het klinkt allemaal logisch.

Waarom ik aan een hoop if then's denk is dat currentLed , trail1, trail2 allemaal kunnen overflowen denk ik.

Stel je voor dat currentLed 0 is en je linksom wilt draaien.
Dan zou je 1 van de currentLed kunnen aftrekken maar dan krijgt trail 1 de waarde -1 en die bestaat niet.

Stel dat currentLed 1 is en je linksom wilt draaien.
Dan zou je 1 van currentLed kunnen aftrekken , dan krijgt trail1 de waarde 0 dus geen probleem.
Dan trek je weer 1 ervan af en dan zou trail2 de waarde -1 krigen wat dus niet goed is.

Dus zoals ik het zie, kan het overflow probleem 3 keer voorkomen.

Ik lees jouw verhaal meerdere keren voor en ga het proberen stap voor stap uit te voeren met de "oude" code.

Ik had al begrepen waarom je de dacht de vele if ... then nodig te hebben.
Maar dat is dus niet zo, lees het verhaal maar eens goed door.
Je hoeft ook geen 4 (of 8) keer te controleren, want door het de eerste keer goed te doen en met je spoor die eerste keer te volgen kan het ook nooit fout gaan.

Ik kan nog wel bedenken hoe je het heel interessant kunt maken als je dit eenmaal aan het werken hebt, maar daar ga ik het nu nog even niet over hebben.

oke

IK heb al een idee om als de richting verandert. de staart te laten verwijderen en dan opnieuw laten opkomen in de nieuwe richting.

Maar eerst de staart werkend krijgen en daarna de snelheid en daarna herschrijven na het idee van blink zonder delay.

Ben dus wel een aantal "weken" hiermee bezig maar leer een heleboel.

@sterretje @MAS3

Is dit een goed begin ?

// Alle pinnen van de leds 
const uint8_t ledPins[] = { 9, 11, 10, 6, 3, 5 };

// de pin van de potmeter
byte Potpin = A3;
// de waarde die de potmeter aangeeft
int Potvalue;

// houdt de index bij van de huidige brandende led 
byte currentLed = 0;
// houdt de index bij van de eerste led van de staart
byte trail1 = 0 ;
// houdt de index bij van de tweede led van de staart 
byte trail2 = 0 ; 
// houdt de index bij van de derde led van de staart 
byte trail3 = 0;


void setup()
{
  // Zet de seriele monitor aan
  Serial.begin(115200);
  Serial.println(F("Start"));

  for (uint8_t cnt = 0; cnt < sizeof(ledPins); cnt++)
  {
    // Zet alle leds uit
    digitalWrite(ledPins[cnt], HIGH);
    // Zet de pin mode op output
    pinMode(ledPins[cnt], OUTPUT);
  }
}


void loop()
{
  // Lees de waarde van de potmeter
  Potvalue = analogRead(Potpin);

   if (Potvalue < 512)
  {
    ////////////////////////
    // aansturen LEDs
    ////////////////////////
    Serial.print(F("Aan: "));
    Serial.println(currentLed);
    Serial.print(F("Trail1: "));
    Serial.println(trail1);
     Serial.print(F("Trail2: "));
    Serial.println(trail2);
     Serial.print(F("Trail3: "));
    Serial.println(trail3);
    
    // Zet de led die de index currentLed heeft aan.
    analogWrite(ledPins[currentLed], 255);
    analogWrite(ledPins[trail1], 117); 
    analogWrite(ledPins[trail2], 54);
    analogWrite(ledPins[trail3], 25); 


    /*
    Serial.print(F("Uit: "));
    if (currentLed == 0)
    {
      Serial.println(sizeof(ledPins) - 1);
      digitalWrite(ledPins[sizeof(ledPins) - 1], HIGH);
    }
    else
    {
      Serial.println(currentLed - 1);
        digitalWrite(ledPins[currentLed - 1], HIGH);
    }

    ////////////////////////
    // aanpassen currentLed
    ////////////////////////
    currentLed++;
    if (currentLed == sizeof(ledPins))
    {
      Serial.println(F("Overflow"));
      currentLed = 0;
    }
  }

  if (Potvalue > 512)
  {
    ////////////////////////
    // aansturen LEDs
    ////////////////////////
    Serial.print(F("Aan: "));
    Serial.println(currentLed);
    digitalWrite(ledPins[currentLed], LOW);
    Serial.print(F("Uit: "));
    if (currentLed == sizeof(ledPins) - 1)
    {
      Serial.println(ledPins[0]);
      digitalWrite(ledPins[0], HIGH);
    }
    else
    {
      Serial.println(currentLed + 1);
      digitalWrite(ledPins[currentLed + 1], HIGH);
    }

    ////////////////////////
    // aanpassen currentLed
    ////////////////////////
  
    if (currentLed == 0)
    {
      Serial.println(F("Overflow"));
      currentLed = sizeof(ledPins) - 1;
    } else {
        currentLed--;
    }
  */
  }
  

  delay(500); 
}

Als trail1/2/3 de indices zijn in ledPins die je wilt veranderen zul je ze een waarde moeten geven die niet nul is. Bv als currentLED 4 is zal trail1 3 zijn, trail2 2 zijn en trail3 1.

Zoals het nu staat zullen de volgende regels in je programma allemaal de led met index 0 aansturen en als een resultaat zal pin 9 de laatste waarde krijgen.
``

Ik denk dat het het handigste is om in loop() iets zoals hieronder te maken

trail1 = currentLed - 1;
trail2 = currentLed - 2;
trail3 = currentLed - 3;

Dan moet je er uiteraard wel op letten dat trailX niet negatief word als currentLed kleiner is dan 3 maar daar was je je al van bewust.

Dank je voor de feedback.

Probeer het verhaal van mas werkend te krijgen door de variabelen zelf rond te doen.
Goed idee om de getallen aan te passen.

Edit 1 :

heb de getallen aangepast maar kan niet zeggen dat ik veel verschil zie in de leds.
Of kan het aan wokwiki liggen ?

Ik heb even gekeken (voordat ik sterretje's opmerking heb gezien, en zie 2 aandachtspunten.
Waar ik het nog niet over heb gehad, is de weerstand die elke LED moet hebben.
Heb jij die er in zitten (ik weet dat je nu nog vooral simuleert) ?

Het eerste dat ik zie is dat jouw commentaar niet klopt met de code, en ik begrijp wel hoe dat komt.
Zo te zien heb jij je LEDs aan 5 volt verbonden en zet je ze aan door de betreffende pin LOW te maken.
Dat werkt prima als je aan alle voorwaarden voldoet.
Maar nu ga je analoge uitgangen gebruiken.
De eerste analoge uitgang maak je 255 en dan zeg je in het commentaar dat je 'm aan zet.
Maar dat is niet waar, want met deze manier van aansluiten zet je 'm dan juist uit.
Je kunt dit zowel hardwarematig als softwarematig oplossen.

Het tweede wat ik zag, was dat je vergeten bent te letten op de juiste volgorde van aansturen van de LEDs, waar ik een specifieke opmerking over heb gemaakt.
Hierdoor gaat het niet zo werken als bedoeld, al bij de eerste ronde van loop().

Wanneer je je code wil testen tussen de wijzigingen door, zou ik ook nog niet beginnen met het veranderen van de snelheid, en voor nu alleen de richting bepalen met de potmeter.

Verder zou ik nog even wachten met het afknippen van de staart als je van richting verandert.
We zijn voorlopig niet zover en ik denk dat je eerst het effect wil zien als je dat juist niet doet.

Inmiddels heb ik ook al weer wat, uiteindelijk niet al te grote uitdagingen bedacht die we hier nog niet eerder besproken hebben maar die weer een mooie aanvulling zullen zijn op dit demo projectje.
Daarover later meer.
Overigens heb ik hier een A4tje liggen waar ik al een en ander opgeschreven heb in verband met dit projectje en diens toekomst (in geval je daarin dan nog geïnteresseerd bent).

Toevoeging: Ik ben het niet eens met sterretje's opmerking over het invullen van de trail waardes, omdat je daarmee juist het correct volgen verpest en je alsnog heel veel if ... then moet gaan inbouwen.
Alleen de laatse regel van sterretje's opmerking ben ik het mee eens en daar heb ik hierboven ook wat over gezegd.
Dat laatste is alleen waar bij het eerste rondje van loop(), en "by design".