Multitasking

[achim]

Hallo
hat jemand Erfahrung mit einem z.B. AT128 und Multitasking gemacht?
In der einfachen Methode müsste es auf allen AT lauffähig sein. Keine zusätzlichen Datein notwendig.
Ich habe es bereits auf diesem AT gemacht, z.B. tastenentprellung wobei ich kurz oder lang unterscheiden kann. Man kann auch mehrere LED mit verschiedenen Zeiten gleichzeitig laufen lassen. Damit kann mal viele Sachen (fast) gleizeitig machen. Zeitschleife beträgt dabei 1 ms (auch kürzer möglich).
Habe erprobte Software dazu bereits fertig. Als nächste soll das Tut dazu kommen. Für einen anderen Typ gibt es bereits ein Tut (für die es eilig haben)
achim

[achim]

Hallo in die Runde
so wie es aussieht hat keiner Erfahrung damit gemacht.
Hat jemand Interesse an der Sache?
Könnt ihr euch was drunter vorstellen?
Frage in die Runde:
Wie kann ich (egal welche Sprache) mehrere LED (ca. 3 bis 5) unabhängig voneinander zu unterschiedlichen Zeiten blinken lassen? Betonung liegt auf unterschiedlich und unabhängig.
Vielleicht hat jemand eine Idee dazu
achim

[arduinopraxis]

Hallo Achim,

das Thema ist sehr interessant. Ich habe momentan keinen konkreten Fall wo das Thema erforderlich ist.

Unterschiedlich blinkende LEDs kann man mit dem Arduino-Sketch "BlinkWithoutDelay" relativ einfach realisieren.

Gruss
Thomas

/* Blink without Delay
 
 Turns on and off a light emitting diode(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.
 
 The circuit:
 * LED attached from pin 13 to ground.
 * Note: on most Arduinos, there is already an LED on the board
 that's attached to pin 13, so no hardware is needed for this example.
 
 
 created 2005
 by David A. Mellis
 modified 8 Feb 2010
 by Paul Stoffregen
 
 This example code is in the public domain.

 
 http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
 */

// constants won't change. Used here to
// set pin numbers:
const int ledPin =  13;      // the number of the LED pin

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);     
}

void loop()
{
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();
 
  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);
  }
}

[microtherion]

Erfahrungen damit gemacht habe ich keine, aber hier einige Überlegungen:

• Grundsätzlich gibt es keinen Grund, warum man nicht ein kleines Multitasking-OS zum Laufen bringen kann.
• Context-Switches sind aber RAM-Hungrig: Allein schon die 32 Register benötigen 64 Bytes pro Prozess zum Speichern, und wenn man noch den Stack etc dazurechnet kommt man auf ein Minimum von 128 Bytes pro Prozess, vermutlich mehr, und bei einem Gesamt-RAM von 2K auf einem ATmega328 ist das nicht so attraktiv.
• In einem Realtime-System, wie das Microcontroller darstellen, will man eigentlich nicht unkontrollierten Parallelismus haben, wie das ein preemptive Multitasking-System wäre.

Trotzdem gibt es einige Systeme, die Multitasking implementieren, z.B.: QP (preemptive) http://playground.arduino.cc/Code/QP und Scoop (cooperative) https://code.google.com/p/arduino-scoop-cooperative-scheduler-arm-avr/

Sinnvoller scheint mir aber der Ansatz, den Code auf kleine Subroutinen zu verteilen, und diese mit einem Event-driven Framework aufzurufen, z.B.: Ebl https://code.google.com/p/ebl-arduino/ oder Aiko https://github.com/samotage/Aiko. Das benötigt keine separaten Stacks oder Register-Saves.

[achim]

Hallo Thomas
es geht eigentlich nicht darum LED zu verschiedenen Zeiten blinken zu lassen. Kenne dein Beispiel nicht. Das gibt es bei mir nicht.
Es geht um das "fast" gleichzeitige zu machen, wie Sensoren, Motore, Textausgabe usw., also in Grunde total verschieden Sachen. Habe die LED nur als Beispiel genommen.

Andere Programme kenne ich auch, die über die verschiedensten Sachen so was zu lassen. Leider bleibt bei einigen Sachen dann kein Platz für mein Programm über.
Mache es wie in deinem Ansatz, zerlege es in kleine Stücke.
Bin dabei das Tut mit Beispielen und Herleitung fertig zu machen. Wenn es klappt steht es morgen im Netz. Ist saueinfach und überall anzuwenden.
achim 

[arduinopraxis]

Hallo Achim,

Bin dabei das Tut mit Beispielen und Herleitung fertig zu machen. Wenn es klappt steht es morgen im Netz. Ist saueinfach und überall anzuwenden.

Gerne schaue ich mir deine Lösung an 

Gruss
Thomas

[achim]

Hab dir was geschickt

[achim]

Der erste Teil Multitasking steht im Netz. Könnt jetzt anfange es zu zerreissen oder eure Meinung dazu sagen
achim

[dinoi]

Hallo Achim,

toll, sehr schön gemachte Beschreibung und leicht verständlich jede Überlegung ist nachvollziehbar. Die Lösung der Problems ist sehr einfach und damit sehr gut einsetzbar. Einziger Punkt bei welchem ich etwas Bedenken habe ist folgendes:
Sobald in die Unterprogramme Schritte eingebaut werden welche selber Zeit brauchen, sei es für die Berechnung oder Abfrage von Sensoren oder Modulen (RTC, usw). Dann geht die Zeitsteuerung wieder schief. Alternativ wäre da evtl. die Abfrage der millis() und der Vergleich if(currentMillis - previousMillis > interval) vom Beispiel "Blink without Delay" besser.

Grüessli Reto

[achim]

Hallo Reto
auch diese Sache kann man relativ einfach gestalten. Es kommt einmal auf die Art der Rechnung drauf. Dabei geht es besonders um den Bereich Festkomma oder Gleitkomma Berechnung. Das macht viel Zeit aus. Dazu zählt auch die Grösse der Zahl als Ergbenis oder Grundlage. Jedes Komma dabei vermeiden. Das andere ist, wie oft muss welcher Sensor ausgelesen werden. Ist unbedingt 1ms nötig oder reicht jeder 10 Durchlauf, ergibt Abtastung von 10 ms oder sogar 50ms? Es ist ein relatives Umdenken dazu nötig. Alles muss der Zeit untergeordnet werden. Es gilt immer der Grundsatz: Nicht auf das Ergenis warten, sondern was kann ich für dich tun. Wenn nicht mache ich halt was anderes.
Bei einer Quarzfrequenz von 16MHz geht eigentlich alles rasant schnell. Eigentlich ... muss den AT nur lassen
Denke dran, das ist nur eine einfache Art, kompliziert geht es immer.
achim

[dinoi]

Hallo Achim,

Du hast mich gerade angesteckt mit diesem Thema  . Hier habe ich jetzt meine Idee mit der Abfrage der millis() umgesetzt.
Dabei habe ich es auch versucht möglichst einfach zu machen, etwas besser wäre es mit einer Klasse statt nur einer Routine. Als Anhang die Ausgabe vom Protokoll.

Gruss Reto

Code: [Select]

/* Blink without Delay Multitasking */

const int ledPin1 = 13;      // the number of the LED pin
const int ledPin2 = 9;       // the number of the LED pin

boolean ledState1 = LOW;
boolean ledState2 = LOW;

unsigned long prevM1 = 0;
unsigned long prevM2 = 0;

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  Serial.begin(9600);
}

void loop()
{
 
// call void parameters ( Intevall, LedPin, Pointer to Previus Millis Variable, Pointer to Led State  )
led_blinken1(1000, ledPin1, &prevM1, &ledState1);
led_blinken1(333, ledPin2, &prevM2, &ledState2);

}

void led_blinken1(long intervl, int ledPin, unsigned long *prevM, boolean *ledState){
  unsigned long currentMillis;
  currentMillis = millis();

  if(currentMillis - *prevM >= intervl) {
    // save the last time you blinked the LED
    *prevM = currentMillis;   

    // write Log
     Serial.print("Led: ");
     Serial.print(ledPin);
     Serial.print(" Time: ");
     Serial.print(intervl);
     Serial.print(" Status: ");
     Serial.print(*ledState);
     Serial.print(" Millis: ");
     Serial.println(currentMillis);

    // if the LED is off turn it on and vice-versa:
     if (*ledState == LOW) {
      *ledState = HIGH;
   } else {
      *ledState = LOW;
      }

    // set the output pin
    digitalWrite(ledPin, *ledState);
  }
 
}


[arduinopraxis]

Hallo zusammen,

ich habe den Lösungsansatz von Achim für Arduino umgesetzt.
Die beiden LED blinken unabhängig voneinander 

Code: [Select]

// Angabe der Quarzfrequenz, wichtig für die Zeit
#define F_CPU 16000000UL
// Angabe der Quarzfrequenz, wichtig für die Zeit
#include <util/delay.h>
// Einbindung Datei Pause
#include <avr/io.h>
// Einbindung Datei Ausgänge


// Einbindung Datei Ausgänge
int16_t led1=0;
int16_t led2=0;



void setup(void)
{
  // Port D als Ausgang D7, D6
  DDRD = B11000000;
 
}


void loop(void)
{
  while (1)
  // Programmschleife
  {
    led_blinken1(); // Aufruf Unterprogramm 1
    led_blinken2(); // Aufruf Unterprogramm 1
    _delay_ms(1);
  }
}

void led_blinken1()
{
  led1++;
  if
  (led1==99)
  {
    PIND = _BV (7);
}
  else
  {
    if (led1==299)
    {
      PIND |= _BV (7);
      led1=0;
    }
  }
}

void led_blinken2()
{
  led2++;
  if (led2==599) {
    PIND = _BV (6);
   
  }
  else
  {
    if (led2==1199) {
      PIND |= _BV (6);
      led2=0;
    }
  }
}
Gruss
Thomas

[achim]

Dann warte mal ab, wenn der Rest kommt. Soll ich das Thema umbenennen, so in Virus 1 bis 3
Arbeite gerade an mehrfach Nutzung, verschiedne Zeiten an einer LED, Tasterabfrage. Tasterübergabe, Taster lang/kurz, Taster 10 fach, Menuesteuerung mit Display.
Da kann sich dein Virus so richtig ausleben.
achim

[arduinopraxis]

Hallo Achim,

Dann warte mal ab, wenn der Rest kommt. Soll ich das Thema umbenennen, so in Virus 1 bis 3

Bin gespannt auf die weiteren Funktionen.
Das Beispiel mit Blink ist ein guter und recht einfacher Ansatz. Voraussetzung ist dass man sich etwas tiefer in seine Programmierung versetzt.

Multitasking sagt genau aus was mit dem Konzept gemeint ist. Vom Virus bin ich noch nicht befallen 
Aber auf jeden Fall ein gutes Projekt um etwas die Gehirnwindungen zu wärmen 

Gruss
Thomas

[dinoi]

Hallo Achim,

gerade letzte Woche habe ich eine "Taster lang/kurz" gebaut, würde mich interessieren, wie Du es gelöst hast.

Gruss Reto