INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
LED Sternenhimmel - oder was ist eine Finite State Machine
30.06.2014, 06:34
Beitrag #1
LED Sternenhimmel - oder was ist eine Finite State Machine
Hallo Forum,

da im Forum immer wieder das Thema "Sternenhimmel" aufkommt habe ich mal versucht einen Lösungsansatz auf Basis sogenannter "Finite State Machines" darzustellen. Mein Geschreibsel kann / soll aber nur eine ganz oberflächliche Darstellung darüber sein, wie man es machen kann.
Ich hoffe dass es einige User/innen nutzbringend verwerten können.

Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.06.2014, 18:42 (Dieser Beitrag wurde zuletzt bearbeitet: 30.06.2014 18:58 von Thorsten Pferdekämper.)
Beitrag #2
RE: LED Sternenhimmel - oder was ist eine Finite State Machine
Hi Ricardo,

die Darstellung des endlichen Automaten ist meiner Meinung nach schon ok, aber die Anwendung in dem Fall halte ich fuer nicht ganz angebracht. Ich denke, dass es die Sache nur komplizierter macht. Eigentlich hat das ganze ja nur einen Zustand, alles andere geht immer "sofort" in den naechsten Zustand ueber.
(Ausserdem greifst Du einmal auf pwm[pwm_count] zu, was wahrscheinlich nicht auffaellt, da ja nur fuer 150ms.)

Das hier waere meine Version des "single" codings: (Nicht getestet, da ich momentan keinen Zugriff auf meinen Arduino habe...)

Code:
// Der PWM-Pin
const uint8_t pin  = 3;
// Variablen fuer 1. LED
const uint8_t pwm_count = 30;
uint8_t pwm[pwm_count];
const int pwm_interval = 150;
uint8_t pwm_now = 0;
boolean pwm_dir = true;
unsigned long lastChange = 0;

void setup()
{
  // Schreibt die PWM Werte in das jeweilige Array pwm
  for (uint8_t i = 0; i < pwm_count; i++) pwm[i] = i * 8;
  // Setzt den Modus des Pins
  pinMode(pin, OUTPUT);
}

void loop()
{
  fsm(pin);
}

void fsm(uint8_t pinx)
{
  unsigned long now = millis();
  analogWrite(pinx, pwm[pwm_now]);
  if (now - lastChange < pwm_interval)
    return;
  lastChange = now;
  if (pwm_now == pwm_count -1) pwm_dir = false;
  if (pwm_now == 0) pwm_dir = true;
  if (pwm_dir){
    pwm_now = pwm_now + 1;
  }else{
    pwm_now = pwm_now - 1;
  };
}

Meiner Meinung nach ist die wichtige Grundidee nicht unbedingt der endliche Automat, sondern die Verwendung einer "Handler-Funktion", die erstmal prueft, ob eine Aenderung ansteht und diese dann durchfuehrt.
...spaeter (morgen wahrscheinlich) dann mehr zum "multi"-Coding.

Gruss,
Thorsten

Hi,
jetzt hatte ich doch noch ein paar Minuten. Hier "mein" Multi-Beispiel:
Code:
// Array der PWM-Pins
const uint8_t pin[6]  = {3, 5, 6, 9, 10, 11};
// Variablen
// Anzahl der Elemente im Array der PWM Werte
// (Fuer jede LED gleich, das koennte man aber auch noch
//  flexibel gestalten.)
const uint8_t pwm_count = 30;
uint8_t pwm[6][pwm_count]; // Array der PWM-Werte
const int pwm_interval[6] = {50,75,100,75,50,125}; // Interval zum Wechsel der PWM-Werte
uint8_t pwm_now[6] = {0,0,0,0,0,0}; // aktuelle Prosition im Array der PWM-Werte
boolean pwm_dir[6] = {true,true,true,true,true,true}; // Zaehlrichtung im Array der PWM-Werte
unsigned long lastChange[6] = {0,0,0,0,0,0};

void setup()
{
  // Schreibt die PWM Werte in die Arrays
  // Um die Unabhängigkeit der Abläufe zu
  // demonstrieren werden Zufallswerte geschrieben
  for(uint8_t led = 0; led < 6; led++) {
    randomSeed(analogRead(0));
    for (uint8_t i = 0; i < pwm_count; i++) pwm[led][i] = (uint8_t) random(0, 256);
    // Setzt den Modus der PWM-Pins
    pinMode(pin[i], OUTPUT);
  }    
}

void loop()
{
// Die FSM werden immer wieder ausgeführt, ohne dass sie sich gegenseitig beeinflussen
// "now" wird hier ermittelt, damit die Zeitbasis fuer alle LEDs synchron bleibt
  unsigned long now = millis();
  for(uint8_t led = 0; led < 6; led++) {
    fsm(led, now);
  };
}

void fsm(uint8_t led, unsigned long now)
{
  analogWrite(pin[led], pwm[led][pwm_now[led]]);
  if (now - lastChange[led] < pwm_interval[led])
    return;
  lastChange[led] = now;
  if (pwm_now[led] == pwm_count -1) pwm_dir[led] = false;
  if (pwm_now[led] == 0) pwm_dir[led] = true;
  if (pwm_dir[led]){
    pwm_now[led] = pwm_now[led] + 1;
  }else{
    pwm_now[led] = pwm_now[led] - 1;
  };
}
Wie vorher: nicht getestet, aber die Idee duerfte klar werden.
Gruss,
Thorsten

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.06.2014, 19:25 (Dieser Beitrag wurde zuletzt bearbeitet: 30.06.2014 19:57 von rkuehle.)
Beitrag #3
RE: LED Sternenhimmel - oder was ist eine Finite State Machine
Hallo Thorsten,
Zitat:die Darstellung des endlichen Automaten ist meiner Meinung nach schon ok, aber die Anwendung in dem Fall halte ich fuer nicht ganz angebracht
Soll ja auch nur eine absolut Low-Level Darstellung sein. Das die Anwendung der FSM für den Zweck oversized ist, ist mir schon klar. Nur bot sich das Thema einfach an um das Grundprinzip (und nur das) irgendwie rüberzubringen.
Zitat:Eigentlich hat das ganze ja nur einen Zustand, alles andere geht immer "sofort" in den naechsten Zustand ueber.
Naja, eigentlich sind es drei wesentliche Zustände, einer der den Pegel schaltet, einer der die Zeit abwartet, einer der den Pegel setzt und die Zählrichtung .
Zitat:Ausserdem greifst Du einmal auf pwm[pwm_count] zu, was wahrscheinlich nicht auffaellt, da ja nur fuer 150ms.)
Danke für den Hinweis, werde den Code korrigeren (war heute früh 6 Uhr).
Das mit der Handlerfunktion ist schon richtig. ich weiß nur nicht ob sich dieses Verfahren durchhalten lässt, wenn andere / außerhalb der FSM eintretende Bedingungen gesetzt werden, die einen Zustandswechsel veranlassen und vorallem wenn verschiedene Aktionen gestartet werden sollen. Spannend dürfte es auch werden wenn verschachtelte FSMs laufen sollen.

Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
01.07.2014, 08:04
Beitrag #4
RE: LED Sternenhimmel - oder was ist eine Finite State Machine
(30.06.2014 19:25)rkuehle schrieb:  Das mit der Handlerfunktion ist schon richtig. ich weiß nur nicht ob sich dieses Verfahren durchhalten lässt, wenn andere / außerhalb der FSM eintretende Bedingungen gesetzt werden, die einen Zustandswechsel veranlassen und vorallem wenn verschiedene Aktionen gestartet werden sollen.
Klar, dann gewinnt wahrscheinlich eine explizite Modellierung als FSM. Ich habe abef Schwierigkeiten, mir da was sinnvolles für das Sternenhimmel-Beispiel einfallen zu lassen.

Falls ich mit einer Antwort helfen konnte, wuerde ich mich freuen, ein paar Fotos oder auch ein kleines Filmchen des zugehoerigen Projekts zu sehen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste