Atmega16 Ausgänge, Zeitmultiplexing, Switch-Case

[Matze (Gast)]

Hallo,

Ich möchte mit folgendem Code erreichen dass alle enthaltenen Ausgänge 
nacheinander Eingschaltet werden und die Gleiche Einschaltzeit haben.
(Zeitmultiplexing für Display)

Wenn nun y von 0 auf 10 hochzählt sollte jeder Zustand genau 1 mal 
auftreten, dies ist jedoch nicht der fall.

Der 1. Ausgang bekommt 1 Puls, der 2. bekommt 2, der Vierte 4 usw

Woran könnte das liegen, ich finde den Fehler nicht.

#include <avr/io.h>

int main(void)
{
      DDRA  = 0xFF;
      DDRB  = 0xFF;
      DDRC  = 0xFF;
      DDRD  = 0xFF;
      PORTA=0xFF;
      PORTB=0xFF;
      PORTC=0xFF;
      PORTD=0xFF;
    while(1)
    {
      for(int y=0;y<11;y++)
      {
      PORTA &= ~(1 << PA0);   // Rück-Setzen
      PORTB &= ~(1 << PB0);   
      PORTB &= ~(1 << PB1);  
      PORTB &= ~(1 << PB2);   
      PORTB &= ~(1 << PB3);  
      PORTB &= ~(1 << PB4);   
      PORTD &= ~(1 << PD1);  
      PORTD &= ~(1 << PD2);   
      PORTD &= ~(1 << PD3);  
      PORTD &= ~(1 << PD4);   
      PORTD &= ~(1 << PD5);   
      switch(y)
      {
      case 0: PORTA |= (1 << PA0);   // Setzen
      case 1: PORTB |= (1 << PB0);   
      case 2: PORTB |= (1 << PB1);  
      case 3: PORTB |= (1 << PB2);   
      case 4: PORTB |= (1 << PB3);  
      case 5: PORTB |= (1 << PB4);  
      case 6: PORTD |= (1 << PD1);   
      case 7: PORTD |= (1 << PD2);   
      case 8: PORTD |= (1 << PD3);   
      case 9: PORTD |= (1 << PD4);   
      case 10: PORTD |= (1 << PD5);  
      }            
      }  
    }
}

Danke für eure Hilfe

[Stefan W. (dl6dx)]

Matze schrieb:

    switch(y)
       {
       case 0: PORTA |= (1 << PA0);
       case 1: PORTB |= (1 << PB0);
       (...)

Die "case"-Label sind Einsprungpunkte. Sie beenden nicht die 
Codesequenz, die davor steht. Im Moment wird bei y == 0 jeder der Pins 
gesetzt, bei y == 1 wird PB0 bis PD5 gesetzt, bei y == 2 PB1 bis PD5 
(und so weiter).

Wenn du willst, dass bei y == 0 nur PA0 gesetzt wird, bei y == 1 nur 
PB0 (usw.), musst du den switch jeweils über "break" verlassen:

    switch(y)
       {
       case 0: PORTA |= (1 << PA0); break;
       case 1: PORTB |= (1 << PB0); break;
       case 2: PORTB |= (1 << PB1); break;
       case 3: PORTB |= (1 << PB2); break;
       case 4: PORTB |= (1 << PB3); break;
       case 5: PORTB |= (1 << PB4); break;
       case 6: PORTD |= (1 << PD1); break;
       case 7: PORTD |= (1 << PD2); break;
       case 8: PORTD |= (1 << PD3); break;
       case 9: PORTD |= (1 << PD4); break;
       case 10: PORTD |= (1 << PD5); break;
       }

Tipp: Lies dir das Kapitel deines C-Buchs über Kontrollstrukturen besser 
noch mal durch.

Außerdem kannst du alle Portbits eines Ports auf einmal zurück setzen:

  PORTA &= ~(1<<PA0);
  PORTB &= ~((1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4));
  PORTD &= ~((1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5));

Da Portregister als volatile deklariert sind, darf der Compiler hier 
nichts zusammenfassen. So hast du 10 read-modify-writeback-Operationen 
statt der minimal möglichen 3.



Grüße

Stefan

Edit: Nur fürs Protokoll: Ja, beim letzen Label (case 10:) ist der Break 
obsolet (das Ende des switch-Konstrukts ist eh erreicht). Schadet aber 
auch nicht.

[Peter II (Gast)]

Stefan Wagner schrieb:
> PORTD &= ~((1<<PD1) | (1<<PD2) | (1<<PD3) | (1<<PD4) | (1<<PD5));
>
> Da Portregister als volatile deklariert sind, darf der Compiler hier
> nichts zusammenfassen. So hast du 10 read-modify-writeback-Operationen
> statt der minimal möglichen 3.

denke nicht. Dann die Rechte seite darf auf einmal ausgewertet werden. 
Es ist nur kein Setzen einen einzelnen Bits sonder es werden alles 8 
Bits auf einmal geändert. Das ganze man Probleme wenn noch eine ISR den 
port gleichzeitig ändert.

[STK500-Besitzer (Gast)]

Stefan Wagner schrieb:
> Da Portregister als volatile deklariert sind, darf der Compiler hier
> nichts zusammenfassen. So hast du 10 read-modify-writeback-Operationen
> statt der minimal möglichen 3.

im rechten Teil steht eine Konstante... Die wird schon zur Compile-Zeit 
berechnet (oder auch wann anders, aber nicht mehr zur Programmlaufzeit)

[Stefan W. (dl6dx)]

Peter II schrieb:
> denke nicht. Denn die rechte Seite darf auf einmal ausgewertet werden.
> Es ist nur kein Setzen einen einzelnen Bits sondern es werden alle 8
> Bits auf einmal geändert.

Bei dem Code, den ich gepostet habe, ist das auch so. Da ist constant 
folding im jeweiligen rvalue möglich und er reduziert sich zu einer 
einzigen Konstanten.

Bei dem vom TO geposteten Code

      PORTA &= ~(1 << PA0);   // Rück-Setzen
      PORTB &= ~(1 << PB0);   
      PORTB &= ~(1 << PB1);  
      (...)

wird je Statement nur ein Bit gelöscht. Und da die Portregister als 
volatile dekariert sind, darf kein constant folding über alle Statements 
hinweg stattfinden.

Grüße

Stefan

[Stefan W. (dl6dx)]

Stefan Wagner schrieb:
> Da Portregister als volatile deklariert sind, darf der Compiler hier
> nichts zusammenfassen. So hast du 10 read-modify-writeback-Operationen
> statt der minimal möglichen 3.

Nur zur Klarstellung: Das bezog sich auf den originalen Code des TO, der 
je Statement nur ein Bit zurücksetzte.

Grüße

Stefan

[Peter D. (peda)]

Matze schrieb:
> und die Gleiche Einschaltzeit haben.

Dann brauchst Du erstmal einen Timerinterrupt.

[Andreas (Gast)]

Peter Dannegger schrieb:
> Dann brauchst Du erstmal einen Timerinterrupt.

Wozu?
Er benutzt keine Interrupts, folglich wird die for-Schleife immer in der 
selben Zeit durchlaufen. Daher sind auch die Pulse immer gleich lang - 
bis auf den letzten (PD5), der ist etwas länger als die anderen - das 
könnte man aber leicht reparieren. ;)

[Peter D. (peda)]

Andreas schrieb:
> folglich wird die for-Schleife immer in der
> selben Zeit durchlaufen.

Das ist aber sehr kurzsichtig gedacht.
Programme sollen ja in der Regel noch mehr machen als nur multiplexen 
und dann ändert sich ständig die Programmlaufzeit.

Eine gleiche Pulslänge über sämtliche Programmlaufzeiten zu erzielen, 
ist ähnlich einfach, wie einen Tisch aus Streichhölzern zusammen zu 
leimen.
Man muß sich die Arbeit ja nicht absichtlich schwerer machen.

Ich will aber niemanden was aufzwingen.
Vielleicht macht es ja manchem Spaß, eine Sackgasse zu programmieren und 
dann alles wegzuschmeißen und nochmal komplett neu anzufangen.