BeneluxSpoor.net forum
Vraag en antwoord => Digitaal => Topic gestart door: Wummeke op 19 November 2015, 09:23:47
-
Enige tijd geleden had ik van Tams een aantal Licht computertjes besteld. een voor gaslamp imitatie en een voor woonhuis verlichting. Deze computertjes zijn dan wel klein, maar ook best prijzig. Dat moet goedkoper kunnen ;D Dus maar eens een paar Arduino Nano's besteld via Ebay. Voor nog geen 3 per stuk, dus een stuk goedkoper dan de LC's van Tams :)
Tijdens het wachten had ik deze site gevonden en ik kan niet ontkennen dat ik de code van de beste man gebruikt heb als inspiratie bron: http://www.herberts-n-projekt.de/basteleien-1/belebtes-haus/. Ook de Tams LC-11 (http://tams-online.de/epages/642f1858-c39b-4b7d-af86-f6a1feaca0e4.sf/de_DE/?ObjectPath=/Shops/642f1858-c39b-4b7d-af86-f6a1feaca0e4/Products/53-0211x) heeft als inspiratiebron gediend.
Alleen, het huisje wat ik van verlichting wilde voorzien was er een met een winkel op de begane grond (namelijk deze: Eisenwaren Fischer (https://www.hood.de/img1/xxl/5188/51880489.jpg)). Dus had ik een dag en nacht programma nodig. Ik heb een tijdlijn uitgedacht volgens welke bepaalde LEDjes aan en uit gaan. Dit in tegenstelling tot Herbert van de link hier boven, die eigenlijk gewoon de verschillende kamertjes afwisselend verlicht in een loopje. Om de tijdlijn te doorlopen, heb ik deze timer library gebruikt: http://playground.arduino.cc/Code/Timer.
Dit is mijn code geworden:
#include "Timer.h"
Timer t;
int bovenLED = 6;
int achterLED = 12;
int winkelLED = 11;
byte tvLED = 9;
long knipperStart,knipperEind,knipperDuur;
void setup() {
pinMode(bovenLED, OUTPUT);
pinMode(achterLED, OUTPUT);
pinMode(winkelLED, OUTPUT);
pinMode(tvLED, OUTPUT);
program();
}
void program() {
boven();
//waardes hieronder zijn de starttijden, tijdsduur staan in de functies
t.after(120000,achter);
t.after(240000,winkel);
t.after(780000,achter);
t.after(900000,boven);
t.after(1080000,bovenMetTV);
t.after(1500000,program);
}
void loop() {
t.update();
}
void boven() {
digitalWrite(bovenLED,HIGH);
t.after(180000,bovenUit); //tijd uit
}
void bovenUit() {
digitalWrite(bovenLED,LOW);
}
void achter() {
digitalWrite(achterLED,HIGH);
t.after(180000,achterUit); //tijd uit
}
void achterUit() {
digitalWrite(achterLED,LOW);
}
void winkel() {
digitalWrite(winkelLED,HIGH);
t.after(600000,winkelUit); //tijd uit
}
void winkelUit() {
digitalWrite(winkelLED,LOW);
}
void bovenMetTV() {
digitalWrite(bovenLED,HIGH);
t.after(300000,bovenUit); //tijd uit. Let op, moet inclusief knipperDuur hieronder zijn!
knipperDuur = 180000; //hoe lang staat de TV aan
static byte knipperHelderheid;
knipperStart = millis()+60000; // starttijd van de TV
knipperEind = knipperStart+knipperDuur; // eindtijd TV
while (millis()<knipperEind) {
knipperHelderheid = random(256);
analogWrite(tvLED, knipperHelderheid);
}
digitalWrite(tvLED, LOW);
}
De TV code is voor het overgrote deel overgenomen van het belebtes haus van Herbert. Korte uitleg: Eerst gaat het licht boven aan. Dan het licht achter in het huisje. Daarna het licht in de winkel. Het licht boven en achter gaan een voor een uit. "s' Avonds" Gaat het licht achter aan, en in de winkel uit. Daarna gaat boven het licht weer aan en achter uit en gaat de TV aan. Na enige tijd gaat de TV uit en even later ook het licht boven. En daarna start het programma weer opnieuw.
Voordat ik dit gemaakt had, ben ik aan het stoeien geweest met een programma voor straat verlichting, geïnspireerd door de Tams LC-9 (http://tams-online.de/epages/642f1858-c39b-4b7d-af86-f6a1feaca0e4.sf/de_DE/?ObjectPath=/Shops/642f1858-c39b-4b7d-af86-f6a1feaca0e4/Products/53-0209x). Dit is dus de eerste Arduino code die ik geschreven heb :)
byte leds[] = {3,6,9,10,11};
long randOn;
long randOff;
int fadeAmount=5;
long randLed;
int randBrightness;
int randFrequency;
//variables for timer
unsigned long timeStart;
unsigned long timeEnd;
unsigned long timeNow;
unsigned long duration = 120000;
long randNumber;
void setup() {
for (int led=0;led<sizeof(leds);led++){
pinMode(leds[led], OUTPUT);
}
}
void flashingLight() {
//random flash LED's 5 times
for (int t=0;t<5;t++)//repeate 5 times
{
for (int i=0;i<sizeof(leds);i++) //as long as i is smalled than the number of LED's
{
randOn = random(sizeof(leds)); //pick a random pin
digitalWrite(leds[randOn],HIGH); //put pin on high
delay(30); //wait
randOff = random(sizeof(leds)); // pick a random pin
digitalWrite(leds[randOff],LOW); // put pin on low
delay(30);
}
}
}
void fadeIn() {
for (int i=0;i<sizeof(leds);i++){
digitalWrite(leds[i], LOW); // turn off all pins
}
for (int brightness=0; brightness <= 255; brightness=brightness+fadeAmount)
{ //for as long as brightness is not full
for (int x=0; x<=4; x++){
analogWrite(leds[x], brightness); //loop through all leds to set brightness
}
delay(30);
}
}
void flickeringLight() {
randLed = random(sizeof(leds)); //pick a random pin
randFrequency = random(5, 10); //pick a number of flickerings
for (int x=0;x<randFrequency;x++){
randBrightness = random(50, 255); //pick a brightness level
analogWrite(leds[randLed], randBrightness); //set brightness level to pin
delay(50);
}
digitalWrite(leds[randLed], HIGH); //turn led back on
}
void highMidLow(){
int loopNr = 0;
do{
for (int x=0; x<=4; x++){
int HMLBright = random(120, 255);
analogWrite(leds[x], HMLBright); //set brightness to low level
}
delay(1500);
loopNr++;
}while (loopNr < 10);
}
void fadeOut() {
for (int brightness=255; brightness >= 0; brightness=brightness-fadeAmount)
{ //for as long as brightness is not full
for (int x=0; x<=4; x++){
analogWrite(leds[x], brightness); //loop through all leds to set brightness
}
delay(30);
}
}
void loop() {
flashingLight();
fadeIn();
timeStart = millis();
timeEnd = timeStart+duration;
do{
highMidLow();
randNumber = random(2);
if (randNumber == 1)
{
flickeringLight();
}
timeNow = millis();
} while (timeNow < timeEnd);
fadeOut();
delay(5000);
}
Ook hier heb ik delen van de code geleend van andere projecten, maar zou niet meer weten welke om eerlijk te zijn.
Korte beschrijving: de lampen gaan knipperend aan en worden daarna steeds feller als ze opwarmen. Een maal aan knippert er af en toe een lamp en zijn de lampen ook niet constant even fel. aan het einde van het programma gaan de lampen met een fade out uit.
Ik zal kijken of ik binnenkort nog demo filmpjes kan uploaden van beide programma's.
Ik hoop dat dit topic als inspiratie dient voor anderen om aan de slag te gaan met Arduino's. En ik hoor graag de op of aanmerkingen om mijn code te verbeteren :)
Oh ja, de ideeën die ik nog heb voor de toekomst: beide programma's stuurbaar maken door bijvoorbeeld een druk knop of dmv een relais aangesloten op een Digikeijs DR4018 om via mijn centrale te kunnen schakelen.
-
Leuk dit, ik zat ook aan zoiets te denken als beginproject om een beetje met de Arduino vertrouwd te raken. Ik ga hier zeker het een ander uit overnemen!
-
Hoi Jan Willem,
Leuk gedaan :) Een Arduino heeft inderdaad meer dan genoeg uitgangen om wat verlichting mee aan te sturen. Let wel op dat je max 100mA uit de Arduino kunt halen. Dus wil je echt groepen ledjes aansturen zal je een transistor moeten gebruiken.
Ik hoef je overigens niet te vertellen dat een Pro Mini weer de helft van een Nano kost? ;D
Zoals je misschien al wel gezien hebt ga ik wel vaker over de code van andere heen met opmerkingen. Ook hier is dat geen uitzondering ;D Dit is absoluut geen kritiek op wat je gemaakt hebt en moet vooral gezien worden als tips om van te leren.
Overigens lijkt het me inderdaad mooi als je een trigger van buitenaf kunt geven. Leuk om zelf te kunnen doen en makkelijker om meerdere dingen meer synchroon te houden.
En waarom mag tvLed wel netjes een byte zijn en de rest niet? ;D En om meer ruimte te besparen (okay, misschien nu niet nodig maar handig om jezelf aan te leren) mogen de variabele als const gedeclareerd worden. En als standaard notatie (in ieder geval door een groot deel van de C schrijvers) wordt de variabele naam dan als MijnConstVariabele naam. Waarbij het beginnen met een hoofdletter een indicatie voor jezelf is dat het gaat om een const (dus je hem niet meer kunt aanpassen in het programma).
Zelf nooit met de Timer library gewerkt maar het is simpel genoeg. Maar om tijden voor jezelf makkelijk te houden (het is immers best onhandig dat een minuut 60 seconde is) had je de tijden kunnen noteren als "2 * 60 * 1000UL" ipv 120000. Je ziet dan gelijk dat het gaat om 2 minuten. Let wel op dat iig één van de nummers dan het achtervoegsel UL moet hebben. Anders is de maximale grote van het getal maar een int (+-32000).
Overigens heeft de Timer library een handige functie die je had kunnen gebruiken namelijk .pulseImmediate(). Dan was het niet nodig geweest alle xUit functies te maken. :D
Maar buiten dat, nu werkt het wel met een heel zooitje timers. Maar eigenlijk doe je alleen maar dingen na elkaar. Je hebt nu al continue 6 timers lopen en het maximum is 10. Het was denk ik makkelijker geweest om 1 timer te zetten die steeds de functie volgendeStap aan roept ofzo. Toegegeven, wisselen in de volgorde van de events is dan wat lastiger.
De functie naam program() is iets wat verwarrend. Naam als startTimers() was misschien wat duidelijker geweest. Beter iets langere maar duidelijke naam zodat het makkelijk te begrijpen is wat de functie doet. Niet alleen voor andere maar ook voor jezelf als je voer een jaar dit project weer opent ;)
En dan eigenlijk het gekke deel. Okay, je gebruikt de random functie voor de tv, prima. Maar bedenk wel dat de TV er exact hetzelfde uit ziet iedere keer dat je de Arduino start ;) Voor een TV simulatie denk ik niet zo erg. Maar dan, waarom is de knipperHelderheid een static?
Daarna ga je zelf aan de slag met de timer omdat de Timer library iets lastiger is toe te passen. Maar je gebruikt het op een verkeerde manier die tot bugs kan leiden. Als je de tijd met millis() wilt bijhouden moet dit altijd in de vorm millis() - vorigeMillis() >= interval. Of, iets anders benaamd voor iets zoals nu wat maar één keer moet: millis() - startTijd >= knipperDuur.
Daarna stop je het in een while loopje, okay. Maar bedenk wel dat de Arduino hierdoor niets anders kan doen. Zou je tijdens je tv routine dus nog een lamp aan willen doen kan dat niet. Om dit te overkomen zou je het TV geknipper een functie in de loop kunnen laten zijn. Natuurlijk alleen iets laten doen als je wilt dat de TV aan staat ;)
En dan doe je iedere iteratie van de loop een nieuwe helderheid voor de TV maken. Dat moet een aardig snel knipperende TV opleveren!
Voor straatverlichting beetje zelfde commentaar. Ooit opgevallen dat ondanks dat je random gebruikt toch altijd dezelfde ledjes eerst aan gaan? Het patroon van de Arduino is elke keer 100 hetzelfde ;D
En ook hier laat de je de boel vast komen te zitten in een while loopje (do while eigenlijk). Dus weer valt er niets anders met je Arduino te doen. Aan de rekenkracht ligt het in ieder geval niet ;)
En ook hier heb je een timer bug door niet de goede volgorde van millis() - startMillis >= interval te gebruiken ;)
Goed, al met al lijkt het vooral commentaar maar je moet het echt lezen als goed bedoelt commentaar ;)
Timo
-
Hi Timo,
Onwijs bedankt voor je commentaar! Ik hoopte ook stiekem wel een beetje op feedback van een pro ;)
Ik ga niet alle keuzes verklaren of verdedigen, het meeste komt denk ik door copy/paste uit voorbeelden en dergelijke van het internet. En als het werkt, maak ik me er niet gauw druk om ;) Maar ik ga zeker proberen mijn projecten te verbeteren.
nogmaals bedankt!
Jan Willem
-
Naar aanleiding van vragen van andere heb ik het woonhuis programma eens wat herschreven waardoor er meer timers vrij komen en de boel naar mijn idee wat makkelijker te veranderen is. Een mogelijke toevoeging is bijvoorbeeld een neon bord wat knippert ofzo en af en toe wat storing heeft ofzo. Zo toe te voegen in de loop.
Een groot verschil met de sketch van Jan Willem is dat hij niet volledig op tijd loopt. Ik heb een knop toegevoegd om het opstaan te starten, doorloopt dan de routine van geen licht tot aan alleen licht in de winkel. En een knop om naar bed te gaan, doorloopt de routine van winkel afsluiten, naar boven gaan, tv kijken en slapen waarna opnieuw begonnen kan worden. Ik heb het met twee knopjes gedaan maar eigenlijk zou je net zo goed hier maar één knopje voor kunnen gebruiken.
Ook heb ik het algoritme voor de TV iets aangepast. Allereerst is de for loop weg en is het onderdeel van de loop(). Ook heb ik de random meer random gemaakt door de (niet aangesloten) A0 poort als seed te gebruiken. Hieruit maak ik vervolgens de random helderheid en de random tijd tussen twee tv beelden. De min en max hiervan is instelbaar.
/******************************************************************************
woonhuis_met_winkel v1 - Scene based light program for a huis with store
Created by Timo Engelgeer (Septillion), November 23 2015
With a couple of wake up scenes and a couple of go to bed scenes including a TV.
Controlles 3 sets of lights, LedBoven (upstairs), LedAchter (livingroom/kitchen?) and LedWinkel (the store)
******************************************************************************/
#include "Timer.h"
#include <Bounce2.h>
Timer t; //De timer voor alles
//De aangesloten uitgangen
const byte LedBoven = 6;
const byte LedAchter = 12;
const byte LedWinkel = 11;
const byte LedTv = 9;
//Aangesloten knoppen, aangesloten tussen deze pin en GND
const byte OpstaanPin = 2;
const byte NaarBedPin = 3;
//Knop object voor debounce
Bounce opstaan, naarBed;
byte scene = 0; //Welke scene hebben we nu?
const byte AantalScenes = 11;
//Tv settings
const unsigned int TvInterval[] = {500, 2000}; //minimale en maximale tijd tussen twee verscillende tv helderheden
const byte TvHelderheid[] = {20, 255}; //minimale en maximale tv helderheid
/*** Lisjt met scenes
0 Nacht, we slapen en wachten om wakker te worden gemaakt
1 Worden wakker, licht boven gaat aan
2 Zijn naar beneden gelopen, licht achterhuis ook aan
3 Zijn boven klaar, licht daar uit
4 Tijd om de winkel te openen!
5 Werkdag, we zijn in de winkel, licht achter uit. Nu wachten op naarBed
6 Dag zit erop, licht achter aan
7 Winkel dicht, licht uit
8 Op naa boven, licht daar aan
9 Zijn klaar beneden, licht achter uit
10 We gaan nog even tv kijken boven
11 Tv uit
0 Nacht, licht uit en slapen, wachten om wakker gemaakt te worden
*/
void setup(){
pinMode(LedBoven, OUTPUT);
pinMode(LedAchter, OUTPUT);
pinMode(LedWinkel, OUTPUT);
opstaan.attach(OpstaanPin, INPUT_PULLUP);
naarBed.attach(NaarBedPin, INPUT_PULLUP);
}
void loop(){
t.update(); //zorg dat de timer blijft lopen
//Als het scene 0 is moeten we kijken of we wakker willen worden
if(scene == 0){
opstaan.update();
if(opstaan.fell()){
volgendeScene();
}
}
//Als het scene 5 is moeten we kijken of we naar bed willen gaan
else if(scene == 5){
naarBed.update();
if(naarBed.fell()){
volgendeScene();
}
}
//Als het scene 10 is moeten we de tv updaten
else if(scene == 10){
tvKijken();
}
}
void volgendeScene(){
scene++; //Volgende scene
//Controleren of we nu niet naar een scene te veel gaan, andere terug naar de eerste.
if(scene > AantalScenes){
scene = 0;
}
switch(scene){
case 0:
digitalWrite(LedBoven, LOW);
break;
case 1:
digitalWrite(LedBoven, HIGH);
t.after(2 * 60 * 1000UL, volgendeScene);
break;
case 2:
digitalWrite(LedAchter, HIGH);
t.after(1 * 60 * 1000UL, volgendeScene);
break;
case 3:
digitalWrite(LedBoven, LOW);
t.after(1 * 60 * 1000UL, volgendeScene);
break;
case 4:
digitalWrite(LedWinkel, HIGH);
t.after(1 * 60 * 1000UL, volgendeScene);
break;
case 5:
digitalWrite(LedAchter, LOW);
break;
case 6:
digitalWrite(LedAchter, HIGH);
t.after(1 * 60 * 1000UL, volgendeScene);
break;
case 7:
digitalWrite(LedWinkel, LOW);
t.after(2 * 60 * 1000UL, volgendeScene);
break;
case 8:
digitalWrite(LedBoven, HIGH);
t.after(1 * 60 * 1000UL, volgendeScene);
break;
case 9:
digitalWrite(LedAchter, LOW);
//goed, om de tv zo een beetje random te laten zijn moeten we de random functie voorzien van een random seed.
//We lezen hiervoor de analoge pin 0 voor uit. Hierop zit niets aangesloten en is dus redelijk random
randomSeed(analogRead(A0));
t.after(2 * 60 * 1000UL, volgendeScene);
break;
case 10:
//we gaan hier tv kijken, wordt gedaan in de loop
t.after(3 * 60 * 1000UL, volgendeScene);
break;
case 11:
digitalWrite(LedTv, LOW); //dus hier wel ff de tv uit zetten
t.after(2 * 60 * 1000UL, volgendeScene);
break;
}
}
//
void tvKijken(){
static unsigned int millisVorigeKeer = 0;
static unsigned int knipperTijd = 0;
unsigned int millisNu = millis();
//Tijd om de helderheid van de tv aan te passen?
if(millisNu - millisVorigeKeer >= knipperTijd){
//We doen dit nu dus de tijd nu opslaan voor de volgende keer
millisVorigeKeer = millisNu;
//Nieuwe random helderheid tussen min en max helderheid van TvHelderheid
analogWrite(LedTv, random(TvHelderheid[0], TvHelderheid[1]));
//Nu nog een nieuwe tijd bepalen wanneer de tv de volgende keer moet knipperen. Tijd tussen min en max van TvInterval
knipperTijd = random(TvInterval[0], TvInterval[1]);
}
}
Ik moet wel zeggen, de code is ongetest ;D Hiervoor zou ik aan de slag moeten gaan met een breadboard maar verwacht geen grote problemen.
Timo
-
Zou je het erg vinden om in de comment van case9 even een hard return toe te passen? Je trekt het forum uit proporties.
-
Gedaan. Maar als er een admin mee leest, zou het CSS object "code.bbc_code" aangepast kunnen worden naar "overflow: auto" of "white-space: normal". Dan gaat het gewoon vanzelf goed ;) (Waarbij de eerste er misschien code technisch gezien beter uit ziet omdat de laatste de indents niet bewaard.)
Timo
-
Toevallig, ik wilde vandaag weer met je commentaar aan de slag :)
Een ding wat ik mij vorige week al afvroeg: kan je de waarde 60*1000UL niet in een variabele stoppen? Als je die variabele dan minuten noemt dan wordt het bijvoorbeeld zo:
const int Minuten = 60*1000UL
case 1:
digitalWrite(LedBoven, HIGH);
t.after(2 * Minuten, volgendeScene);
break;
of gaat er dan iets stuk?
-
Nee, er gaat niets stuk. Nouwja, als je tenminste een unsigned long gebruikt voor minuten, anders zit je met hetzelfde probleem ;) Enige nadeel is, dan wordt het getal werkelijk door de Arduino berekend als het het getal ziet. Een serie van instructies op de Arduino dus. (Laad de variable Minuten, laad variabele 2, vermenigvuldig ze.) Als je het op schrijft als "2 * 60 * 1000UL" zal de Arduino IDE het getal al voor je uitrekenen als je upload klikt en gebruikt het resultaat in de code. Zou je de machine code dan bekijken is het maar één instructie namelijk, laad het getal 120.000.
Wat je voor de leesbaarheid wel zou kunnen doen is gebruik maken van een define ofwel macro.
#define MINUTEN *60*100UL
Een define is eigenlijk een grote "zoek en vervang actie" voor er machine code van gemaakt wordt. (Doorzoek de code naar "MINUTEN" en vervang het door "*60*1000UL"). Je kan dan inderdaad gewoon code schrijven als
t.after(2 MINUTEN, volgendeScene);
Timo
-
Toppie posting ik heb die code gebruik van de straat verlichting.
Mijn vraag alleen is hoeveel kan je totaal hier mee schakelen zijn er nu 5 ledjes maar gemiddelde trein baan heeft er wel meer.
Groetjes Harry
-
De uitgang van een Arduino alleen kan niet mega veel schakelen. Per pin max 40mA maar 20mA per pin wordt aangeraden. Ook het totaal mag niet over de 200mA gaan.
Maar je kan de uitgangen altijd versterken met een transistor. Voordeel is dan ook dat je niet gelimiteerd bent tot de 5V van de Arduino. Daarvoor kan je iets als een BC547 (+ base weerstand) uit de rommeldoos pakken en heb je 100mA tot je beschikking. Of als je meer dan één uitgang wilt versterken is de ULN2803 nog altijd een goedkope oplossing. Daarmee heb je gemiddeld 150mA per uitgang (max 500mA per uitgang, max 1,2A voor de chip) tot je beschikking. Wil je nog meer schakelen is het verstandiger naar een mosfet te grijpen. Een goedkope (maar smd) oplossing is dan de IRF7313.
Timo
-
Waarom is de tijdslimiet van 2 minuten ingebouwd.
Ik wil de straatverlichting gaan gebruiken voor mijn perronverlichting.
En dan is dat steeds uitschakelen knap irritant.
grt Piet.
-
Dan zou je je ook nog kunnen afvragen of dat dan wel perse met een Arduino moet, een eenvoudig schakelaartje is toch veel handiger. Piet?
Groetjes
-
Mijn idee. Wat een gedoe om een lampje aan en uit te zetten.
-
@PietB, er is nergens een tijdslimiet van 2 minuten ingesteld. Wel is er een instelbaar tijdschema opgenomen naar het oorsprokelijk idee van Wummeke. Of doel je op de eerdere code van Wummeke? Nu had ik daar ook de nodige opmerkingen over (geen commentaar) maar die heb ik nooit logischer herschreven...
Als je aan geeft wat je er precies van verwacht kan ik er nog een keer naar kijken :) Maar als je inderdaad alleen aan/uit wilt is een schakelaar net zo makkelijk ;D
Timo
-
Ja Klaas en wim, daar hebben julli natuurlijk gelijk.
Maar ik wil meer, een tl-simulatie voor mijn perron verlichting maken.
Ongeveer als dit https://youtu.be/NELnAG5Y2kk
Je ziet hier een arduino micro met de straatverlichting sketch die 4 leds (de perron verlichting) random laten knipperen voordat ze continue gaan branden.
grt Piet.
-
Hoi Piet,
Dat is natuurlijk wel aan te passen. Is dat de code uit de eerste post? Moet namelijk zeggen dat ik het niet heel TL-achtig vindt. De knipper pulsen zijn te lang en TL verlichting fade lang niet zo merkbaar in. Eigenlijk onmerkbaar dus dat zou je zelfs weg kunnen laten. Heb je ook geen PWM kanalen nodig en zou je er zo een 16 kanaals TL aansturing van kunnen maken :) Iets wat er op een perron denk ik nog beter uit ziet.
Timo
-
@PietB, er is nergens een tijdslimiet van 2 minuten ingesteld.
void loop() {
flashingLight();
fadeIn();
timeStart = millis();
timeEnd = timeStart+duration;
do{
highMidLow();
randNumber = random(2);
if (randNumber == 1)
{
flickeringLight();
}
timeNow = millis();
} while (timeNow < timeEnd);
fadeOut();
delay(5000);
}Ik bedoel de duration in de mainloop, die veroorzaakt toch het dimmen en weer opstarten van het geheel?
Als je aan geeft wat je er precies van verwacht kan ik er nog een keer naar kijken :)
Wat ik wil of verwacht is dat als de zaak gestart is , dit blijft doorlopen tot de spanning er afgaat.
Maar als je inderdaad alleen aan/uit wilt is een schakelaar net zo makkelijk ;D
Neen dat hadden onze vrienden uit Zeeland terrecht opgemerkt, maar dat zoek ik niet.
grt Piet.
-
Dat is natuurlijk wel aan te passen. Is dat de code uit de eerste post?
Ja dat is de code uit de éérste post.
Moet namelijk zeggen dat ik het niet heel TL-achtig vindt. De knipper pulsen zijn te lang en TL verlichting fade lang niet zo merkbaar in.
ja die fade in en out is niet mooi en de knipperpulsen zijn aan te passen.
Maar dat opnieuw starten vind ik irritant.
Eigenlijk onmerkbaar dus dat zou je zelfs weg kunnen laten. Heb je ook geen PWM kanalen nodig en zou je er zo een 16 kanaals TL aansturing van kunnen maken :) Iets wat er op een perron denk ik nog beter uit ziet.
Dat is ook een idee.
grt Piet.
-
Dat opnieuw opstarten is makkelijk opgelost. flashingLight() en fadeIn() naar de setup() en alles in de do-while (afgezien van alle timing gedoe) is het enige dat nodig is in loop().
Als je er nog niet uit komt kan ik vanavond of morgen wel even kijken. Maar voor echt mooi TL licht mag er denk ik meer op de schop en is al het dimmen van de uitgangen een beetje overdreven. ;D Denk dat het er al mooier uit ziet als je meer dan 4 kanalen hebt.
Timo
-
Ja Timo,
dat begrijp ik, ga ik morgen mee verder.
grt Piet.
-
Ongeveer als dit https://youtu.be/NELnAG5Y2kk
Je ziet hier een arduino micro met de straatverlichting sketch die 4 leds (de perron verlichting) random laten knipperen voordat ze continue gaan branden.
Bij dat soort dingen heb ik altijd mijn twijfels. Doen die TL's dat in het echt ook? Bij straatverlichting worden meestal starterloze armaturen gebruikt, die gaan in één keer aan en knipperen niet.
-
het tijdperk van mijn baan is III tm V en die had je toen nog niet Klaas.
-
Tegenwoordig inderdaad wel en voor straatverlichting ook al wel langer. Maar staat me bij dat op Hengelo voor de renovatie dat het gewoon een geknipper was als het licht aan ging. ;D
Timo
-
Als ik me als topic starter ook even met de discussie mag bemoeien:
Ik heb met het straatverlichting projectje geprobeerd om de werking van een TAMS LC-9 na te bootsen: http://tams-online.de/epages/642f1858-c39b-4b7d-af86-f6a1feaca0e4.sf/de_DE/?ObjectPath=/Shops/642f1858-c39b-4b7d-af86-f6a1feaca0e4/Products/53-0209x
Het was meer een vingeroefening om te leren programmeren, dan dat ik er echt een duidelijk idee bij had wat het zou moeten kunnen enzo. Leuk dat het na al die tijd weer naar boven gehaald wordt.
Mocht je er zelf controle over willen hebben wanneer de boel in en uitschakelt, dan kun je (net als bij de TAMS print) een knop aan je Arduino knopen en een actie programmeren die de boel uitschakelt voor je.
Zoals bij alle open source projecten/software, is iedereen vrij om mijn programmeer werk te verbeteren en aan te passen naar eigen behoefte.