SUMO ASURO ... eine Beschäftigung für Weihnachten

So, jetzt ist es bald wieder so weit. Die Weihnachtszeit steht vor der Tür und damit auch schon wieder ein paar freie Tage, die ich der Kreativität widmen möchte. :Weihnacht

Vor einiger Zeit habe ich einen Sumo- Roboterwettkampf beobachtet und dachte mir, dass wäre doch eine schöne Aufgabe für den Asuro.
Beim SUMO-Wettkampf sind 2 Roboter in einer Arena. Jeder der Roboter soll versuchen, den anderen möglichst schnell aus der Arena zu schieben.

Video: hier finde sich das aktuelle Ergebnis dieses Threads

Ich denke, das wäre ein ganz witzige Aufgabe für 2 ASUROs. Für den Anfang kann man das Ganze mit nur einem ASURO probieren. Der zweite Roboter wird durch Joghurtbecher simuliert.

Dazu habe ich mir mal einen kleines Spielbrett gebastelt ( mit normalem DINA4 Druckerpapier und schwarzem Isolierband )

Um die Joghurtbecher zu erkennen, eignet sich der "wastsche" Abstandssensor.

Wer hat Lust, über die Feiertage zu einem kleinen, entspannten Wettbewerb? :Ostern
Das Ziel könnte sein, die Joghurtbecher möglichst schnell vom Brett zu kriegen.

Falls jeman 2 ASUROs hat, könnte man vielleicht auch das gegnerische Programm hier aus dem Forum posten und dann auf dem eigenen Spielfeld gegeneinander antreten lassen.

das klingt gut. nur würden sich vermutlich die abstandssensoren der beiden asuros gegenseitig völlig aus dem konzept bringen... aber da lässt sich sicher ne lödung finden.

Ich hab meinen Asuro zwar noch nicht, aber vom Grundprinzip her denke ich mir das so:

Asuro fährt einfach gerade aus, bis er an der Begrenzung ist, oder seinen "Gegner" findet.

Wenn er etwas berüht, gibt er Vollgas nach vorne. Sobald der die Linie sieht, fährt er ein Stück rückwärts und eine Kurve. Dann geht das Ganze von vorne los.

Zitat:

---

Ich hab meinen Asuro zwar noch nicht ...

---

Wie schade, den bekommst Du aber sicher an Weihnachten, oder? Allerdings wirst Du dann erst mal eine ganze Weile lang mit Lötarbeiten beschäftigt sein.

Zitat:

---

Asuro fährt einfach gerade aus, bis er an der Begrenzung ist, oder seinen "Gegner" findet.

---

Hier mal ein kleines Testvideo zur Gegnererkennung, bei dem der ASURO nicht gerade ausfährt. Wie man sieht, geht es auch auf kurvigem Wege.

Hallo

Eigentlich ja eine nette Idee, aber wenn ich die asuros so zusammenboxen sehe, tuts mir im Herzen weh. Manche wären froh, wenn ihr asuro endlich richtig funktioniert und ihr wollt ihn als Crashcar missbrauchen. Da gefällt mir die Version asuro vs joghurtbecher doch deutlich besser.

Zitat:

---

Wie schade, den bekommst Du aber sicher an Weihnachten, oder? Allerdings wirst Du dann erst mal eine ganze Weile lang mit Lötarbeiten beschäftigt sein.

---

Vielleicht dann zu Ostern in der Variante: Eierschubsen.

(Das soll nun aber keine Anmeldung meinerseits zum Wettbewerb sein *anmerkt*)

Gruß

mic

Hallo Radbruch,

das mit dem Zusammencrashen ist natürlich ewas hart für die ASUROs, aber man könnte ja auch einen Schaumstoffschutz um den Roboter bauen.

Auf die Idee mit dem ASURO Sumo bin ich durch eine Veranstaltung mit dem ct-Bot gekommen. Es war wirklich begeisternd, zu sehen wie sich die Roboter bewegt haben. Da dachte ich mir, mit dem ASURO müsste das doch auch möglich sein.

Die Kombination aus Abstandsensor und Liniensensor erweitert die Möglcihkeiten des ASURO ungemein. Das ASURO Projekt erschien mir der einfachste Anwendungsfall dafür zu sein.

Ein Wettbewerb ist immer etwas anstrengend, weil man so viel Zeit dafür braucht. Wer also lieber so ein wenig programmiert, kann ja mit ein paar guten Ideen hier beitragen, vielleicht ergibt sich ja eine interessante Diskussion.

Gruß,
robo

@Robo.fr:

Gibts da ein Video über das Sumo ringen der CT Bot´s. Könntest du mir mal den Link schicken, würde mir das gerne mal angugen. Danke

Grüße,

1nDaClu8

Leider habe ich es nur "live" gesehen.

Um zu testen, wie gut man den ASURO mit Hilfe seiner Liniensensoren im Spielfeld halten kann, habe ich ein kleines Testprogramm geschrieben.
Die Auswertung der Liniensensoren reagiert auf die sprungartige Helligkeitsänderung der Liniensensoren. Dazu wird die über einen Tiefpassfilter ermittelte durchschnittliche Helligkeit mit den aktuellen Werten der Sensoren verglichen.

Code:

---

#include "asuro.h" 

#define LIMIT 20        // Helligkeitsveraenderung, bei der eine Linie detektiert wird
#define TIEFPASS 50 // grosser Wert=grosse Zeitkonstante
// globale Variablen
uint16_t HellLinks;
uint16_t HellRechts;
/*************************************************************************

        uint8_t testhell()

        testhell ermittelt die durchschnittliche Helligkeit der beiden
        Linienphottransistoren mit Hilfe eines Tiefpassfilters.
        Unterschreitet die Helligkeit schlagartig den tiefpassgefilterterten
        Wert, wird ein Flag gesetzt.

        Ausgabe:
        testhell=0: keine Linie
        Bit0= Linie links erkannt
        Bit1= Linie rechts erkannt
    Bit0+Bit1 Linie senkrecht


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

uint8_t testhell()
{
        uint8_t ergebnis=0;
        uint16_t lineData[2];

        LineData(lineData);
        HellLinks=(HellLinks*TIEFPASS+lineData[0])/(TIEFPASS+1);
        HellRechts=(HellRechts*TIEFPASS+lineData[1])/(TIEFPASS+1);
        StatusLED(YELLOW);
        if((lineData[0]+LIMIT)<(HellLinks)) ergebnis|=1;       
        if((lineData[1]+LIMIT)<(HellRechts)) ergebnis|=2;
        Msleep(10);
        return ergebnis;
}

int main(void)
{
        int n;

        Init();

        StatusLED(RED);
        FrontLED(ON);

        // mittlere Helligkeit im Stand ermitteln
        for(n=0;n<300;n++)
        {
                testhell();
        }
        StatusLED(YELLOW);

        MotorDir(FWD,FWD);
        MotorSpeed(150,150);
        while(1)
        {
                n=testhell();
               
                BackLED(n&0x01,n&0x02);
                StatusLED(YELLOW);

                if(n!=0) // Falls Linie erkannt, dann drehen und zurück
                {                       
                        StatusLED(GREEN);
                        MotorDir(RWD,RWD);
                        MotorSpeed(150,100);
                        Msleep(600);
                        MotorDir(RWD,FWD);
                        MotorSpeed(200,200);
                        Msleep(600);
                        MotorDir(FWD,FWD);
                        MotorSpeed(150,150);
                }

                Msleep(10);
        }

}
/***************************************************************************
 * 
 *  2007 robo.fr (Nickname) , christoph(at)roboterclub-freiburg.de
 *
 ***************************************************************************
 *  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 version 2 of the License,                *
 *  If you extend the program please maintain the list of authors.        *
 *  ( if there is no real name, the nick name has to be mentioned )
 *  If you want to use this software for commercial purposes and you      *
 *  don't want to make it open source, please contact the authors for    *
 *  licensing.                                                            *
 ***************************************************************************/

---

Wie gut das ganze funktioniert sieht man hier .

und? wie gut klappt es bei dir?

Wie gut das ganze funktioniert sieht man hier .

@damaltor: was macht eigentlich die Bilderekennung in OpenCV für Linux. Wolltest Du nicht das Programm nach Linux portieren?

jaa.. das wollte ich mal probieren. aber im moment habe ich kaum zeit, auch mein asuro der eine art eval board bekommen soll, liegt schon seit wochen zerlegt im schrank. :( aber deoin programm gefällt mir, die idee mit dem tiefpass ist toll.

Bei mir war die Erfahrung, was Projekte angeht, folgende: Alle Projekte immer auf einen funktiionsfähigen Stand bringen, das kostet zwar etwas Anstrengung, vor allen Dingen gegen Ende. Das Leben eines Entwicklers ist nun einmal hart, und zu einem erfolgreichen Projekt gehören nun mal 2 Dinge: Der Spass an der Idee und die Anstrengung und der Schweiß, etwas zu Ende zu bringen. Belohnt wird das ganze mit der Zahl der Projekte auf die man stolz sein kann.

Aber wieder zurück zum SUMO:
Gerade eben habe ich noch eine erweiterte, schwierigere Variante auf Youtube gefunden .
In der Mitte des Feldes wird ein Gegenstand aufgestellt, den die Roboter nicht umwerfen sollten. Dadurch wird die Aufgabe erschwert, wel die Roboter nicht mehr einfach so auf alles zufahren dürfen.

Hallo

Scheint ja prima zu funktionieren. Wenn wir allerdings alle die selben Programme flashen, dürfte es wohl ein Patt geben. Bitte nicht falsch verstehen, ich bin natürlich für OpenSource und finde es prima, wenn ihr Codes für grundsätzliche Lösungen postet. Aber wir sollten auch Alternativen anbieten.

Könnte man das Spielfeld nicht sechseckig machen? Das wäre sehr viel leichter zu konstruieren und zu kleben. Wer's nimmer weiß: Beim Sechseck sind die Seiten so lang wie der Radius des Umkreises...

Bild hier  
(Quelle: wikipedia)

Gruß

mic

Hallo Radbruch,

die ganze Zeit überlege ich schon, ob ein 6-Eck einen Vorteil gegenüber einem 8-Eck hat. Das Bild in meinem ersten Post zeigt das 8-Eck, welches ich für meine Versuche auf zusammengeklebte Din A4-Plätter konstruiert habe. Es war relativ einfach zu erstellen, 4 Seiten sind parallel zur Unterlage und ich habe keinen großen Circel gebraucht.

Eventuell hätte eine kreissymmetrische Spielfläche einen Vorteil, weil dann der Roboter den Mittelpunkt vielleicht besser finden kann.

Gruß,
robo

Hallo robo

Nachdem ich mir nun auf zwei A3-Blättern ein sechseckiges Spielfeld zusammengeklebt habe, bin ich mir auch nicht mehr sicher, ob es wirklich bedeutend einfacher als ein Achteck ist. Klassisch konstruiert mit Schnur und Stift ist es zwar schnell, aber beim Kleben der schwarzen Streifen habe ich dann festgestellt, dass man sich dabei auch gut an den Blatträndern orientieren kann und deshalb dürfte ein Achteck auch einfach zu kleben sein.

Vielleicht könnte mein asuro bei meinem Spielfeld die Mitte leichter finden, weil die Winkel der Klebestreifen größer sind und man sie deshalb leichter finden könnte als beim Achteck. Aber ob das für die gestellte Aufgabe (suche den Becher und schiebe ihn raus) einen Vorteil bringt, wage ich zu bezweifeln.

Dein Linienerkennungsprogramm läuft mit meinem asuro auch sehr gut. Da ich aber als FrontLED eine IR-LED aus einer alten Fernbedienung eingebaut habe, musste ich den Wert für Limit auf 200 erhöhen und wegen meiner kürzeren Endübersetzung die Geschwindigkeit etwas anpassen. Blöderweise läuft grad mein linker Motor nicht zurück, ich muss also leider erstmal den Fehler suchen bevor ich mich richtig draufstürzen kann.

Gruß

mic

Hallo radbruch,

wie gehts dem ASURO Motortreiber? Laufen die Motoren schon wieder?

Zitat:

---

Dein Linienerkennungsprogramm läuft mit meinem asuro auch sehr gut. Da ich aber als FrontLED eine IR-LED aus einer alten Fernbedienung eingebaut habe, musste ich den Wert für Limit auf 200

---

Den Programmcode habe ich extra auf die Verhältnisse des Standard des Originalasuro angepasst. In einem meiner zwei ASUROs ist eine 24000mcd superhelle rote LED eingebaut. Dort muss der Wert auch auf 200 erhöht werden. Die Grenzlinienerkennung wird dadurch natürlich um noch einiges stabiler.
Vielleicht hat die ultrahelle, roten LED einen Vorteil weil man sehen kann, ob sie eingeschaltet sind und das Infrortliche eventuell den IR-Empfänger für die Abstandmessung stören könnte.


Im Moment beschäftige ich mich ein wenig mit der Zielfindung über den IR-Abstandsmesser. Gar nicht so einfach.

Ich habe eine kleine Funktion geschrieben, mit der grob der Abstand ermittelt werden kann, in dem die Pulsweite durchge"sweept" wird.
Waste hat das schon mal gemacht ( glaube ich ) aber ich konnte es auf die schnelle nicht finden

Code:

---

uint8_t abstand()
{
        uint8_t k=FALSE,n;
        uint16_t j,z;

        for(n=1;n<10;n++)
        {
      OCR2  = 254-n;  //OCR2=0xFE ( sehr nahe )
      Msleep(2);
          z=0;
          for(j=0;j<1000;j++) if (PIND & (1 << PD0))z++;
          if (z>900) k=n;
        }
        if(k==9) k=FALSE; // Falls Abstand größer 10 Abstand=FALSE
        return k;
}

---

Hallo robo.fr

Wie du ja weißt habe ich mit der IR-Abstandsmessung auch schon gespielt. Letztlich habe ich dann einen mit Folie beschichteten "Reflektor" gebastelt und ihn unter den Kabelbinder des Motors geklemmt:

Bild hier  

Und noch ein Video dazu:
Bild hier  
http://www.youtube.com/watch?v=6-5pah_oQUw

Ganz wichtig dabei ist ein lichtdichtes Irgendwas (Karton, Folie, aufgeschnittener Schrumpfschlauch...) zwischen den IR-Empfänger und die Platine zu klemmen und es seitlich hoch zwischen Empfänger und IR-LED zu biegen um "Kriechlicht" zu verhindern!

Der "Rüssel" auf der IR-LED besteht aus mehreren Lichtwellenleitern (ca. 1€/Meter) in einem Schrumpfschlauch und dient der Bündelung des Lichtstrahls. Es funktioniert aber auch ohne recht gut, aber nicht so scharfkantig.

Hier noch der Code MIT Kantensuchen (ich hoffe, er funktioniert noch):

Code:

---

/* asuro haelt mittels IR-Messung vorgewaehlten
        Abstand zu einem Gegenstand und richtet sich dabei nach einer Kante aus.

        14.2.2007 mic
*/

#include "asuro.h" // Version mit dutycycles und TOIE2 in Init() (ab ca. v2.5)

unsigned char i, ir_bits, dist, dir_l, dir_r;  // zaehler, bitzaehler, abstand, richtungen
unsigned int bitspeicher, delay; // filter, rythmus

int main(void)
{

        Init();

        MotorDir(FREE,FREE); // Stillstand vorbelegen
        MotorSpeed(150,150); // je mehr desto hektisch
  bitspeicher = 1; // 16 Bits Filter für IR-Echos
  dist=240; // Sollabstand (zw. 0x90 und ca.250, je groesser desto nah)
  delay=Gettime(); // Rythmus fuers Kantensuchen

        while (1) {
       
        // vor und zurueck
       
                DDRD |= (1 << DDD1); // IR-LED an
                PORTD &= ~(1 << PD1);
                OCR2 = dist; // gewuenschter Abstand
                bitspeicher = bitspeicher*2+(PIND & (1 << PD0));
                ir_bits=0;  // bei diesem Abstand soll auf 2 von 8 Nicht-Echos gefahren werden
                for (i=0; i<8; i++) if (bitspeicher & (1 << i)) ir_bits++; // letzte 8 Echos
                dir_l=dir_r=FREE;
                if (ir_bits > 4 ) dir_l = dir_r = FWD; // mehr als zweimal kein Echo = zu weit
                if (ir_bits < 2 ) dir_l = dir_r = RWD; // weniger als zwei Nicht-Echos = zu nah
                MotorDir(dir_l,dir_r);  // Abstand korrigieren
                if (Gettime() >= delay) {  // mehr als eine Sekunde seit dem letzen Suchen der Kante
        // nach links drehen bis kein Echo mehr kommt

                if ((dir_l) == (FWD)) {  // bei Vorwaertsfahrt
                        dir_l = FREE; dir_r = FWD;
                } else if ((dir_l) == (RWD)) {  // bei Rueckwaertsfahrt
                        dir_l = RWD; dir_r = FREE;
                } else { dir_l=FWD; dir_r=RWD; }; // im Stillstand
                MotorDir(dir_l,dir_r);
                //MotorDir(RWD,FWD);
                DDRD |= (1 << DDD1); // IR-LED an
                PORTD &= ~(1 << PD1);
                OCR2 = 0x90; // maximale Distanz
        do {
                bitspeicher = bitspeicher*2+(PIND & (1 << PD0)); // Bitspeicher fuellen
                ir_bits=0;
                for (i=0; i<16; i++) if (bitspeicher & (1 << i)) ir_bits++;
        } while (ir_bits < 15); // alle Bits gesetzt bedeutet keine Echo = Kante ueberfahren

        // rechts drehen und mit Soll-Distanz nach Echo suchen (sicherheitshalber mehrfach!)

                if ((dir_l) == (FREE)) {  // abhaengig von verwendeter Methode zurückschwenken
                        dir_l = FWD; dir_r = FREE;
                } else if ((dir_r) == (FREE)) {
                        dir_l = FREE; dir_r = RWD;
                } else { dir_l=RWD; dir_r=FWD; };
                MotorDir(dir_l,dir_r);
                //MotorDir(FWD,RWD);
                DDRD |= (1 << DDD1); // IR-LED an
                PORTD &= ~(1 << PD1);
                OCR2 = dist; // Messdistanz laden
        for (i=0; i<10; i++) { //mehrfach pruefen und gegebenfalls fahren um die Kante sicher zu finden
                bitspeicher=1; // alle Bits geloescht bedeutet volles Echo = Kante wiedergefunden
                do  bitspeicher = bitspeicher*2+(PIND & (1 << PD0)); while (bitspeicher != 0);
          //for (bitspeicher=1; bitspeicher != 0; bitspeicher*2+(PIND & (1 << PD0)));
        }
        if (((dir_l) != (FREE)) && ((dir_r) != (FREE))) MotorDir(FREE,FREE); // anhalten oder durchstarten
        //MotorDir(FREE,FREE);
        delay=Gettime()+500; // einmal pro Sekunde die Kante suchen
                }
        } // endloss

while(1); return 0;
}

---

Der asuro hält den vorgegebenen Abstand zum Blatt und richtet sich nach der linken Blattkante aus. Die IR-Echos werden gefiltert und erst nach einer festgelegten Anzahl von Echos/Nichtechos wird reagiert. Achtung, die verwendete asuro-Lib muss die IR-Erweiterung nach Waste enthalten und den Timer zur IR-Pulserzeugung folgendermaßen Initialisieren:

Code:

---

        //-------- seriell interface programmed in boot routine and already running -------
        //  prepare 36kHz for IR - Communication
        TCCR2 = (1 << WGM20) | (1 << WGM21) | (1 << COM20) | (1 << COM21) | (1 << CS20);
        OCR2  = 0x91; // duty cycle for 36kHz
        TIMSK |= (1 << TOIE2); // 36kHz counter for sleep

---

(aus Init() in asuro.c ab ca. 2.5)

Wenn man OCR2 ändert, kann man nicht mehr per IR mit dem Terminal kommunizieren, weil die 36kHz-Trägerfrequenz nicht mehr stimmt. Zuvor muss man wieder den Defaultwert (OCR2 = 0x91) wieder laden.

Zitat:

---

wie gehts dem ASURO Motortreiber? Laufen die Motoren schon wieder?

---

Er ist leider immer noch "krank", ich hatte noch keine Zeit danach zu schauen.

Gruß

mic

Zitat:

---

Er ist leider immer noch "krank", ich hatte noch keine Zeit danach zu schauen.

---

Oh, sehr schade, der arme ASURO. [-o< Und das an Weihnachten. :Weihnacht

Mittlerweile habe ich auch neue Versuche unternommen, den ASURO so zu programmieren, dass er einen Joghurtbecher besser finden kann.


Aber ich bin immer noch etwas neidisch auf das Video von waste ( ich nehme mal an, dass es von waste ist ). Der ASURO ruckelt da relativ wenig. Daher vermute ich, dass der ASURO eher 2 IR Sensoren verwendet. Aber leider sieht man das auf dem Video so schlecht.

Ich frage nicht einen richtigen Reglerentwurf für das Problem machen könnte. Dazu müsste man aber eine passende Struktur finden :-k

Nach doch etwas mehr Auwand als ursprünglich gedacht, spielen 2 ASUROs in der Sumo-Arena miteinander: O:)

http://www.youtube.com/v/LkEv21QNzsY

Was haltet Ihr davon?

Hallo robo.fr
Ich hab ein Problem mit den einen Programm womit der Asuro im Achteck(Sechseck) bleibt und zwar kent Mein program die funkion "Msleep Nicht"
die Fehlermeldung sieht Folgenermasen aus: C:\ASURO_src\FirstTry/test.C:71:undefined reference to `Msleep'
C:\ASURO_src\FirstTry/test.C:74:undefined reference to `Msleep'
C:\ASURO_src\FirstTry/test.C:79:undefined reference to `Msleep'
Ich wäre dankbar wen einer mir helfen Könnte

Gruß
Chief 2

Hallo

Msleep() und andere Funktionen gibt es erst in den neueren Versionen von asuro.c:

http://sourceforge.net/project/showf...age_id=172835#

Ab Version 2.7 wird's extrem kompliziert und man entfernt sich zunehmend von der Hardware (auch wenn mich wohl einige schlagen wollen, wenn ich das behaupte). Hier das Chancelog der Version 2.61:

Code:

---

ASURO Library Versions History
==============================

Version 2.6.1
=============

- 20.11.2006 Bugfixes: (Autor: m.a.r.v.i.n)
            * PrinInt Funktion: evtl. Fehler beim Flashen mit RS232/IR Transceiver,
              wg. Folge von 0-Bytes im erzeugten Hex-File.
              Bug tracking von francesco
            * SIGNAL (SIG_ADC): static Variable toggle initialisiert
              Bugtacking von Rolf_Ebert
            Warnings entfernt wg. obsolete Header File bei neueren WinAVR Versionen.

Version 2.6
===========

- 28.09.2005 Doxygen Kommentare. (Autor: m.a.r.v.i.n)

Version 2.5
===========

- 31.07.2005 Turn() Funktion mit speed Parameter. (Autor: Andun)
 
Version 2.4
===========

- 30.07.2005 Erweiterungen, Go() und Turn() Funktionen. (Autoren: stochri, Andun)

Version 2.3
===========

- 10.06.2005 Anpassungen wg. Umbau der Infrarot Schnittstelle als Kollisionsdetektor (Autor: waste)
 
        count36kHz ersetzt count72kHz. Timer2 geändert. 
       

Version 2.2
===========

- 31.03.2005 Erweiterte Funktionen (Autor: weja - Robotrixer Buxtehude)

        Kurzbeschreibung der Funktionen in der neuen asuro.h, asuro.c vom 31.03.05



        Leider konnten die neuen Funktionen nicht mehr in einer Extradatei untergebracht
        werden, weil mehrere "alte" Funktionen verändert wurden, damit z.B. die Systemzeit
        integriert werden konnte. Auch wurde die PollSwitch Funktion vom Ballast der Fließkomma-
        berechnung befreit. Nun ist wieder mehr Platz für eigenen Code vorhanden.





                                Encoder_Init()

        Dieser Befehl installiert die Interrupt Funktion für den automatischen Wegzähler.
       
                                Encoder_Start()
                               
        Startet die automatische Zählung nach
       
                                Encoder_Stop()
                               
        neu. Diese Stopp Funktion hält den Zähler an
       
                                Encoder_Set(int,int)
                               
        Setzt die Variablen encoder[0] und encoder[1]. Z.B.: Encoder_Set(0,0) setzt beide
        Variablen auf Null.
       
                                switches
                               
        ist eine Variable, die, wenn Startswitch() gestartet wurde, auf wahr gesetzt wird,
        sobald eine Taste gedrückt wurde. gleichzeitig wird die Tastenüberwachung wieder
        abgeschaltet. Beispiel:
        Start_Switch();
        while (!switches){;} //wartet auf Tastendruck
        // an dieser Stelle kann mit Pollswitch geprüft werden
        // welche Taste gedrückt wurde, wenn nötig.
        switches=FALSE;  // für eine neuen Aufruf von Startswitch()
       
                                Msleep(int)
                               
        wartet die angegebene Zeit in ms. Z.B warte 10 Sekunden: Msleep(10000);
       
                                Gettime()
                               
        Gibt die Zeit, die seit dem letzten Start des Asuro vergangen ist als unsigned long zurück.
        Die Angabe erfolgt auch hier in Millisekunden.
       
                                PrintInt(int)
                               
        Eine kleine Ausgabehilfe für Integerwerte.
        Beispiel Zeilenweise Ausgabe der encoder Werte:
        PrintInt(encoder[0]);SerWrite("  ",3);PrintInt(encoder[1]);SerWrite("\n\r",2);
       

        31.03.05                                                                          Robotrixer Buxtehude

Version 2.1
===========

- 10.11.2003 Original Version von der ASURO CD (Autor: Jan Grewe - DLR)

---

Ich verwende v2.3

Gruß

mic

hast du die lib aus dem forum oder welche

mfg liggi

Hallo Radbruch
Wo soll ich den die dateien hintun
Hallo Liggi
Ich habe noch die lib Die bei den WinAVR-20071221 dabei war

Die Dateien muss man da hintun wo die alten sind. Sie ersetzen asuro.h und asuro.c

Wenn du nicht weißt, wo die sind, unter Windows kann man auch Dateien suchen: Start->Suchen->Nach Dateien und Ordern

und dann asuro.* eingeben.

Die asuro-Library ist nicht Teil von WinAVR sondern gehört zur Doku des asuros. Deshalb wird sie wohl in dem Ordner sein indem sich auch eure selbstgeschriebenen asuro-Programme befinden. Deshalb werden sie auch mit #include "asuro.h" eingebunden. "" bedeutet im selben Verzeichniss wie das Programm.

Gruß

mic

Wen ich die dateien Asuro.h/c eingebe findet er die nur im first try ordner und wen ich die da ändere dan geht ganix mehr also hab ich wieder die normalen asuro,c/h da hingemac

Gruß
Chief 2

Na, wenn du nur die findest, werden es wohl die richtigen sein. Und wenn du die änderst und danach "dann geht garnix mehr" ist, sind sie es bestimmt. Was bedeutet denn "dann geht garnix mehr"?

Um es etwas abzukürzen: Welche Version hast du runtergeladen? Hast du die Dateien entpackt? Hast du beide Dateien (h+c) ersetzt? Welche Fehlermeldungen hast du jetzt?

Gruß

mic

ich habe die version 2.7.1 heruntergeladen und entpakt und dan beide tateien Asuro.c Asuro.h dursch die neuen ersetz und dan war als ich die datai mit der make finkion compiliren wollte standden da nur fehlermeldung
Gruß
Chief 2

Die Funkion "Msleep,MotorDir" und andere wie das das sind doch alle variablen oder?

Nein, es sind Funktionen. Hier hast du die Kopie von Msleep():

Code:

---

void Msleep(int dauer)
{
        int z;
        for(z=0;z<dauer;z++) Sleep(72);
}

---

(aus asuro.c)

Kopieren und in deinem Programm einfügen, dann kannst du es vermutlich mit den orginalen asuro.c/.h komplilieren.

Ich dachte, du willst den asuro programmieren. Wenn du aber lieber lernen willst, wie man die 2.7er-Lib installiert, kannst du es hier nachlesen:

https://www.roboternetz.de/phpBB2/ze...ag.php?t=26594

mic

Ich hab das jetz anstelle des Msleepeingesetz abber dann steht da 4 mal
Test.c:**: error: expected ':', ','or ')' before numerik constant

Und wen Ich Diesen Error anklicken fürt der mich immer in die zeile die den error verusacht und das ist die zeile mit:
void Msleep(int dauer)
Gruß
Chief

Da hast du irgendwo noch ein : oder ein , oder eine ) vergessen. Poste doch mal den Bereich mit ein paar Zeilen davor und danach. Oder gleich alles...

Gruß

mic

Ok :

Code:

---

#include "asuro.h" 

#define LIMIT 20  // Helligkeitsveraenderung, bei der eine Linie detektiert wird
#define TIEFPASS 50 // grosser Wert=grosse Zeitkonstante
// globale Variablen
uint16_t HellLinks;
uint16_t HellRechts;
/*************************************************************************

  uint8_t testhell()

  testhell ermittelt die durchschnittliche Helligkeit der beiden
  Linienphottransistoren mit Hilfe eines Tiefpassfilters.
  Unterschreitet die Helligkeit schlagartig den tiefpassgefilterterten
  Wert, wird ein Flag gesetzt.

  Ausgabe:
  testhell=0: keine Linie
  Bit0= Linie links erkannt
  Bit1= Linie rechts erkannt
    Bit0+Bit1 Linie senkrecht


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

uint8_t testhell()
{
  uint8_t ergebnis=0;
  uint16_t lineData[2];

  LineData(lineData);
  HellLinks=(HellLinks*TIEFPASS+lineData[0])/(TIEFPASS+1);
  HellRechts=(HellRechts*TIEFPASS+lineData[1])/(TIEFPASS+1);
  StatusLED(YELLOW);
  if((lineData[0]+LIMIT)<(HellLinks)) ergebnis|=1;   
  if((lineData[1]+LIMIT)<(HellRechts)) ergebnis|=2;
  void Msleep(int 10);
{
  int z;
  for(z=0;z<10;z++) Sleep(72);
}
  return ergebnis;
}

int main(void)
{
  int n;

  Init();

  StatusLED(RED);
  FrontLED(ON);

  // mittlere Helligkeit im Stand ermitteln
  for(n=0;n<300;n++)
  {
      testhell();
  }
  StatusLED(YELLOW);

  MotorDir(FWD,FWD);
  MotorSpeed(150,150);
  while(1)
  {
      n=testhell();
     
      BackLED(n&0x01,n&0x02);
      StatusLED(YELLOW);

      if(n!=0) // Falls Linie erkannt, dann drehen und zurück
      {         
        StatusLED(GREEN);
        MotorDir(RWD,RWD);
        MotorSpeed(150,100);
        void Msleep(int 600);
{
  int z;
  for(z=0;z<600;z++) Sleep(72);
}
        MotorDir(RWD,FWD);
        MotorSpeed(200,200);
        void Msleep(int 600);
{
  int z;
  for(z=0;z<600;z++) Sleep(72);
}
        MotorDir(FWD,FWD);
        MotorSpeed(150,150);
      }

      void Msleep(int 10)
{
  int z;
  for(z=0;z<10;z++) Sleep(72);
}
  }

}
/***************************************************************************
 *   
 *  2007 robo.fr (Nickname) , christoph(at)roboterclub-freiburg.de
 *
 ***************************************************************************
 *  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 version 2 of the License,                *
 *  If you extend the program please maintain the list of authors.        *
 *  ( if there is no real name, the nick name has to be mentioned )
 *  If you want to use this software for commercial purposes and you      *
 *  don't want to make it open source, please contact the authors for    *
 *  licensing.                                                            *
 ***************************************************************************/

---

Code:

---

#include "asuro.h"

#define LIMIT 20 // Helligkeitsveraenderung, bei der eine Linie detektiert wird
#define TIEFPASS 50 // grosser Wert=grosse Zeitkonstante
// globale Variablen
uint16_t HellLinks;
uint16_t HellRechts;
/*************************************************************************

uint8_t testhell()

testhell ermittelt die durchschnittliche Helligkeit der beiden
Linienphottransistoren mit Hilfe eines Tiefpassfilters.
Unterschreitet die Helligkeit schlagartig den tiefpassgefilterterten
Wert, wird ein Flag gesetzt.

Ausgabe:
testhell=0: keine Linie
Bit0= Linie links erkannt
Bit1= Linie rechts erkannt
Bit0+Bit1 Linie senkrecht


*************************************************************************/
void Msleep(int dauer)
{
        int z;
        for(z=0;z<dauer;z++) Sleep(72);
}
/*************************************************************************/
unsigned char testhell(void)
{
        uint8_t ergebnis=0;
        uint16_t lineData[2];

        LineData(lineData);
        HellLinks=(HellLinks*TIEFPASS+lineData[0])/(TIEFPASS+1);
        HellRechts=(HellRechts*TIEFPASS+lineData[1])/(TIEFPASS+1);
        StatusLED(YELLOW);
        if((lineData[0]+LIMIT)<(HellLinks)) ergebnis|=1;
        if((lineData[1]+LIMIT)<(HellRechts)) ergebnis|=2;

        Msleep(10);
        return ergebnis;
}

int main(void)
{
        int n;

        Init();

        StatusLED(RED);
        FrontLED(ON);

        // mittlere Helligkeit im Stand ermitteln
        for(n=0;n<300;n++)
        {
                testhell();
        }
        StatusLED(YELLOW);

        MotorDir(FWD,FWD);
        MotorSpeed(150,150);
        while(1)
        {
                n=testhell();

                BackLED(n&0x01,n&0x02);
                StatusLED(YELLOW);

                if(n!=0) // Falls Linie erkannt, dann drehen und zurück
                {
                        StatusLED(GREEN);
                        MotorDir(RWD,RWD);
                        MotorSpeed(150,100);

                        Msleep(600);

                        MotorDir(RWD,FWD);
                        MotorSpeed(200,200);

                        Msleep(600);

                        MotorDir(FWD,FWD);
                        MotorSpeed(150,150);
                }

                Msleep(10);
        }
        return(0);
}
/***************************************************************************
*
* 2007 robo.fr (Nickname) , christoph(at)roboterclub-freiburg.de
*
***************************************************************************
* 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 version 2 of the License, *
* If you extend the program please maintain the list of authors. *
* ( if there is no real name, the nick name has to be mentioned )
* If you want to use this software for commercial purposes and you *
* don't want to make it open source, please contact the authors for *
* licensing. *
***************************************************************************/

---

Ich hoffe, es funzt jetzt.

mic

Danke es hat endlich funkionirt ich danke dir Für deine Große hilfe

Gruß
Chief 2

Hallo Chief2,

damit das Ganze etwas einfacher wird, habe ich an dieser Stelle ein HEX-File abgelegt, damit man die Abstandserkennung sofort ausprobieren kann.

Gruß,
robo

Hallo Robo.fr
Danke Für das Programm Ich werd es sofort ausprobieren

Gruß Chief 2

Hallo alle zusammen
ich hab mir so ein programm machen wollen das der asuro die becher aus dem ring schiebt abber das programm meldet immer den fehler:
"test.c:207:error:expectet Identifiter or '(' before '{' token"
wen ich es kompilieren möchete
Hir ist das ProgrammDie zeile wo angeblich der Fehler liegt ist mit einen/***<<<***/makiert

Code:

---

#include "asuro.h"
#include <stdlib.h>
#define LIMIT 20 // Helligkeitsveraenderung, bei der eine Linie detektiert wird
#define TIEFPASS 50 // grosser Wert=grosse Zeitkonstante
// globale Variablen
uint16_t HellLinks;
uint16_t HellRechts;
 
void Msleep(int dauer)
{
  int z;
  for(z=0;z<dauer;z++) Sleep(72);
}

unsigned char testhell(void)
{
  uint8_t ergebnis=0;
  uint16_t lineData[2];

  LineData(lineData);
  HellLinks=(HellLinks*TIEFPASS+lineData[0])/(TIEFPASS+1);
  HellRechts=(HellRechts*TIEFPASS+lineData[1])/(TIEFPASS+1);
  StatusLED(YELLOW);
  if((lineData[0]+LIMIT)<(HellLinks)) ergebnis|=1;
  if((lineData[1]+LIMIT)<(HellRechts)) ergebnis|=2;

  Msleep(10);
  return ergebnis;
}

int main(void)
{
  int n;

  Init();

  StatusLED(RED);
  FrontLED(ON);

  // mittlere Helligkeit im Stand ermitteln
  for(n=0;n<300;n++)
  {
      testhell();
  }
  StatusLED(YELLOW);

  MotorDir(FWD,FWD);
  MotorSpeed(150,150);
  while(1)
  {
      n=testhell();

      BackLED(n&0x01,n&0x02);
      StatusLED(YELLOW);

      if(n!=0) // Falls Linie erkannt, dann drehen und zurück
      {
        StatusLED(GREEN);
        MotorDir(RWD,RWD);
        MotorSpeed(150,100);

        Msleep(600);

        MotorDir(RWD,FWD);
        MotorSpeed(200,200);

        Msleep(600);

        MotorDir(FWD,FWD);
        MotorSpeed(150,150);
      }

      Msleep(10);
  }
  return(0);
}

uint8_t objekt_sichtbar(uint8_t distance)
{
        uint16_t j,z;
       
          DDRD |= (1 << DDD1);  // Port D1 als Ausgang
          PORTD &= ~(1 << PD1);  // PD1 auf LOW

        OCR2  = 254-distance;  // wenn OCR2=0xFE dann Objekt sehr nahe
        z=0;
        for(j=0;j<30;j++); // loop time: 5ms
        {
                if (PIND & (1 << PD0))z++;
                Sleep(6); // 6*Sleep(6)=1ms
        }
        if (z>=29) return FALSE; // Objekt nicht gefunden
        else return TRUE;
}
{
        uint8_t k,n;                    /***<<<***/                    /***<<<***/                        /***<<<***/
       
        k=255;
        for(n=0;n<8;n++)
        {
        if (!objekt_sichtbar(n)) k=n; // solange kein Objekt, Distanz erhoehen
        } 
        return k;

          uint8_t n;
 
          Init();

          while(1)
        {
                  n=abstand();
                StatusLED(OFF);
                  BackLED(OFF,OFF);
                         
                if(n!=255)
                  {
                          if (n<6) MotorDir (FWD,FWD);MotorSpeed(220,220);
                          if (n<4) MotorDir (FWD,FWD);MotorSpeed(220,220);
                          if (n<3) MotorDir (FWD,FWD);MotorSpeed(220,220);
                          if (n<2) MotorDir (FWD,FWD);MotorSpeed(220,220);
                        Msleep(10);
                }
        }
}

---

habe deinen doppelpost entfernt. bitte nur einmal klicken und dann warten!!

du schliesst die funktion uint8_t objekt_sichtbar() mit einer schliessenden klammer }. danach öffnest du weider eine klammer { ohne einen funktionsnamen zu definieren.