Atmega8 - Pin Nummer dynamisch?

[Thomas F. (thomas41587)]

Hallo zusammen,

in einer Funktion bräuchte ich die Möglichkeit, Pin-Nummern dynamisch zu 
adressieren. Also anstatt z.B.: "PORTB |= (1<<PB1)" -> "PORTB |= 
(1<<PB{variable})". Ich habe versucht dieses "Problem" zu googlen aber 
leider findet sich einfach nichts...

Vielen Dank jetzt schon für eure Hilfe!

[Christopher B. (chrimbo)]

Guck dir am besten einfach mal an was PB1 ist.
Hint: Es ist 1

d.h. 1<<PB1 == 1<<1 == 2

[Jim M. (turboj)]

Trivialst:

uint8_t pin_nr = 0;

PORTB |= (1<<pin_nr);

[Dr. Sommer (Gast)]

PB1 ist einfach nur definiert als 1, PB7 ist 7 usw. Du kannst also 
einfach

PORTB |= (1 << var);

machen. Achtung dass das ggf. langsam ist (var*3 Takte oder so) weil der 
AVR keinen Barrelshifter hat.

[Thomas F. (thomas41587)]

Wow, so einfach :D vielen Dank für die schnelle Hilfe, es funktioniert 
:)

[chris (Gast)]

Der Vorgang ist dann vermutlich auch nicht atomar, da der Compiler 
daraus wohl kein sbi bzw. cbi machen kann.
Also aufpassen wenn du in Interrupts Operationen auf dem selben PORT 
durchführst.

Das könnte man jedoch durch eine Funktion lösen:

void portb_set_pin(uint8_t pin)
{
  switch (pin)
  {
  case 0:
  PORTB |= (1<<0);
    break;
  case 1:
  PORTB |= (1<<1);
    break;
  case 2:
  PORTB |= (1<<2);
    break;
  case 3:
  PORTB |= (1<<3);
    break;
  case 4:
  PORTB |= (1<<4);
    break;
  case 5:
  PORTB |= (1<<5);
    break;
  case 6:
  PORTB |= (1<<6);
    break;
  case 7:
  PORTB |= (1<<7);
    break;
  default:
    break;
  }
}

[Frank M. (ukw) (Moderator)]

chris schrieb:
> Der Vorgang ist dann vermutlich auch nicht atomar, da der Compiler
> daraus wohl kein sbi bzw. cbi machen kann.
> Also aufpassen wenn du in Interrupts Operationen auf dem selben PORT
> durchführst.
>
> Das könnte man jedoch durch eine Funktion lösen:

Ach, durch die Funktion wird die Operation atomar?

[chris (Gast)]

Frank M. schrieb:
> Ach, durch die Funktion wird die Operation atomar?

Der eigentliche Zugriff auf das PORT-Register sollte m.M. nach dadurch 
atomar sein, da in der Funktion dann lauter sbi-Befehle stehen.
Benutzt man aber

 PORTB |= (1<<x);

dann wird das wohl ein read-modify-write.
Und zwischen modify und write kann dann ein Interrupt zuschlagen und den 
PORT modifizieren, so dass es Probleme gibt. (Das write macht die vom 
Interrupt vorgenommene Veränderung sofort wieder rückgängig, indem es 
den gesamten PORT beschreibt.)

Allerdings gebe ich zu, dass ich gerade keine Zeit habe, meine Theorie 
anhand des asm-Codes zu überprüfen. Möglicherweise irre ich mich also.
Vielleicht schafft der Compiler es ja auch, aus einer variablen 
Pinnummer einen sbi-Befehl zu machen.

[chris (Gast)]

So, ich habe es mal ausprobiert (gcc 4.7.2, Optimierung -Os)
Quellcode siehe Anhang.

Mit der oben von mir geposteten Funktion wird wie erwartet für jeden Pin 
ein sbi erzeugt:

void portb_set_pin(uint8_t pin)
{
  switch (pin)
  66:  e8 2f         mov  r30, r24
  68:  f0 e0         ldi  r31, 0x00  ; 0
  6a:  e8 30         cpi  r30, 0x08  ; 8
  6c:  f1 05         cpc  r31, r1
  6e:  90 f4         brcc  .+36       ; 0x94 <portb_set_pin+0x2e>
  70:  e6 5e         subi  r30, 0xE6  ; 230
  72:  ff 4f         sbci  r31, 0xFF  ; 255
  74:  09 94         ijmp
  {
    case 0:
    PORTB |= (1<<0);
  76:  28 9a         sbi  0x05, 0  ; 5
    break;
  78:  08 95         ret
    case 1:
    PORTB |= (1<<1);
  7a:  29 9a         sbi  0x05, 1  ; 5
    break;
  7c:  08 95         ret
    case 2:
    PORTB |= (1<<2);
  7e:  2a 9a         sbi  0x05, 2  ; 5
    break;
  80:  08 95         ret
    case 3:
    PORTB |= (1<<3);
  82:  2b 9a         sbi  0x05, 3  ; 5
    break;
  84:  08 95         ret
    case 4:
    PORTB |= (1<<4);
  86:  2c 9a         sbi  0x05, 4  ; 5
    break;
  88:  08 95         ret
    case 5:
    PORTB |= (1<<5);
  8a:  2d 9a         sbi  0x05, 5  ; 5
    break;
  8c:  08 95         ret
    case 6:
    PORTB |= (1<<6);
  8e:  2e 9a         sbi  0x05, 6  ; 5
    break;
  90:  08 95         ret
    case 7:
    PORTB |= (1<<7);
  92:  2f 9a         sbi  0x05, 7  ; 5
  94:  08 95         ret

Mit dem variablen Shift wird dagegen wild durch die Gegend gerechnet:

      PORTB |= (1<<pin_nr);
  6c:  45 b1         in  r20, 0x05  ; 5
  6e:  9c 01         movw  r18, r24
  70:  00 90 00 01   lds  r0, 0x0100
  74:  02 c0         rjmp  .+4        ; 0x7a <main+0x24>
  76:  22 0f         add  r18, r18
  78:  33 1f         adc  r19, r19
  7a:  0a 94         dec  r0
  7c:  e2 f7         brpl  .-8        ; 0x76 <main+0x20>
  7e:  24 2b         or  r18, r20
  80:  25 b9         out  0x05, r18  ; 5
  82:  eb cf         rjmp  .-42       ; 0x5a <main+0x4>

Flashverbrauch ist 202 byte (Funktion) vs. 174 byte (variabler Shift)

Ohne mich mit Assembler genauer auszukennen, vermute ich dass die 
Funktionsvariante wohl schneller ist als der variable Shift.
Und eben zusätzlich atomar.

lg
Chris