AVR: Variable einem Ausgangsport zuweisen

[Norbert M. (schnorpser)]

Hallo,

stehe eben auf dem Schlauch..
Versuche den Inhalt einer Variablen, einem Port zuzuweisen.
Das Programm (ein Testprogramm), soll den Zustand des Ports D einlesen 
(Taster) und auf Port B ausgeben. Das ganze teste ich via STK500-Board, 
AVR: ATmega8

Problem: Die LEDs leuchten immer, Tastendrücker werden ignoriert.

Kann mir bitte jemand auf die Sprünge helfen?

#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdint.h>

static volatile uint8_t tastenzustand = 0x00;

int main(void)
{
    // PORTB Ausgänge
  DDRB  = 0xFF;
    PORTB = 0xFF;
    // PORTC Eingänge
    DDRD  = 0x00;
    PORTD = 0xFF;
  
  while(1)
  {
    if (!(PIND & (1<PIND0)))
      tastenzustand = tastenzustand | 0x01;
    else
      tastenzustand = tastenzustand & 0x01;
    
    if ((PIND & (1<PIND1)))
      tastenzustand = tastenzustand | 0x02;
    else
      tastenzustand = tastenzustand & 0x02;
    
    if ((PIND & (1<PIND2)))
      tastenzustand = tastenzustand | 0x04;
    else
      tastenzustand = tastenzustand & 0x04;  
      
    if (!(PIND & (1<PIND3)))
      tastenzustand = tastenzustand | 0x08;
    else
      tastenzustand = tastenzustand & 0x08;
    
    if (!(PIND & (1<PIND4)))
      tastenzustand = tastenzustand | 0x10;
    else
      tastenzustand = tastenzustand & 0x10;
    
    if (!(PIND & (1<PIND5)))
      tastenzustand = tastenzustand | 0x20;
    else
      tastenzustand = tastenzustand & 0x20;
    
    if (!(PIND & (1<PIND6)))
      tastenzustand = tastenzustand | 0x40;
    else
      tastenzustand = tastenzustand & 0x40;
    
    if (!(PIND & (1<PIND7)))
      tastenzustand = tastenzustand | 0x80;
    else
      tastenzustand = tastenzustand & 0x80;
    
    PORTB = tastenzustand; 
  }
}

Dankende Grüße
Norbert

[Ralf (Gast)]

Denk' noch mal nach:
Deine dir selbst gestellte Aufgabe hat nichts mit dem zu tun, was du 
programmiert hast. Das geht viel einfacher! ...

Norbert Martsch schrieb:
> Das Programm (ein Testprogramm), soll den Zustand des Ports D einlesen

[Markus (Gast)]

Vielleicht hilft's:

tastenzustand = tastenzustand & 0xFE;
   statt
tastenzustand = tastenzustand & 0x01;

etc.

P. S. Das Programm läßt sich stark vereinfachen.

[Klaus (Gast)]

Hallo,


Du musst die Bits auch wieder mal auf 0 setzen

nicht so,
Norbert Martsch schrieb:
> tastenzustand = tastenzustand & 0x01;

sondern so
  tastenzustand = tastenzustand & ~0x01;

[Norbert M. (schnorpser)]

Hallo zusammen,

noch ein Nachtrag: im weiteren Verlauf soll später die Variable 
tastenzustand verzögert und danach erst die LED aktiviert/deaktiviert 
werden, und zwar jede Taste unabhängig voneinander. Insofern mag der 
jetzige Code etwas sinnentleert aussehen, dieser wird aber noch wachsen 
und ist nur ein "Modul" des Vorhabens, welches ich separat testen 
möchte.

Viele Grüße,
Norbert

[Ralf (Gast)]

Norbert Martsch schrieb:
> Das Programm (ein Testprogramm), soll den Zustand des Ports D einlesen
> (Taster) und auf Port B ausgeben.

!!!

[Ralf (Gast)]

Ralf schrieb:
> Norbert Martsch schrieb:
>> Das Programm (ein Testprogramm), soll den Zustand des Ports D einlesen
>> (Taster) und auf Port B ausgeben.
>
> !!!

Na gut, etwas spät. Ändert aber an dem möglichen Code nicht viel.

Tastenzustand=PORTD;
/* Mach was mit Tastenzustand, aber nicht so umständlich */
PORTB=Tastenzustand;

[Norbert M. (schnorpser)]

Hallo,

habe den Code nun am laufen und es funktioniert :-)
Was im Eingangsposting auch falsch war:
NICHT

if (!(PIND & (1<PIND0)))

SONDERN

if (!(PIND & (1<<PIND0)))

(doppelte einfache eckige Klammer nach links) :-)


Hier der funktionierende Code:

#include <avr/interrupt.h>
#include <avr/io.h>
#include <stdint.h>
#include <util/delay.h>

volatile uint8_t keystate = 0x3F;
volatile uint16_t countTimer2 = 0;  // Speichert den aktuellen Zählerwert

volatile uint8_t keycounter_0;
volatile uint8_t keycounter_1;
volatile uint8_t keycounter_2;
volatile uint8_t keycounter_3;
volatile uint8_t keycounter_4;
volatile uint8_t keycounter_5;
volatile uint8_t keycounter_6;
volatile uint8_t keycounter_7;

void init_io()
{
    // PORTB Ausgänge
  DDRB  = 0xFF;
    PORTB = 0x3F;
    // PORTD Eingänge
    DDRD  = 0x00;
    PORTD = 0x3F;
}

// ISR zum auffangen der Interrupts:
ISR(TIMER2_COMP_vect)
{

  if (countTimer2 < 100 )
  {
    countTimer2++;
  }
  else 
  
  {
    if ( (keycounter_0 != 0)  && (!(keystate & 0x01)) )
    
    {
      keycounter_0--;
    }
    
    if ( (keycounter_1 != 0)  && (!(keystate & 0x02)) )
    
    {
      keycounter_1--;
    }
    
    if ( (keycounter_2 != 0)  && (!(keystate & 0x04)) )
    
    {
      keycounter_2--;
    }
    
    if ( (keycounter_3 != 0)  && (!(keystate & 0x08)) )
    
    {
      keycounter_3--;
    }
    
    if ( (keycounter_4 != 0)  && (!(keystate & 0x10)) )
    
    {
      keycounter_4--;
    }
    
    if ( (keycounter_5 != 0)  && (!(keystate & 0x20)) )
    
    {
      keycounter_5--;
    }
/*    
    if ( (keycounter_6 != 0)  && (!(keystate & 0x40)) )
    
    {
      keycounter_6--;
    }
    
    if ( (keycounter_7 != 0)  && (!(keystate & 0x80)) )
    
    {
      keycounter_7--;
    }
*/    
    countTimer2 = 0;
  }  
}


int main(void)
{
  cli();
  init_io();
  
  // Initialisierung Timer2:
  TCCR2 = (1<<CS21) | (1<<WGM21);  // Prescaler von 8 | CTC-Modus (siehe unten für Beschreibung)
//  TCNT2 = 0;
  OCR2  = 100;            // Vergleichswert
  TIMSK |= (1<<OCIE2);        // Interrupts aktivieren und damit Timer starten
  sei();  
  
  while(1)
  {
    //Taste0
    if ((PIND & (1<<PIND0)))
    {
      if (keycounter_0 == 0)
      {
        keystate |= 0x01;  //aus
      }
    }
    else
    {
      keystate &= ~0x01;
      keycounter_0 = 255;
    }
    
    //Taste 1
    if ((PIND & (1<<PIND1)))  //Taste losgelassen
    {
      if (keycounter_1 == 0)
      {
        keystate |= 0x02;  //aus
      }
    }
    else            //Taste gedrückt
    {
      keystate &= ~0x02;  //an
      keycounter_1 = 255;
    }
    
    //Taste 2
    if ((PIND & (1<<PIND2)))
    {
      if (keycounter_2 == 0)
      {
        keystate |= 0x04;
      }
    }
    else
    {
      keystate &= ~0x04;  
      keycounter_2 = 255;
    }
    
    //Taste 3
    if ((PIND & (1<<PIND3)))
    {
      if (keycounter_3 == 0)
      {
        keystate |= 0x08;
      }
    }
    else
    {
      keystate &= ~0x08;
      keycounter_3 = 255;
    }
    
    //Taste 4
    if ((PIND & (1<<PIND4)))
    {
      if (keycounter_4 == 0)
      {
        keystate |= 0x10;
      }
    }
    else
    {
      keystate &= ~0x10;
      keycounter_4 = 255;
    }
    //Taste 5
    if ((PIND & (1<<PIND5)))
    {
      if (keycounter_5 == 0)
      {
        keystate |= 0x20;
      }
    }
    else
    {
      keystate &= ~0x20;
      keycounter_5 = 255;
    }
/*    
    //Taste 6
    if ((PIND & (1<<PIND6)))
    {
      if (keycounter_6 == 0)
      {
        keystate |= 0x40;
      }
    }
    else
    {
      keystate &= ~0x40;
      keycounter_6 = 255;
    }
    
    //Taster 7
    if ((PIND & (1<<PIND7)))
    {
      if (keycounter_7 == 0)
      {
        keystate |= 0x80;
      }
    }
    else
    {
      keystate &= ~0x80;
      keycounter_7 = 255;
    }
*/
    PORTB = keystate;
  }
}

Euch vielen Dank für die Hinweise und Tipps,
Norbert