next topic »

[on:]

Hallo,
ich habe vor eine Landkarte zu bauen in der 6 Leuchttürme durch LED´s angezeigt werden sollen. Diese sollen gleichzeitig, aber alle in ihren originalen Frequenzen leuchten.
Nun meine Frage. Ist es möglich, das mit einem Arduino zu bewerkstelligen?

twoll065

[Reply #1 on:]

Klar ist das möglich mit der millis() Funktion.
Wenn du die Frequenz der einzelnen Türme kennst kein Problem.
Gruß
Bernward

[Reply #2 on:]

Danke, dann werde ich mich warscheinlich erst einmal in die Programmierung einarbeiten müssen. Ich denke das das kein Anfängerprojekt meht ist.

 

[Reply #3 on:]

Lernen, lernen, lernen ist angesagt. Was ja nicht so schlimm ist.
Hat schon jemand so ein ähnliches Projekt probiert?

[Reply #4 on:]

Nette Idee....

Prinzipiell ja. Du brauchst für jeden Leuchtturm einen Schaltausgang. Da hast Du genug von.

Der Rest ist Software. Das Lichttelegramm des Leuchtfeuers ist ja nichts weiter als das das Licht zu bestimmten Taktzeiten an oder aus ist.

Du musst Dir also eine Tabelle erstellen, in denen alle Hell- und Dunkelzeiten auf einer Zeitschiene abgebildet werden. Dort suchst Du Dir das kleinste gemeinsame Zeitfenster, was auch als Takt dienen kann.

Das könnte dann so aussehen:

LT1: 11100111001110011100....
LT2: 11001100110011001100....

usw.

Der Rest ist dann eigentlich simpel. Die Steuersequenz packst Du pro Leuchtturm in ein Array.

Im Loop läufst Du im Zeittakt. Pro Zeittakt nimmst Du den nächsten Wert aus dem Array und schaltest je nach Wert die entsprechende LED an oder aus. Das machst Du bei jedem Takt für alle Arrays bzw. LED.

Wenn Du am Arrayende angekommen bist gehts wieder von vorn los.

Edit: Anstelle ner Endlosschleife kannst Du natürlich auch nen Timer verwenden und dann beim Auslösen des Timer-Events die Ausgabe machen.

[Reply #5 on:]

Ein kleiner Tipp zum lernen
wenn du im folgenden Sketch in der setup blinkdauer =1000; deklarierst, dann blinkt die LED im Sekundentakt.
Und so kannst du das parallel für alle 6 machen.

Code:

if (millis() - blinken < blinkdauer) digitalWrite(LED, HIGH);
   else digitalWrite(LED, LOW);
  if (millis() - blinken > blinkdauer * 2) blinken = millis();

Gruß
Bernward

[Reply #6 on:]

Wenn dir vieleDinges Ansatz gefällt, will ich nichts sagen.

Sollte es dir aber (zu) kompliziert vorkommen, gibt es auch andere Ansätze (ohne kleinstes gemeinsames Zeitfenster und Takt -- eher wie Bernward's Vorschlag)

Unter der Voraussetzung, dass jeder Leuchtturm nur ein einfaches Muster (z.B. 1sec an, 9 sec aus) hat, musst du nur diese zwei Zahlen haben und dir merken, wann zum letzten Mal geschaltet wurde.

Wenn du keine delay() Funktion in loop verwendest, ist loop() in einer Millisekunde (oder so *) fertig und startet dann gleich wieder.
 *)_{Ob so ein Durchlauf 100µs oder 10ms dauert, ist egal, aber das ist eine normale Größenordnung}
 
In fast jedem Durchlauf wird dein Programm feststellen, dass nichts zu ändern ist; ganz selten wird festgestellt, dass eine LED einen anderen Zustand kriegt, diese letzte Schaltzeit wird gespeichert, und fertig.

Dass man so -beliebig- viele LEDs unabhängig voneinander schalten kann, ist hoffentlich klar
( na ja, mehr als Udo's  20 LEDs erfordern mehr Aufwand )

[Reply #7 on:]

Danke schon mal,
so ähnlich wie der Fast Counter?

[Reply #8 on:]

Ich würde für sowas die Blinksequenz einfach "malen", also so: http://blog.blinkenlight.net/experiments/basic-effects/pov-reloaded/. Einfach die Periodenlänge von 2ms auf 10 oder 100ms hochdrehen und gut.

Also etwa so:

Code:

MsTimer2::set(100, blink);

Danach kannst Du bis zu 20 Leuchttürme kontrollieren

[Reply #9 on:]

Wenn Du mir die Frequenzen der 6 Leuchttürme verrätst und versprichst, daß Ergebnis ins Netz zu stellen, dann baue ich das POV Programm direkt für Deinen Fall um.

[Reply #10 on:]

Ich hab ja nur eine Handvoll mal nach Leuchtfeuern navigiert in meinem Landratten-Hobbyurlaubssegler-Leben, und im echten Leben hat man auch den Nachteil, selten mehrere gleichzeitig zu sehen.

Dass die Feuer tatsächlich über lange Zeiträume synchron sind, entspricht eigentlich nicht meinem Eindruck.

Udo's POV Ansatz ist toll, lebt aber von der Synchronisation, während Leuchttürme für mich langsam und scheinbar unregelmäßig blinken und die Muster erst mit langem Hinschauen und Mitzählen  deutlich werden...

Hier vorstellen solltest du dein Projekt  in jedem Fall 

[Reply #11 on:]

Das wäre ja Spitze 

Hier die Zeiten:


alles in Sekunden.


twoll065

[Reply #12 on:]

alles in Sekunden.

Im Prinzip ist das Blinkenlassen von ein paar LEDs in ihrem jeweils eigenen Blinkrhythmus keine große Aktion.

Es geht es doch eigentlich nur darum, ein in Text- und Tabellenform formuliertes Problem in geeignete Datenstrukturen und Algorithmen zu verpacken, so dass der Arduino dann die Pins High und Low schalten kann, um LEDs zum Leuchten zu bringen oder dunkel zu belassen.

Die drei Statusarten "ein", "aus" und "Pause" verstehe ich so, dass "Pause" ebenfalls "aus" bedeutet, so dass es eigentlich nur "ein" und "aus" gibt, oder?

Beim Turm Pilsum schließt sich offenbar an 3 s "aus" noch 8,5s "Pause" an, was sich zu 11,5s "aus" zusammenfassen läßt?

Schau mal drüber, ob es so korrekt ist (Timings in Millisekunden, damit man alles mit "ganzen Zahlen" rechnen kann):

Code:

//                      ein   aus   ein   aus   ein   aus   ein   aus
int Norderney_timing[]={ 200, 2800, 200 , 2800, 200 , 5800};
int Pilsum_timing[]   ={3000, 3000, 3000,11500};
int Campen_timing[]   ={ 700, 2300,  700, 2300,  700, 2300,  700, 5300};
int Schillig_timing[] ={6000, 6000};
int Voslapp_timing[]  ={6000, 3000};
int Tossens_timing[]  ={6000, 1000};

So?

[Reply #13 on:]

Moin,
genau so ist das gemeint.

Pause = aus

[Reply #14 on:]

genau so ist das gemeint.

Alles klar, anbei mein Codevorschlag.

Code:

// Leuchtturm LEDs schalten by Jurs im Arduino-Forum Deutsch
//
// LED: Pin-Nummer der zu schaltenden LED
// gesamt= Gesamtlänge aller Timings zusammen für einen Zyklus des Leuchtturms
// n= Anzahl der nachfolgenden ein/aus Timings
//                      LED gesamt  n   ein   aus   ein   aus   ein   aus   ein   aus
int Norderney_timing[]={ 2, 12000,  6,  200, 2800,  200, 2800, 200 , 5800};
int Pilsum_timing[]   ={ 3, 20500,  4, 3000, 3000, 3000,11500};
int Campen_timing[]   ={13, 15000,  8,  700, 2300,  700, 2300,  700, 2300,  700, 5300};
int Schillig_timing[] ={ 5, 12000,  2, 6000, 6000};
int Voslapp_timing[]  ={ 6,  9000,  2, 6000, 3000};
int Tossens_timing[]  ={ 7,  7000,  2, 6000, 1000};

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  // define OUTPUT pins
  pinMode(Norderney_timing[0], OUTPUT);
  pinMode(Pilsum_timing[0], OUTPUT);
  pinMode(Campen_timing[0], OUTPUT);
  pinMode(Schillig_timing[0], OUTPUT);
  pinMode(Voslapp_timing[0], OUTPUT);
  pinMode(Tossens_timing[0], OUTPUT);
}


void TurmStatus(int* Turmdata)
{
  // Anfangs von eingeschaltetem Blinkstatus ausgehen
  boolean blinkStatusOn=true;
  // Zeit im Blinkzyklus per Modulo-Arithmetik
  // aus millis() und der Gesamt-Zykluszeit des Turms errechnen
  long inCycleTime=millis() % Turmdata[1];
  int onoffCount=Turmdata[2]; // Anzahl der ein/aus Schaltungen
  while (onoffCount>0 && inCycleTime-Turmdata[3+Turmdata[2]-onoffCount]>0)
  {
    // bereits abgelaufene Blinkzeit abziehen
    inCycleTime-=Turmdata[3+Turmdata[2]-onoffCount];
    onoffCount--; // Anzahl der ein/aus Schaltungen vermindert
    blinkStatusOn=!blinkStatusOn; // Blinkstatus wechselt
  }
  // wenn alles durch, dann den errechneten Blinkstatus setzen
  digitalWrite(Turmdata[0], blinkStatusOn);
}

void loop() {
  TurmStatus(Norderney_timing);
  TurmStatus(Pilsum_timing);
  TurmStatus(Campen_timing);
  TurmStatus(Schillig_timing);
  TurmStatus(Voslapp_timing);
  TurmStatus(Tossens_timing);
  // put the rest of your loop code here
}

In das Daten-Array pro Leuchtturm habe ich nun noch drei weitere Werte gepackt, und zwar
- LED: die Pin-Nummer des zu schaltenden Arduino Digital-Pins
- gesamt: die Gesamt-Zykluslänge (alle ein/aus-Einzelzeiten zusammengezählt)
- n: die Anzahl der ein/aus Schaltungen an diesem Leuchtturm pro Zyklus

So konnte ich den Code kurz halten und trotz der einfachen Programmlogik ohne zusätzliche Libraries sollten die Schaltzeiten zwar nicht auf die Mikrosekunde genau, aber auf einem 16 MHz Arduino doch so ca. +/- zwei Millisekunden eingehalten werden.

Natürlich gibt es immer mehrere Möglichkeiten, so etwas zu programmieren.