Simulation einer for-schleife (Software SPI)

[hilflos (Gast)]

Guten Tag,

Zu allererst: Ich habe kein Ozilloskop und versuche mich deshalb gerade 
mit dem Simulator vom AtmelStudio 6.1.2440 beta.

Die Funktion, die aufgerufen wird, sieht folgendermaßen aus:

void send_spi(uint8_t byte){
uint8_t i=0;
//PB 7 = clock; , auf low ziehen
PORTB &= ~(1 << PB7);

  for (i=0;i<8;i++) {
    if (byte &(1 << (7-i))) {
      PORTB |= (1 << PB5);
    }      
    else {
      PORTB &= ~(1 << PB5);
    }
          
    PORTB |= (1 << PB7);
    _delay_ms(1);
    PORTB &= ~(1 << PB7);
    _delay_ms(1);
  }

PORTB &= ~(1 << PB5);
}

Letzendlich soll eine Art Software SPI realisiert werden. Der Simulator 
von Atmel geht allerdings bei i=0 nicht mehr in die if-Bedingung. Mir 
fehlt also in der Simulation das letzte Bit. Warum? Letzendlich würde 
ich dann ja haben:
if (byte &(1 << 0))
Mag das der Simulator nicht? Oder mag das der compiler schonmal 
garnicht?

Ich bin ratlos und weiß also nicht, ob der Fehler im Simulator oder im 
Code liegt.

Danke für jeden Hinweis!

[Falk B. (falk)]

@  hilflos (Gast)

>Die Funktion, die aufgerufen wird, sieht folgendermaßen aus:

>void send_spi(uint8_t byte){
>uint8_t i=0;
>//PB 7 = clock; , auf low ziehen
>PORTB &= ~(1 << PB7);

>  for (i=0;i<8;i++) {
>    if (byte &(1 << (7-i))) {

Ist ungünstig. Besser so.

http://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Schiebeoperationen

>Letzendlich soll eine Art Software SPI realisiert werden.

Sieht OK aus.

> Der Simulator
>von Atmel geht allerdings bei i=0 nicht mehr in die if-Bedingung.

Doch.

> Mir
>fehlt also in der Simulation das letzte Bit.

Nö, i fängt ja mit 0 an!

> Warum? Letzendlich würde
>ich dann ja haben:
>if (byte &(1 << 0))
>Mag das der Simulator nicht?

Das sollte kein Problem sein.

>Ich bin ratlos und weiß also nicht, ob der Fehler im Simulator oder im
>Code liegt.

Möglicherweise am Simulator. Schalte mal im Compiler die Optimierung 
aus, in den Projektoptionen.

[hilflos (Gast)]

Hallo Falk!

Hab das Problem gelöst. Undzwar hab ich den Code mit Hilfe deines Links 
und ein bisschen google umgebaut und nun simuliert er einwandfrei. Mit 
den Optimierungsoptionen hab ich garnichts weiter getan. Zur 
Vollständigkeit hier einmal der Code:

void send_spi(uint8_t byte){
uint8_t i=0;
//PB 7 = clock;
uint8_t mask = 0x80;

  for (i=0;i<8;i++) {
    if (byte &(mask)) {
      PORTB |= (1 << PB5);
    }
    else {
      PORTB &= ~(1 << PB5);
    }

    PORTB |= (1 << PB7);
    _delay_ms(1);
    PORTB &= ~(1 << PB7);
    _delay_ms(1);
    mask = (mask >> 1);
  }

PORTB &= ~(1 << PB5);
}

Danke!

[Fallobst (Gast)]

Anstatt der Maske kann man gleich das zu sendende Byte schieben. Das ist 
noch ein bisschen effizienter.

[Falk B. (falk)]

@  hilflos (Gast)

>Vollständigkeit hier einmal der Code:

Das kann man noch ein klein wenig effizienter machen, ohne 
Schleifenzähler. Die Maske reicht. Siehe unten. Und byte ist kein guter 
Name für eine Variable.

void send_spi(uint8_t data){

  uint8_t mask;

  for (mask=0x80; mask !=0; mask >>= 1;) {
    if (data & mask) {
      PORTB |= (1 << PB5);
    }
    else {
      PORTB &= ~(1 << PB5);
    }

    PORTB |= (1 << PB7);
    _delay_ms(1);
    PORTB &= ~(1 << PB7);
    _delay_ms(1);
    mask >>= 1;
  }

PORTB &= ~(1 << PB5);
}

[Falk B. (falk)]

@  Fallobst (Gast)

>Anstatt der Maske kann man gleich das zu sendende Byte schieben. Das ist
>noch ein bisschen effizienter.

Das ist egal, man braucht so oder so einen Schleifenzähler.

[Fallobst (Gast)]

Die Maskierung data & mask spart man sich aber.

[Wusel D. (stefanfrings_de)]

Ich habe die Erfahrung gemacht, dass optimierter Code sich schlecht im 
simulator debuggen lässt. Also simuliere ich immer erst mit -O0 und 
hoffe, dass das Programm später mit -Os oder -O1 noch richtig 
funktioniert. Bis jetzt hatte es stets geklappt.

[Falk B. (falk)]

@  Fallobst (Gast)

>Die Maskierung data & mask spart man sich aber.

Eine Maskierung mit einer Konstanten ist hier auch nicht schneller.
Einen Zugriff auf das Carry-Bit wie unter Assembler hat man in C nicht.

[Fallobst (Gast)]

Falk Brunner schrieb:
> Eine Maskierung mit einer Konstanten ist hier auch nicht schneller.
> Einen Zugriff auf das Carry-Bit wie unter Assembler hat man in C nicht.

Richtig, mit dem Carry wäre es noch schneller. Aber selbst ohne ist die 
Version besser. Die Maskierung benötigt zwei Assembler-Befehle (mov, 
and) + Sprungbefehl. Ein konstantes Bit lässt sich entweder mit 
sbrc/sbrs oder mit bst+brts/brtc prüfen. Außerdem wird ein Register 
weniger benötigt (spielt hier keine Rolle).

[Falk B. (falk)]

OK, es noch einen Tick effizienter ;-)