C/C++ erlernen

Hallo MiniMax,

ob Du C oder C++ lernernen willst musst Du selbst entscheiden. Dev-C++ ist keine Programmiersprache sondern eine IDE (Integrated Development Environment - Integrierte Entwicklungsumgebung), ein Programm, das man zum Erstellen von Anwendungen braucht.

MfG Mark

Wenn Du nichts mit Microcontroller am Hut hast, was ich nicht annehme, wenn Du hier landest, und Objekt-Orientierte Programmierung (OOP) lernen willst, empfehle ich C++ und Java. Das richtige Forum mit allen Tipps findest Du hier: www.c-plusplus.de
Gute C++-Tutorials: siehe http://www.henkessoft.de/C++/Links/links.htm

Hallo zusammen,
ich möchte mal alles klarstellen:

- 13 Jahre alt
- Bremen
- Roboter, PC, Modellbau,

Ich suche einfach nur Hilfe über Roboter in diesem Forum!
Ich habe auch schon bemerkt dass alle hier sehr hilfsbereit sind.
Dafür sage ich Schonmahl D A N K E =P~

Und nun zum Eigentlichen Thema:

Ich baue mit meinem Freund, der gar keine Ahnung hat im Gegensatz zu mir hat, einen Roboter ohne irgendeinen Bausatz! Die Schaltungen Löte ich mir, anhand Bauanleitungen die im Roboter Netz sind, zusammen!
Wenn jemand Tipps, Vorschläge, Warnungen oder sogar Schaltpläne hat wäre ich sehr dankbar wenn sie mir per E-Mail geschickt oder ins Forum geschrieben werden.

MiniMax
-----------------------------------------------------------------------------

E-Mail: h.m.p.flyer@hotmail.de

Danke für die Info und vor allem viel Erfolg bei eurem Vorhaben. Nehmt euch nicht zu viel auf einmal vor, besser immer kleine Schritte, die ihr auch prüfen könnt.

Welchen Microcontroller wollt ihr einsetzen?
Wie wird der Roboter angetrieben und geregelt?

Schaut euch andere Vorbilder genau an:
z.B. ASURO, Nibo, c't-Bot, RP6, RN-Platinen.

Hallo ehenkes,
Welchen Mikrocontroller wir nehmen wollte ich euch mal Fragen!
Wie er angetrieben wird ist noch unklar, wir schwanken zwischen Kette und Rädern! Was ist besser?
Einmal die Feststehenden sachen im Überblick:

- Kamera schwenkbar
- RN-Speak
- Alle möglichen Sensoren

Welche Steuerplatine sollen wir nehmen?

MiniMax :-)

-----------------------------------------------------
E-Mail: h.m.p.flyer@hotmail.de

OK, also das übliche Vorhaben, ein Roboter, der "sieht, spricht und fühlt".
Setzt euch vorsichtshalber klare, technisch und finanziell erreichbare Zwischenziele. Diese beiden Boards könnten für euch das Richtige sein:
https://www.roboternetz.de/wissen/index.php/RN-Control
https://www.roboternetz.de/wissen/in...p/RNBFRA-Board
Wenn ihr einen Kettenantrieb bevorzugt, würde ich einen fertigen RP6 empfehlen, den könnt ihr dann mit Sensorik zu pflastern. Vor allem habt ihr dann schon eine funktionierende C-Bibliothek.
Prozessorempfehlung: ATmega32 oder höher.

Danke ehnekes!
Weitere Ideen sind auch noch gut also ich schaue morgen wiedr ins forum!

Bis bald

MiniMax

Wie gefällt euch der Nibo?

Ein Asuro roboterbausatz ist gut geeignet um die C++ Grundlagen zu lernen.

Zitat:

---

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:

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  *
******************/

/*
// 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. ;-)