Moin,
Der Titel ist Programm: ich möchte eine Lampe beim einschalten blinken lassen wie eine alte Starter Neonröhre, aus Zeiten vor EVG oder gar LED.
An sich ein sehr leichtes Projekt, einen analogWrite, eine millis abfrage fürs Timing.
Mein Problem sibd eher die Werte fürs feintuning, damit es authentisch ausschaut.
Hat jemand Erfahrung mit solchen Dingen? Eventuell in der Modelleisenbahn oä
Vielen Dank im Voraus
Filme eine Leuchtstoffröhre und miß daraus die Zeiten und Helligkeiten nach dem Einschalten aus.
Hallo
in einem dunklen Raum das Einschaltzeitverhalten mit einen LDR aufzeichnen und bei Gefallen ins EEPROM schreiben.
Also die Moba tools hab ich mal überflogen, auch für nicht modellbahner echt eine eierlegende wollmilchsau für grundlegende Applikationen. Sanftes ein/ ausschalten kann es auch aber nich das typische blinken.
Leider habe ich aktuell kein Gebäude im Kopf wo ich ne alte Röhre habe und im Büro liegen leider auch nur LED oder EVG Geräte.
Hat evtl einer von euch eine und könnte Timings und Helligkeiten ermitteln? Meinetwegen auch gegen einen kleinen Obolus....
dann wart' mal auf den Library Ersteller, ich vermute der lässt sich dazu animieren sowas zu implementieren.
Wobei warum versuchst du nicht selbst ein wenig? eine random Anzahl an Random Geflacker, dann auf 80%. Und dann langsam heller werdend.
"Richtig" oder "falsch" gibts da eh nicht meines Erachtens. ich würde es halt nicht übertreiben mit dem Effekt. Denn dann schauts grauslich aus.
Und immer gilt: Was spuckt google aus?
Eine kalte Leuchtstofflampe blinkt länger.
Ein Video: Suche Video von flackernder Leuchtstoffröhre - Beleuchtung und Lichteffekte - Schiffsmodell.net
Leuchtstoffröhre defekt, was ist kaputt Starter oder Röhre - YouTube
Gewusst wie.... Leuchtstoffröhre / Starter austauschen - Wohnlicht.com - YouTube
Flackernde Leuchtstoffröhre (18. Mai 2020) | Der Shopblogger
Es gibt sogar einen 5067 Leuchtstoffröhren-Simulator von Vissmann
Grüße Uwe
uwefed:
Eine kalte Leuchtstofflampe blinkt länger.
Richtig. Wenn meine kalt ist flackert sie bis zu 4 mal kurz auf, wenn sie warm ist leuchtet sie sofort.
Ein System gibt es da ansonsten nicht. Ich würde es, wie noiasca vorgeschlagen hat, machen: Random
Mit ATtiny45 und Schieberegistern habe ich mal ein Modellhaus beleuchtet, auch mit Leuchtstofflampengeflacker. Eine Leuchtstofflampe kann nur ein oder aus, aber die Ein- und Auszeiten sind zufällig.
flackernZimmer09 = random(50, 200); Mit den Zeiten muß man etwas spielen, bis es gefällt.
noiasca:
dann wart' mal auf den Library Ersteller, ich vermute der lässt sich dazu animieren sowas zu implementieren.
Der wird vermutlich auf die Kreativität des Programmierers setzen. Die Zeitgeber kann man aber dafür einsetzen.
agmue:
Der wird vermutlich auf die Kreativität des Programmierers setzen. Die Zeitgeber kann man aber dafür einsetzen.
grad mal in seine softled Klasse reingesehen. Puh, hut ab ... ich glaub ich mach das doch mit millis
noiasca:
grad mal in seine softled Klasse reingesehen. Puh, hut ab ... ich glaub ich mach das doch mit millis
und einem zweidimensionales Array für den Zeitwert und PWM-Wert
naja so ein Versuch.
/* Neon Leute
Turns on and off light emitting diodes (LED) connected to a digital pin,
without using the delay() function. This means that other code can run at the
same time without being interrupted by the LED code.
by noiasca
2021-01-30 https://forum.arduino.cc/index.php?topic=725431.0
V1
*/
// aus, zündet, leuchtet, 100%
enum class State {OFF, START, RUNNING, FULL};
class NeonLed {
private:
State state = State::OFF;
unsigned long previousMillis; // timestamp for states
unsigned long previousMillisEffect; // timestamp for the effect
uint16_t interval = 10; // how fast should the led be dimmed (=milliseconds between steps)
byte actual = 0; // actual PWM
uint16_t startTimeMin = 3000; // how long will it take from off to stable on
uint16_t startTimeMax = 6000;
const byte ledPin; // a GPIO for the LED, on UNO only PIN 3 5 6 9 10 11 are PWM
public:
NeonLed(byte attachTo):
ledPin(attachTo)
{}
void begin() {
pinMode(ledPin, OUTPUT);
}
void on() // einschalten
{
state = State::START;
previousMillis = millis();
analogWrite(ledPin, 2); // "glimm"
interval = 500;
Serial.println(F("D47 START"));
}
void off() // ausschalten
{
analogWrite(ledPin, 0);
state = State::OFF;
}
void tick() {
if (state == State::START) {
uint32_t currentMillis = millis();
if (currentMillis - previousMillisEffect > interval)
{
if (actual >= 200) // alles ab diesem Wert ist "ein" daher müssen wir nun "aus" Schalten
{
actual = random(0, 3); // leichtes Glimmen der "Enden" ... könnte man auch ganz auf 0 setzen
interval = random(700, 2000); // unregeläßige Dunkelphasen (zwischen dem Aufblitzen)
}
else
{
actual = random(200, 255);
interval = 30; // kurzes Aufblitzen
}
analogWrite(ledPin, actual);
previousMillisEffect = currentMillis;
}
if (currentMillis - previousMillis > (uint16_t)random(startTimeMin, startTimeMax))
{
actual = 200; // after the neon is stable "on" it will take some time to reach 100%
interval = 100; // we need 55 steps to get full 255 PWM = aprox 55 Seconds till the Neon tube has full brightness
analogWrite(ledPin, actual);
previousMillis = currentMillis;
state = State::RUNNING;
Serial.println(F("D71 RUNNING"));
}
}
if (state == State::RUNNING) {
uint32_t currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
actual++;
analogWrite(ledPin, actual);
if (actual >= 255)
{
state = State::FULL; // lower end reached. Switch to Idle state
Serial.println(F("D86 full"));
}
}
}
}
};
NeonLed neon(6); // on UNO only PIN 3 5 6 9 10 11 are PWM
//or as array of objects
//NeonLed neon[] {3, 5, 6, 9, 10, 11}; // on UNO only PIN 3 5 6 9 10 11 are PWM
void setup() {
Serial.begin(115200); //only used for debug
Serial.println(F("Neon Tube"));
Serial.print (__DATE__);
Serial.print (F(" "));
Serial.println(__TIME__);
randomSeed(analogRead(A4));
neon.begin(); // für jede Neonlampe einmal notwendig
neon.on(); // das entspricht dem "Einschalten" mit dem Schalter
/*
for(auto &i : neon) // for each object in the array
{
i.begin();
i.on();
}
*/
}
void loop() {
neon.tick();
//for(auto &i : neon) i.tick(); // if you use an array of objects
}
jetzt könnte man noch an den Timings drehen oder mehr setter machen zum Beeinflussen der Parameter.
tjard-frischling:
ich möchte eine Lampe beim einschalten blinken lassen wie eine alte Starter Neonröhre, aus Zeiten vor EVG oder gar LED.
Neonröhren haben keinen Starter, werden mit Hochspannung betrieben.
Mir stellt sich die Frage, warum man LEDs einsetzt, dann aber eine Leuchtstoffröhre simuliert? Eine Leuchtstoffröhre ist in der Ausbeute effektiv.
Wie lang ist die LED-Leuchte?
Mir stellt sich die Frage, warum man LEDs einsetzt, dann aber eine Leuchtstoffröhre simuliert? Eine Leuchtstoffröhre ist in der Ausbeute effektiv.
weil so eine Leuchtstoffröhre vieleicht einen Meter lang ist, das Modellhäuschen auf der Modelleisenbahn im Modellmaßstab 1:87 vieleicht pro Modellfenster nur etwa 1cm Platz bietet, und man daher mit einer LED beleuchtet und eine Leuchtstoffröhre IMITIEREN will.
urdaino:
Neonröhren haben keinen Starter, werden mit Hochspannung betrieben.
Meine Neonröhren (Leuchtstofflampe) haben einen Starter, früher mechanisch, jetzt elektronisch.
urdaino:
Mir stellt sich die Frage, warum man LEDs einsetzt, dann aber eine Leuchtstoffröhre simuliert?
Weil man beispielsweise im Eisenbahnmodellbau eine frühere Epoche nachbildet, wo Neonröhren flackern, Schweißbrenner blitzen und Fernseher zur Abendunterhaltung flimmern.
All das kann man mit in dieser Epoche im Alltag noch nicht vorhandenen LEDs simulieren.
noiasca:
weil so eine Leuchtstoffröhre vieleicht einen Meter lang ist, das Modellhäuschen auf der Modelleisenbahn im Modellmaßstab 1:87 vieleicht pro Modellfenster nur etwa 1cm Platz bietet, und man daher mit einer LED beleuchtet und eine Leuchtstoffröhre IMITIEREN will.
Das er das auf seiner Modellbahn einbauen möchte, kann ich nirgendwo lesen.
agmue:
Meine Neonröhren (Leuchtstofflampe) haben einen Starter, früher mechanisch, jetzt elektronisch.
Das sind aber keine Neonröhren, sondern wie du selber verlinkst Leuchtstoffröhren. Die enthalten auch kein Neon.
urdaino:
Das er das auf seiner Modellbahn einbauen möchte, kann ich nirgendwo lesen.
Das stimmt zweifellos, aber trotzdem scheint die "Modellbau-Vermutung" im Raum zu liegen 
Edit:
Der TO hat dazu aber keine Angaben gemacht.
Die Frage ist natürlich berechtigt: Wieso sollte jemand so etwas simulieren wollen, wenn es nicht für Modellbau ist.
Was mir noch einfällt: Als "Requisit" auf einer Theaterbühne oder für Filmaufnahmen (z.B. Szene in einem Lagerraum in den 70er Jahren).
Ich bleib in einer Modellstadt.
Gott sorgt für Tag und Nacht,
der Nachtwächter geht rum und schaltet Lampen ein.
Der er dem Alkohol nicht abgeneigt ist, stimmen die Zeiten nicht ganz genau, und manchmal bleibt auch eine hängen, weil er sie vergessen hat. Tja, vieleicht diskutiert er in einem Wirtshaus gerade, warum viele Leute zu Leuchtstoffröhren Neonlampen sagen. Er ärgert sich darüber, aber trotzdem muss er einfach seinen Job machen.
/* Neon Leuchte
Turns on and off light emitting diodes (LED) connected to a digital pin,
without using the delay() function. This means that other code can run at the
same time without being interrupted by the LED code.
by noiasca
2021-01-30 https://forum.arduino.cc/index.php?topic=725431.0
V2 with random timer
*/
// aus, zündet, leuchtet, 100%
enum class State {OFF, START, RUNNING, FULL};
class NeonLed {
private:
State state = State::OFF;
unsigned long previousMillis; // timestamp for states
unsigned long previousMillisEffect; // timestamp for the effect
uint16_t interval = 10; // how fast should the led be dimmed (=milliseconds between steps)
byte actual = 0; // actual PWM
uint16_t startTimeMin = 3000; // how long will it take from off to stable on
uint16_t startTimeMax = 6000;
const byte ledPin; // a GPIO for the LED, on UNO only PIN 3 5 6 9 10 11 are PWM
public:
NeonLed(byte attachTo):
ledPin(attachTo)
{}
void begin() {
pinMode(ledPin, OUTPUT);
}
State getState()
{
return state;
}
void on() // einschalten
{
state = State::START;
previousMillis = millis();
analogWrite(ledPin, 2); // "glimm"
interval = 500;
Serial.print(F("D47 START ")); Serial.println(ledPin);
}
void off() // ausschalten
{
analogWrite(ledPin, 0);
state = State::OFF;
Serial.print(F("D53 OFF ")); Serial.println(ledPin);
}
void tick() {
if (state == State::START) {
uint32_t currentMillis = millis();
if (currentMillis - previousMillisEffect > interval)
{
if (actual >= 200) // alles ab diesem Wert ist "ein" daher müssen wir nun "aus" Schalten
{
actual = random(0, 3); // leichtes Glimmen der "Enden" ... könnte man auch ganz auf 0 setzen
interval = random(700, 2000); // unregeläßige Dunkelphasen (zwischen dem Aufblitzen)
}
else
{
actual = random(200, 255);
interval = 30; // kurzes Aufblitzen
}
analogWrite(ledPin, actual);
previousMillisEffect = currentMillis;
}
if (currentMillis - previousMillis > (uint16_t)random(startTimeMin, startTimeMax))
{
actual = 200; // after the neon is stable "on" it will take some time to reach 100%
interval = 100; // we need 55 steps to get full 255 PWM = aprox 55 Seconds till the Neon tube has full brightness
analogWrite(ledPin, actual);
previousMillis = currentMillis;
state = State::RUNNING;
Serial.print(F("D71 RUNNING ")); Serial.println(ledPin);
}
}
if (state == State::RUNNING) {
uint32_t currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
actual++;
analogWrite(ledPin, actual);
if (actual >= 255)
{
state = State::FULL; // lower end reached. Switch to Idle state
Serial.print(F("D86 FULL ")); Serial.println(ledPin);
}
}
}
}
};
NeonLed neon[] {3, 5, 6, 9, 10, 11}; // GPIO for the LED, on UNO only PIN 3 5 6 9 10 11 are PWM
byte modelHour; // will store the model time for our town
const byte ledPin = 13; // a simple LED
// Genesis 1:5
// God called the light "day", and the darkness He called "night."
// And there was evening, and there was morning - the first day.
void god()
{
static byte previousModelHour;
modelHour = ((millis() / 10000UL) + 16) % 24 ; // Model time starts at 16:00
if (previousModelHour != modelHour)
{
Serial.print(F("modelHour=")); Serial.println(modelHour);
previousModelHour = modelHour;
}
}
// the watchman of the town switches on/off the lights - der Nachtwächter
void watchman()
{
static uint32_t previousMillis = 0;
if (millis() - previousMillis > 1000) // once a second
{
// turn on some lamps in the evening
if (modelHour == 18 && neon[0].getState() == State::OFF) neon[0].on(); // pünktlich einschalten um 18 Uhr
if (modelHour == 19 && neon[1].getState() == State::OFF && random(10) >= 8) neon[1].on(); // zufälliges einschalten nach 19 Uhr
if (modelHour == 19 && neon[2].getState() == State::OFF && random(10) >= 8) neon[2].on();
if (modelHour == 20 && neon[3].getState() == State::OFF && random(10) >= 8) neon[3].on();
if (modelHour == 17 && digitalRead(ledPin) == LOW) digitalWrite(ledPin, HIGH); // simples Einschalten eines Digitalpins
if (modelHour == 9 && neon[0].getState() == State::FULL) neon[0].off(); // pünktlich ausschalten
if (modelHour == 8 && neon[1].getState() == State::FULL && random(10) >= 8) neon[1].off();
if (modelHour == 8 && neon[2].getState() == State::FULL && random(10) >= 8) neon[2].off();
if (modelHour == 7 && neon[3].getState() == State::FULL && random(10) >= 8) neon[3].off();
if (modelHour == 6 && digitalRead(ledPin) == HIGH) digitalWrite(ledPin, LOW);
previousMillis = millis();
}
}
void setup() {
Serial.begin(115200);
Serial.println(F("Neon Tube - Model Town"));
Serial.print (__DATE__);
Serial.print (F(" "));
Serial.println(__TIME__);
randomSeed(analogRead(A4));
pinMode(ledPin, OUTPUT);
for (auto &i : neon) i.begin(); // call begin for each object in the array
}
void loop() {
for (auto &i : neon) i.tick(); // check each Neon object if something is to do
god(); // give God some time to care for night and day
watchman(); // the watchman will switch on/off the lights
}
Hallo
hier kommt meine "klassen- und arraylose" Lösung mit einer Tüte voll mit random()- Funktionen.
Auch bei dieser Lösung kann das Zeitverhalten abgestimmt werden, von hektisch bis erträglich
#define ProjektName "Simulator Neon Licht flackern"
unsigned long stempel;
int ledPins[] = {5};
#define ledNummer unsigned int nummer=0; nummer< (sizeof(ledPins)/sizeof(int)); nummer++
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
Serial.print("File: "); Serial.println(__FILE__);
Serial.print("Projekt: "); Serial.println(ProjektName);
for (ledNummer) pinMode (ledPins[nummer], OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
if (millis() - stempel > random(250, 750)) {
stempel = millis();
if (random(0,2)) analogWrite(ledPins[0], random(2, 256)); else analogWrite(ledPins[0], 0);
}
Eine "bunte" Lösung mit einer RGB-Led ist ist Arbeit, falls jemand die Leuchterscheinung eines laufenden Fernsehempfänger simulieren will.
deine ist aber dauerhaft kaputt
Für dich: die schließende Klammer fehlt und schau dir mal das "auto ranged based for" unter C++ an.
Ich denke das würde dein Konstrukt vereinfachen.