C++ E/A für den ATmega8

[Rüdiger Knörig (Gast)]

Im Rahmen eines kleinen Projekts habe ich für den ATmega8 eine Klasse 
für die serielle Ein/Ausgabe geschrieben, welche ohne großen 
Ressourcenaufwand typischen C++-Komfort anbietet:

#include "USARTMega8.h"

using namespace std;

int main()
{
  DDRB=0x3;
  PORTB=0x0;
  USARTMega8<9600> usart;
  int zahl;
  while(true)
  {
    usart << "Zahl eingeben: ";
    usart >> zahl;
    if(usart.warErfolgreich())
    {
      usart << endl << "Eingegebene Zahl: " << zahl << endl;
    }
    else
    {
      usart << endl << "Fehler!" << endl;
    }
    PORTB ^= 0x2;
  }
}

Die USARTMega8-Klasse baut auf dem hier im C-Tutorium gezeigten 
Quelltext auf:

/**
 * @file USARTMega8.h
 * @brief Deklaration der USARTMega8-Klasse.
 * @author Dr. Rüdiger Knörig ([e-mail])
 * @date 11.07.2013
 */

#ifndef USARTMEGA_H_
#define USARTMEGA_H_

#include <avr/io.h>

using namespace std;

const char *endl="\n\r";

/**
 * @brief Serielle Schnittstellenklasse für den ATMega8.
 * @author Dr. Rüdiger Knörig ([e-mail])
 * @date 11.07.2013
 * @tparam BaudRate Desired baud rate.
 */
template<unsigned long int BaudRate> class USARTMega8
{
public:

  /**
   * @brief Konstruktor.
   */
  USARTMega8() : erfolg(true)
  {
    uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*BaudRate) - 1);
    //uint16_t ubrr = (uint16_t) ((uint32_t) F_CPU/(16*9600ul) - 1);

    UBRRH = (uint8_t) (ubrr>>8);
    UBRRL = (uint8_t) (ubrr);

    // UART Receiver und Transmitter anschalten
    // Data mode 8N1, asynchron
    UCSRB = (1 << RXEN) | (1 << TXEN);
    UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);

    // Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte)
    do
    {
      UDR;
    }
    while (UCSRA & (1 << RXC));
  }

  /**
   * @brief Destruktor.
   */
  ~USARTMega8() {}

  /**
   * @brief Druckt ein einzelnes Zeichen.
   * @param[in] zeichen Zeichen zum Drucken.
   */
  void druckeZeichen(const char zeichen)
  {
      // Warten, bis UDR bereit ist für einen neuen Wert
      while (!(UCSRA & (1 << UDRE)));
      // UDR Schreiben startet die Übertragung
      UDR = zeichen;
  }

  /**
   * @brief Druckt eine ganze Zeichenkette.
   * @param[in] zeichenKette Zeichenkette zum Drucken.
   */
  void druckeZeichenkette(const char *zeichenKette)
  {
    while(*zeichenKette) druckeZeichen(*zeichenKette++);
  }

  /**
   * @brief Liest ein einzelnes Zeichen von der seriellen Schnittstelle.
   * Diese Methode wartet blockierend auf einen Empfang.
   */
  uint8_t leseZeichenBlockierend()
  {
      // Warten, bis etwas empfangen wird
      while (!(UCSRA & (1 << RXC)));

      // Das empfangene Zeichen zurückliefern
      return UDR;
  }

  /**
   * @brief Liest ein einzelnes Zeichen von der seriellen Schnittstelle.
   * Diese Methode wartet nicht auf einen Empfang.
   * @param[out] zeichen Referenz auf die aufnehmende Zeichenvariable.
   * @return Wahr, wenn ein Zeichen gelesen wurde.
   */
  bool leseZeichenNichtBlockierend(uint8_t &zeichen)
  {
    if((UCSRA & (1 << RXC)))
    {
      zeichen=UDR;
      return true;
    }
    else
    {
      return false;
    }
  }

  /**
   * @brief Liest eine Zeichenkette von der seriellen Schnittstelle ein.
   * @param[out] puffer Aufnahmepuffer.
   * @param[in] pufferLaenge Größe des Aufnahmepuffers.
   */
  void leseZeichenkette(char *puffer,unsigned int pufferLaenge)
  {
    char *ende=puffer + pufferLaenge - 1;
    while(puffer < ende)
    {
      char zeichen=leseZeichenBlockierend();
      if((zeichen==' ') || (zeichen == '\t') || (zeichen == '\n')) break;
      *(puffer++)=zeichen;
    }
    *puffer=0;
  }

  /**
   * @brief Vergleicht zwei Zeichenketten.
   * @param[in] zk1 Erste Zeichenkette.
   * @param[in] zk2 Zweite Zeichenkette.
   * @param[in] maxLaenge Maximale Länge der Zeichenketten.
   * @return 0 wenn beide Zeichenketten identisch sind, -1 wenn zk1 < zk2 und 1 wenn zk1 > zk2.
   */
  int vergleicheZeichenketten(const char *zk1,const char *zk2,unsigned int maxLaenge)
  {
    for(unsigned int k=0;k<maxLaenge;k++)
    {
      char z1=zk1[k];
      char z2=zk2[k];
      if((z1==0) || (z2 == 0))
      {
        if((z1==0) && (z2 != 0)) return -1;
        if((z2==0) && (z1 != 0)) return 1;
        return 0;
      }
      else
      {
        if(z1 < z2) return -1;
        if(z1 > z2) return 1;
      }
    }
    return 0;
  }

  /**
   * @brief Liest eine Ganzzahl ein.
   * @param[out] zahl Referenz auf die aufnehmende Ganzzahlvariable.
   * @return Wahr, wenn eine Zahl ohne Probleme eingelesen werden konnte.
   */
  bool leseZahl(int &zahl)
  {
    bool ziffernGelesen=false;
    bool hatVorzeichen=false;
    bool erfolg=false;
    bool negativ=false;
    zahl=0;
    do{
      uint8_t zeichen=leseZeichenBlockierend();
      if((zeichen == ' ') || (zeichen == '\t') || (zeichen == '\n') || (zeichen == '\r'))
      {
        erfolg=ziffernGelesen;
        if((ziffernGelesen==false) && ((zeichen == ' ') || (zeichen == '\t'))) continue;
        else break;
      }
      else if((zeichen == '+') || (zeichen == '-'))
      {
        if(hatVorzeichen) return false;
        if(zeichen == '-') negativ=true;
        hatVorzeichen=true;
        druckeZeichen(zeichen);
      }
      else if((zeichen >= '0') && (zeichen <= '9'))
      {
        zahl = zahl*10+(zeichen-'0');
        ziffernGelesen=true;
        druckeZeichen(zeichen);
      }
      else
      {
        druckeZeichenkette("Falsch!\n\r");
        return false;
      }
    }while(true);
    if(negativ) zahl=(~zahl+1);
    return erfolg;
  }

  /**
   * @brief Druckt die gegebene Zahl auf der seriellen Konsole aus.
   * @param[in] zahl Auszudruckende Zahl.
   */
  void schreibeZahl(int32_t zahl)
  {
    char puffer[10];
    char *ptr=puffer+10;
    char *endPtr=ptr;

    if(zahl < 0)
    {
      druckeZeichen('-');
      zahl = (~zahl) + 1; // 2er-Komplementär invertieren
    }
    do
    {
      char ziffer='0'+(zahl % 10);
      *(--ptr)=ziffer;
      zahl /= 10;
    }while(zahl > 0);
    for(;ptr < endPtr;ptr++) druckeZeichen(*ptr);
  }

  /**
   * @brief Inspektor für den Erfolg der letzten Strom-Eingabe.
   * @return Wahr, wenn die letzte Stromeingabe erfolgreich war.
   */
  bool warErfolgreich() { return erfolg; }

  /**
   * @brief Strom-Ausgabeoperator für Zeichenketten.
   * @param[in] zeichenkette Auszugebende Zeichenkette.
   * @return Referenz auf das USART-Objekt zwecks Verkettung.
   */
  USARTMega8 &operator<<(const char *zeichenkette)
  {
    druckeZeichenkette(zeichenkette);
    return *this;
  }

  /**
   * @brief Strom-Ausgabeoperator für Zahlen.
   * @param[in] zahl Auszugebende Zahl
   * @return Referenz auf das USART-Objekt zwecks Verkettung.
   */
  USARTMega8 &operator<<(int zahl)
  {
    schreibeZahl(zahl);
    return *this;
  }

  /**
   * @brief Strom-Eingabeoperator für Zahlen.
   * @param[out] Zahl Referenz auf die einzulesende Zahl.
   * @return Referenz auf das USART-Objekt zwecks Verkettung.
   */
  USARTMega8 &operator>>(int &zahl)
  {
    erfolg=leseZahl(zahl);
    return *this;
  }

protected:
  bool erfolg; /**< Indiziert einen Erfolg/Mißerfolg bei der letzten Strom-Eingabe. */
};

#endif