WP: Mitsubishi Ecodan PUHZ-SHW112YAA, ERSC-VM2C, Procon ┃ PV: 4800Wp, SolarEdge SE5K, 15x JAM60S17/320, ZW 15º ┃ WTW: Zehnder Q600 ┃ SH: Home Assistant, Proxmox, Intel NUC 8i5 Mini

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.
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
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.
uiteraard AMS1117 eraan voor 3.3V.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.
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 ]
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Loopback test van de kabel lukt wel gewoon?
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
:strip_exif()/f/image/26v9U2ja4o6GFipzcYNnst9o.jpg?f=fotoalbum_large)
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) :
:strip_exif()/f/image/9lhMUtC9Y2DlQojDxxpxbpwT.jpg?f=fotoalbum_large)
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.
:no_upscale():strip_icc():strip_exif()/f/image/FoTjaGX8bCQIkv0WN7VWKIxj.jpg?f=user_large)
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.
:strip_exif()/f/image/UuYs6HTretvY5etpbflsvL1h.jpg?f=fotoalbum_large)
:strip_exif()/f/image/vk5S48hZAMTm6cbjbBC2P35o.jpg?f=fotoalbum_large)
:strip_exif()/f/image/vpYwjMygMF8M33kIoSiNdkzb.jpg?f=fotoalbum_large)
:no_upscale():strip_icc():strip_exif()/f/image/xkEqe2nSTM9ZrHHbBsrXKgI8.jpg?f=user_large)
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.
:strip_exif()/f/image/V0TAtneJjpS67c48TZLDzd4z.jpg?f=fotoalbum_large)
En dit wordt dan de Proteus Wizard instelling :
[ Voor 32% gewijzigd door kitao op 20-12-2024 01:18 . Reden: Voortschrijdend inzicht ]
Correctie : Inmiddels lukt het wel om Arduino IDE 2.3.4 op MCS7 te laten draaien.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
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.
:strip_exif()/f/image/EDggPdH5Y9Xz3uNNDzd5XqS9.jpg?f=fotoalbum_large)
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 ]
Correctie 3 :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.
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/
Waar vind ik orginele?
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Kiwi electronics is mijn go-to voor dit soort spul. Tinytronics ook voor andere boards.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?
Kia E-Niro 2019 Executiveline. OTGW/HA Enthousiasteling.
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 wordenDanielson 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?
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.
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
:strip_exif()/f/image/UvZotiHG32Q2OwlhRub4Veds.jpg?f=fotoalbum_large)
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.
:strip_exif()/f/image/4vxZLEOHzjg2anhSmk8bdG2y.png?f=user_large)
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"
:strip_exif()/f/image/S475Qo5exmvUxu51SKbTYo9s.jpg?f=fotoalbum_large)
======================== 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 ]
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
:no_upscale():strip_icc():strip_exif()/f/image/aV3olzrUfdYZpv9529AHFwbW.jpg?f=user_large)
Website voor de software
:strip_exif()/f/image/O0vR4NIUQWOdwxHBP9UsowKk.jpg?f=fotoalbum_large)
:strip_exif()/f/image/PMalY72fazrOo9OZ8JNxeE9v.jpg?f=fotoalbum_large)
https://www.saleae.com/pages/downloads
Wizzard
:no_upscale():strip_icc():strip_exif()/f/image/02abpUXQV9JcRtINk51VmboK.jpg?f=user_large)
Geinstalleerd en in actie - het betreft overigens wel een demo versie, dus metingen opslaan zal wel niet gaan.
:strip_exif()/f/image/ibEYgkPTxncZgDvAkhhS1lcB.jpg?f=fotoalbum_large)
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 ]
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
:strip_exif()/f/image/OU9U69prLiWCqbL4rmr97mcU.jpg?f=fotoalbum_large)
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
:strip_exif()/f/image/53q67ZBHBJPXDhfuwrQ5fnvC.jpg?f=fotoalbum_large)
Op Proteus lukte het uiteindelijk om de sketch, dat overigens in assembly is geschreven, in beeld te krijgen, met een common cathode display.
:strip_exif()/f/image/KA0rvEuiFrhYplQEZQAzP9pq.jpg?f=fotoalbum_large)
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 ]
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
:no_upscale():strip_icc():strip_exif()/f/image/kIMVGl3WU8l31TphEZR9iSWW.jpg?f=user_large)
En voeg de 4 files die Zip- gedownload waren toe
:no_upscale():strip_icc():strip_exif()/f/image/tJmxdg3CgAokYU842NgH8elt.jpg?f=user_large)
Dit compileerde in 1 keer maar helaas de Rfid opstelling werkte niet
In main.c staat het volgende :
1
2
3
4
5
| [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.
:strip_exif()/f/image/kp1KeI1trvlbpayGXxHfZ4Ky.jpg?f=fotoalbum_large)
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.
:strip_exif()/f/image/mxbt4tNOj0HZ3BrbCJSx5cfa.jpg?f=fotoalbum_large)
:strip_exif()/f/image/WjCEiYWZKxDvjvABlJrpY8lJ.jpg?f=fotoalbum_large)
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 ]
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:
:strip_exif()/f/image/8pcNvtkjD53c5kajjWjlap4Z.jpg?f=fotoalbum_large)
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
:strip_exif()/f/image/WtTTfU6ecXAfJ9ruiB0iTEoI.jpg?f=fotoalbum_large)
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
:no_upscale():strip_icc():strip_exif()/f/image/TFapQFKi54qhTksttZEqwM2K.jpg?f=user_large)
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
:strip_exif()/f/image/dAOBzRp5mP4NPb32UGwKqJv3.jpg?f=fotoalbum_large)
.
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 ]
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 hebbenkitao 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?
Direct, nee. Simpele spanningsdeler zou ook voldoen.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 ?
Ja bedankt voor de tip van een spanningsdeler, zoiets als dit denk ik dan aan
:no_upscale():strip_exif()/f/image/qnN4y3W0Xpofuna8Lu1LPRID.webp?f=user_large)
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"
/f/image/MKNDTAqQ5M4IPZGQYMgab500.png?f=fotoalbum_large)
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
:strip_exif()/f/image/eBFWmtHI0SSIOyTzRfJv5WkI.jpg?f=fotoalbum_large)
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 ]
Ja, tnx, dat is inderdaad iets om rekening mee te houden
:strip_exif()/f/image/9RVmtH16LXjqVg7eLD1MTgjR.jpg?f=fotoalbum_large)
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
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.
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?
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 ]
https://www.olimex.com/Pr...-ISO/open-source-hardware_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,
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
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 ]
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. 81vanaalten 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: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.
- 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.
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?
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
:no_upscale():strip_icc():strip_exif()/f/image/cRHCR6KAWTnjjiEy6TumMtDA.jpg?f=user_large)
.
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.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]
.
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!
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.
:no_upscale():strip_icc():strip_exif()/f/image/gFnB4npNu2JhMgONMSVytdpX.jpg?f=user_large)
.
Ah, nee, zo modern ben ik niet.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/
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.
Check: mijn Unifi switches hebben een aantal poorten met PoE, dus die gebruik ik al om een paar apparaten via ethernet te voeden.Inmiddels wat nazoek gedaan via de Copiloot en om PoE mogelijk te maken zou een speciale switch of injector nodig zijn?
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 ]
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 :
1
2
3
4
5
6
7
8
9
| 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:
:strip_exif()/f/image/gpFmSRZFgVNZlzQsTxCxH3Sx.jpg?f=fotoalbum_large)
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:
:strip_exif()/f/image/ql4IydQOcDoe9pyJlO63h20U.jpg?f=fotoalbum_large)
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!
:strip_exif()/f/image/w47sf3ktG7ir3ShN6WUYS3Tl.jpg?f=fotoalbum_large)
https://wokwi.com/
.
[ Voor 26% gewijzigd door kitao op 20-12-2025 12:13 . Reden: Plaatje toegevoegd ]
Aangenomen dat je verwijst naar het stukje segment<>pin vertaling zie ik niet iets herhalends of overbodig - als gezegd: mits onderhouden.
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.
Bedankt voor de tip, ik snap wat je bedoeltSeptillion 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.
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| #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?
:strip_exif()/f/image/yeteI8zmWB5yvSIjDj5ZAE2s.jpg?f=fotoalbum_large)
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.
.
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.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.
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: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.
1
| #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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| 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
"Get somewhat accurate time from router."DjoeC schreef op zondag 21 december 2025 @ 23:19:
code:
1 2 3 4 5void readDS18B20() { // Get somewhat accurate time from router. setup_UDP(); gettime_UDP();
"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.
Dank je voor de toelichting en gezien het toch pittige commentaar van Accretion hieropDjoeC 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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37void 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
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:
:strip_exif()/f/image/q1ELIOUzRAyDdYPCef44cTRU.jpg?f=fotoalbum_large)
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
:no_upscale():strip_icc():strip_exif()/f/image/tFE3UDFjgT4qwDUqYmcAVLbU.jpg?f=user_large)
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 ]
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.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.
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:
1
2
3
4
| // 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:
1
2
3
4
5
6
7
8
9
10
11
| /* 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
Even afronding: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: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.
- 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.
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?
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:
(en ja, er zal vast genoeg aan te verbeteren zijn - maar vooralsnog voldoet dit voor mij)code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96#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(); } }
Dank nogmaals aan iedereen die mee dacht en mij deze richting op stuurde!
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:
:no_upscale():strip_icc():strip_exif()/f/image/ic4R6dsv7WxNmJ8Axa7MDiwW.jpg?f=user_large)
.