[Discussie] Arduino-topic

[roeleboel]

Een relais om de 2 relais aan te sturen dus? Interessant idee.

Concreet zou dat dus zoiets als dit worden:
https://www.kiwi-electron...v-3a-dpdt-v23105a5001a201
met dan relais 1 op pinnen 9-11-13, en relais 2 op pinnen 4-6-8 als ik het goed begrijp?

De software kant heb ik niet zoveel schrik voor, maar ik programmeer al lang genoeg om te weten dat iedereen af en toe een steek laat vallen, en volgens de installateur van de ventilatie zou een fout mij hier tussen de 250 & 750 euro kosten afhankelijk van wat/hoeveel er stuk gaat, dat is wat mij betreft meer dan genoeg om alles met een loep te bekijken vooraleer ik het effecitef aansluit

Edit: het verbaast me eigenlijk dat een 'driestandenschakelaar-voor-arduino' niet direct kant en klaar te vinden is, maar dat je zelf iets in elkaar moet knutselen.

[ Voor 11% gewijzigd door roeleboel op 18-01-2021 14:45 ]

[Tom-Z]

@roeleboel Het kan ook gewoon met twee SPDT relais:



Niet mogelijk om met de software iets fout te doen.

[Septillion]

Idee van @Tom-Z is het meest veilig. Alleen als het om gewone mechanische ventilatie gaat moet M1 wel constant onder spanning blijven. Verder kan je dan het schema volgen. Je eindigt dan met één relais voor opschakelen (stand1 of stand2/3) en één voor stand2 of stand3.

Maar als je een moderne ventilatie hebt (met elektronische regeling) dan vind deze het niet erg om op zowel stand 2 als stand 3 spanning te hebben en zal gewoon stand

[roeleboel]

Het gaat hier over 3 draden L1, L2 en L3, waarbij als alles open is (dus geen enkel contact) stand 1 actief is, L1+L2 verbonden geeft stand 2 en L1+L3 verbonden geeft stand 3.
Een licht aangepast schema van @Tom-Z is idd wel een goed idee, het lijkt me niet dat daar iets mee mis kan gaan.
(zelfs met twee doorgebrande relais kan ie dan maar in 1 stand staan)

[kitao]

Heeft iemand deze software in bezit ?
https://www.robotshop.com...troller%20based%20designs.
Ook rechtstreeks te krijgen zo te zien, klik op het Arduino logo
https://www.labcenter.com/buy-vsm/
Kost respectievelijk maar liefst $ 248,- en € 200,-
Is voor mij nogal prijzig maar als iemand er goede ervaringen mee heeft hoor ik het graag. Of een alternatief.
Ben al een maand aan het oefenen met de demo, hetgeen prima bevalt overigens, maar daar zit geen enkele micro toegankelijk in.
En ik neem aan dat dit een eenmalige aanschafprijs is en niet per jaar ofzo.

[AteGjalt]

Erasmo schreef op maandag 18 januari 2021 @ 13:23:
Ik geef af en toe Arduino les aan een klasje, weet iemand nog leuke projecten? Ondertussen zijn we al bijna door de starterskit boekjes heen.

Heb al zelf een opdracht gemaakt die een zonnetracker maakt op basis van LDR's en servo's maar wellicht heeft iemand hier nog wat leuks gemaakt onlangs.

Automatisch irrigatiesysteem zou wel een mooie uitdaging zijn denk ik.
Ik zou hier ook eens tussen kijken: https://www.hackster.io/arduino?ref=topnav

[Erasmo]

AteGjalt schreef op dinsdag 19 januari 2021 @ 12:56:
[...]


Automatisch irrigatiesysteem zou wel een mooie uitdaging zijn denk ik.
Ik zou hier ook eens tussen kijken: https://www.hackster.io/arduino?ref=topnav

Dat is wel een toffe, met twee draadjes in de grond de weerstand uitlezen en aan de hand daarvan een pompje aansturen.

Vandaag eerst maar de setjes controleren en aanvullen want er is weer behoorlijk wat gesloopt.

[tsjoender]

Erasmo schreef op maandag 18 januari 2021 @ 13:23:
Ik geef af en toe Arduino les aan een klasje, weet iemand nog leuke projecten? Ondertussen zijn we al bijna door de starterskit boekjes heen.

Dit is ook wel een leuke misschien?: https://www.mysensors.org/build/parking

Sowieso is MySensors wel aardig wellicht om met Arduino's en radio modules een netwerkje te bouwen. Ik heb ook nog aardig wat NRF24L01 clones liggen mocht je die in jouw cursus willen gebruiken.

[Septillion]

@Erasmo Misschien simon says? Maar dan met ledjes? Of een dobbelsteen? Beide kan met gewone ledjes of neopixels etc

[ Voor 39% gewijzigd door Septillion op 20-01-2021 11:27 ]

[Erasmo]

tsjoender schreef op woensdag 20 januari 2021 @ 11:26:
[...]


Dit is ook wel een leuke misschien?: https://www.mysensors.org/build/parking

Sowieso is MySensors wel aardig wellicht om met Arduino's en radio modules een netwerkje te bouwen. Ik heb ook nog aardig wat NRF24L01 clones liggen mocht je die in jouw cursus willen gebruiken.

Heb geen neopixels op het moment maar wel een hoop normale leds, opzich wel een mooie om te laten zien hoe de ultrasoon sensor werkt, seriele monitor naar de laptop en uitlezen maar. We hebben voor radio's hier nog een paar andere kitjes liggen. Het is een beetje lastig om soms leuke projecten te verzinnen want ik heb soms leerlingen die beter C++ kunnen dan ik en soms leerlingen waar je meer dan een uur bezig bent om ze een eenvoudige stroomkring met een ledje en een knopje op een breadboard te bouwen. En dan zitten ze soms ook nog eens bij elkaar in de klas! Maar goed het is leuk werk, want regelmatig zie je de spreekwoordelijke lampjes opeens branden als ze het door hebben.

Septillion schreef op woensdag 20 januari 2021 @ 11:27:
@Erasmo Misschien simon says? Maar dan met ledjes? Of een dobbelsteen? Beide kan met gewone ledjes of neopixels etc

Leds genoeg. Een dobbelsteen is wel een goede, kan ze dan mooi het concept RNG leren.

[kitao]

Top 10 Arduino projects blijkt er te zijn, meerdere.

https://www.ubuntupit.com...-you-can-build-right-now/

Deze is vrij recent ook, januari 23 2021

Bouw instructies ontbreken echter. Of ik kijk er overheen.

**********


Arduino hovercraft

https://howtomechatronics.com/arduino-projects/

[ Voor 30% gewijzigd door kitao op 27-01-2021 21:54 ]

[jbhc]

roeleboel schreef op maandag 18 januari 2021 @ 13:51:
Ik heb een ventilatiesysteem dat ik kan aansturen door een 3-standenschakelaar.

Ik had al bedacht dat ik dit kan nabootsen door 2 relais te gebruiken, maar dan heb je altijd het risico dat je via een softwarefout de 2 tegelijk aanzet.

Bestaat iets in die aard dat ik via arduino softwarematig kan aansturen?
En zo ja: op welke (engelstalige) term moet ik zoeken? Of is de 'standaard oplossing' hier toch 2 relais gebruiken? 'driestandenschakelaar arduino' levert helaas niets bruikbaars op...

Leuk, ik heb zoiets voor mijn badkamer. Daar zit een Itho box op welke je aan kan sturen met een schakelaar. Ik heb hier een arduino met behulp van relais op aangesloten om zo met vertaging als het licht aan gaat de box in 2 stappen steeds harder te laten draaien en als het licht uit gaat in 2 stappen weer langzamer te laten draaien.

Dit omdat ik niet wil dat als iemand snachts naar het toilet gaat, dat ding meteen vol gaat blazen.

Als je de schakelaar wil handhaven (ik gebruik die persoonlijk niet) zou ik deze op een of andere manier aan de arduino koppelen.

[ Voor 6% gewijzigd door jbhc op 28-01-2021 13:20 ]

[toekie]

Hoi!! Ik heb samen met een mede tweaker een klimaat controller gemaakt. Draait op een mega met een nextion display. Nu heb ik alleen een probleem hij geeft op willekeurige moment een freeze van de klokfunctie, die stopt met tikken. Heb nu een minimale setup gemaakt met alleen arduino, scherm, RTC en power, maar hij blijft dit hebben. Soms al binnen 1 uur soms pas na 5 uur. Ik denk zelf dat het een overflow probleem is maar ik kan het vinden. Denk zelf dat het of bij de UV sensor zit, die vertoont soms wat drift in de waardes of de watchdog timer. Wellicht dat iemand van jullie een idee heeft wat het kan zijn? Ik krijg het niet gevonden.
Code

[DataGhost]

toekie schreef op zaterdag 30 januari 2021 @ 22:29:
Hoi!! Ik heb samen met een mede tweaker een klimaat controller gemaakt. Draait op een mega met een nextion display. Nu heb ik alleen een probleem hij geeft op willekeurige moment een freeze van de klokfunctie, die stopt met tikken. Heb nu een minimale setup gemaakt met alleen arduino, scherm, RTC en power, maar hij blijft dit hebben. Soms al binnen 1 uur soms pas na 5 uur. Ik denk zelf dat het een overflow probleem is maar ik kan het vinden. Denk zelf dat het of bij de UV sensor zit, die vertoont soms wat drift in de waardes of de watchdog timer. Wellicht dat iemand van jullie een idee heeft wat het kan zijn? Ik krijg het niet gevonden.
Code

Tsja, zo'n grote code dump met een bug die na een tijdje pas optreedt is lastig debuggen, zeker zonder het apparaat zelf te hebben. Dit is dus een mooi moment om dat te gaan leren. Als het kan met een debugger en anders moet je zelf iets verzinnen (bijv. via Serial). Met dat laatste verander je wel je programma dus dat kan bij-effecten hebben.
Anyway, het klinkt als iets dynamisch. Dat kan een berekening zijn die je doet, afhankelijk van de tijd (en wat er tussendoor allemaal gebeurt), die op een gegeven moment misgaat. Is het alleen de klok die stopt of stopt je hele sketch? Zonder heel uitgebreid in je code te kijken zie ik dat je enorm veel kleine dingetjes doet met de String-klasse. Dat is vaak een red flag en kan heel gauw zorgen voor een hopeloos gefragmenteerd geheugen waardoor je opeens "geen geheugen meer over hebt" voor een nieuwe String. Dan kan je klok dus ook niet opnieuw getoond worden. Ik gok dat je probleem weggaat als je "normale string-operaties" gebruikt met een constant geheugengebruik (preallocated). Dus het liefst heel de String-klasse niet meer gebruiken. Je hebt namelijk geen garbage collection en ook geen virtueel geheugen, waardoor het ook niet "gedefragmenteerd" kan worden.
Hier nog wat leesvoor over String.

[Yucon]

roeleboel schreef op maandag 18 januari 2021 @ 13:51:
Ik heb een ventilatiesysteem dat ik kan aansturen door een 3-standenschakelaar.

Ik had al bedacht dat ik dit kan nabootsen door 2 relais te gebruiken, maar dan heb je altijd het risico dat je via een softwarefout de 2 tegelijk aanzet.

Bestaat iets in die aard dat ik via arduino softwarematig kan aansturen?
En zo ja: op welke (engelstalige) term moet ik zoeken? Of is de 'standaard oplossing' hier toch 2 relais gebruiken? 'driestandenschakelaar arduino' levert helaas niets bruikbaars op...

Als je 1 functie gebruikt om de uitgaande pinnen als setje aan te sturen zit je toch wel aardig veilig. Ik vind het ook vreemd dat je in het arduino ecosysteem geen standaard oplossing vindt, maar laten we wel wezen; dat is hobbyspul dus zelfs als het bestond zou het evenmin 100% fail safe zijn.Als zo'n relais blijft hangen omdat het fysiek kapot gegaan is heb je dezelfde situatie.. ik vraag me eigenlijk ook af of je installatie daar niet gewoon tegen bestand is. Het kan best zijn dat je installateur met z'n uitspraak het zekere voor het onzekere neemt.

Als het je een beter gevoel geeft zou je ook nog een servo op een conventionele schakelaar kunnen zetten.

edit :kaku schakelaars kun je toch ook via een arduino aansturen staat me bij? Daar heb je wel 3-weg schakelaars voor.

[ Voor 15% gewijzigd door Yucon op 31-01-2021 09:27 ]

[chaoscontrol]

@toekie Controleer of je 2 timers niet ooit tegelijk getriggerd worden. Staat 1 op 100ms interval en de ander op 1000ms interval zullen ze eens per 10x tegelijk lopen. Mijn ervaring is dat de arduino dan over zijn nek gaat.

DataGhost schreef op zondag 31 januari 2021 @ 01:36:
zie ik dat je enorm veel kleine dingetjes doet met de String-klasse. Dat is vaak een red flag en kan heel gauw zorgen voor een hopeloos gefragmenteerd geheugen waardoor je opeens "geen geheugen meer over hebt" voor een nieuwe String.

Iedereen aapt dit altijd na maar heb je een idee hoeveel String variables je moet gebruiken voor je tegen dat probleem aan loopt? Ik denk dat bijna niemand die nog een Arduino gebruikt hier ooit last van krijgt. Dit kun je trouwens meten door je heap af en toe te bekijken.

[ Voor 58% gewijzigd door chaoscontrol op 31-01-2021 10:31 ]

[toekie]

Hallo allen ,

@DataGhost

Als het kan met een debugger en anders moet je zelf iets verzinnen (bijv. via Serial). Met dat laatste verander je wel je programma dus dat kan bij-effecten hebben.

Yes via serial is hoe ik nu debug en gewoon ouderwets de code door speuren.

Is het alleen de klok die stopt of stopt je hele sketch?

Het is alleen de klok, verdere functionaliteit blijft, zoals de knoppen, pwm en alle scherm functies, sensors de waardes die ze geven ook. Maar omdat ik veel tijdsgebonden functies heb ala 'lampg gaat aan op tijdstip X, werken die praktisch allemaal niet meer want bij de klok freeze wordt tijd X nooit behaald.


@chaoscontrol

Controleer of je 2 timers niet ooit tegelijk getriggerd worden. Staat 1 op 100ms interval en de ander op 1000ms interval zullen ze eens per 10x tegelijk lopen. Mijn ervaring is dat de arduino dan over zijn nek gaat.

Ja daar heb ik op gelet, want dat tijdens het initieele bouwen een irritant probleem want dan klapte hij er helemaal uit inderdaad. Heb het er nu in staan dat op het scherm het tijds kader verkleurt als je overlappende tijden hebt en als je een timer uit zet, deze niet meer meetelt voor als functie (eerst blijft hij bij off nog wel meetellen). Heb nog niet gelet op de interval timings omdat dit begeven moment dus gewoon goed liep. Ik heb uberhaupt veel draaien met 1s intervals waar ik al naar heb zitten kijken maar dat veranderen maakte tot nu toe niks uit, dan ga ik bij alle functies eens naar de intervallen kijken. Bedankt voor de tip!

Bedankt voor jullie feedback, duik er meteen weer in!

[DataGhost]

chaoscontrol schreef op zondag 31 januari 2021 @ 10:29:

[...]


Iedereen aapt dit altijd na maar heb je een idee hoeveel String variables je moet gebruiken voor je tegen dat probleem aan loopt? Ik denk dat bijna niemand die nog een Arduino gebruikt hier ooit last van krijgt. Dit kun je trouwens meten door je heap af en toe te bekijken.

Urenlang laten lopen van een sketch waar dit met behoorlijke regelmaat gebeurt lijkt me anders een prima recept hiervoor.

[chaoscontrol]

DataGhost schreef op zondag 31 januari 2021 @ 11:23:
[...]

Urenlang laten lopen van een sketch waar dit met behoorlijke regelmaat gebeurt lijkt me anders een prima recept hiervoor.

Heeft er weinig mee te maken. Het ligt aan de lengte/grootte van de String en of er een block vrij is waar deze helemaal in past. Zo even snel door de code te kijken zijn het allemaal kleine Strings en is de kans erg klein dat dit niet ergens in een vrij block past.

[DataGhost]

Geheugenfragmentatie is in een klein geheugen (8KB) met veel dynamische allocaties anders toch gauw een dingetje hoor. Ik zou er zeker op letten, helemaal aangezien er ontzettend veel betere oplossingen zijn voor de string-operaties die ik daar zie gebeuren.

[ Voor 37% gewijzigd door DataGhost op 31-01-2021 12:41 ]

[Santford]

Erasmo schreef op maandag 18 januari 2021 @ 13:23:
Ik geef af en toe Arduino les aan een klasje, weet iemand nog leuke projecten? Ondertussen zijn we al bijna door de starterskit boekjes heen.

Ik lees dat je soms ook meer gevorderde programmeurs in je klasje hebt zitten, misschien is het een leuke uitdaging voor hun om een woord of hun naam in morsecode op een LED te laten signaleren. Simpele opdracht om uit te leggen en in feite heb je er alleen tabel van het alfabet in morse voor nodig, maar software technisch zit er best veel in. Met een smartphone app kun je dan controleren of het gelukt is.

[Rrob]

Ik wil een const int aanroepen dsn2 maar dan als dsnx waarbij x eerder is gedefinieerd als 2 Ik kom er niet uit of dat kan en hoe dat moet. Iemand tips?

En hetzelfde met snx+1 en sn3 waarbij sn3 een nieuwe functie is.

code:

const int dsn2 = 2000;
[....]
void sn2(){
  x = 2;
  unsigned long currentMillis = millis();
  startMillis = currentMillis;
  while(pulseslaap< pusn * x && currentMillis - startMillis <= dsnx){
    digitalWrite(pinsn, SNA);}

    digitalWrite(pinsn, SNP);
    stopMillis = currentMillis;

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

    else {
    errorsn();
}}

[Tom-Z]

@Rrob Lees jezelf even in in wat een array is. Dat is de manier waarop je kan doen wat je wil met dsnx.

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).

Als je echt letterlijk een andere functie wil aanroepen uit een lijst op basis van een getal, dan kun je met een array van function pointers werken maar dat is nogal ingewikkeld en waarschijnlijk niet de gepaste oplossing voor wat je wil.

[Rrob]

@Tom-Z thanks, een array lijkt idd de oplossing.

dat 2e deel kom ik nog niet helemaal uit, zoals ik het begrijp kan ik met sn(int n) in 1 keer sn1 t/m sn(oneindig) maken waarbij de x steeds 1 groter wordt.
Het klopt dat ik idd na sn2 ook sn3 t/m sn9 heb waarvoor dat prima zal werken alleen sn1 en sn10 zijn anders en na sn10 moet het stoppen.

[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...