Ein Asuro roboterbausatz ist gut geeignet um die C++ Grundlagen zu lernen.Das interessiert mich jetzt doch! Warum findet man keine Beschreibungen über die Art der Durchführung und Beispielprogramme in C++ für den ASURO? Auf dem ATmega128 des Nibo ist C++ überhaupt kein Problem. Allerdings muss man AVR Studio/WinAVR noch ziemlich herum heben, damit diese ansonsten komfortable Kombi überhaupt bereit ist, C++ zu übersetzen. Hier ein Beispiel-Programm für den Nibo:
#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 *
******************/
/*
// nur 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);
}
Zeige bitte mal eines für den ASURO. ;-)