[Discussie] Arduino-topic

[Tom-Z]

@Rrob Waarom kan je niet expliciet sn10() aanroepen uit sn9()? Waarom moet het per se afhankelijk van de variabele x?

Het klinkt alsof je een XY-probleem hebt (een vraag stellen naar wat jij denkt dat de oplossing zou moeten zijn terwijl het probleem eigenlijk heel ergens anders zit).

[Rrob]

@Tom-Z dat scheelt typen en ik dacht dat je dat bedoelde met:

Voor die functie aanroepen (snx+1) ligt het misschien meer voor de hand om van x een argument te maken, dus een functie sn(int n) te definiëren die als argument een getal n neemt zodat je die kan aanroepen als sn(x+1).

Maar met een array en x++ hoef ik al een stuk minder aan te passen (naast sn1 tm 10 zijn er ook nog so1-10 en nog 6 andere 1 - 10)

code:

void sn2(){
x++;
[...]
timer.setTimeout(DSNP, sn3); }

[mcDavid]

@Rrob kun je eens uitleggen wat je precies probeert te bereiken dan? Want ik denk dat @Tom-Z gelijk heeft... Behalve de ontzettend slechte functienamen is er waarschijnlijk een grotere ontwerpfout die je maakt.

[Tom-Z]

@Rrob Je opmerking "een stuk minder aan te passen" baart me zorgen. Zodra je code gaat kopiëren en plakken (met kleine aanpassingen) is er waarschijnlijk iets mis. Als je 10 functies sn1 t/m sn10 hebt die allemaal heel erg op elkaar lijken is er vrijwel zeker een betere manier om zoiets te programmeren met maar 1 functie.

In principe zou je het zo kunnen herschrijven:

code:

void sn(int x){
  unsigned long currentMillis = millis();
  startMillis = currentMillis;
  while(pulseslaap< pusn * x && currentMillis - startMillis <= dsn[x]){
    digitalWrite(pinsn, SNA);}

    digitalWrite(pinsn, SNP);
    stopMillis = currentMillis;

    if (pulseslaap == pusn *x && stopMillis - startMillis <=dsn[x]){
      if (test == 1){
              snprintf_P(s, sizeof(s), PSTR("slaap neer %i %i"),x , stopMillis - startMillis);
              Blynk.virtualWrite(V0, s); 
            }
      timer.setTimeout(DSNP, sn(x+1));
     }

    else {
    errorsn();
}}

Helaas werkt dit niet helemaal omdat de timer.setTimeout niet overweg kan met een functie met argumenten. Mogelijk kun je daar omheen werken door van x een globale variabele te maken ipv. het als argument mee te geven. Maar wat de beste oplossing is hangt af van wat je precies wil bereiken.

[Rrob]

Ik wil een lier dmv een motor 10x 1,5 rotatie laten maken. Die controleer ik met een hall sensor en 4 magneten op de lier die via een interrupt 'pulseslaap' optelt.
Na elke 1,5 rotatie moet er een constante pauze zijn ' timer.setTimeout(DSNP' en van elke 1,5 rotatie wordt de tijd gecontroleerd zodat alles stop als er iets vastloopt. Die controletijd 'dsn[x]' is voor elke van de 10x anders.Als het draaien in een stap te lang duurt stopt het proces en wordt er een foutmelding gemaakt 'else { errorsn();'

de eerste en laatste stap zijn wat uitgebreider ivm checks en rapportage, de overige 8 stappen zijn bijna identiek.

Nu ik het typ denk ik dat ik gewoon een for loop nodig heb en de timeout moet vervangen door iets met while en currentmillis

[Raven]

Weet iemand toevallig waar de Arduino IDE de entries uit network ports (in menu ports) bewaart? Er staat een NodeMCU met OTA sketch dubbel in omdat ik na het (over verschillende subnets ) werkend krijgen van OTA static DHCP aan heb gezet en 't ding een ander IP heeft gekregen, waardoor entry nr 2 verscheen. Ik zie niet hoe ik de oude eruit kan halen...

[Atmoz]

Wie weet hoe ik deze JSON goed geparst krijg?

code:

 [{"success":{"username":"1234567890"}}]

Dat "element" met "succes" erin maakt het voor mij niet makkelijk erop...

Er zijn tal van voorbeelden te vinden, maar die hebben allemaal niet zo'n "1st element" erin.

Ik gebruik nu deze code:

code:

        StaticJsonDocument<200> doc;
        DeserializationError error = deserializeJson(doc, payload);

        if (error) {
           Serial.print(F("deserializeJson() failed: "));
           Serial.println(error.f_str());
           return;
        }

 
      String username = doc["success"]["username"];
      SendUDP(username);

Er komt dan "NULL" terug... (in "payload" zit uiteraard de JSON)

Wie kan me helpen?

[edit]

Tom-Z schreef op donderdag 10 juni 2021 @ 11:09:
@Atmoz

code:

String username = doc[0]["success"]["username"];

Geweldig, het werkt! THANKS

[ Voor 13% gewijzigd door Atmoz op 10-06-2021 11:12 ]

[Tom-Z]

@Atmoz

code:

String username = doc[0]["success"]["username"];

[Septillion]

@Atmoz http://snippets-r-us.com/

Maar je probleem is niet dat "succes" maar het feit dat het een array (met een enkel element) is

[OxyDrokz]

Hallo allemaal!
Voor een simpel projectje met een 8 voudig relaisboard heb ik een pointer in de juiste richting nodig;
Het doel is het na elkaar aansturen van de relais tot ze allemaal aan staan, om dan weer allemaal uit te gaan en zo een x aantal keren, waarna ze allen aan moeten blijven.

Ik wil met een SPDT schakelaar met stabiele middenstand het relaisbord aansturen; toggle de ene kant op voor "aan", en de andere kant op voor "uit" Dit wilde ik aanpakken met een bool voor de staat.

Het eerste is gelukt; de loop start zodra ik de switch naar de aan positie duw.
Het stoppen lukt echter niet... Na wat inlezen denk ik een interrupt nodig te hebben, maar de documentatie en voorbeelden daarvoor lijken toegespitst op veel complexere cases als het uitzetten van 8 relais.
Wat zie ik over het hoofd?

code:

int relay0 = A0;
int relay1 = A1;
int relay2 = A2;
int relay3 = A3;
int relay4 = A4;
int relay5 = A5;                        // A6 en A7 niet geschikt als output
int relay6 = 3;                         // gebruik D2 en D3 als output
int relay7 = 2;
int switchon = 11;                      // schakelaar aan
int switchoff = 12;                     // schakelaar uit
bool aan = false;                       // state variabele false bij aanvang

void setup() {                          // pins instellen
  pinMode(relay0, OUTPUT);
  digitalWrite(relay0, HIGH);           //HIGH is uit
  pinMode(relay1, OUTPUT);
  digitalWrite(relay1, HIGH);
  pinMode(relay2, OUTPUT);
  digitalWrite(relay2, HIGH);
  pinMode(relay3, OUTPUT);
  digitalWrite(relay3, HIGH);
  pinMode(relay4, OUTPUT);
  digitalWrite(relay4, HIGH);
  pinMode(relay5, OUTPUT);
  digitalWrite(relay5, HIGH);
  pinMode(relay6, OUTPUT);
  digitalWrite(relay6, HIGH);
  pinMode(relay7, OUTPUT);
  digitalWrite(relay7, HIGH);
  pinMode(switchon, INPUT_PULLUP);      //pullup tegen zwevende input
  pinMode(switchoff, INPUT_PULLUP);
  
}

void loop() {
  if (digitalRead(switchon) == LOW)
  {
    delay(100);                         // delay to debounce switch
    aan = true;                         // aan naar true
  }
    if (digitalRead(switchoff) == LOW)
  {
    delay(100);                         // delay to debounce switch
    aan = false;                        // aan naar false
  }
  while (aan == true)
  {
    digitalWrite(relay0, LOW);
    delay(1700);
    digitalWrite(relay1, LOW);
    delay(1700);
    digitalWrite(relay2, LOW);
    delay(1700);
    digitalWrite(relay3, LOW);
    delay(1700);
    digitalWrite(relay4, LOW);
    delay(1700);
    digitalWrite(relay5, LOW);
    delay(1700);
    digitalWrite(relay6, LOW);
    delay(1700);
    digitalWrite(relay7, LOW);
    delay(3000);
    digitalWrite(relay0, HIGH);
    digitalWrite(relay1, HIGH);
    digitalWrite(relay2, HIGH);
    digitalWrite(relay3, HIGH);
    digitalWrite(relay4, HIGH);
    digitalWrite(relay5, HIGH);
    digitalWrite(relay6, HIGH);
    digitalWrite(relay7, HIGH);
    delay(1000);
  }
}

Ik snap dat ik doordat ik in de loop zit na "aan" geen enkele invloed meer heb.
Hoe los ik dit eenvoudig op?

[Santford]

@OxyDrokz
Je hebt de sequence voor het schakelen van de relais binnen een while loop geprogrammeerd, daar komt het programma niet meer uit tenzij je binnen de haakjes de voorwaarde voor de while loop weer false maakt.

[OxyDrokz]

Santford schreef op dinsdag 15 juni 2021 @ 10:11:
@OxyDrokz
Je hebt de sequence voor het schakelen van de relais binnen een while loop geprogrammeerd, daar komt het programma niet meer uit tenzij je binnen de haakjes de voorwaarde voor de while loop weer false maakt.

Dus hieruit maak ik op dat ik in de loop herhaaldelijk moet checken of de switchoff pin laag wordt getrokken?

[Santford]

OxyDrokz schreef op dinsdag 15 juni 2021 @ 10:13:
[...]


Dus hieruit maak ik op dat ik in de loop herhaaldelijk moet checken of de switchoff pin laag wordt getrokken?

Of je kunt in plaats van een while-loop een if-statement gebruiken, dan blijft de rest van het programma uitgevoerd worden.

[InTheDisorder]

OxyDrokz schreef op dinsdag 15 juni 2021 @ 10:13:
[...]


Dus hieruit maak ik op dat ik in de loop herhaaldelijk moet checken of de switchoff pin laag wordt getrokken?

Dit is inderdaad hoe het werkt. Hou er wel rekening mee dat je een heleboel delays in je while loop hebt staan, dus afhankelijk van waar je controleert of de switch uit gezet word kan het even duren voordat de code ook echt op dat punt komt waardoor je relais nog steeds aan kunnen gaan terwijl de switch al uit staat.

[Septillion]

@OxyDrokz Daarnaast een tip, als je veel gelijke dingen hebt is een array vaak een stuk makkelijker. Dan hoef je jezelf niet zo vaak te herhalen.

@OxyDrokz Daarnaast een tip, als je veel gelijke dingen hebt is een array vaak een stuk makkelijker. Dan hoef je jezelf niet zo vaak te herhalen.

@OxyDrokz Daarnaast een tip, als je veel gelijke dingen hebt is een array vaak een stuk makkelijker. Dan hoef je jezelf niet zo vaak te herhalen.



En zoals anderen ook al aangegeven hebben, je hebt blocking code gemaakt. Dus het zal niet echt snel reageren.

[OxyDrokz]

Dank allen!
Het array ga ik mee beginnen, daar heb met python al wel eens mee gewerkt.

Ik heb er nu een IF van gemaakt, maar de code stopt dus inderdaad alleen als de switchoff laag is aan het eind van de loop.
Met welke functie los ik dit netjes op?

[InTheDisorder]

Ik zou het oplossen door inderdaad een array te maken met je relais er in, en daar dan overheen loopen en voor of na iedere call van digitalWrite(relays[i], LOW) controleren of de switch in de uit positie staat.

code:

while(aan == true) {
  for(int i = 0; i < relays.length; i++) {
    if(aan == false) {
      continue;
    }

    digitalWrite(relays[i], LOW);
    if (digitalRead(switchoff) == LOW) {
      aan = false;
      continue;
    }
    delay(1700);
  
    if(i == relays.length - 1) {
      //methode aanroepen om alles weer uit te zetten
    }
  }
}

Is al even geleden dat ik iets met Arduino heb gedaan dus weet niet of het array.length of array.size is om de groote op te vragen, maar iets zoals dit zou ik iig doen.

Hmm, bedenk me wel net dat de loop zo nog afgemaakt wordt als de switch uit gezet wordt, dus dit is ook nog niet 100% correct. Opgelost door een check op het begin te maken en continue aan te roepen waardoor de huidige iteratie van de loop overgeslagen wordt. Zo stopt hij vrij snel met loopen als aan op false wordt gezet.

[ Voor 36% gewijzigd door InTheDisorder op 15-06-2021 11:06 ]

[OxyDrokz]

InTheDisorder schreef op dinsdag 15 juni 2021 @ 10:39:
Ik zou het oplossen door inderdaad een array te maken met je relais er in, en daar dan overheen loopen en voor of na iedere call van digitalWrite(relays[i], LOW) controleren of de switch in de uit positie staat.

code:

while(aan == true) {
  for(int i = 0; i < relays.length; i++) {
    if(aan == false) {
      continue;
    }

    digitalWrite(relays[i], LOW);
    if (digitalRead(switchoff) == LOW) {
      aan = false;
      continue;
    }
    delay(1700);
  
    if(i == relays.length - 1) {
      //methode aanroepen om alles weer uit te zetten
    }
  }
}

Is al even geleden dat ik iets met Arduino heb gedaan dus weet niet of het array.length of array.size is om de groote op te vragen, maar iets zoals dit zou ik iig doen.

Hmm, bedenk me wel net dat de loop zo nog afgemaakt wordt als de switch uit gezet wordt, dus dit is ook nog niet 100% correct. Opgelost door een check op het begin te maken en continue aan te roepen waardoor de huidige iteratie van de loop overgeslagen wordt. Zo stopt hij vrij snel met loopen als aan op false wordt gezet.

Bedankt!
Het array had ik zelf inmiddels in elkaar geknutseld, met hulp van hier.
De code is nu zo geworden en stopt nu. Op dit moment stopt hij gewoon in de laatste staat, even uitvogelen op welke manier ik hem kan laten stoppen en alles weer HIGH trekken.
Hij is vanaf het stoppunt ook weer startbaar nu

code:

int relayArray[] = {A0,A1,A2,A3,A4,A5,3,2};
int switchOn = 11;
int switchOff = 12;
int q = 8; // aantal relais
int delay1 = 100;
bool aan = false;

void setup() {

  for (int i = 0; i < q; i++){
    pinMode(relayArray[i],OUTPUT);
    digitalWrite(relayArray[i], HIGH);
  }
  pinMode(switchOn, INPUT_PULLUP);
  pinMode(switchOff, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(switchOn) == LOW) {
    delay(100);                         // delay to debounce switch
    aan = true;                         // aan naar true
  }
    if (digitalRead(switchOff) == LOW) {
    delay(100);                         // delay to debounce switch
    aan = false;                        // aan naar false
  }
  while (aan == true) {
    for (int i = 0; i < q; i++){
      if (aan == false) {
        continue;
      }

      digitalWrite(relayArray[i], LOW);
      if (digitalRead(switchOff) == LOW) {
        aan = false;
        continue;
      }
      delay(delay1);

      if (i == q-1){
        for (int i = 0; i < q; i++){
          digitalWrite(relayArray[i], HIGH);
      }
    }
  }
  }
}

[Septillion]

Mijn versie van het eerste programma:

C++:

//Pins
const byte RelayPins[] = {A0, A1, A2, A3 ,A4,A5, 3, 2};
const byte SwitchOnPin = 11;
const byte SwitchOffPin = 12;
const byte NrofRelays = sizeof(RelayPins); 

//timing
const unsigned int DelayBetween = 1700;
const unsigned int DelayExtra = 3000 - DelayBetween;
const unsigned int DelayOff = 1000;

bool turnOn = false;

void setup() {

  for (byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
    pinMode(RelayPins[i],OUTPUT);
  }
  pinMode(SwitchOnPin, INPUT_PULLUP);
  pinMode(SwitchOffPin, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(SwitchOnPin) == LOW) {
    delay(100);                         // delay to debounce switch
    turnOn = true;                        // aan naar true
  }
    if (digitalRead(SwitchOffPin) == LOW) {
    delay(100);                         // delay to debounce switch
    turnOn = false;                        // aan naar false
  }
  
  if(turnOn){
    for(byte i = 0; i < NrofRelays; i++){
      digitalWrite(i, LOW);
      delay(DelayBetween);
    }
    
    delay(DelayExtra);
    
    for(byte i = 0; i < NrofRelays; i++){
      digitalWrite(i, HIGH);
    }
    delay(DelayOff);
  }
}

Maar dat is nog steeds blocking. Ofwel, als je later de Arduino ook nog wat anders wilt laten doen ben je verkeerd bezig.

Daarnaast is me niet duidelijk wat je wilt met de schakelaar. Is dit een verende met middestand ofzo? Als dat zo is dan heb je met blockende code ook een probleem daar deze dan alleen gelezen wordt na het hele rondje. Stoppen kan dan alleen met alle uit. Is dat wat je wilt? En waarom geen normale aan/uit schakelaar?

Ofwel, het je beschrijving van wat je wilt wat er gebeurd is nog incompleet.

[OxyDrokz]

Septillion schreef op dinsdag 15 juni 2021 @ 13:27:
Mijn versie van het eerste programma:

C++:

//Pins
const byte RelayPins[] = {A0, A1, A2, A3 ,A4,A5, 3, 2};
const byte SwitchOnPin = 11;
const byte SwitchOffPin = 12;
const byte NrofRelays = sizeof(RelayPins); 

//timing
const unsigned int DelayBetween = 1700;
const unsigned int DelayExtra = 3000 - DelayBetween;
const unsigned int DelayOff = 1000;

bool turnOn = false;

void setup() {

  for (byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
    pinMode(RelayPins[i],OUTPUT);
  }
  pinMode(SwitchOnPin, INPUT_PULLUP);
  pinMode(SwitchOffPin, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(SwitchOnPin) == LOW) {
    delay(100);                         // delay to debounce switch
    turnOn = true;                        // aan naar true
  }
    if (digitalRead(SwitchOffPin) == LOW) {
    delay(100);                         // delay to debounce switch
    turnOn = false;                        // aan naar false
  }
  
  if(turnOn){
    for(byte i = 0; i < NrofRelays; i++){
      digitalWrite(i, LOW);
      delay(DelayBetween);
    }
    
    delay(DelayExtra);
    
    for(byte i = 0; i < NrofRelays; i++){
      digitalWrite(i, HIGH);
    }
    delay(DelayOff);
  }
}

Maar dat is nog steeds blocking. Ofwel, als je later de Arduino ook nog wat anders wilt laten doen ben je verkeerd bezig.

Daarnaast is me niet duidelijk wat je wilt met de schakelaar. Is dit een verende met middestand ofzo? Als dat zo is dan heb je met blockende code ook een probleem daar deze dan alleen gelezen wordt na het hele rondje. Stoppen kan dan alleen met alle uit. Is dat wat je wilt? En waarom geen normale aan/uit schakelaar?

Ofwel, het je beschrijving van wat je wilt wat er gebeurd is nog incompleet.

Bedankt voor het meedenken!
Het enige doel van deze arduino nano is het aansturen van de relais. Hier komen 8 stuks verlichte letters aan en die worden dan opeenvolgend verlicht.
De schakelaar heeft inderdaad een retour naar middenstand (on)-off-(on) die had ik nog liggen, vandaar.
Ik had het idee om dan een toggle "aan" en een toggle "uit" te hebben.
Ga zo maar eens in de hoop met componenten naar een andere schakelaar zoeken, misschien werkt dat eenvoudiger.

[Septillion]

@OxyDrokz Op zich is een toggle dan ook prima te gebruiken. Maar eigenlijk ben je dan al twee dingen aan het doen op de Arduino en dan zijn delay()'s al heel snel een probleem. Naar mijn idee zou les twee van Arduino, na blink, moetne zijn "En gebruik nu nooit meer delay"

Mijn non-blocking versie zou iets zijn als:

C++:

#include <Bounce2.h>

//Pins
const byte RelayPins[] = {A0, A1, A2, A3 ,A4,A5, 3, 2};
const byte SwitchOnPin = 11;
const byte SwitchOffPin = 12;
const byte NrofRelays = sizeof(RelayPins); 

//timing [ms]
const unsigned int DelayBetween = 1700;
const unsigned int DelayOn = 3000;
const unsigned int DelayOff = 1000;

bool turnOn = false;
byte nextRelay = 0;
unsigned long lastMillis;
Bounce switchOn;
Bounce switchOff;

void setup() {
  for (byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
    pinMode(RelayPins[i],OUTPUT);
  }
  switchOn.attach(SwitchOnPin, INPUT_PULLUP);
  switchOff.attach(SwitchOffPin, INPUT_PULLUP);
}

void loop() {
  updateSwitches(); 
  updateRelays();
}

void allRelayOff(){
  for(byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
  }
}

void updateRelays(){
  if(turnOn){
    //turn on one by one, first led may be turned on without waiting
    if(nextRelay < NrofRelays){
      if((millis() - lastMillis >= DelayBetween) || (nextRelay == 0)){
        lastMillis = millis();
        digitalWrite(RelayPins[nextRelay++], LOW);
      }
    }
    //all led's on
    else if(nextRelay == NrofRelays){
      if(millis() - lastMillis >= DelayOn){
        lastMillis = millis();
        allRelayOff();
        nextRelay++;
      }
    }
    //all off
    else{
      if(millis() - lastMillis >= DelayOff){
        lastMillis = millis();
        nextRelay = 0;
      }
    }
  }
}

void updateSwitches(){
  switchOn.update();
  switchOff.update();
  
  if(switchOn.fell()){
    turnOn = true;
  }
  else if(switchOff.fell()){
    turnOn = false;
    allRelayOff();
    nextRelay = 0;
  }
}

[DataGhost]

Septillion schreef op dinsdag 15 juni 2021 @ 21:57:
@OxyDrokz Op zich is een toggle dan ook prima te gebruiken. Maar eigenlijk ben je dan al twee dingen aan het doen op de Arduino en dan zijn delay()'s al heel snel een probleem. Naar mijn idee zou les twee van Arduino, na blink, moetne zijn "En gebruik nu nooit meer delay"

Mijn non-blocking versie zou iets zijn als:

C++:

#include <Bounce2.h>

//Pins
const byte RelayPins[] = {A0, A1, A2, A3 ,A4,A5, 3, 2};
const byte SwitchOnPin = 11;
const byte SwitchOffPin = 12;
const byte NrofRelays = sizeof(RelayPins); 

//timing [ms]
const unsigned int DelayBetween = 1700;
const unsigned int DelayOn = 3000;
const unsigned int DelayOff = 1000;

bool turnOn = false;
byte nextRelay = 0;
unsigned long lastMillis;
Bounce switchOn;
Bounce switchOff;

void setup() {
  for (byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
    pinMode(RelayPins[i],OUTPUT);
  }
  switchOn.attach(SwitchOnPin, INPUT_PULLUP);
  switchOff.attach(SwitchOffPin, INPUT_PULLUP);
}

void loop() {
  updateSwitches(); 
  updateRelays();
}

void allRelayOff(){
  for(byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
  }
}

void updateRelays(){
  if(turnOn){
    //turn on one by one, first led may be turned on without waiting
    if(nextRelay < NrofRelays){
      if((millis() - lastMillis >= DelayBetween) || (nextRelay == 0)){
        lastMillis = millis();
        digitalWrite(RelayPins[nextRelay++], LOW);
      }
    }
    //all led's on
    else if(nextRelay == NrofRelays){
      if(millis() - lastMillis >= DelayOn){
        lastMillis = millis();
        allRelayOff();
        nextRelay++;
      }
    }
    //all off
    else{
      if(millis() - lastMillis >= DelayOff){
        lastMillis = millis();
        nextRelay = 0;
      }
    }
  }
}

void updateSwitches(){
  switchOn.update();
  switchOff.update();
  
  if(switchOn.fell()){
    turnOn = true;
  }
  else if(switchOff.fell()){
    turnOn = false;
    allRelayOff();
    nextRelay = 0;
  }
}

Let met dit patroon van vele millis()-calls op, zeker als je ooit micros() wilt gaan gebruiken. Het is een goede bron van een hele hoop gekke timing-issues. Ik gebruik hier persoonlijk altijd een passende variabele voor zodat de call maar eenmalig per loop gedaan hoeft te worden en de waarde de hele iteratie hetzelfde blijft.

[Septillion]

@DataGhost Vind ik een beetje een overtrokken reactie. Enige "gekke" dat kan gebeuren is dat millis() al één tick verder is tijdens de assignment dan tijdens de comparison. En zo nauwkeurig hoeft dit ook niet. De millis-call stelt verder ook niets voor.

Bij micros() heb je een wat grotere kans dat hij al verder is en kan de overhead van de call relatief wat meer zijn. Maar of dat nu "gekke timing-issues" te noemen, nee.

[DataGhost]

Septillion schreef op woensdag 16 juni 2021 @ 08:08:
@DataGhost Vind ik een beetje een overtrokken reactie. Enige "gekke" dat kan gebeuren is dat millis() al één tick verder is tijdens de assignment dan tijdens de comparison. En zo nauwkeurig hoeft dit ook niet. De millis-call stelt verder ook niets voor.

Bij micros() heb je een wat grotere kans dat hij al verder is en kan de overhead van de call relatief wat meer zijn. Maar of dat nu "gekke timing-issues" te noemen, nee.

Ik heb het over het algemeen, voor als je ooit met een project bezig gaat waarbij dit wel kritisch is of kan zijn. Dan kan je het maar beter in je achterhoofd hebben of, liever, al aangeleerd hebben om het "goed" te doen. Zeker op het moment dat je met bepaalde "blocking" calls gaat werken of als interrupts er tussendoor fietsen, kan zelfs een tweede millis()-call meer dan één tick verder zijn.

In ieder geval introduceer je hiermee (onnodig) drift in je timing. Geen probleem in dit voorbeeld, maar iets om in gedachten te houden.

[Septillion]

@DataGhost Het is belangrijk je eisen te weten. Maar ging mij vooral om de aanduiding "gekke timing issues".

Maar gezien de overhead (in typen of global houden etc) vind ik het geen meerwaarde hier hebben. Ja, het kan 2ms worden, nouw en. Als dat een probleem vormt dan is de huidige millis centraal opslaan maar een deel van de oplossing. Zal je tijdens de handeling überhaupt interrupts moeten uitschakelen als dat een probleem is (of alles naar een interrupt halen) en zal je last millis gewoon incremental moeten doen ipv voorzien van de huidige waarde. Maar de extra complexiteit is het niet waard imho. En verdient al helemaal niet de benaming "gekke timing issues".

[DataGhost]

Global? Extra complexiteit?

code:

void loop() {
    const unsigned long now = millis();
    // doe je ding
    if (now - lastMillis >= eenTijdje) {
        lastMillis = now;
    }
    // etc
}

[ Voor 1% gewijzigd door DataGhost op 16-06-2021 11:45 . Reden: inderdaad septillion, const ]

[OxyDrokz]

Thanks. Hier ga ik mee verder. Hoop nieuwe functies om eens te bekijken.

Septillion schreef op dinsdag 15 juni 2021 @ 21:57:
@OxyDrokz Op zich is een toggle dan ook prima te gebruiken. Maar eigenlijk ben je dan al twee dingen aan het doen op de Arduino en dan zijn delay()'s al heel snel een probleem. Naar mijn idee zou les twee van Arduino, na blink, moetne zijn "En gebruik nu nooit meer delay"

Mijn non-blocking versie zou iets zijn als:

C++:

#include <Bounce2.h>

//Pins
const byte RelayPins[] = {A0, A1, A2, A3 ,A4,A5, 3, 2};
const byte SwitchOnPin = 11;
const byte SwitchOffPin = 12;
const byte NrofRelays = sizeof(RelayPins); 

//timing [ms]
const unsigned int DelayBetween = 1700;
const unsigned int DelayOn = 3000;
const unsigned int DelayOff = 1000;

bool turnOn = false;
byte nextRelay = 0;
unsigned long lastMillis;
Bounce switchOn;
Bounce switchOff;

void setup() {
  for (byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
    pinMode(RelayPins[i],OUTPUT);
  }
  switchOn.attach(SwitchOnPin, INPUT_PULLUP);
  switchOff.attach(SwitchOffPin, INPUT_PULLUP);
}

void loop() {
  updateSwitches(); 
  updateRelays();
}

void allRelayOff(){
  for(byte i = 0; i < NrofRelays; i++){
    digitalWrite(RelayPins[i], HIGH);
  }
}

void updateRelays(){
  if(turnOn){
    //turn on one by one, first led may be turned on without waiting
    if(nextRelay < NrofRelays){
      if((millis() - lastMillis >= DelayBetween) || (nextRelay == 0)){
        lastMillis = millis();
        digitalWrite(RelayPins[nextRelay++], LOW);
      }
    }
    //all led's on
    else if(nextRelay == NrofRelays){
      if(millis() - lastMillis >= DelayOn){
        lastMillis = millis();
        allRelayOff();
        nextRelay++;
      }
    }
    //all off
    else{
      if(millis() - lastMillis >= DelayOff){
        lastMillis = millis();
        nextRelay = 0;
      }
    }
  }
}

void updateSwitches(){
  switchOn.update();
  switchOff.update();
  
  if(switchOn.fell()){
    turnOn = true;
  }
  else if(switchOff.fell()){
    turnOn = false;
    allRelayOff();
    nextRelay = 0;
  }
}

[Septillion]

@DataGhost Als je het er pal voor doet is nog steeds niet alles in de loop in sync (want hé, ik ga niet alles als spagetti in de loop gooien). En voor wat je er mee op schiet is het in dit geval zelfs die extra regel naar mijn idee niet eens waard. Zeg niet dat ik het nooit doe, bijvoorbeeld als ik meerdere verstrengelde statements heb. Maar dan maak ik het wel const

[DataGhost]

Septillion schreef op woensdag 16 juni 2021 @ 11:41:
@DataGhost Als je het er pal voor doet is nog steeds niet alles in de loop in sync (want hé, ik ga niet alles als spagetti in de loop gooien). En voor wat je er mee op schiet is het in dit geval zelfs die extra regel naar mijn idee niet eens waard.

??? Heb je misschien een voorbeeld van wat je bedoelt?

Maar dan maak ik het wel const

Daar heb je wel gelijk in.

[DataGhost]

Ah, ik had niet gezien dat je functie updateRelays() niet gewoon "loop()" heette. Dus ik denk dat je bedoelt dat je allemaal losse functies hebt die je vanuit loop() aanroept, en dat je denkt dat je in elke afzonderlijk now = millis(); bovenaan zet.

Kijk, als je niet eens probeert het in sync te laten lopen, is het nogal wiedes dat het niet in sync loopt. Jouw werkwijze is inderdaad eentje die voortvloeit uit overal millis() en micros() gebruiken, dan is er geen verschil tussen alles in een loop() en losse functies die vanuit loop() worden aangeroepen. Maar als je nou eens gewend bent om altijd je volatiles (want dat is een millis()-/micros()-call eigenlijk) te freezen voordat je ermee bezig gaat, ga je vanzelf nadenken over hoe je dit synct in de functies die je aanroept. Dat kan bijvoorbeeld door een argument wat je meegeeft.

code:

void loop() {
    const unsigned long now = millis();
    updateSwitches(now);
    updateRelays(now);
}
void updateRelays(const unsigned long now) {
    // ...
}
void updateSwitches(const unsigned long now) {
    // ...
}

En natuurlijk, waar je het niet gebruikt kan je het argument weglaten.

[Septillion]

@DataGhost Dat ja. Maar om ze nu echt volatiles te noemen is wel beetje verwarrend met de de volatile keyword. En nu overal dezelfde paramter mee te moeten geven, maak het dan een global. (Met als nadeel niet-constness).

Maar onder de streep, als je 1 LSD niet kunt hebben dan is je opzet überhaupt fout eigenlijk. Dus ik vind het allemaal maar storm in een glas water

[DataGhost]

Septillion schreef op woensdag 16 juni 2021 @ 12:08:
@DataGhost Dat ja. Maar om ze nu echt volatiles te noemen is wel beetje verwarrend met de de volatile keyword. En nu overal dezelfde paramter mee te moeten geven, maak het dan een global. (Met als nadeel niet-constness).

Maar onder de streep, als je 1 LSD niet kunt hebben dan is je opzet überhaupt fout eigenlijk. Dus ik vind het allemaal maar storm in een glas water

Een volatile variabele is eentje die kan veranderen zonder dat daar aanleiding toe is in de code waarin je bezig bent (externe verandering). In dat opzicht is een call naar een functie die eigenlijk gewoon als variabele gebruikt wordt hetzelfde. Zeker als de verwachting is dat deze in de meeste gevallen geen verschillend resultaat geeft, want zo gebruik je die (en helaas velen met jou). Daarom zeg ik het zo.

De aanrader om dan maar een global te gebruiken vind ik vreemder, zeker na jouw terechte opmerking dat je variabele const hoort te zijn en dat inderdaad niet kan met een global die over verschillende calls van loop() een andere waarde hoort te hebben. Bovendien is een global juist extra clutter van je namespace die je liever niet hebt. Dit zal alleen maar meer fouten in de hand kunnen werken. En simpelweg het bestaan van de global is voldoende om er iets mee te doen in functies die hem gebruiken, alleen is nergens de eis dat deze geset of geüpdatet moet zijn. Een argument/parameter maakt dat expliciet en zorgt dat je erover nadenkt, waardoor het bijna onmogelijk is deze te vergeten correct door te geven.

Programmeren is niet simpelweg zo min mogelijk typen, "don't repeat yourself" slaat niet op bijv. het meegeven van argumenten. Een const argument in twee functies vervangen door een non-const global, waarbij je niet eens de eis hebt deze elke keer te setten zoals je dat bij het meegeven van een argument wel expliciet moet doen, met bovendien de kans dat een andere functie die (onverwacht) tussentijds overschrijft is geen gezonde manier van programmeren naar mijn mening.

En nu is het 1 LSD/LSB, straks zijn het er meer (blocking call waarvan je dacht dat 'ie niet blocking was, of library call die lang duurt) en zeker als je micros gebruikt zijn het er veel meer. Helemaal als je met timed communicatie met een extern apparaat bezig bent. Zeker op micros-niveau is die impact snel groot. Op een 1MHz chip duurt elke instructie minimaal een microseconde. Een digitalRead kan zomaar richting de 50us gaan en een analogRead al 100us of meer. Dat kunnen forse verschillen zijn. Waar de aversie vandaan komt van het op een robuuste manier programmeren snap ik niet zo goed. Dat is een beetje het punt wat ik nog steeds mis, je draagt steeds alternatieven aan of bagatelliseert de mogelijke impact (waarschijnlijk omdat je zelf nog geen situatie bent tegengekomen waarbij dit een issue is), maar wat is nou de reden om het niet op mijn manier te doen? Wat is er objectief slechter aan?

[Septillion]

DataGhost schreef op woensdag 16 juni 2021 @ 13:17:
[...]

Een volatile variabele is eentje die kan veranderen zonder dat daar aanleiding toe is in de code waarin je bezig bent (externe verandering).

Wat dus niet gebeurd want je vraagt steeds een nieuw kopie op Ik verwacht dan ook nooit dat deze hetzelfde moet zijn als de call ervoor.

want zo gebruik je die (en helaas velen met jou). Daarom zeg ik het zo.

Nope, zo gebruik ik het niet. Maar aangezien ik niet LSD nauwkeurig hoef te zijn, want dan is deze opzet al niet goed, is het geen probleem. Ja, het kan iets nauwkeuriger maar het lost niets op.

De aanrader om dan maar een global te gebruiken vind ik vreemder, zeker na jouw terechte opmerking dat je variabele const hoort te zijn en dat inderdaad niet kan met een global die over verschillende calls van loop() een andere waarde hoort te hebben. Bovendien is een global juist extra clutter van je namespace die je liever niet hebt. Dit zal alleen maar meer fouten in de hand kunnen werken. En simpelweg het bestaan van de global is voldoende om er iets mee te doen in functies die hem gebruiken, alleen is nergens de eis dat deze geset of geüpdatet moet zijn. Een argument/parameter maakt dat expliciet en zorgt dat je erover nadenkt, waardoor het bijna onmogelijk is deze te vergeten correct door te geven.

Daar heb je zeker een punt. Wrapper in een getter en een setter (of updater) zou dan een oplossing zijn. En ja, het is extra namespace clutter. Maar als het iets is dat je op zo veel plekken gebruikt is dat het naar mijn idee waard. Of je zou echt volledig OO moeten gaan. Dat je er echt over na denk als je het aan de gros van je functies mee moet geven betwijfel ik ook, het is dan gewoon gewenning.

En nu is het 1 LSD/LSB, straks zijn het er meer (blocking call waarvan je dacht dat 'ie niet blocking was, of library call die lang duurt) en zeker als je micros gebruikt zijn het er veel meer. Helemaal als je met timed communicatie met een extern apparaat bezig bent.

Dan gaat dit het probleem echt niet wegnemen. Moet je het wel samen toepassen met lastMillis incremental maken en dan nog is er enorme kans op jitter. Dus als je zo timing kritisch bent is je opzet globaal gezien al fout.

Zeker op micros-niveau is die impact snel groot. Op een 1MHz chip duurt elke instructie minimaal een microseconde. Een digitalRead kan zomaar richting de 50us gaan en een analogRead al 100us of meer. Dat kunnen forse verschillen zijn.

Klopt dat die inderdaad relatief veel tijd kosten. En dan kan het een deel oplossing zijn van het probleem. Maar het simeplweg altijd zo doen maskeert ook weer deels het probleem dat er werkelijk tijd zit tussen de stappen. Om nog maar te zwijgen dat op een standaard (8-bit) Arduino de resolutie 4us is.

Waar de aversie vandaan komt van het op een robuuste manier programmeren snap ik niet zo goed.

Die is er ook niet, ik zie hier alleen niets robuuster worden gemaakt. Want dit lost an sich namelijk gewoon helemaal niets op. En gaat ook gewoon niet voorkomen dat je andere timing issues kan hebben. Want trage of blocking functies gooien nog steeds roet in het eten. Ofwel, je zal altijd gewoon over de timing moeten nadenken als het meer kritisch wordt.

waarschijnlijk omdat je zelf nog geen situatie bent tegengekomen waarbij dit een issue is

Zullen ze niet in mijn schoenen gaan staan? Dank je wel

maar wat is nou de reden om het niet op mijn manier te doen?

Niets, maar ik doe het hier niet omdat het niets bijdraagt.

Wat is er objectief slechter aan?

Absoluut niets! Dat het slecht zou zijn is iets wat jij er van gemaakt hebt. Dat iets niet goed is maakt iets nog nog niet slecht. Het lost in dit geval gewoon niets op. En naar mijn idee lost het aanwennen an sich ook niets op zonder echt inzicht te hebben in timing in het algemeen. Er is gewoon geen universele manier om het in elke situatie juist te doen. Dus nee, niets slechts aan Het is puur dat jij doet voorkomen dat het vaker aanroepen van millis() "vreemde" timing issues kan geven zonder dat je dat toelicht.

[Atmoz]

Ik rol hier van het ene probleem in het andere

Graag zou ik een array van int8_t (genaamd TwinkleTwinkle) willen vullen vanuit een string.
Maar wat ik ook probeer, het lukt gewoon écht niet

Wat ik ook aan m'n procedure meegeef, er komt geen goed geluid uit:

code:

void TestSjrot(String dataaa){

  //SendUDP(dataaa);
  //int8_t dataad = dataaa.toInt() *-1;

  int dju = dataaa.toInt();
  int8_t dataad = dju *-1;  // *-1 om er een negatief getal van te maken (is nodig voor TwinkleTwinkle4[])

  SendUDP(String(dataad));
  
 static int8_t TwinkleTwinkle4[] = {dataad,NOTE_A5,SCORE_END}; //dataad

 XT_MusicScore_Class* Musikkk;

  Musikkk = new XT_MusicScore_Class(TwinkleTwinkle4,TEMPO_PRESTISSIMO,INSTRUMENT_ORGAN);

  //XT_MusicScore_Class Musikkk(TwinkleTwinkle4,TEMPO_ALLEGRO,INSTRUMENT_ORGAN);  //INSTRUMENT_PIANO

  DacAudio.FillBuffer();  

  if(Musikkk->Playing==false)       // if not playing,
    DacAudio.Play(Musikkk);       // play it, this will cause it to repeat and repeat... 
}

Terwijl als ik zélf de int "dju" vul met bijvoorbeeld 50, dan werkt het wel netjes.
Maar het gekke is: SendUDP(String(dataad)); zorgt wel ervoor dat ik in m'n debug-programma -50 terug krijg (dus ook als ik "dju" laat vullen door de functie... waarom wordt die -50 in TwinkleTwinkle4[] niet "gezien" als -50 en wordt die wel als -50 verstuurd met "SendUDP"?)

Eigenlijk wil ik van string naar int, en daar zijn 100en voorbeelden van te vinden, maar toch werkt het daarmee niet.

Wat gaat hier verkeerd?

[Septillion]

@Atmoz Als eerste, je vult hem uit een String, niet een string

En weer zit je met wat mogelijk is tijdens runtime. Je hebt nu een compiler time initializatie staan van je array maar 'dataad' is nog niets. Je zal de array moeten vullen tijdens runtime door over alle times te lopen en een copy te doen. En 'TwinkleTwinkle4' zal groot genoeg moeten zijn om dat te kunnen hebben.

Daarnaast, wat staat er in je String? Echt losse 1-char grote noten of echt de tekst "NOTE_A5"? Beetje een XY problem

Ik kan denk ik alleen maar aanraden hier om die String te laten vallen. Ik denk echt dat je het daarmee veel lastiger maakt dan je zou moeten willen.

PS Wat een variable namen.....

[Atmoz]

Septillion schreef op maandag 21 juni 2021 @ 17:18:
@Atmoz Als eerste, je vult hem uit een String, niet een string

Thanks! Ik ga straks even uitzoeken wat de verschillen zijn

En weer zit je met wat mogelijk is tijdens runtime. Je hebt nu een compiler time initializatie staan van je array maar 'dataad' is nog niets. Je zal de array moeten vullen tijdens runtime door over alle times te lopen en een copy te doen. En 'TwinkleTwinkle4' zal groot genoeg moeten zijn om dat te kunnen hebben.

Ah wow! Ok, ik dacht al... dit kán toch gewoon niet wat hier (weer) aan de hand is

Ik snap denk ik redelijk goed aan de hand is hier, maar ik zou niet weten hoe ik dit moet oplossen...

Daarnaast, wat staat er in je String? Echt losse 1-char grote noten of echt de tekst "NOTE_A5"? Beetje een XY problem

Ik stuur vanuit de PC een String met daarin 50
Dus op de PC doe ik: SendUDP("50")

Ik kan denk ik alleen maar aanraden hier om die String te laten vallen. Ik denk echt dat je het daarmee veel lastiger maakt dan je zou moeten willen.

Ik lees sowieso dat werken met Strings absoluut niet het beste/fijnste is... Maarja, hoe dan?

PS Wat een variable namen.....

Haha klopt, dat krijg je vanzelf na vele uren achter elkaar dingen proberen/prutsen/testen...
Dan gaat het al snel van redelijke nette en logische benamingen naar "test123", testSjrot, etc...
En als het écht lukt soms zelfs scheldwoorden, maar dat is dan toch met de gedachte om het de volgende compile er weer uit te halen omdat het puur om te testen is die keer

Anyway: ik ben érg benieuwd hoe ik mijn probleem hierboven kan oplossen...

[Septillion]

Atmoz schreef op maandag 21 juni 2021 @ 18:22:
Thanks! Ik ga straks even uitzoeken wat de verschillen zijn

Een string is gewoon een array van char afgesloten met een null-char.
Een String is een object met dynamisch geheugen.

Ik stuur vanuit de PC een String met daarin 50
Dus op de PC doe ik: SendUDP("50")

Dat is dus een string met "50".

Ik lees sowieso dat werken met Strings absoluut niet het beste/fijnste is... Maarja, hoe dan?

Gewoon naar een char array lezen. En dan eigenlijk daarna direct al omzetten naar een nummer en daarmee eigenlijk een char/byte. Je zou ook al direct de byte waarde kunnen sturen misschien.

Met welke functie luister je naar UDP? Zelf nooit direct met UDP gewerkt.

En wil je ook meer dan één waarde kunnen sturen? Al bedacht hoe je "protool" er dan uit gaat zien?

Haha klopt, dat krijg je vanzelf na vele uren achter elkaar dingen proberen/prutsen/testen...
Dan gaat het al snel van redelijke nette en logische benamingen naar "test123", testSjrot, etc...
En als het écht lukt soms zelfs scheldwoorden, maar dat is dan toch met de gedachte om het de volgende compile er weer uit te halen omdat het puur om te testen is die keer

Toch probeer ik dan vaak logische namen te houden omdat ik het anders zelf 5 minuten later al niet meer snap

[Atmoz]

Septillion schreef op maandag 21 juni 2021 @ 20:10:
[...]

Een string is gewoon een array van char afgesloten met een null-char.
Een String is een object met dynamisch geheugen.


[...]

Dat is dus een string met "50".


[...]

Dankjewel!

Gewoon naar een char array lezen. En dan eigenlijk daarna direct al omzetten naar een nummer en daarmee eigenlijk een char/byte. Je zou ook al direct de byte waarde kunnen sturen misschien.

Hmzz, klinkt als je het zo zegt makkelijker gezegd dan gedaan

Met welke functie luister je naar UDP? Zelf nooit direct met UDP gewerkt.

Dat doe ik zo:

code:

   if(udp.listen(1234)) {
        udp.onPacket([](AsyncUDPPacket packet) {
            String test = (const char*)packet.data();        
            TestSjrot(test);
            //reply to the client
            //packet.printf("Got %u bytes of data", packet.length());
        });
    }

En wil je ook meer dan één waarde kunnen sturen? Al bedacht hoe je "protocol" er dan uit gaat zien?

Daar heb ik inderdaad wel al stiekem over nagedacht, maar voor nu hoeft dat niet. Ik ben al lang blij als 1 toon werkt.
Zojuist heb ik int8_t dataad = -50; globaal (boven setup()) gedeclareerd, en dan tijdens runtime vul ik hem weer, maar zelfs dán werkt het niet. Ik dacht dat ik hiermee dat probleem van het aanmaken tijdens compile time had omzeilt?!

Toch probeer ik dan vaak logische namen te houden omdat ik het anders zelf 5 minuten later al niet meer snap

Je hebt helemaal gelijk, ik moet daar ook wat serieuzer mee om gaan.

[Septillion]

@Atmoz Even recap wat je hier doet

C++:

String test = (const char*)packet.data();  

Je hebt een AsyncUDPPacket-object waar je de methode data() van aanroept. Return type daarvan is een uint8_t pointer. Deze cast je vervolgens naar een const char pointer. Vervolgens maak je een String-object aan waar je dit via operator overloading aan toevoegt. Beetje omslachtig dus.

Daarnaast hoeft packet.data() volgens mij niet null-terminated te zijn. Het dus zomaar als string (char pointer/array) is dus gevaarlijk. Volgens mij ben je zelf verantwoordelijk om te checken dat je nog in de data zit door middel van data.length() of door het te lezen met .read() (ook al is het wel raar dat read(void) int als return type heeft...).

Dus denk dat het een goed moment is om een stap terug te nemen en even goed te bedenken (en te beschrijven) wat je wilt bereiken. Want zo met snippets helpen is ergggg lastig.

[Shattering]

Hey allen! Recent gestart met arduino's. Wat leuk! Ik was op zoek naar een webshop waar ik accessoires, kabels & dergelijk kon aankopen. Hebben jullie tips?

Bedankt!

[Accretion]

Shattering schreef op zaterdag 26 juni 2021 @ 18:43:
Hey allen! Recent gestart met arduino's. Wat leuk! Ik was op zoek naar een webshop waar ik accessoires, kabels & dergelijk kon aankopen. Hebben jullie tips?

Bedankt!

Binnenkort moet je BTW en invoerrechten betalen vanuit China.

Dus wellicht een starterkit van eBay en een paar Arduino-clones.

Maar ook bijvoorbeeld arrangement aan weerstandjes, LED's, knopjes e.d.

[Septillion]

Binnenkort is over 4 dagen... Dus voor China bestellingen zonder BTW en PostNL toeslag ben je al te laat

[AteGjalt]

Shattering schreef op zaterdag 26 juni 2021 @ 18:43:
Hey allen! Recent gestart met arduino's. Wat leuk! Ik was op zoek naar een webshop waar ik accessoires, kabels & dergelijk kon aankopen. Hebben jullie tips?

Bedankt!

bitsandparts.nl en tinytronics.nl zijn wel goede hobby shops, heb er zelf geen enkele klacht over.

[Shattering]

Hey! Heb gisteren een hoop spulletjes besteld op bitsandparts.nl.
Nu nog wat leuke projecten verzinnen .

[AteGjalt]

@Shattering kijk eens op hackster.io voor wat inspiratie.

[Raven]

Raven schreef op vrijdag 4 juni 2021 @ 09:36:
Weet iemand toevallig waar de Arduino IDE de entries uit network ports (in menu ports) bewaart? Er staat een NodeMCU met OTA sketch dubbel in omdat ik na het (over verschillende subnets ) werkend krijgen van OTA static DHCP aan heb gezet en 't ding een ander IP heeft gekregen, waardoor entry nr 2 verscheen. Ik zie niet hoe ik de oude eruit kan halen...

Anyone? Op het Arduino-forum weten ze het niet en heb Total Commander alle Arduino IDE gerelateerde files laten doorzoeken op de naam van de netwerkpoort die ik eruit wil hebben, niks gevonden.

[Raymond P]

@Raven AFAIK leunt de Arduino IDE network discovery op Multicast DNS (mDNS).
Je entry zou dus moeten verdwijnen als je de IDE restart, daar wordt (door de IDE) geen cache van bijgehouden.

[ Voor 0% gewijzigd door Raymond P op 22-07-2021 14:43 . Reden: typo ]

[Raven]

@Raymond P mDNS ben ik mee bekend, heb er een programma op de router-pc voor moeten installeren om die datapakketjes naar een ander VLAN te krijgen zodat ik vanuit elk netwerk van OTA gebruik kan maken.

... en dat was het inderdaad, had de hele tijd de IDE open gehouden, blijkbaar "vergeet" ie pas de entries bij een herstart.

[Raymond P]

Ja die hele flow is een beetje klungelig. Zeker als je een aantal actief hebt.

Ik gebruik arduino-cli en espota.py zodat ik daar geen last van heb en gewoon een hostname of ip mee kan geven.
snelle copy/paste:

code:

#!/bin/sh

arduino-cli compile --build-cache-path /home/ray/sketchbook/cache --fqbn esp8266:esp8266:d1_mini:ssl=basic,dbg=Disabled /home/ray/sketchbook/sensor

python3 /home/ray/.arduino15/packages/esp8266/hardware/esp8266/2.7.2/tools/espota.py -i temperature.iot.lan.int -p 8266 --auth="temperature" -f "/home/ray/sketchbook/sensor/sensor.esp8266.esp8266.d1_mini.bin"

[Mee_]

Eenvoudig vraagje: ik heb een Arduino Nano 33 IoT, maar deze heeft - waar hij zit - niet genoeg wifi-signaal. Is het mogelijk om de range hiervan te verbeteren met een externe antenne?

[Toiletman]

'avond. Na een aantal jaar geen Arduino meer aangeraakt te hebben ligt er een mooi project in het verschiet: het automatiseren van de tuinberegening:

Ruwe situatieschets:

Outputs:
7x 24V AC kleppen (solenoids)
1x 230V AC Pomp
1x 230V AC Heater

Inputs:
- weersvoorspelling
- temperatuursensor technische ruimte
- waternivosensor (waterdichte drukmeter?)
- watersensor overstort
- watersensor lekkage
- (luchtvochtigheid)
- (T buiten)
- (lichtintensiteit buiten?)

Ik zit nog een beetje te twijfelen over de aanpak maar ik zat te denken aan een Arduino setup via ethernet. Datalogging kan dan via de NAS, en eventueel parsen van weerdata en instellen van irrigatieplannen ook. Dat kan dan via ethernet naar de arduino als input.

Qua hoeveelheid inputs/outputs zou het gewoon met een Uno moeten kunnen, waarbij ik me echter afvraag of de hoeveelheid geheugen wel ok is?

Een alternatief zou zijn om meer werk op de Arduino zelf te doen en de NAS minder te laten doen (alleen logging?). Het lijkt me dat je dan al echt wel op een Mega uitkomt?

Hoe kijken jullie hier tegenaan? Uno of Mega? Of zou het met allebei wel moeten lukken?

Qua verdere hardware ben ik nog een beetje aan het rondshoppen, qua outputs heb ik in ieder geval deze relais gevonden:
8CH 5V relais bordje
5V 40A 230V SSR
Het 8CH bordje zal via een aparte 5V voeding moeten worden gevoed omdat de Arduino niet genoeg stroom kan leveren.
De 230V relais lijken me wel handig om in een aparte behuizing te doen en de pomp trekt max 6A, dus met de meeste 'dev boardjes kom je er toch niet.

In totaal levert dit al wel een hoop voedingen op:
5VDC voor de 8CH relais
7/9VDC voor de Arduino zelf
24VAC voor de kleppen
(en natuurlijk 230V voor alles)... kan dit nog op een fraaiere manier?

Qua aansturing via ethernet is er natuurlijk het ethernet shield van arduino, maar ik kwam ook dit boardje tegen: goedkoper en ook een stuk minder 'intrusive'. Iemand ervaring met (één van) beide oplossingen?

Naar het hele sensorgebeuren moet ik nog gaan kijken, dat wordt waarschijnlijk volgend weekend.

Hoe kijken jullie hier tegenaan? Ben ik op de juiste weg? Andere ideeën?

In domotica is natuurlijk behoorlijk wat te vinden van mensen die middels HA of domoticz of dergelijke platforms soortgelijke dingen doen, maar wij hebben verder nog geen domotica, dus ik wilde nog niet meteen in die hele wereld duiken.

[itcouldbeanyone]

Toiletman schreef op zondag 8 augustus 2021 @ 21:52:
'avond. Na een aantal jaar geen Arduino meer aangeraakt te hebben ligt er een mooi project in het verschiet: het automatiseren van de tuinberegening:

Ruwe situatieschets:

Outputs:
7x 24V AC kleppen (solenoids)
1x 230V AC Pomp
1x 230V AC Heater

Inputs:
- weersvoorspelling
- temperatuursensor technische ruimte
- waternivosensor (waterdichte drukmeter?)
- watersensor overstort
- watersensor lekkage
- (luchtvochtigheid)
- (T buiten)
- (lichtintensiteit buiten?)

Ik zit nog een beetje te twijfelen over de aanpak maar ik zat te denken aan een Arduino setup via ethernet. Datalogging kan dan via de NAS, en eventueel parsen van weerdata en instellen van irrigatieplannen ook. Dat kan dan via ethernet naar de arduino als input.

Qua hoeveelheid inputs/outputs zou het gewoon met een Uno moeten kunnen, waarbij ik me echter afvraag of de hoeveelheid geheugen wel ok is?

Een alternatief zou zijn om meer werk op de Arduino zelf te doen en de NAS minder te laten doen (alleen logging?). Het lijkt me dat je dan al echt wel op een Mega uitkomt?

Hoe kijken jullie hier tegenaan? Uno of Mega? Of zou het met allebei wel moeten lukken?

Qua verdere hardware ben ik nog een beetje aan het rondshoppen, qua outputs heb ik in ieder geval deze relais gevonden:
8CH 5V relais bordje
5V 40A 230V SSR
Het 8CH bordje zal via een aparte 5V voeding moeten worden gevoed omdat de Arduino niet genoeg stroom kan leveren.
De 230V relais lijken me wel handig om in een aparte behuizing te doen en de pomp trekt max 6A, dus met de meeste 'dev boardjes kom je er toch niet.

In totaal levert dit al wel een hoop voedingen op:
5VDC voor de 8CH relais
7/9VDC voor de Arduino zelf
24VAC voor de kleppen
(en natuurlijk 230V voor alles)... kan dit nog op een fraaiere manier?

Qua aansturing via ethernet is er natuurlijk het ethernet shield van arduino, maar ik kwam ook dit boardje tegen: goedkoper en ook een stuk minder 'intrusive'. Iemand ervaring met (één van) beide oplossingen?

Naar het hele sensorgebeuren moet ik nog gaan kijken, dat wordt waarschijnlijk volgend weekend.

Hoe kijken jullie hier tegenaan? Ben ik op de juiste weg? Andere ideeën?

In domotica is natuurlijk behoorlijk wat te vinden van mensen die middels HA of domoticz of dergelijke platforms soortgelijke dingen doen, maar wij hebben verder nog geen domotica, dus ik wilde nog niet meteen in die hele wereld duiken.

Zou prima met een uno kunnen, kwa geheugen hangt van je programming skills af

[AteGjalt]

Toiletman schreef op zondag 8 augustus 2021 @ 21:52:
'avond. Na een aantal jaar geen Arduino meer aangeraakt te hebben ligt er een mooi project in het verschiet: het automatiseren van de tuinberegening:

Ruwe situatieschets:

Outputs:
7x 24V AC kleppen (solenoids)
1x 230V AC Pomp
1x 230V AC Heater

Inputs:
- weersvoorspelling
- temperatuursensor technische ruimte
- waternivosensor (waterdichte drukmeter?)
- watersensor overstort
- watersensor lekkage
- (luchtvochtigheid)
- (T buiten)
- (lichtintensiteit buiten?)

Ik zit nog een beetje te twijfelen over de aanpak maar ik zat te denken aan een Arduino setup via ethernet. Datalogging kan dan via de NAS, en eventueel parsen van weerdata en instellen van irrigatieplannen ook. Dat kan dan via ethernet naar de arduino als input.

Qua hoeveelheid inputs/outputs zou het gewoon met een Uno moeten kunnen, waarbij ik me echter afvraag of de hoeveelheid geheugen wel ok is?

Een alternatief zou zijn om meer werk op de Arduino zelf te doen en de NAS minder te laten doen (alleen logging?). Het lijkt me dat je dan al echt wel op een Mega uitkomt?

Hoe kijken jullie hier tegenaan? Uno of Mega? Of zou het met allebei wel moeten lukken?

Qua verdere hardware ben ik nog een beetje aan het rondshoppen, qua outputs heb ik in ieder geval deze relais gevonden:
8CH 5V relais bordje
5V 40A 230V SSR
Het 8CH bordje zal via een aparte 5V voeding moeten worden gevoed omdat de Arduino niet genoeg stroom kan leveren.
De 230V relais lijken me wel handig om in een aparte behuizing te doen en de pomp trekt max 6A, dus met de meeste 'dev boardjes kom je er toch niet.

In totaal levert dit al wel een hoop voedingen op:
5VDC voor de 8CH relais
7/9VDC voor de Arduino zelf
24VAC voor de kleppen
(en natuurlijk 230V voor alles)... kan dit nog op een fraaiere manier?

Qua aansturing via ethernet is er natuurlijk het ethernet shield van arduino, maar ik kwam ook dit boardje tegen: goedkoper en ook een stuk minder 'intrusive'. Iemand ervaring met (één van) beide oplossingen?

Naar het hele sensorgebeuren moet ik nog gaan kijken, dat wordt waarschijnlijk volgend weekend.

Hoe kijken jullie hier tegenaan? Ben ik op de juiste weg? Andere ideeën?

In domotica is natuurlijk behoorlijk wat te vinden van mensen die middels HA of domoticz of dergelijke platforms soortgelijke dingen doen, maar wij hebben verder nog geen domotica, dus ik wilde nog niet meteen in die hele wereld duiken.

Ik zou voor de zekerheid voor een mega gaan, afhankelijk van de sensoren en libraries kan het aardig in het geheugen gaan zitten. De extra IOs zijn dan mooi meegenomen voor eventuele uitbreidingen.
Je kan van tevoren een sketch maken met alle nodige libraries geimporteerd en alle stukjes voorbeeld en dan kijken of t wil compilen voor de uno.
Voor waterniveau kan je ook kijken of ultrasoon een optie is of een magnetische vlotter en een aantal reedswitches.

[mcDavid]

@Toiletman ik zou uberhaupt afraden zoveel functionaliteit op één arduino te hangen. Niet omdat het niet kan, maar praktisch is anders. Waarschijnlijk zitten niet al die sensoren in één behuizing, dus krijg je allereerst al te maken met grote kabellengtes waar niet alle sensoren mee overweg zullen kunnnen. Daarnaast wordt de firmware flink ingewikkelder naar mate je meer dingen "parallel" wilt doen (iets wat op een uC eigenlijk niet kan natuurlijk).

Ik zou gewoon een handjevol ESP8266's pakken en niet teveel tegelijk op één apparaat willen doen.

[Septillion]

@Toiletman Ik zou zelf nooit voor een Mega gaan, wat een hel aan draadjes maak je er dan van. Gezien je ethernet wilt, een ESP'tje? En dan gewoon er een paar IO extenders aan hangen, blijft het veel netter van.

Of zoals @mcDavid ook suggereert, een handje vol ESP's als het niet allemaal bij elkaar zit.

Qua power, als je voor een 3v3 Arduino gaat kan je gewoon alles vanaf de 5V doen. Als je voor een 5V versie gaat zou ik 12V relays pakken en dit ook gewoon aan de Arduino voeren. Even een diode en een condensator er tussen en gaan. Onboard regulator van meeste bordjes is wat krap maar als je niet zo veel stuurt op 5V gaat het wel. Anders extern een step down converter naar 5V ertegenaan gooien.

[Tom]

Ik heb een Arduino MKR WiFi 1010 besteld, samen met de MRK IoT carrier. Zover ik gezien heb is dat erin klikken, voeding eraan en gaan. Voor een testje zou ik ook graag een camera bestellen (pré als er ook een microfoontje in zit). Kwaliteit is ondergeschikt (mits niet 15 jaar terug gsm-camera in de tijd qua kwaliteit), het is meer voor een proof-of-concept.

Nu kom ik wel camera's tegen, maar ik weet niet goed welke compatible zijn (en voor een leek ook aan de gang te krijgen binnen Arduino). Het liefst zonder te solderen, maar die eis moet ik denk ik laten vallen? Of is er iets met een stekkertje dat op dat carrier-bordje past?

[AteGjalt]

Tom schreef op maandag 9 augustus 2021 @ 14:24:
Ik heb een Arduino MKR WiFi 1010 besteld, samen met de MRK IoT carrier. Zover ik gezien heb is dat erin klikken, voeding eraan en gaan. Voor een testje zou ik ook graag een camera bestellen (pré als er ook een microfoontje in zit). Kwaliteit is ondergeschikt (mits niet 15 jaar terug gsm-camera in de tijd qua kwaliteit), het is meer voor een proof-of-concept.

Nu kom ik wel camera's tegen, maar ik weet niet goed welke compatible zijn (en voor een leek ook aan de gang te krijgen binnen Arduino). Het liefst zonder te solderen, maar die eis moet ik denk ik laten vallen? Of is er iets met een stekkertje dat op dat carrier-bordje past?

Denk dat je moet kijken naar een arducam oid. Een ESP32-CAM is misschien ook een optie.
Beeld en geluid wordt lastig voor een arduino, dan moet je overstappen naar wat krachtigers als een raspberry.

[Tom]

Thanks. Vergeten om te vermelden dat het geen live-feed hoeft te zijn. Als ik er met een event een still (jpg) uit kan halen is dat voldoende.

[Toiletman]

Bedankt voor alle input!

itcouldbeanyone schreef op maandag 9 augustus 2021 [~ i.Stijn] 07:19:
[...]
Zou prima met een uno kunnen, kwa geheugen hangt van je programming skills af

Die zijn niet zo denderend, vandaar .

AteGjalt schreef op maandag 9 augustus 2021 @ 09:49:
[...]
Ik zou voor de zekerheid voor een mega gaan, afhankelijk van de sensoren en libraries kan het aardig in het geheugen gaan zitten. De extra IOs zijn dan mooi meegenomen voor eventuele uitbreidingen.
Je kan van tevoren een sketch maken met alle nodige libraries geimporteerd en alle stukjes voorbeeld en dan kijken of t wil compilen voor de uno.
Voor waterniveau kan je ook kijken of ultrasoon een optie is of een magnetische vlotter en een aantal reedswitches.

Thx! Interessant idee om met een ultrasoon aan de slag te gaan, die zou ik zelfs nog wel moeten hebben liggen.

mcDavid schreef op maandag 9 augustus 2021 @ 10:01:
@Toiletman ik zou uberhaupt afraden zoveel functionaliteit op één arduino te hangen. Niet omdat het niet kan, maar praktisch is anders. Waarschijnlijk zitten niet al die sensoren in één behuizing, dus krijg je allereerst al te maken met grote kabellengtes waar niet alle sensoren mee overweg zullen kunnnen. Daarnaast wordt de firmware flink ingewikkelder naar mate je meer dingen "parallel" wilt doen (iets wat op een uC eigenlijk niet kan natuurlijk).

Ik zou gewoon een handjevol ESP8266's pakken en niet teveel tegelijk op één apparaat willen doen.

mbt 'parallel' is dat niet echt aan de orde, 1x per minuut dataloggen is waarschijnlijk al overkill, dus het alles mag gewoon sequentieel en het mag nog lang duren ook.

Septillion schreef op maandag 9 augustus 2021 @ 10:13:
@Toiletman Ik zou zelf nooit voor een Mega gaan, wat een hel aan draadjes maak je er dan van. Gezien je ethernet wilt, een ESP'tje? En dan gewoon er een paar IO extenders aan hangen, blijft het veel netter van.

Of zoals @mcDavid ook suggereert, een handje vol ESP's als het niet allemaal bij elkaar zit.

Qua power, als je voor een 3v3 Arduino gaat kan je gewoon alles vanaf de 5V doen. Als je voor een 5V versie gaat zou ik 12V relays pakken en dit ook gewoon aan de Arduino voeren. Even een diode en een condensator er tussen en gaan. Onboard regulator van meeste bordjes is wat krap maar als je niet zo veel stuurt op 5V gaat het wel. Anders extern een step down converter naar 5V ertegenaan gooien.

Ik pak jullie reacties mbt ESP en draadjes even samen hoor:
Die ESP's had ik al wel eens van gehoord, maar vooral als wifi chip. Er zit blijkbaar ook ethernet bij, maar kaartjes waar die ook daadwerkelijk gebruikt zijn een stuk prijziger dan de typische paar dollar. Ik ben zelf niet zo denderend qua elektronica solderen en dergelijke, dus ik heb het liefst iets dat out of the box al redelijk goed werkt.
Of bedoelen jullie om gewoon met de wifi versies aan de slag te gaan? Qua beveiliging en ethervervuiling heb ik het liever bedraad.
Het voordeel van ESP's met extenderboardjes is dat je dan de draadjes fysiek wat beter van elkaar kunt scheiden? Of begrijp ik het verkeerd?

Qua draadjes is de grootste bende natuurlijk de 8 kleppen, maar die leken me redelijk netjes weg te werken door het relaisbord en de kleppen redelijk dicht bij elkaar te zetten en de signaaldraden vanuit de mega middels UTP kabel te doen (dus één draad met een hoop aders).
Het sensorgebeuren moet ik nog wat dieper induiken, maar dat zou inderdaad nogal een zooitje kunnen worden met wat er allemaal heen en weer moet... maar ook daar wellicht dat één of twee UTP kabels een hoop kunnen vervoeren zonder een enorme chaos.

Je voedingsadvies snijdt wel hout, ik zal eens kijken wat de opties voor 3,3V arduino zijn, of anders 12V relais.

[LooneyTunes]

Toiletman schreef op maandag 9 augustus 2021 @ 22:57:

Qua draadjes is de grootste bende natuurlijk de 8 kleppen, maar die leken me redelijk netjes weg te werken door het relaisbord en de kleppen redelijk dicht bij elkaar te zetten en de signaaldraden vanuit de mega middels UTP kabel te doen (dus één draad met een hoop aders).

Let dan vooral op de lengte van je kabel (heen en terug) en het stroomverbruik van de kleppen. (~1 Ampère schijnt normaal te zijn bij 24v AC)
Ethernetkabel is niet gemaakt voor stroom .
En natuurlijk geleiders van koper en geen aluminium en/of ijzer.

[ Voor 5% gewijzigd door LooneyTunes op 10-08-2021 11:23 ]

[mcDavid]

LooneyTunes schreef op maandag 9 augustus 2021 @ 23:53:
[...]

Ik pak jullie reacties mbt ESP en draadjes even samen hoor:
Die ESP's had ik al wel eens van gehoord, maar vooral als wifi chip. Er zit blijkbaar ook ethernet bij, maar kaartjes waar die ook daadwerkelijk gebruikt zijn een stuk prijziger dan de typische paar dollar. Ik ben zelf niet zo denderend qua elektronica solderen en dergelijke, dus ik heb het liefst iets dat out of the box al redelijk goed werkt.
Of bedoelen jullie om gewoon met de wifi versies aan de slag te gaan? Qua beveiliging en ethervervuiling heb ik het liever bedraad.
Het voordeel van ESP's met extenderboardjes is dat je dan de draadjes fysiek wat beter van elkaar kunt scheiden? Of begrijp ik het verkeerd?

Oh, dat er ethernetvarianten bestaan wist ik niet eens. Ik zou gewoon lekker met wifi werken. Hoeveel "ethervervuiling" verwacht je van een boardje dat 1x per minuut een handjevol TCP pakketjes verstuurt? Duty cycle zal nog geen honderste zijn van je telefoon of zo. En wifi is over het algemeen een stuk veiliger dan ethernet. Tenzij je 802.1x geimplementeerd hebt maar dat betwijfel ik (en twijfel nog harder of uC-libraries dat ondersteunen).

[Septillion]

@Toiletman Als je de boel stabiel wilt hebben zal je toch echt moeten solderen, alles met een bende Dupond draadjes doen is ook wel vragen om problemen in een project van dit formaat. Zeker omdat als je wat lengte hebt naar sensoren je waarschijnlijk ook nog wel een beetje filtering wilt doen.

En ja, de ESP kan ook wel werken met bedraad ethernet, volgens mij ook wel met de gelinkte module, maar het is wel wat meer werk dan gewoon de wifi. Voor ethervervuiling hoef je niet bang te zijn als je nu al wifi hebt. Bordje zal daar amper aan bijdragen, zeker als hij maar 1x per uur wat moet loggen. En beveiliging, als je nu ook wifi draait verandert een extra wifi client daar natuurlijk niets aan. Dus tenzij je nu helemaal geen Wifi hebt is dat geen issue.

Extra voordeel van een ESP over een klassieke 8-bit Arduino is dat je veel meer rekenkracht en geheugen hebt, erg fijn als je internet/netwerk zaken gaat doen.

En ja, als je wat behapbare modules hebt kan je die mooi kort aansluiten op waar het nodig is. Zet ze op een printplaat met wat connectoren / aansluitingen (en filtering) voor de sensoren etc. Want daar zie ik meer draden rommel (samen met dat een Arduino altijd te weinig power en GND aansluitingen heeft). Zoveel draadjes op een Mega aansluiten eindigt naar mijn idee altijd alleen maar in spaghetti bolognese. Niet zo zeer door de draadlengtes maar meer dat het gewoon veel draadjes zijn. Ook al pak je UTP, het blijven veel draadjes om aan te sluiten op een Mega. Printjes maken (en dat kan gewoon met experimenteerprint) waar je modules in drukt (ESP's, port expanders maar ook liever een Nano / Pro Mini ipv een Uno/Mega) en dan connectoren maakt de boel al stuk netter. Ook kan je dan makkelijk het project in delen hakken om te ontwikkelen en om te testen.

En relais board wil je gewoon dicht bij je microcontroller hebben. De draden naar de kleppen kunnen lang zijn. Vergeet daar de blusdiode (indien DC of snubber indien AC) niet.

[AteGjalt]

Tom schreef op maandag 9 augustus 2021 @ 15:40:
Thanks. Vergeten om te vermelden dat het geen live-feed hoeft te zijn. Als ik er met een event een still (jpg) uit kan halen is dat voldoende.

Dan zou ik gewoon voor een ESP32-CAM gaan, genoeg voorbeelden beschikbaar op internet.
Zelf gebruik ik er ook één om elke 10min een foto naar een http server te sturen.

[Raven]

Kent iemand toevallig een >=16bit ADC met samplerate dat hoog genoeg is om een sinus van 50Hz te kunnen meten en dat een Arduino library heeft? Zit al even te zoeken, helaas zonder succes. Er zijn genoeg ADC's, maar een beetje rappe ADC (>=10ksps) met Arduino lib heb ik nog niet kunnen vinden.

[Atmoz]

Kan iemand mij uitleggen hoe (of nog beter: waarom* ) onderstaande code precies werkt?

code:

void breatheUpdate(const uint8_t * segment, const uint32_t increment, const uint8_t step, const uint8_t lowLimit)
{
  static uint32_t lastTimeChange = 0;
  static uint8_t direction = 1;
  static uint8_t value = lowLimit;
  if(millis() - lastTimeChange > increment)
  {
    value += (direction * step);
    if (value <= lowLimit || value >= 255)
    {
      direction = direction * -1;
    }
    for(uint8_t i = 0; i < sizeof(segment); i++)
    {
      strip.setPixelColor(segment[i], strip.Color(0, 0, value));
    }
    strip.show();
    lastTimeChange += increment;
  }
}

Boven setup() doe ik:

const uint8_t mySegment[] = {0,1,2,3};

In de main-loop roep ik dit aan als:

breatheUpdate(mySegment, 5, 1, 0);


Wat ik dus echt niet snap is hoe dit kan werken zonder dat er "ergens" (extern) buiten de functie zélf een variabele wordt gebruikt om de huidige "status" in op te slaan. Iets dat ik zelf wel altijd gebruik om vervolgens met behulp van millis() iets te doen.

Iemand die dit kan uitleggen?


*ik heb deze code ergens online gevonden en hij werkt perfect --> 4 LED's van een NeoPixel LED-strip faden hiermee netjes aan/uit


[edit]

Ik vraag dit overigens niet alleen uit interesse/nieuwsgierigheid, ik zou het ook graag weten om een probleempje op te lossen:

De aanroep in de main-loop werkt opzich heel goed, maar als ik tussendoor iets anders heb gedaan (servotje laten bewegen) dan knipperen de LED's eerst even heel snel (dus niet meer "breathend").

Dat vind ik niet mooi en zou ik graag willen oplossen. Dus daarom was ik opzoek naar die "externe" variabele om het "breathen" opnieuw te laten beginnen

De 2e vraag is dan eigenlijk ook: hoe kan het dat de LED's ineens heel snel gaan knipperen nadat de microprocessor even iets anders heeft gedaan? Het lijkt er net op alsof "er iets in te halen is" ofzo

[ Voor 21% gewijzigd door Atmoz op 28-10-2021 10:04 ]

[DataGhost]

Classic fout haha.
Om te beginnen, de staat wordt opgeslagen in de static variabelen. In het kort komt het erop neer dat de initiële toewijzing aan een static variabele slechts de eerste keer dat de functie wordt aangeroepen wordt gedaan en dat de variabelen zelf (binnen de scope van de functie) blijven bestaan. Dus de eerste aanroep is lastTimeChange 0, als deze in de functie veranderd wordt naar 5, zal deze in de volgende aanroep ook 5 zijn en niet op 0 gezet worden.

Nou naar het "classic" gedeelte. Op regel 6 wordt gekeken hoeveel tijd er verstreken is, en of dat meer is dan increment. Dus zegmaar tijdVerstreken = millis() - lastTimeChange. Als tijdVerstreken > increment dan moet er iets gaan gebeuren. Tot zover logisch. Alleen op regel 18 wordt iets gedaan waardoor de naam van lastTimeChange niet meer klopt. De laatste keer dat er iets veranderd is is namelijk op millis() en niet op lastTimeChange + increment. Als je dus je increment op 5ms hebt, en je CPU is 200ms met iets anders bezig, duurt het 40 calls voordat lastTimeChange weer bij is met millis(). Dus je functie wordt heel vaak heel snel achter elkaar uitgevoerd. De makkelijke fix is increment op regel 18 vervangen door millis(). Liefst doe je maar 1 aanroep naar millis() en sla je die op in een variabele trouwens, voor het geval deze tussen regel 6 en 18 verhoogt, maar die kans is in dit geval niet heel groot. Wat er dan gaat gebeuren is dat je breathe gewoon eventjes stilstaat terwijl je CPU bezig is, en daarna verder gaat waar 'ie mee bezig was. Als je dat wilt veranderen zal je de aansturing van je servo non-blocking moeten maken (net als deze breathe), en misschien ook de breathe-functie nog verder aanpassen zodat de snelheid afhangt van de precieze hoeveelheid verstreken tijd, anders zal deze alsnog marginaal langzamer gaan breathen als er veel servo-aansturing gedaan wordt.

[Atmoz]

DataGhost schreef op donderdag 28 oktober 2021 @ 10:44:

...uitgebreid + interessant verhaal...

Wow! Dat wist ik écht niet... *schaam schaam*

En thanks voor je uitgebreide en duidelijke antwoord
Weer wat geleerd vandaag!

Super bedankt

[SToRM666]

Even dit topic een beetje vanonder het stof halen. Ik heb recent ook een leuk project (bijna) afgewerkt, ik heb namelijk een shuffleton gebouwd.

Een korte uitleg van hoe het werkt. Je speelt met maximum 4 spelers over verschillende rondes. Elke beurt probeer je met 7 munten een zo hoog mogelijke score te gooien door in de gaten te gooien. Dit gaat door tot iemand een totaalscore van over de 6000 heeft. De huidige ronde wordt dan nog afgewerkt en de winnaar is dan degene met de hoogste totaalscore.

Je ziet 5 scoreschermpjes, degene in de hoeken zijn de totaalscores per speler en degene net onder het midden is de gegooide score in de huidige beurt voor een speler. De kleine scores zijn de gegooide gaten en bij een bonus (bovenste 3 gaten of de 2 buitenste) worden deze in het groen weergegeven

Het systeem van een munt betalen per speler heb ik vervangen door een knop met LED verlichting. En daarnaast heb ik dan nog een knop voorzien om naar de volgende speler te gaan. Ik heb als extra optie ook nog ingebouwd dat je kan bepalen tot welke score er gegooid moet worden (zit niet in het origineel).

Hij is nog niet helemaal af, maar hij werkt nu wel volledig! Het scorebord moet nog afgewerkt worden en ik zit er ook aan te denken om geluid toe te voegen (als ik de originele geluiden zou kunnen vinden zou dat super zijn).

Wat foto's :





Voor de gaten heb ik zelf een huls ontworpen en geprint waar een sensor in past:



En dit is zo ongeveer de laatste status:



Dat zwarte vlak is een stuk plexiglas dat ik wat donkerder gemaakt heb, zodat de scores nog af te lezen zijn. Uiteindelijk wil ik op die plek een groot plexiglas plaatsen met een "shuffleton" sticker erop en dan het plexiglas donkerder maken waar de scores zitten.

Het is echt een erg leuk spel om met een biertje erbij te spelen. Ik heb met de bouw van deze in ieder geval al enorm veel nieuwe dingen geleerd die ik in een nieuwe versie anders zou willen doen
Een originele Shuffleton kan je al niet meer nieuw kopen, maar je kan ze soms nog wel tweedehands vinden.

[ Voor 12% gewijzigd door SToRM666 op 17-11-2022 21:37 ]

[SToRM666]

Ik ben ondertussen weeral wat verder aan het ontwikkelen en ik heb nu een update klaar staan met een full-color P4 LED matrix van 32x64 pixels:



Ziet er behoorlijk goed uit en het is echt veeel gemakkelijker qua soldeerwerk en dergelijke

[theorganiser]

Ik heb hier al een tijd van alles liggen denk aan :
bijna alles is nog nieuw

1. Arduino Nano v3
2. Allerlei weerstandjes
3. ledlampjes, display
4. allerlei andere kleine accessoires ( zat ook in een starterpakket)

voor de liefhebber mag dit afgehaald worden in Naarden, of voor een 10tje wil ik het ook wel opsturen.
Stuur een prive berichtje bij interesse

Edit:
Opgehaald !

[ Voor 8% gewijzigd door theorganiser op 09-12-2022 11:50 ]

[lloullou]

Voor diensten en betaalde opdrachten hebben we vraag en aanbod, zie onder andere
categorie: Software development

[ Voor 78% gewijzigd door _ferry_ op 19-03-2023 14:41 ]

[barrymossel]

Ik ben bezig met een klein projectje om een virtuele (bluetooth) muis te laten bewegen op meerdere manier op basis van MQTT.

Momenteel is de loop:

Arduino:

void loop() {
  if (command == 1) {
    Serial.println("Ik doe helemaal niks");
    delay(1000);
  } else if (command == 2) {
    Serial.println("Move mouse pointer up");
    Mouse.move(0,-1);
    delay(1000);
    Serial.println("Move mouse pointer right");
    Mouse.move(1,0);
    delay(1000);
    Serial.println("Move mouse pointer down");
    Mouse.move(0,1);
    delay(1000);
    Serial.println("Move mouse pointer left");
    Mouse.move(-1,0);
    delay(1000);
  } else if (command == 3) {
    int distance = random(10, 600);
    int x = random(3) - 1;
    int y = random(3) - 1;
    for (int i = 0; i < distance; i++) {
    
    Mouse.move(x, y, 0);
    delay(move_interval);

  }
  
  if (random(0,7) == 3 )
        Mouse.click(MOUSE_RIGHT);
  
  delay(loop_interval);
  }

  mqttClient.loop();
}

Die delays blokkeren de loop en dat is niet wenselijk. Dit kan ik voorkomen door het gebruik van millis, maar hoe doe ik dit dan bij mijn "command==2"? Dus met:

Arduino:

    Serial.println("Move mouse pointer up");
    Mouse.move(0,-1);
    delay(1000);
    Serial.println("Move mouse pointer right");
    Mouse.move(1,0);
    delay(1000);
    Serial.println("Move mouse pointer down");
    Mouse.move(0,1);
    delay(1000);
    Serial.println("Move mouse pointer left");
    Mouse.move(-1,0);
    delay(1000);

[DataGhost]

Eigenlijk op dezelfde manier maar dan moet je ook de huidige state bijhouden, die je na elke sub-actie verandert dus.

[SToRM666]

SToRM666 schreef op woensdag 7 december 2022 @ 21:52:
Ik ben ondertussen weeral wat verder aan het ontwikkelen en ik heb nu een update klaar staan met een full-color P4 LED matrix van 32x64 pixels:

[Afbeelding] [Afbeelding]

Ziet er behoorlijk goed uit en het is echt veeel gemakkelijker qua soldeerwerk en dergelijke

Met dit type scherm heb ik nu net mijn laatste versie van mijn darts scorebord gemaakt (met de stem van Russ Bray):



Deze stuur je dus via rf aan met het losse toetsenbord, maar die ga ik nog wat herwerken😊
Er zijn al losse accu’s onderweg en ik ga de toetsen zelf en de onderlinge afstand nog wat aanpassen. Het zijn cherry mx blue toetsen, dus dat typt wel vrij goed.

[ Voor 7% gewijzigd door SToRM666 op 24-01-2024 09:08 ]

[breinonline]

Vraagje. Ik probeer een serie leds te starten op basis van een tijdslijn. Sommige in een keer, sommige via een fade en 2 die moeten knipperen in een bepaald ritme. Die laatste werkt prima als losse functie (dus alleen knipperen uploaden naar de arduino) maar in de totale tijdslijn gaat de led op pin 8 zwakker mee in het ritme. Kan iemand mij verklaren waar dat hem in zit?

C++:

// =============== Voyager LED sequence =============== //
// Note: Total duration per fade: (miliseconds) = maxPWM / fadeIncrement * fadeInterval

// =============== Configuration =============== //
// Configuration strobes
const int pin_Strobe[] = {7, 8, 8, 7};                                      // Strobe LED pins are triggered in this sequence after the period in array_Strobe has passed
unsigned long array_Strobe[] = {3250, 50, 150, 50};                         // Array {OFF, ON, etc.}. How in setup the leds are initalized determines the first state (LOW = off, HIGH = on)
const byte interval_Strobe = sizeof(array_Strobe) / sizeof(unsigned long);  // Tracker for how many intervals have past
byte civ_Strobe = 0;                                                        // Current Interval Value counter
unsigned long pmillis_Strobe = 0;                                           // Millis start value

// Configuration fade: all arrays are only nessessary for fading leds. But they are all filled so a pwm led can be on each position in the sequence.
// Lights(indexnrs): Cabin(0), Navigation(1), strobes(2), Deflector(3), Impulse(4), Nacelles(5), Floodlight(6), Torpedo(7) 
//                              { 0,    1,    2,   *3,   *4,   *5,   *6,    7     }  // Array index number (* = PWM function in use)
const int LED[8] =              { 6,    12,   7,    11,   10,   9,    3,    5     }; // Pin nrs
const int maxPWM[8] =           { 255,  255,  255,  255,  255,  255,  255,  255   }; // Max brightness
const int Time[8] =             { 1000, 1000, 4000, 5500, 7000, 8500, 10500,10500 }; // Start time for led to go on (counted from time = 0)
int fadeValue[8] =              { 0,    0,    0,    0,    0,    0,    0,    0     }; // Start fade higher then 0 (from start timeline)
int fadeInterval[8] =           { 50,   50,   50,   50,   50,   50,   50,   50    }; // How fast to increment?
byte fadeIncrement[8] =         { 5,    5,    5,    2,    3,    3,    3,    5     }; // How smooth to fade? Lower = smoother.
unsigned long pmillis_Fade[8] = { 0,    0,    0,    0,    0,    0,    0,    0     }; // millis() timing Variable for fading
unsigned long pmillis_Seq = 0;                                                       // millis() timing Variable for startsequence
byte fadeDirection = 0;                                                              // Variable for fade Direction (0 = up, 1 = down)

// =============== SETUP =============== //
void setup()
{
  for (int y=0; y < 8; y++) {            // Look up all led pins in array,
    pinMode(LED[y], OUTPUT); }             // and set all LED's in the array to output
  digitalWrite(8, LOW);                  // Write initial state of strobe light 1
  digitalWrite(LED[2], LOW);             // Write initial state of strobe light 2
  for (int x=3; x < 7; x++) {            // Look up all PWM led pins in array (only possible if next to each other in the array),
    analogWrite(LED[x], fadeValue[x]); }   // and write initial state of fade leds
}

// =============== FUNCTIONS =============== //
void Strobe(unsigned long now) {                                                    // Strobes function
  if (now - pmillis_Strobe >= array_Strobe[civ_Strobe]) {                           // If the time interval has elapsed,
     civ_Strobe = civ_Strobe + 1;                                                     // select the next interval in the list,
        if (civ_Strobe >= interval_Strobe) {                                            // if all intervals in array have been past,
           civ_Strobe = 0; }                                                            // reset the array to start,
    digitalWrite(pin_Strobe[civ_Strobe], not digitalRead(pin_Strobe[civ_Strobe]));    // change state of the LED each next interval step,
    pmillis_Strobe = now; }                                                           // save the time of change
}

void Fade(unsigned long now, int x) {                          // Fade function
   if (now - pmillis_Fade[x] >= fadeInterval[x]) {             // If the time interval has elapsed,
      fadeValue[x] = fadeValue[x] + fadeIncrement[x];            // select the next interval in the list,
         if (fadeValue[x] >= maxPWM[x]) {                          // if all intervals have been past,
            fadeValue[x] = maxPWM[x]; }                            // end fade and keep it max,
      analogWrite(LED[x], fadeValue[x]);                         // write brightness to led,
      pmillis_Fade[x] = now; }                                   // save the time of change.
}

// =============== LOOP =============== //
void loop()
{
  unsigned long now = millis(); // Get current value of millisecond counter for functions

// Start startsequence
 for (int y=0; y < 8; y++) {                  // For each index in the array
    if (now - pmillis_Seq > Time[y]) {          // If time in array has past (counted from start timeline), 
       if ( y==3 || y==4 || y==5 || y==6 ) {      // if index is a pwm led,
          Fade(now, y); }                         // call fade function with current millis
       else if ( y == 2 ) {                     // Else if index is the strobes,
          Strobe(now); }                          // call the strobes function
       else {                                   // If not pwm led of strobe,
          digitalWrite(LED[y], HIGH);}            // just switch on led
    }
 }
  Strobe(now);                                // Update strobes

}

[Septillion]

@breinonline Voor pin 8 zet je nooit de pinMode.

Waarom is überhaupt pin_Strobe een losse array? Of andersom, waarom niet een array per functie? Nu heb je dus veel variabelen in arrays die je nooit gebruikt.

Daarnaast, de indentatie en brackets zijn wel een beeeetje all over the place...

[breinonline]

Septillion schreef op zondag 23 juni 2024 @ 14:06:
@breinonline Voor pin 8 zet je nooit de pinMode.

Dat was hem! Dank

Waarom is überhaupt pin_Strobe een losse array? Of andersom, waarom niet een array per functie? Nu heb je dus veel variabelen in arrays die je nooit gebruikt.

Daarnaast, de indentatie en brackets zijn wel een beeeetje all over the place...

Dank voor de opbouwende kritiek. Het is mijn eerste project in C++...
De strobes wil ik 200ms na elkaar hebben. Dat is te doen met twee losse functies (dat had ik eerst). Ik wil nog combineren met een dubbele schakelaar dat de lichten een voor een starten (deze code) en de andere schakeloptie alles maar zonder de strobes. Alle pogingen daartoe leiden er steeds toe dat de strobes toch vaak out-of-sync gaan lopen.
Om dat te voorkomen heb ik ze juist samengevoegd. Maar dan moet de ene keer naar de ene pin geschreven worden (2x: aan en uit) en dan naar de andere. Dat bereik ik met deze array. Maar als dat handiger kan dan hoor ik het graag.

[Raven]

Is er iemand toevallig bekend met de ESP-201?



Aangesloten zoals ^, maar Arduino IDE krijgt geen verbinding, al zie ik tijdens het connecting de blauwe LED wel knipperen, maar verder niets. Eindigt met "A fatal esptool.py error occurred: Failed to connect to ESP8266: Timed out waiting for packet header"

GPIO0 hangt uiteraard aan de ground tijdens het flashen.

[Septillion]

@Raven Je zegt, GPIO0 hangt aan GND, maar reset je hem daarna ook wel?

[Raven]

@Septillion Jup, zowel resetknop geprobeerd als de 3.3V lijn erachter weg.

[Septillion]

@Raven Je USB Serial doet op de datalijnen ook netjes 3v3?

En Rx en Tx zitten goed? Eventueel keer omdraaien voor als de labels toch voor de counter part bleken.

En als het op een breadboard is, alle verbindingen triple checken.

[Raven]

@Septillion Check, sterker nog, deze FTDI-kabel is berucht Het is die van Sparkfun die door een communicatiefout wel 3.3V datalijnen heeft, maar 5V op de VCC draad heeft

Originally, the cable was designed to have 3.3V VCC, however something was lost in translation between SparkFun and our supplier and we got stuck with a whole bunch of FTDI cables that have a slight mix up in wiring. These have 5V VCC, and 3.3V I/O. The 5V Vcc output shouldn't be a problem unless this cable is being used to power a sensitive circuit such as a sensor.

uiteraard AMS1117 eraan voor 3.3V.

Rx/Tx meerdere keren gechecked en als ik ze omdraai (verkeerd plaats) dan licht de blauwe LED niet op bij activiteit.

Inderdaad breadboard, alles gecheckt. Enige wat ik nog kan doen is een andere ESP-201 (heb er 2) erop drukken, alleen moet ik bij die de niet-breadboard vriendelijke UART-header eraf solderen en vervangen door een ge-angled versie. Die zit namelijk dezelfde richting op gesoldeerd als de headers aan de zijkanten

edit: Net ff 5V ergens anders weggehaald, voor het geval de FTDI-kabel niet genoeg kan leveren, maakte geen verschil.

[ Voor 5% gewijzigd door Raven op 05-10-2024 17:25 ]

[Septillion]

@Raven Dat is wel irritant van de headers ja. Überhaupt borden zonder auto-reset zijn irritant

Loopback test van de kabel lukt wel gewoon?

[Raven]

@Septillion Check, kabel is goed.

[Raven]

@Septillion Het ingebakken AP (AI-THINKER_CC4822) werkt overigens wel (mits boot normale modus), kan er verbinding mee maken, maar IP-adres in browser openen geeft connection refused.

[kitao]

Debugging not supported ...
Jammer want ik had graag wat register waardes in de codeflow willen zien bij een Arduino Assembly programma.
In Micro Chip Studio 7 blijkt dit wel mogelijk te zijn, na het maken van een New Project, via het veldje Arduino Projects.
Dit is me alleen gelukt met de oudere Arduino IDE-versie 1.8.19, met de meest recente versie 2.3.4 loopt het spaak (?)
Mogelijke oorzaak daarvan staat hier :
https://forum.microchip.c...5C3l000000MfQzEAK/t388636
Onderste post, verouderde zooi

Voor wie het ook wil proberen, of tips heeft over de gevolgde methode, kijk deze twee videos, die onderdeel zijn van playlists :

YouTube: Assembly via Arduino (part 1) - Introduction
YouTube: #56 Programming the Arduino Uno Using Atmel Studio 7

De tweede video is nodig om de Uno via Usb vanuit MCS7 te programmeren/uploaden.
Het assembly gedeelte heb ik handmatig kunnen toevoegen, dat betreft de eerste video.
Rechtsklik op het bestand en Add File (bij de rode pijl) :



Resultaat is dat een Arduino sketch in assembly geschreven kan worden en met MCS7 gedebugged en opgeladen kan worden op een bordje. Of in een simulator, zie mijn post in EL-kroeg.

[kitao]

Voorbeeldje overzetten van Assembly Arduino IDE naar Proteus Debugger :



YouTube: Assembly via Arduino (part 1) - Introduction

YouTube: Assembly via Arduino (part 5) - Programming LCD

Kuzechie legt uit dat de ino.file en de s.file dezelfde naam moeten hebben in de Arduino IDE.

In Proteus moet de main-file main.ino blijven heten.











Het is voor mij geen eitje gebleken om dit draaiend te krijgen met al die paths en project wizzards en dit is dan ook geen Instructable maar meer een globale wegwijzer naar de mogelijkheden.

============================= EDIT ================================

Hoewel het bovenstaande wel werkt met getoond LCD programma van Kuzechie lukt dat niet met een aantal anderen uit diezelfde serie.
Dat is op te lossen met op de gewone manier in Arduino IDE 2 de Kuzechie sketch te compilen en op te slaan, de Arduino IDE af te sluiten en dan vanuit Proteus die opgeslagen sketches handmatig met 'Add Existing File' toe te voegen en die nu dus wel dezelfde namen hebben.



En dit wordt dan de Proteus Wizard instelling :

[ Voor 32% gewijzigd door kitao op 20-12-2024 01:18 . Reden: Voortschrijdend inzicht ]

[kitao]

kitao schreef op zondag 15 december 2024 @ 14:14:
[Afbeelding]

Debugging not supported ...
Jammer want ik had graag wat register waardes in de codeflow willen zien bij een Arduino Assembly programma.
In Micro Chip Studio 7 blijkt dit wel mogelijk te zijn, na het maken van een New Project, via het veldje Arduino Projects.
Dit is me alleen gelukt met de oudere Arduino IDE-versie 1.8.19, met de meest recente versie 2.3.4 loopt het spaak (?)
Mogelijke oorzaak daarvan staat hier :
https://forum.microchip.c...5C3l000000MfQzEAK/t388636
Onderste post, verouderde zooi

Correctie : Inmiddels lukt het wel om Arduino IDE 2.3.4 op MCS7 te laten draaien.
Post wijzigen ging niet meer en ik wil geen software benadelen met bevindingen die achteraf niet helemaal kloppen, ook al weet ik niet waarom het nu wel werkt.

De Arduino sketchsjes met assembly zijn over te zetten naar zowel Proteus als naar MCS7.
Van die twee vind ik Proteus het fijnst om mee te oefenen.
Bij MCS7 kon ik niet uit een loop komen waarin Input werd gevraagd - van buitenaf, bijvoorbeeld een externe spanning op de ADC pinnen van de Arduino.
Step Out bleek niet te lukken bij MCS7 en bij Proteus wel.
Sowieso gaat daar het veranderen van input waardes makkelijker hoewel ik niet beweer dat dat bij MCS7 niet kan maar ik vermoed dat je dan een MCU erop aangesloten moet hebben met een MicroChip programmer ofzo. Of een speciaal bestandje :

Stimulus is the simulation of hardware signals/data into the device.
https://onlinedocs.microc...33-AC8D-4348B11BB2DB.html

Hieronder een voorbeeldje van een loop waar ik met Proteus wel kan Step Outen.



Dus al met al is mijn projectje om Arduino met assembly code, oftewel AVR Assembly, op zowel MCS7 als Proteus te debuggen en te simuleren best aardig gelukt

https://ww1.microchip.com...et-Manual-DS40002198A.pdf

Correctie 2 :

Register waarden kunnen eenvoudig handmatig gewijzigd worden. Dus een externe Stimulus is (in dit geval) niet nodig.
Het gaat bijvoorbeeld om onderstaande loop waar een ADCSAR-flag getest wordt of die op 1 staat.
Die blijkt handmatig ingevoerd te kunnen worden :

[ Voor 13% gewijzigd door kitao op 24-12-2024 15:31 . Reden: Voortschrijdend inzicht ]

[kitao]

kitao schreef op zondag 15 december 2024 @ 14:14:
[Afbeelding]

Debugging not supported ...
Jammer want ik had graag wat register waardes in de codeflow willen zien bij een Arduino Assembly programma.

Correctie 3 :
Het blijkt dus wel mogelijk te zijn om te debuggen in IDE2 als je maar het juiste boardje aansluit. Genoemd wordt bijvoorbeeld de Zero met onboard debug chip.

https://docs.arduino.cc/s...utorials/ide-v2-debugger/

[Danielson]

Waren kopen jullie je Arduino Nano's? Ik bestel ze over het algemeen op AliExpress of Amazon, maar dit zijn allemaal "Fake CH340" chips.

Waar vind ik orginele?

[Raven]

@Danielson Adafruit of NL-dealer Kiwi?

[Dutchess_Nicole]

Danielson schreef op dinsdag 14 januari 2025 @ 08:44:
Waren kopen jullie je Arduino Nano's? Ik bestel ze over het algemeen op AliExpress of Amazon, maar dit zijn allemaal "Fake CH340" chips.

Waar vind ik orginele?

Kiwi electronics is mijn go-to voor dit soort spul. Tinytronics ook voor andere boards.

[Septillion]

Danielson schreef op dinsdag 14 januari 2025 @ 08:44:
Waren kopen jullie je Arduino Nano's? Ik bestel ze over het algemeen op AliExpress of Amazon, maar dit zijn allemaal "Fake CH340" chips.

Waar vind ik orginele?

Naar mijn idee bestaat er niet zoiets als "fake CH340" chips... Dat is namelijk al gewoon een goedkoop China design. Afgezien van mensen die misschien geen drivers installeren er nooit een issue mee gezien. En geef zelf dus juist de voorkeur aan de CH340 boven FTDI of Silicon Labs chips omdat daar juist wel veel fakes voor in omloop zijn. (Die overigens in de basis prima werken maar door de driver kreupel gemaakt worden )

[Accretion]

Is d'r geen Nano variant van de Leonardo?

De 32u4 vindt ik ook wel leuk, juist omdat deze geen afzonderlijke usb-serial chip nodig heeft.

Alhoewel, tegenwoordig gebruik ik toch voornamelijk ESP32 gebaseerde bordjes.

[kitao]

De micro zie ik staan en daaronder nog wat alternatieven :

The Micro is a microcontroller board based on the ATmega32U4 (datasheet), developed in conjunction with Adafruit. It has 20 digital input/output pins (of which 7 can be used as PWM outputs and 12 as analog inputs), a 16 MHz crystal oscillator, a micro USB connection, an ICSP header, and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a micro USB cable to get started. It has a form factor that enables it to be easily placed on a breadboard.

The Micro board is similar to the Arduino Leonardo in that the ATmega32U4 has built-in USB communication, eliminating the need for a secondary processor. This allows the Micro to appear to a connected computer as a mouse and keyboard, in addition to a virtual (CDC) serial / COM port.

https://store.arduino.cc/en-nl/products/arduino-micro

[kitao]

In het midden een Avr Isp bootloader shield.

https://www.bitsandparts....ISP%20Shield%20Manual.pdf

https://github.com/RalphBacon/Bootloader-Shield-8MHz

Om een bootloader up te loaden zet je het shield op de Uno en dan kan er een bootloader in de zif-chip worden geprogrammeerd. Toen ik het shield bestelde dacht en hoopte ik eigenlijk dat ik zo ook andere 'normale' sketches kon uploaden in de 328P zif-chip. Dat blijkt niet te gaan want in de ISP-blokjes, die in elkaar klikken, zitten dan de Reset aan Reset vast, oftewel PC6 van de programmeerder Uno zit dan verbonden met de PC6 van de ontvanger.



https://www.diymore.cc/pr...rammer-for-arduino-uno-r3

Vandaar dat ik het blauwe draadje met pin 10, SS, op de Uno heb verbonden.
Dan blijkt het wel mogelijk een sketch in de Zif-chip te flashen, dit is een paar keer getest met blink-variaties na verplaatsing van de aldus geprogrammeerde chip naar het breadboard ernaast.

Wat ik mij nu afvraag is hoe het kan dat er wel met ingeklikte shield een bootloader in de ontvangende chip kan worden geschoten maar niet op dezelfde manier een andere sketch ?
Want, zo heb ik begrepen, een bootloader 'is ook maar een sketch net als iedere andere' en komt in hetzelfde geheugenblok terecht net als iedere andere sketch.

Paar andere linkjes die in relatie staan tot dit onderwerp :

YouTube: #119 Bootloader Shield 🛡️ and 8Mhz Arduino Barebones (made easy)

https://docs.arduino.cc/b...-isp/ArduinoToBreadboard/

kitao in "De EL-kroeg - Deel 4"



======================== Edit ==================================

Na verder rommelen met dit ding en iets strikter navolgen van de handleiding blijkt het toch mogelijk te zijn om met ingeklikt shield een normale sketch in de zif 328P chip te schieten.

Dit is de handleiding
https://github.com/RalphBacon/Bootloader-Shield-8MHz
en er staat in 5.1 om een folder in Examples te plaatsen maar je kunt net zo goed deze Ino-file
https://github.com/RalphB.../master/OPENSMART_ISP.ino
in een lege sketch plakken en dan volgens de handleiding naar de Uno uploaden met MKII programmer geselecteerd.

Eenmaal geupload via Tools de Programmer terugzetten naar Arduino as ISP, zie handleiding 5.2 stap 4, en in plaats van 'burn bootloader' kun je in die stap en met 'Upload using Programmer' een normale sketch erin schieten, bijvoorbeeld een Blink.

Inmiddels ook erachter gekomen dat met ingeklikt shield de bootloader die erin zit uitgelezen kan worden mbv de Board_Detector sketch en via de Serial Port Monitor op 115200 baud.
Waarover hier meer :

kitao in "De EL-kroeg - Deel 4"

[ Voor 24% gewijzigd door kitao op 05-02-2025 18:01 . Reden: Github link toegevoegd ]

[kitao]

Logic Analyzer 8 CH, 24MHz USB

Daar gaat deze post in het kort over, voor wie er nog niet zo bekend mee is. Heb het zelf jaren niet gebruikt en het moest op een andere computer geinstalleerd worden met Windows 11 en ik heb van de stappen een paar snips gemaakt.

Produkt


Website voor de software




https://www.saleae.com/pages/downloads

Wizzard


Geinstalleerd en in actie - het betreft overigens wel een demo versie, dus metingen opslaan zal wel niet gaan.


Dit apparaatje kost ca. 14 euro, o.a. bij Bol en is handig bij het monitoren van digitale schakelingen.
Voor die prijs zijn het gekloonden, ook die ik heb, maar de officiele software van Saleae is er blijkbaar toch compatible mee. Hetgeen mij niet heel vanzelfsprekend lijkt en zover ik gezien heb niet aangegeven staat bij de verkoop informatie.

[ Voor 7% gewijzigd door kitao op 08-02-2025 18:36 ]

[kitao]

Het volgende gaat ook over Arduino software maar die is niet gratis.
Hier kunnen pakketten worden geselecteerd
https://www.labcenter.com/buy-vsm/
Er zit een gratis demo pakket bij maar ik zou eerst proberen of er daar een uno mee geblinkt kan worden.
Op basis van deze video
YouTube: Assembly via Arduino - Programming DS1307 RTC
met deze code
https://akuzechie.blogspo...a-arduino-ds1307-rtc.html
een RTC Max7219 geprobeerd op te bouwen maar dat werkte niet goed met het aangetaste printje wat ik nog ergens had liggen

In zulke gevallen of als ik een onderdeel mis komt een simulator van pas.
Simulide is wel gratis en vind ik persoonlijk zelfs leuker als Proteus
https://simulide.com/p/
maar is beperkter met de beschikbare onderdelen.
Toch kan je daar best veel mee, het heeft ook een RTC en een Max7219 maar die is gekoppeld aan een matrix

Op Proteus lukte het uiteindelijk om de sketch, dat overigens in assembly is geschreven, in beeld te krijgen, met een common cathode display.

Het is wel een stuk lastiger om de project instellingen, libraries, compiler paths, files toevoegen etc om die bij Proteus goed te krijgen maar uiteindelijk is er wel meer mee mogelijk als met Simulide.

Ps, zie svp
kitao in "arduino uren en minuten verstellen"
De Sda en Scl 10K weerstanden zouden pull ups moeten zijn.
.

[ Voor 3% gewijzigd door kitao op 23-02-2025 16:24 ]

[kitao]

Dit gaat over RFID RC522 die ik nog ergens had liggen en een toepassing voor heb gezocht. Eerst naar een Uno standaardvoorbeeld gekeken
https://arduinogetstarted.com/tutorials/arduino-rfid-nfc

Dat is een goed artikel en introduceert ook Logic Level Shifters maar ik wou dit overzetten naar een Atm32.
Om die te programmeren gebruik ik Atmel Studio en de zoekcombinatie Atm32 + RC522 leverde dit op:

https://medium.com/@riyay...rocontroller-31c32df78861

Dat verwijst naar diverse goeie sites maar ook naar Git waar het hele project is gecodeerd
https://github.com/Riya00...-Using-Atmega32/tree/main

Klik de groene <>Code knop en download de Zip.
Dan vanuit Atmel Studio in Solution Explorer klik op Add Existing Items



En voeg de 4 files die Zip- gedownload waren toe



Dit compileerde in 1 keer maar helaas de Rfid opstelling werkte niet
In main.c staat het volgende :

C:

[i]int main()
{
    DDRB |= (1<<rs)|(1<<en)|(1<<buzzer);
    DDRC &= ~((1<<pin0)|(1<<pin1)|(1<<pin2)|(1<<pin3));
    PORTB |= (1<<buzzer);[/i]

Verander de DDRC in :

DDRC |= (1<<pin0)|(1<<pin1)|(1<<pin2)|(1<<pin3);

DDRC staat voor Data Direction Register C en met het &= ~( wordt daar een Input van gemaakt hetgeen naar mijn idee niet klopt als je vanuit Port C een LCD van data wil voorzien.


https://microcontrollersl...facing-examples-features/

Verbindingen:
RC522 : Vcc op 3.3V , TX naar RX ATM32, RX naar TX Atm32.
Atm32 : PB0 naar RS LCD, PB1 naar EN LCD, PC7-4 naar D7-4 LCD, PB2 aan een Buzzer of Ledje, Kristal 8MHz.
LCD : RW aan GND leggen.



Dit is allemaal best omslachtig want hetzelfde kan veel makkelijker en sneller worden bereikt met de Arduino IDE en bijvoorbeeld een Uno of Nano. Het op deze manier programmeren geeft wel iets meer uitdaging en is net een een graadje lastiger als de standaard methode.
De Arduino IDE heb ik in het begin gebruikt voor het testen van de componenten maar het voordeel van Atmel/Microchip Studio is dat het meer mogelijkheden tot debuggen biedt.

[ Voor 7% gewijzigd door kitao op 13-04-2025 18:17 ]

[kitao]

Hi, misschien dat iemand hier wat meer kan vertellen over een level-shifter en Uno R3 voltages ?

Ik gebruik de Uno o.a. om signalen naar een Altera Max II te sturen maar die draait op 3.3V. De gebruikte signalen zijn voor een 3x8-decoder volgens deze webpagina:
https://www.engineersgara...d-8x3-encoder-using-vhdl/

Gecompileerd in Quartus verscheen na wat instellingen dit plaatje op Modelsim:



De sim werkt dus naar behoren en de volgende stap was om dit op breadboard te zetten met in de Uno een aangepaste versie van dit programma : https://projecthub.arduin...led-binary-counter-defdd9



Op de foto is het goed aangesloten maar dat was eerst niet zo, ik had namelijk totaal niet verwacht dat er onder en boven VCC en GND op de level-shifter zouden zitten dus had VCC rechtstreeks op pin 3 staan



Iemand enig idee waarom dit dubbel is uitgevoerd ?
Met dit soort bordjes wordt op de cent winst gemaakt dus lijkt mij nogal overbodig?

En is er een manier om in de getoonde opstelling de level shifter er tussen uit te halen ? Dat er rechtstreeks 3.3 V uit de gebruikte pinnen van de Uno komt ?

Ps, deze is ook handig voor dit soort dingen


.
Ps2, als mogelijk antwoord op mijn eigen vraag, de dubbele uitvoering van VCC en GND is waarschijnlijk om twee of meerdere Logic Level Shifter Bi-Directional 5V/3.3V Modules te 'daisy chainen', aan elkaar door te lussen.
.

[ Voor 13% gewijzigd door kitao op 18-06-2025 10:27 ]