Blaulicht(Polizei) nachahmen, Denkanstoss gesucht

Hallo Freunde,
vielleicht kann mir ja hier wer einen Denkanstoss geben, wie ich an die Realisierung meines Vohabens rangehen könnte?
Also ich habe geplant erst mal mit 2 blauen LEDs solcj ein Warnlicht ähnlich dem Blaulicht auf Polizei , Feuerwehr oder Zollautos zu bauen.
Es sollen zwei 5mm LED in einen PyracrylStreifen stecken und das blaue Blitzlich imitieren, ich komme aber nur immer zum wechselseitigen
blinken ..irgendwie fehlt mir da ne "Marschrichtungszahl" bei der Programmierung(Attiny13...43). der Chip hat nur die Leds zu steuern.

Kann wer helfen, mir einen Denkanstoss zu geben ?

Gruss und Dank

Gerhard

Hallo!

Ich kann mir noch erinnern, dass vor zig Jahren "Blaulicht" bei Krankenwagen mit rotierendem spherischen Spiegel erzeugt wurde, weil damals noch keine µC gegeben hat. Rein elektronisch scheint mir das mit mehreren blinkenden superhellen LEDs mit kleinem Abstrahlwinkel + Linse realisierbar (evtl. mit geeigneten Blenden, falls nötig), also vieeel Spass und Erfolg damit. :D

Was fehlt dir genau?

Im Anhang die zulässigen Blinkfolgen in D.

Hallo und Danke Euch beiden...
@picture: nein so kompliziert wollte ich es nicht machen...Modell soll einfaches Modell bleiben und auch Hobby...einfach nur blinken..flackern soll das mit dem Rundumspiegel nachstellen.

@dremler: Danke für die Grafik, da weiss ich wies blinken soll/kann..

Ich habe hier von meinen Enkel irgendso ein "Blinkspielzeug" mit 2 LED rt/bl, die flackerten, wenn man das Teil schüttelte dann ne zeitlang abwechselnd, die Leiterplättchen waren mal in so was ähnlichen wie Tennisbälle drinnen und haben dann schön bunt eben geflackert wenn man die gerollt hat...

Nun, ich habe mal einen ATTiny aufs STK500 gesteckt und werde mal experimentieren....und das kam dabei raus :

Code:

---

/* ========================================================================== */
/*                                                                            */
/*  police_flash.c                                                          */
/*  (c) 2014 Gerhard Hinze                                                  */
/*                                                                            */
/*  Description                                                              */
/*                                                                            */
/* ========================================================================== */
#ifndef F_CPU
//#define F_CPU  3686400UL  für STK500
#define F_CPU  4800000UL  //fclock intern
#endif
/* ========================================================================== */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/* ========================================================================== */
#include <avr/io.h>
#include <util/delay.h>
/* ========================================================================== */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/* ========================================================================== */


int main(void){
    DDRB |= (1<< PB0) | (1<< PB1); 
     
 
    while(1){
     
        PORTB |= (1<<PB1);  //OFF
        PORTB &= ~(1<<PB0); //ON  0/1
    _delay_ms(50);

        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
      _delay_ms(50) ;

        PORTB |= (1<<PB1);  //OFF
        PORTB &= ~(1<<PB0);  //ON 0/2
    _delay_ms(50);

        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
    _delay_ms(50);

        PORTB |= (1<<PB1);  //OFF
        PORTB &= ~(1<<PB0); //ON  0/3
    _delay_ms(50);

        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
    _delay_ms(100);        // Umschaltpause von links nach rechts
       
        PORTB &= ~(1<<PB1);  //ON  1/1
        PORTB |=  (1<<PB0);  //OFF
    _delay_ms(50);

        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
    _delay_ms(50);

        PORTB &= ~(1<<PB1);  //ON  1/2
        PORTB |= (1<<PB0);  //OFF
    _delay_ms(50);
        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
    _delay_ms(50);

        PORTB &= ~(1<<PB1);  //ON  1/3
        PORTB |=  (1<<PB0);  //OFF
    _delay_ms(50);

        PORTB |= (1<<PB0);  //OFF
        PORTB |= (1<<PB1);  //OFF
    _delay_ms(100);
     
    }
 

return 0;
}

/* ========================================================================== */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/* ========================================================================== */

---

Gruss und Dank

Gerhard

Jetzt, wo das Programm schon mal testweise steht, kann man sich Gedanken über Modularisierung und Verbesserung machen.

Das Programm führt ja immer wieder die gleichen Sequenzen aus: Schalte Pins ein bzw aus, warte...
Das klingt doch schonmal stark nach ner Funktion: esWerdeLicht( pinout, wartezeit )

Als nächstes könnte man pinout und wartezeit aus 2 Arrays auslesen und den Funktionsaufruf zuzüglich Array auslesen in eine Schleife packen. Dann musst Du fürs experimentieren nicht immer den Code ändern, sondern einfach nur das Array.

Und dann kannst Du eben auch mehrere Arrays speichern, jeweils ein eigenes für die verschiedenen Blinkfolgen. Mit ein paar Jumpern an nicht benötigten Pins kannst Du dann bestimmen welche Blinkfolge abgespielt werden soll.

Schon hast Du ne Blinklichtschaltung, die Du für alles mögliche benutzen kannst:
Krankenwagen, Polizei, Feuerwehr, Straßenmeisterei, Blinklichtbake ....
Mit noch kleinen Änderungen sogar als Ampel.

Die gleiche Idee hatte ich auch schon, mal sowas zu bauen. Insbesondere finde ich dabei interessant, dass die Einsatzfahrzeuge heute nicht mehr AN, AUS blinken wie man das von den alten, Rotationsblaulichtern blinken, sondern ganz offensichtlich in unterschiedliche Zeiten.

Das Zeitdiagramm beschreibt aber meines Erachtens nur die Folge für Gelblicht und nicht für Blaulicht

Laufen die Blinklichter auf den Autos nicht asynchron und geringfügig versetzt ?
Ich hab das mal für ein Modellauto mit einem PIC gemacht. Da habe ich im Timerinterrupt immer 2 Variabeln heruntergzählt bis 0.
Wenn sie 0 erreicht hatten, habe ich wieder den Startwert gesetzt wobei der eine Startwert z.B. 300 war und der andere 317.
Immer wenn der entsprechende Timer der LED abgelaufen war, wurde die LED getoggelt. Das läuft dann schön asynchron.

Kommt halt immer auf die Technik an. Drehspiegelleuchten drehen immer asynchron. Gasentladungslampen laufen geringfügig asynchron, da die Ladezeiten durch die Kondensatoren unterschiedlich sind.

Nur LED Leuchten dürfen perfekt synchron laufen, wenn sie von einem Steuergerät angesteuert werden (z. B. in einem Blaulichtbalken). Wenn sie jedoch jeder nen eigenen µC haben dann dürften sie auch asynchron laufen.

Kann dremler da bestätigen. Drehspiegel und Gasentladungslampen laufen asynchron, da die Bauweise und Funktion diverse Toleranzen nicht ausgleicht. Wäre zu teuer und auch unnötig.

Dazu kommt, dass die Asynchornität auch ein gewisses Maß an zusätzlicher Aufmerksamkeit erzeugt. Wenn ich z.B. an der Ampel stehe fällt meine Aufmerksamkeit häufig darauf, dass mein Blinker eine andere Frequenz halt als das Fahrzeug vor mir :D Das menschliche Gehirn versucht immer die Frequenz zu erkennen (gab da mal nen Bericht zu einer Taschenlampe, deren Freuqenz leicht schwankt und so Angreifer verwirrt, inkl. Gleichgewichtsbeeinträchtigung und Übelkeit :D )

Da die Elektronik für LED-Befeuerung meist µC-gesteuert ist (um verschiedene Lichtfolgen einstellen zu können) sind diese meistens synchron. Ggf werden die verschiedenen Blinkfolgen aber auch durchgewechselt um mehr Aufmerksamkeit zu erzeugen.

Die Blinkfolgen die weiter oben gezeigt wurden werden auch bei Blaulichtern verwendet. Welche Folge eingestellt wird ist aber immer abhängig vom Kunden/Ausrüster und kann selbst bei der gleichen Organisation variieren.

Ich habe auf http://de.wikipedia.org/wiki/Rundumkennleuchte einige Infos gefunden, u.a. den Link auf die gesetzliche Regelung, mit Formeln für die Blinkerei. Also bevor du den Antrag auf Genehmigung deiner Kennleuchten stellts, kannst prüfen ob alle gesetzlichen Anforderungen erfüllt sind:
http://www.bmvi.de//cae/servlet/cont...klicht-pdf.pdf

LG witkatz

Danke für den Hinweis, kann man 'ne Menge nachlesen,
aber für die Leuchten an meinem Zumo-Roboter mache ich mir die " eigenen gesetzlichen Anforderungen"....ich möchte ja keine öffendliche Fahrzeuge der Justiz oder sonst welcher Organen des Staates ausrüsten..
Da muss ich keinen Genehmigungsantrag stellen.. ;)

Gruss und Dank

Gerhard

JA zum Glück. Ich möchte mir nicht vorstellen, dass die Polizei mit Zumo-Robotern z.B. gegen Demonstranten vorgeht ;-)
Die Norm schreibt im Wesentlichen vor, dass kurz hintereinander folgende Mehrfach-Blitze als ein Blinkzeichen gelten. Die Hellzeit ist max. 0,4/f also 200ms bei 2Hz, also in 200ms kanns du zwei oder drei mal Blinken und dann 300ms Pause. Die Blinkfrequenz muss 60-100 Blitze pro Minute betragen (also ca. 2Hz).
Punkt 7.2.1 im Anhang 5 beschreibt dass Gruppen von Kennleuchten als eine Einheit blinken wenn sich die Lichtverteilung überschneidet.

Viel Erfolg und ich würde mich freuen, ein Video vom Zumo mit Blaulicht zu sehen. Und ich werde mit Sicherheit keine fotometrische Prüfung nachfordern ;-)

Gruß von der Ruhr an die Oder
witkatz