Roboterbausatz Nibo

Im Nibo wiki findet man folgenden Beitrag zum Thema Löten:
http://nibo.editthis.info/wiki/L%C3%B6ten

Die Dokumenation wurde heute aktualisiert:
http://download.nicai-systems.com/ni...o_20070728.pdf

Ich habe das Antikollisionsprogramm mit dem geometrischen Sensorschwerpunkt um Gewichtungsfaktoren ergänzt, einen Speedfactor zugefügt, mit den Grenzen etwas gespielt und versucht, Schwingungen vorzubeugen. Diese Grenzen hängen auch noch von der Tageszeit (Lichteinfluss IR), evtl. auch von der Akkuspannung (Messwerte IR) ab. Nibo bewegt sich damit schon, ohne sich zu verletzen. ;-)
Er bleibt manchmal noch unter Bürostuhlbeinen hängen. Da könnte man etwas mit der Odometrie machen. Da die Räder bei glatten Böden durchdrehen, geht aber kein einfacher Vergleich, ob sich das Rad überhaupt noch dreht. Gebogene schwarze Hindernisse, die IR schlucken und nach oben reflektieren, sind logischerweise auch ein physikalisches Problem. Gute Tipps?

Code:

---

/********************************************
*                                          *
*  N I B O  -  A N T I K O L L I S I O N  *
*                                          *
********************************************/

// Stand: 31.07.2007, 01:00h
// Erhard Henkes
// www.henkessoft.de

// Geometrischer Sensorschwerpunkt
// Gewichtung der Sensoren
// Einfaches Ausweichen nach Grenzwerten

// TODO: unter Bürostuhlbein einklemmen
//      fährt im Kreis, weil er z.B. immer links ausweicht

#include <stdlib.h>
#include <avr/interrupt.h>

#include "nibo/niboconfig.h"
#include "nibo/iodefs.h"

#include "nibo/delay.h"
#include "nibo/adc.h"
#include "nibo/pwm.h"
#include "nibo/i2cmaster.h"
#include "nibo/display.h"

#include "nibo/bot.h"
#include "nibo/leds.h"
#include "nibo/gfx.h"
#include "nibo/irco.h"
#include "nibo/motco.h"
#include "nibo/floor.h"

#define LINKS        0
#define VORNE_LINKS  1
#define VORNE        2
#define VORNE_RECHTS 3
#define RECHTS      4

#define SPEEDFACTOR 30

// Zustände
#define BLOCKIERT        1
#define AUSWEICHEN      2
#define FREI            0
#define HINDERNISLINKS  3
#define HINDERNISRECHTS  4
#define GERADEAUS        5


// Deklarationen von Hilfsfunktionen
void Init();
void float2string(float value, int decimal, char* valuestring);
void leds_set_status_all(uint8_t col0, uint8_t col1, uint8_t col2, uint8_t col3, uint8_t col4, uint8_t col5);
float SupplyVoltage(void);
void textout(int x, int y, char* str, int ft);


int main()
{
  Init();

  // Kollisionsvermeidung vorbereiten
    uint16_t Vektor[5][2]; // Einheitsvektoren (*10) [0] ist x- und [1] ist y-Wert
    Vektor[0][0] = -10; // LINKS x
    Vektor[0][1] =  0; // LINKS y
    Vektor[1][0] =  -7; // VORNE_LINKS x
    Vektor[1][1] =  7; // VORNE_LINKS y
    Vektor[2][0] =  0; // VORNE x
    Vektor[2][1] =  10; // VORNE y
    Vektor[3][0] =  7; // VORNE_RECHTS x
    Vektor[3][1] =  7; // VORNE_RECHTS y
    Vektor[4][0] =  10; // RECHTS x
    Vektor[4][1] =  0; // RECHTS y

  uint8_t weightfactor[5]; // Gewichtungsfaktor
  weightfactor[LINKS]        = 1;
  weightfactor[VORNE_LINKS]  = 2;
  weightfactor[VORNE]        = 3;
  weightfactor[VORNE_RECHTS] = 2;
  weightfactor[RECHTS]      = 1;

    uint16_t VektorMalSensor[5][2];  // Sensorwert * Einheitsvektor (*10)
    uint16_t VektorMalSensorSumme[2]; // Sensorschwerpunkt (x,y) für Auswertung

  // Vorbereitungen
  leds_set_displaylight(1000);
  leds_set_headlights(256);
  floor_enable_ir();
  motco_setPWM(512,512);
  motco_setSpeed(3,3);

  // fixe Display-Anzeigen
      textout(35,0,"Volt",      0);
    textout(0, 8,"distance:", 0);
  textout(0,24,"floor:",    0);
  textout(0,40,"line:",    0); 

  // Hauptschleife
  while(1)
  {
      // Akkuspannung anzeigen
      float Ubatt = SupplyVoltage();
        char text[6];
        float2string(Ubatt,2,text);   
        textout(0,0,"    ",0); // 5 Zeichen löschen
      textout(0,0,text,  0);

      // Abstandsmessung Raumgefühl
      irco_startMeasure();
      irco_update();
     
      // Floor
      uint16_t floor_distance[2];
      uint16_t line_distance[2];

      // Abstandsmessung Floor     
      floor_update();
      floor_distance[0] = floor_l;
      floor_distance[1] = floor_r;
      line_distance[0]  = line_l;
      line_distance[1]  = line_r;

      //Strings für Display
      char irco_string[5][5];
      char floor_string[2][5];
      char line_string[2][5];
     
      // Laufvariablen
      int i,j;
 
      /*
        IR-Abstandssensoren
      */
     
      for(i=0; i<5; ++i)
          textout(i*21,16,"      ",0); //löschen

      for(i=0; i<5; ++i) // z.Z. noch rechts 0 und links 4 !!!!!!!!!!!!!
      {
          itoa(irco_distance[i],irco_string[i],10);       
          textout(i*21,16,irco_string[i],0);
      }

      /*
        IR-Floorsensoren (Abgrunderkennung)
      */
     
      for(i=0; i<2; ++i)
          textout(i*28,32,"      ",0); //löschen

      for(i=0; i<2; ++i)
      {
          itoa(floor_distance[i],floor_string[i],10);       
          textout(i*28,32,floor_string[i],0);
      }

      /*
        IR-Liniensensoren
      */

      for(i=0; i<2; ++i)
          textout(i*28,48,"      ",0); //löschen

      for(i=0; i<2; ++i)
      {
          itoa(line_distance[i],line_string[i],10);       
          textout(i*28,48,line_string[i],0);
      }
     
      /*
        MOTCO
       
        Mathematische Methode "x/y-Schwerpunkt der Sensorvektoren bilden":
        (Einheitsvektoren * 10) * Sensorwert (0-255) * weightfactor, davon Summe bilden

        VektorMalSensorSumme[...] 0 ist x-Wert und 1 ist y-Wert
        Blockade: y kann maximal 14790 groß werden (vl, v, vr 255)
        Richtung: x kann maximal -6120 (Hindernis links) bzw. +6120 (H. rechts) werden (l, vl 255 bzw. r, vr 255)
      */
     
        // Ermittlung von VektorMalSensorSumme[...] (gewichteter x- und y-Wert)
      VektorMalSensorSumme[0] = 0; // x-Wert
        VektorMalSensorSumme[1] = 0; // y-Wert

      // i entspricht links, vornelinks, vorne, vornerechts, rechts
      // j entspricht x und y
     
      for (i=0; i<5; ++i)
      {
          for (j=0; j<2; ++j)
          {
              VektorMalSensor[i][j] = Vektor[i][j] * irco_distance[i] * weightfactor[i]; // 4-i wegen IRCo?????
              VektorMalSensorSumme[j] += VektorMalSensor[i][j];
          }
      }

      // Reaktion auf VektorMalSensorSumme[...] (x- und y-Wert)     
     
      // GrenzenY
      uint16_t GrenzeY1 = 12000; // Zustandsgrenze: BLOCKIERT  / AUSWEICHEN
      uint16_t GrenzeY2 =  6000; // Zustandsgrenze: AUSWEICHEN / FREI
     
      // GrenzenX
      uint16_t GrenzeXlinks  = -2000; // Zustandsgrenze: LINKS  / GERADEAUS
      uint16_t GrenzeXrechts =  2000; // Zustandsgrenze: RECHTS / GERADEAUS

      // Zustandsvariable
      uint8_t zustand    = 0;
      uint8_t zustand_old = 0;     

      // Zustand ermitteln
      {  // y-Wert
                if( VektorMalSensorSumme[1] >=GrenzeY1)            zustand = BLOCKIERT;
        if((VektorMalSensorSumme[1] < GrenzeY1) &&
                    (VektorMalSensorSumme[1] >=GrenzeY2))
        {
            // x-Werte
            if( VektorMalSensorSumme[0] < GrenzeXlinks  )  zustand = HINDERNISLINKS; 
                        if( VektorMalSensorSumme[0] > GrenzeXrechts )  zustand = HINDERNISRECHTS;
            if((VektorMalSensorSumme[0] >=GrenzeXlinks) &&
                          (VektorMalSensorSumme[0] <=GrenzeXrechts))  zustand = GERADEAUS;     
        }
        if (VektorMalSensorSumme[1] < GrenzeY2)            zustand = FREI;
      }

      // Auf Zustand reagieren
      if(zustand == zustand_old)
      {
        // kein MOTCo-Befehl notwendig
      }
      else //Veränderung eingetreten
      {
          // Sondermaßnahmen
        // gegen Schwingung links/rechts: einmal GERADEAUS erzwingen
        if((zustand_old == HINDERNISLINKS) || (zustand_old == HINDERNISRECHTS))
        {
            zustand = GERADEAUS;
        }
        // gegen Schwingung vor/zurück: zweimal zurück
        if((zustand_old == BLOCKIERT) && (zustand == GERADEAUS))
        {
            zustand = BLOCKIERT;
        }
        // direkt vorne frei?
        if(irco_distance[2]<150)
        {
            zustand = zustand_old;     
        }
       
        //Allgemeine Maßnahmen           
        switch(zustand)
        {
            case FREI:
                        //entry
                    leds_set_status_all(LEDS_OFF, LEDS_OFF, LEDS_GREEN, LEDS_GREEN, LEDS_OFF, LEDS_OFF);
                        //do
                motco_setSpeed( 3*SPEEDFACTOR, 3*SPEEDFACTOR );  // rasch vorwärts
                                delay(10);
            //exit
            break;
            case HINDERNISRECHTS:
            //entry
                    leds_set_status_all(LEDS_OFF, LEDS_OFF, LEDS_OFF, LEDS_OFF, LEDS_ORANGE, LEDS_ORANGE);
                        //do
                motco_setSpeed(  -SPEEDFACTOR,  SPEEDFACTOR );  // nach links drehen
                            delay(10);
            //exit
            break;
            case GERADEAUS:
            //entry
                                leds_set_status_all(LEDS_OFF, LEDS_OFF, LEDS_ORANGE, LEDS_ORANGE, LEDS_OFF, LEDS_OFF);
            //do
                motco_setSpeed( 2*SPEEDFACTOR, 2*SPEEDFACTOR );  // gemäßigt vorwärts 
                            delay(10);
            //exit
            break;
            case HINDERNISLINKS:
            //entry
                                leds_set_status_all(LEDS_ORANGE, LEDS_ORANGE, LEDS_OFF, LEDS_OFF, LEDS_OFF, LEDS_OFF);
            //do
                motco_setSpeed(  SPEEDFACTOR,  -SPEEDFACTOR );  // nach rechts drehen
                            delay(10);
            //exit
            break;
            case BLOCKIERT:
            //entry
                                leds_set_status_all(LEDS_OFF, LEDS_OFF, LEDS_RED, LEDS_RED, LEDS_OFF, LEDS_OFF);       
            //do
                motco_setSpeed(-2*SPEEDFACTOR,-2*SPEEDFACTOR );  // rückwärts fahren
                            delay(10);
            //exit
            break;
        }
        zustand_old = zustand;
        motco_update();
      }
  }//Ende while-Hauptschleife

  while(1);
    return 0;
}


// Hilfsfunktionen

void Init()
{
    sei(); // enable interrupts

    i2c_init();
  pwm_init();
  display_init();
 
  bot_init();
  leds_init();
  floor_init();
    gfx_init();
}

void leds_set_status_all(uint8_t col0, uint8_t col1, uint8_t col2, uint8_t col3, uint8_t col4, uint8_t col5)
{
        leds_set_status(col0,0);       
        leds_set_status(col1,1);
        leds_set_status(col2,2);
        leds_set_status(col3,3);
        leds_set_status(col4,4);
        leds_set_status(col5,5);
}

float SupplyVoltage(void)
{
  bot_update();     
  return(0.0166 * bot_supply - 1.19);
}

void textout(int x, int y, char* str, int ft)
{
  gfx_move(x,y);
  gfx_print_text(str,ft);
}

void float2string(float value, int decimal, char* valuestring)
{
    int neg = 0;    char tempstr[20];
  int i = 0;  int j = 0;  int c;    long int val1, val2;
  char* tempstring;
  tempstring = valuestring;
  if (value < 0){  neg = 1; value = -value; }
    for (j=0; j < decimal; j++)  {value = value * 10;}
    val1 = (value * 2);
    val2 = (val1 / 2) + (val1 % 2);
    while (val2 !=0){
      if ((decimal > 0) && (i == decimal)){
          tempstr[i] = (char)(0x2E);
          i++;
      }
      else{
          c = (val2 % 10);
          tempstr[i] = (char) (c + 0x30);
          val2 = val2 / 10;
          i++;
      }
    }
    if (neg){
      *tempstring = '-';
      tempstring++;
    }
    i--;
    for (;i > -1;i--){
      *tempstring = tempstr[i];
      tempstring++;
    }
    *tempstring = '\0';
}

---

Noch zum Thema Löten:
http://www.curiousinventor.com/guides/How_To_Solder

Eine der Probleme besteht oft darin, eine geeignete Fernbedienung mit RC5-Code sicher zu erwerben. Auf diesem Weg ist es mir beim Nibo gelungen: (Einstellung an Universalfernbedienung: TV1, 023)
https://www.roboternetz.de/phpBB2/vi...=303427#303427

Wo findet man eigentlich weiterführende Informationen über das Zusammenspiel der 3 Controller? Es gibt für den Nibo wohl eine Firmware, die über den ATMega128 die beiden ATtiny44 "flasht".
Es gibt im Wiki Infos über das .hex-File, aber keinen sourcecode. Warum werden Informationen über Bootloader und z.B. obige Firmware so ein Geheimnis gemacht? (Gilt auch für andere uC Hersteller).
Gruß
Lisbeth

Hallo Lisbeth! Ja genau so. Die Funktionsweise der Initializer-Software wird über die Jumper (vier Möglichkeiten) geregelt. Beim Nibo liegt alles "offen", manches allerdings unter der Motorhaube. Du kannst den gesamten Sourcecode einsehen:
https://nibo.svn.sourceforge.net/svn...ibo/trunk/src/

Am besten beschaffst Du Dir TortoiseSVN 1.4.4. http://tortoisesvn.net/

Damit kannst Du das Repository auf einfache Weise exportieren. Besorge Dir den Sourcecode immer von dort, nicht über Sourceforge, da dieses Paket nicht aktuell ist.

Verwendest Du MS Windows oder Linux als Betriebssystem?

Siehe z.B. ein kleines Hallo-Welt-Programm in C:
https://nibo.svn.sourceforge.net/svn...c/test1/test.c

Ich habe übrigens angefangen, Nibo in C++ zu programmieren. Nicht ganz einfach, aber es funktioniert prächtig. Hier ein kleines Beispiel:

Code:

---

#include <avr/interrupt.h>
#include "nibocc/niboconfig.hpp"

#include "nibocc/i2cmaster.hpp"
#include "nibocc/adc.hpp"
#include "nibocc/bot.hpp"
#include "nibocc/delay.hpp"
#include "nibocc/display.hpp"
#include "nibocc/floor.hpp"
#include "nibocc/graphicdisplay.hpp"
#include "nibocc/irco.hpp"
#include "nibocc/leds.hpp"
#include "nibocc/motco.hpp"
#include "nibocc/pwm.hpp"
#include "nibocc/textdisplay.hpp"

#include <stdlib.h> // RAND_MAX 32767
#include <stdint.h>
#include <string.h> // MyString

using namespace nibocc;

// Hilfsfunktionen
float SupplyVoltage(void);


// Hilfsklassen

/*****************
*  Stringklasse  *
******************/

 
// notwenig für WinAVR bis Mai 2007 bzw. bis GCC 4.1.2
// Ersatz für new, new[], delete und delete[] der fehlenden C++-Standard-Bibliothek
void* operator new      (size_t size) { return malloc(size); }
void* operator new[]    (size_t size) { return malloc(size); }
void  operator delete  (void* ptr)  { free(ptr); }
void  operator delete[] (void* ptr)  { free(ptr); }

class MyString
{
  private:
    char * pData_;

  public:
    friend MyString operator+( const MyString &, const MyString & );
    MyString() : pData_( NULL ) {} // inline ctor
    MyString( const char * pText );
        MyString( const MyString & text ); // Copy-Konstruktor
    ~MyString(); // dtor
    const MyString & operator=( const MyString & text );

    bool operator==( const MyString & text ) const;
    char operator[]( int index ) const;
    operator const char * () const; // cast zum C-String
        operator char * () const; // cast zum C-String
    int getLaenge() const;
    void ausgeben() const;
};

MyString operator+( const MyString & leftstring, const MyString & rightstring );

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

// ctor mit C-String als Argument
MyString::MyString( const char * pText ) : pData_( NULL )
{
  if( pText )
  {
    pData_ = new char[ strlen( pText ) + 1 ];
    strcpy( pData_, pText );
  }
}

// copy-ctor
MyString::MyString( const MyString & text ) : pData_( NULL )
{
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
}

// dtor
MyString::~MyString()
{
  delete[] pData_;
}

// ==
bool MyString::operator==( const MyString & text ) const
{
  if( pData_ == NULL || text.pData_ == NULL )
  {
    return ( pData_ == NULL && text.pData_ == NULL );
  }
  return ( strcmp( pData_, text.pData_ ) == 0 );
}

// []
char MyString::operator[]( int i ) const
{
  if( i >= 0 && i < getLaenge() )
  {
    return pData_[i];
  }
  else
  {
    return '\0';
  }
} 

// Länge des Textes ermitteln
int MyString::getLaenge() const
{
  if( pData_ == NULL )
  {
    return 0;
  }
  else
  {
    return strlen( pData_ );
  }
}

// cast zu C-String
MyString::operator const char * () const
{
  return pData_;
}

MyString::operator char * () const
{
  return pData_;
}

// Zuweisungs-Operator
const MyString & MyString::operator=( const MyString & text )
{
  if( this == &text ) // Selbstzuweisung abfangen
  {
    return *this;
  } 
  delete[] pData_;
  if( text.pData_ )
  {
    pData_ = new char[ strlen( text.pData_ ) + 1 ];
    strcpy( pData_, text.pData_ );
  }
  else
  {
    pData_ = NULL;
  }
  return *this;
}

void MyString::ausgeben() const
{
  // TODO
}

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

MyString operator+( const MyString & leftstring, const MyString & rightstring )
{
  MyString result;
  if( leftstring.pData_ != NULL && rightstring.pData_ != NULL )
  {
    result.pData_ = new char[ strlen( leftstring.pData_ ) +
                              strlen( rightstring.pData_ ) + 1 ];
    strcpy( result.pData_, leftstring.pData_ );
    strcat( result.pData_, rightstring.pData_ );
  }
  else if( rightstring.pData_ != NULL )
  {
    result = rightstring;
  }
  else if( leftstring.pData_ != NULL )
  {
    result = leftstring;
  }
  return result;
}


class RandomStdlib // verwendet rand() aus <stdlib.h>
{
private:
  const uint16_t seed_;
public:
  RandomStdlib():seed_(static_cast<uint16_t>(3000*SupplyVoltage())){}

  int getNum() const
  {
    static uint8_t seed_flag=0;
    if(!seed_flag)
    {
      srand(seed_);
      seed_flag = 1; // true
    }
    return rand();
  }
};

template<typename T_Generator>
class Wuerfel
{
private:
  const uint16_t maxzahl_;
  const uint16_t maxrandom_;
  T_Generator zahlengenerator_; // Template-Typ

public:
  Wuerfel(uint16_t maxzahl):maxzahl_(maxzahl),maxrandom_(RAND_MAX-(RAND_MAX%maxzahl)) {}

  uint16_t wuerfelt()
  {
    uint16_t r;
    do{ r = zahlengenerator_.getNum(); }
      while ( r >= maxrandom_ );
    return ( r % maxzahl_ +1 );
  }
};


int main()
{
    sei();
    Bot::init();
    Leds::init();
    Pwm::init();
    Display::init();
    Graficdisplay::init();
 
    Leds::set_displaylight(1000);

    Graficdisplay::move(0,10);
        Graficdisplay::print_text("Nibo Lichtorgel", 0);
    Graficdisplay::move(0,20);
        Graficdisplay::print_text("mit Zufallsgenerator", 0);
    Graficdisplay::move(0,40);
        Graficdisplay::print_text("LED", 0);
    Graficdisplay::move(40,40);
        Graficdisplay::print_text("Color", 0);

        MyString str, str1, str2;
        str1 ="AVR-Programm mit";
        str2 =" C++!";
        str = str1 + str2;

        Graficdisplay::move(0,54);
        Graficdisplay::print_text( (char *) str, 0);
           
        Wuerfel<RandomStdlib> w(6); // 1 ... 6
        Wuerfel<RandomStdlib> c(3); // 1 ... 3
       
        uint8_t wurf, color;       
        char text[2];
       
        while(1)
    {
            static uint16_t pause = 1200;
                pause -=50;
                if(pause<50) pause = 50;

                wurf  = w.wuerfelt()-1;
                color = c.wuerfelt();

                itoa(wurf,text,10);
            Graficdisplay::move(23,40);
                Graficdisplay::print_text(text, 0);

                itoa(color,text,10);
            Graficdisplay::move(75,40);
                Graficdisplay::print_text(text, 0);

                Leds::set_status(color,wurf);
            Leds::set_headlights(170*(wurf+1)); // 170...1020
               
               
                Delay::delay(pause);

                for(int i=0; i<6; ++i)
                        Leds::set_status(LEDS_OFF,i);
        }

  while(1);
  return 0;
}

// Hilfsfunktionen

float SupplyVoltage(void)
{
  bot_update();     
  return(0.0166 * bot_supply - 1.19);
}

---

Bin gerade an einer FSM nicht mit if/else oder switch/case, sondern gemäß http://www.ai-junkie.com/architectur...ut_state1.html mit Klassen, die den jeweiligen Zustand im Sinne eines "state design pattern" repräsentieren, falls Dich so etwas interessieren sollte.

@ehenkes:
1) Betriebssystem: Tut nix zur Sache! (Ich will keine Angriffsfläche für die diversen Fraktionen bieten :-) ) Der Nibo hat ja eh (noch) keins
2) C++: Welche Entwicklungsumgebung? Warum FiniteStateMachine?
3) Mein Vorschlag bzgl. Löten ist, dass es gut wäre, auch einen Fertigbausatz (vielleicht ohne mechanische Montage) gegen Aufpreis anzubieten. Der RP6 kostet ja fertig 129 EUR und das bei "nur" einen ATMega32.
4) Kann man hier im roboternetz eventuell die Technischen Daten der 3 hier so heiß diskutierten Roboter Asuro, Nibo und RP6 im Vergleich reinstellen?
5) Wie ich anderswo schon schrieb, liebe ich meine rasende Leiterplatte Asuro (mit Hüftschaden), weil er so ist, wie er ist. Zum Nibo muss ich erst noch ein Verhältnis aufbauen, aber er kommt mir jetzt schon ein wenig altklug vor....
6) So, und jetzt hör ich für heute auf: Nibo blinkt und rotiert.
Bis demnächst
Lisbeth

@Lisbeth:
ad 1) Mutig! Zu Nibo OS: Da gibt es FreeRTOS: http://www.cypax.net/snippets/index?...=de#mu-tasking
ad 2) Ich verwende AVR Studio + WinAVR für C++, habe nix Besseres. FiniteStateMachine (FSM) für ein Bewegungs-/Antikollisions-Programm
ad 3) Fertig bestückte Platine? Da gibt es doch dieses Problem mit dem 7805, der erst zum Schluss nach dem Anziehen der Schrauben festgelötet wird. Wartet man eine gewisse Zeit, kann man Nibo sicher fertig zusammen gebaut via ebay ergattern. Ich nehme Deinen kaum gebrauchten Nibo sofort, wenn Du "Traktoren" nicht magst. Da könnte ich die Kommunikation via RC5-Code testen. ;)
ad 4) vielleicht noch den c't-Bot dazu nehmen. Der Entwickler hat den Nibo basierend auf den Erfahrungen mit ASURO und c't-Bot entwickelt. Technische Daten sind aber noch nicht alles. Nibo's Vorteil sind die 5 IR-Sensoren. Die vorhandenen Dokumentationen, Programme, Bibliotheken und Erfahrungen sind ebenfalls wichtig.
ad 5) "rasende Leiterplatte" "altklug" - nicht übel! Weiter so. :)
ad 6) Die berühmte "Initializer.hex", deren Sourcecode Du ja nun auch kennst. Ich verwende übrigens noch eine Version vom 18.07., weil bei den neuen Versionen irgendwie Odometriedaten verloren gehen und Nibo suizid-gefährdet durch die Gegend schießt. Da ist der ASURO eine lahme Seifenkiste dagegen.
Tipp: Lege Dir mindestens zwei Akku-Sätze bereit. Nibo ist ein Energiebündel, kein Leisetreter.

Bin auf Deine Ideen, Vorschläge und Programme gespannt! Hoffentlich machst Du bei C++ mit. "ASURO ist C, Nibo ist C, C++ und Java." 8-[

Noch eine Frage: Du bist doch an MS Robotics Studio interessiert? Wie stellst Du Dir die Implementierung für den Nibo vor?

Wa sind deine Hauptinteressen bezüglich Programmierung des Nibo?

So, da bin ich wieder!
1) Mal eine Frage, den Verbrauch betreffend: soweit ich weiß, haben Asuro und Nibo die gleichen Antriebsmotoren. Diese sind doch die größten Verbraucher, oder? (Mein Nibo hat kein Display!) Wieso braucht Nibo so viel mehr Leistung?
2) Gibt es ein "HowTo" zum Laden des ersten selbsterstellten Programms? In etwa so: Starten Atmel Studio 4.13, Einbinden der header .... (Pfadangaben ...), Kompilieren, Flashen (per ISP-Schnittstelle)
3) 7805: Eine fertig bestückte Leiterplatte kann leicht verwendet werden (ohne "nachlöten"). Ich würde übrigens niemals meinen Asuro und Nibo bei ebay verhökern!! Was sind das für Menschen....
4) MSRS: anderer Faden, aber ich verstehe dort die Aussage: ... service fertig nicht?!?!
Gruß
Lisbeth

1) http://nibo.editthis.info/wiki/Stromversorgung (Verbrauchsdaten)
Das Display ist doch das Sahnehäubchen beim Nibo! Ohne Display könnte ich mir überhaupt nicht vorstellen.
2) Ist in Entwicklung. Frage mal beim Entwickler nach. Vielleicht erhälst Du eine Vorabversion. Wenn nein, sagst Du mir Bescheid, dann stelle ich ein kleines Beispiel für AVR Studio auf meine Homepage. Wenn Du das allerdings noch nicht alleine schaffst, wird C++ schwierig, da man da alles manuell im makefile erledigen muss. AVR Studio unterstützt C++ nicht wirklich, es duldet es nur. Das Thema muss ich wohl auf meiner Homepage beschreiben, wenn das Programmiertutorial das nicht umfasst.
3) Du hängst also doch schon etwas an dem "altklugen" Traktor. ;)
4) "... service fertig nicht?!?!" Wie meinen? :)