16-Bit Zahl auf LCD

[Felix the cat (Gast)]

Ich hab ein Problem, ich möchte eine 16 Bit Binärzahl, die in zwei 
Registern ist, auf das LCD ausgeben und zwar als Integer Dezimalzahl 
habe aber noch keinen Plan wie ich das am besten realisieren soll.
Wenn ich z.B.  1111'1111'1111'1111 habe soll auf dem Display  -32768 
erscheinen, habe ich 111'1111'1111'1111 soll 32767 erscheinen.
Hat jemand eine Idee wie man das realisieren könnte?

[Ralf Schumnig (Gast)]

Hi Felix,

kennst Du http://www.atmel.com/atmel/acrobat/doc0938.pdf ?

Vorher würde ich das höchstwertigste Bit (Vorzeichen) testen, ggfls. 
Minuszeichen generieren und dann im MSB löschen.

Grüsse
Ralf

[Felix the cat (Gast)]

Hallo

Danke, ich habe es unterdessen geschafft!
Wer genaueres wissen möchte soll sich die Doku anschauen, die ich 
geschrieben habe (atached).

MfG

Felix

[dunial (Gast)]

Hallo,

kann jemand den oberen Code einmal in C für einen Mega8 umschreiben ?
Die 16Bit Zahl soll aus dem Zählregister des Timer1 gelesen werden und 
dann auf einem LCD-Display mit einer 4-Bit-Ansteuerung angezeigt werden.
Das wäre sehr nett.

Gruß
D.

[Karl H. (kbuchegg)]

dunial schrieb:
> Hallo,
>
> kann jemand den oberen Code einmal in C für einen Mega8 umschreiben ?
> Die 16Bit Zahl soll aus dem Zählregister des Timer1 gelesen werden und
> dann auf einem LCD-Display mit einer 4-Bit-Ansteuerung angezeigt werden.
> Das wäre sehr nett.
>

  char Buffer[8];
  uint16_t Wert;

  Wert = TCCR1;
  utoa( Wert, Buffer, 10 );
  lcd_string( Wert );

Wobei lcd_string eine Funktion ist, die einen Textstring auf einem LCD 
ausgeben können muss.

[H.Joachim S. (crazyhorse)]

oder sprintf(), ok, frisst rel. viel Platz.

[dunial (Gast)]

Hallo,

bei "Wert = TCCR1;" bringt der Compiler eine Fehlermeldung.
Ich dachte immer, es wird das TCNT1-Register ausgelesen und nicht das 
TCCR1.
Beim Test erscheinen keine Zahlen, sondern zusammenhangslose Buchstaben 
und Zeichen...

Der Zähler wird mit einem externen Signal gespeist, wobei die steigenden 
Flanken erkannt werden (TCCR1B=0x07;). Bei jedem Impuls zählt der Timer 
logischerweise immer 1 aufwärts, und das eine Minute lang (dafür 
verwende ich in einer Schleife den Timer0). Der aktuelle Wert soll, wie 
ich schon sagte, auf dem LCD erscheinen.
Ist es auch möglich, ein Komma an folgende Stelle zu setzen ("xxxxxx" zu 
"xxxx,xx") und wenn das vorletzte oder das letzte "x" = 0 ist, die leere 
Stelle hinter dem Komma und die Stelle vor dem Komma mit einer Null 
aufzufüllen (z.B. 0,54 (bei Zählstand 54) oder 0,09 (bei Zählstand 9) ?

Gruß
D.

[Karl H. (kbuchegg)]

dunial schrieb:
> Hallo,
>
> bei "Wert = TCCR1;" bringt der Compiler eine Fehlermeldung.
> Ich dachte immer, es wird das TCNT1-Register ausgelesen und nicht das
> TCCR1.

Du hast recht.
Ich hab nicht im Datenblatt nachgesehen und offensichtlich hat mir mein 
Gedächtnis beim schnellen Tippen einen Streich gespielt.

> Beim Test erscheinen keine Zahlen, sondern zusammenhangslose Buchstaben
> und Zeichen...

Dann zeig den möglichst kompletten Code.
Meine Kristallkugel tippt auf einen Array-Überlauf, weil du den 
Ausgabebuffer zu klein dimensioniert hast.

> Ist es auch möglich, ein Komma an folgende Stelle zu setzen ("xxxxxx" zu
> "xxxx,xx") und wenn das vorletzte oder das letzte "x" = 0 ist, die leere
> Stelle hinter dem Komma und die Stelle vor dem Komma mit einer Null
> aufzufüllen (z.B. 0,54 (bei Zählstand 54) oder 0,09 (bei Zählstand 9) ?

Alles ist möglich.
In dem Fall, wenn die Laufzeit bzw. Programmgröße nicht dagegen spricht, 
würde ich zu sprintf greifen

http://www.mikrocontroller.net/articles/FAQ#Wie_kann_ich_Zahlen_auf_LCD.2FUART_ausgeben.3F

  char Buffer[10];

  ...

  sprintf( Buffer, "%d,%02d", Wert / 100, Wert % 100 );
  lcd_string( Buffer );

[Ste N. (steno)]

Hallo dunial,

ich hatte mal das selbe Problem und nicht ausreichend Platz für 
sprintf(). Habe mir dann folgende Funktion geschrieben welche sicher 
noch nicht das Optimun ist, aber für meine Zwecke ausreichend war.

// Funktion Int to String (Zahl, länge des fertigen String, Komma)
// Komma = 2 -> Zahl / 100, Komma = 0 für kein Komma
char *int_to_str (signed long zahl, unsigned char len, signed char komma)
{
static char buffer[16]; // String für Übergabe  

buffer[len] = 0;
  
if (zahl<0)       // wenn Zahl negativ... 
{
  zahl = -zahl;     // Zahl positiv machen
  buffer[0] = '-';   // an erste Stelle im String ein '-' schreiben 
}
else buffer[0] = ' ';   // ansonsten ein Leerzeichen 

do
{  
  if ((komma < 0) && !(zahl % 10) && !(zahl / 10)) buffer[--len] = ' ';  // führende Nullen ausblenden
  else buffer[--len] = zahl % 10 + '0';  // Modulo 10 der Zahl in String schreiben
  
  if (--komma == 0) buffer[--len] = '.';  // wenn Kommastelle erreicht '.' schreiben
  
  zahl /= 10;    // Zahl durch 10
}
while (len > 1);   // solange bis der String voll ist, erstes Zeichen nicht überschreiben, Vorzeichen!
return buffer;
}

Viele Grüße,
Steffen

[Philipp B. (philipp_burch)]

Karl heinz Buchegger schrieb:
>> Beim Test erscheinen keine Zahlen, sondern zusammenhangslose Buchstaben
>> und Zeichen...
>
> Dann zeig den möglichst kompletten Code.
> Meine Kristallkugel tippt auf einen Array-Überlauf, weil du den
> Ausgabebuffer zu klein dimensioniert hast.

Meine Kristallkugel tippt eher darauf, dass du wenigstens den Puffer zum 
LCD schicken solltest und nicht den Int ;)

Anstelle

  char Buffer[8];
  uint16_t Wert;

  Wert = TCCR1;
  utoa( Wert, Buffer, 10 );
  lcd_string( Wert );

besser

  char Buffer[8];
  uint16_t Wert;

  Wert = TCNT1;
  utoa( Wert, Buffer, 10 );
  lcd_string( Buffer );

[Karl H. (kbuchegg)]

Philipp Burch schrieb:
> Karl heinz Buchegger schrieb:
>>> Beim Test erscheinen keine Zahlen, sondern zusammenhangslose Buchstaben
>>> und Zeichen...
>>
>> Dann zeig den möglichst kompletten Code.
>> Meine Kristallkugel tippt auf einen Array-Überlauf, weil du den
>> Ausgabebuffer zu klein dimensioniert hast.
>
> Meine Kristallkugel tippt eher darauf, dass du wenigstens den Puffer zum
> LCD schicken solltest und nicht den Int ;)


Mist.
Mea culpa.

Danke für die Korrektur.

[dunial (Gast)]

Hallo,

vielen Dank erst einmal für die vielen Antworten :-) !!
Den Code habe ich beigefügt. Evtl. ist es noch wichtig zu sagen, dass 
ich mit AVR Studio 4 und mit dem Compiler WinAVR arbeite.
Die Variante von Steffen werde ich morgen einmal ausprobieren.

Einmal zur Erläuterung meines Projektes:

Es soll eine Zähleinheit für einen selbstgebauten Geigerzähler werden. 
Der Impuls kommt von einem NE555, der die Impulse des Zählrohrs für den 
Mega8 aufbereitet.
Das Programm besteht aus 3 Unterprogrammen:
-Programm A: eine Minute lang die ankommenden Impulse zählen (soll auch 
schon auf LCD ausgegben werden). Nach der Minute soll das Ergebnis 15 
Sekunden lang angezeigt werden. Wenn keine andere Programmwahl durch 
einen Taster erfolgt, läuft das Programm A erneut durch. Durch einen 
Reset-Impuls (nicht der Reset des Controllers an Pin PC6 !) kann man zur 
main-Schleife zurückkehren.
-Programm B: 30 Sekunden lang messen. Danach das Ergebnis in der 2. 
Zeile anzeigen ('xxxx,xx 30sec.') und den Wert in µSv/h in der 1. Zeile 
berechnen und ausgeben.
-Programm C: 10 Sekunden messen. Sonst genau so wie B.
Das schwierige war nun, einen geeigneten Zähler zu programmieren. Der 
einfache 8Bit-Timer0 zählt ja nur bis 255. Da hätte man dann bei jedem 
Überlauf Variabeln setzen müssen und Gleichungen bearbeiten, damit der 
Gesamtzählwert angezeigt wird. Also dachte ich mir, nehme ich den Timer1 
der bis ca. 65.500 zählen kann. Da aber bei stark strahlenden Mineralien 
das noch nicht ausreicht, habe ich mit der Formel ZA=Z1+ZG gearbeitet. 
ZA ist der Ausgabewert auf dem LCD-Display. Z1 ist der momentane 
Zählwert des Timer1. Wenn Z1 größer gleich 50.000 ist, dann wird Z1=ZG 
gesetzt und der Timer1 wieder auf null gesetzt. Somit kann man insgesamt 
bis ca. 115.500 zählen. Das entspricht dann 1155,00µSv/h

Die strings für das LCD wollte ich in den EEPROM schreiben. Das 
Schreiben an sich hat auch funktioniert, aber beim Test war dann die 
ganze Anzeige schwarz ??? Deshalb habe ich die strings direkt in main 
eingegeben.

Gruß
Daniel

[Karl H. (kbuchegg)]

Die dringlichste Kritik:

Du solltest den Befehl 'goto' schleunigst aus dem C-Wortschatz 
streichen.

[Karl H. (kbuchegg)]

TCNT1=0x00;    //Z�hlregister Timer1 wird auf null gesetzt
      TCNT1H=0x00;  //High-Byte Timer1 wird auf null gesetzt
      TCNT1L=0x00;  //Low-Byte Timer1 wird auf null gesetzt


TCNT1 ist das 16-Bit Zählregister!
Bestehend aus TCNT1H und TCNT1L.
Obiges ist also doppelt gemoppelt.

[H.Joachim S. (crazyhorse)]

ach, manchmal ist goto sowas von nützlich.

[Karl H. (kbuchegg)]

if (TCNT1>=0xc350)  //ist Timer1 >= 50.000 ?


Warum schreibst du nicht gleich

      if (TCNT1 >= 50000)  //ist Timer1 >= 50.000 ?

Jetzt steht im Kommentar dasselbe wie im Code: -> Kommentar kann 
entfallen und braucht daher auch nicht weiter gepflegt werden. Und vor 
allen Dingen: Ein nicht vorhandener Kommentar kann auch nicht falsch 
sein, wenn der Code mal geändert wird.

[Karl H. (kbuchegg)]

H.joachim Seifert schrieb:
> ach, manchmal ist goto sowas von nützlich.

Aber nicht in diesem Programm :-)
Das ist an der Schwelle zum Spaghetti-Code

[dunial (Gast)]

"Die dringlichste Kritik:

Du solltest den Befehl 'goto' schleunigst aus dem C-Wortschatz
streichen."

...es funktioniert aber ;-)
Das werde ich natürlich in Zukunft anders lösen. Das ist mein erstes 
C-Programm, welches ich entwerfe. Da fällt einem selbst so ein 'Fehler' 
gar nicht auf.

Gruß
Daniel

[dunial (Gast)]

Hallo,
hier einmal ein Ausschnitt aus dem Quelltext. Der Sekundentimer und der 
eigentliche Programmablauf funktionieren einwandfrei (das "goto" habe 
ich erst einmal so gelassen (schäm*)). Nur das Anzeigen der Zahl 
funktioniert noch nicht. Die Variable 'za' soll angezeigt werden. Die 
Schleife "retmin1" dauert eine Minute und hier soll der laufende 
Zählstand des Timer1 auf dem LCD-Display ausgegeben werden.
Kann sich jemand einmal den Code ansehen und diesen berichtigen, damit 
das angezeigt wird, was ich will ?
Das wäre sehr nett.

Gruß
Daniel

...
zg=0x00;
za=0x00;
sekunde=0x00;
TCNT0=0x00;
TCCR0|=0x03;

...
      TCNT1=0x00;
      TCCR1B=0x07;
      goto retmin1;
    
retmin1:
      za=z1+zg;
      z1=TCNT1;
      
    set_cursor(0,1);

char *int_to_str (unsigned char len, signed char komma)
  {
  static char buffer[16];

  buffer[len] = 0;
  
  if (za<0) 
    {
      za = -za; 
      buffer[0] = '-';
    }
    else buffer[0] = ' ';

  do
  {  
    if ((komma < 0) && !(za % 10) && !(za / 10)) buffer[--len] = ' ';
    else buffer[--len] = za % 10 + '0';
  
    if (--komma == 0) buffer[--len] = '.';
  
    za /= 10;
  }
  while (len > 1);
return buffer;
}

if (TCNT0<0xff)
  {
  goto retmin1;
  }
if (TCNT0=0xff)
  {
  sekunde++;
  TCNT0=0x00;
    if (sekunde<=3685)
    {
    goto retmin1;
    }
    else
    {
    TCNT0=0x00;
    TCCR1B=0x00;
    set_cursor(2,2);
    ...
    }
   }
goto retmin1;
...

[Karl H. (kbuchegg)]

dunial schrieb:

> Kann sich jemand einmal den Code ansehen und diesen berichtigen, damit
> das angezeigt wird, was ich will ?

Du brauchst dringend ein C-Buch

Der Teil hier

char *int_to_str (int za, unsigned char len, signed char komma)
{
  static char buffer[16];

  buffer[len] = 0;
 
  if (za<0)
  {
    za = -za;
    buffer[0] = '-';
  }
  else buffer[0] = ' ';

  do
  {
    if ((komma < 0) && !(za % 10) && !(za / 10)) buffer[--len] = ' ';
    else buffer[--len] = za % 10 + '0';
 
    if (--komma == 0) buffer[--len] = '.';

    za /= 10;
  } while (len > 1);

  return buffer;
}

ist eine Funktion für sich. Die wird ausserhalb von main() geschrieben

char *int_to_str (int za, unsigned char len, signed char komma)
{
  ...
  ...
  return buffer;
}

int main()
{
  ...
}

Irgendwo musst du die Funktion dann aber auch aufrufen

...
retmin1:
      za=z1+zg;
      z1=TCNT1;
      
      set_cursor(0,1);

      ptr = int_to_str( za, 3, 1 );  // ob 3 und 1 stimmen kann ich nicht sagen
                               // musst du bestimmen, was da passt
      lcd_string( ptr );

      if (TCNT0<0xff)
      {
        goto retmin1;
      }
...

und du musst dir noch eine Variable ptr definieren

  char * ptr;

[Karl H. (kbuchegg)]

Warum hast du eigentlich die ursprüngliche Lösung nicht dem Prinzip nach 
beibehalten.

Ursprünglich war das

    retmin1:
      za=z1+zg;
      z1=TCNT1;    //Variable z1 nimmt den Wert des Z�hlregisters TCNT1 von Timer1 an
      

        /*Wert, der in "lcd_string" steht, wird  aus den 16 Bits des Timer1 ausgelesen. */
        //za Anzeige auf LCD (noch nicht erf�llt)
      char Buffer[8];
        utoa( z1, Buffer, 10 );
      set_cursor(0,1);
        lcd_string( Buffer );

Jetzt willst du za ausgeben. za ist ein unsigned long und die 
korrspondierende Funktion zur Wandlung dafür heisst ultoa

    retmin1:
      za=z1+zg;
      z1=TCNT1;    //Variable z1 nimmt den Wert des Z�hlregisters TCNT1 von Timer1 an
      

        /*Wert, der in "lcd_string" steht, wird  aus den 16 Bits des Timer1 ausgelesen. */
        //za Anzeige auf LCD (noch nicht erf�llt)
      char Buffer[12];    /* 7 benutzbare Zeichen könnte bei einem ulong knapp werden -> größer gehen */
      ultoa( za, Buffer, 10 );
      set_cursor(0,1);
      lcd_string( Buffer );

Die Funktionsnamen sind nach einem Schema aufgebaut. In der Mitte steht 
jeweils 'to' um anzuzeigen, dass etwas konvertiert wird. Das 'a' hinten 
bedeutet ASCII, also Text. Und vorne steht ein Kürzel für den Datentyp

   itoa     integer to ascii
   utoa     unsigned integer to ascii
   ltoa     long to ascii
   ultoa    unsigned long to ascii


Wie gesagt, du brauchst dringend ein Buch!

[dunial (Gast)]

Hallo,

ich darf verkünden: es klappt !!

Vielen Dank noch einmal für eure Bemühungen.
Nach einem Buch werde ich mich einmal umsehen. Ich habe nur momentan 
eines, dass im Speziellen die Controller der Atmel-Mega-Serie behandelt. 
Da gibt es auch Codebeispiele und Anwendungen, aber eben nicht für so 
einen Zähler.

Viele Grüße
Daniel

[Karl H. (kbuchegg)]

dunial schrieb:
> Hallo,
>
> ich darf verkünden: es klappt !!
>
> Vielen Dank noch einmal für eure Bemühungen.
> Nach einem Buch werde ich mich einmal umsehen. Ich habe nur momentan
> eines, dass im Speziellen die Controller der Atmel-Mega-Serie behandelt.
> Da gibt es auch Codebeispiele und Anwendungen, aber eben nicht für so
> einen Zähler.

Du brauchst ein Grundlagenbuch für C!

Ein Buch über die speziellen Formgebungen des Brennraums und dessen 
Auswirkungen auf den Wirkungsgrad hilft dir nichts oder nur wenig, wenn 
dein Problem darin besteht, wie so ein Ottomotor eigentlich 
funktioniert. Klar kann man sich das eine oder andere aus dem 
Spezialbuch zusammenreimen. Aber es wird immer ein Zusammenreimen 
bleiben und nie etwas Handfestes werden!

[Karl H. (kbuchegg)]

Ich hab dein Programm mal etwas bearbeitet.
Es entspricht der Funktionalität nicht ganz deinem Programm. ABer es 
soll dir zeigen, wie man sich durch die Einführung von Funktionen den 
Code in kleinere überschaubarere Einheiten zergliedern kann.

#include "lcd_routine.h"
//#include <avr/eeprom.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
#include <util/delay.h>
#include "string.h"

#define RST_PIN PC1
#define T1 PC5
#define T2 PC4
#define T3 PC3
#define SigE PD5
#define GET(PORT,PIN) (!((PORT)&(1<<(PIN))))

//Strings im EEPROM
/*unsigned char StartbildZ1[] EEMEM = "Geigerz\xE1hler";
unsigned char StartbildZ2[] EEMEM = "mit VA-Z-310";
unsigned char PrgauswahlZ1[] EEMEM = "Zum Starten ein";
unsigned char PrgauswahlZ2[] EEMEM = "Programm w\xE1hlen";
unsigned char Prg1Z1[] EEMEM = "Programm 1:";
unsigned char Prg1Z2[] EEMEM = "1 Minute messen";
unsigned char Prg2Z1[] EEMEM = "Programm 2:";
unsigned char Prg2Z2[] EEMEM = "30 Sek. messen";
unsigned char Prg3Z1[] EEMEM = "Programm 3:";
unsigned char Prg3Z2[] EEMEM = "10 Sek. messen";
unsigned char Einheit[] EEMEM = "ySv/h";
unsigned char DP[] EEMEM = ".";
unsigned char Neustart[] EEMEM = "Neustart Messung";
unsigned char Zeit1[] EEMEM = "1 Minute";*/

//Laufvariabeln
unsigned char t0;  //Variable t0 (Wert Timer0)
unsigned long zg;  //Variable zg (Wert Gesamtstand Timer1 nach �berlauf)
unsigned long za;  //Variable za (Wert zur Ausgabe durch das LCD)
unsigned long z1;  //Variable z1 bis zum 1.�berlauf Timer1

//Zeitvariable
volatile unsigned int  sekunde;

//////////////////////////////////////////////////////////////////////
SIGNAL(SIG_INTERRUPT0)  //Interrupt f�r Timer0-�berlauf
{
  sekunde++;      //Wert der Variablen 'sekunde' um 1 erh�hen
}

//////////////////////////////////////////////////////////////////////
void lcd_header( const char* pgm_name, const char* time_String )
{
  lcd_clear();

  set_cursor( 1, 1 );
  lcd_string( pgm_name );

  set_cursor( 1, 2 );
  lcd_string( time_String );

  _delay_ms(500);
}

//////////////////////////////////////////////////////////////////////
void lcd_utoa( unsigned int zahl )
{
  char Buffer[8];
  utoa( zahl, Buffer, 10 );
  lcd_string( Buffer );
}

//////////////////////////////////////////////////////////////////////
void lcd_ultoa( unsigned long zahl )
{
  char Buffer[14];
  utoa( zahl, Buffer, 10 );
  lcd_string( Buffer );
}

//////////////////////////////////////////////////////////////////////
void messung( unsigned int messzeit )
{
  lcd_clear();
  set_cursor(7,1);
  lcd_data('.');  //setzten des Dezimalpunktes
  set_cursor(11,1);
  lcd_string("ySv/h");

                  //unsigned char t0;  Variable t0 (Wert Timer0)
                  //unsigned long zg;  Variable zg (Wert Gesamtstand Timer1 nach �berlauf)
                  //unsigned long za;  Variable za (Wert zur Ausgabe durch das LCD)
  t0 = 0;        //Variable t0 (Wert Timer0) wird auf null gesetzt
  zg = 0;        //Variable zg (Wert Gesamtz�hlstand) wird auf null gesetzt
  za = 0;        //Variable za (Wert Zahlausgabe LCD) wird auf null gesetzt
  sekunde = 0;   //Zeitvariable auf null gesetzt

  TCNT0  = 0;     //Anfangswert Timer0 ist null
  TCCR0 |= 0x03;  //Timer0 wird gestartet; Teiler 011 Systemtakt :64


                  //unsigned long z1;  Variable z1 bis zum 1.�berlauf Timer1
  z1 = 0;         //Variable z1 (Wert Z�hlregister TCNT1 von Timer1) wird auf null gesetzt

  TCCR1A = 0;     //kein Compare- und/oder PWM-Betrieb
  OCR1A  = 0;
  OCR1B  = 0;
  TCNT1  = 0;     //Z�hlregister Timer1 wird auf null gesetzt
  TCCR1B = 0x07;  //Timer1 wird gestartet; am PinT1(PD5) werden steigende Flanken erkannt

  do {
    z1 = TCNT1;    //Variable z1 nimmt den Wert des Z�hlregisters TCNT1 von Timer1 an

    if( z1 >= 50000 )  //ist Timer1 >= 50.000 ?
    {              //TCNT1L>=0x50,TCNT1H>=0xc3
      z1 = zg;
      zg = 50000;
    }
      
    za = z1 + zg;
    set_cursor( 0, 1 );
    lcd_ultoa( za );

  } while( sekunde < messzeit );

  TCCR0 = 0;
  TCNT0 = 0;
  TCCR1B = 0x00;    //Timer1 stopp
}

//////////////////////////////////////////////////////////////////////
void miss_60_sekunden()
{
  lcd_header( "Programm 1:", "1 Minute messen");
  messung( 60 );
}

//////////////////////////////////////////////////////////////////////
void miss_30_sekunden()
{
  lcd_header( "Programm 2:", "30 Sek. messen");
  messung( 30 );
}

//////////////////////////////////////////////////////////////////////
void miss_10_sekunden()
{
  lcd_header( "Programm 3:", "10 Sek. messen");
  messung( 10 );
}

//////////////////////////////////////////////////////////////////////
int main (void)  
{
  DDRB = 0xff;    //Pins PortB sind alles Ausg�nge
  PORTB = 0x00;  
  DDRC = 0x00;    //Pins PortC sind alles Eing�nge
  PORTC |= (1 << T3) | (1 << T2) | (1 << T1) | (1<<RST_PIN);  //internen Pull-Up f�r PC1, PC3 bis PC5 aktivieren
  DDRD = 0xff;    //Pins PortD sind alles Ausg�nge
  DDRD &= ~(1 << SigE);//Pin1 auf Eingang und andere im urspr�nglichen Zustand belassen

  lcd_init();
  lcd_clear();
  set_cursor(2,1);
  lcd_string("Geigerz\xE1hler");

  set_cursor(2,2);
  lcd_string("mit VA-Z-310");
  _delay_ms(600);
  lcd_clear();

  while(1)    //Anfang Programmschleife
  {
    set_cursor(0,1);
    lcd_string("Zum Starten ein");
    set_cursor(0,2);
    lcd_string("Programm w\xE1hlen");
    _delay_ms(50);

    if (GET(PINC,T1))
    {
      miss_60_sekunden();
    }

    else if (GET(PINC,T2))
    {
      miss_30_sekunden();
    }

    else if (GET(PINC,T3))
    {
      miss_10_sekunden();
    }
  }  //Ende Programmschleife
}  //Ende main