Roboterbausatz Nibo

[ehenkes]

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:

#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.