16bit Zeichen über SPI übertragen

[Dshing S. (dshing)]

Hi,
ich versuche grade ein 16bit Zeichen von einem Atmega88 auf einen 
Attiny2313 zu übertragen. Mit 8bit funktioniert es soweit auch.
Mein Ansatz ist zwei 8bit Zeichen von dem mega88 zusenden und dann im 
2313 immer zwei 8bit zu einem 16bit Zeichen zusammen zusetzen.
Das Problem ist, dass er jedes 8bit Zeichen ca. 6mal empfängt oder 
sendet.
Wie kommt es dazu? Muss ich auf irgendwas achten, damit es nur einmal 
gesendet wird?
Momentan sende ich nur ein 8bit Zeichen und zähle wie oft es empfangen 
wurde.
Atmega88:

void SPI_MasterTransmit(uint8_t cData)
{
SPDR = cData;
while(!(SPSR & (1<<SPIF))){};
}

Attiny2313 :

ISR (USI_START_vect)
{
  SPI_Register = USIDR;
  USISR |= (1<<USISIF);
  counter++;
}

[Oliver J. (skriptkiddy)]

Wie sieht die Hardware aus, und wie der Rest des Codes?


Gruß Oliver

[Dshing S. (dshing)]

Also auf den Sender läuft sonst nur noch das irmp Programm hier aus dem 
Forum, aber das hat so weit ich weiß nichts mit dem SPI zu tun, oder 
etwa doch?
Die Tasten von der IR sind entprellt. Das er also mehr mals die 
Sendefunktion aufruft kann sein.
Hardware seitig ist das es ohne SS, also nur Clock MOSI und MISO sind 
verbunden.
Bei dem Empfänger läuft sonst noch ein Timer interrupt und ein UART 
interrupt und sonst noch ein code um zwei Siebensegmet anzeigen 
anzusteuern.

Wie kann denn die "ISR (USI_START_vect)" noch aufgerufen werden? Oder 
brauch der µC hardwareseitig so lange um das interrupt bit wieder zu 
löschen, dass er das ganze noch 6 mal aufruft, denn wenn ich den counter 
zu Testzwecken verzögert in der main zählen lasse, dann zählt er 
richtig, also folgen die 5 ungewollten interrupts unmittelbar nach der 
Sendung.
Ein "volatile" vor der Variablen initaliesierung hab ich auch beim 
counter.

[Erich (Gast)]

>SPI_MasterTransmit

Muss man nicht  e r s t  abfragen, ob das (vorherige) Byte rausgegangen 
ist?

[Knut B. (Firma: TravelRec.) (travelrec)]

Erich schrieb:
> Muss man nicht  e r s t  abfragen, ob das (vorherige) Byte rausgegangen
> ist?

Muss man! Erst SPSR einlesen und wenn SPIF gesetzt ist, dann SPDR 
schreiben. Dies löscht dann auch SPIF. Das allererste Byte schreibt man 
direkt, weil ja erst nach dessen Übertragung SPIF das erste Mal gesetzt 
wird.

[Dshing (Gast)]

Also ich hab es jetzt so verstanden:

void SPI_MasterTransmit(uint8_t cData)
{
  if (SPSR & (1<<SPIF))
  {
    SPDR = cData;
  }
}

bei der SPI initaliesierung hab ich das erste Zeichen gesendet, also so:

SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);
PORTB |= (1<<PB5)|(1<<PB3);
SPDR =0;

[Dshing S. (dshing)]

Funktioniert aber immer noch nicht :( Sind immer noch jedes mal 6 
Durchläufe.

[Coder (Gast)]

SPI ist doch Full-Duplex?!?

[Dshing S. (dshing)]

Ja ist es, aber ich brauche es nur in ein Richtung.
Hab es jetzt aber auch mal so Probiert:
 Sender:

void SPI_MasterTransmit(uint8_t cData)
{
SPDR = cData;
while(!(SPSR & (1<<SPIF))){};
return SPDR;
}

Empfänger:

ISR (USI_START_vect)
{
  while(!(USISR & (1<<USISIF)));
  SPI_Register = USIDR;
  USISR |= (1<<USISIF);
  while(!(USISR & (1<<USISIF)));
  USIDR = 12;
  counter++;
}

Dann bleibt er aber im zweiten "while" in der ISR hängen und ohne while 
macht er gar nichts.

Mir ist aufgefallen, das er je nach dem welches Zahl ich sende, er 
unterschiedlich viele Zyklen macht aber jedes mal ungefähr die gleiche 
Anzahl bei der selben Zahl.

[Knut B. (Firma: TravelRec.) (travelrec)]

Zeig mal den Rest Deines Codes.

[Dshing (Gast)]

Also die Codes sehen so aus. Den IRMP Quellcode gibt es hier im Forum.
http://www.mikrocontroller.net/articles/IRMP

[gfdgf (Gast)]

Coder schrieb:
> SPI ist doch Full-Duplex?!?

Ja.

[Sascha W. (sascha-w)]

@Dshing

Hallo,

kann es sein, das von IRMP der Tastenrepeat als mehrmaliges Drücken der 
entsprechenden Taste weitergegeben wird, und der Sender deshalb den Code 
mehrmals sendet?!

Sascha

[Dshing S. (dshing)]

Also ich bin mir nicht ganz sicher, was du meinst, aber beim Sender 
kommt er ja nur in die switch Anweisung, wenn der list.schalter1==0. Den 
lasse ich ja aber dann gleich wieder auf 1 setzen und brauch er 0,7s bis 
er es wieder auf 0 setzt.


Gibt es denn noch eine andere Möglichkeit ein Zeichen mit >=16bit zu 
übertragen als mit so einer counter Variante?

[Karl H. (kbuchegg)]

Dshing Sung schrieb:
> Also ich bin mir nicht ganz sicher, was du meinst

Was er meint ist:
Hast du eigentlich schon mal überprüft, ob der Sender 6 mal empfängt, 
weil der Sender 6 mal sendet? Denn das wäre die naheliegenste Erklärung 
für dein beobachtetes Verhalten am Empfänger.

Infrarot-Fernsteuerungen senden bei einem Tastendruck normalerweise 
mehrmals die Tastenbetätigung.

[Sascha W. (sascha-w)]

Dshing Sung schrieb:
> Gibt es denn noch eine andere Möglichkeit ein Zeichen mit >=16bit zu
> übertragen als mit so einer counter Variante?
also der Counter allein ist Mist, da du keine Syncronisierung hast wann 
das 1. Byte kommt.
Du must in deiner SPI noch eine Leitung als SlaveSelect hinzufügen. Wenn 
die sagen wir mal L-Active ist, dann weiß der Empfänger das nach einem 
Übergang von H->L als nächstes das ERSTE von n-Byte kommt. Nachdem alle 
Bytes übertragen sind wird die select-Leitung wieder deaktiviert.

bisher sehe ich in deinem Code aber nicht's zur Übertragung von 
16Bit-Werten.

Sascha

[Dshing (Gast)]

Also ich hab auf der Senderseite jetzt mal das IRMP komplett 
rausgenommen.
Und nur das notwendigste gelasen. Aber es bleibt beim Alten. Also muss 
der Fehler doch im Empfänger liegen oder, nur wo?

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


struct {
   unsigned schalter1:1; 
} list;

    uint8_t h=0;
  
void Hard (void)
{

  TCCR0B  |=  (1 << CS00)|(1 << CS02);              //Timer clk/1024

  DDRB |= (1 << PB0)|(1 << PB2)|(1<<PB3)|(1<<PB5);
  
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);  //64              //SPI init////////////////////
}
  
void SPI_MasterTransmit(uint8_t cData)
{
SPDR = cData;
while(!(SPSR & (1<<SPIF)));
}

int main (void)
{
  Hard();
  for (;;)
{

if(TIFR0 & (1<<TOV0))    //wird 30.5 mal in der sekunde erreicht
{
  h++;
  TIFR0 |= (1 << TOV0);
}

if (h==90)        //alle 1.5s
{
  PORTB ^= (1<<PB0);
  list.schalter1=0;    // Tastenentprellung
}
if (  (PIND & (1<<PD7)) && list.schalter1==0)
{
  list.schalter1=1;
  SPI_MasterTransmit(23);
  h=0;
}}
}

[Dshing (Gast)]

Also ich hab jetzt mal die CLK-Frequenz geändert, wenn ich sie 
verdopple, dann halbiert es sich von ca. 6 auf 3 und wenn ich die 
Frequenz halbiere bekomme ich ca. 13 Durchläufe.
Also scheint der Fehler eine Zeit basierend zu sein, aber leider hilft 
mir das nicht weiter :(

[Sascha W. (sascha-w)]

also dein Problem liegt im Empfänger

Datenblatt tn2313
<Zitat>
•  Bit 7 – USISIF: Start Condition Interrupt Flag
When Two-wire mode is selected, the USISIF flag is set (to one) when a 
start condition is detected. When output disable mode or Three-wire mode 
is selected and (USICSx =0b11 & USICLK = 0) or (USICS = 0b10 & USICLK = 
0), any edge on the SCK pin sets the flag.
</Zitat>

zum Empfang verwendest du die USI_START_ISR - wann wird die ausgelöst?!
Mit deiner Init des USI ist die Bedingung (USICS = 0b10 & USICLK = 0) 
erfüllt, und damit bekommst du mit jeder Taktflanke an SCK einen 
Interrupt -> also 16x pro Byte!


Sascha

[Dshing (Gast)]

Achso, da ist mein Englisch wohl einfach zu schlecht, ich dachte nicht 
das das heißt, dass er bei JEDER CLK-Flanke auslöst. Also muss ich jetzt 
bei jeder Sendung nach der ersten Flanke den Interrupt ausschalten und 
danach wieder einschalten? Gibt es da nicht eine elegantere Lösung? So 
wie auch beim UART?

[Dshing S. (dshing)]

Hat den keiner mehr einen Tipp für mich, wie ich es hin bekommen kann, 
ein 16bit Zeichen zu übermitteln?