Variable Portzuweisung WinAVR (C) ATmega

[Stefan M. (st-m)]

Folgendes Problem:

Ich möchte Daten (1Byte, unsigned char) an einem Port ausgeben oder 
einlesen. Dazu kann ich ja ganz einfach meiner Variablen den Port 
zuweisen:

Variable_Eins = PINF
PORTF = Variable_Zwei

Soweit so schön. Das setzt aber voraus dass die 8 Bit der Variablen 
genau auf die 8 bit des Ports passen. Wie stelle ich es aber nun 
beispielsweise an, dass die oberen 4 Bit der Variablen an PortC und die 
unteren 4 Bit an PortF gehen? Wie kann ich in der Header-Datei möglichst 
einfach und flexibel festlegen an welchen Pin die einzelnen Bits meiner 
Variablen gehen? Und das möglichst ohne komplizierte und seitenlange 
Bit-setzen- oder Bit-lesen-Makros?
Gibt es dafür eine einfache Syntax?

[Falk (Gast)]

@ Stefan Malig (st-m)

>beispielsweise an, dass die oberen 4 Bit der Variablen an PortC und die
>unteren 4 Bit an PortF gehen? Wie kann ich in der Header-Datei möglichst
>einfach und flexibel festlegen an welchen Pin die einzelnen Bits meiner
>Variablen gehen? Und das möglichst ohne komplizierte und seitenlange
>Bit-setzen- oder Bit-lesen-Makros?
>Gibt es dafür eine einfache Syntax?

Ich fürchte das geht nur mit komplizierten Makros. Man kann ja die 
Verdrahtung im AVR nicht ändern. Ist ja kein FPGA ;-).

MFG
Falk

[Karl H. (kbuchegg)]

Stefan Malig wrote:

> Gibt es dafür eine einfache Syntax?

Nein.
Da wird dir nichts anderes übrig bleiben, als jedes Bit
einzeln zu behandeln

#define LESE_PORT_A   PORTB
#define LESE_PORT_B   PORTF


  uint8_t Result;

  Result = 0;
  Result |= LESE_PORT_A & ( 1 << BIT_0 );
  Result |= LESE_PORT_A & ( 1 << BIT_1 );
  Result |= LESE_PORT_A & ( 1 << BIT_2 );
  Result |= LESE_PORT_A & ( 1 << BIT_3 );
  Result |= ( LESE_PORT_B & ( 1 << BIT_0 ) ) << 4;
  Result |= ( LESE_PORT_B & ( 1 << BIT_1 ) ) << 4;
  Result |= ( LESE_PORT_B & ( 1 << BIT_2 ) ) << 4;
  Result |= ( LESE_PORT_B & ( 1 << BIT_3 ) ) << 4;

Wenn dann auch noch die 'Nibble-Bits' völlig frei zugeordnet
werden sollen, dann wirds noch aufwändiger.

#define PORT_BIT_A    PORTB          // vom PORTB ...
#define BIT_A         5              // ... nimm Bit Nr 5 ...
#define RESULT_BIT_A  0              // ... und gib es im Ergebnis auf
                                     // Bit Nr 0

#define PORT_BIT_B    PORTC          // vom PORTC ...
#define BIT_B         0              // ... nimm Bit Nr 0 ...
#define RESULT_BIT_B  2              // ... und gib es im Ergebnis auf
                                     // Bit Nr 2

...

  Result = 0;
  Result |= ( ( PORT_BIT_A & ( 1 << BIT_A ) ) ? 1 : 0 ) << RESULT_BIT_A;
  Result |= ( ( PORT_BIT_B & ( 1 << BIT_B ) ) ? 1 : 0 ) << RESULT_BIT_B;
  Result |= ( ( PORT_BIT_C & ( 1 << BIT_C ) ) ? 1 : 0 ) << RESULT_BIT_C;
  Result |= ( ( PORT_BIT_D & ( 1 << BIT_D ) ) ? 1 : 0 ) << RESULT_BIT_D;
  Result |= ( ( PORT_BIT_E & ( 1 << BIT_E ) ) ? 1 : 0 ) << RESULT_BIT_E;
  Result |= ( ( PORT_BIT_F & ( 1 << BIT_F ) ) ? 1 : 0 ) << RESULT_BIT_F;
  Result |= ( ( PORT_BIT_G & ( 1 << BIT_G ) ) ? 1 : 0 ) << RESULT_BIT_G;
  Result |= ( ( PORT_BIT_H & ( 1 << BIT_H ) ) ? 1 : 0 ) << RESULT_BIT_H;

Flexibilität hat nun mal seinen Preis.