Show Posts
Pages: 1 ... 15 16 [17] 18 19 ... 39
241  International / Deutsch / Re: Arduino und Threading on: May 17, 2013, 01:15:58 pm
Wo wird die Variable den eingelesen ?
Im Thread findet im Moment nur die Ausgabe statt und wenn die Variable leer ist, dann liegt das vermutlich nicht am Thread. Stell mal bitte mehr Quellcode von deiner Software zur Verfügung.
242  International / Deutsch / Re: Projekt: LCDMenuLib - Menüs mit mehreren Ebenen ( Tree-Model / Nested Set ) on: May 17, 2013, 01:14:00 pm
Das funktioniert genauso wie eine normale Scroll Funktion auf dem Display.
Da ich so etwas bisher noch nicht gebraucht habe, existiert dafür keine fertige Funktion.
Du könntest aber mit  if(CTR_check_button()) {
und   if(g_button_up > 0) {  und  if(g_button_down > 0) {  die Scroll Funktion steuern.

Vielleicht gibt es hier ja irgendwo schon eine Lib im Forum die sich mit dem Scrollen durch längere Texte beschäftigt.
243  International / Deutsch / Re: Arduino und Threading on: May 17, 2013, 10:43:35 am
Hi, die Lib wurde soeben nochmal aktualisiert.

Du kannst an einen Thread keine Parameter übergeben. Es ist genau so wie bei der setup() {} und loop() {} Funktion des Arduinos. Es können innerhalb des Threads lokale Variablen angelegt werden, ansonsten ist die Kommunikation nur über globale Variablen möglich.
244  International / Deutsch / Re: Arduino und Threading on: May 16, 2013, 04:01:03 pm
Hi, du kannst auch mal hier reinschauen, wobei ich morgen noch ein Update der Lib hochladen werde in dem die Initialisierung weiter vereinfacht wurde und mehr als 3 Beispiele beinhaltet sind.

http://forum.arduino.cc/index.php?topic=165552.0
245  International / Deutsch / Re: Atmel Studio 6 kein Syntax Prüfung?? on: May 15, 2013, 11:56:57 am
Quote
@Jomelo, sind die Sprachen C++ , C# bei dir im Amtel Studio aufgeführt? Bei mir stehen die nicht drin, nur CSS( ? ). Im Visual Studio sind sie aber aufgeführt. Beide Programme sollen doch aber das Gleiche sein!!??

Die beiden Software Versionen sind ja nicht das gleiche. So kann man das nicht ausdrucken. Atmel Studio hat nichts mit C# zu tun.
Bei mir funktioniert die Autovervollständigung so wie das Syntaxhighlighting. Ich habe dazu mal zwei Bilder im Anhang eingefügt.
246  International / Deutsch / Re: Atmel Studio 6 kein Syntax Prüfung?? on: May 14, 2013, 12:55:52 pm
Ich habe erst VS installiert und anschließend AS 6.1

Bei VS habe ich alles installiert einschließlich C/C++, c#, f, ....

Edit:
Wenn ich VS 2013 installiere, dann läuft Atmel Studio garnicht mehr. Irgendwie ein Fehler in der Shell oder so
247  Development / Suggestions for the Arduino Project / Re: project: simpleThreads only generated with macros and some global variables on: May 14, 2013, 01:32:18 am
Hey,
i have updated the first thread. There are now two examples in the lib archiv:

- led blinking with two different frequenys on digital pin 12 and 13
- thread control with three threads and an output over serial monitor

Examples under:  File->examples->simpleThread->...  in arduino software
248  International / Deutsch / Re: Atmel Studio 6 kein Syntax Prüfung?? on: May 13, 2013, 04:03:50 pm
Hi, so nun konnte ich das mal testen.

Visual Studio Ultimate 2010:  kein syntax Highlighting, compilieren und upload funktionieren

Atmel Studio 6.1: syntax Hifhlighting compilieren und upload funktionieren ohne probleme.
249  International / Deutsch / Re: Atmel Studio 6 kein Syntax Prüfung?? on: May 12, 2013, 10:10:11 am
Ich teste das mal eben. Ich habe auch beide Programme installiert, nur das Addin fehlt noch.

Edit 1:
Hmm, ich habe das AddIn installiert, aber wie kann ich damit ein Arduino Programm erstellen ? (neues Projekt anlegen)
250  International / Deutsch / Re: Projektvorstellung: einfache Threads auf dem Arduino mit Hilfe von Makros on: May 12, 2013, 06:57:28 am
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.
251  Development / Suggestions for the Arduino Project / project: simpleThreads only generated with macros and some global variables on: May 12, 2013, 06:55:20 am
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
252  International / Deutsch / Re: Totaler Anfänger, Hilfe für Uni-Projekt nötig on: May 12, 2013, 03:10:23 am
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 ;-)
253  International / Deutsch / Re: Projektvorstellung: einfache Threads auf dem Arduino mit Hilfe von Makros on: May 10, 2013, 06:03:29 am
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.
254  International / Deutsch / Re: Projektvorstellung: einfache Threads auf dem Arduino mit Hilfe von Makros on: May 09, 2013, 05:30:57 pm
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
255  International / Deutsch / Projektvorstellung: simpleThreads auf dem Arduino mit Hilfe von Makros on: May 09, 2013, 02:59:48 pm
Last Update 18.11.2013

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 oder Libs). Um diesem Prozess zu vereinfachen habe ich eine Lib geschrieben die Threads generiert. Jeder Thread kann zeitbasiert (timebased) oder eventbasiert (eventbased) angelegt werden. Bei den zeitbasierten Threads wird nochmal zwischen Threads mit statischer und dynamischer Ausführzeit unterschieden. Bei den dynamischen Threads kann die Zeit zur Laufzeit des Programmes noch verändert werden. Wenn mehrer Threads angelegt sind, müssen diese nicht mehr einzeln in der Loop Funktion aufgerufen werden. Dazu gibt es eine Run-Funktion (simpleThread_run()) die automatisch, entweder der Reihenfolge nach oder Priorität orientiert die einzelnen Threads aufruft.

Verwendungsmöglichkeiten dieser Lib:
  • strukturierter Programmablauf von mehreren Unterprogrammen
  • Display aktualisieren (750ms), Buttons auslesen (50ms), Sensorwerte auslesen (500ms), Messerte per Ethernet übertragen (jede Minute)
  • Verschiedene Statusanzeigen die Zeitlich gesteuert auf einem LCD angezeigt werden sollen
  • 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 oder Zustands gesteuert ausgeführt werden


Mir ist bewusst das es schon eine ähnliche Lib gibt. 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. Je nach Thread Art wird unterschiedliche viel Ram fest belegt.

Allgemein gilt für das Thread Management
Für jeden Thread werden zwei Bit benötigt. In diesen wird gespeichert ob der Thread gestartet/gestoppt ist und ob der Therad zurückgesetzt werden soll. Für den ersten Thread der angelegt wird, werden zwei Byte reserviert. Jeder weitere Thread bis zum achten greift auf diese zwei Byte zurück. Erst der neunte Thread reserviert erneut zwei Byte.
1 - 8 => zwei Byte
9 - 16 => zwei weitere Byte ...
Diese Speicherbelegung trifft auf eventbasierte Threads zu.

zeitbasierter Thread mit statischer Zeit
Auf Basis der algemeinen Belegung, werden hier vier weitere Bytes im Ram belegt

zeitbasierter Thread mit dynamischer Zeit
Auf Basis der algemeinen Belegung, werden hier acht weitere Bytes im Ram belegt

Initialisierung von Threads:
Zuerst muss die simpleThread.h eingebunden werden. Anschließen muss außerhalb von allen existierenden Funktionen die Initialisierung eingeleitet werden. Bei dieser wird angegeben wie viel neue Threads angelegt werden sollen. Wenn der Wert über die Anzahl nicht der existierenden Thread Anzahl entspricht, treten Fehler auf, die sich dadurch außern, dass das Programm einfach durchläuft ohne start / stop / wait_time / events.
Nach dem festlegen der Thread Anzahl, werden die einzelnen Threads angelegt. Jeder Thread muss zuerst ein eindeutige ID bekommen, die von 0 an aufwärts gezählt werden muss.
Befehle:
  • simpleThread_init( anzahl an threads )
  • simpleThread_new_timebased_static(id, thread_name, wait_time)
  • simpleThread_new_timebased_dynamic(id, thread_name, wait_time)
  • simpleThread_new_eventbased(id, thread_name)

Anschließen wird die Priorität festgelegt. Hierzu werden die Thread namen in einer Liste eingetragen. Der oberste Eintrag hat die größte Priorität. Dies ist in den Beispielen am besten verdeutlicht.

Für jeden Therad der oben angelegt wurde, muss zudem eine Setup- und Loop-Funktion angelegt werden. Die Loop Funktion besitzt einen Rückgabe Wert, auf den weiter unten eingegangen wird. Dieser kann gesetzt werden, muss aber nicht.
Der erstellte Code könnte so aussehen:
Code:
void simpleThread_setup(thread_name)
  {  
  
  }  

  boolean simpleThread_loop(thread_name)
  {

  }

Aufbau eines Threads:
Jeder Thread besteht aus einer SETUP und LOOP Funktion. Die Setup Funktion wird einmal zu Beginn aufgerufen. Anschließend wird ausschließlich die Loop Funktion ausgeführt. Ein Thread kann gestartet und gestoppt werden. Mit dem Reset Befehl setzt man einen Thread zurück, sprich beim nächsten Aufruf wird die Setup-Funktion erneut aufgerufen. Jeder Thread kann mit  "isRun" überprüft werden, ob dieser gestartet oder gestoppt ist. Zudem gibt es die Möglichkeit
Befehle:
  • simpleThread_start(thread_name) oder simpleThread_event_start(thread_name)
  • simpleThread_stop(thread_name)
  • simpleThread_stopStable(thread_name)
  • simpleThread_reset(thread_name) oder simpleThread_event_reset
  • simpleThread_restart(therad_name) oder simpleThread_event_restart
  • simpleThread_loop(thread_name)
  • simpleThread_setup(thread_name)
  • simpleThread_stable(thread_name)
  • simpleThread_run(_simpleThread_M_without_priority  oder  _simpleThread_M_with_priority)

Den Programmablauf eines einzelnen Threads kann man sich wie folgt vorstellen:


Um Kontrollfunktionen bei vielen Threads zu vereinfachen, können Gruppen von Threads angelegt werden. Jede Gruppe kann einzeln gestartet, gestoppt, zurückgesetzt oder zurückgesetzt und gestartet werden.
Befehle:
  • simpleThread_group_init(group_name, anzahl der threads in der gruppe)
  • simpleThread_group(thread name)
  • simpleThread_group_start(groupe_name)
  • simpleThread_group_stop(group_name)
  • simpleThread_group_stopStable(group_name)
  • simpleThread_group_reset(group_name)
  • simpleThread_group_restart(group_name)

Zur Vereinfachung gibt es auch die Möglichkeit die Setup- oder Loop- Funktion eines Threats direkt aufzurufen. Dafür wurden folgende Befehle eingeführt:
  • simpleThread_call(thread_name)
  • simpleThread_call_loop(thread_name)
  • simpleThread_call_setup(thread_name)
  • simpleThread_call_stable(thread_name)


Da es Event- Zeitbasierte Threads gibt wird der Ablauf wie im folgenden Bild generiert. Der Thread der dort eingezeichnet ist, wurde vom Ablauf her weiter oben schon beschrieben.


Dieser Ablauf der nun Beschrieb wurde ist in den gesamten Ablauf eingebettet. Der gesamte Ablauf kann der Reihenfolge nach oder mittels einer Priorität durchlaufen werden.

der Reihenfolge nach (A):
Bei jedem Thread wird der Reihenfolge nach überprüft ob dieser gestartet wurde und ob bei zeitbasierten Threads die Wartezeit abgelaufen ist oder bei eventbasierten Threads das ein Event gestartet wurde. Wenn keine Bedingung erfüllt ist, wird der nächste Thread überprüft. Ansonsten wird der Thread ausgeführt.

mittels Priorität (B)
Es findet die gleiche Überprüfung wie schon unter "der Reihenfolge nach (A)" beschrieben statt. Der Unterschied liegt in der Überprüfung der Bedingungen. Wenn keine Bedingung erfüllt ist, passiert das gleich wie unter (A). Wenn der Thread ausgeführt wird, beginnt anschließend die Schleife von neuem. Je nach Rückgabewert der Thread-Loop-Funktion. Ist der Rückgabewerte "null" oder "false" startet die Schleife die die einzelnen Threads aufruft neu. Wenn der Wert "true" ist, beginnt die Prozedur von neuem.

Das System kann man so verstehen:


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 Moment werden 5 Beispiele mit angeboten. Ich werde die Beispiel in der nächsten Zeit noch sinnvoller gestalten. Im Moment zeigen diese nur, wie man die Funktionen anlegt.

Beispiel Code
Code:
#include <simpleThread.h>  
 
#define _sT_cnt         _sT_cnt_1

simpleThread_init(_sT_cnt ); //init one new thread
simpleThread_new_timebased_static  (_sT_P1  , _sT_millis, 1000    , _sT_start  , Loop_1);


void setup()
{  
  Serial.begin(9600);
  simpleThread_initSetup(_sT_cnt);
}

void loop()
{
  simpleThread_run(_sT_priority);;
}

//global var
uint8_t g_thread_counter = 0;

//new setup for loop_1
void simpleThread_setup(Loop_1)
{
}  
// new loop function for thread loop_1
boolean simpleThread_loop(Loop_1)
{  
  Serial.println(g_thread_counter); // output counter value every 1000 ms    
  g_thread_counter++; // increment counter    
  return false;    
}

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


Pages: 1 ... 15 16 [17] 18 19 ... 39