Multitasking für den Asuro (II)

[Giwo]

Hallo!

Ich habe meinen Asuro letztens aus einer alten Kiste ausgegraben, und beschlossen mal wieder was damit zu machen.

Vor 1 1/2 Jahren etwa hab ich mal ein einfaches Multitasking für den Asuro geschrieben (siehe https://www.roboternetz.de/phpBB2/viewtopic.php?p=87192). Besteht Interesse daran, das ganze mal weiterzuführen und benutzbar zu machen?

Ich werde mal in den nächsten Tagen mein Multitasking mit der etwas angenehmeren AsuroLib 2.61 (siehe http://sourceforge.net/projects/asuro) kombinieren. Dann hat man was zum ausprobieren und spielen.

[EDH]

also multitasking ist allgemein ein sehr interessantes thema. von mir gibts dazu vollste unterstützung.
allerdings frage ich mich ob diese mutitasking aufm asuro dan auch wirklihc von vielein leuten eingesetzt wird. eigentölich lohnt sich so was nur, wenn man die leds gleichzeitig blinken lassen will.
wenn man die sesnoren ausliest, kannn man das eigentlich auhc nacheindander machen,.
auf die nullkommanichts sekunden kommt es dann auch nicht an.

ergo: ein sehr interessantes thema, das beim asuro aber vermutlich keinen wirklichen einsatzzweck funden wird


mfg EDH

[der_andi]

Sicher gibts da nen Sinn dafür, ein extra Task für die Ausgabe beispielsweise, das sind recht Zeitintensive Funktionen.

[EDH]

zugegbeneermasen. aber was will man in der zeit machne, wo er was ausgiebt. vom tisch runterfallen?

[Jon]

aber was will man in der zeit machne, wo er was ausgiebt. vom tisch runterfallen?
Ja, warum nicht. Es ist immer schön, wenn der ASURO irgendwo runterfällt ;)

jon

[der_andi]

Nö, ich denke da eher an einen extra-Thread der ständig diverse Betriebswerte ausliest und ausgibt, Wärenddessen kann der andere Thread ja machen was er will ohne ständig von der scheiß Ausgabe gestört zu werden.

Btw, meine Katze und Tischkanten sind die natürlichen Feinde eines Asuro. Ich denke ich werde irgendwann mal einen Erschütterungssensor anbringen um messen zu können wie hart der Aufschlag war.

[damaltor]

Ich denke ich werde irgendwann mal einen Erschütterungssensor anbringen um messen zu können wie hart der Aufschlag war.

coole idee, dann machen wir hier ne highscore-liste... =)

multitasking finde ic sehr interessant, klingt sehr gut! als von mir aus besteht interesse... =)

[Giwo]

So, ich hab mich in der letzten Woche mal wieder in die ganze Asuro-Materie eingearbeitet, und kleine Verbesserungen an der Multitasking-Bibliothek vorgenommen. Mit der AsuroLib 2.6.1 habe ich mich allerdings noch nicht richtig beschäftigt. Ich habe eben mal bei m_a_r_v_i_n angefragt, ob er Interesse an Multitasking in seiner AsuroLib hat.

Aber hier ist erstmal ein weiteres Testprogramm, das mit der original Asuro-Bibliothek arbeitet. Es lässt den Asuro in Schlangenlinien fahren. Bei einer Kollision weicht er ein Stück zurück. Das ganze habe ich mit 4 Prozessen implementiert. Mehr steht in den Kommentaren am Anfang:


/************************************************** *************************

* *

* This program is free software; you can redistribute it and/or modify *

* it under the terms of the GNU General Public License as published by *

* the Free Software Foundation; either version 2 of the License, or *

* any later version. *

************************************************** *************************/

/************************************************** ************************
* Dieses Programm demonstriert, wie Multitasking zur Robottersteuerung *
* eingesetzt werden kann. Es kommen hier 4 Tasks zum einsatz: *
* *
* debugTask: Gibt Statusmeldungen ueber die IR-Schnittstelle aus. *
* *
* cruiseTask: Faehrt abwechselnd leichte Links- und Rechtskurven. *
* *
* avoidTask: Entzieht cruiseTask nach einer Kollision die Kontrolle, und *
* faehrt ein Stueck nach hinten. *
* *
* MAIN_TASK (hauptprogramm): Koordiniert den Zugriff von cruiseTask und *
* avoidTask auf die Motoren. *
* *
************************************************** ************************/

#include "asuro.h"
#include "task.h"
#include <string.h>

// Einen String ausgeben
void SerWriteString(char *outStr) {
SerWrite(outStr, strlen(outStr));
}

// Eine Zahl ausgeben
void SerWriteInt(int outInt) {
char outStr[8];
itoa(outInt, outStr, 10);
SerWrite(outStr, strlen(outStr));
}

int cruiseLeft, cruiseRight; // Motorgeschwindigkeit, gesetzt von cruiseTask

int avoidLeft, avoidRight; // Motorgeschwindigkeit, gesetzt von avoidTask

int avoidControl; // Will avoidTask die Kontrolle ueber die
// Motoren uebernehmen?

int currentLeft, currentRight; // Momentane Motorgeschwindigkeit

char switches; // Die gedrueckten Taster

//Setzt die Motorgeschwindigkeit. Zulaessige Werte: -255..255 enspricht rueckwerts..vorwaerts
void MyMotorSpeed(int left, int right) {
char left_dir = left >=0 ? FWD : RWD;
char right_dir = right >=0 ? FWD : RWD;
left = left < 0 ? -left : left;
right = right < 0 ? -right : right;

MotorDir(left_dir, right_dir);
MotorSpeed(left, right);
}

//Faehrt abwechselnd leichte Links- und Rechtskurven.
void cruiseTask(void) {
while (1) {
cruiseLeft=180;
cruiseRight=200;
Sleep(72UL*1000); // 1s links herum;
cruiseLeft=200;
cruiseRight=180;
Sleep(72UL*1000); // 1s rechts herum;
}
}

//Entzieht cruiseTask nach einer Kollision die Kontrolle, und faehrt ein Stueck nach hinten.
void avoidTask(void) {
while(1) {
switches = PollSwitch();
if (switches!=0) { // Ein Taster geddueckt?
avoidControl = 1; // Ja: Kontrolle uebernehmen
if ((switches & 0x07) != 0) { // Taster auf der rechten Seite gedrueckt?
avoidLeft = -150; // Ja: nach hinten-links ausweichen
avoidRight = -100;
} else {
avoidLeft = -100; // Sonst: nach hinten-rechts ausweichen
avoidRight = -150;
}
Sleep(72UL*1000); // 1s nach hinten fahren
avoidControl = 0; // Kontrolle wieder an cruiseTask abgeben
}
switchTask();
}
}

//Gibt Statusmeldungen ueber die IR-Schnittstelle aus.
void debugTask(void) {
while(1) {
// Motorgeschwindigkeiten
SerWriteInt(currentLeft);
SerWriteString(" ");
SerWriteInt(currentRight);
SerWriteString(" ");

// Kontrolle
SerWriteInt(avoidControl);
SerWriteString(" ");

// Taster
SerWriteInt(switches);
SerWriteString(" ");

// Wieviel ist noch auf den Stacks frei?
SerWriteInt(freeStackSize(1));
SerWriteString(" ");
SerWriteInt(freeStackSize(2));
SerWriteString(" ");
SerWriteInt(freeStackSize(3));

SerWriteString("\r\n");
Sleep(75UL*100);
}
}


//Koordiniert den Zugriff von cruiseTask und avoidTask auf die Motoren.
int main(void)

{
Init(); /* Asuro initialisieren */
initTask(); /* Task initialisieren */

cruiseLeft=0;
cruiseRight=0;
avoidLeft=0;
avoidRight=0;
avoidControl=0;

// Tasks starten
// Die Stackgroessen wurden experimentell ermittelt. Das kann etwas muesehlig sein,
// denn: Stack zu klein -> absturtz
// und: Stack zu gruss -> absturtz
// Eine Hilfe bietet hier die Funktion freeStackSize, die ermittelt wieviel Platz
// noch auf einem Stack ist. (Siehe debugTask)
addTask(cruiseTask, 128);
addTask(avoidTask, 128);
addTask(debugTask, 330);


while(1) {
if (avoidControl) { // Will avoidTask die Kontrolle haben?
currentLeft=avoidLeft; // Ja: avoidTask bekommt Kontrolle
currentRight=avoidRight;
} else {
currentLeft=cruiseLeft; // sonst: cruiseTask bekommt Kontrolle
currentRight=cruiseRight;
}
MyMotorSpeed(currentLeft, currentRight);
switchTask();
}

return 0;

}



Das ganze funktioniert soweit. Allerdings hat sich herausgestellt, das 1kb Ram recht wenig ist. Die richtigen Stackgrößen für die einzelnen Tasks herauszufinden war etwas Fummelarbeit. Mehr als 4-5 Tasks werden wohl kaum möglich sein.

Das ganze kann man hier runterladen: http://stud.fh-wedel.de/~ii4984/Task.cruise.zip

[freak_ontour]

das is echt ne coole Sache..

biste jetzt schon weiter gekommen???

MFG
Frea_ontour

PS: Frohe Weihnachten gehabt zu haben...