Nibobee? Brauche Hilfe

[emailmoi]

Hallo Nibobee-Kenner,

ich möchte gerne das Programm vom Asuro sumo code auf meine Biene übertagen!! kann mir jemand dabei helfen? Zuerst muss sich die Biene nur innerhalb eines mit schwarz eingerahmten Felds bewegen. Die soll die schwarze Linie erkennen und bremsen dann entweder nach links drehen oder nach rechts, je nachdem mit welchem Liniensensor sie die Linie zuerst erkannt hat!

Vielen Dank im voraus
MfG

[Rabenauge]

Das Programm kannst du für den NiboBee erstmal vergessen.
Dadurch, dass unterschiedliche Hardware und verschiedene Bibliotheken benutzt werden, ist es doch eher mühselig, das Programm umzuschreiben (du musst wahrscheinlich so ziemlich alles neu schreiben).

Benutz doch einfach das von workwind (Forensuche, ich bin _auch_ zu faul, das jetzt für dich zu tun) gepostete Linienfolgeprogramm, mit einigen Modifikationen sollte sich das durchaus eignen.
Geht auch einfacher, im Grunde (workwind hat da eine nette Regelung eingebaut, die allerdings bei höheren Geschwindigkeiten und fiesen Linien überfordert ist), im Grunde musst du ja nur:

wenn(links_is_finster)
{nach rechts drehen};
............
Vorher die Bodensensoreinheit kalibrieren und fertig.
Feinheiten, wie ein geregeltes weg drehen von der Linie, kannst du dann immer noch einbauen.

[emailmoi]

Vielen Dank für deine schnelle Antwort!!
Das ist sicherlich zu kompliziert den Asuro-Code auf Nibobee zu übertragen. Ich versuch heute noch das Linienverfolgungsprogramm zu modifizieren, um meine gewünschte Funktion zu erreichen...Aber welche werte muss ich für schwarz und weiss nehmen?
MfG

[Rabenauge]

Das musst du ausprobieren. Beim NiboBee ist ein Programm bei, was dir die LED`s je nach Helligkeit schaltet , ich denke es war bei den Tutorials dabei. Das Programm wäre leicht zu modifizieren, brauchst ja nur anstelle der LED`s die Motoren passend ansteuern.

Ich persönlich würde nicht mit festen Werten arbeiten. Zwar funktioniert die Linieneinheit des NiboBee sehr gut, aber dann reagiert das Ding auf jeden Fliegen****. Bei sowas programmiere ich im allgemeinen unscharf, beispielsweise: dreimal messen, den Mittelwert nehmen und wenn _der_ eindeutig schwarz oder weiss ergibt (also deutlich jenseits der Schwelle ist...) wird erst reagiert.

Oder: die Schwelle zwischen schwarz und weiss ermitteln und dann erst reagieren, wenn der Wert _deutlich_ drunter oder drüber liegt.

Allerdings kann das auch falsch sein, z.B. beim Sumo (nebenbei: _dafür_ ist die Standardbiene eh kaum zu gebrauchen, weil sie sehr wenig Grip hat) ist es eventuell taktisch besser, schon am Rand des schwarzen zu reagieren.

Pauschale Werte bringen selten was, es macht schon einen Unterschied, ob du auf der später benutzten Unterlage oder einer anderen kalibrierst.

[emailmoi]

Hallo Rabenauge,

ich habe bis jetzt das Linienverfolgungsprogramm so weit modifiziert, aber leider ist fährt die Biene immer weiter, die erkennt die schwarze Linie nicht. Kannst du bitte auf mein Programm einen Bilck werfen, ich erkenne meinen Fehler nicht?

echo
int main() {
  activate_output_group(IO_LEDS);  // LED bits als Output
  motpwm_init();
  motpwm_setLeft(0);
  motpwm_setRight(0);
  analog_init();
  line_readPersistent();
  set_output_group(IO_SENS);       // Pull-ups aktivieren
  activate_output_bit(IO_LINE_EN);
	int i;
  

  // Countdown: LEDs blinken lassen
  for (i=0; i<10; i++) {
    led_set(LED_L_RD, 1);
    led_set(LED_R_RD, 1);
    _delay_ms(10);
    led_set(LED_L_RD, 0);
    led_set(LED_R_RD, 0);
    _delay_ms(990);
  }
  led_set(LED_L_YE, 1);
  led_set(LED_R_YE, 1);
  _delay_ms(1000);
  led_set(LED_L_YE, 0);
  led_set(LED_R_YE, 0);

  // Hauptschleife:
  while(1) {
    sei();
    _delay_ms(1);
    
    int16_t lval = line_get(LINE_L);
    int16_t rval = line_get(LINE_R);

    if (lval < 30) {
      led_set(LED_L_RD, 1);
      led_set(LED_R_RD, 0);
	  fahre(2);	
	  fahre(0);
	  
    } 
	
	else {
      
      led_set(LED_L_RD, 1);
      led_set(LED_R_RD, 1);
	  fahre(1);
      
    } 
	
	if (rval < 30) {
      
      led_set(LED_L_RD, 0);
      led_set(LED_R_RD, 1);
	  fahre(2);
	  fahre(-1);
      
    } 
	
	else {
      
      led_set(LED_L_RD, 1);
      led_set(LED_R_RD, 1);
	  fahre(1);
      
    }

	if (rval < 30 && lval < 30) { // soll bedeuten, wenn die biene senkrecht auf die Linie fährt
      
      led_set(LED_L_RD, 1);
      led_set(LED_R_RD, 1);
	  fahre(2);
	  fahre(-1);
      
    } 
	
   }
  return 0;
} 

int fahre(int8_t richtung) {
   switch(richtung) {
      case 1: {
         motpwm_setLeft(400);  /* Kreis im Uhrzeigersinn */
         motpwm_setRight(350);
         led_set(LED_L_RD, 0);
         led_set(LED_R_RD, 1);
         break; }
      case -1: {               /* Kreis gegen die Uhr */
          motpwm_setLeft(350);
         motpwm_setRight(400);
         led_set(LED_L_RD, 1);
         led_set(LED_R_RD, 0);
         break; }
      case 0: {               	/* volle Kraft zurück */
         motpwm_setLeft(-1024);
         motpwm_setRight(-1024);
         led_set(LED_L_YE, 1);
         led_set(LED_R_YE, 1);
         delay(800);
         motpwm_setLeft(1000);   /* Drehen */
         motpwm_setRight(-1000);
         delay(150);
         break; }
	  case 2: {               /* Bremsen */
         motpwm_setLeft(0);
         motpwm_setRight(0);
         led_set(LED_L_RD, 1);
         led_set(LED_R_RD, 1);
         break; }
         }
return 0;
}

Das Linienverfolgungsprog funktioniert einwandfrei, wie auf dem Video zu sehen ist!!! D.h die Kalibrierung der Bodensensoren ist richtig gemacht worden.
http://www.youtube.com/watch?v=vOPQUw7_Bsc
Vielen Dank

[Rabenauge]

Erstens: warum machst du das denn soo umständlich?

Ich erwähnte schon das (mitgelieferte, und auch frei downloadbare) Tutorial.
Dort ist (wenn ich mich recht entsinne, auf Seite 3 ein Programm enthalten, was die Bibliotek der Biene komplett nutzt- es sind vielleicht gerade mal 20 Zeilen oder so.
Alles, was du an dem Programm ändern müsstest, ist, anstelle der LED`s die Motoren passend zu schalten.
Das geht also weit kürzer zu schreiben als das workwind-Programm!
Obendrein finde ich es übersichtlicher, aber das ist Angewohnheit.

Zweitens: bist du sicher, dass dein Zustandsautomat _so_ wirklich funktionieren kann?

Beispiel:

if (rval < 30) { 
      
      led_set(LED_L_RD, 0); 
      led_set(LED_R_RD, 1); 
     fahre(2); 
     fahre(-1);

Es wird also zuerst Zustand 2 abgearbeitet:

case 2: {               /* Bremsen */ 
         motpwm_setLeft(0); 
         motpwm_setRight(0); 
         led_set(LED_L_RD, 1); 
         led_set(LED_R_RD, 1); 
         break; }

Da die Biene (immerhin fährst du Vollgas) einen gewissen Bremsweg hat (ich habe den, auch bei niedrigeren Geschwindigkeiten, ohne Bremsrampe nie unter 5mm bekommen), wäre es durchaus denkbar, dass sie dann schon über die Linie drüber ist.

und dann würde

case -1: {               /* Kreis gegen die Uhr */ 
          motpwm_setLeft(350); 
         motpwm_setRight(400); 
         led_set(LED_L_RD, 1); 
         led_set(LED_R_RD, 0); 
         break; }

gar nicht mehr aufgerufen, weil es ja schon wieder hell ist.
Obendrein sind solche feinen Regelungen (immerhin gerade mal 50 von 1024) ohnehin so eine Sache bei der Biene, das funktioniert, wie bei mir, aktuell bei sehr sachten Kurven schon, aber für ernsthafte Lenkbewegungen musst du etwas gröber zu Werke gehen.
Dein case2 im konkreten Fall ist soo kurz, dass ich bezweifle, dass die Motoren darauf überhaupt erst reagieren, ehe case -1 aufgerufen wird- oder du schon über die Linie drüber bist.

Leg mal ein weisses Blatt auf nen dunklen Untergrund (einfach, damit du sehhhr breite Linien hast), so ist schonmal sicher dass du nicht über die Linien drüberfährst.
Dann spiel mit den Werten: Lenk gröber (da kannst du, wenn deine Biene leicht genug läuft (Getriebe!) ohne weiteres mal zwischen rechts und links 200 Unterschied geben oder gleich das innere Rad stehen lassen.
Ausserdem dürfte die Xval < 30 schon sehr, sehr schwarz sein, solche niedrigen Werte erreiche ich erst an der Tischkante, auf meinem schwarzen Papier nicht immer.
Fang an mit dem halben Wertebereich, und taste dich sachte vor bis es sauber läuft.
Ausserdem hast du den mittleren Lichtsensor auch noch, der ist zum verstärken der Lenkbewegung:

wenn(rechts schwarz)
{lenke bisschen}
wenn(mitte auch schwarz)
{lenke kräftig}

gar nicht schlecht, so hast du schon, ohne grosse Regelei, eine zweistufige Korrektur.

[emailmoi]

Hallo Rabenauge,
ich habe das oben stehende Programm getestet und es hat gut funktioniert.
Schau dir mal mein Video an: http://www.youtube.com/watch?v=bYBDdeuBhYk
Mein Problem war bei der Kalibrierung, ich hatte die Sensoren nachts auf einem andern weissen Untergrund.
Danke Für deine Unterstützung

[Rabenauge]

Schaut doch gut aus.
Und ja: die Kalibrierung ist das A und O an der ganzen Geschichte, ohne die klappt nix.
Trotzdem: ich würde das Programm einfacher schreiben, glaub mir, lang genug werden die Programme später sowieso.