BeneluxSpoor.net forum
Vraag en antwoord => Elektronica en analoog => Topic gestart door: Ronald Schreuder op 21 July 2025, 09:52:28
-
Goedemorgen,
Ik ben nu op het punt om de verlichting aan te leggen.
Straatlantaarns, en verlichting voor de huisjes en het station.
Nu wil ik de verlichting in de huisjes een beetje slim maken, af en toe een lamp aan, en uit, en dat willekeurig.
Heb zo'n 30 leds voor huisjes en ongeveer 20-30 straatlantaarns (ook led)
Bestaat er een apparaat om dit slim te schakelen? Heb al de 5074 Multi protocol light decoder gevonden, heeft iemand ervaring hiermee? Is best duur om even te 'proberen'
Of zijn er alternatieven? Analoog of digitaal vind ik niet belangrijk.
-
Hoi Ronald,
Dat gaat uitstekend en erg goedkoop met een Arduino nano.
Een sketch om de leds willekeurig aan te laten gaan is zo geschreven, met of zonder AI. Je kun ook (TL) inschakel verschijnselen erbij maken.
1 uitgang kan makkelijk een led aan, bij meerdere wellicht een Mosfet erachter, goedkope printjes op Ali daarvoor.
Voor zover nodig is hulp geen probleem.
-
Je kan ook kijken naar neo pixel leds. Die kan je daisychainen (achter elkaar aansluiten. Elke led is dan individueel bedienbaar. Het zijn RGB leds, dus je kan er ook kleuren mee maken. En de helderheid finetunen ed. Maar het echte warmwitte wat je misschien wilt, zit er dan net niet in.
(https://media.s-bol.com/jBOpV8zrX25z/XRxJ7k/550x412.jpg)
Voor lantaarns zijn ze dan weer minder handig. Dat zou ik dan doen door middel van een transistor printje. Daarmee kan je dan hele groepen leds aan en uit zetten tegelijk.
(https://hobbycomponents.com/2173-large_default/stepper-motor-and-uln2003-driver-board.jpg)
Arduino is wel het meeste flexibel. Ik kan wel een programma uit m'n mouw schudden en dan zet ik boven in iets van een tabel, die jij dan makkelijk zelf kan aanpassen zodat je kan spelen met helderheid, kleurtjes, aan uit tijden etc. Dan zorg ik er ook voor dat je makkelijk met meer leds kan uitbreiden ed.
Je kan ook denken aan een dag nacht simulatie. Als het dan avond wordt, kunnen de lampjes in huizen op verschillende willekeurige tijden aanspringen en dito voor uit. Elke avond zal dan anders zijn dan de voorgaande avond. Maar ik heb ook losse DCC printjes, dan kan je bijvoorbeeld ook denken aan zelf avond of ochtend inschakelen met bijvoorbeeld je multimaus.
Mvg,
Bas
-
Bedankt voor de reacties, ik zou mij moeten verdiepen in een Arduino, is zo'n transistor print daar op aan te sluiten? Kan ik dat kant-en-klaar kopen?
Ik voel er wel wat voor om iets aan te schaffen wat ik later kan uitbreiden.
Ik hou mij aanbevolen voor een programma (dat heet een script toch?) wat ik zelf kan instellen, moet mij alleen heel erg inlezen in die materie.
Wel fantastisch dat ik die hulp hier kan krijgen.
Ik ben best bedreven in elektronica, alleen ben nu 58, en ben echt (nog) niet thuis in die mini computertjes. Maar als het daarmee allemaal mogelijk is wil daar wel meer over weten.
-
In principe kan je alles kant en klaar kopen. En je hoeft niks te solderen. Je bent bij aliexpress het goedkoopste uit, maar ook in NL kan je alles kopen. Ik koop zelf wel eens wat bij hackerstore, maar je hebt nog meer van dat zulks, zoals iPrototype, kiwielectronics etc.
Ik zou zelf een breadboard aanschaffen
(https://hackerstore.nl/Afbeeldingen/29groot.jpg)
Arduino nano (kan je in breadboard prikken). (en denk om een USB mini kabel)
(https://hackerstore.nl/Afbeeldingen/3groot.jpg)
Uln2003 print
(https://hackerstore.nl/Afbeeldingen/94groot.jpg)
en een bunch aan aan breadboard/dupont kabels. male-male en male-female en misschien ook een handje female-female. Altijd handig.
(https://images.beneluxspoor.net/bnls_2025/image-687e0605b0e37.png) (https://images.beneluxspoor.net/bnls_2025/image-687e0605b0e37.png)
Als laatste, als je wilt, kan je nog neopixels kopen. Die hebben ze wel bij hackerstore, maar niet die losse dingen. Die moet je elders bij elkaar googelen.
Met die ULN2003 printjes, kan je overweg met een 12V voeding. Als je 5V neopixel leds gaat gebruiken, moeten die een aparte voeding krijgen. Ik heb me recentelijk ook laten vertellen dat er o.a. ook 12V neopixels bestaan.
Je kan ook wat normale warmtwitte leds kopen en een weerstanden kit met wat waardes.
Mvg,
Bas
-
Wauw, geweldig die info! Ik koop niks in China, maar als het hier te koop is prima. Ik ga er naar kijken.
En hoe krijg ik zo'n script erop? Kan ik dat zelf?
Die neopixels trekken mij niet zo, ik heb al een hoop leds, en mijn voorkeur gaat uit naar warm-witte leds.
Hoeveel kan ik er aansluiten op zo'n transistor print? kan dat dan ook in groepen?
En kan ik meerdere prints aansluiten op een Arduino?
Ik zag op Hackerstore dat deze een stappenmotor kan aansturen, is dat wel correct?
Ik ben super blij met alle hulp!
-
https://www.h0modelspoor.nl/index.php?topic=3396.0
-
Wauw, geweldig die info! Ik koop niks in China, maar als het hier te koop is prima. Ik ga er naar kijken.
Die dealers in NL halen ze ook daar vandaan en verkopen het door voor iets meer.
En hoe krijg ik zo'n script erop? Kan ik dat zelf?
Ik heb hier een beknopte handleiding en wat uitleg over wat het is en hoe je het aan de praat krijg.
https://train-science.com/arduinos-wat-kan-je-ermee/ (https://train-science.com/arduinos-wat-kan-je-ermee/)
Hoeveel kan ik er aansluiten op zo'n transistor print? (http://Hoeveel kan ik er aansluiten op zo'n transistor print?)
Veel, die uln2003 kan uit mijn hoofd iets van 500mA per kanaal (7) en alles te samen iets van 2A.
Met 5mA per led (wat al fors is) kan je 100 leds per kanaal aansluiten. Je kan ze ook nog parallel aansluiten als dat nodig is, maar of je dat nodig ga hebben, betwijfel ik.
Bas
-
vind het leuk dat je hier de winkelier rijk gaat maken en china niet goed genoeg is.Ik denk aan mijn portemonnee en als ik het ginds voor 1 euro kan kopen ga ik hier geen 20 euro betalen voor identiek hetzelfde dat die verkoper ook daar haalt
-
Bas, bedankt voor alle info, ik ga er in duiken!
Kan jij dan tzt zo'n programma schrijven voor mij?
-
vind het leuk dat je hier de winkelier rijk gaat maken en china niet goed genoeg is.Ik denk aan mijn portemonnee en als ik het ginds voor 1 euro kan kopen ga ik hier geen 20 euro betalen voor identiek hetzelfde dat die verkoper ook daar haalt
Prima, ieder zijn ding!
-
Kan jij dan tzt zo'n programma schrijven voor mij?
Sure thing, bro. ik heb 10 pauzes per week op werk ;) Dan kan er wel een tussendoortje tussen
Bas
-
(y)
-
Om het makkelijk te maken zou ik een Arduino nano in een shield plaatsen, zie bijvoorbeeld:
Ik heb dit zojuist gevonden op AliExpress: €4,59 | Mini Nano V3.0 ATmega328P Microcontroller Board voor Arduino CH340 USB Driver 16Mhz Nano V3.0 ATMEGA328P/168P
https://a.aliexpress.com/_EGLHUYQ
Zie het printje met de connectoren eraan.
Een Nano heeft 22 in/uitgangs pinnen. Een aantal heeft pwm om de leds te dimmen.
Voor het uitproberen zou ik inderdaad een breadbord aanschaffen, daar kun je mooi de Nano en leds plus weerstanden inprikken. Pas op, 5V max.
Ik zou met iets van 2-3K per led beginnen op 5 Volt.
Maar begin maar niet met Arduino, te verslavend:)
Ik had ook al hulp aangeboden maar Bas heeft veel meer ervaring ;)
-
Kon het even niet laten, DeepSeek de volgende vraag gesteld:
Schrijf een arduino nano sketch om meerdere leds onafhankelijk van elkaar random in en uit te schakelen met een tabel voor de maximale en minimale waarden.
Reactie: ( niet getest )
// Configuratie
const int numLeds = 3; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {100, 200, 300}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {500, 800, 1000}; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates[i]);
previousTimes[i] = 0;
intervals[i] = random(minTimes[i], maxTimes[i]);
}
}
void loop() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
// Debug output (optioneel)
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates[i] ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
[ / c o d e ]
Uitleg erbij
Hier is een Arduino Nano sketch die meerdere LED's onafhankelijk van elkaar random aan- en uitzet, met een tabel voor de minimale en maximale aan-tijden:
```cpp
// Configuratie
const int numLeds = 3; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {100, 200, 300}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {500, 800, 1000}; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates[i]);
previousTimes[i] = 0;
intervals[i] = random(minTimes[i], maxTimes[i]);
}
}
void loop() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
// Debug output (optioneel)
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates[i] ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
```
### Uitleg:
1. **Configuratie**:
- `numLeds`: Aantal LED's dat je wilt aansturen
- `ledPins[]`: De pinnen waarop de LED's zijn aangesloten
- `minTimes[]` en `maxTimes[]`: Min en max aan-tijden in milliseconden voor elke LED
2. **Werking**:
- Elke LED heeft zijn eigen timing en staat
- Wanneer een LED aan gaat, wordt een nieuwe random tijd tussen min en max gekozen
- Wanneer een LED uit gaat, wordt een kortere tijd gebruikt (hier de helft van de minimale aan-tijd)
3. **Uitbreidingen**:
- Voeg meer LED's toe door `numLeds` en de tabellen aan te passen
- Pas de uit-tijden aan door de berekening `minTimes[i] / 2` te wijzigen
- Voor complexere patronen kun je aparte min/max tabellen voor aan- en uit-tijden maken
### Aansluiting:
Sluit elke LED aan met een weerstand (bijv. 220Ω) tussen de Arduino pin en de lange poot (anode) van de LED. De korte poot (kathode) gaat naar GND.
Let op: De random() functie in Arduino is niet echt random maar pseudo-random. Voor meer random gedrag kun je een random seed toevoegen in setup() met `randomSeed(analogRead(0))` als je een ongebruikte analoge pin hebt.
Het lijkt heel wat maar dat valt reuze mee.
-
Bert, de backticks werken hier niet, we hebben code tags op het forum ::)
[ c o d e ] [ / c o d e ]
// Configuratie
const int numLeds = 3; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {100, 200, 300}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {500, 800, 1000}; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins, OUTPUT);
ledStates = LOW;
digitalWrite(ledPins, ledStates);
previousTimes = 0;
intervals = random(minTimes, maxTimes);
}
}
void loop() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes >= intervals) {
// Schakel de LED
ledStates = !ledStates;
digitalWrite(ledPins, ledStates);
// Update de vorige schakeltijd
previousTimes = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals = random(minTimes, maxTimes);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals = minTimes / 2;
}
// Debug output (optioneel)
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals);
}
}
}
-
Bedankt Bas,
Ken het maar was te lui ::)
edit:
Er zit een fout in de sketch:
Compilation error: incompatible types in assignment of 'int' to 'long unsigned int [3]'
In deze regels:
previousTimes = 0;
intervals = random(minTimes, maxTimes);
Moet even weer nazoeken waarom incompatible, mocht je het zo weten Bas, graag.
Bij toeval ben ik nu bezig met een eigen gebouwd huisje met leds erin, dus kan ik het mooi testen
-
Intervals is een array. Je moet deze indexeren wil je een waarde aan een element toekennen.
M.a..w, intervals vervangen door intervals[ i ]
Komt enkele malen voor in het programma. Ff ook nog nakijken of i de juiste index is op alle plaatsen.
-
Goedemorgen,
Ik ben nu op het punt om de verlichting aan te leggen.
Straatlantaarns, en verlichting voor de huisjes en het station.
Nu wil ik de verlichting in de huisjes een beetje slim maken, af en toe een lamp aan, en uit, en dat willekeurig.
Heb zo'n 30 leds voor huisjes en ongeveer 20-30 straatlantaarns (ook led)
Bestaat er een apparaat om dit slim te schakelen? Heb al de 5074 Multi protocol light decoder gevonden, heeft iemand ervaring hiermee? Is best duur om even te 'proberen'
Of zijn er alternatieven? Analoog of digitaal vind ik niet belangrijk.
Toch maar even terugkomen op de vraag van de TS. Nu de heren verder bakkeleien over het wel en wee van het programmeren van een Arduino, gebruik ik zelf de apparaatjes van Woodland. Hier kan je de Led's makkelijk mee in / uitschakelen, dimmen, ad rondom schakelen. Op beide van mijn modelbanen gebruik ik deze zonder problemen. Geen digitaal gedoe.
Rob
-
Bert, je bent echt overal vergeten om achter te tikken :P. Dit compileert:
// Configuratie
const int numLeds = 3; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {100, 200, 300}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {500, 800, 1000}; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins, OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins, ledStates);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
}
void loop() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins, ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
// Debug output (optioneel)
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
Ik ben zelf echter meer dan de object georienteerde aanpak. Niet altijd, maar voor dit soort dingen vind ik het wel handig. Ik zal eerdaags iets in elkaar sleutelen.
Mvg,
Bas
-
Bedankt Bas en Rob.
Heb zelf overigens niets getypt, is allemaal AI.
-
Ik denk dat ik wat heb.
De bovenste vier regels zijn de enige die je hoeft aan te passen. Hier kan je gebruikte pinnen tussen de accolades {} zetten, en je kan 3 tijden aanpassen.
const int pin[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 } ;
const int MIN_HOUSE_TIME = 5000 ;
const int MAX_HOUSE_TIME = 15000 ;
const int DAY_CHANGE_TIME = 200000 ;
Elke zoveel tijd (dayTimer) klapt 'state' om. Alle pinnen gaan van af dat moment in een willekeurige volgorde om met een willekeurig (instelbare) tijd tot de volgende.
(https://images.beneluxspoor.net/bnls_2025/afbeelding-687eb9e202516.png) (https://images.beneluxspoor.net/bnls_2025/afbeelding-687eb9e202516.png)
De rest van de code ziet er zo uit. Er zijn echter wat meer bestandjes bij betrokken. Dus ik moet een .zip mailen zodat je alles hebt.
Het was wel even een puzzeltje, maar het is gelukt.
#include "light.h"
#include "src/ST.h"
const int nLights = sizeof(pin) / sizeof(pin[0]) ;
Light light[nLights] ;
Timer timer ;
Timer dayTimer ;
void setup()
{
Serial.begin(115200);
for (int i = 0; i < nLights; i++)
{
light[i].begin(pin[i]);
}
timer.set(TIMER_BLEEP, MIN_HOUSE_TIME);
dayTimer.set(TIMER_TOGGLE, DAY_CHANGE_TIME);
randomSeed(analogRead(A7));
}
void loop()
{
timer.update();
dayTimer.update();
if (timer.Q)
{
uint8_t targetState = dayTimer.Q;
// Count how many lights are not yet in the correct state
int mismatches = 0;
for (int i = 0; i < nLights; i++)
{
if (light[i].getState() != targetState) { mismatches ++ ; }
}
// Only toggle if there's something left to update
if (mismatches > 0)
{
bool updated = false;
// Try random indices until one needs to change
while (!updated)
{
int index = random(nLights);
if (light[index].getState() != targetState)
{
light[index].setState(targetState);
updated = true;
timer.PT = random(MIN_HOUSE_TIME, MAX_HOUSE_TIME);
char buf[64] ;
sprintf( buf, "index: %3d, Time to next: %4d, state: %d", (int)index, (int)timer.PT/*/1000*/, (int)targetState ) ;
Serial.println( buf ) ;
}
}
}
}
}
De hoofd aandrijfveer is hier de dayTimer en die staat dan hier op 200s (alle tijden voer je in ms). Je zou die dus ook kunnen vervangen door een schakelaar. Als je dan de schakelaar omzet, dan volgen de lampen 1 voor 1 met willekeur.
Mvg,
Bas
-
Bedankt Bas, Ik moet mij er nog wel in verdiepen, maar vind het leuk dat je zo enthousiast bent en mij wilt helpen.
De rest ook allemaal bedankt voor de bijdragen.
Je kunt mij gewoon een email sturen als je dat wilt.
Gr Ronald
-
Toch maar even terugkomen op de vraag van de TS. Nu de heren verder bakkeleien over het wel en wee van het programmeren van een Arduino, gebruik ik zelf de apparaatjes van Woodland. Hier kan je de Led's makkelijk mee in / uitschakelen, dimmen, ad rondom schakelen. Op beide van mijn modelbanen gebruik ik deze zonder problemen. Geen digitaal gedoe.
Rob
Rob, ik heb even zitten kijken naar dat systeem, ziet er goed uit en is kant-en-klaar, maar wordt dat niet heel duur?
En er zijn 4 uitgangen, maar kun je daar per uitgang ook meerdere ledjes (eigen leds) op aansluiten, weet jij de maximale uitgang-stroom per uitgang?
Anders moet je voor elke 4 leds zo'n ding hebben, dan lopen de kosten aardig op...
-
Beste allen
Misschien heb ik het gemist, maar DE aanpak is toch gewoon gebruik te maken van de MoBaLedLib? Dat is een heel open source ecosystem, waarbij je kant en klare printjes kan kopen en de programmering bijvoorbeeld doet door wat vakjes in een spreadsheet in te vullen.
Ik hou van zelfbouw, maar voor de verlichting van de modelbaan zou ik altijd voor de mobaledlib kiezen. In Nederland is bijvoorbeeld Theo Maassen een actieve ontwikkelaar, en die heeft ook uitstekende printjes ontworpen.
https://wiki.mobaledlib.de/
https://wiki.mobaledlib.de/spezial/user/theo/hauptplatine_tmaa
Groet, Aiko
-
Beste Aiko,
Moba is een prima oplossing, net als een sketch in een Arduino proppen, die van Bas of die van mij ( na ja AI) en ook de Woodland oplossing met elk hun eigen voor en nadelen.
Ten eerste Woodland, verreweg het eenvoudigste te implementeren maar ongetwijfeld ook veruit het duurste, dat alleen houd me al tegen.
Dan Moba, de inleertijd is erg lang lijkt me, zeker voor de spoor liefhebbers zonder al te veel affiniteit met electronica. Daarbij is de Duitse taal ook een drempel, niet voor mij overigens.
Verder zie ik wat betreft open source een nadeel, vaak kan het alles maar wordt daardoor wat onoverzichtelijk. Ik wil hierbij niet generaliseren.
Zelf een sketch in een Arduino laden stelt niet veel voor, daarbij kost een Nano rond de €3 plus nog iets om hem in te steken, en kun je er veel leds onafhankelijk mee aansturen.
Kan me wel voorstellen dat niet iedereen hier zin in heeft / het een te hoge drempel vindt.
Voor mij is het een deel van de hobby om zelf printen te ontwerpen maar alle keuzes hierboven zijn prima, wellicht is er nog meer, ieder zijn ding.
-
Je laat code wel maken door AI, maar Duits vertalen? :P. Daar is AI wel goed in (y).
Die moba dingen, is dat nu alles zelf in elkaar solderen? :-X.
Dat doet me terug denken aan een van mn eerste projecten...
https://forum.beneluxspoor.net/index.php?topic=97216.0 (https://forum.beneluxspoor.net/index.php?topic=97216.0)
Ik heb er ooit een SMD versie van ontworpen maar die heeft nog geen daglicht gezien.
Bas
-
Weet niet hoe serieus ik jouw reactie moet zien Bas.
Duits hoef ik niet te vertalen, spreek en schrijf het als 2e taal.
En dit was mijn eerste AI sketch. Om te laten zien dat het vrij simpel kan zijn.
Veel omvangrijkere sketches heb ik zelf geschreven. Onder andere voor mijn rijdende auto’s
-
Mijn reacties moet je sws niet serieus nemen ::)
-
Alternatieve versie voor UNO, NANO, MEGA en ESP's, Program: MIXLY
Voorbeeld met timers,
Simple timer 1 heeft 1sec on/off ritme.
Simple timer 16 stuurt timers aan tbv verschillende ritmes van timers al dan niet random.
(https://images.beneluxspoor.net/bnls_2025/Schermafbeelding-2025-07-22-115458-687f60b0ee9f6.png) (https://images.beneluxspoor.net/bnls_2025/Schermafbeelding-2025-07-22-115458-687f60b0ee9f6.png)
-
Natuurlijk kan je van alles zelf maken. Ik hoor ook bij die groep.
Als je doel is leuk elektronica te ontwerpen, en de toepassing is bijzaak, dan moet je dat ook gewoon doen. Maar als je doel is lampjes op de modelbaan te schakelen, en de (zelfbouw) elektronica is het middel, dan begin je toch niet van scratch?
Op een gegeven moment wil je lampjes niet alleen schakelen, maar ook dimmen. Als je veel lampjes hebt, dan wordt dat met een Arduino niet triviaal.
Veel handiger is dan gebruik te maken van het WS2811/WS2812 protocol. Dat kan je helemaal zelf programmeren, je kan een bestaande WS2811/2812 library nemen en de rest zelf programmeren of je neemt meteen de MobaLedLib.
Groet, Aiko
-
Nog een alternatief! Bahn Steurung 2000. Op basis van het arduino mega platform, i2c en behoorlijk goedkope standaardhardware - voor honderden leds, en met een volledige webinterface erbij voor alle variaties die je maar wilt, en open source:
https://github.com/0x3b29/Bahnhofs-Steuerung-2000
-
In mijn (AI) sketch zaten nog meer fouten, aantal i tjes toegevoegd.
Als test 11 leds aangesloten, er kunnen er meer op 1 nano, tijden kort gehouden voor de demo.
https://youtu.be/ZknzNEzZbX8 (https://youtu.be/ZknzNEzZbX8)
-
Ik heb een Arduino gekocht en een ULN2003 en ik ben best wel enthousiast. Ook vele filmpjes gezien (oa van Bas) en daar al veel van opgestoken.
Volgens mij moet ik volgende kunnen doen, 5 tot 7 outputs gebruiken op de Arduino nano en die aansluiten op de inputs van de ULN2003, dan kan ik per output kanaal 40/50 smd leds parralel aansluiten en elk kanaal verschillend aansturen.
1 kanaal willekeurig aan/uit, 2e ook maar met andere tijden, 3, 4 kanaal constant aan en kanaal 5 aan, maar met fade-in. (straatlantaarns)
Een schemaatje gemaakt.
Bas en Bert, bedankt voor jullie input!
En ik hou mij nog aanbevolen voor een script, maar dan moet ik denk ik precies weten hoeveel leds ik ga gebruiken?
Gr Ronald
(https://images.beneluxspoor.net/bnls_2025/IMG-6473-2-6880e7a98072d.jpg) (https://images.beneluxspoor.net/bnls_2025/IMG-6473-2-6880e7a98072d.jpg)
(https://images.beneluxspoor.net/bnls_2025/IMG-6472-6880e7a980334.jpg) (https://images.beneluxspoor.net/bnls_2025/IMG-6472-6880e7a980334.jpg)
-
Prima opzet met die ULN, gebruik ik ook voor stappenmotoren.
Dit is de sketch waarmee ik de 11 leds aanstuur:
// Configuratie
const int numLeds = 11; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {3000, 3000, 3000,3000, 3000, 3000, 3000, 3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
}
void loop() {
//delay (1000);
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
// Debug output (optioneel)
Serial.print("ledPins ");
Serial.print(ledPins[i]);
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
Het enige wat je moet aanpassen zijn het aantal leds (in jouw geval uitgangen waarmee je de gropen leds aanstuurt)
Het aantal gebruikte uitgangen moet er mee matchen, tevens het aantal min en max times. En uiteraard de gewenste maximale en minimale schakeltijden waartussen de random generator kiest. Wil je voor een uitgang een vaste tijd dan simpelweg min en max voor die uitgang gelijk zetten.
Ik heb er (nog) geen dimbare uitgangen in zitten, dat komt wellicht maar werkt alleen op de PWM uitgangen (3, 5, 6, 9, 10, 11)
Bas zal ook een prima sketch hebben, niet kunnen testen omdat ik niet alle gebruikte bibliotheken kan vinden.
-
De ULN schakelt naar 0V toe. Dwz dat je de kathodes aan de ULN moet verbinden. Over elke led valt ongeveer 1,3V (geel/rood/groen) tot 3.2V, warm wit. Als je dus 5 warmwitte leds in serie schakelt, dan moet je voeding minstens 5 x 3.2V kunnen leveren. En heel belangrijk: er moet een voorschakelweerstand in serie. Anders doen je leds het heel erg goed maar ook heel erg kort.
Je kan ook meerdere parallel groepjes van leds aan 1 ULN pin hangen.
Als je die arduino IDE geinstalleerd heb, kan je beginnen met de blink sketch op de arduino te schieten, kan je vinden onder examples. Dan kan je 1 pin knipperen.
Als je ruzie heb met het uploaden op die nano, dan staat er onder tools bij bootloader 2 versies met 328. Als het niet lukt, moet je de ander pakken.
(https://images.beneluxspoor.net/bnls_2025/image-6880edaa6230f.png) (https://images.beneluxspoor.net/bnls_2025/image-6880edaa6230f.png)
Mvg,
Bas
-
Fijn om te horen dat ik enigszins goed bezig ben. Dat van die voorschakelweerstand is bekend, daar heb ik er genoeg van liggen, in diverse waardes, dus dat komt goed.
Ik zit alleen even met de voeding. Als het volgens bijgaand overzicht doe, welke voeding moet ik dan hebben voor de ULN? want ik moet wel 5/6 kanalen voeden.
Heb nog enkele Meanwell voedingen van 12 en 16 V DC, heb ik daar wat aan?
Bert, ik ga morgen jou sketch erin zetten, moet vanavond werken.
Dimmen is waarschijnlijk niet nodig, ik kan ook een hogere weerstand gebruiken voor een serie van 5 leds.
(https://images.beneluxspoor.net/bnls_2025/IMG-6474-6880f8d565fb3.jpg) (https://images.beneluxspoor.net/bnls_2025/IMG-6474-6880f8d565fb3.jpg)
-
Daar waar je gnd heb, moet de + komen
-
Daar waar je gnd heb, moet de + komen
Ja klopt, had je gezegd. Maar voedt ik de leds apart of via de ULN print? Want daar mag volgens mij max 12 volt op komen?
Ik zit nog een beetje met de spanningen, en waar ik wat moet voeden.
De Nano krijgt voeding via de usb, dat weet ik. Daarna loop ik beetje vast. wil ook geen printjes opblazen
-
De ULN kan maximaal 50 volt hebben, meer dan nodig.
Naast USB kun je de Nano ook met 5 V voeden.
-
Datasheet van de ULN200x serie :
https://www.st.com/resource/en/datasheet/uln2001.pdf (https://www.st.com/resource/en/datasheet/uln2001.pdf)
Jeroen.
-
Dan wordt dit hem?
En die R afhankelijk van hoeveel leds er in serie gaan, want bij 5 warm witte leds x 3.2V in serie heb ik volgens mij geen voorschakelweerstand nodig.
Maar ik ga het morgen even proberen op een breadboard.
(https://images.beneluxspoor.net/bnls_2025/IMG-6475-688117c3342ed.jpg) (https://images.beneluxspoor.net/bnls_2025/IMG-6475-688117c3342ed.jpg)
-
de veel gemaakte fout : geen weerstand nodig.De weerstand dient als stroombeperking en zelfs al bedraagt die bv maar 1 ohm is hij nodig om het leven van de leds te sparen
-
Schema ziet er legit uit. 2 puntjes.
De 16V hoeft niet op de uln2003. Die aansluiting is bedoeld voor inductieve belastingen zoals spoelen of motoren.
Gebruik wel een DC trafo en geen AC.
Mvg,
Bas
-
Buiten de opmerking van Bellejt: denk dat er teveel licht uit komt maar dat ga je zien
-
Ok, duidelijk.
Bert, als het licht te fel is maak ik of de weerstand hoger of zet er een extra led in serie bij.
Bas, duidelijk. Goed dat het zegt. Maar de gnd gebruik ik wel toch? En ik heb DC trafo's
Bellejt, oke komt goed.
Ik ga morgen eerst even iets aansluiten, en kijken of het werkt.
Bas of Bert, kan ik de output voor de straatlantaarns een paar keer laten knipperen om hem dan constant te laten branden?
-
, kan ik de output voor de straatlantaarns een paar keer laten knipperen om hem dan constant te laten branden?
Dat kan ik er wel bij jongen. Weet niet of me dat binnen een paar dagen lukt ivm bezigheden.
Dan wordt het een gescheiden routine van de random leds.
Nog wel een vraag:
Hoe wil je de lamp in- en uitschakelen?
Kan met een simpele schakelaar op een ingang van de Nano maar in plaats daarvan of daarnaast ook met een lichtgevoelige sensor.
-
Geweldig, heeft geen haast. Inschakelen gaat dmv een schakelaar. Evt later te vervangen door een relais/decoder te bedienen vanuit Itrain.
Ronald
-
Komt goed
-
kan ik de output voor de straatlantaarns een paar keer laten knipperen om hem dan constant te laten branden?
Waarom wil je dat? Het is een misverstand dat straatlantaarns met TL knipperen bij het inschakelen. Die armaturen zijn starterloos, er zitten zelfstartende buizen in en die knipperen niet.
-
Je hebt vast gelijk Klaas maar voor het leuk is ook een reden ;)
Ronald.
Aansturen kan ook via DCC. Relais zijn wat old school.
Zelf gebruik is een (eigen) at mega ic op een print met connectoren en een DCC ingang.
Namaken is een eitje..
-
Waarom wil je dat? Het is een misverstand dat straatlantaarns met TL knipperen bij het inschakelen. Die armaturen zijn starterloos, er zitten zelfstartende buizen in en die knipperen niet.
Omdat ik dat leuk vind.
Niet knipperen vind ik saai.
-
Je hebt vast gelijk Klaas maar voor het leuk is ook een reden ;)
Ronald.
Aansturen kan ook via DCC. Relais zijn wat old school.
Zelf gebruik is een (eigen) at mega ic op een print met connectoren en een DCC ingang.
Namaken is een eitje..
Ja het wordt waarschijnlijk aansturen via een DCC decoder. Heb nog wel ergens een vrije uitgang. Komt goed.
-
Omdat ik dat leuk vind.
Niet knipperen vind ik saai.
Straatverlichting is ook hartstikke saai. Het gaat aan als de zon onder gaat en weer uit als de zon opkomt, elke dag hetzelfde.
Maar als jij het leuk vindt, lekker laten knipperen.
-
Flikkerende TL verlichting:
https://youtu.be/LAA6AyNP_vk?t=15 (https://youtu.be/LAA6AyNP_vk?t=15)
Ja het wordt waarschijnlijk aansturen via een DCC decoder.
Dat kan, maar ook dan moet je willicht iets van elektronica er aan hangen. Bij een spoeldecoder meestal niet, maar dat kan per decoder verschillen hoe ze werken.
Zelf zou ik een DCC printje nemen. Die hang je ook met 3 draden aan je arduino. Via de arduino IDE library installer, kan je de NMRA DCC library installeren en dan kan de arduino zelf DCC commando's decoderen. Het is niet zo veel code om te kloppen
(https://raw.githubusercontent.com/bask185/Train-Science-DIY/refs/heads/master/PCB_RELEASES/digital%20interface%20boards/DCC/DCC.png)
Mvg,
Bas
-
Blink is gelukt, geen problemen bij de installatie.
Led knippert en kan zelf de tijden of het knipperen wijzigen, leuk!
Nu even leds verzamelen voor mijn huisjes om de boel goed te testen.
-
Mooi Ronald (y)
Heb een begin gemaakt met het inschakel verschijnsel.
-
Kijk maar of je hier wat aan hebt. Ik kan het als subroutine opnemen in de andere sketch
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart
const int pwmPin = 9; // PWM output pin voor Led
const int enablePin = 2; // Enable pin met pull-up, start de sequentie bij schakelen naar 0
// parameters
const int minBrightness = 60; // minimale helderheid
const int maxBrightness = 255; // maximale helderheid
const int warmupDuration = 5000; // flikkertijd
const int fullBrightnessPause = 3000; // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000; // na flikkeleren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max
// Status variabelen
enum LightState { OFF, FLICKER, HALF, FADE_UP, PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;
void setup() {
pinMode(pwmPin, OUTPUT);
pinMode(enablePin, INPUT_PULLUP);
analogWrite(pwmPin, 0);
randomSeed(analogRead(5));
}
void loop() {
unsigned long currentTime = millis();
unsigned long stateTime = currentTime - stateStartTime;
// Schakelaar logica
if (!digitalRead(enablePin) && !isEnabled) {
isEnabled = true;
currentState = FLICKER;
stateStartTime = currentTime;
} else if (digitalRead(enablePin) && isEnabled) {
isEnabled = false;
currentState = OFF;
analogWrite(pwmPin, 0);
}
if (!isEnabled) return;
// State machine voor laslicht gedrag
switch (currentState) {
case FLICKER:
if (stateTime < warmupDuration) {
// *** fase
currentBrightness = random(minBrightness, maxBrightness * 0.7);
analogWrite(pwmPin, currentBrightness);
delay(50);
} else {
currentState = HALF;
stateStartTime = currentTime;
currentBrightness = maxBrightness / 2;
analogWrite(pwmPin, currentBrightness);
}
break;
case HALF:
if (stateTime >= 1000) {
currentState = FADE_UP;
stateStartTime = currentTime;
}
break;
case FADE_UP:
{
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPin, currentBrightness);
if (progress >= 1.0) {
currentState = PAUSE;
stateStartTime = currentTime;
}
break;
}
case PAUSE:
if (stateTime >= fullBrightnessPause) {
// Herstart de hele sequentie
currentState = FLICKER;
stateStartTime = currentTime;
}
break;
}
}
-
Ik ga er naar kijken, bedankt!
-
laatste post even weer gewist, moet nog even wat corrigeren.
Net gedaan, ik had een verkeerde code. gekopieerd.
Hieronder de combinatie van beide, de random Leds en de Led met inschakelverschijnsel.
In regel 57 en 58 kun je 1 of beide subroutines uitschakelen met // vooraan.
Nog een correctie, ik zag net dat de random Leds allemaal aanblijven indien je de subroutine disabled, de volgende code aangepast:
was: // digitalWrite(ledPins, ledStates);
nu: digitalWrite(ledPins, LOW);
Pas op dat poorten 2 en 9 gereserveerd zijn voor de Led met inschakelverschijnsel.
// next lines for randomLeds
// Configuratie
const int numLeds = 5; // Aantal LED's
const int ledPins[numLeds] = { 3, 4, 5, 6, 7 }; // Pinnen waar de LED's op aangesloten zijn, pins 2 & 9 reserved for LedFlash
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 1000, 1000, 1000, 1000, 1000 }; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 3000, 3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
// next lines for ledFlash
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart
const int pwmPin = 9; // PWM output pin voor Led
const int enablePin = 2; // Enable pin met pull-up, start de sequentie bij schakelen naar 0
// parameters
const int minBrightness = 60; // minimale helderheid
const int maxBrightness = 255; // maximale helderheid
const int warmupDuration = 5000; // flikkertijd
const int fullBrightnessPause = 3000; // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000; // na flikkeren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max
// Status variabelen
enum LightState { OFF,
FLICKER,
HALF,
FADE_UP,
PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;
void setup() {
Serial.begin(9600);
// next lines for randomLeds
// Stel alle LED-pinnen in als OUTPUT
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
// digitalWrite(ledPins[i], ledStates);
digitalWrite(ledPins[i], LOW);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
// next lines for ledFlash
pinMode(pwmPin, OUTPUT);
pinMode(enablePin, INPUT_PULLUP);
analogWrite(pwmPin, 0);
}
void loop() {
randomLeds(); // switch random leds on and off, put // in front of line to switch off
ledFlash(); // switch led on with flikkering effect, put // in front of line to switch off
}
void randomLeds() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
// Debug output (optioneel)
Serial.print("ledPins ");
Serial.print(ledPins[i]);
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
void ledFlash() {
unsigned long currentTime = millis();
unsigned long stateTime = currentTime - stateStartTime;
// Schakelaar logica
if (!digitalRead(enablePin) && !isEnabled) {
isEnabled = true;
currentState = FLICKER;
stateStartTime = currentTime;
} else if (digitalRead(enablePin) && isEnabled) {
isEnabled = false;
currentState = OFF;
analogWrite(pwmPin, 0);
}
if (!isEnabled) return;
// State machine voor laslicht gedrag
switch (currentState) {
case FLICKER:
if (stateTime < warmupDuration) {
// *** fase
currentBrightness = random(minBrightness, maxBrightness * 0.7);
analogWrite(pwmPin, currentBrightness);
delay(50);
} else {
currentState = HALF;
stateStartTime = currentTime;
currentBrightness = maxBrightness / 2;
analogWrite(pwmPin, currentBrightness);
}
break;
case HALF:
if (stateTime >= 1000) {
currentState = FADE_UP;
stateStartTime = currentTime;
}
break;
case FADE_UP:
{
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPin, currentBrightness);
if (progress >= 1.0) {
currentState = PAUSE;
stateStartTime = currentTime;
}
break;
}
case PAUSE:
if (stateTime >= fullBrightnessPause) {
// Herstart de hele sequentie
currentState = FLICKER;
stateStartTime = currentTime;
}
break;
}
}
-
Goedemorgen Bert,
Ben vanmorgen met je eerste sketch bezig geweest, voor de lantaarns.
Leuk, leuk, nog leuker!
Het werkt goed, heb 4 lantaarns in serie aangesloten op 12 V, en dat gaat goed! Beetje knipperen, beetje faden en dan vol aan, perfect!
Ik kan geen video uploaden, maar ben heel tevreden.
Alleen de herhaling mag eruit, als ik opstart kan hij gewoon aanblijven totdat de 'enablepin' wordt uitgezet. Dat doe ik dan met een on/off contact op een schakeldecoder.
Ik vindt dit zo leuk, wist niet dat dit allemaal mogelijk was, en met heel weinig middelen. nu nog dieper induiken op het zelf programmeren, want ik heb nog veel meer ideeën! (ophaalbrug met brugseinen en stappenmotor) Dat gaat allemaal goed komen.
Ik moet zo werken, late dienst, maar ga morgen of overmorgen verder met de tweede sketch, om het totaal te testen, maar ben nu al heel erg tevreden.
Bedankt (Bas ook) dat jullie mij hiermee zo goed helpen.
-
Graag gedaan, leuk dat het inspireert.
De herhaling haal ik er vanavond of morgen voor je uit.
-
Hierbij de aangepaste sketch.
Nog even over nagedacht, om de loop er helemaal uit te laten lijkt me voor testdoeleinden niet handig maar je kunt best van mening verschillen.
Ik heb een flag toegevoegd die je zelf op 0 (geen loop) of 1 (wel loop) kunt zetten.
Zie regel 18:
const int enableLoop = 1; // enables the restart, set to 1 to enable loop, 0 to disable loop.
// next lines for randomLeds
// Configuratie
const int numLeds = 5; // Aantal LED's
const int ledPins[numLeds] = { 3, 4, 5, 6, 7 }; // Pinnen waar de LED's op aangesloten zijn, pins 2 & 9 reserved for LedFlash
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 10000, 20000, 30000, 40000, 50000 }; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 20000, 40000, 60000, 80000, 100000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
// next lines for ledFlash
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart (depending on enable loop)
const int pwmPin = 9; // PWM output pin voor Led
const int enablePin = 2; // Enable pin met pull-up, start de sequentie bij schakelen naar 0
const int enableLoop = 1; // enables the restart, set to 1 to enable loop, 0 to disable loop
// parameters
const int minBrightness = 10; // minimale helderheid
const int maxBrightness = 255; // maximale helderheid
const int warmupDuration = 5000; // flikkertijd
const int fullBrightnessPause = 3000; // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000; // na flikkeren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max
// Status variabelen
enum LightState { OFF,
FLICKER,
HALF,
FADE_UP,
PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;
void setup() {
Serial.begin(9600);
// next lines for randomLeds
// Stel alle LED-pinnen in als OUTPUT
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
// digitalWrite(ledPins[i], ledStates);
digitalWrite(ledPins[i], LOW);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
// next lines for ledFlash
pinMode(pwmPin, OUTPUT);
pinMode(enablePin, INPUT_PULLUP);
analogWrite(pwmPin, 0);
}
void loop() {
randomLeds(); // switch random leds on and off, put // in front of line to switch off
ledFlash(); // switch led on with flikkering effect, put // in front of line to switch off
}
void randomLeds() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
digitalWrite(ledPins[i], ledStates[i]); // write current Ledstate
ledStates[i] = !ledStates[i]; // change Ledstate
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
// intervals[i] = minTimes[i] / 2;
intervals[i] = minTimes[i];
}
// Debug output (optioneel)
Serial.print("ledPins ");
Serial.print(ledPins[i]);
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
void ledFlash() {
unsigned long currentTime = millis();
unsigned long stateTime = currentTime - stateStartTime;
// Schakelaar logica
if (!digitalRead(enablePin) && !isEnabled) {
isEnabled = true;
currentState = FLICKER;
stateStartTime = currentTime;
} else if (digitalRead(enablePin) && isEnabled) {
isEnabled = false;
currentState = OFF;
analogWrite(pwmPin, 0);
}
if (!isEnabled) return;
// State machine voor laslicht gedrag
switch (currentState) {
case FLICKER:
if (stateTime < warmupDuration) {
// *** fase
// currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
currentBrightness = random(minBrightness, maxBrightness);
analogWrite(pwmPin, currentBrightness);
delay(50);
} else {
currentState = HALF;
stateStartTime = currentTime;
currentBrightness = maxBrightness / 2;
analogWrite(pwmPin, currentBrightness);
}
break;
case HALF:
if (stateTime >= 1000) {
currentState = FADE_UP;
stateStartTime = currentTime;
}
break;
case FADE_UP:
{
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPin, currentBrightness);
if (progress >= 1.0) {
currentState = PAUSE;
stateStartTime = currentTime;
}
break;
}
case PAUSE:
if (stateTime >= fullBrightnessPause & enableLoop == 1) {
// Herstart de hele sequentie
currentState = FLICKER;
stateStartTime = currentTime;
}
break;
}
}
Uiteraard kun je ook de loop in zijn geheeld inactief maken of verwijderen.
Dat zijn deze regels:
case PAUSE:
// if (stateTime >= fullBrightnessPause & enableLoop == 1) {
// // Herstart de hele sequentie
// currentState = FLICKER;
// stateStartTime = currentTime;
// }
// break;
Er was nog iets wat mij niet zinde. Bij opstarten gaan alle random leds meteen aan, ik heb zelf liever dat de uitgangspositie allemaal uit is.
Dit heb ik gedaan door de volgende regels met elkaar te wisselen. Naar wens kun je dat terug draaien:
digitalWrite(ledPins, ledStates); // write current Ledstate
ledStates = !ledStates; // change Ledstate
-
Nu ik toch bezig ben, ik had nog een delay in de sketch staan, vaak niet zo'n probleem, maar ben er toch wat allergisch voor indien er meerdere processen tegelijk lopen.
Het delay vervangen door millis.
Hierbij de recente sketch, het deel met de // ervoor kun je wissen. Regel 119 ™ 133.
// next lines for randomLeds
// Configuratie
const int numLeds = 5; // Aantal LED's
const int ledPins[numLeds] = { 3, 4, 5, 6, 7 }; // Pinnen waar de LED's op aangesloten zijn, pins 2 & 9 reserved for LedFlash
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 10000, 20000, 30000, 40000, 50000 }; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 20000, 40000, 60000, 80000, 100000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
unsigned long lastFlickerTime; // vertraging in FlickterTime
bool ledStates[numLeds]; // Huidige staat van elke LED
// next lines for ledFlash
// Flikkeren -> Halve helderheid -> Fade-up -> Pauze -> Herstart (depending on enable loop)
const int pwmPin = 9; // PWM output pin voor Led
const int enablePin = 2; // Enable pin met pull-up, start de sequentie bij schakelen naar 0
const int enableLoop = 1; // enables the restart, set to 1 to enable loop, 0 to disable loop
// parameters
const int minBrightness = 10; // minimale helderheid
const int maxBrightness = 255; // maximale helderheid
const int warmupDuration = 5000; // flikkertijd
const int fullBrightnessPause = 3000; // Na flikkeren en fade up start de sequentie na de ingesteld tijd opnieuw
int fadeDuration = 5000; // na flikkeren start de Led op 50% helderheid en gaat in de ingeschakelde tijd naar max
// Status variabelen
enum LightState { OFF,
FLICKER,
HALF,
FADE_UP,
PAUSE };
LightState currentState = OFF;
unsigned long stateStartTime;
int currentBrightness = 0;
bool isEnabled = false;
void setup() {
Serial.begin(9600);
// next lines for randomLeds
// Stel alle LED-pinnen in als OUTPUT
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
// digitalWrite(ledPins[i], ledStates);
digitalWrite(ledPins[i], LOW);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
// next lines for ledFlash
pinMode(pwmPin, OUTPUT);
pinMode(enablePin, INPUT_PULLUP);
analogWrite(pwmPin, 0);
}
void loop() {
randomLeds(); // switch random leds on and off, put // in front of line to switch off
ledFlash(); // switch led on with flikkering effect, put // in front of line to switch off
}
void randomLeds() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
digitalWrite(ledPins[i], ledStates[i]); // write current Ledstate
ledStates[i] = !ledStates[i]; // change Ledstate
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
// intervals[i] = minTimes[i] / 2;
intervals[i] = minTimes[i];
}
// Debug output (optioneel)
Serial.print("ledPins ");
Serial.print(ledPins[i]);
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
}
}
}
void ledFlash() {
unsigned long currentTime = millis();
unsigned long stateTime = currentTime - stateStartTime;
// Schakelaar logica
if (!digitalRead(enablePin) && !isEnabled) {
isEnabled = true;
currentState = FLICKER;
stateStartTime = currentTime;
} else if (digitalRead(enablePin) && isEnabled) {
isEnabled = false;
currentState = OFF;
analogWrite(pwmPin, 0);
}
if (!isEnabled) return;
// State machine voor laslicht gedrag
// switch (currentState) {
// case FLICKER:
// if (stateTime < warmupDuration) {
// // *** fase
// // currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
// currentBrightness = random(minBrightness, maxBrightness);
// analogWrite(pwmPin, currentBrightness);
// delay(50);
// } else {
// currentState = HALF;
// stateStartTime = currentTime;
// currentBrightness = maxBrightness / 2;
// analogWrite(pwmPin, currentBrightness);
// }
// break;
switch (currentState) {
case FLICKER:
if (stateTime < warmupDuration) {
// *** fase
if (currentTime - lastFlickerTime >= 50) { // Replaces delay(50)
lastFlickerTime = currentTime;
// currentBrightness = random(minBrightness, maxBrightness * 0.7); // origineel
currentBrightness = random(minBrightness, maxBrightness);
analogWrite(pwmPin, currentBrightness);
}
} else {
currentState = HALF;
stateStartTime = currentTime;
currentBrightness = maxBrightness / 2;
analogWrite(pwmPin, currentBrightness);
}
break;
case HALF:
if (stateTime >= 1000) {
currentState = FADE_UP;
stateStartTime = currentTime;
}
break;
case FADE_UP:
{
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPin, currentBrightness);
if (progress >= 1.0) {
currentState = PAUSE;
stateStartTime = currentTime;
}
break;
}
}
}
-
Bert, ik heb de laatste sketch getest, en ik ben uitermate tevreden. Ontzettend bedankt (Bas ook) voor alle moeite en tijd die jullie in mij hebben gestoken.
Ik ga er zeker verder mee, want ik vind het niet alleen leuk, maar ik leer hier ook veel van.
Volgende project is een ophaalbrug besturen, dat doe ik nu nog met een servo (schokkerig) met brugseinen erbij. Ben al aan het kijken voor een stappenmotor.
Nogmaals bedankt!
Gr Ronald
-
Bert, als je nog een keer tijd hebt, zou jij nog 1 ding voor mij willen doen?
De sketch in tweeën splitsen?
Dus 1 sketch met 7 outputs voor random aan/uit
en 1 sketch met 7 outputs voor de straatlantaarns?
Heeft geen haast, en als je er geen zin in hebt ook prima, maar als je wel zin en tijd hebt....
Gr Ronald
-
Geen probleem Ronald, doe ik 1 dezer dagen.
-
Ronald, alvast de eerste voor de random leds, de tijden kun je vast zelf aanpassen?
// Configuratie
const int numLeds = 7; // Aantal LED's
const int ledPins[numLeds] = {2, 3, 4, 5, 6, 7, 8}; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = {1000, 1000, 1000, 1000, 1000, 1000, 1000}; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = {3000, 3000, 3000,3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
}
-
Hoi Bert, ja dat lukt!
Fijn, bedankt!
-
Hier dan de sketch voor de 7 uitgangen, "TL" met inschakel verschijnsel.
Paar opmerkingen:
Led 7 kan niet faden, de Nano's en ook Uno's hebben 6 PWM uitgangen. In de sketch gaat led 7 van 0 naar max en omgekeerd.
Je kunt led 7 verwijderen door het laatste getal in de arrays te verwijderen.
Vervang dan regel 5 door 6, 9 door 10 en 13/14 door 17/18.
// 7 LEDs met flikkeren -> halve helderheid -> fade-up -> pauze -> herstart (afhankelijk van enableLoop)
const int numLeds = 7;
// PWM output pins voor LEDs
const int pwmPins[] = { 3, 5, 6, 9, 10, 11, 13 }; // 7 outputs
//const int pwmPins[] = { 3, 5, 6, 9, 10, 11 }; // 6 outputs
// Enable pins met pull-up, start de sequentie bij schakelen naar GND
const int enablePins[] = { 2, 4, 7, 8, 12, A0, A1 }; // 7 outputs
// const int enablePins[] = { 2, 4, 7, 8, 12, A0, }; // 6 outputs
// Enables de restart voor elke LED (0 = geen loop, 1 = loop) // 7 outputs
const int enableLoop[] = { 1, 1, 1, 1, 1, 1, 1 }; // Loop enabled. Pas aan per LED indien nodig
// const int enableLoop[] = { 0, 0, 0, 0, 0, 0, 0 }; // Loop disabled. Pas aan per LED indien nodig
// Enables de restart voor elke LED (0 = geen loop, 1 = loop) // 6 outputs
// const int enableLoop[] = { 1, 1, 1, 1, 1, 1 }; // Loop enabled. Pas aan per LED indien nodig
// const int enableLoop[] = { 0, 0, 0, 0, 0, 0 }; // Loop disabled. Pas aan per LED indien nodig
// Parameters voor alle LEDs (kan per LED verschillend gemaakt worden)
const int minBrightness = 10; // minimale helderheid
const int maxBrightness = 255; // maximale helderheid
const int warmupDuration = 5000; // flikkertijd
const int fullBrightnessPause = 3000; // Pauze na fade-up
const int fadeDuration = 5000; // duur van fade-up
// Status variabelen per LED
enum LightState { OFF,
FLICKER,
HALF,
FADE_UP,
PAUSE };
LightState currentState[numLeds] = { OFF };
unsigned long stateStartTime[numLeds];
unsigned long lastFlickerTime[numLeds];
int currentBrightness[numLeds] = { 0 };
bool isEnabled[numLeds] = { false };
void setup() {
Serial.begin(9600);
// Initialiseer alle pins
for (int i = 0; i < numLeds; i++) {
pinMode(pwmPins[i], OUTPUT);
pinMode(enablePins[i], INPUT_PULLUP);
analogWrite(pwmPins[i], 0);
}
}
void loop() {
for (int i = 0; i < numLeds; i++) {
ledFlash(i); // Verwerk elke LED afzonderlijk
}
}
void ledFlash(int ledIndex) {
unsigned long currentTime = millis();
unsigned long stateTime = currentTime - stateStartTime[ledIndex];
// Schakelaar logica
if (!digitalRead(enablePins[ledIndex]) && !isEnabled[ledIndex]) {
isEnabled[ledIndex] = true;
currentState[ledIndex] = FLICKER;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" geactiveerd");
} else {
if (digitalRead(enablePins[ledIndex])) {
isEnabled[ledIndex] = false;
currentState[ledIndex] = OFF;
analogWrite(pwmPins[ledIndex], 0);
}
}
if (!isEnabled[ledIndex]) return;
switch (currentState[ledIndex]) {
case FLICKER:
if (stateTime < warmupDuration) {
// *** fase
if (currentTime - lastFlickerTime[ledIndex] >= 50) {
lastFlickerTime[ledIndex] = currentTime;
currentBrightness[ledIndex] = random(minBrightness, maxBrightness);
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
}
} else {
currentState[ledIndex] = HALF;
stateStartTime[ledIndex] = currentTime;
currentBrightness[ledIndex] = maxBrightness / 2;
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" halve helderheid");
}
break;
case HALF:
if (stateTime >= 1000) {
currentState[ledIndex] = FADE_UP;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" start fade-up");
}
break;
case FADE_UP:
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness[ledIndex] = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
if (progress >= 1.0) {
currentState[ledIndex] = PAUSE;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" volle helderheid bereikt");
}
break;
case PAUSE:
if (stateTime >= fullBrightnessPause && enableLoop[ledIndex] == 1) {
// Herstart de hele sequentie
currentState[ledIndex] = FLICKER;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" herstart sequentie");
}
break;
}
}
-
Geweldig Bert, dank je wel.
1 opmerking, het gedeelte met
void randomLeds() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
digitalWrite(ledPins[i], ledStates[i]); // write current Ledstate
ledStates[i] = !ledStates[i]; // change Ledstate
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
// intervals[i] = minTimes[i] / 2;
intervals[i] = minTimes[i];
}
// Debug output (optioneel)
Serial.print("ledPins ");
Serial.print(ledPins[i]);
Serial.print("LED ");
Serial.print(i);
Serial.print(": ");
Serial.print(ledStates ? "AAN" : "UIT");
Serial.print(", Volgende schakeling in: ");
Serial.println(intervals[i]);
Zit er niet bij (eerste sketch) is dit bewust?
Heb hem nog niet geprobeerd ivm werk, paar late diensten achter elkaar en verder druk.
Het verder aanpassen gaat prima lukken.
Nogmaals ontzettend bedankt
-
Ik begrijp niet precies met “ zat er niet bij” wat precies.
Kan best zijn dat ik niet consequent ben geweest. Het deel onder debug kan weg als je wilt.
Mochten er nog aanpassingen gewenst zijn, je weet me te vinden ;)
-
Het gedeelte voor de random leds in het gesplitste gedeelte is anders dan het gedeelte voor de random leds in de sketch voor beide toepassingen (random + lantaarns)
Het stuk wat begint met
void randomLeds()
zit er niet in, of is dit niet meer nodig?
Deze regel in de lantaarns - sketch is ook anders,
int enablePins[] = { 2, 4, 7, 8, 12, A0, A1 }; // 7
Kan ik willekeurig welke pin met 'gnd' verbinden of moet ik voor elke uitgang een pin verbinden?
Als het kan zou ik het liefst 1 pin verbinden om elk kanaal (6 of 7) allemaal tegelijk te activeren
-
Void randomleds is een subroutine.
Dat is overzichtelijk indien er meer sub programma’s staan in 1 sketch.
Nu staat het onder de void loop, en getest, dus zou ok moeten zijn.
Indien je wat tegenkomt hoor ik het vast.
Edit:
Wat betreft programmeren ben ik een hobbyist, dus het kan vast allemaal beter, als het werkt, is het ok denk ik dan maar.
Eerlijk gezegd heb ik dit ook voor mezelf in elkaar gedraaid 8)
-
Ah, je antwoord kwam terwijl ik aan het typen was. Perfect, ik ga het morgen of donderdag testen en dan hoor je het wel.
Ben heel blij met je hoor, en ik vind je een prima hobbyist.
-
Hoi Bert, de lantaarns werken perfect! Dank.
De random leds niet, krijg een compilation error;
C:\Users\HP\AppData\Local\Temp\ccFR0VBn.ltrans0.ltrans.o: In function `main':
C:\Users\HP\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/main.cpp:46: undefined reference to `loop'
collect2.exe: error: ld returned 1 exit status
exit status 1
Compilation error: exit status 1
Misschien wil je hier nog eens naar kijken als je tijd hebt
-
Vreemd maar ga ik doen.
Meteen led 7 eruit?
-
Graag, rustig aan.
En kan je ook instellen dat ik schakel met 1 pin ipv alle uitgangen apart?
Bedankt voor de moeite.
-
Af=af ;)
Met 1 ingang alle 6 tegelijk schakelen kan ook.
Wil je dat voor vast of als keuze?
-
Vast alsjeblieft, ik schakel dan een x aantal lampen met 1 nano, via een decoder. en ik schakel een x aantal lantaarns ook via een nano. Dus ik ga 4 of 5 secties schakelen, elk met een nano.
-
Denk te weten waarom je een compilatie fout kreeg, indien je in een array het aantal inputs wijzigt moet ook het aantal aanwezige getallen in de array veranderd worden, dat had ik niet gemeld.
Kom erop terug.
-
Het duurde even, er zat nog een fout in, indien de enable pin naar 0 gaat hoort het zo te zijn dat de leds eerst gaan flikkeren en niet meteen aan gaan, dat gebeurde soms wel, soms niet. Dat lijkt nu gerepareerd.
En je hebt nu 1 enable pin voor de 6 uitgangen.
De serial print commando's kun je naar wens allemaal verwijderen.
// 6 LEDs with single enable pin: flicker -> half brightness -> fade-up -> pause -> restart (if loop enabled)
const int numLeds = 6;
// PWM output pins for LEDs
const int pwmPins[] = { 3, 5, 6, 9, 10, 11 }; // 6 outputs
// Single enable pin with pull-up, starts sequence when switched to GND
const int enablePin = 2; // Single enable pin for all LEDs
// Enables restart for each LED (0 = no loop, 1 = loop)
const int enableLoop[] = { 0, 0, 0, 0, 0, 0 }; // Loop disabled. Change per LED if needed
// const int enableLoop[] = { 1, 1, 1, 1, 1, 1 }; // Loop enabled. Change per LED if needed
// Parameters for all LEDs (can be made different per LED)
const int minBrightness = 10; // minimum brightness
const int maxBrightness = 255; // maximum brightness
const int warmupDuration = 5000; // flicker duration
const int fullBrightnessPause = 3000; // Pause after fade-up
const int fadeDuration = 5000; // duration of fade-up
// Status variables per LED
enum LightState { OFF,
FLICKER,
HALF,
FADE_UP,
PAUSE };
LightState currentState[numLeds] = { OFF };
unsigned long stateStartTime[numLeds];
unsigned long lastFlickerTime[numLeds];
int currentBrightness[numLeds] = { 0 };
bool isEnabled = false; // Single enable state for all LEDs
void setup() {
Serial.begin(9600);
// Initialize all pins
for (int i = 0; i < numLeds; i++) {
pinMode(pwmPins[i], OUTPUT);
analogWrite(pwmPins[i], 0);
}
pinMode(enablePin, INPUT_PULLUP);
}
void loop() {
unsigned long currentTime = millis();
// Single enable logic for all LEDs
if (!digitalRead(enablePin) && !isEnabled) {
isEnabled = true;
// Initialize all LEDs to FLICKER state
for (int i = 0; i < numLeds; i++) {
currentState[i] = FLICKER;
stateStartTime[i] = currentTime;
lastFlickerTime[i] = currentTime;
}
Serial.println("All LEDs activated");
} else if (digitalRead(enablePin) && isEnabled) {
isEnabled = false;
// Turn off all LEDs
for (int i = 0; i < numLeds; i++) {
currentState[i] = OFF;
analogWrite(pwmPins[i], 0);
}
}
if (!isEnabled) return;
// Process each LED
for (int i = 0; i < numLeds; i++) {
ledFlash(i, currentTime);
}
}
void ledFlash(int ledIndex, unsigned long currentTime) {
unsigned long stateTime = currentTime - stateStartTime[ledIndex];
switch (currentState[ledIndex]) {
case FLICKER:
if (stateTime < warmupDuration) {
// Flicker phase
if (currentTime - lastFlickerTime[ledIndex] >= 50) {
lastFlickerTime[ledIndex] = currentTime;
currentBrightness[ledIndex] = random(minBrightness, maxBrightness);
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
}
} else {
currentState[ledIndex] = HALF;
stateStartTime[ledIndex] = currentTime;
currentBrightness[ledIndex] = maxBrightness / 2;
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" half brightness");
}
break;
case HALF:
if (stateTime >= 1000) {
currentState[ledIndex] = FADE_UP;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" start fade-up");
}
break;
case FADE_UP:
{
float progress = min(1.0, (float)stateTime / fadeDuration);
currentBrightness[ledIndex] = maxBrightness / 2 + (maxBrightness / 2) * progress;
analogWrite(pwmPins[ledIndex], currentBrightness[ledIndex]);
if (progress >= 1.0) {
currentState[ledIndex] = PAUSE;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" full brightness reached");
}
}
break;
case PAUSE:
if (stateTime >= fullBrightnessPause && enableLoop[ledIndex] == 1) {
// Restart the whole sequence
currentState[ledIndex] = FLICKER;
stateStartTime[ledIndex] = currentTime;
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" restart sequence");
}
break;
case OFF:
// Shouldn't get here when enabled
break;
}
}
-
Perfect Bert, ga morgen testen, dan ben ik vrij.
Alleen die compilatie fout zat in de sketch van de random leds, daar heb je nog niet naar gekeken? Geeft niet, rustig aan.
Gr Ronald
-
Ah, random, kijk ik naar
-
straatlampen werkt perfect!
-
straatlampen werkt perfect!
Fijn te lezen!
Er waren een paar berichten heen en weer gegaan, was de draad wat kwijt maar hier de 7 random Leds. Bij mij werkt het prima, de vorige versie was inderdaad niet ok.
Mocht je nog aanpassingen wensen hoor ik het wel.
// Configuratie
const int numLeds = 7; // Aantal LED's
const int ledPins[numLeds] = { 2, 3, 4, 5, 6, 7, 8 }; // Pinnen waar de LED's op aangesloten zijn
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 1000, 1000, 1000, 1000, 1000, 1000, 1000 }; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 3000, 3000, 3000, 3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates);
previousTimes[i] = 0;
intervals[i] = random(minTimes, maxTimes);
}
}
void loop() {
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
// Hier gebruiken we de helft van de minimale aan-tijd als uit-tijd
intervals[i] = minTimes[i] / 2;
}
}
}
}
-
Bedankt Bert
Kan hier ook een enable pin in?
-
Komt goed
-
Hier is ie:
// Configuratie
const int numLeds = 7; // Aantal LED's
const int ledPins[numLeds] = { 2, 3, 4, 5, 6, 7, 8 }; // Pinnen waar de LED's op aangesloten zijn
const int activationPin = 9; // Activatiepin (0 = active, 1 = disabled)
// Min en max aan-tijden in milliseconden voor elke LED
const unsigned long minTimes[numLeds] = { 1000, 1000, 1000, 1000, 1000, 1000, 1000 }; // Minimale aan-tijd per LED
const unsigned long maxTimes[numLeds] = { 3000, 3000, 3000, 3000, 3000, 3000, 3000 }; // Maximale aan-tijd per LED
// Variabelen voor timing
unsigned long previousTimes[numLeds]; // Laatste keer dat elke LED veranderde
unsigned long intervals[numLeds]; // Huidige interval voor elke LED
bool ledStates[numLeds]; // Huidige staat van elke LED
void setup() {
// Initialiseer seriële communicatie (optioneel voor debugging)
Serial.begin(9600);
// Initialiseer activatiepin als INPUT_PULLUP
pinMode(activationPin, INPUT_PULLUP);
// Initialiseer LED pinnen als OUTPUT
for (int i = 0; i < numLeds; i++) {
pinMode(ledPins[i], OUTPUT);
ledStates[i] = LOW;
digitalWrite(ledPins[i], ledStates[i]);
previousTimes[i] = 0;
intervals[i] = random(minTimes[i], maxTimes[i]);
}
}
void loop() {
// Lees de activatiestatus
bool isActive = (digitalRead(activationPin) == LOW); // 0 = active, 1 = disabled
if (isActive) {
// Systeem is actief - voer normale werking uit
unsigned long currentTime = millis();
for (int i = 0; i < numLeds; i++) {
// Controleer of het tijd is om de LED te schakelen
if (currentTime - previousTimes[i] >= intervals[i]) {
// Schakel de LED
ledStates[i] = !ledStates[i];
digitalWrite(ledPins[i], ledStates[i]);
// Update de vorige schakeltijd
previousTimes[i] = currentTime;
// Bepaal een nieuw random interval voor de volgende schakeling
if (ledStates[i] == HIGH) {
// LED gaat aan - gebruik aan-tijd interval
intervals[i] = random(minTimes[i], maxTimes[i]);
} else {
// LED gaat uit - gebruik een korte uit-tijd (of pas aan-tijd aan)
intervals[i] = minTimes[i] / 2;
}
}
}
} else {
// Systeem is gedeactiveerd - zet alle LEDs uit
for (int i = 0; i < numLeds; i++) {
if (ledStates[i] != LOW) {
ledStates[i] = LOW;
digitalWrite(ledPins[i], LOW);
}
}
}
}
-
Ga hem morgenochtend testen, zit nu op mijn werk.
Fijne avond !
-
Beste Bert,
Getest en ik ben super-blij!
Het is helemaal goed zo, ik ben heel tevreden.
Nogmaals heel erg bedankt voor de moeite die je in mij hebt gestoken.
Ik vind het ook leuk dat ik nieuwe mogelijkheden heb ontdekt met iets waar ik van dacht dat ik dat niet kon. Moet nog veel leren, maar jullie hebben mij wel enthousiast gemaakt.
Fijn weekend alvast!
-
Leuke reactie Ronald, dat heb ik wel eens anders meegemaakt, dank.
We zitten hier op het forum om elkaar te helpen en inspireren (y)
-
Ik was al bezig met een huisje, sterk geïnspireerd op een pand die we onlangs in Bernkastel hadden gezien. Nog niet af maar leuk om de sketch te laten zien.
https://youtu.be/XkrEhkHJQxo (https://youtu.be/XkrEhkHJQxo)
-
Geweldig, goed gedaan!