[Discussie] Arduino-topic

[Atmoz]

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

code:

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

Boven setup() doe ik:

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

In de main-loop roep ik dit aan als:

breatheUpdate(mySegment, 5, 1, 0);


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

Iemand die dit kan uitleggen?


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


[edit]

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

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

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

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

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

[DataGhost]

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

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

[Atmoz]

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

...uitgebreid + interessant verhaal...

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

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

Super bedankt

[SToRM666]

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

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

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

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

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

Wat foto's :





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



En dit is zo ongeveer de laatste status:



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

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

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

[SToRM666]

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



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

[theorganiser]

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

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

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

Edit:
Opgehaald !

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

[lloullou]

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

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

[barrymossel]

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

Momenteel is de loop:

Arduino:

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

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

  mqttClient.loop();
}

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

Arduino:

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

[DataGhost]

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

[SToRM666]

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

[Afbeelding] [Afbeelding]

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

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



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

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

[breinonline]

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

C++:

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

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

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

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

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

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

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

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

}

[Septillion]

@breinonline Voor pin 8 zet je nooit de pinMode.

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

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

[breinonline]

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

Dat was hem! Dank

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

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

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

[Raven]

Is er iemand toevallig bekend met de ESP-201?



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

GPIO0 hangt uiteraard aan de ground tijdens het flashen.

[Septillion]

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

[Raven]

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

[Septillion]

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

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

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

[Raven]

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

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

uiteraard AMS1117 eraan voor 3.3V.

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

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

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

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

[Septillion]

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

Loopback test van de kabel lukt wel gewoon?

[Raven]

@Septillion Check, kabel is goed.

[Raven]

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

[kitao]

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

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

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

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



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

[kitao]

Voorbeeldje overzetten van Assembly Arduino IDE naar Proteus Debugger :



YouTube: Assembly via Arduino (part 1) - Introduction

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

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

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











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

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

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



En dit wordt dan de Proteus Wizard instelling :

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

[kitao]

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

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

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

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

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

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



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

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

Correctie 2 :

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

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

[kitao]

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

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

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

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

[Danielson]

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

Waar vind ik orginele?

[Raven]

@Danielson Adafruit of NL-dealer Kiwi?

[Dutchess_Nicole]

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

Waar vind ik orginele?

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

[Septillion]

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

Waar vind ik orginele?

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

[Accretion]

Is d'r geen Nano variant van de Leonardo?

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

Alhoewel, tegenwoordig gebruik ik toch voornamelijk ESP32 gebaseerde bordjes.

[kitao]

De micro zie ik staan en daaronder nog wat alternatieven :

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

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

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

[kitao]

In het midden een Avr Isp bootloader shield.

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

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

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



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

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

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

Paar andere linkjes die in relatie staan tot dit onderwerp :

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

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

kitao in "De EL-kroeg - Deel 4"



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

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

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

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

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

kitao in "De EL-kroeg - Deel 4"

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

[kitao]

Logic Analyzer 8 CH, 24MHz USB

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

Produkt


Website voor de software




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

Wizzard


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


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

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

[kitao]

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

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

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

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

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

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

[kitao]

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

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

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

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

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



En voeg de 4 files die Zip- gedownload waren toe



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

C:

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

Verander de DDRC in :

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

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


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

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



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

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

[kitao]

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

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

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



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



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



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

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

Ps, deze is ook handig voor dit soort dingen


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

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

[Septillion]

kitao schreef op woensdag 18 juni 2025 @ 07:28:
Iemand enig idee waarom dit dubbel is uitgevoerd ?
Met dit soort bordjes wordt op de cent winst gemaakt dus lijkt mij nogal overbodig?

Denk voor gemak voor daisy chain inderdaad. Want hoe zeer ze ook proberen te bespraken is de grootste besparing vaak dat ze het niet zelf bedacht hebben

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

Direct, nee. Simpele spanningsdeler zou ook voldoen.

[kitao]

@Septillion
Ja bedankt voor de tip van een spanningsdeler, zoiets als dit denk ik dan aan


https://arduinokitproject...uetooth-arduino-tutorial/

Kort na mijn vorige post in dit topic over een Uno gekoppeld aan een CPLD kwam ik toevallig iets soortgelijks tegen, zie
kitao in "Het grote 'breadbord computer' topic"


https://eecs.blog/8-bit-computer-in-an-fpga/#more-detail

en daar staan 3 level shifters op met iets van 24 x 2 lijnen totaal
Op zich is dat al een zooitje maar met op iedere lijn een spanningsdeler met weerstanden zal nog meer een warboel worden vrees ik.
Niet dat ik al zeker weet dit project uit te gaan voeren maar een beginnetje is gemaakt en het kan ook per module opgezet worden waarschijnlijk. Nu schijnt het wel mogelijk te zijn om een Arduino Uno te 'hacken' dat er 3.3V uit de I/O komt, zie
https://learn.adafruit.co...echniques/3-3v-conversion
maar dat is nogal een drastische vrijwel onomkeerbare botte mes ingreep.

Toch heb ik het in een andere vorm geprobeerd en dat gaat inderdaad



Atmega 328P stand-alone geprogrammeerd met Arduino IDE via een FTDI FT232RL USB en vervolgens op 3.3V labvoeding aangesloten waardoor er 3.3V Out op de Led-pin ontstaat.

En er zullen ook andere Arduino borden zijn die standaard op 3.3V draaien maar makkelijkste is als ik er vertrouwd mee ben en ook dat er in de gebruikte sketches niet van pin positie gewisseld hoeft te worden met dat project
https://github.com/EECSB/8Bit-Computer
en dan lijkt mij dit een geschikte kandidaat :
If you used Arduino Nano in your projects in the past, the Nano 33 BLE is a pin-equivalent substitute. Your code will still work, but remember, it operates at 3.3V.
https://store.arduino.cc/products/arduino-nano-33-ble
.

[ Voor 5% gewijzigd door kitao op 23-06-2025 05:35 . Reden: typo ]

[Septillion]

@kitao De ATmega328P kan inderdaad prima op 3v3 werken en dan komt er ook 3v3 uit de IO. Maar officieel is de standaard 20MHz buiten spec om hem op 3v3 te laten werken. Dan zal je het crystal moeten vervangen voor een (uit mijn hoofd) 16MHz exemplaar.

[kitao]

@Septillion

Ja, tnx, dat is inderdaad iets om rekening mee te houden



https://ww1.microchip.com...-ATmega328P_Datasheet.pdf

en iets scherper kijkend zie ik nu dat genoemde 3.3 V Nano helemaal geen Atmega Nano is
The Arduino Nano 33 BLE is based on the nRF52840 microcontroller
https://store.arduino.cc/products/arduino-nano-33-ble

[vanaalten]

OK, misschien ben ik hier helemaal verkeerd, maar je moet toch ergens beginnen:
Ik heb een klein hobbyproject in gedachten. Ben over het algemeen niet zo bezig met elektronica, programmeren en zo, maar wat ik graag zou willen:

• Functie: IR-commando ontvangen van een Logitech Harmony remote en dan een Wake-on-Lan via ethernet het netwerk opsturen.
• Het nog-te-maken device staat 24/7 aan, liefst dus low-power, zero-maintenance.
• Moet een ethernet-aansluiting hebben (duh...) en, om adapter uit te sparen, Power-over-Ethernet gevoed zijn. Natuurlijk kan het functioneel ook prima draadloos werken, maar ik wil dingen bij voorkeur bedraad.
• Op de een of andere manier dus een IR-ontvanger hebben.

Na wat google, rondzoeken enzo kwam ik uit op een Arduino Leonardo ETH2 met PoE. Ik ben wel gecharmeerd van Arduino als concept, heb ik een heeeeel ver verleden wel eens iets met Arduino gedaan dus dit leek mij wel een goede basis.

Echter: dit bord blijkt End-of-Life, dus zal lastig aan te komen zijn. Wat zijn dan mijn alternatieven?
Arduino Uno + Arduino Ethernet Shield 2 + Ag9000-S PoE module?

Of zijn er beter, desnoods niet-Arduino, keuzes te maken?

[_ferry_]

De Arduino code kun je doorgaans ook op een ESP32 draaien, en er zijn wel wat bordjes met een ESP+LAN+PoE te vinden denk ik zo, dat is inderdaad beter dan die laatstgenoemde optie. Ook heb je dan volgens mij een makkelijkere implementatie qua ethernet interface dan met zo'n shield.

Edit, dat laatste is niet zo'n issue bij het ethernet shield. Maar wel bij de shield met ENC... Chippies er op.

Anyway, voor de prijs van een shield heb je een ESP bordje wat alles al aan boord heeft, behalve de IR ontvanger dan

[ Voor 29% gewijzigd door _ferry_ op 13-12-2025 20:28 ]

[Raven]

_ferry_ schreef op zaterdag 13 december 2025 @ 20:07:
De Arduino code kun je doorgaans ook op een ESP32 draaien, en er zijn wel wat bordjes met een ESP+LAN+PoE te vinden denk ik zo,

https://www.olimex.com/Pr...-ISO/open-source-hardware

[_ferry_]

Raven schreef op zondag 14 december 2025 @ 09:33:
[...]

https://www.olimex.com/Pr...-ISO/open-source-hardware

Precies, of evt deze;
https://www.olimex.com/Pr...POE2/open-source-hardware
Of van een andere fabrikant;
https://www.tinytronics.n...s3-w5500-ethernet-met-poe

[ Voor 12% gewijzigd door _ferry_ op 14-12-2025 09:58 ]

[vanaalten]

Dank voor het meedenken! En dat zijn wel leuke kleinere oplossingen. Binnenkort even wat meer in verdiepen en dan hopelijk rond oud&nieuw wat hobbyen.

[kitao]

vanaalten schreef op zaterdag 13 december 2025 @ 15:31:
OK, misschien ben ik hier helemaal verkeerd, maar je moet toch ergens beginnen:
Ik heb een klein hobbyproject in gedachten. Ben over het algemeen niet zo bezig met elektronica, programmeren en zo, maar wat ik graag zou willen:

• Functie: IR-commando ontvangen van een Logitech Harmony remote en dan een Wake-on-Lan via ethernet het netwerk opsturen.
• Het nog-te-maken device staat 24/7 aan, liefst dus low-power, zero-maintenance.
• Moet een ethernet-aansluiting hebben (duh...) en, om adapter uit te sparen, Power-over-Ethernet gevoed zijn. Natuurlijk kan het functioneel ook prima draadloos werken, maar ik wil dingen bij voorkeur bedraad.
• Op de een of andere manier dus een IR-ontvanger hebben.

Na wat google, rondzoeken enzo kwam ik uit op een Arduino Leonardo ETH2 met PoE. Ik ben wel gecharmeerd van Arduino als concept, heb ik een heeeeel ver verleden wel eens iets met Arduino gedaan dus dit leek mij wel een goede basis.

Echter: dit bord blijkt End-of-Life, dus zal lastig aan te komen zijn. Wat zijn dan mijn alternatieven?
Arduino Uno + Arduino Ethernet Shield 2 + Ag9000-S PoE module?

Of zijn er beter, desnoods niet-Arduino, keuzes te maken?

In stappen opdelen is waarschijnlijk het meest effectief, te beginnen bij de IR-detectie. In het verleden eens in verdiept en toevallig vandaag een stukje ervan weer opgepakt, zie Hfdst.7 pag. 81
https://www.digikey.nl/ht...understanding-signals.pdf
Getoond wordt hoe een Sony IR-signaal gedetecteerd en ontcijferd kan worden. Welk protocol jouw afstandbediening gebruikt weet ik niet maar dat kan dus verschillen per fabrikant.
https://www.sbprojects.net/knowledge/ir/sirc.php


.

[vanaalten]

kitao schreef op zondag 14 december 2025 @ 17:18:
[...]


In stappen opdelen is waarschijnlijk het meest effectief, te beginnen bij de IR-detectie. In het verleden eens in verdiept en toevallig vandaag een stukje ervan weer opgepakt, zie Hfdst.7 pag. 81
https://www.digikey.nl/ht...understanding-signals.pdf
Getoond wordt hoe een Sony IR-signaal gedetecteerd en ontcijferd kan worden. Welk protocol jouw afstandbediening gebruikt weet ik niet maar dat kan dus verschillen per fabrikant.
https://www.sbprojects.net/knowledge/ir/sirc.php

[Afbeelding]
.

Ik ging er eigenlijk van uit dat een willekeurig microprocessor bord (Arduino of wat dan ook) met een standaard IR-ontvanger-IC al goed genoeg gaat zijn, dus had mij daar nog niet zo in verdiept.
Het gaat om een Logitech Harmony, dus in principe kan die van alles sturen. Maar dit stukje van de puzzel gaat denk ik wel het meeste tijd kosten.

Dank voor de link naar informatie!

[NewGuest]

Wellicht dat je van dit aardig oude project nog wat inspiratie kan op doen. https://www.picbasic.nl/rc5-rc6_transceiver.htm

[kitao]

@vanaalten
Persoonlijk ben ik nog geen uC of board tegengekomen dat standaard is voorzien van een IR-optie, maar goed, ik wist ook nog niet dat er via de ethernetkabel spanning geleverd kon worden. Ik zag wel in de vorige links een bluetooth-optie en met een app op je telefoon heb je dan, afhankelijk van jouw toepassing en wensen, waarschijnlijk geen IR-afstandsbediening meer nodig. De webpagina hieronder heb ik een tijdje geleden nog gedaan, dat ging best goed en aan het eind ervan staan nog enkele doorverwijzingen.
https://arduinokitproject...uetooth-arduino-tutorial/

Inmiddels wat nazoek gedaan via de Copiloot en om PoE mogelijk te maken zou een speciale switch of injector nodig zijn? ESP tot nu toe nooit gebruikt maar mogelijke Arduino alternatieven zijn o.a.
https://wiki.dfrobot.com/...OE_Mainboard_SKU__DFR0342
https://www.seeedstudio.c...oard-with-PoE-p-4822.html
https://docs.arduino.cc/r...o-ethernet-rev3-with-poe/
https://github.com/SuperHouse/EtherUno

Inderdaad staat er retired bij de arduino-ethernet-rev3-with-poe maar die zullen waarschijnlijk via bijvoorbeeld een Ali nog steeds goed verkrijgbaar blijken te zijn. Hieronder de DFRobot optie.


.

[vanaalten]

kitao schreef op maandag 15 december 2025 @ 07:49:
@vanaalten
Persoonlijk ben ik nog geen uC of board tegengekomen dat standaard is voorzien van een IR-optie, maar goed, ik wist ook nog niet dat er via de ethernetkabel spanning geleverd kon worden. Ik zag wel in de vorige links een bluetooth-optie en met een app op je telefoon heb je dan, afhankelijk van jouw toepassing en wensen, waarschijnlijk geen IR-afstandsbediening meer nodig. De webpagina hieronder heb ik een tijdje geleden nog gedaan, dat ging best goed en aan het eind ervan staan nog enkele doorverwijzingen.
https://arduinokitproject...uetooth-arduino-tutorial/

Ah, nee, zo modern ben ik niet.
Een IR-afstandbediening blijft nodig: TV en receiver zijn beiden nog uit de vorige eeuw en spreken geen moderne draadloze protocollen. Los daarvan lijkt een enkele afstandbediening die alle apparaten kan bedienen mij handiger dan een telefoon-app.

Oh, bedenk mij net dat ik de hele use-case van m'n project niet heb uitgelegd, want leek mij niet zo noodzakelijk:
Ik heb onlangs een mediaspeler-PC in elkaar gezet om een Intel NUC mediaspeler te vervangen. Echter: de NUC kan je via infrarood aanzetten, dus daadwerkelijk vanuit de uit-stand aan. De nieuwe mediaspeler kan dat helaas niet. Bios opties geprobeerd, maar nee: uit is uit en dan moet je met de aan-knop op het apparaat 'm aan zetten. En ik kan wel sleep-mode als alternatief gebruiken, maar dat vind ik een beun-oplossing en niet leuk. Dus idee is om een Arduino - of, nu waarschijnlijker, een ESP32 - te gebruiken die een specifiek IR-commando omzet naar een wake-on-lan via ethernet en op die manier de mediaspeler aan zet.

Inmiddels wat nazoek gedaan via de Copiloot en om PoE mogelijk te maken zou een speciale switch of injector nodig zijn?

Check: mijn Unifi switches hebben een aantal poorten met PoE, dus die gebruik ik al om een paar apparaten via ethernet te voeden.

[_ferry_]

Andere optie er zijn IC's die je kunt inleren qua IR, en dat kan ook met een arduino.
Zie bijv. https://docs.arduino.cc/libraries/irremote/
Heb ze ooit gebruikt, en daarmee stuurde ik dan een uitgang van de mircrocontroller waarmee ik de powerknop verbond. Zo kon ik ook met de IR remote de PC aanzetten. Zonder LAN (voeden via de USB bijvoorbeeld) en een stuk minder hardware.

[ Voor 12% gewijzigd door _ferry_ op 15-12-2025 09:42 ]

[Septillion]

Voor ontvangen van IR signalen is het inderdaad het makkelijkste om een all in one te namen op de juiste frequentie, meestal 38kHz. Iets als een TL1838 of TSSP4038 ofzo. Dan rollen de bitjes er zo uit. En dan kan je gewoon een van de Arduino libraries gebruiken om er begrijpbare data van te maken.

[kitao]

Naar aanleiding van deze post: kitao in "De EL-kroeg - Deel 4"
en deze video: YouTube: Arduino UNO + 7-Segment LCD Display - Full Tutorial (How to use segm...

Voor wie interesse heeft in het aansturen van een Segmented Display.
De video verwijst naar een Github Ino sketch: https://github.com/upiir/arduino_7segment_lcd_display
De sketch is dus niet bedoeld voor een 7-segment display maar een Common Cathode 7-segment display op een breadboard kan er wel mee aangestuurd worden. De pin indeling voor een Uno is als volgt :

C#:

 pinMode(SEG_COM, OUTPUT); // set pin 2 as output
  pinMode(SEG_A, OUTPUT); // set pin 8 as output
  pinMode(SEG_B, OUTPUT); // set pin 9 as output  
  pinMode(SEG_C, OUTPUT); // set pin 5 as output  
  pinMode(SEG_D, OUTPUT); // set pin 4 as output  
  pinMode(SEG_E, OUTPUT); // set pin 3 as output  
  pinMode(SEG_F, OUTPUT); // set pin 7 as output  
  pinMode(SEG_G, OUTPUT); // set pin 10 as output  
  pinMode(SEG_DP, OUTPUT); // set pin 6 as output 

In het origineel kloppen de comments ernaast niet vandaar dat ik dit stukje code heb geplaatst. Voor de rest werkt de sketch prima en heb deze in Proteus met een Arduino Uno als microcontroller gesimuleerd. Alle Commons en alle Segments op 1 pinnetje gaat in het echt natuurlijk niet maar de simulatie accepteert het en het gehele display wordt zichtbaar:



Omdat een segmented display aangestuurd wordt met een AC-signaal maakt het volgens mij eigenlijk niet uit of je een CC of CA 7-segment display met diezelfde sketch aanstuurt. Op breadboard heb ik alleen de CC getest maar in een Simulide simulatie heb ik ze allebei erin gezet:



https://simulide.com/p/ Pin 2 heeft een periode van 20 ms en bij de CA had eigenlijk ook een weerstandsblokje moeten zitten.

Deze video van dezelfde autheur simuleert een transparant display met Wokwi, zie minuut 09:45

YouTube: Thank You for 100K - Here is Your Gift!



https://wokwi.com/
.

[ Voor 26% gewijzigd door kitao op 20-12-2025 12:13 . Reden: Plaatje toegevoegd ]

[Septillion]

@kitao Als je dat soort herhalende commentaar naast je code zet kan je beter geen commentaar gebruiken. Beste commentaar herhaal je jezelf niet in. Ofwel, geen variabele waardes etc noemen. Als je nu je variabele wijzigt wordt je alleen maar op het verkeerde been gezet door je commentaar.

[DjoeC]

@Septillion Ik gen een groot voorstander van uitgebreid commentaar ter plekke zolang dat de bedoeling van het statement blok weergeeft. Maar commentaar moet net zo goed worden bijgewerkt als de onderliggende code.

Aangenomen dat je verwijst naar het stukje segment<>pin vertaling zie ik niet iets herhalends of overbodig - als gezegd: mits onderhouden.

[Septillion]

@DjoeC Ik ben ook groot voorstander van commentaar. Maar als een regel code super duidelijk is hoeft die geen commentaar. Zeggen wat een regel doet is geen commentaar, je wilt uitleggen wat je wilt bereiken. Dus bijvoorbeeld "Pinnen voor 7-segment configureren".

En waardes van een variabele herhalen in je commentaar is naar mijn idee een doodzonde. Dan zou je net zo goed geen variabele kunnen gebruiken als je die toch gaat lopen herhalen. Goed commentaar hoef je dus ook niet aan te passen als je doel hetzelfde blijft maar je implementatie verandert.

[kitao]

Septillion schreef op zondag 21 december 2025 @ 10:15:
@kitao Als je dat soort herhalende commentaar naast je code zet kan je beter geen commentaar gebruiken. Beste commentaar herhaal je jezelf niet in. Ofwel, geen variabele waardes etc noemen. Als je nu je variabele wijzigt wordt je alleen maar op het verkeerde been gezet door je commentaar.

Bedankt voor de tip, ik snap wat je bedoelt
Zelf codeer ik niets maar probeer het wel enigzins te kunnen lezen en na deze sketch in Atmel Studio met een debug te hebben doorlopen wist ik zeker dat de code comments niet klopten.
Het volgende is uit het origineel:
https://github.com/upiir/...segmented_lcd_display.ino

C++:

#define SEG_COM 2
#define SEG_A 8
#define SEG_B 9
#define SEG_C 5
#define SEG_D 4
#define SEG_E 3
#define SEG_F 7
#define SEG_G 10
#define SEG_DP 6
[...]
void setup() {
  
  // set all the needed Arduino pins as outputs (7 pins for 7-segment display, 1 pin for decimal point, 1 pin for common electrode)
  pinMode(SEG_COM, OUTPUT); // set pin 2 as output
  pinMode(SEG_A, OUTPUT); // set pin 3 as output
  pinMode(SEG_B, OUTPUT); // set pin 4 as output  
  pinMode(SEG_C, OUTPUT); // set pin 5 as output  
  pinMode(SEG_D, OUTPUT); // set pin 6 as output  
  pinMode(SEG_E, OUTPUT); // set pin 7 as output  
  pinMode(SEG_F, OUTPUT); // set pin 8 as output  
  pinMode(SEG_G, OUTPUT); // set pin 9 as output  
  pinMode(SEG_DP, OUTPUT); // set pin 10 as output              
}

Ik heb van het void setup blokje de comments aangepast mocht iemand van plan zijn dit projectje met een 7-segment led display te willen gaan uitvoeren zodat er geen pinnetjes geroosterd gaan worden bij iemand met minder ervaring ermee. In dat opzicht ben ik op het gebied van LCD-displays zelf een beginner dus moet daar ook mee oppassen wil ik zoiets gaan aansluiten. Momenteel heb ik geen los exemplaar dus vandaar dat ik het even met een 7-seg led op breadboard uittestte.

Ik heb inmiddels wel zo ongeveer begrepen dat zo'n LCD werkt als condensator component dus dan in principe zou mijn Proteus simulatie ook in het echt zo opgesteld kunnen worden?
Als ik een simulatie meting verricht gaat er nauwelijk stroom door de leiding heen. Of meet ik verkeerd?



Het is dezelfde simulatie als in de vorige post met enkel een AC amperemeter erin gevoegd.
De periode van IO2 is 20 ms en de simulatie draait op diezelfde Github code van autheur Upir.
.

[DjoeC]

Septillion schreef op zondag 21 december 2025 @ 10:32:
@DjoeC Ik ben ook groot voorstander van commentaar. Maar als een regel code super duidelijk is hoeft die geen commentaar. Zeggen wat een regel doet is geen commentaar, je wilt uitleggen wat je wilt bereiken. Dus bijvoorbeeld "Pinnen voor 7-segment configureren".

En waardes van een variabele herhalen in je commentaar is naar mijn idee een doodzonde. Dan zou je net zo goed geen variabele kunnen gebruiken als je die toch gaat lopen herhalen. Goed commentaar hoef je dus ook niet aan te passen als je doel hetzelfde blijft maar je implementatie verandert.

Je hebt gelijk. En ik zie in de .ino dat de pinnummers al in de #DEFINE gekoppeld zijn. Dan is het "risico" op miscommunicatie in een later stadium door niet aangepast commentaar een heel stuk groter.

[kitao]

DjoeC schreef op zondag 21 december 2025 @ 10:26:
@Septillion Ik ben een groot voorstander van uitgebreid commentaar ter plekke zolang dat de bedoeling van het statement blok weergeeft. Maar commentaar moet net zo goed worden bijgewerkt als de onderliggende code.

Aangenomen dat je verwijst naar het stukje segment<>pin vertaling zie ik niet iets herhalends of overbodig - als gezegd: mits onderhouden.

Mits goed onderhouden is herhalend en goed gekozen commentaar erg nuttig, vooral voor gebruikers zoals ik die niet al te goed thuis zijn in het coderen. Maar zoals ik het begrepen heb is achteraf wijzigen van commentaar regels nogal een opgave als het IC's betreft met 80+ pinnen en vele honderden regels aan code in een programma. Op zich in deze besproken Ino-file hadden de comments beter meteen achter de Define's kunnen worden gezet want voor een niet-codeur is een regel zoals hieronder nogal vaag:

C++:

#define SEG_A 8

Want wat is pin 8?
Op een Atmega 328 is dat niet dezelfde pin als op een Uno. Pin 8 is namelijk Gnd
Met Pin 8 op de Uno zou dan overzichtelijker PortB0 kunnen worden genoemd ofzo met als voordeel dat het ook makkelijker naar bijvoorbeeld een Nano kan worden overgezet.

[DjoeC]

@kitao Ik snap je doel en de problemen. Hier is een stukje uit 1 van mijn .ino's waar - naar mijn idee - commentaar zowel nuttig is maar niet compleet onderhouden (850 vertraging ipv 900 uit het commentaar) Ik ben ook absoluut geen Arduino programmeur (wel in andere talen):

code:

void readDS18B20()
{
                                        // Get somewhat accurate time from router. 
  setup_UDP();
  gettime_UDP();
                                        // Start temp calculations on all sensors
  sensors1.requestTemperatures();
  sensors2.requestTemperatures();
                                        // 1 second later all calculations should be complete
                                        // @ highest (12 bit) resolution.  11 bit takes max 0.375 sec.
                                        // But why rush.....
//  delay(1000)
                                        // Made 900 ms to keep 60 sec turnaround per reading
  delay(850);
                                        // For debugging purposes: Print # sensors per port which we 
                                        // identified earlier.
  Serial.print("sensNum1 : ");                    
  Serial.println(sensNum1, DEC);                  
  Serial.print("sensNum2 : ");                    
  Serial.println(sensNum2, DEC);                  
                                        // Go get all temps per port
  Serial.println("==>getTemp1<==");
  for (i = 0; i < sensNum1; i++)
    {
    getTemp1(sensTab [i]);
    processTemp();
    }
                                        // Careful:  When using more than 2 ports this needs to be changed
                                        // together with some other things....
  Serial.println("==>getTemp2<==");
  for (i = sensNum1; i < sensNumTot; i++)
    {
    getTemp2(sensTab [i]);
    processTemp();
    } 
  Serial.println("==>ReadyTemps<==");
}

Code kwaliteit zal best iets op aan te merken zijn maar dit werkt voor mij om tientallen DS18B20 temperatuur sensoren in 1 keer uit te lezen

[Accretion]

DjoeC schreef op zondag 21 december 2025 @ 23:19:

code:

void readDS18B20()
{
                                        // Get somewhat accurate time from router. 
  setup_UDP();
  gettime_UDP();

"Get somewhat accurate time from router."
"gettime_UDP"

Dat soort commentaar heb ik een hekel aan.
Dat de 'getTime_UDP' tijd ophaalt via UDP heb ik niets aan.
Ik vraag mij af waarom je op dat punt tijd ophaalt, zeker gezien het niet naar een variabele geschreven wordt én daar verder niets mee gedaan wordt in dezelfde functie?

En daarnaast, wat is het verschil tussen getTemp1 en getTemp2?

Ik heb liever een block comment boven de functie die uitlegt wat de functie doet dan per regel.
Dat werkt ook beter met programma's die documentatie genereren.

Commentaar kan ook beter boven de regel staan dan ernaast, is makkelijker als je twee IDE windows naast elkaar hebt staan. Zo allemaal op een lijn proberen te krijgen is alleen maar onhandig als je een lijn toevoegt die weer langer is en je alles weer moet uitlijnen.

[kitao]

DjoeC schreef op zondag 21 december 2025 @ 23:19:
@kitao Ik snap je doel en de problemen. Hier is een stukje uit 1 van mijn .ino's waar - naar mijn idee - commentaar zowel nuttig is maar niet compleet onderhouden (850 vertraging ipv 900 uit het commentaar) Ik ben ook absoluut geen Arduino programmeur (wel in andere talen):

code:

void readDS18B20()
{
                                        // Get somewhat accurate time from router. 
  setup_UDP();
  gettime_UDP();
                                        // Start temp calculations on all sensors
  sensors1.requestTemperatures();
  sensors2.requestTemperatures();
                                        // 1 second later all calculations should be complete
                                        // @ highest (12 bit) resolution.  11 bit takes max 0.375 sec.
                                        // But why rush.....
//  delay(1000)
                                        // Made 900 ms to keep 60 sec turnaround per reading
  delay(850);
                                        // For debugging purposes: Print # sensors per port which we 
                                        // identified earlier.
  Serial.print("sensNum1 : ");                    
  Serial.println(sensNum1, DEC);                  
  Serial.print("sensNum2 : ");                    
  Serial.println(sensNum2, DEC);                  
                                        // Go get all temps per port
  Serial.println("==>getTemp1<==");
  for (i = 0; i < sensNum1; i++)
    {
    getTemp1(sensTab [i]);
    processTemp();
    }
                                        // Careful:  When using more than 2 ports this needs to be changed
                                        // together with some other things....
  Serial.println("==>getTemp2<==");
  for (i = sensNum1; i < sensNumTot; i++)
    {
    getTemp2(sensTab [i]);
    processTemp();
    } 
  Serial.println("==>ReadyTemps<==");
}

Code kwaliteit zal best iets op aan te merken zijn maar dit werkt voor mij om tientallen DS18B20 temperatuur sensoren in 1 keer uit te lezen

Dank je voor de toelichting en gezien het toch pittige commentaar van Accretion hierop zijn er denk ik een aantal voorwaarden te bedenken bij de keuze van stijl van de commentaar regels. Zoals: Is het commentaar voor iemand zelf die later de eigen code weer opduikelt of is het voor derden, al dan niet geoefend of beginnend? En sommige IDE's, zoals MPLab hebben een automatische tekstregel wrap optie, dwz dat er geen horizontale scrollbar nodig is en de code regels niet uit beeld verdwijnen en het zich aanpast aan de window breedte.

De Github pagina waar ik naar verwees
https://github.com/upiir/arduino_7segment_lcd_display
is voor de beginnende derden categorie dus het onjuist pin nummeren in zijn commentaar regels was nogal slordig van autheur Upir, die overigens wel een recent en zeer rijk Youtube Arduino Uno Display kanaal heeft:
https://www.youtube.com/@upir_upir/videos

Ik heb zelf wel eens geprobeerd te programmeren met o.a. Basic, PBasic, Assembly, C, C++ en Arduino Ide* maar ik ben ermee gestopt vanwege gebrek aan aanleg ervoor en liep vast naarmate het moeilijker werd (story of my life)
* Arduino uses C++ — but with a custom framework and build system on top.

Tegenwoordig ben ik ook een beetje bezig met Cpld's en Fpga's en dan worden er weer andere programmeertalen gebruikt zoals Verilog en Vhdl dus het wordt sowieso toch al teveel om dat te gaan leren en blijft het bij copy/pasten en af en toe wat aanpassen van een paar regeltjes.

Overigens ging mijn vraagje niet zozeer over het coderen maar over het aansturen van een segmented LC-display zoals opnieuw afgebeeld in dit plaatje:


klik

Alle 36 display pinnen zitten op 1 Uno pin, namelijk pin 2 oftwel PortD2 waarmee het gehele display in de simulatie zichtbaar wordt. Ik heb in diezelfde simulatie een AC amperemeter direkt na pin2 er tussen geplaatst, zie vorige post en die slaat nauwelijks uit dus nu vraag ik me af of deze opstelling ook in het echt zo zou werken?
Verstandig lijkt me dan wel om per keer 1 dipswitchje te activeren om eventueel een verhoogde aanloopstroom te voorkomen indien alle dipswitches geactiveerd zijn terwijl er spanning op wordt gezet. Kortom > opstarten met alle schakelaars op OFF.
Ik heb zo'n type LCD'tje besteld


40PIN TN Positive 4-Digits Segment LCD Panel White/Blue/Yellow Green Backlight Static Drive 5V Industrial Digital Display Screen

en dan probeer ik het met een stand alone Atmega328P chip die ik nog op breadboard heb staan met een amperemeter er tussen.
.

[ Voor 4% gewijzigd door kitao op 23-12-2025 04:08 . Reden: Plaatje toegevoegd ]

[DjoeC]

Accretion schreef op maandag 22 december 2025 @ 07:14:
[...]


"Get somewhat accurate time from router."
"gettime_UDP"

Dat soort commentaar heb ik een hekel aan.
Dat de 'getTime_UDP' tijd ophaalt via UDP heb ik niets aan.
Ik vraag mij af waarom je op dat punt tijd ophaalt, zeker gezien het niet naar een variabele geschreven wordt én daar verder niets mee gedaan wordt in dezelfde functie?

En daarnaast, wat is het verschil tussen getTemp1 en getTemp2?

Ik heb liever een block comment boven de functie die uitlegt wat de functie doet dan per regel.
Dat werkt ook beter met programma's die documentatie genereren.

Commentaar kan ook beter boven de regel staan dan ernaast, is makkelijker als je twee IDE windows naast elkaar hebt staan. Zo allemaal op een lijn proberen te krijgen is alleen maar onhandig als je een lijn toevoegt die weer langer is en je alles weer moet uitlijnen.

Ik gebruik vooral Global variabelen want dat werkt het beste voor mij. Dat je in de clip geen gebruik ziet zegt verder niets (nee, ik ga niet de hele .ino delen). Waarom daar? Ik haal die timestamp 1x op om in elke temperatuur observatie (loopje wat je niet ziet) aan de meting toe te voegen.

getTemp1 & getTemp2 zijn 2 instanties van een one-wire netwerk op 2 verschillende pin's, eerder in de sketch gedocumenteerd. De functie als zodanig stuurt 1 commando naar het one-wire netwerk en zegt: Alle DS18B20 op dit netwerk luister: "Bepaal de temperatuur op dit moment". Die wordt in een loopje na de delay (850ms) per sensor uitgelezen. Voordeel: ipv elke sensor individueel laten rekenen met 1 sensor per 375ms bij 11 bits volgens commentaar elders in de INO:

code:

                                        // Accuracy:  9 bit = 0.5    C, calc time =  93.75 ms  
                                        //           10 bit = 0.25   C,           = 187.5  ms
                                        //           11 bit = 0.125  C,           = 375    ms
                                        //           12 bit = 0.0625 C,           = 750    ms

wordt er nu in totaal 375ms gerekend. Dat scheelt bij de (maximaal) 60 sensoren in deze opzet 59*375ms. En dat maakt dat de ESP langer in deep-sleep gaat tussen metingen.

Enneh, programma's die zelf documentatie genereren houd ik dan weer niet van.... "In principe" dienen programma code zelf documenterend te zijn, als dat niet is heb je zut gemaakt. In mijn geval was dit mijn eerste Arduino poging na wat met examples (en dus ook met C (?) gekloot te hebben en had ik dus behoefte aan een beschrijving voor mijzelf:

code:

/*    WeMos D1 mini V2 with multiple sensors
      Version 2016-08-06
      Control via MQTT, debug Serial
      
      Hookup guide:
        - connect D0 to RST in order to wake op from deep sleep
        - DS18B20:
          + connect 5V (3.3V does not work properly with many sensors) to VDD pin of DS18B20 
          + connect G(round) to GND pin of DS18B20
          + Connect DS18B20 DQ data pin to D4, D5, ...
*/

Kan het beter? Natuurlijk! Is mijn manier DE manier? Natuurlijk niet. Maar deze methode - zeker met mijn vorm van programmeren en als je door de hele .ino heen loopt werkt voor mij. Het is (wordt) geen open-source, het draait inmiddels 9 jaar met in die 9 jaar minimaal onderhoud en heeft inmiddels zo'n 250.000.000 metingen geleverd aan de tegenhanger, een Python programma op een Raspberry dat mbv Grafana (toen ook allemaal nieuw voor mij) de boel verder verwerkte naar database, acties, alerts.

OK, beetje afgedwaald want het ging om wat zinvol commentaar is of niet. Meningen daarover verschillen dus en dat mag. We zijn het er over eens dat commentaar niet letterlijke beschrijving moet zijn van het statement en zeker niet in herhalingen hoort te vallen. Commentaar moet bijdragen aan het begrip van wat waarom moet gebeuren en commentaar moet onderhouden worden. Voor mij blijft meespelen dat de code eigenlijk door de keuze van variabele namen (kort of lang) en de bijbehorende documentatie alsook de structuur van het proggie begrijpelijk wordt. Nogmaals, er is niet 1 correcte methode.

En om je een idee te geven hoe dat werkt, ik ben opgeleid met VSP, Volmac Structured Programming. De commentaren hieronder, waar over VSP gemijmerd wordt, geven iets meer insight en zegt vast ook iets over mijn leeftijd

[vanaalten]

vanaalten schreef op zaterdag 13 december 2025 @ 15:31:
OK, misschien ben ik hier helemaal verkeerd, maar je moet toch ergens beginnen:
Ik heb een klein hobbyproject in gedachten. Ben over het algemeen niet zo bezig met elektronica, programmeren en zo, maar wat ik graag zou willen:

• Functie: IR-commando ontvangen van een Logitech Harmony remote en dan een Wake-on-Lan via ethernet het netwerk opsturen.
• Het nog-te-maken device staat 24/7 aan, liefst dus low-power, zero-maintenance.
• Moet een ethernet-aansluiting hebben (duh...) en, om adapter uit te sparen, Power-over-Ethernet gevoed zijn. Natuurlijk kan het functioneel ook prima draadloos werken, maar ik wil dingen bij voorkeur bedraad.
• Op de een of andere manier dus een IR-ontvanger hebben.

Na wat google, rondzoeken enzo kwam ik uit op een Arduino Leonardo ETH2 met PoE. Ik ben wel gecharmeerd van Arduino als concept, heb ik een heeeeel ver verleden wel eens iets met Arduino gedaan dus dit leek mij wel een goede basis.

Echter: dit bord blijkt End-of-Life, dus zal lastig aan te komen zijn. Wat zijn dan mijn alternatieven?
Arduino Uno + Arduino Ethernet Shield 2 + Ag9000-S PoE module?

Of zijn er beter, desnoods niet-Arduino, keuzes te maken?

Even afronding:
De tip van @_ferry_ was een hele bruikbare, ik heb uiteindelijk een Olimex ESP32-POE2 aangeschaft - met als doorslaggevend argument dat de fabrikant ook een mooie passende behuizing (BOX-ESP32-POE2) verkoopt. Inclusief verzending was ik zo'n 55 euro kwijt.
Een bruikbare infraroodontvanger had ik nog liggen (Vishay TSOP32238), evenals wat flatcable en een connector voor de UEXT poort. Dus simpelweg die TSOP32238 aan pinnen 1, 2 en 3 van de UEXT connector verbinden en de hardware was klaar.

Software: dat was wat puzzelen. Infrarood ontvangen kon met IRremote library die best goed gedocumenteerd was. Maar voor mij was het dan puzzelen als beginner of die (*Arduino*-IRremote) bruikbaar was voor ESP32, twijfels over of de pinnummer het GPIO nummer of fysieke IC pinnummer moest zijn. Als je dan ook de serial debugger baudrate op 115200 hebt gezet, maar aan de ontvanger kant nog op 9600 staat, dan verloopt het debuggen wat moeizaam.

Anyway, de afstandbediening die ik gebruik (voor een FLIRC receiver) wordt niet direct als protocol herkent, maar met 'raw code' kan je 'm toch bruikbaar ontvangen. Dus dat gedeelte was goed oplosbaar.

Ethernet was ook wat puzzelen. Het verbinden en IP-adres krijgen stelde weinig voor, met dank aan de goede voorbeelden van de fabrikant. Hoe een UDP pakketje voor WOL te verzenden was vooral trial&error. De AsyncUDP library bleek uiteindelijk bruikbaar, maar qua documentatie vond ik het wat karig (moet je nou connecten voor je wat kan sturen? En moet je vervolgens writeTo, sendTo of broadcastTo gebruiken?). Met behulp van tcpdump/wireshark pakketjes monitoren en vergelijken met een 'echt' wake-on-lan commando hielp mij hier wel bij.

Ofwel, uiteindelijke code:

code:

#ifndef ETH_PHY_TYPE
#define ETH_PHY_TYPE   ETH_PHY_LAN8720
#define ETH_PHY_ADDR   0
#define ETH_PHY_MDC   23
#define ETH_PHY_MDIO  18
#define ETH_PHY_POWER 12
#define ETH_CLK_MODE  ETH_CLOCK_GPIO0_OUT
#endif

#include <ETH.h>
#include <AsyncUDP.h>
#include "PinDefinitionsAndMore.h"
#include <IRremote.hpp>
#define IR_RECEIVE_PIN 4  // GPIO4

#define WOL_PORT 9
#define WOL_MAC 0xA0AD9F162A1F

static bool eth_connected = false;
unsigned char MagicPacket[102];
AsyncUDP udp;

void onEvent(arduino_event_id_t event) {
  switch (event) {
    case ARDUINO_EVENT_ETH_START:
      Serial.println("ETH Started");
      // The hostname must be set after the interface is started, but needs
      // to be set before DHCP, so set it from the event handler thread.
      ETH.setHostname("esp32-ethernet");
      break;
    case ARDUINO_EVENT_ETH_CONNECTED:
      Serial.println("ETH Connected");
      break;
    case ARDUINO_EVENT_ETH_GOT_IP:
      Serial.println("ETH Got IP");
      Serial.println(ETH);
      eth_connected = true;
      break;
    case ARDUINO_EVENT_ETH_LOST_IP:
      Serial.println("ETH Lost IP");
      eth_connected = false;
      break;
    case ARDUINO_EVENT_ETH_DISCONNECTED:
      Serial.println("ETH Disconnected");
      eth_connected = false;
      break;
    case ARDUINO_EVENT_ETH_STOP:
      Serial.println("ETH Stopped");
      eth_connected = false;
      break;
    default: break;
  }
}

void setup() {
  // Set-up serial debugger:
  Serial.begin(115200);

  // Set-up IR receiver:
  IrReceiver.begin(IR_RECEIVE_PIN);
  Serial.print(F("Ready to receive IR signals of protocols: "));
  printActiveIRProtocols(&Serial);
  Serial.println(F("at pin " STR(IR_RECEIVE_PIN)));

  // Set-up ethernet:
  Network.onEvent(onEvent);
  ETH.begin();

  // Build magic packet: 6 x 255, 16 x MAC address to wake:
  for (int i=0; i<6; i++)
    MagicPacket[i] = 255;
  for (int i=0; i<16; i++)
    for (int j=0; j<6; j++)
      MagicPacket[6 + j + (6*i)] = char((WOL_MAC>>(40-(8*j)))&255);

  Serial.print("Magic packet: ");
  for (int i=0; i<sizeof(MagicPacket); i++) Serial.print(MagicPacket[i], HEX);
  Serial.println();
}

void loop() {
  if (IrReceiver.decode()) {
    auto tDecodedRawData = IrReceiver.decodedIRData.decodedRawData; // uint32_t on 8 and 16 bit CPUs and uint64_t on 32 and 64 bit CPUs
    if (IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT) {
      Serial.println(F("Repeat received."));
    } else {
      Serial.print(F("Raw data received: 0x"));
      Serial.println(tDecodedRawData, HEX);
    }
    if (tDecodedRawData == 0x89D547CF) {
      Serial.println("Waking up remote machine");
      udp.writeTo(MagicPacket, sizeof(MagicPacket), ETH.broadcastIP(), WOL_PORT);
    }
    IrReceiver.resume();
  }
}

(en ja, er zal vast genoeg aan te verbeteren zijn - maar vooralsnog voldoet dit voor mij)

Dank nogmaals aan iedereen die mee dacht en mij deze richting op stuurde!

[kitao]

@vanaalten
Mooi dat je het in werking hebt gekregen, is geen makkelijk project als je aan zoiets van de grond af aan begint.
Met name dit hieronder, uit jouw link, gaat in het begin meestal wel goed bij mij:

Important notice: ESP32-POE2 has no galvanic isolation from Ethernet's power supply, this might be a problem for ground loops. This also means that when you program the board via the USB connector the Ethernet cable should be disconnected (if you have power over the Ethernet enabled)! Any board with own external power supply attached to ESP32-POE2 can be dangerous. Consider using Olimex USB-ISO to protect your computer and board from accidental short circuit (do not use external power for the USB-ISO!).

maar na een tijdje ben ik dat dan weer vergeten en flash ik zo de Usb van de laptop aan gort

Met wat rode tape probeer ik gekluns schade te voorkomen:


.

[kitao]

Gisteren een Uno Q 2GB uit het doosje gehaald


https://www.arduino.cc/en/uno-q/
datablad 37 pagina's: https://docs.arduino.cc/r...ts/ABX00162-datasheet.pdf

en niet om reclame te maken maar misschien van belang is dat die niet via Arduino maar via Digikey besteld is.
https://www.digikey.nl/en...arduino/ABX00162/27526619
Scheelt in kosten want het board is goedkoper en met gratis verzending boven de $60,- maar mogelijk dat het te lang op de plank heeft gelegen en de pre-installatie software of het image verouderd was?

Om de Q te kunnen gebruiken is er Arduino App Lab nodig en de 'normale' Arduino IDE.
https://docs.arduino.cc/software/app-lab/
Dus eenmaal App Lab geopend en board aangesloten verscheen de melding :
"Het systeem van het board is verouderd en adviseerde me om "Flasher Tool te installeren."
Op dat punt bleef App Lab steken dus er was geen andere keus als de Flasher Tool te installeren en daarmee een nieuw image op de MPU te flashen, volgens deze instructie:
https://docs.arduino.cc/tutorials/uno-q/update-image/
Vervolgens brak er een ca. 10 uur durende marathon aan met een CoPiloot die uiteindelijk tot de conclusie kwam dat er geen online Arduino Q OS beschikbaar is en heeft na die 10 uur een ticket gefabriceerd om te sturen naar klantenservice, waarvan hieronder een gedeelte daarvan, auto-vertaald vanuit Engels:

Toen ik voor het eerst de gloednieuwe UNO Q met Arduino App Lab verbond, meldde de software onmiddellijk dat het systeem van de board verouderd was en adviseerde me om "Flasher Tool te halen." Ik volgde deze prompt precies zoals aangegeven. Ik downloadde de Arduino Flasher CLI van de officiële Arduino-softwarepagina en gebruikte het zoals voorgeschreven.

Het flashen is succesvol voltooid, maar het hulpmiddel installeerde een Debian 13 (trixie) basisimage in plaats van het volledige Arduino UNO Q-besturingssysteem. Na het flashen start de board normaal op, maar de volgende problemen doen zich voor:
Het systeem meldt:
PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
Het qboard-subsysteem ontbreekt:
dpkg -l | grep qboard geeft geen resultaten
De qboard-pakketten zijn niet beschikbaar in de repository:
apt search qboard geeft niets terug.
Het Arduino OS-meta‑pakket (arduino-unoq-os) kan niet worden geïnstalleerd
De LED-matrix en App Lab-integratie werken niet omdat de benodigde services niet aanwezig zijn
Na het bekijken van de documentatie van de tool ontdekte ik dat de Arduino Flasher CLI Debian-images flasht, niet het volledige Arduino UNO Q OS. Dit verklaart waarom het bord op een basisniveau van Linux functioneel werd, maar alle UNO Q-specifieke services zoals qboard en matrixsupport verloor.
etc.
*****************************************************

Board werkt wel met de standaard voorbeelden. Voor mij is het vrij nieuw zo'n combinatie tussen Mcu en Mpu maar mogelijk herkent iemand dit beter met mogelijk een tip hierover.



Arduino App Lab is designed specifically for the Arduino UNO Q board, which combines a microcontroller (MCU) and a microprocessor (MPU) running Linux. It allows you to build Apps that can include both C++ sketches for the MCU and Python scripts for the MPU, connected via the Bridge API. It also integrates Bricks — prebuilt modules such as AI models, web servers, or API connectors — that run in parallel with your Apps, often as Docker containers. App Lab supports multiple modes:
Desktop Mode (USB) for direct programming from PC.
Network Mode (Wi-Fi) for wireless development.
SBC Mode to use the UNO Q as a standalone computer.
.

[ Voor 10% gewijzigd door kitao op 25-01-2026 13:37 . Reden: link toegevoegd ]

[Accretion]

kitao schreef op zondag 25 januari 2026 @ 12:50:
Gisteren een Uno Q 2GB uit het doosje gehaald

Klinkt als niet de beste 'out of box experience'.

Wel goed dat ze naar STM gewisseld zijn, USB-C gebruiken en interessant dat ze een on-board QWIIC connector hebben.

"App lab" had ik ook nog niet gezien, die drag&drop mogelijkheid ziet er leuk uit om ook jeugd geïnteresseerd te krijgen in embedded spul.

De combinatie van MPU en MCU is interessant, maar vaak heb je maar een van beide nodig, dus denk niet dat ik snel een Q ga bestellen.

[kitao]

@Accretion

Klinkt als niet de beste 'out of box experience'.

Nee niet echt maar het Q-board is momenteel voor een groot deel functioneel en zonder de specifieke testjes van de Copiloot had ik waarschijnlijk nog niet eens gemerkt dat de brug tussen MPU en MCU ontbreekt want de uitgeprobeerde standaard voorbeelden doen het tot dusver.
Hier een aantal links voor de geinteresseerde:
- https://docs.arduino.cc/tutorials/uno-q/user-manual/
- https://docs.arduino.cc/tutorials/uno-q/debian-guide/
De tweede link is een sub van de eerste.
- https://docs.arduino.cc/r.../ABX00162-full-pinout.pdf

Dit is een korte analyse van de Copiloot van het Brug probleem:

🟩 1. The MCU side is fully intact
You can upload sketches.
You can use Arduino Core.
You can control GPIO, matrix, LEDs, etc.
This part is fine.
🟧 2. The Linux side can run Python and Debian normally
You can use it as a small Linux computer.
🟥 3. The Bridge cannot be restored without the official Arduino OS image
Because:
qboard is missing
App Lab runtime is missing
arduino-router service is missing
systemd units are missing
GPIO initialization scripts are missing
MCU handshake logic is missing
Python integration is missing
The only way to restore the Bridge is to reflash the official Arduino OS image

Dat moet dan via klantenservice komen want die staat niet online volgens de AI.
en :
qboard is the Linux-side software stack that makes the UNO Q behave like an Arduino. It includes the matrix driver, App Lab runtime, RPC layer, and MCU communication services. Your board has Debian and the MCU firmware, but qboard is missing.

Dus tja, afwachten wat klantenservice naar me gaat mailen, ik heb al een auto-mail gekregen maar dat leverde geen oplossing. Toch kan ik er nu al wat mee stoeien en dit bevalt me ook wel:
You can use it as a small Linux computer.
Ik heb wel eens een Linux partitie op mijn PC gehad maar door wat geklungel ging de lap op slot en zit dat nog steeds dus dat was best een prijzig experimentje, zeker vergeleken met dit boardje.

Hier het Brug Mechanisme:
https://docs.arduino.cc/t...rocedure-call-rpc-library


.

[kitao]

Nog even kort samengevat:
Q-board vanuit de doos aangesloten met Arduino App Lab geopend waarna dit verscheen:
"Het systeem van het board is verouderd, installeer "Flasher Tool".
Op dat punt bleef App Lab steken dus er was geen andere keus als de Flasher Tool te installeren en daarmee een nieuw image op de MPU te flashen, volgens deze instructie:
https://docs.arduino.cc/tutorials/uno-q/update-image/
en deze:
How to Reflash the Operating System to Your Arduino UNO Q
https://www.digikey.com/e...f9341633f1522f5a792eb622c

Dat flasht dan een nieuwe Debian erin maar dat is blijkbaar niet het Arduino OS image.

Na bezig te zijn geweest met Secure Shell SSH, het gaat stapje voor stapje allemaal, is er een error verdwenen.
Dit command /$ systemctl status ssh en met het Q-board in Netwerk modus had als resultaat dat de Router tussen MPU en MCU goed herkend wordt en blijft.

Maar volgens de Cop assistent is dit de huidige situatie:



This is exactly what happens when the board is flashed with a Debian-only image instead of the full Arduino OS image.

Kern van het probleem is dus waar een Full Arduino OS image voor het Q-board 2GB te vinden en te installeren valt. Ondertussen wachtend op Klantenservice is het board goed te gebruiken want er zit een OS op maar blijkbaar niet (meer) het OS waarmee het geleverd werd of dat erin had moeten zitten.
.

[ Voor 6% gewijzigd door kitao op 27-01-2026 06:43 . Reden: link toegevoegd ]

[kitao]

Update:
Netjes en snel persoonlijk antwoord gekregen per email van Arduino klantenservice. Dit heeft, volgend op de eerdere aanwijzingen van de Copiloot, de laatste plooitjes glad gestreken en het Q-board is nu zoals het hoort te zijn. Er blijkt bijvoorbeeld dat na een 'power-cycle' of een sudo reboot de MCU sketch niet 'auto-runt' zolang daar geen apart knopje voor wordt omgezet, zie afbeelding rechtsboven en link daaronder.



https://docs.arduino.cc/t...running-an-app-at-startup

De foto hieronder van het Q-board is van een matrix voorbeeld die er nu op draait volgens deze link:
https://docs.arduino.cc/t...q/user-manual/#led-matrix



Om terminal commands te geven en om de Linux files te bekijken op de MPU heb ik Visual Studio Code geinstalleerd maar er zijn daar meerdere opties voor om dat te kunnen doen.



Ik heb dus geen spijt van de aankoop en eigenlijk heeft het verouderde OS waarvan het image vervangen moest worden er indirect toe geleid om het board beter te leren kennen.
https://docs.arduino.cc/tutorials/uno-q/update-image/

Of iedere klant daar blij mee zal zijn is de vraag
.

[kitao]

Handig, als je van de level shifters of van de weerstandsdelers af wil, de Due heeft standaard 3.3V op z'n I/O's dus met het gemak van de Arduino Ide bijvoorbeeld rechtstreeks met een Cpld te verbinden.
Vandaag uitgepakt, eerste wat opviel zijn de dubbel uitgevoerde Usb-aansluitingen. Volgens co-piloot :
1. “Programming ATmega16U2” (micro‑USB)
This is the programming port.
It works exactly like the classic Arduino Uno/Mega programming interface.
The ATmega16U2 acts as a USB‑to‑serial converter.
This is the recommended port for uploading sketches, especially on first use.
It also powers the board safely.
2. “Native USB SAM3X” (micro‑USB)
This is the native USB port, wired directly to the SAM3X8E ARM chip.
Useful for:
USB HID (keyboard/mouse)
USB MIDI
High‑speed serial
Custom USB device classes
You can upload through it, but if your sketch crashes the USB stack, the port may stop responding until you reset the board.

Boardje omdraaien en dan valt er tekst te lezen welke connector wat is. Dichtst bij de Jack is de “Programming ATmega16U2”.



https://www.theengineerin...ction-to-arduino-due.html
The Arduino Due is the first Arduino board based on a 32-bit ARM core microcontroller. With 54 digital input/output pins, 12 analog inputs, 2 DAC and 2 CAN it is the perfect board for powerful larger scale Arduino projects.
https://docs.arduino.cc/hardware/due/#tech-specs
.

[DjoeC]

Een vraag, niet specifiek ESPhome maar ik kan eigenlijk geen "juist" topic vinden maar hier weet vast iemand het antwoord.

Na heel veel jaren moet ik mijn oude ESP8266 code opnieuw compileren. Dat betekent nieuwe Arduino IDE gebruiken (v2.3.8) boardmanager(s) en alle libraries in nieuwe, onbekende versies opnieuw installeren. Nu loop ik vast op de esp8266 library in de gigantische keuze lijst. Dat was in de "oude" compiler ESP8266 by the ESP8266 community maar ik kan niets vinden dat daar op lijkt. En dan maar hopen dat alles compatibel is.

Weet iemand de huidige naam van de oude ESP8266 library met daarin o.a. ESP8266WiFi.h en WiFiUdp.h?

Schopje naar het Arduino topic

[ Voor 3% gewijzigd door Septillion op 12-03-2026 14:03 ]

[ocmer]

DjoeC schreef op donderdag 12 maart 2026 @ 13:58:
Een vraag, niet specifiek ESPhome maar ik kan eigenlijk geen "juist" topic vinden maar hier weet vast iemand het antwoord.

Na heel veel jaren moet ik mijn oude ESP8266 code opnieuw compileren. Dat betekent nieuwe Arduino IDE gebruiken (v2.3.8) boardmanager(s) en alle libraries in nieuwe, onbekende versies opnieuw installeren. Nu loop ik vast op de esp8266 library in de gigantische keuze lijst. Dat was in de "oude" compiler ESP8266 by the ESP8266 community maar ik kan niets vinden dat daar op lijkt. En dan maar hopen dat alles compatibel is.

Weet iemand de huidige naam van de oude ESP8266 library met daarin o.a. ESP8266WiFi.h en WiFiUdp.h?

[mbr]Schopje naar het Arduino topic[/]

Ik heb een vergelijkbare situatie gehad; probeerde code van een 4 jaar oud project opnieuw te compileren waarbij de libraries inmiddels niet meer compatibel met elkaar waren. Het is me, met veel frustraties, niet gelukt.
Uiteindelijk heb ik de ESP8266 vervangen door een ESP32, een paar libraries vervangen, en compileerde alles in 1 keer en heb ik een veel toekomstvastere situatie.

[Septillion]

@DjoeC Volgens mij is de ESP8266 boards package (niet library) nooit opgenomen in de standaard boards en altijd een additional gebleven. Dus gewoon, net als toen, zelf toevoegen.

Zelf al een tijd niet meer de Arduino IDE gebruikt (ook nooit naar de v2 gewisseld) dus hoe dan de library compatibiliteit is zal sterk afhangen van wat je gebruikt. Maar kijkende naar wat ESPHome nog kan gebruiken met het ESP8266 Arduino framework zou ik zeggen dat veel nog wel moet werken.

[DjoeC]

Septillion schreef op donderdag 12 maart 2026 @ 14:16:
@DjoeC Volgens mij is de ESP8266 boards package (niet library) nooit opgenomen in de standaard boards en altijd een additional gebleven. Dus gewoon, net als toen, zelf toevoegen.

Zelf al een tijd niet meer de Arduino IDE gebruikt (ook nooit naar de v2 gewisseld) dus hoe dan de library compatibiliteit is zal sterk afhangen van wat je gebruikt. Maar kijkende naar wat ESPHome nog kan gebruiken met het ESP8266 Arduino framework zou ik zeggen dat veel nog wel moet werken.

Ik ga eens aan t klooien..... Ik heb in de esp8266 pagina blijkbaar over de link naar hier heen gelezen. Ben de laatste tijd niet altijd 100% helder....

"Veel" werkt misschien nog wel, maar met de opnieuw geinstalleerde oude IDE met libraries gaat er iets fout in het discovery deel van het onewire deel: Discovery stopt na 1 device ipv dat ie ze alle 23 herkent Dus ik wil even helemaal opnieuw beginnen inclusief examples voordat ik een paar ESP32-C3's bestel.

<aanvulling>: Compileren werkt inmiddels, de onewire functie "search" doet t niet (meer) in een loop. Is geen hardware probleem want de "reserve" ESP8266 met de oude software doet t nog wel. Dat wordt nog een "leuk" uitzoek klusje.

[ Voor 8% gewijzigd door DjoeC op 12-03-2026 15:18 ]

[Raven]

Heeft iemand ervaring met het gebruiken van Arduino's (al mogen ESP's ook) om toetsenbordaanslagen te emuleren? Specifiek gaat het om het gebruiken van hotkeys i.c.m. een KVM-switch.

Ik gebruik die i.c.m. een JetKVM en dat werkt, alleen pikt de KVM-switch de scroll lock niet op waardoor ik het OSD niet kan openen (tenzij die automatisch geopend wordt na powerloss, dan is ie open en kan ik 'm bedienen) maar ook niet van input kan wisselen.

Er hangt mij iets van bij dat er Arduino's/ESP's zijn die HID ondersteunen, maar zelf heb ik daar helemaal geen ervaring mee, misschien iemand hier wel?

[JeroenH]

Raven schreef op zaterdag 11 april 2026 @ 09:22:
Heeft iemand ervaring met het gebruiken van Arduino's (al mogen ESP's ook) om toetsenbordaanslagen te emuleren?

Ik heb een keer wat voor mijn werk gebouwd met een Raspberry Pi Pico. Een medisch apparaat gaf een maak-contact van 100ms, maar de software op de computer had een toetsaanslag nodig om een foto op te slaan. De leverancier wilde het officiële kastje wel leveren voor E1500 (en dat voor vier opstellingen, dus keer vier), maar na een grondige risico-analyse hebben we dit zelf gebouwd voor nog geen 10% van die kosten. Werkt tot op de dag van vandaag nog betrouwbaar. De twee spares die ik ook gebouwd hebben liggen te verstoffen

[Raven]

@JeroenH Hmm, ik heb ergens een Pico W liggen, alleen de vraag waar (verhuizing)....

[JeroenH]

Als ik trouwens een beetje google dan lees ik dat de ESP32-S2 en ESP32-S3 ook een HID (dus toetsenbord en/of muis) moeten kunnen nadoen. Maar één van die varianten moet je maar net hebben liggen...

[kitao]

Update na kitao in "[Discussie] Arduino-topic"

Na ruim twee maanden onderbreking de Uno Q 2GB opnieuw aangesloten en na het openen van AppLab werd er een update aangeboden: versie 0.6.0. Die geaccepteerd en vervolgens mbv de Copiloot het volgende commando gegeven: systemctl status arduino-router

De output daarvan gaf deze reactie:
🎉 Conclusion: The Bridge subsystem is now restored

Everything in your output indicates:
- The update fixed the underlying issue
- The router is healthy
- The MCU link is healthy
- The RPC layer is healthy
- The backend is talking to the router
This is the first time in the entire debugging history that all components are green.

✔️ Why “Blink LED with UI” proves Bridge is working
The fact that the LED toggles means:
✔️ Router is working
✔️ MCU firmware is responding
✔️ RPC layer is alive
✔️ Serial link is healthy
✔️ AppLab → Router → MCU communication is intact
✔️ Bridge is restored end‑to‑end
This is the strongest possible confirmation.

Boardje is dus enkel door de Uno Q een paar maanden te laten verstoffen en met een standaard AppLab update 'gerepareerd'



Zie deze Github voor de releases:
https://github.com/arduino/arduino-app-lab/releases
Uno Q handleiding:
https://docs.arduino.cc/tutorials/uno-q/user-manual/
.

[ Voor 2% gewijzigd door kitao op 12-04-2026 04:40 . Reden: link toegevoegd ]

[Raven]

JeroenH schreef op zaterdag 11 april 2026 @ 11:47:
Als ik trouwens een beetje google dan lees ik dat de ESP32-S2 en ESP32-S3 ook een HID (dus toetsenbord en/of muis) moeten kunnen nadoen. Maar één van die varianten moet je maar net hebben liggen...

Ik heb net even de nogal grote (maar goddank per winkel gesorteerde) email-map met bestellingen doorzocht, zo te zien nooit een S2 of S3 variant van de ESP32 besteld.

Inmiddels wel de Pico W gevonden, met display erop die ook nog eens 2 knopjes en een joystickje heeft. Heb ergens een sketch waarmee het display wordt aangestuurd en de knopjes en joystick-richting wordt gedetecteerd. Eens kijken of ik HID daar aan kan toevoegen... al is OTA denk ik eerst handiger, dan hoef ik die niet telkens aan de pc te hangen.

De Arduino IDE update met mDNS fix is volgens mij nog niet uit.

edit: @JeroenH Heb het al niet meer nodig , had de JetKVM op de muispoort ipv toetsenbordpoort aangesloten, daarna werkte de macro met 2 scroll locks (met 100ms ertussen en erna) wel

[ Voor 12% gewijzigd door Raven op 11-04-2026 19:54 ]

[kitao]

Onderin een doos kwam ik nog een setje RF7020 modules tegen. Volgens de copiloot is dat vrijwel hetzelfde als een APC220. Dat blijkt ook wel uit dit artikel dat de titel APC220 heeft en een foto toont van dat board met opdruk RF7020:




Getting Started with APC220 Radio Module: Setup & Guide | DFRobot Wiki

Er wordt in het artikel beschreven dat er een driver nodig is maar bij aansluiten van de module op de laptop werd de driver meteen herkend door Windows 11.
Verder wordt erin beschreven hoe de module in te stellen maar ooit heb ik die eens eerder gebruikt en misschien dat ik dat al gedaan had want het bleek niet nodig.

Als te verzenden signaal heb ik een geluidsensor toegepast, een KY-037



Aanvankelijk wou ik een alarm via de Usb op de computer laten afgaan als er een geluid wordt gedetecteerd maar na een aantal uren proberen is dit nog niet gelukt. Serial communication terminal programma HTerm ontving wel het signaal maar heeft zover ik gevonden heb geen trigger functie en pogingen om de Copiloot een Python programma daarvoor te laten schrijven zijn niet geheel gelukt.
Daarom de Usb converter eraf gehaald en vervolgens een Uno Transmitter naar een Uno Receiver opstelling opgebouwd dat wel goed werkt.



code transmitter

C++:

#include <SoftwareSerial.h>

// --- RF module on pins 10 (RX) and 11 (TX) ---
SoftwareSerial RF(10, 11); // RX, TX

// --- KY-037 sound sensor ---
const int soundPin = 2;     // KY-037 digital output (DO)

// --- Onboard LED (pin 13) ---
const int ledPin = LED_BUILTIN;

// --- Flashing behaviour ---
const unsigned long flashInterval = 100;   // LED toggles every 100 ms
const unsigned long alertDuration = 2000;  // 2 seconds (adjust as needed)

// --- Internal state ---
bool alertActive = false;
unsigned long alertStartTime = 0;
unsigned long lastFlashTime = 0;

void setup() {
  pinMode(soundPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  RF.begin(9600);
}

void loop() {

  // --- Detect gong from KY-037 ---
  if (!alertActive && digitalRead(soundPin) == HIGH) {
    alertActive = true;
    alertStartTime = millis();
    lastFlashTime = millis();

    // --- Transmit Gong! once per detection ---
    RF.println("Gong!");
  }

  // --- Flash onboard LED for alertDuration ---
  if (alertActive) {

    // Toggle LED at the flash interval
    if (millis() - lastFlashTime >= flashInterval) {
      digitalWrite(ledPin, !digitalRead(ledPin));
      lastFlashTime = millis();
    }

    // Stop after alertDuration
    if (millis() - alertStartTime >= alertDuration) {
      alertActive = false;
      digitalWrite(ledPin, LOW);  // ensure LED is off
    }
  }
}

.
code receiver

C++:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);

  Serial.begin(9600);  // RF receiver connected to pins 0 (RX) and 1 (TX)
}

void loop() {
  static String buffer = "";

  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c == '\n') {
      // End of line: process buffer
      if (buffer.indexOf("Gong") != -1) {
        // Flash LED a few times
        for (int i = 0; i < 3; i++) {
          digitalWrite(LED_BUILTIN, HIGH);
          delay(200);
          digitalWrite(LED_BUILTIN, LOW);
          delay(200);
        }
      }
      buffer = "";
    } else if (c != '\r') {
      buffer += c;
    }
  }
}

.
De transmitter wordt getriggerd door de KY-037 dat bij geluidsdetectie z'n DO pin hoog maakt. De Uno zendt vervolgens de tekst Gong! uit en knippert z'n onboard ledje een paar keer.
De receiver ontvangt en vergelijkt de tekst met Gong en indien juist knippert die ook een paar keer zn ledje.
De APC220 gebruikt slechts vier van de 7 pinnen, namelijk Vcc, Gnd, RX en TX.
SoftwareSerial is bij de Transmitter gebruikt zodat het niet in de weg zit bij het uploaden en debuggen van de sketches. APC220 RX komt dan op pin 11 TX van de Uno.
Persoonlijk heb ik er zelf geen enkele regel aan geschreven, dat doet de AI tegenwoordig.

De APC220 blijkt niet goedkoop te zijn en er zullen best betere alternatieven zijn maar op zich is dit best een leuk project. Mogelijk met een vervolg als het gelukt is via de Usb-converter de laptop te laten flitsen.

Misschien dat iemand een idee heeft hoe dat gerealiseerd kan worden gebruik makend van de Arduino IDE Serial Monitor? Ik kreeg daar namelijk al meteen het struikelblok voor m'n voeten geworpen dat er een Poort én een Board ingesteld moeten worden. Een Poort zonder Board in de Ide instellen lukte me niet zo best
.

[kitao]

Inmiddels is ook de transmissie naar de laptop gelukt. Dat werkte zoals gezegd al met HTerm die de ontvangst vertaalde en dus ook bevestigde maar die triggert niets. Pogingen om de luisterende HTerm ahw te vervangen met een Python-script lukte niet, ondanks enkele uren proberen.

Het blijkt te liggen aan de Usb-adapter die bij de APC220 zit, het zwarte boardje en dat is een CP2102.
De Transmitter is hetzelfde gebleven maar de Receiver opstelling is nu deze geworden:



APC220 is de antenne ontvanger die verbonden is met een FT232RL TTL USB Adapter, oftewel CP2102 is vervangen door FT232. (RX en TX kruislings en Vcc en Gnd gewoon doorverbinden)
Vervolgens met Notepad++ een Python bestandje aangemaakt:

Python:

import serial

ser = serial.Serial("COM9", 9600, timeout=1)

print("Listening...")

while True:
    data = ser.readline()
    if data:
        print("RAW:", data)

.
Dan PowerShell openen en deze instructie erin plakken, die wel afhankelijk is van het path waar het staat:
& "C:\Program Files\Python313\python.exe" d:\VSCode_Python_EigenProgs\doorbell_test.py

Mijn programmaatje staat bijvoorbeeld op een externe D:\ schijf, vandaar de d:\ hierboven en Python313 staat geinstalleerd op C:\Program Files.

Van PowerShell kreeg ik deze output:
>>
Listening...
RAW: b'Gong!\r\n'

Dat werkt dus goed en de rest is enkel nog meer toeters en bellen eraan hangen zodat de laptop een alarm gaat geven zodra aan de transmissie kant de KY-037 een geluid detecteert.

De oorzaak volgens de assistent is het volgende:

XML:

⭐ Why your CP2102 behaved badly
Your CP2102 module was:
opening the COM port but not delivering data to Python while HTerm worked fine and timing
 was inconsistent and newline framing was odd and Python’s readline() never triggered and
raw reads still didn’t show anything. 
This is classic CP2102 behavior on some Windows systems.

The CP2102 is known for:
delayed UART startup
inconsistent CR/LF timing
buffer stalls
Windows driver quirks
“port opens but no data” bugs
weird behavior when switching between HTerm and Python

HTerm is extremely forgiving.
Python is extremely strict.
That’s why HTerm worked and Python didn’t.

⭐ Why the FT232RL is different
The FT232RL is the gold standard of USB‑serial adapters.
It has:
✔ rock‑solid Windows drivers
✔ perfect timing
✔ perfect CR/LF handling
✔ perfect buffering
✔ perfect compatibility with Python
✔ no startup delay
✔ no “ghost data”
✔ no dropped bytes
✔ no weird behavior when switching programs
It is the most stable USB‑serial chip ever made.

If Python can’t read from a CP2102, the FT232RL almost always fixes it instantly.

.
Tja, dat krijg je met boardjes die van onder het stof worden gehaald

Voordeel van de APC220 is dat het een goed bereik heeft, volgens de specs althans:
Range 1200m line of sight (1200 bps)
https://wiki.dfrobot.com/tel0005#tech_specs
.

[Septillion]

@kitao Als je tijdens de install van Python het vinkje zet bij "Add to PATH" hoef je niet zo'n moeilijk commando te maken. Dan had je gewoon naar de file kunnen gaan en hem runnen.

En in de Arduino IDE maakt het volgens mij geen fluit uit welk board je pakt voor serial monitor. Zolang COM port en baudrate goed staan is het go.

[Ruitenwisser]

Septillion schreef op maandag 11 mei 2026 @ 12:03:
@kitao Als je tijdens de install van Python het vinkje zet bij "Add to PATH" hoef je niet zo'n moeilijk commando te maken. Dan had je gewoon naar de file kunnen gaan en hem runnen.

Je kan deze alsnog gewoon toevoegen aan je pad via "Environment Variables"

C:\Program Files\Python313

en

C:\Program Files\Python313\Scripts

[kitao]

Bedankt allebei voor de tips

Ik heb het struikelblok wat ik tegen kwam iets uitgebreider in beeld gebracht. Onderstaande foto toont een APC220 Radio Communicatie Module gekoppeld via RX/TX aan een FT232RL USB to serial UART Interface die dan weer via de rode kabel aan de laptop vast zit.



Dit is de ontvangst zijde en bij mij zit die op Com9 zoals te zien op het scherm. Dat gedeelte gaat dus nog goed maar in datzelfde scherm moet er dan een board gekozen worden maar in de droplijst staan geen APC220 of None als opties vermeld.

Zover ik geprobeerd heb, gebruikmakend van de Serial Monitor in de Arduino IDE, lukte het me niet om tekst in beeld te krijgen dat vanaf de Transmitter (een APC220 aan een Uno met een geluidssensor) verzonden wordt naar de laptop ontvangst zijde. Simpelweg omdat er waarschijnlijk toch een microcontroller persé als board ingesteld moet worden om de IDE in beweging te kunnen krijgen.
Vandaar mijn vraag of dit te omzeilen is?

Wat betreft het path, daar kwam de assistent mee en heeft als voordeel dat er heel snel een PowerShell geopend kan worden en de instructieregel ...

PS C:\Users\sf490> & "C:\Program Files\Python313\python.exe" d:\VSCode_Python_EigenProgs\doorbell_alarm_edit.py

... vanuit een Notepad in de taakbalk met een Ctrl+C en een Ctrl+V meteen draait. Er hoeft dan geen Python software opgestart te worden.

[ Voor 12% gewijzigd door kitao op 11-05-2026 17:59 ]

[Septillion]

@Ruitenwisser Ja, dat kan zeker ook. Maar voor beginner bijna makkelijker om gewoon de laatste Python te installeren

@kitao Gewoon een Uno selecteren. Misschien dat de nieuwere iets anders dan gewoon een standaard COM-poort doen maar zolang je gewoon een simpel board selecteert die een USB-Serial chip gebruikt kan je elke USB-serial module gebruiken die je wilt.

En als je dus Python in je PATH hebt is het simpelweg d:\VSCode_Python_EigenProgs\doorbell_alarm_edit.py of als je al in de juiste map zit is doorbell_alarm_edit.py voldoende Sterker nog, dubbelklikken op de file is al voldoende! Enige is dat als er dan een error in de code zit het scherm gelijk sluit zonder dat je de error kan lezen.

[kitao]

@Septillion

Bedankt, het is na jouw advies inderdaad gelukt om de Arduino IDE Serial Monitor met slechts een APC220 en een FT232RL, zoals getoond in de vorige foto, om deze tekst te laten ontvangen en uit te printen:



Zoals te zien verschijnt er Gong! als tekst dus dat is gelukt. Er zit in bovenstaande opstelling geen Uno aangesloten maar Serial Monitor denkt blijkbaar van wel. Een eventuele volgende stap zou dan kunnen zijn om met de Gong! tekst en met de Serial Monitor, na activering van een sensor, om dan een alarm op de laptop af te laten gaan want dat was de hele opzet.

Vervolgens wat met het path geprobeerd en dat is inmiddels ook gelukt, een .py is nu te executen met een dubbele klik:



Wat constant vast liep was de suggestie van de Copiloot om in PowerShell de instructie 'where python' uit te voeren. Dat gaf geen enkele keer een goede uitkomst dus het werd een diep doolhof om er dan uiteindelijk achter te komen dat de instructie 'where xyz' helemaal niet bestaat op PowerShell
De assistent heeft dat als volgt samengevat:

XML:

.
⭐ 4. The only thing that is “broken” is where

You tested:
where notepad
where cmd
and both returned nothing.

This proves:

❌ PowerShell’s where command is not functioning

✔ PATH is functioning
✔ Python is functioning
✔ Your system is functioning

where is a cmd.exe tool, not a PowerShell tool.

On some systems, PowerShell fails to pass PATH correctly to it.

This is cosmetic — not functional.

You never need where for real work.

⭐ 5. Your system is now in perfect working order

Let’s summarize what you have achieved:

✔ Python runs from any folder
✔ Python is correctly installed
✔ PATH is correctly configured
✔ The Python launcher works
.

.
En ja, het klopt, ik ben nog niet lang geleden pas begonnen met Python maar daarbij opgemerkt dat ik geen enkele programmeertaal probeer te leren. Er zijn namelijk een aantal verschillende boardjes waar ik wat mee bezig ben en dan kom je talen tegen zoals C, Cpp voor Arduino, Vhdl, Verilog, Assembly, PBasic, Linux, TCL en dan nog wat Siemens Logo! en nu dus Python en dat zijn er gewoon teveel om die te leren.
Ik probeer het wel een beetje te kunnen lezen en te begrijpen maar zelf proberen te schrijven begin ik niet meer aan. En in feite is dat ook niet meer nodig want net als een rekenmachine voor mathematica heb je nu een AI voor het programmeren.

Het instellen van een path heeft op zich niet veel met programmeren te maken maar meer met computer systeem instellingen. Dat probeer ik dan wel een beetje te oefenen maar alleen als ik het tegenkom, wat nu dus het geval was en gelukkig is dat dan toch nog goed gekomen. Tnx!
.

[kitao]

Ruitenwisser schreef op maandag 11 mei 2026 @ 14:04:
Je kan deze alsnog gewoon toevoegen aan je pad via "Environment Variables"
C:\Program Files\Python313
en
C:\Program Files\Python313\Scripts

Bedankt dat maakte inderdaad ook deel uit van de oplossing:



Daarna is het ook nog eens aan de User Variables toegevoegd.
Ook dat lukt me echt niet zonder assistent, zit namelijk diep verborgen:

Win+I > System > About > Advanced System Settings > Environment Variables > User Variables > Path > Edit > New > Move Up.
.
@Septillion schreef:
"Als je tijdens de install van Python het vinkje zet bij "Add to PATH" "

Dat is volgens mij ook gedaan bij de installatie van Python313. Tijdens het probleem oplossen kwam ook naar voren dat Windows terug bleef vallen op het path naar de voorheen geinstalleerde Python App maar het voert te ver om die hele copiloot conversatie nog een keer uit te gaan spitten. Bij een eventuele volgende software installatie zal ik er wat meer op letten hoe dat uitpakt, tnx.

Ps3:
Het lijkt erop dat een alarm triggeren met alleen de Arduino IDE niet uitgevoerd kan worden:

XML:

.
⭐ The Arduino IDE Serial Monitor cannot trigger a sound on your laptop

Not on its own.
Not with a setting.
Not with a hidden option.
Not with a plugin.

It is only:
a text viewer
a simple serial terminal
no scripting
no automation
no event hooks
no sound output
no “on message received” actions

So even if it shows:
Gong!
Gong!
…it cannot react to it.

This is a hard limitation of the Arduino IDE.
.

[ Voor 40% gewijzigd door kitao op 12-05-2026 11:29 . Reden: Ps3 ]

[Septillion]

@kitao Ah, ja. Als je Python een update wilt geven kan je beter de oude versie verwijderen. Bij één versie blijven maakt zaken makkelijker.

Qua serial monitor, het board type is bij de meeste absoluut niet van belang. Zolang het bord gewoon als COM-poort in Windows staat maakt het geen fluit uit welke je kiest.

Maar inderdaad, serial monitor is maar een simpele applicatie.

[kitao]

@Septillion

Achteraf gezien vraag ik me nu af waarom ik niet zelf even geprobeerd heb om een 'fop-dummy'-board in te stellen maar goed, het einddoel is met toepassing van Python wel bereikt namelijk dat bij activering van een sensor het signaal daarvan via RF op mijn laptop binnenkomt en een alarm activeert. Volgens de Fun met Electronica leverancier is het bereik maar liefst een kilometer.

418MHz to 455MHz
Zendbereik 1000 meter, open veld, bij 2400bps
Output power 20 mW
https://shop.funmetelectr...nten/apc220-radio-module/

Er staat niet bij welke chip er op het Usb-boardje zit, mogelijk is dat ook weer een CP2102 maar zoals eerder beschreven is Python daar niet blij mee en kan m.i. beter een FT232RL worden gebruikt.
.

[Ruitenwisser]

kitao schreef op dinsdag 12 mei 2026 @ 10:05:
[...]


Bedankt dat maakte inderdaad ook deel uit van de oplossing:

[Afbeelding]

Daarna is het ook nog eens aan de User Variables toegevoegd.
Ook dat lukt me echt niet zonder assistent, zit namelijk diep verborgen:

Win+I > System > About > Advanced System Settings > Environment Variables > User Variables > Path > Edit > New > Move Up.

System variabelen is voor heel je systeem en user variabelen enkel voor je huidige user. Als je het aan de system variabelen hebt toegevoegd, zou je dit in principe niet meer moeten toevoegen aan je user variabelen.

Bij mij komen beide opties te voorschijn bij het zoeken na de Win toets te hebben ingedrukt.



Naar mijn gevoel moet je als beginner niet te veel klooien met Python versies. De 3.14 heeft niets noemenswaardig meer dan 3.13 en eenmaal dat je daar tegenaan gaat lopen zal je toch al bezig zijn met virtuele omgevingen.

[kitao]

@Ruitenwisser

Bedankt voor de tip nogmaals
Wat het installeren en instellen betreft dat doe ik het liefst op de automaat natuurlijk maar er komen momenten dat er handmatig bijgestuurd moet worden of dat nu bij Python, Quartus of Libero of etc. is, soms ontkom je daar gewoon niet aan.

Natuurlijk is er dan de keus om ervan af te blijven want 'ik weet niet precies wat er gaat gebeuren als ik dit knopje indruk' maar dat betekent dan ook vaak dat het gewenste dan niet gaat draaien.

En eigenlijk heb ik wel lastigere installaties doorlopen als bovenstaande, bijvoorbeeld het installeren van een driver voor een Usb-blaster op Windows11.

Toch begrijp ik je advies wel, bijvoorbeeld toen ik dit als suggestie voorgelegd kreeg:

XML:

Fix A — Remove WindowsApps from your User PATH
This is safe.
You don’t need WindowsApps for anything unless you use Microsoft Store apps 
from the command line. 
Steps:
Open Environment Variables
Under User variables for sf490
Select Path
Click Edit
Remove this entry:
%USERPROFILE%\AppData\Local\Microsoft\WindowsApps
Click OK
Restart PowerShell
Then:
where python
will finally show:
C:\Program Files\Python313\python.exe

Dat ging me iets te ver, een heel path afbreken en dan mogelijk erachter komen dat dan andere software pakketten niet meer openen. Dus ja, het gaat ook een beetje op gevoel en soms met geluk.
Gaat het fout dan ben je wel veel tijd kwijt aan het herstellen maar is er toch iets van geleerd.
Minder leuk is als je hele laptop niet meer wil opstarten en onbruikbaar wordt, dat heb ik ook wel eens gehad na een partitie opdeling dus zonder risico is het inderdaad niet.
.

[ Voor 43% gewijzigd door kitao op 12-05-2026 14:53 ]

[Ruitenwisser]

kitao schreef op dinsdag 12 mei 2026 @ 14:33:

Toch begrijp ik je advies wel, bijvoorbeeld toen ik dit als suggestie voorgelegd kreeg:

XML:

Fix A — Remove WindowsApps from your User PATH
This is safe.
You don’t need WindowsApps for anything unless you use Microsoft Store apps 
from the command line. 
Steps:
Open Environment Variables
Under User variables for sf490
Select Path
Click Edit
Remove this entry:
%USERPROFILE%\AppData\Local\Microsoft\WindowsApps
Click OK
Restart PowerShell
Then:
where python
will finally show:
C:\Program Files\Python313\python.exe

Dat ging me iets te ver, een heel path afbreken en dan mogelijk erachter komen dat dan andere software pakketten niet meer openen. Dus ja, het gaat ook een beetje op gevoel en soms met geluk.
Gaat het fout dan ben je wel veel tijd kwijt aan het herstellen maar is er toch iets van geleerd.
Minder leuk is als je hele laptop niet meer wil opstarten en onbruikbaar wordt, dat heb ik ook wel eens gehad na een partitie opdeling dus zonder risico is het inderdaad niet.

Ik wil wel eens weten wat je hem gevraagd had voor die fix te krijgen.

Windows bekijkt je PATH variable in volgorde. Dus als je een exe wilt starten, gaat ie eerst in de eerste directory kijken, daarna de volgende enzovoort tot ie het gevonden heeft. Door je python pad naar boven te verplaatsen kan je maken dat ie python.exe altijd in die ene directory gebruikt.

[kitao]

Ruitenwisser schreef op dinsdag 12 mei 2026 @ 14:20:
System variabelen is voor heel je systeem en user variabelen enkel voor je huidige user. Als je het aan de system variabelen hebt toegevoegd, zou je dit in principe niet meer moeten toevoegen aan je user variabelen.

Ik heb dat nog eens nagevraagd want de assistent was degeen die zulke ingrepen voorstelde bij het proberen de 'where python' commando in werking te krijgen. Terwijl PowerShell dat commando dus helemaal niet kent dus dat was een mooie kluit in het riet.
.

XML:

.
⭐ Why some people say “put it in only one”

This advice comes from Unix/Linux culture, where:
PATH order matters more
duplicate entries can cause confusion
different users have different environments

On Windows, the rules are different:
✔ User PATH overrides System PATH
✔ But duplicates do not break anything
✔ Windows merges both lists internally
✔ The first matching executable wins
So having Python in both lists is not wrong.

⭐ The only time duplicates cause trouble

Duplicates only matter if ...
one entry points to Python 3.13
the other points to Python 3.11 or 3.9
... and Windows picks the wrong one

But in your case:
✔ Both entries point to the same folder
So there is no risk.
.

.
Ik heb het dus zo laten staan en niet meer veranderd, ook omdat deze laptop maar 1 gebruiker heeft.

Om een beetje bij het topic te blijven, hier een leuk projectje met een CPLD MaxII en een Due, beiden op 3.3V nivo. De sketch is op maat gegenereerd door de assistent.
.

C++:

/*  
 *
 *    13-05-26 
 *
 *   MAX II → Arduino Due → 7‑segment display
 *  Pins:
 *    D2  = bit0 (LSB)
 *    D3  = bit1
 *    D4  = bit2
 *    D5  = bit3 (MSB)
 *
 *    D13 = clock output (0.25 Hz)
 *
 *    D6..D12 = segments a..g (common cathode, HIGH = ON)
 */

const uint8_t bitPins[4] = {2, 3, 4, 5};       // LSB → MSB
const uint8_t segPins[7] = {6, 7, 8, 9, 10, 11, 12}; // a..g

// Hexadecimal lookup table for common‑cathode 7‑segment
// bit0=a ... bit6=g
const uint8_t hexTo7Seg[16] = {
  0b00111111, // 0
  0b00000110, // 1
  0b01011011, // 2
  0b01001111, // 3
  0b01100110, // 4
  0b01101101, // 5
  0b01111101, // 6
  0b00000111, // 7
  0b01111111, // 8
  0b01101111, // 9
  0b01110111, // A
  0b01111100, // b
  0b00111001, // C
  0b01011110, // d
  0b01111001, // E
  0b01110001  // F
};

void setup() {
  // Input pins from MAX II
  for (int i = 0; i < 4; i++) {
    pinMode(bitPins[i], INPUT);
  }

  // Output pins to 7‑segment
  for (int i = 0; i < 7; i++) {
    pinMode(segPins[i], OUTPUT);
    digitalWrite(segPins[i], LOW);
  }

  // Clock output
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
}

void loop() {
  // --- Generate 0.25 Hz clock on pin 13 ---
  digitalWrite(13, HIGH);
  delay(2000);     // 2 seconds high
  digitalWrite(13, LOW);
  delay(2000);     // 2 seconds low

  // --- Read 4‑bit value from MAX II ---
  uint8_t value = 0;
  for (int i = 0; i < 4; i++) {
    value |= (digitalRead(bitPins[i]) << i);
  }

  // --- Convert to 7‑segment pattern ---
  uint8_t pattern = hexTo7Seg[value & 0x0F];

  // --- Output to 7‑segment display ---
  for (int i = 0; i < 7; i++) {
    bool on = pattern & (1 << i);
    digitalWrite(segPins[i], on ? HIGH : LOW);
  }
}

.
De Due stuurt een kloksignaal naar de Max, die zet dat om naar een 4-bit counter dat via 4 Ledjes afgetakt wordt naar de Due die in feite een CD4511 vervangt en dat omzet naar een Hex 7-segment.

Hier een voorbeeld van een CD4511 circuit maar dat IC heb ik niet vandaar de Due software versie er van laten maken:



MaxII RTL Viewer, dat geeft schematisch de 'fabric' weer die met Quartus erin geflasht is:



Hardware opstelling:



Bron met video, schema en code voor een CPLD :
http://www.pyroelectro.com/edu/fpga/parallel_hardware/

Zo'n assistent geeft dus aardig wat voordelen, waar ik een paar jaar geleden als niet-programmeur afhankelijk was van kant en klare internet voorbeeld codes kun je die nu gewoon op maat laten genereren.
.

[kitao]

Vandaag een Nano 33 BLE Sense Rev2 uit het doosje gehaald en die blijkt op dat piepkleine boardje meerdere sensors erop te hebben > https://docs.arduino.cc/h...-ble-sense-rev2/#features waaronder een digital microphone (MP34DT06JTR). Om het board uit te proberen heb ik de Gong opstelling van de vorige post als uitgangspunt genomen en wederom de assistent de sketch laten schrijven. Uiteindelijk 4 uur ! later is die dan goed gekomen. Nadeel is namelijk dat als de assistent eenmaal in een verkeerde aftakking zit het erg lastig kan blijken te zijn om weer op het goede padje te komen, maar goed, zelf schrijf ik het niet
.

XML:

🛑  Why it suddenly works
Your board was never defective.
The BLE stack was never broken.
Windows was never the real problem.

The entire issue was caused by this single line:
while (!Serial) {}
That line blocks the sketch forever when USB is not connected.

So BLE never started.
PDM never started.
Your sketch never ran.

Once removed, the board behaves like a proper wireless device.

.
De storing zat dus in de 'single line' die die zelf had geschreven
In de sketch hieronder is het uiteindelijk hersteld, zie setup() regel 31.
.

C++:

#include <PDM.h>
#include <ArduinoBLE.h>

#define LED_PIN LED_BUILTIN

// Custom UUIDs (Windows-safe)
BLEService gongService("12345678-1234-5678-1234-56789abcdef0");
BLEByteCharacteristic gongChar(
  "12345678-1234-5678-1234-56789abcdef1",
  BLERead | BLENotify
);

// Microphone buffer
volatile int16_t sampleBuffer[256];
volatile int samplesRead = 0;

// PDM callback
void onPDMdata() {
  int bytesAvailable = PDM.available();
  PDM.read((int16_t *)sampleBuffer, bytesAvailable);
  samplesRead = bytesAvailable / 2;
}

void setup() {
  delay(1000);  
  
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  Serial.begin(115200);
  // while (!Serial) {}
  delay(200);

  Serial.println("Starting BLE Doorbell Transmitter…");

  // --- BLE SETUP ---
  if (!BLE.begin()) {
    Serial.println("BLE start failed!");
    while (1);
  }

  BLE.setLocalName("NanoDoorbell");
  BLE.setAdvertisedService(gongService);

  gongService.addCharacteristic(gongChar);
  BLE.addService(gongService);

  gongChar.writeValue((byte)0);

  BLE.advertise();
  Serial.println("BLE advertising…");

  // --- MIC SETUP ---
  PDM.onReceive(onPDMdata);
  PDM.setGain(30);
  if (!PDM.begin(1, 16000)) {
    Serial.println("Failed to start PDM!");
    while (1);
  }
}

void loop() {
  BLEDevice central = BLE.central();

  // Always read microphone data
  if (samplesRead > 0) {
    long sum = 0;
    for (int i = 0; i < samplesRead; i++) {
      int16_t s = sampleBuffer[i];
      sum += (long)s * s;
    }

    float rms = sqrt((float)sum / samplesRead);
    samplesRead = 0;

    Serial.println(rms);

    // LED + BLE logic
    if (rms > 300) {
      digitalWrite(LED_PIN, HIGH);
      if (central && central.connected()) {
        gongChar.writeValue((byte)1);
      }
    } else {
      digitalWrite(LED_PIN, LOW);
      if (central && central.connected()) {
        gongChar.writeValue((byte)0);
      }
    }
  }

  // Keep BLE alive
  BLE.poll();
}

.
Net als bij de Uno-APC220 opstelling moet er dan nog een .py bijgemaakt worden en kan de Nano33 draadloos als Gong-detector worden ingezet.
.

Python:

import asyncio
from bleak import BleakClient, BleakScanner
import winsound

SERVICE_UUID = "12345678-1234-5678-1234-56789abcdef0"
CHAR_UUID    = "12345678-1234-5678-1234-56789abcdef1"

# This MUST be at the top level, not inside any function
last_value = 0

async def run():
    print("Scanning for NanoDoorbell…")
    device = await BleakScanner.find_device_by_filter(
        lambda d, ad: d.name and "NanoDoorbell" in d.name
    )

    if not device:
        print("NanoDoorbell not found")
        return

    print(f"Found device: {device.address}")
    async with BleakClient(device) as client:
        print("Connected. Waiting for notifications…")

        def callback(sender, data):
            global last_value
            value = int(data[0])

            # Trigger only on 0 → 1 transition
            if last_value == 0 and value == 1:
                print("🔔 GONG DETECTED!")
                winsound.Beep(2000, 200)
                winsound.Beep(1500, 200)
                winsound.Beep(1000, 200)

            last_value = value

        await client.start_notify(CHAR_UUID, callback)

        while True:
            await asyncio.sleep(1)

asyncio.run(run())

.



.

[kitao]

Om nog even terug te komen op het board zelf, dat is een Arduino Nano 33 BLE Sense Rev.2.
Na een tijdje ermee aan het orienteren te zijn blijkt dat het niet aansluit op de Arduino IoT Cloud:
Nano 33 BLE Sense Rev2 is not supported by Arduino Cloud, and the Cloud Agent is correctly rejecting it.
Het gaat dan over de IoT Cloud, niet over de Cloud Editor (IDE):

Feature
Supported on Nano 33 BLE Sense Rev2?
Cloud Editor (Web Editor)
✔ Yes
Arduino IoT Cloud
❌ No
-------------------------------------------------------------

Dat niet alleen, er is ook een MicroPython online IDE waar dat board ook niet op aansluit:
⭐ 1. The Nano 33 BLE Sense Rev2 does not work with the online MicroPython IDE
For the Nano 33 BLE Sense Rev2, you must use the desktop MicroPython editor

In beide gevallen wordt er geinformeerd dat de Nano ESP32 daar wel op aansluit.
Op het eerste gezicht is dat boardje vrijwel identiek:
https://docs.arduino.cc/hardware/nano-esp32/



Arduino Nano ESP32 | IoT & MicroPython Board
https://www.dfrobot.com/product-2723.html

Toch handig om te weten voordat je zoiets bestelt

**********************************************************************************************************
PS,
Wat niet vermeld staat is dat (bij mij althans) de MicroPython Firmware en soort van image op je board zet die de originele Bootloader uitwist !!

Ik heb een stuk of vijf methoden opgesomd zien worden door de assistent maar geen enkele bood herstel. Uiteindelijk zelf maar wat geprobeerd, namelijk binnen de normale Arduino IDE 2.3.8 het Blink Example pakken en Upload klikken. Vervolgens gaat die dan eerst compileren en op moment dat dit klaar is vlak voor of tegelijk met de Upload Cyclus de onboard Reset knop dubbel klikken.

⭐ Why Arduino doesn’t document this
Because the Nano 33 BLE family has a fragile bootloader, and the docs are… optimistic.
MicroPython overwrites the Arduino runtime, and the IDE uploader is extremely picky about timing.
.

[ Voor 29% gewijzigd door kitao op 20-05-2026 17:20 ]

[kitao]

Na een maand of twee sinds kitao in "[Discussie] Arduino-topic" opnieuw de Uno Q uit de kast gehaald want ik kwam bij toeval een leuk projectje tegen >
https://newbiely.com/tuto...4-digit-7-segment-display

Dit blijkt een hele serie te zijn en hoewel de Uno Q IDE dat App Lab heet al ingebouwde voorbeelden heeft is het toch fijn om te zien dat er op meerdere plekken ondersteuning begint te onstaan. Wie er nog meer weet hoor ik het graag

Na aansluiten werd er een update geinstalleerd en zit App Lab inmiddels op versie 0.8.0



Zoals gezegd in de vorige post zijn de problemen die ik had met de RouterBridge na een update verdwenen en dat is gelukkig nog steeds zo. Het project met het 7Seg Display toont dat aan.

Wel een beetje opletten met spanningsnivo's, Newbiely geeft in het schema en in de tabel aan om het display op de 5V pin van de Uno Q aan te sluiten maar dit is volgens de assistent geen goed plan :

XML:

⭐ So what happens if you power the 74HC595 module at 5 V?

Two problems:

1. Logic mismatch

UNO Q outputs 3.3 V → HC595 expects 3.5 V for HIGH
→ unreliable shifting, flickering, wrong digits

2. Backfeeding risk

If the HC595 outputs go HIGH at 5 V, and the UNO Q pin is LOW or configured as input:
5 V flows into a 3.3 V pin through the protection diode into the MCU’s VDD rail 
potentially damaging the chip
.

De User Manual vind ik wat dit betref niet echt duidelijk :
The UNO Q is equipped with two connector types: the classic UNO-style headers on the top, designed for prototyping and debugging, guaranteeing full compatibility with Arduino UNO Shields

Terwijl het datablad https://docs.arduino.cc/r...ts/ABX00162-datasheet.pdf op pagina 23 het volgende noteert >

JDIGITAL (A2) (JDIGITAL1) / JANALOG (A3) (JANALOG1): 3.3 V GPIO with support for SPI, UART, CAN, PWM, and ADC inputs.
Analog inputs are referenced to VREF+ on the 3.3 V rail. Valid input range is 0 V to VREF+.
Some STM32U585 pads are 5 V-tolerant in digital mode, however when configured as ADC or any analog function (such as A0 through A5), they are not 5 V-tolerant and must not exceed VDD + 0.3 V.
Use external conditioning like a voltage divider or buffer for higher voltages.
For A4/A5 when used as I2C3 (PC1/PC0), use pull-ups to 3.3 V only.
Additionally, ~D3 (PB0) uses a TT-type I/O structure and is 3.6 V-tolerant, it is not 5 V-tolerant in any mode, including digital.

Shields van de Uno Rev3 met IC Atm328P 'zomaar' even op de Uno Q met IC STM32U585 te gaan zetten kan verkeerd gaan uitpakken. Het gehele Uno Q board als 3.3 Volt te beschouwen is voorlopig mijn uitgangspunt en vandaar dat ik de voeding voor het display niet vanaf de 5V pin maar vanaf de 3.3V pin heb afgetakt.



Ps, sinds Newbiely is me nu ook bekend geworden dat Telegram gebruikt kan worden icm de Q en dat was met de Copilot snel opgezet en werkt goed.

XML:

📨 What Telegram is >
Telegram is a messaging app, similar to WhatsApp or Signal, but with one big difference:
It has a built‑in Bot API.
That means you can create automated “robot accounts” that:
send messages
receive commands
react to events
send sensor data
control devices remotely
This is why Telegram is extremely popular in IoT and home‑automation projects.

🤖 Why the UNO Q supports Telegram
Because the UNO Q runs Debian Linux on the MPU side, it can run Python scripts
that use the Telegram Bot API.

.

[ Voor 7% gewijzigd door kitao op 10-06-2026 12:14 . Reden: Ps ]

[kitao]

Handig, zo'n LCD display met I2C serial interface

Vaak zitten die al voorgemonteerd op het LCD maar ze zijn ook los verkrijgbaar waardoor er meer flexibiliteit is, zoals hier >



De copiloot heeft er het volgende programma voor geschreven waar ik het backlight uit heb gezet voor de foto dat anders overbelicht zou worden >

C++:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);  // address may be 0x27 or 0x3F

void setup() {
  lcd.init();
  lcd.backlight();

  lcd.setCursor(0, 0);
  lcd.print("I2C LCD Test");
}

void loop() {
  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.noBacklight(); // uitgezet ivm overbelichting foto

  lcd.print("Row 0: Hello!");

  lcd.setCursor(0, 1);
  lcd.print("Row 1: Testing");

  lcd.setCursor(0, 2);
  lcd.print("Row 2: 20x4 OK");

  lcd.setCursor(0, 3);
  lcd.print("Row 3: I2C Good");

  delay(2000);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Counting...");
  for (int i = 0; i < 20; i++) {
    lcd.setCursor(0, 1);
    lcd.print("i = ");
    lcd.print(i);
    lcd.print("      "); // clear trailing digits
    delay(200);
  }

  lcd.clear();
  lcd.setCursor(0, 2);
  lcd.print("Backlight toggle");
  lcd.noBacklight();
  delay(1000);
  lcd.backlight();
  delay(1000);
}

Hier meer info >
https://arduinogetstarted.com/tutorials/arduino-lcd-20x4
.

[kitao]

Best wel handig zo'n copiloot, je geeft er wat gegevens aan zoals :

Een rond 1.28" TFT , 240RGBx240 ALL, Driver IC : GC9A01, Interface SPI en Nano 33 BLE Sense en vervolgens krijg je de library die er voor nodig is en dat is deze https://github.com/moononournation/Arduino_GFX en de AI genereert er een sketch voor >

C++:

// 02 augustus 2026
// Werkt goed, gebruikt deze library
// https://github.com/moononournation/Arduino_GFX
// Heeft verschillende examples

#include <Arduino_GFX_Library.h>

#define TFT_CS   10
#define TFT_DC   7
#define TFT_RST  8

#define TFT_SCK  13
#define TFT_MOSI 11

Arduino_DataBus *bus = new Arduino_SWSPI(
    TFT_DC, TFT_CS, TFT_SCK, TFT_MOSI, -1
);

Arduino_GFX *gfx = new Arduino_GC9A01(
    bus, TFT_RST, 0, true
);

void setup()
{
  gfx->begin();
  gfx->fillScreen(RGB565_BLACK);

  gfx->setTextColor(RGB565_WHITE);
  gfx->setTextSize(2);
  gfx->setCursor(40, 120);
  gfx->print("Hello Nano 33!");
}

void loop()
{
}

Helaas zijn de examples in de library niet zo geschikt voor de Nano 33 maar heb dat board toch gebruikt vanwege de 3.3V die het als I/O standaard heeft en is er geen level shifter nodig.
Over de Library >
Arduino_GFX is a Arduino graphics library. Currently support GC9A01 round display, GC9106, GC9107, HX8347C, etc.

Copiloot >
The original example is built for ILI9341 + hardware SPI, which is why your screen stays blank.
Your display is GC9A01, and your Nano 33 BLE Sense requires Software SPI unless you explicitly pass the SPI object. So I rewrote the example into a clean, correct, Nano‑33‑BLE‑Sense‑compatible GC9A01 clock.
Below is the full working sketch.

En zodoende is dit voorbeeld (ook geschikt voor ESP en PI) aangepast aan de Nano 33 >
https://github.com/moonon...alogClock/AnalogClock.ino

Dat geeft dit beeld >



Zoeken op dat display geeft resultaat van eigen bodem
https://www.studiopieters.nl/gc9a01/
en gebruikt andere libraries

edit:
Het is toch gelukt het library example op de Nano 33 werkend te krijgen door de driver te veranderen. Deze regel in het example >
Arduino_GFX *gfx = new Arduino_ILI9341(bus, DF_GFX_RST, 0 /* rotation */, false /* IPS */);
veranderen naar >
Arduino_GFX *gfx = new Arduino_GC9A01(bus, DF_GFX_RST, 0 /* rotation */, false /* IPS */);
.

[ Voor 7% gewijzigd door kitao op 02-08-2026 15:12 ]