ASURO Dunkel-Hell-Kantenverfolgung

Hallo zusammen,

ich bin neu hier und hätte auch erst mal eine Riesenbitte an euch!
Nächste Woche muss ich an der Uni im Rahmen eines Mechatronik-Lehrganges mit dem ASURO arbeiten.
Leider habe ich keinerlei Zugang zum Roboter, noch habe ich umfangreiche C Kenntnisse.

Natürlich habe ich mich eingelesen, und ich habe natürlich auch eine Idee, wie das zu machen ist, allerdings mangelt es dann an den Programmierkenntnissen und daran, dass ich keinen ASURO habe.

Die Aufgabe lautet genau:
"Entwerfen Sie ein Verfahren, um mit Hilfe der Liniensensoren eine Hell-Dunkel-Kante (keine dünne dunkle Linie) zu verfolgen. Erstellen Sie hierfür ein geeignetes C-Programm."

Da ich gesehen habe wie billig der ASURO ist, werd ich mir den auch zulegen, aber das klappt bis nächste Woche ja leider nicht mehr.

Meine Idee bis jetzt (wie man das dann programmiert...keine Ahnung)
Die 2 Liniensensoren fahren auf 2 versch. Unterlagen.
Der rechte meinetwegen auf weiß, der linke auf schwarz.
Also müssen auch die Sensorwerte verschieden sein.
LineData[1] (der linke) so um die 600? und LineData[2] (der rechte) so um die 100?
Das wars ja eigentlich denke ich...Motoransteuerung und so einfach konstante Geschwindigkeit(?)

Achja, desweiteren soll man Umgebungslicht kompensieren.
Meine Idee war da bis jetzt, dass man 2 Unterlagenmessungen (Schwarz,Weiß) mit der FrontLED macht. Die LineData Werte müssten zB auf Weiß mit und ohne LED immer einen konstanten Differenz-Wert haben.
Denke ich zumindest, ob das stimmt weiss ich natürlich wieder nicht.
Vielleicht könnt ihr mir da weiterhelfen??

Ich weiss dass ich ziemlich viel fordere, aber nicht wirklich viel biete, ausser meinen bescheidenen Ideen.
Aber da euch das hoffentlich Spaß macht, ASURO zu "beleben", hoffe ich auch dass ihr mir aus meiner Zwickmühle raushelfen könnt!!

Gebt einfach mal euren Input an mich. Wäre echt nett!!

Liebe Grüße

ich glaube, du solltest mal die suchfunktion benutzen. da gibts schon was...

Jo hallo :)

Ich habe die Suchfunktion schon benutzt, aber leider finde ich nur was zur Linienverfolgung und den "Trick" wie man das bereits mitgelieferte Linienverfolgungsprogramm ausnutzen kann um Kanten zu verfolgen, was allerdings nur bei best. Anordnung der Hell-Dunkel Bereiche funktioniert.
Und ich denke das geht bestimmt noch anders.
Habe übrigens gerade einen ASURO bei Ebay ersteigert für 28,78€
Aber bis zum Montag bekomme ich den eh nicht mehr, und am Dienstag muss ich das Projekt vorstellen :(

Greift mir doch unter die Arme ;) (ich weiss, das ist schon ziemlich viel was ich da verlange!! )

Wünsche euch ein schönes WOchenende!

du hast schon recht, es macht spaß den kleinen zu beleben... aber fertige codes zu posten ist nicht der sinn des forums.

was hast du denn für ideen, wie könnte man das problem angehen?

Naja also wie gesagt, meine Grundideen habe ich ja in meinem ersten Post genannt.

1) Ich weiss der ASURO hat 2 Liniensensoren. Einen mehr links und einen mehr rechts an der Unterseite (Weiss nicht so genau wo sich die befinden).
Das heisst, wenn der ASURO einer Scharz-Weiß-Kante folgen soll, muss ein Sensor immer nur Schwarz und ein Sensor immer nur Weiß anzeigen!
Falls meinetwegen der rechte Sensor aber nicht Weiß, sondern auch Schwarz anzeigt, dann soll er so lange nach rechts fahren, bis er wieder beide Farben an den Sensoren anzeigt.
Ich denke das ist euch klarer als mir, dass das Gedankenkonstrukt sehr einfach ist, das zu programmieren um einiges schwerer ist, vor allem wenn man von C noch gar keine rechte Ahnung hat.

2) Das mit dem Umgebungslicht hat sich anscheinend so bewahrheitet wie ich mir das gedacht habe. 2 Messungen des Unterbodens einmal mit LED und einmal ohne ergibt das reflektierte Licht, wenn man von den Messungen die Differenz bildet. Ein Code dafür war auch hier im Forum zu finden.

Zu 1. würde ich das eigentlich versuchen, analog zum LineTest zu programmieren. Also die Sensoren scannen lassen, Daten einlesen, mit Referenzwerten für Weiss und Schwarz abgleichen, und dann dementsprechend die Motoren ansteueren, um Abkurs auszugleichen.

Klar ist es Schei*e (sorry ;) ) fertige Codes zu nutzen, aber es muss ja nicht perfekt funktionieren (hoffe ich zumindest).
Deshalb hoffe ich ihr könnt mir schnell (für euch wahrscheinlich schnell weil iihr wisst in welche Richtung es geht und was ihr tun müsst) ein kleines Programm schreiben. Es wäre wirlkich dringend :( Oder halt nur ein Grundgerüst oder sowas?

So, ich wünsche euch ein schönes Wochenende!! :)

EDIT:
Da fällt mir gerade ein, wenn ich das bei 1. so machen würde wie oben genannt, dann könnte der ASURO der Linie ja nur folgen wenn auch wirklich die bestimmte Farbe zB Weiß rechts ist. So sollte das aber nicht sein, weil es eigentlich egal sein sollte, wie die Farben gelegen sind.
Deshalb meine Idee jetz grade, wenn die Liniensensoren abtasten mit LED und ohne, dann ergibt sich ja die besagt Differenz. Für Weiß-Schwarz muss das ja ein best. Wert sein...kA vielleicht 200 oder so.
Dann könnte ich doch ASURO sagen, er soll so lange rumfahren, bis er eine "Farbdifferenz" von ~200 findet. Wie man das natürlich wieder programmiert..... 8-[

startet der roboter auf der kante? oder daneben? wenn er daraufsteht dann kann er am start versuchen zu erkennen ob links oder rechts schwarz ist.

....vor allem wenn man von C noch gar keine rechte Ahnung hat.....

die meisten machen vom asuro eh "copy" und "paste", weil das datenblatt vom avr8 nicht gelesen wird und das winavr-c schlechthin kennen.

hier kannst du sehen was winavr-c heißt :

http://www.mikrocontroller.net/forum/2

und die beißen sich ganz schön die zähne aus die studies. es ist nicht einfach zu proggen.

Zitat:

Zitat von damaltor

startet der roboter auf der kante? oder daneben? wenn er daraufsteht dann kann er am start versuchen zu erkennen ob links oder rechts schwarz ist.

Hey Damaltor,
also da in meiner Aufgabenstellung nichts drin steht, nehme ich den einfacheren Fall an...der Asuro steht also bereits auf der Kante.
Das heisst doch also, wenn der schon drauf steht, und ich scanne, dann ist LineData[0] (zB Weiß mit dem Digitalwert der quantisierten Fototransistorspannung gefüllt, so ca. 600?) und LineData[1] müsste dann für schwarz so etwa 200 haben?
Folglich muss man in einer while Schleife die Anweisung geben, so lange mit gleicher Geschwindigkeit weiter zu fahren, bis der Wert eines Sensors nicht mehr im Toleranzbereich liegt. Für Weiß würde das doch heissen: weiter rechts lenken, wenn zu viel schwarz auf dem rechten Liniensensor! Aber wie genau macht man das? Man hat doch nur die Möglichkeit mehr SPeed am rechten bzw linken Antrieb zu geben?! Ich will aber eigentlich dass der Asuro gleich schnell bleibt...muss ich nach der Richtungskorrektur also wieder die Variable SPEED initialiesieren, die ich vor dem HauotProgramm mit dem Wert zB 0Fh festlege?

Zitat:

Zitat von robby-fant

und die beißen sich ganz schön die zähne aus die studies. es ist nicht einfach zu proggen.

Also ich finde ja den Kommentar persönlich nicht angebracht.
Ich gebe ja freiweg zu, dass ich keine Ahnung habe von C, weil wir halt im Grundlagenstudium davon nichts mitgekriegt haben(leider nur Java und Pascal)
Aber man kann von KEINEM verlangen, dass er den ASURO auf 1 1/2 Wochen (klar, vlt nur einfache Programme) programmiert, wenn man C noch nie zuvor benutzt hat.
Und dass man dann auf alle "Studies" generalisiert, ist auch Quatsch. Wir müssen das ja auch erst lernen, wie jeder andere auch.

Meine Antwort jetzt nicht böse auffassen, ich musste da nur schmunzeln ;)

Bin auch Student...

damit der asuro nicht immer schneller/langsamer wird, gibt es einen kleinen trick: man korrigiert nur an einem rad. so wird dieses immer wieder beschleunigt und gebremst, und im endeffekt wird der asuro nicht immer schneller.

mach dir einen abluafplan:

der asuro wird eingeschaltet. folgendes soll passieren:

Code:

// Korrekturvariable: speed=150 WENN rechts > 550 UND links < 450 DANN { ENDLOSSCHLEIFE BEGINN BEIDE MOTOREN VORWÄRTS MOTORENGESCHWINDIGKEIT links 150, rechts "speed" //also zu beginn auch 150 WENN LINKS>600 UND RECHTS>600 //also beide seiten weiss DANN speed=speed+10 WENN LINKS<400 UND RECHTS < 400 //also beide seiten schwarz DANN speed=speed-10 ENDLOSSCHLEIFE ENDE } // ende von WENN WENN links > 550 UND rechts < 450 DANN { ENDLOSSCHLEIFE BEGINN BEIDE MOTOREN VORWÄRTS MOTORENGESCHWINDIGKEIT links 150, rechts "speed" //also zu beginn auch 150 WENN LINKS>600 UND RECHTS>600 //also beide seiten weiss DANN speed=speed-10 WENN LINKS<400 UND RECHTS < 400 //also beide seiten schwarz DANN speed=speed+10 ENDLOSSCHLEIFE ENDE } // ende von WENN Ende des programms

so sollte das ganz grob funktionieren. am anfang wird geprüft wo schwarz und wo weiss ist, und dann wird je nachdem eine endlosschleife ausgeführt. wenn beide sensoren die gleiche fareb sehen, dann wird die geschwindigkeit des rechten motors angepasst.

das programm ist eben mal so entstanden, ob es funktioniert weiss ichnicht. korrekturen bitte posten...

den programmCODE dazu kannst du ja mal selbst überlegen. wenn du ne idee hast dann poste mal.

es könnte sein dass du deine zahlenwerte anpassen musst, weil die linedata werte bei jedem asuro stark variieren können.

Danke damaltor,

ich weiß, dass du Student bist an der FH Jena ;)
Aber du hast ASURO bestimmt auch nicht nach einer Woche drauf gehabt, bzw C...denk ich doch mal ;)

Jedenfalls, danke für deinen Input. So habe ich mir das vorgestellt. Das Verfahren ist mir eigentlich klar.
Ich werde heute nachmittag mal VERSUCHEN, nen code zu schreiben.
ASURO soll also nur einer Kante nachfahren, das mit dem Umgebungslicht vernachlässige ich vorerst mal. Ich nehme mal deine Schwellenwerte 550 für weiß und 450 für schwarz!!

Ich hoffe, dass ich da was einigermaßen brauchbares "hinzaubere".

Danke für deine Hilfe damaltor!!

c konnte ich vorher ganz gut... ;)

macht nix. mal sehn was rauskommt...

Hey damaltor,

Schau dir das doch mal an ob das so ungefähr C entspricht.
Hab das heute nachmittag mal versucht zu schreiben.
Das ist jetzt meiner Meinung nach NUR die Kantenverfolgung, mit 2 Unterscheidungen, je nach dem wo grade schwarz und weiß ist.
Mit den Schleifen bin ich mir nicht ganz sicher...und auch nicht wo ich die while(1) Schleife setzen muss. Wie ist das mit den if-Anweisungen? Die verlangen doch eigentlich eine reine else-Anweisung? Ich hab da jetzt ne if else Anweisung gemacht, da ich das in irgendeinem Programm in der Asuro Lib gesehen habe.

Code:

#include "asuro.h" #define SPEED 0x9F int main(void) { unsigned int data[2]; //data[0]->rechts, data[1]->links Init(); FrontLED(On); MotorDir(FWD,FWD); MotorSpeed(SPEED,SPEED); while(1) { LineData(data); //Liniensensoren if ( data[0]>550 && data[1]<450 ) //RECHTS weiß, LINKS schwarz -> gerade weiterfahren { MotorDir(FWD,FWD); MotorSpeed(SPEED,SPEED); } else if ( data[0]>600 && data[1]>600) //RECHTS weiß, LINKS weiß -> weiter LINKS fahren { MotorDir(FWD,FWD); SPEED=SPEED+10; MotorSpeed(150,SPEED); } else if ( data[0]<400 && data[1]<400 ) //RECHTS schwarz, LINKS schwarz -> weiter RECHTS fahren { MotorDir(FWD,FWD); SPEED=SPEED-10; MotorSpeed(150,SPEED); } LineData(data); if ( data[0]<450 && data[1]>550 ) //RECHTS schwarz, LINKS schwarz -> gerade weiterfahren { MotorDir(FWD,FWD); MotorSpeed(Speed,Speed); } else if (data[0]>600 && data[1]>600) //RECHTS weiß, LINKS weiß -> weiter RECHTS fahren { MotorDir(FWD,FWD); SPEED=SPEED-10; MotorSpeed(150,SPEED); } else if (data[0]<400 && data[1]<400 ) //RECHTS schwarz, LINKS schwarz -> weiter LINKS fahren { MotorDir(FWD,FWD); SPEED=SPEED+10; MotorSpeed(150,SPEED); } } while (1); return 0; }

Danke fürs durchschauen!!

Schönen Abend noch :)

Schritt 1: bevor du es dir angewöhnst - schreibe keine hex-zahlen. du sparst keinen deut speicher, du musts umrechnen, und das programm wird unübersichtlicher. ausserdem musst du ein zeichen mehr tippen ;)

data[0] ist links, 1 ist rechts.

ich pass dein progeamm mal etwas an...

Code:

#include "asuro.h" int main(void) { unsigned int data[2]; //data[0]->rechts, data[1]->links unsigned char speed=150; Init(); FrontLED(On); MotorDir(FWD,FWD); MotorSpeed(speed,speed); if ((data[0]>550)&&(data[1]<450)) { // links weiss rechts schwarz while(1){ if ((data[0] > 600)&&(data[1] > 600)) { // wenn beide weiss speed=speed-10 } if ((data[0] < 400)&&(data[1] < 400)) { //wenn beide schwarz speed=speed+10 } MotorSpeed(150,speed); LineData(data[]); } //ende schleife } //ende if if ((data[1]>550)&&(data[0]<450)) { // links schwarz rechts weiss while(1){ if ((data[0] > 600)&&(data[1] > 600)) { // wenn beide weiss speed=speed+10 } if ((data[0] < 400)&&(data[1] < 400)) { //wenn beide schwarz speed=speed-10 } MotorSpeed(150,speed); LineData(data[]); } //ende schleife } //ende if while(1){ //wenn beide ifs nicht erfüllt wurden und damit beide endlosschleifen nicht gestartet wurden, dann wird das hier gemacht StatusLED(RED); } return 0; } //ende main()

also: theoretisch sollte wenigstens eins der beiden ifs erfüllt sein (also linksschwarzrechtsweiss oder linksweissrechtsschwarz). je nachdem wird eine der beiden endlosschleifen gestartet und es wird immer geprüft ob beide fototransistoren die gleiche farbe sehen. dann wird die geschwindigkeit des rechten rades (über speed) angepasst.
wenn keines der beiden ifs erfüllt war, also nicht eindeutig gefunden wurde wo weiss und schwarz ist, wird die endlosschleife am ende ausgeführt (wenn erstmal eine der ersten schleifen läuft, kommt das programm hier nie an) und die statusled wird rot.

dieses programm ist sehr einfach gestrickt, und die werte für die fototransistoren sind nicht angepasst, und es kann noch keinen helligkeitsausgleich. aber ein anfang sollte es wohl sein.

ich habs nicht getestet...viel glück... =)

"Leider habe ich keinerlei Zugang zum Roboter, noch habe ich umfangreiche C Kenntnisse."

Dann ist der Asuro der ideale Einstieg für Dich.
C-Schnell-Kurs: http://www2.its.strath.ac.uk/courses/c/

Erst mal danke ehenkes.
Ich werde mir das mal morgen durchlesen!!

Und dann noch ein paar Fragen an dich damaltor.
1) Nach der Init() und der Festlegung von MotorDir usw....warum wird da nicht als erstes LineData gemacht?!? Du machst die while Schleife und am Ende dieser liest du erst die LineData(data[]) ein...soll das quasi heißen: Liese solange die LineData ein, bis eines der beiden ifs erfüllt ist? Das verwirrt mich ein bisschen, da bei Pascal das ja direkt nacheinander geschrieben wird. Habe ich das richtig verstanden?
2)Kannst du mir erklären warum das immer while(1) heißen muss? Für was steht die 1?

Ansonsten ist mir das eigentlich klar wie es funktioniert...nur wie gesagt, C ist komplett neu für mich!!

Danke für die Hilfe!!

das LIneData am Anfang habe ich vergessen. es kann direkt hinter Init() stehen.
ausserdem kann die zeile Motorspeed(speed,speed) am anfang weg, wird ja später eh gestartet.

eine while-schleife läuft solange, wie das was in der klammer ist WAHR ist. WAHR ist alles, was nicht null ist. null ist also FALSCH.

while(3==3) -> WAHR -> 1 -> schleife wird ausgeführt.
while(1+2==3) -> WAHR -> 1 -> wird ausgeführt
while(3-1==4) -> FALSCH -> 0 -> schleife wird nicht ausgeführt

while(3+3) -> WAHR (ist nicht 0) -> 1 -> schleife wird ausgeführt
while(3-3) -> FALSCH (ist gleich 0) -> 0 -> schleife wird nicht ausgeführt

x=3;
while(x==3) -> WAHR

tja... und while(1) wird ausgeführt solange in den klammern nicht 0 steht, also ewig. =) wird also eines der beiden ifs als richtig bewertet, also linksschwarzrechtsweiss oder andersrum, wird die entsprechende endlosschleife ausgeführt. der rest des programms wird dann nie mehr ausgeführt, da die endlosschleofe nie wieder verlassen werden kann!

Ah ok, jetzt habe ich das erst gerafft. Ich dachte while(1) steht immer nur einmal in einem ASURO Programm! Jetz isses klar.
Das soll einfach eine Endlosschleife sein, die nur verlassen wird, wenn keine einzige if Bedingung erfüllt worden ist. Und genauso ist es mit der zweiten while Schleife. Falls auch diese nicht erfüllt wird, wird das Programm beendet und die rote LED geht an!!

Danke für die Hilfe!!

nicht ganz. eine while(1) schleife wird NIEMALS verlassen.
völlig unabhängig von dem was drin ist.

(für die cracks: ja ich weiss, möglich ist es. aber so selten gebraucht...)

es wird am anfang durch die beiden ifs geprüft ob schwarz rechts oder links ist. dann wird die entsprechende endlosschleife gestartet. und nie mehr verlassen!!

nur wenn keines der beiden ifs wahr ist, also nicht erkannt wurde wo schwarz ist, dann wird die letzte schleife gestartet, und die led rot gemacht.

Achso, ok, das iss noch eine kleine Feinheit, aber das ist genauso logisch.
Ich hoffe ich bekomme das am Dienstag gut rum!

Wenn ich dann meinen eigenen ASURO habe, bastel ich da mal weiter dran rum...ich glaube nicht, dass ich den morgen noch bekomme und zusammenbauen kann.

Dann werd ich in meiner freien Zeit mal ein bisschen damit rumspielen!!

Also nochmal dankeschön! Du warst mir eine große Hilfe.

Schau Dir für den ASURO bei C folgende Features an:
- logische Bit-Operatoren (zumindest | und <<)
- if/else
- while, do/while und for
- Funktionen
- Zeiger und Arrays http://www.henkessoft.de/C++/C/arrays_pointer.htm

Hallo,

jetzt möchte ich meinem alten Programm gerne zur Umgebungslichtkompensation was hinzufügen.
Da ich ja auf einer Schwarz-Weiß-Kante fahre, ist meine Idee folgende:
Ich stehe auf der Kante, links schwarz rechts weiß.
Ich messe nun also auf beiden Transistoren jeweils mit LED on und off.
Dann bilde ich die Differenz aus den Messwerten des linken bzw. rechten Transistors. Da links auf schwarz steht, müsste sich ja hierfür eine andere Differenz ergeben als für den rechten Transistor.

Code:

Init(); FrontLED(Off); LineData(data); //links->schwarz, rechts->weiß a=data[0]; b=data[1]; FrontLED(On); c=data[0]; d=data[1]; schwarz=c-a; weiß=d-b;

Das habe ich also soweit.
Das würde ich gerne in eine Funktion umgeblicht packen, damit ich im mainprogram nur noch umgeblicht aufrufen muss.
Jetzt ist aber mein Problem, dass ich an die Differenzwerte für Weiß und Schwarz nicht rankomme. Wie bekomme ich denn den Digitalwert?
Desweiteren hab ich mit der funktion so meine Probleme.

Zitat:

int umgeblicht (LineData(Data));
{
int a,b,c,d,schwarz,weiß;
FrontLED(Off);
LineData(data); //links->schwarz, rechts->weiß
a=data[0];
b=data[1];
FrontLED(On);
c=data[0];
d=data[1];
schwarz=c-a;
weiß=d-b;
}

so würde ich meine Funktion basteln und dann im main einbauen.
Ist das so in etwa richtig? Bin ich auf dem richtigen Kurs?

Ich weiß, das sieht alles ziemlich unkoordiniert aus :(

Wenn ich dann mal den Differenzwert habe, dann kann ich das in dem obigen(von damaltor) verbesserten Programm als Bedingung in den if Anweisungen einbauen.
Andererseits habe ich mir auch überlegt, dass ich die Differenz zwischen Links und Rechts bilde, das müsste ja, wenn man auf Kurs ist, immer einen festen Wert ergeben.
Beides hört sich für mich plausibel an...aber am Programmieren haperts halt wieder.

Ich hoffe ihr könnt mir mal wieder helfen!!

Liebe Grüße

an sich ganz fein, aber damit misst du nicht das umgebungslicht, sondern nur den unterschied zwischen frontled on und off. wozu?

teste erstmal das programm ob das überhaupt funktioniert, bevor du es verfeinerst...

Morgen!
Also mein Gedanke war, wenn ich zB mit dem linken Sensor auf einer schwarzen Fläche stehe, dann müsste die Differenz der beiden linken Sensorwerte(LED ON OFF) einen ~gleichbleibenden Wert ergeben. Völlig aus dem Hut gezogen sage ich jetzt einfach für eine schwarze Fläche ergibt sich eine Differenz von 100, und für eine weiße etwa 200. Somit hätte ich ja eine Bedingung dafür, ob sich ASURO auf Kurs befindet, oder ob er neben der Spur liegt.
Was ich mir aber da eingehandelt hab, kam mir erst später in den Sinn: Ich muss immer erst 2mal messen, einmal mit einmal ohne LED, muss die Werte zwischenspeichern, und die müsste ich dann mit Referenzwerten vergleichen, also mit diesen 100 und 200 (welche ich natürlich nicht habe).
Ist es möglich, dass mir ASURO diese Werte schickt (per IR nach dem Programmablauf)? Und dann müsste ich vor jeder while Schleife, von denen ich momentan ja Stück habe, diese Messung machen, und das wird dann ja relativ lange für eine so kleine Funktion!
Ich hoffe, meine Idee mit dem Differenzwert einer LED ist klar, ob die so funktioniert weiß ich nicht.

Leider kann ich das auch noch nicht testen, da mein ASURO noch nicht da ist. Und selbst dann muss ich den erst mal zum laufen bringen :(

die idee sollte gehen. die werte kannst du bei jedem mal wo das programm gestertet wird, neu einlesen und in einer variable speichern. wenn sie sich dauerhaft sehr ähneln, dann könnte man sie auch im eeprom des prozessors speichern. eine kurzzeitige messung mit quasiblinkender led ist kein problem. nur den sinn des ganzen verstehe ich nicht. wozu wissen wo der unterschied ist?

Na ich möchte gerne den Unterschied zwischen schwarzer und weißer Fläche wissen, unabhängig davon, wie die Lichtverhältnisse sind. Wenn ich von den Schwellenwerten 450 und 550 ausgehe, dann sind die ja immer noch vom Umgebungslicht abhängig. Mit dieser Differenzbildung möchte ich gerne einen zu einer best. Farbfläche korrespondierenden Wert erhalten.
Wenn der ASURO dann über das Feld fährt, und stets diese Messung macht und mit dem Differenzwert vergleicht, weiß er, ob am linken Sensor was anderes anliegt als am rechten. Und das halt auch, wenn unterschiedliche Lichtverhältnisse vorliegen. (Ich denke das mit 450 und 550 sollte hier OHNE Probleme auch funktionieren, nur ist das mit dem Umgebungslicht halt Teil der Aufgabe!!!).
Ich würde das ja mal gern versuchen, aber ich kann ja nicht.

Wie würdest du das, was ich da vorhabe denn in eine Funktion packen?
Ich habs ja oben schon mal versucht...ich will die definieren und dann nur im Programm aufrufen müssen.

Oder eben so: Wie könnte man denn die Umgebungslichtkompensation noch/sonst machen?

Also so hab ich mir das vorgestellt. Bitte nicht auf die Feinheiten achen ;)

Code:

#include "asuro.h" int RefLinks(LineData); //Funktion für Differenzwert Links FrontLED(ON); LineData(Data); a=data[0]; FrontLED(OFF); LineData(Data); c=data[0]; LRef=a-c; return LREF; int RefRechts(LineData); //Funktion für Differenzwert Rechts FrontLED(ON); LineData(Data); b=data[1]; FrontLED(OFF); LineData(Data); d=data[1]; RRef=b-d; return RRef; int main(void) { unsigned int data[2]; //data[0]->links, data[1]->rechts unsigned char speed=150; unsigned char taste; Init(); FrontLED(ON); LineData(Data); a=data[0]; b=data[1]; FrontLED(OFF); LineData(Data); c=data[0]; d=data[1]; LRef=a-c; //Aktueller Referenzwert Links RRef=b-d; //Aktueller Referenzwert Rechts if ((data[0]<450)&&(data[1]>550)) { // links schwarz rechts weiß while (1){ LREF = RefLinks(LineData); //Aufrufen der Funktion RRef = RefRechts(LineData); //Aufrufen der Funktion if (LRefakt > LRef );{ //zu weit rechts->links weniger speed speed=speed-10; } if (RRefakt < RRef );{ //zu weit links->links mehr speed speed=speed+10; } MotorSpeed(speed,150); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } .... für linksweissrechtsschwarz genauso

Bitte kommentieren was ihr dazu sagt, wäre das so in der Art möglich?
Könnt ihr mir eine andere Möglichkeit nennen? Oder mir etwas zeigen?

EDIT: Wie ich meine "Umgebungslichtkompensation" in die erste Abfrage, also bei der Entscheidung wo nun schwarz und weiß sind, einbaue, habe ich noch keinen Schimmer. Eigentlich ist das ja sinnlos, weil ich nicht zuordnen kann, was für ein Wert für schwarz und was für ein wert für weiß steht!
Ich dreh mich im Kreis :(

Jetzt habe ich nochmal was....

Code:

#include "asuro.h" int main(void){ unsigned int data[2]; unsigned char speed=150; unsigned char taste; unsigned char A=0,B=0; Init(); LineData(data); A=data[0]; B=data[1]; FrontLED(ON); MotorDir(FWD,FWD); while ((data[0]>550) && (data[1]<450)){ //LwRs BackLED(OFF,OFF); MotorSpeed(150,150); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]<550) && (data[1]>550)){ //LsRw BackLED(ON,ON); MotorSpeed(150,150); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]>600) && (data[1]>600) && (A>B)){ //weiter rechts BackLED(ON,OFF); speed=speed-10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]<400) && (data[1]<400) && (A>B)){ //weiter links BackLED(OFF,ON); speed=speed+10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]>600) && (data[1]>600) && (A<B)){ //weiter links BackLED(OFF,ON); speed=speed+10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]<400) && (data[1]<400) && (A<B)){ //weiter rechts BackLED(ON,OFF); speed=speed-10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while(1){ StatusLED(RED); } return 0; }

Im Prinzip nichts anderes als vorhin!!
Nur jetzt soll der ASURO auch mit dem Wechsel der Farben der Kanten zurechtkommen, also nicht in einer Endlosschleife while(1) stecken bleiben.
Deswegen lese ich am Anfang mit A und B die Werte für links und rechts ein, egal welche Farbe die haben. Dann gehe ich in die einzelnen Schleifen und vergleiche die Bed. mit A und B. Das Problem ist nur, dass nach einem Programmdurchlauf A und B erneut eingelesen werden (oder?)...und falls ASURO grade 2mal auf weiß steht, dann stimmt gar nichts mehr. Kann man die zuerst gemessenen Werte irgendwo-/wie unveränderbar speichern ???

Habt Geduld mit mir ;)

oben rechts über deinem post ist ein button, da steht edit drauf. bitte editiere deine beiträge, und hänge das neue dran, sofern noch kein anderer nach dir gepostet hat.

deinen code muss ich mir mal morgen zu gemüte führen, für heute bin ich zu müde... =)

Erst mal Entschuldigung, für mein Gespamme...ich hab den EDIT Button aber schon mal benutzt ;)

Und jetzt zu meiner neuesten Kreation.
Erst mal kurz der Ablauf, was ich mir dabei gedacht habe.

1. Einlesen ob rechtsschwarzlinksweiß oder andersrum
2. Abspeichern in A und B
while(1){
3. Falls A>B (linksweißrechtsschwarz) -> 2 versch. while schleifen
4. Falls A<B (linksschwarzrechtsweiß) -> 2 versch. while schleifen
}

Einfach mal anschauen!!

Ich würde das ja mal gerne versuchen, aber so rein beim durchschauen denk ich mir, das müsste doch funktionieren :)

Code:

#include "asuro.h" int main(void){ unsigned int data[2]; unsigned char speed=150; unsigned char taste; unsigned char A=0,B=0; Init(); LineData(data); A=data[0]; B=data[1]; FrontLED(ON); MotorDir(FWD,FWD); if ( ((data[0]>550) && (data[1]<450)) || ((data[0]<450) && (data[1]>550)){ while(1){ do { BackLED(OFF,OFF); MotorSpeed(150,150); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } }//ende do while (((data[0]>550) && (data[1]<450)) || ((data[0]<450) && (data[1]>550))) while ((data[0]>600) && (data[1]>600) && (A>B)){ //weiter rechts BackLED(ON,OFF); speed=speed-10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]<400) && (data[1]<400) && (A>B)){ //weiter links BackLED(OFF,ON); speed=speed+10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]>600) && (data[1]>600) && (A<B)){ //weiter links BackLED(OFF,ON); speed=speed+10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } while ((data[0]<400) && (data[1]<400) && (A<B)){ //weiter rechts BackLED(ON,OFF); speed=speed-10; MotorSpeed(150,speed); LineData(data); taste=PollSwitch(); if (taste>0){ MotorSpeed(0,0); StatusLED(RED); } } }//ende while }//ende if while(1){ StatusLED(RED); } return 0; }//ende main

EDIT: Ich hab keine Ahnung warum jetzt alles bold ist, ich habe keinen Knopf gedrückt!!

sieht auf den ersten blick gar nicht schlecht aus. wird zeit dass du deinen asuro bekommst zum testen... =)

edit: habe das bold weggemacht. das lag an der schlechten html-interpretation des phbb2-systems: du hast a<b geschreiben, und [b] bedeutet "BOLD" in html. wenn du sowas nochmal hast, musst du unten drunter die checkbox "HTML DEAKTIVIEREN" anklicken.

Na super, immerhin etwas!! :)
Ich lasse das jetzt einfach mal so.
Das mit der Umgebungslichtkompensation versuche ich einfach mit einer Mittelwertbildung aus Wert LED an und Wert LED aus. Mal sehen wie gut das klappt.

Jetzt habe ich nur noch eine kurze Frage, die nichts mit dem Topic zu tun hat.
Wie sage ich denn ASURO, dass er 3 sekunden lang rückwärts fahren soll?
Kann ich da die MSleep Funktion verbauen? Wenn ja, wie?

Ich würde einfach sagen

Code:

while (MSleep(3000)) { MotorDir(RWD,RWD); MotorSpeed(100,100); }

Ich kann mir nicht vorstellen, dass das so richtig ist :-k

Code:

MotorDir(RWD,RWD); MotorSpeed(100,100); Msleep(3000); MotorSpeed(0,0);

na toll jetzt ist mein text bold... mal ändern gleich.

so wie du das hast ist falsch. besser so:

MotorDir(RWD,RWD);
MotorSpeed(100,100);
Msleep(3000);

Ach klar. War ja irgendwie klar, dass das wieder so einfach war!!!
Danke ihr 2 (und vor allem an dich damaltor) für die große Hilfe!

Ich hoffe die Tage kommt mein Bausatz, dann werd ich das nächste Woche mal versuchen zusammenzubauen..habe schon lange nicht mehr gelötet. Hoffentlich mache ich nichts kaputt.
Dann brauche ich wahrscheinlich auch noch was zur Datenübertragung, weil mein Notebook IR Transceiver bestimmt ned funktioniert.
Aber das ist ein anderes THema!!

bei dem bausatz ist ein transceiver dabei. der kann an den rs232 (COM) anschluss angesteckt werden. leider funktioniert er an einigen notebook-schnittstellen nicht richtig, aber das soltest du einfach mal ausprobieren. ansonsten müsstest du dir den usb-transceiver zulegen. der kostet allerdings etwa 20 Euro.

Hey damaltor,

wo du dir schon die Mühe gemacht hast, mir zu helfen, will ich dir zumindest sagen wie der Versuch denn so abgelaufen ist!
Um es kurz zu machen...der ASURO hat rein gar nix gemacht, der hat nur die StatusLED auf rot gemacht und das wars dann ](*,)

Naja, mein ASURO ist per Post angekommen, ich hoffe ich bekomme das die Tage hin den zum Laufen zu bringen, dann kann ich ja mal weiterversuchen!

Danke nochmal für deine Hilfe

na gut, das ist nicht so schlimm. warte mal bis du einen asuro hast, und dann bis er zusammengebaut hast. das kriegen wir noch hin.