/*
    Atmega8
    Pollin Funk-AVR-Evaluationsboard v1.1
 
    Project -> Configuration Options in AVR Studio:
    Frequency:    1000000 bzw. 12000000
    Optimization: -Os
*/
#include <avr/io.h>
#include <util/delay.h>
 
// LEDs sind active-high geschaltet
#define LED_AN(LED)	(PORTD |=  (1<<(LED)))
#define LED_AUS(LED)	(PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED)	(PORTD ^=  (1<<(LED)))
#define LED1		PD6
#define LED2		PD5
#define TASTER	        PB1
 
int main(void)
{
  DDRB &= ~(1<<TASTER);          // Port B: Eingang für Taster
  DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2
 
  // Anfangseinstellung
  LED_AN(LED1);
  LED_AUS(LED2);
 
  while(1)
  {
    _delay_ms(1000);  // Wert 1000 erlaubt ab avr-libc 1.6
    LED_TOGGLE(LED1);
    LED_TOGGLE(LED2);
  }
}

/*
    Atmega8
    Externer Quarz-Oszillator: 12 MHz
 
    Pollin Funk-AVR-Evaluationsboard v1.1
*/
 
#include <avr/io.h>
#include <util/delay.h>
 
// LEDs sind high-active geschaltet
#define LED_AN(LED)	(PORTD |=  (1<<(LED)))
#define LED_AUS(LED)	(PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED)	(PORTD ^=  (1<<(LED)))
#define LED1		PD6
#define LED2		PD5
 
// TASTER ist high-active geschaltet 
#define TASTER	PB1
#define TASTER_GEDRUECKT()	(PINB & (1<<TASTER))
 
int main(void)
{
  DDRB &= ~(1<<TASTER);	         // Port B: Eingang für Taster
  DDRD |= (1<<LED1) | (1<<LED2); // Port D: Ausgang für LED1 und LED2
 
  while(1)
  {
    if (!TASTER_GEDRUECKT())
    {
      // Taster ist nicht (!) gedrückt
      LED_AN(LED1);
      LED_AUS(LED2);
    }
    else
    {
      // Taster ist gedrückt
      LED_AUS(LED1);
      LED_AN(LED2);
    }
  }
}

/*
    Atmega8
    Externer Quarz-Oszillator: 12 MHz
 
    Pollin Funk-AVR-Evaluationsboard v1.1
*/
 
#include <avr/io.h>
#include <util/delay.h>
#include <inttypes.h>
 
// LEDs sind high-active geschaltet
#define LED_AN(LED)	(PORTD |=  (1<<(LED)))
#define LED_AUS(LED)	(PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED)	(PORTD ^=  (1<<(LED)))
#define LED1		PD6
#define LED2		PD5
 
// TASTER ist high-active geschaltet 
#define TASTER	PB1
#define TASTER_GEDRUECKT()	(PINB & (1<<TASTER))
#define TASTE_AUF 0
#define TASTE_ZU  1
 
void ausgabe(uint8_t wert)
{
  if (wert & (1<<0)) // Bit 0
    LED_AN(LED1);
  else
    LED_AUS(LED1);
 
  if (wert & (1<<1)) // Bit 1
    LED_AN(LED2);
  else
    LED_AUS(LED2);
}
 
int main(void)
{
  uint8_t alter_tastenzustand = TASTE_AUF;
  uint8_t zaehler = 0;
 
  DDRB &= ~(1<<TASTER);			// Port B: Eingang für Taster
  DDRD |= (1<<LED1) | (1<<LED2);	// Port D: Ausgang für LED1 und LED2
 
  while(1)
  {
    ausgabe(zaehler);
 
    if (TASTER_GEDRUECKT() && (alter_tastenzustand == TASTE_AUF))
    {
      // Wechsel von OFFEN nach GESCHLOSSEN
      zaehler++;
      alter_tastenzustand = TASTE_ZU;
    }
 
    if (!TASTER_GEDRUECKT())
      alter_tastenzustand = TASTE_AUF;
  }
}

/*
    Pollin Funk-AVR-Evaluationsboard v1.1
    Atmega8
 
    Externer Quarz-Oszillator: 12 MHz
    Optimierung: -Os
 
    RS232-Einstellungen:
    9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
 
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
 
// LEDs sind high-active geschaltet
#define LED_AN(LED)     (PORTD |=  (1<<(LED)))
#define LED_AUS(LED)    (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^=  (1<<(LED)))
#define LED1            PD6
#define LED2            PD5
 
// TASTER ist high-active geschaltet
#define TASTER             PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF          0
#define TASTE_ZU           1
/* in Millisekunden */
#define ENTPRELLUNG        10
 
void UART_init(void)
{
    // Baudrate setzen
    // 9600 Baud bei F_CPU 12 MHz
    // (Baudratenfehler = +0,2%)
    UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
    UBRRL = (uint8_t)  (F_CPU / (16 * 9600L) - 1);
 
    //      Empfangen,   Senden erlauben
    UCSRB = (1<<RXEN) | (1<<TXEN);
 
    // Frame Format:              8 Bits,                  No Parity,          1 Stopbit
    UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}
 
// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
    // sofort zurückkehren und Zustand melden
    return UCSRA & (1<<RXC);
}
 
// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
    // Warte bis UART Eingang voll
    while ( !(UCSRA & (1<<RXC)) )
        ;
    return UDR;
}
 
// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
    // Warte bis UART Ausgang frei
    while ( !(UCSRA & (1<<UDRE)) )
        ;
    UDR = z;
}
 
// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
    while ( *s )
    {
        UART_putchar(*s);
        s++;
    }
}
 
#define EINGABE_START 	0
#define EINGABE_ABBRUCH EINGABE_START
#define EINGABE_MAX 		3
#define FORMFEED '\014'
 
 
void rs232(uint8_t *wert)
{
    static int16_t alter_wert = -1;
    uint8_t anzahl_ziffern;
    uint8_t zeichen;
    char puffer[23];
 
    // Eingabe über RS232
 
    // Ohne Warten prüfen, ob Zeichen an UART vorhanden
    if ( UART_peekchar() )
    {
        // Zeichen ist da.
 
        // Aktuellen Wert ausgeben
 
        // Neue Seite im Terminal anfordern.
        // Bewirkt ein Löschen des Bildschirms
 
        UART_putchar(FORMFEED);
 
        // Einleitender Text, was im folgenden ausgegeben wird
        UART_puts("Alter Z\204hler = "); // \204 ist ä in Oktalschreibweise
 
        // Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
        itoa((int) *wert, puffer, 10);
        UART_puts(puffer);
 
        // Dann die gleiche Zahl in Hexadezimalziffern
        UART_puts(" 0x");
        itoa((int) *wert, puffer, 16);
        UART_puts(puffer);
 
        // Dann die gleiche Zahl in Binärziffern
        UART_puts(" 0b");
        itoa((int) *wert, puffer, 2);
        UART_puts(puffer);
 
        // Schliesslich noch der Zustand der LEDs auf dem Board senden
        UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
        UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
 
        // Zeilenabschluss zur Formatierung der Anzeige
        UART_puts("\r\n");
 
        // Neuen Wert eingeben
 
        // Initialisierung
        UART_puts("Eingabe> ");
        anzahl_ziffern = EINGABE_START;
 
        // Eingabeschleife
        do
        {
            // 1. bereits Zeichen am UART Eingang abholen
            // in weiteren Schleifen auf neue Zeichen warten
            zeichen = UART_getchar();
 
            // Zeichen auswerten
            if ( (zeichen == '-') && (anzahl_ziffern == EINGABE_START) )
            {
                // MINUS
                UART_puts(" -1");
                UART_puts("\r\n");
                *wert -= 1;
                break;
            }
            else if ( (zeichen == '+') && (anzahl_ziffern == EINGABE_START) )
            {
                // PLUS
                UART_puts(" +1");
                UART_puts("\r\n");
                *wert += 1;
                break;
            }
            else if ( (zeichen == '\n') || (zeichen == '\r') )
            {
                // ENTER oder RETURN: Abschluss der Eingabe
                break;
            }
            else if ( (zeichen >= '0') && (zeichen <= '9') )
            {
                // Eingabe einer Ziffer
                UART_putchar(zeichen); // Echo
                puffer[anzahl_ziffern++] = zeichen;
                puffer[anzahl_ziffern] = 0;
            }
            else
            {
                // Sonstiges Zeichen ist für uns illegal
                anzahl_ziffern = EINGABE_ABBRUCH;
                UART_puts(" Abbruch.");
                UART_puts("\r\n");
                break;
            }
        }
        while ( anzahl_ziffern < EINGABE_MAX );
 
        // Eingabe prüfen
        if ( anzahl_ziffern != EINGABE_ABBRUCH )
        {
            // Ziffern in Zahl umwandeln
            int i = atoi(puffer);
 
            // z.B. erlaubter Wertebereich sei 0 bis 255
            if ( (i >= 0) && (i < 256) )
            {
                UART_puts(" Ok.");
                UART_puts("\r\n");
                *wert = (uint8_t) i;
            }
            else
                UART_puts(" Ung\201ltig.\r\n"); // \201 ist ü in Oktalschreibweise
        }
    }
 
    // Ausgabe auf RS232 (s.oben)
    // bei nur Änderung des Wertes gegenüber der letzten Ausgabe
    //
    // alter_wert wurde mit -1 initialisiert. Das ist ausserhalb
    // des Wertebereichs von *wert, D.h. spätere Abfrage, ob
    // (alter_wert != *wert) ist, ist beim ersten Durchlauf wie
    // gewünscht wahr,
    //
    if (alter_wert != *wert)
    {
        alter_wert = *wert;
        UART_puts("Z\204hler = ");
        itoa((int) *wert, puffer, 10);
        UART_puts(puffer);
        UART_puts(" 0x");
        itoa((int) *wert, puffer, 16);
        UART_puts(puffer);
        UART_puts(" 0b");
        itoa((int) *wert, puffer, 2);
        UART_puts(puffer);
        UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
        UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
        UART_puts("\r\n");
    }
}
 
void ausgabe_led(uint8_t wert)
{
    if (wert & (1<<0)) // Bit 0
        LED_AN(LED1);
    else
        LED_AUS(LED1);
 
    if (wert & (1<<1)) // Bit 1
        LED_AN(LED2);
    else
        LED_AUS(LED2);
}
 
int main(void)
{
    uint8_t alter_tastenzustand = TASTE_AUF;
    uint8_t zaehler = 0;
 
    DDRB &= ~(1<<TASTER);           // Port B: Eingang für Taster
    DDRD |= (1<<LED1) | (1<<LED2);  // Port D: Ausgang für LED1 und LED2
 
    UART_init();
    UART_putchar(FORMFEED);
 
    while (1)
    {
        rs232(&zaehler);
 
        ausgabe_led(zaehler);
 
        if ( TASTER_GEDRUECKT() )
        {
#if ENTPRELLUNG
            _delay_ms(ENTPRELLUNG);
            if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
            {
                // Wechsel von OFFEN nach GESCHLOSSEN?
                if ( alter_tastenzustand == TASTE_AUF )
                {
                    zaehler++;
                    alter_tastenzustand = TASTE_ZU;
                }
            }
        }
 
        if ( !TASTER_GEDRUECKT() )
        {
#if ENTPRELLUNG
            _delay_ms(ENTPRELLUNG);
            if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
                alter_tastenzustand = TASTE_AUF;
        }
    }
}

/*
    Pollin Funk-AVR-Evaluationsboard v1.1
    Atmega8
 
    Externer Quarz-Oszillator: 12 MHz
    Optimierung: -Os
 
    RS232-Einstellungen:
    9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
 
#include "funkhw.h"
#include "rs232.h"
#include "lcd-routines.h"
 
/* in Millisekunden */
#define ENTPRELLUNG        10
 
void ausgabe_lcd(uint8_t wert)
{
    static int16_t alter_wert = -1;
    char puffer[23];
 
    if (wert != alter_wert)
    {
        // Ausgabe nur bei Änderungen
        alter_wert = wert;
        itoa((int) wert, puffer, 10);
 
        lcd_clear();
        lcd_string("Zaehler = ");
        lcd_string(puffer);
    }
}
 
void ausgabe_led(uint8_t wert)
{
    if (wert & (1<<0)) // Bit 0
        LED_AN(LED1);
    else
        LED_AUS(LED1);
 
    if (wert & (1<<1)) // Bit 1
        LED_AN(LED2);
    else
        LED_AUS(LED2);
}
 
int main(void)
{
    uint8_t alter_tastenzustand = TASTE_AUF;
    uint8_t zaehler = 0;
 
    DDRB &= ~(1<<TASTER);           // Port B: Eingang für Taster
    DDRD |= (1<<LED1) | (1<<LED2);  // Port D: Ausgang für LED1 und LED2
 
    UART_init();
    UART_putchar(FORMFEED);
 
    lcd_init();
 
    while (1)
    {
        rs232(&zaehler);			// RS232 Eingabe und Ausgabe
 
        ausgabe_lcd(zaehler); // LCD Ausgabe
 
        ausgabe_led(zaehler); // LED Ausgabe
 
        if ( TASTER_GEDRUECKT() )
        {
#if ENTPRELLUNG
            _delay_ms(ENTPRELLUNG);
            if ( TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
            {
                // Wechsel von OFFEN nach GESCHLOSSEN?
                if ( alter_tastenzustand == TASTE_AUF )
                {
                    zaehler++;
                    alter_tastenzustand = TASTE_ZU;
                }
            }
        }
 
        if ( !TASTER_GEDRUECKT() )
        {
#if ENTPRELLUNG
            _delay_ms(ENTPRELLUNG);
            if ( !TASTER_GEDRUECKT() )
#endif /* ENTPRELLUNG */
                alter_tastenzustand = TASTE_AUF;
        }
    }
}

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
// Die Pinbelegung ist über defines in lcd-routines.h einstellbar
 
#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>
 
// sendet ein Datenbyte an das LCD
 
void lcd_data(unsigned char temp1)
{
    unsigned char temp2 = temp1;
 
    LCD_PORT |= (1<<LCD_RS);        // RS auf 1 setzen
 
    temp1 = temp1 >> 4;
    temp1 = temp1 & 0x0F;
    LCD_PORT &= 0xF0;
    LCD_PORT |= temp1;               // setzen
    lcd_enable();
 
    temp2 = temp2 & 0x0F;
    LCD_PORT &= 0xF0;
    LCD_PORT |= temp2;               // setzen
    lcd_enable();
 
    _delay_us(42);
}
 
// sendet einen Befehl an das LCD
 
void lcd_command(unsigned char temp1)
{
    unsigned char temp2 = temp1;
 
    LCD_PORT &= ~(1<<LCD_RS);        // RS auf 0 setzen
 
    temp1 = temp1 >> 4;              // oberes Nibble holen
    temp1 = temp1 & 0x0F;            // maskieren
    LCD_PORT &= 0xF0;
    LCD_PORT |= temp1;               // setzen
    lcd_enable();
 
    temp2 = temp2 & 0x0F;            // unteres Nibble holen und maskieren
    LCD_PORT &= 0xF0;
    LCD_PORT |= temp2;               // setzen
    lcd_enable();
 
    _delay_us(42);
}
 
// erzeugt den Enable-Puls
void lcd_enable(void)
{
    // Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers einfügen
    // http://www.mikrocontroller.net/topic/81974#685882
    LCD_PORT |= (1<<LCD_EN);
#if 1
    _delay_us(4); // kurze Pause, Original aus dem Tutorial ist bei meinem Display zu kurz!
#else
    _delay_us(1); // kurze Pause
#endif
    // Bei Problemen ggf. Pause gemäß Datenblatt des LCD Controllers verlängern
    // http://www.mikrocontroller.net/topic/80900
    LCD_PORT &= ~(1<<LCD_EN);
}
 
// Initialisierung:
// Muss ganz am Anfang des Programms aufgerufen werden.
 
void lcd_init(void)
{
    LCD_DDR = LCD_DDR | 0x0F | (1<<LCD_RS) | (1<<LCD_EN);   // Port auf Ausgang schalten
 
    // muss 3mal hintereinander gesendet werden zur Initialisierung
 
    _delay_ms(15);
    LCD_PORT &= 0xF0;
    LCD_PORT |= 0x03;
    LCD_PORT &= ~(1<<LCD_RS);      // RS auf 0
    lcd_enable();
 
    _delay_ms(5);
    lcd_enable();
 
    _delay_ms(1);
    lcd_enable();
    _delay_ms(1);
 
    // 4 Bit Modus aktivieren
    LCD_PORT &= 0xF0;
    LCD_PORT |= 0x02;
    lcd_enable();
    _delay_ms(1);
 
    // 4Bit / 2 Zeilen / 5x7
    lcd_command(0x28);
 
    // Display ein / Cursor aus / kein Blinken
    lcd_command(0x0C);
 
    // inkrement / kein Scrollen
    lcd_command(0x06);
 
    lcd_clear();
}
 
// Sendet den Befehl zur Löschung des Displays
 
void lcd_clear(void)
{
    lcd_command(CLEAR_DISPLAY);
    _delay_ms(5);
}
 
// Sendet den Befehl: Cursor Home
 
void lcd_home(void)
{
    lcd_command(CURSOR_HOME);
    _delay_ms(5);
}
 
// setzt den Cursor in Zeile y (1..4) Spalte x (0..15)
 
void set_cursor(uint8_t x, uint8_t y)
{
    uint8_t tmp;
 
    switch (y)
    {
    case 1:
        tmp=0x80+0x00+x;
        break;    // 1. Zeile
    case 2:
        tmp=0x80+0x40+x;
        break;    // 2. Zeile
    case 3:
        tmp=0x80+0x10+x;
        break;    // 3. Zeile
    case 4:
        tmp=0x80+0x50+x;
        break;    // 4. Zeile
    }
    lcd_command(tmp);
}
 
// Schreibt einen String auf das LCD
 
void lcd_string(char *data)
{
    while (*data)
    {
        lcd_data(*data);
        data++;
    }
}

// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
void lcd_data(unsigned char temp1);
void lcd_string(char *data);
void lcd_command(unsigned char temp1);
void lcd_enable(void);
void lcd_init(void);
void lcd_home(void);
void lcd_clear(void);
void set_cursor(uint8_t x, uint8_t y);
 
#if 0
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!
#define F_CPU 8000000
#endif
 
// LCD Befehle
 
#define CLEAR_DISPLAY 0x01
#define CURSOR_HOME   0x02
 
// Pinbelegung für das LCD, an verwendete Pins anpassen
 
#if 1
// Änderung des LCD Anschlusses
// Pollin Funk AVR Evaluationsboard v1.1
// DB4 bis DB7 des LCD sind mit PC0 bis PC3 des AVR verbunden
#define LCD_PORT      PORTC
#define LCD_DDR       DDRC
#define LCD_EN        PC5
#define LCD_RS        PC4
#define LCD_DB7       PC3
#define LCD_DB6       PC2
#define LCD_DB5       PC1
#define LCD_DB4       PC0
#else
#define LCD_PORT      PORTD
#define LCD_DDR       DDRD
#define LCD_RS        PD4
#define LCD_EN        PD5
// DB4 bis DB7 des LCD sind mit PD0 bis PD3 des AVR verbunden
#endif 

/*
    Pollin Funk-AVR-Evaluationsboard v1.1
    Atmega8
*/
 
// LEDs sind high-active geschaltet
#define LED_AN(LED)     (PORTD |=  (1<<(LED)))
#define LED_AUS(LED)    (PORTD &= ~(1<<(LED)))
#define LED_TOGGLE(LED) (PORTD ^=  (1<<(LED)))
#define LED1            PD6
#define LED2            PD5
 
// TASTER ist high-active geschaltet
#define TASTER             PB1
#define TASTER_GEDRUECKT() (PINB & (1<<TASTER))
#define TASTE_AUF          0
#define TASTE_ZU           1 

#ifndef FORMFEED
#define FORMFEED '\014'
#endif
 
void UART_init(void);
 
// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void);
 
// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void);
 
// Zeichen in UART Ausgang geben
void UART_putchar(char z);
 
// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s);
 
void rs232(uint8_t *wert);

/*
    Pollin Funk-AVR-Evaluationsboard v1.1
    Atmega8
 
    Externer Quarz-Oszillator: 12 MHz
    Optimierung: -Os
 
    RS232-Einstellungen:
    9600 Baud, 8 Bits, No Parity, 1 Stopbit
*/
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
 
#include "funkhw.h"
#include "rs232.h"
 
#define EINGABE_START 	0
#define EINGABE_ABBRUCH EINGABE_START
#define EINGABE_MAX 		3
 
void UART_init(void)
{
    // Bausrate setzen
    // 9600 Baud bei F_CPU 12 MHz
    // (Baudratenfehler = +0,2%)
    UBRRH = (uint8_t) ((F_CPU / (16 * 9600L) - 1) >> 8);
    UBRRL = (uint8_t)  (F_CPU / (16 * 9600L) - 1);
 
    //      Empfangen,   Senden erlauben
    UCSRB = (1<<RXEN) | (1<<TXEN);
 
    // Frame Format:              8 Bits,                  No Parity,          1 Stopbit
    UCSRC = (1<<URSEL) | ((1<<UCSZ1) | (1<<UCSZ0)) | ((0<<UPM1) | (0<<UPM0)) | (0<<USBS);
}
 
// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void)
{
    // sofort zurückkehren und Zustand melden
    return UCSRA & (1<<RXC);
}
 
// Auf Zeichen im UART Eingang warten
uint8_t UART_getchar(void)
{
    // Warte bis UART Eingang voll
    while ( !(UCSRA & (1<<RXC)) )
        ;
    return UDR;
}
 
// Zeichen in UART Ausgang geben
void UART_putchar(char z)
{
    // Warte bis UART Ausgang frei
    while ( !(UCSRA & (1<<UDRE)) )
        ;
    UDR = z;
}
 
// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s)
{
    while ( *s )
    {
        UART_putchar(*s);
        s++;
    }
}
 
void rs232(uint8_t *wert)
{
    static int16_t alter_wert = -1;
    uint8_t anzahl_ziffern;
    uint8_t zeichen;
    char puffer[23];
 
    // Eingabe über RS232
 
    // Ohne Warten prüfen, ob Zeichen an UART vorhanden
    if ( UART_peekchar() )
    {
        // Zeichen ist da.
 
        // Aktuellen Wert ausgeben
 
        // Neue Seite im Terminal anfordern.
        // Bewirkt ein Löschen des Bildschirms
 
        UART_putchar(FORMFEED);
 
        // Einleitender Text, was im folgenden ausgegeben wird
        UART_puts("Alter Z\204hler = "); // \204 ist ä in Oktalschreibweise
 
        // Zahl in Ziffernfolge umwandeln. Hier zuerst in Dezimalziffern
        itoa((int) *wert, puffer, 10);
        UART_puts(puffer);
 
        // Dann die gleiche Zahl in Hexadezimalziffern
        UART_puts(" 0x");
        itoa((int) *wert, puffer, 16);
        UART_puts(puffer);
 
        // Dann die gleiche Zahl in Binärziffern
        UART_puts(" 0b");
        itoa((int) *wert, puffer, 2);
        UART_puts(puffer);
 
        // Schliesslich noch der Zustand der LEDs auf dem Board senden
        UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
        UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
 
        // Zeilenabschluss zur Formatierung der Anzeige
        UART_puts("\r\n");
 
        // Neuen Wert eingeben
 
        // Initialisierung
        UART_puts("Eingabe> ");
        anzahl_ziffern = EINGABE_START;
 
        // Eingabeschleife
        do
        {
            // 1. bereits Zeichen am UART Eingang abholen
            // in weiteren Schleifen auf neue Zeichen warten
            zeichen = UART_getchar();
 
            // Zeichen auswerten
            if ( (zeichen == '-') && (anzahl_ziffern == EINGABE_START) )
            {
                // MINUS
                UART_puts(" -1");
                UART_puts("\r\n");
                *wert -= 1;
                break;
            }
            else if ( (zeichen == '+') && (anzahl_ziffern == EINGABE_START) )
            {
                // PLUS
                UART_puts(" +1");
                UART_puts("\r\n");
                *wert += 1;
                break;
            }
            else if ( (zeichen == '\n') || (zeichen == '\r') )
            {
                // ENTER oder RETURN: Abschluss der Eingabe
                break;
            }
            else if ( (zeichen >= '0') && (zeichen <= '9') )
            {
                // Eingabe einer Ziffer
                UART_putchar(zeichen); // Echo
                puffer[anzahl_ziffern++] = zeichen;
                puffer[anzahl_ziffern] = 0;
            }
            else
            {
                // Sonstiges Zeichen ist für uns illegal
                anzahl_ziffern = EINGABE_ABBRUCH;
                UART_puts(" Abbruch.");
                UART_puts("\r\n");
                break;
            }
        }
        while ( anzahl_ziffern < EINGABE_MAX );
 
        // Eingabe prüfen
        if ( anzahl_ziffern != EINGABE_ABBRUCH )
        {
            // Ziffern in Zahl umwandeln
            int i = atoi(puffer);
 
            // z.B. erlaubter Wertebereich sei 0 bis 255
            if ( (i >= 0) && (i < 256) )
            {
                UART_puts(" Ok.");
                UART_puts("\r\n");
                *wert = (uint8_t) i;
            }
            else
                UART_puts(" Ung\201ltig.\r\n"); // \201 ist ü in Oktalschreibweise
        }
    }
 
    // Ausgabe auf RS232 (s.oben)
    // bei nur Änderung des Wertes gegenüber der letzten Ausgabe
    //
    // alter_wert wurde mit -1 initialisiert. Das ist ausserhalb
    // des Wertebereichs von *wert, D.h. spätere Abfrage, ob
    // (alter_wert != *wert) ist, ist beim ersten Durchlauf wie
    // gewünscht wahr,
    //
    if (alter_wert != *wert)
    {
        alter_wert = *wert;
        UART_puts("Z\204hler = ");
        itoa((int) *wert, puffer, 10);
        UART_puts(puffer);
        UART_puts(" 0x");
        itoa((int) *wert, puffer, 16);
        UART_puts(puffer);
        UART_puts(" 0b");
        itoa((int) *wert, puffer, 2);
        UART_puts(puffer);
        UART_puts( (*wert & 2) ? " LED2-An " : " LED2-Aus");
        UART_puts( (*wert & 1) ? " LED1-An" : " LED1-Aus");
        UART_puts("\r\n");
    }
}