Ein letztes Update:

- Initialisierung weiter vereinfacht (_L_id, _H_id, und Zeit Definitionen entfernt)
- Divisionen wieder eingefügt, da hierdurch die Initialisierung von einem neuem Thread vereinfacht wird.
  Die Divisionen werden vom Compiler berechnet und als Konstante Zahl in die generierten Funktionen eingesetzt.
- Beispiel ins Englische übersetzt
- "default loop time" Definition mit in die Erstellung des Threads integriert.

[Update 13.05.2013]

Hey,
I wrote a lib, that can be create simple Threads only with Makros.

The following functions are supported
  
 sequence control:
 * __simpleThread_START(thread_name):
 * __simpleThread_STOP(thread_name):
 * __simpleThread_RESET(thread_name):
 * __simpleThread_RESTART(thread_name): reset + start
 * __simpleThread_IS_RUNNING(thread_name): check if a therad is started
 * __simpleThread_SET_DYN_TIME(thread_name, loop time in ms):  set new loop time, is only available when the thread is with
      __simpleThread_dyn initialized
 * __simpleThread_GET_DYN_TIME(thread_name): get loop time, is only available when the thread is with __simpleThread_dyn initialized
 
 initialization:
 * __simpleThread(thread_name, loop_time): create a new static thread with a name and a default loop time
 * __simpleThread_dyn(thread_name, loop_time on start): create a new dynamic thread with a name and a default loop time
 * __simpleThread_PTR(thread_name): containes the function pointer
 * __simpleThread_LOOP(thread_name): thread loop, same feature as in the arduino software
 * __simpleThread_SETUP(thread_name): thread setup, same feature as in the arduino software
 * __simpleThread_IN_LOOP(): this macro must be called from the orginal arduino loop function
 
 Futures:
 * - the lib contains only macros and one typedef
 * - the first thread need about 300 byte flash memory, ever next need about 90 byte flash memory
 * - threads can be controlled from other threads
 * - a thread must be started befor it runs
 * - the thread call is standardized
 * - the ram use is as small as possible. Every static thread needs 4 byte and a few bits
 * - few bits: for the first 1 - 8 threads 3 bytes are needed for the thread management. For the next 9 - 16 threads 3 new bytes are required
 * - the dynamic threads needs 4 additional bytes ram for the unsigned long loop time value
 * - the loop time from dynamic threads can be changed in the programm running
 * - the loop to call the thread functions needs some bytes on ram, this value is ever the same

What do you think ?

I come from Germany and presented this lib already in the forum. A user said that it might be useful for arduino :: std :: Lib.
PS: Sorry for my "brocken" english, i hope you can read and understand it.

Update 13.05.2013
- add two examples:
--- example: blinking of two leds with different frequences (2 threads)
--- example: thread control with three threads, output over serial monitor

Ich sehe das so wie Udo Klein.

Desweiteren kann ich, wenn ihr das Projekt noch umsetzt wollt, euch einen besseren Kontroller/System empfehlen.
Wir haben im Studium immer mit der LeanXcam (https://de.wikipedia.org/wiki/LeanXcam) gearbeitet, insofern es um Bildauswertung ging. Mit dieser Kamera lässt können auf dem Bild Muser oder Bereiche in verschiedenen Farben erkannt werden. Desweiteren kann man das Objektiv durch andere Objektive mit Farbfilter und Zoom-Faktoren ersetzen, so wird man unabhängiger gegenüber Hell / Dunkel Effekten und kann den Abstand besser justieren.

Die Daten der Kamera werden per Ethernet übertragen, damit ist eine Anbindung an gängige Lagerhaltungssysteme möglich. Applikationen lassen sich in C / C++ oder in OpenCV (für Bildverarbeitung auf der Kamera) schreiben. Man kann frei wählen ob man das Bildmaterial direkt von der Kamera zum PC Überträgt und dort die Verarbeitung durchführt oder ob die "Intelligenz" der Kamera eine vor Verarbeitung durchführt und danach die Bilder übertragen werden. Solche Kameras werden auch als Intelligente Kameras bezeichnet.
Die Kamera besitzt noch zwei IO Ausgänge die direkt in der Programmierung angesprochen werden können.

Ein Beispiel:
Wir haben die Kamera unter einem Octokoppter angebracht und auf einem Feld Rehe erkannt. Dies Funktioniert auch wenn der Untergrund braun (Erde trocken, Erde nass) und bei Wolken/Sonne  ist.

Ein weiteres Beispiel:
Mit der Kamera kann man Unkraut auf Erde erkenne. Wenn man nun mit UV Licht oder IR Licht auf Pflanzen strahlt, kann man auch auf einer Wiese Unterschiede zwischen den Pflanzen erkennen, wenn noch passende Farbfilter eingesetzt werden. Jede Pflanze reflektiert das Licht anders.

Vielleicht werden von der Kamera zu viele Funktionen unterstützt. Aber man lernt hier die Bildverarbeitung ;-)

[Änderungen:]

Ich habe ein Update des ersten Threads durchgeführt. Die Datei die im Anhang ist, wurde ebenfalls überarbeitet.

Änderungen:
- die simpleTools Lib wird nicht mehr benötigt
- die Threads werden nur noch durch Macros und bestehende Arduino Funktionen generiert
- Vorhandene Divisionen wurden bis auf die Initialisierung entfernt
- Die Thread Funktionen sehen nun wieder wie Funktionen aus (mit Geschweiften Klammern)
- Es gibt für das Thread_Setup und die Thread_Loop Schleife zwei getrennte Funktionen, so wie es für ein Arduino Programm üblich ist
- Threads können mit dynamischen Zeiten erstellt werden
- Intern: Umstellung auf bitWrite und bitRead


Die Dokumentation einschließlich Grafiken werde ich mal erstellen, wenn ich mir sicher bin das die größten Fehler behoben sind.

[Edit:]

Hi, das stimmt, die Berechnungen habe ich nicht mit eingerechnet und den Namen des Threads auch nicht. Wobei wie die Speicherauslastung beim Namen ist kann ich nicht genau sagen, da es ja nur ein Zeiger auf eine Funktion ist.  

In den 3 Bit des Threads wird gespeichert:  start/stop ,  reset,  first_init.

Die Variablen werden erstmal als uint8_t angelegt, also bei einem Thread werden 3 Byte belegt. Aber wenn 8 Threads verwendet werden sind es immer noch 3 Byte die den Status speichern. Erst ab dem 9 Thread müssen 6 Byte belegt werden. Daher werden "grob gesagt"  3 Bit pro Thread für das Management im Hintergrund benötigt. Vielleicht fällt mir noch eine bessere Variante ein um die Divisionen zu minimieren.

Der Vorteil von Makros ist, das ich den Quellcode den ich überall einfügen müsste durch verhältnismäßig einfache Aufrufe einheitlich darstellen kann. Zudem hat der Programmierer nicht mehr das Problem Änderungen an allen Stellen im Programm durchführen wenn es um eine Erweiterung geht. Ich bin mir nicht sicher ab wann ein Objekt das ich für jeden Thread erstellen könnte, kleiner wäre als der direkte Funktionsaufruf.

Zum Aufbau des Konstrukts:
Ich verwende dieses Konstrukt mit einem LCDMenu in dem ich für unterschiedliche Unterpunkte Threads starten und Stoppen kann, je nachdem wie ich diese gerade brauche. Bei größeren Projekten gefiel mir nicht, dass ich um eine Unterfunktion zu starten oder zu Stoppen immer gleich eine Variable(1 Byte) angelegt hatte. Zudem, wenn man ein Menü mit 30 Buttons für verschiedene Funktionen hat, kommt man schnell mit den Variabel Namen durcheinander und es wird unübersichtlich.

Für kleine Projekte lohnt sich das nur, wenn man die Möglichkeit zur Erweiterung für später offen halten möchte.  

Edit:
Es lässt mir ja so gerade keine Ruhe. Also ich habe nun nochmal versucht herauszubekommen, wie lange ein Leerer Thread benötigt um ausgeführt zu werden. Dafür habe ich mein Beispiel Umgeschrieben, so das 20 Threads ausgeführt werden.
Bei 20 Threads ist die Auszuführende Zeit  <1 ms.

Flash-Speicher:
- Einbindung der Thread Struktur für einen Thread: 364 Byte
- Einbindung für jeden weiteren Thread: 106 Byte

[Ich würde mich freuen wenn Ihr das Beispiel mal testen würdet und eure Meinung dazu abgebt.]

Oft ist es so, dass große Programme irgendwann unübersichtlich werden. Ab diesen Punkt hilft einem nur noch Abstraktion des Codes und eine Zerlegung auf mehrere Dateien (Tabs). Um diesem Prozess zu vereinfachen habe ich eine kleine Lib geschrieben die Threads generiert. Jeder Thread wird mit einer Wartezeit initialisiert. Nach dieser Zeit wird der Thread aufgerufen. Anschließend muss erst die Wartezeit wieder abgelaufen sein, damit er erneut aufgerufen werden kann.

In Threads können Abläufe abgelegt werden, die nicht immer Ausgeführt werden müssen, z.B.:

• - Taster Entprellen (100 ms)
• - Display aktualisieren (750ms)
• - Sensorwerte Abfragen (50ms)
• - Verschachtelte Zeitabläufe, z.B: bei der Fotografie (mehrere Bilder in bestimmten Zeitabfolgen), oder beim Aquarium Beleuchtung an/aus /Ströumungsrichtungen ...  
• - oder Andere Funktionen die Zyklisch ausgeführt werden

Die Threads können einzeln gestartet und gestoppt werden. z.B. ist das Starten eines Threads auch aus einem anderem Thread möglich.

Mir ist bewusst das es schon eine ähnliche Klasse gibt, die Threads anlegt, nur war es mir sehr wichtig so wenig wie möglich an Ram zu belegen, daher befinden sich in der Klasse nur Makros. Durch die Makros wird der Quellcode für die Threads beim kompilieren generiert und im Flash-Speicher abgelegt. Für die Variable die für die Threads generiert werden, wird pro Therad 4 Byte und 3 Bit im Ram belegt. Die 4 Byte beziehen sich auf den Timer der die Funktionen periodisch aufruft. Die 3 Bit sind für das Thread Management.

1 - 8 Threads benötigen 3 Byte im Ram. Wenn mehr Threads benötigt werden, wird jeweils für 8 Threads 3 weitere Bytes für das Thread Management belegt.    

Die Lib unterstützt folgende Funktionen:

• - Thread Start
• - Thread Stop
• - Thread Reset
• - Thread ReStart
• - Thread IsRunning
• - Thread SetDynTime
• - Thread GetDynTime

Jeder Thread hat eine Setup Funktion und eine Loop Funktion.  Im Setup werden Variablen initialisiert. Diese Funktion wird einmalig beim Start aufgerufen und kann nur durch den Thread Reset bzw Thread Restart erneut aufgerufen werden. Durch die Stop Funktion wird der Thread quasi Pausiert und kann mit Start wieder erneut weiterlaufen. Die Loop Funktion wird zyklisch aufgerufen, je nachdem wie die Zeit am Anfang initialisiert wurde.

Im Anhang ist ein Archiv in dem sich die simpleThreads Lib befinden. Der Ordner muss nach dem Enpacken in das libraries Verzeichnis kopiert werden. Wenn die Arduino Software anschließend gestartet wird kann ein Beispiel unter Datei->Beispiele->Beispiele->simpleThread geöffnet werden.

Im Beispiel werden drei Threads angelegt.
Der erste ersten beiden sind voneinander abhängig. Der erste Thread wird im Setup gestartet.
Sobald der erste Thread läuft wird über den seriellen Monitor ein Zähler ausgegeben. Wenn der Zähler den Wert 5 erreicht, wird der zweite Thread aus dem ersten gestartet. Dieser läuft wesentlich schneller ab und beendet sich selbst.
Der dritte Thread wird auch im Setup gestartet. Dieser Thread ist so ausgelegt das die Looptime zur Laufzeit verändert werden kann. Der Thread startet mit einer Zeit von 5000 ms und halbiert seine Looptime bei jedem Aufruf, bis die Zeit < 50 ms ist. Danach Startet der Thread erneut bei 5000 ms.

Ich würde mich freuen wenn Ihr das Beispiel mal testen würdet und eure Meinung dazu abgebt.

Ich verwende dieses Konzept nun schon etwas länger und will es nicht mehr missen.  Mit dem Konzept lässt sich auch ganz schön das delay() Problem umgehen. In nächster Zeit werde ich meine Menü Klasse auch dahingehend überarbeiten, das Hintergrund Prozesse durch Threads realisiert werden. Dann kann eine klare Trennung zwischen der Initialisierung des Menüs, den Menüfunktionen und den Hintergrund Abläufen geschaffen werden.

Update 22.05.2013

• Beispiele und Änderungen werden im Moment überarbeitet. Neue Macros integriert, Beschreibung folgt
• Lib ist Funktionstüchtig

Hi, das sieht ja schon sehr gut aus, eine Verbesserung hätte ich noch.

Du könntest allgemein die Datentypen besser ausnutzen.  "Int"  ist  2 Byte groß, wenn du nun nur Zahlenwerte zwischen 0-255 hast kannst du besser "uint8_t" oder  "unsigned char" verwenden, da dann nur 1 Byte belegt wird.

[Edit:]

So, ich schau gerade mal das Programm an und folgendes fällt mir direkt auf:

- in eine while schleife die unendliche läuft  (1)  gehören keine Variablendeklarationen   ->  unsigned long ....
- in deinem Programm wird extrem Viel Ram des Arduinos belegt (durch die ircodes.h).

Durch die große Ramauslastung stürzt dein Programm ab. Der Arduino hat nur 2k Byte. Die sollte sinvoller genutzt werden anstatt statische nicht veränderliche Variablen zu speichern.
Du könntest die ircodes  im Flash Speicher ablegen, danach sollte dein Programm wieder laufen.
Um den Speicherbedarf weiter zu optimieren kannst du ach die Seriellen Ausgaben im Flash ablegen.

Beispiele dazu findest du hier im Forum.

Edit:
Ich zitiere Uwefed:

Verwende die F()-Makro http://arduino.cc/forum/index.php/topic,127552.msg965539.html#msg965539

Und zweidimensionale Arrays kannst du mit PROGMEM in den Flash speichern.

Man kann die Geschwindigkeit auch über optische Sensoren messen, z.B. den Laser bei einer Maus, der die Bilder des Untergrundes mit der Verschiebung zum davor aufgenommen Bild vergleicht. Wenn man hier eine andere Linse einsetzt ist auch eine größere Abstand zum Boden möglich.

Ansonsten: Fertige Sensoren gibt es nicht, oder kosten sehr sehr viel Geld.

Hi,

das kann das Programm auch nicht feststellen, daher muss man ja die Auflistung immer anpassen. Man müsste den Compiler anpassen um so einen Fehler abfangen zu können, das geht aber viel zu tief und ist keine Lösung.

Vermutlich in der Loop Funktion, ich bastel gleich mal ein Beispiel wie das dann aussehen könnte.

Hi,
das liegt an den 'delay`s' im Code. Schau dir mal das Beispiel  "Blink without delay" an. Dann sollte dein Problem bald behoben sein.

Hi, ich habe mal dieses Thema auf den neusten Stand gebracht.
Die Lib wurde aktualisiert und das Tutorial angepasst.

Mehr Informationen gibt es im ersten Beitrag:
http://arduino.cc/forum/index.php/topic,73816.0.html

Ist doch schon super, einige Fehler findet man erst wenn man eine Nacht drüber schläft, oder eine längere Pause macht.

Ich hatte in einem Eintrag von dir weiter oben gesehen dass du ein delay(500); im Code hast. So etwas ist immer schlecht, da der Programmablauf dann für 500ms gestoppt wird und keine Hintergrundabläufe funktionieren.

Am besten könntest du so etwas ersetzen durch

Code:

// Globale Variable deklarieren am besten bei den anderen Timer Variablen
unsigned long g_timer_2 = 0;

// und dann der Code der alle 500 ms aufgerufen werden soll
if(CTR_timer(g_timer_2, 500)) {
  //hier dann der Code der nur alle 500 ms ausgeführt wird
}

Mikrocontroller (außer sie haben zwei Kerne) arbeiten ihr Programm von oben nach unten ab. Echt paralleles arbeiten ist nur mit FPGAs /CPLDs (werden in VHDL Programmiert / synthetisiert) oder Mehrkernprozessoren möglich.
Das Threading beschreibt ein Verfahren bei dem auch nicht "echt" parallel gearbeitet wird, sondern sehr schnell hintereinander. Wobei die einzelnen Threads über ein Scheduler gesteuert werden.
Im Prinzip wird jeder Funktion / jedem Programm ein Intervall zugewiesen. Vom Scheduler wird dann die Funktion in diesem Intervall aufgerufen, wobei auch überprüft wird ob eine andere Funktion eine wichtigere Priorität hat. Es kommt auch vor, dass die Ausgeführte Funktion unterbrochen wird um eine Wichtigere Funktion auszuführen.

http://de.wikipedia.org/wiki/Prozess-Scheduler

Auf dem Arduino ist dies diese Struktur nur ansatzweise umsetzbar.