Attiny2313 spi-slave c

[Kimmy (Gast)]

Hallo,
ich möchte einen Attiny2313 als slave in einem SPI-Bus benutzen. 
allerdings habe ich probleme die Daten richtig zu empfangen.

ISR(INT0_vect){
  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
}

new_spi_data frage ich dann in der main-schleife ab. Allerdings bekomme 
ich nur 0x00 als daten. egal was ich sende. spi_data ist dabei als 
volatile definiert.

Am Master funktioniert die Übertragung richtig. Ich bekomme die Daten 
auch richtig zurück. Also kann es schon einmal nicht total verkehrt 
sein.
weiss einer, wie ich die Daten bei einem Attiny richtig abfragen muss?

[Marc V. (Firma: Vescomp) (logarithmus)]

Kimmy schrieb:
> Am Master funktioniert die Übertragung richtig. Ich bekomme die Daten
> auch richtig zurück. Also kann es schon einmal nicht total verkehrt
> sein.
> weiss einer, wie ich die Daten bei einem Attiny richtig abfragen muss?

 Poste mal dein Programm, es ist meistens so, dass irgendetwas ganz
 anders ist als in Fragestellung.

 Verstehe das sowieso nicht:
 "Ich habe ein Problem mit meinem Programm aber den poste ich nicht,
 weil absolut unwichtig, alles andere stimmt 100%".

 Wie ist new_spi_data deklariert ?

 Was hat INT_0 ISR mit SPI zu tun ?

[Kimmy (Gast)]

INT0 ist quasi mein SlaveSelect, da ich anders nicht weiss wie ich 
mitbekommen kann, dass der Master etwas gesendet hat. Wenn der Master zu 
senden anfängt, setzt er diesen Pin auf Low, wodurch die ISR aufgerufen 
wurde.

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


#define F_CPU 8000000UL // for _delay_ms(); _delay_us()
#define FOSC 8000000UL // for Baudrate

/* -- includes -- */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "spi.h"
#include "uart.h"

/* -- USART -- */
#define USART_BAUD 1200
#define USART_MYUBRR FOSC/16/USART_BAUD-1
/* --  -- */

/* -- SPI -- */
#define PORT_SPI    PORTB
#define DDR_SPI     DDRB
#define DD_MISO     DDB6
#define DD_MOSI     DDB5
#define DD_SS       DDB2
#define DD_SCK      DDB7

volatile unsigned char spi_data;
volatile unsigned char new_spi_data;
/* -- -- */

void spi_init()
// Initialize pins for spi communication
{
  /* --- SLAVE --- */
  /* Set MISO as output, all others input */ 
  DDR_SPI = (1 << DD_MISO);
  DDR_SPI &= ~((1 << DD_MOSI) | (1 << DD_SCK));

  /* Enable SP */
  USICR = ((0<<USISIE)|            // Start Condition Interrupt Enable
       (0<<USIOIE)|            // Counter Overflow Interrupt Enable
       (0<<USIWM1)|(1<<USIWM0)|      // Three-wire mode
       (1<<USICS1)|(0<<USICS0)|(0<<USICLK)|
       (0<<USITC));            // Toggle Clock Port Pin

  extern_interrupt_init();

}

void extern_interrupt_init(void){
  DDRB &= ~(1 << DDD2); // External Interrupt on INT0

  MCUCR |= (1 << ISC01); // INT0 falling edge
  MCUCR &= ~(1 << ISC00); // INT0 falling edge

  GIMSK |= (1 << INT0);  // enable INT0 interrupt
}

ISR(INT0_vect){
  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
}


int main(void){
  spi_data = 0;
  usart_data = 0;
  new_usart_data = 0;
  usart_init(USART_MYUBRR);
  usart_transmit_string("USART devices ready \r\n"); 
  spi_init();
  usart_transmit_string("SPI devices ready \r\n"); 
  sei(); // Global Interrupts activate
  DDRB |= (1<<PORTD5); // PD5 -> Output
  PORTD &= ~(1<<PORTD5); // PD5 -> Low
  while (1){
    if(new_spi_data==1){
      usart_transmit_string("\r\n received data: ");
      usart_transmit_char(spi_data);
      new_spi_data = 0;
    }

  }
}

[S. Landolt (Gast)]

Zwei Schreibfehler:

> DDRB &= ~(1 << DDD2); // External Interrupt on INT0
> DDRB |= (1<<PORTD5); // PD5 -> Output

Wird nicht mit Letzerem MOSI auf Ausgang geschaltet?

[Kimmy (Gast)]

Das stimmt, war beides falsch geschrieben.

Habe die pins jetzt auf dem richtigen Port gelegt.

> DDRD &= ~(1 << DDD2); // External Interrupt on INT0
> DDRD |= (1<<PORTD5); // PD5 -> Output

Doch leider erhalte ich immer noch nur 0x00 als ergebnis

[Marc V. (Firma: Vescomp) (logarithmus)]

Kimmy schrieb:
> INT0 ist quasi mein SlaveSelect, da ich anders nicht weiss wie ich
> mitbekommen kann, dass der Master etwas gesendet hat.

  USISR |=  (1<<USIOIF);

 Muss auch mal zurückgesetzt werden - normalerweise beim Init
 und dann vor jedem Empfang ;)

 P.S.

  USIDR =  _PassendeAntwort_;
  USISR |=  (1<<USIOIF);

 Wäre auch nicht schlecht...

[Kimmy (Gast)]

Habe das in der ISR zum schluss eingefügt und bei der initialisierung. 
Das hat aber gebracht, dass ich zunächst völlig falsche werte erhalte 
und nach ein paar mal senden (ca. 8mal ) gar nichts mehr empfangen wird.

[Marc V. (Firma: Vescomp) (logarithmus)]

Kimmy schrieb:
> Habe das in der ISR zum schluss eingefügt und bei der initialisierung.

ISR(INT0_vect){

  USIDR =  _PassendeAntwort_;
  USISR =  (1<<USIOIF);

  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
}

 EDIT:
 Nicht |= , sondern =

[Kimmy (Gast)]

Was bedeutet

USIDR =  _PassendeAntwort_;

?

Habe jetzt

ISR(INT0_vect){
  USISR |=  (1<<USIOIF);

  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
}

void spi_init()
// Initialize pins for spi communication
{
  /* --- SLAVE --- */
  /* Set MISO as output, all others input */ 
  DDR_SPI = (1 << DD_MISO);
  DDR_SPI &= ~((1 << DD_MOSI) | (1 << DD_SCK) | (1 << DD_SS));

  /* Enable SP */
  USICR = ((0<<USISIE)|            // Start Condition Interrupt Enable
       (0<<USIOIE)|            // Counter Overflow Interrupt Enable
       (0<<USIWM1)|(1<<USIWM0)|      // Three-wire mode
       (1<<USICS1)|(0<<USICS0)|(0<<USICLK)|
       (0<<USITC));            // Toggle Clock Port Pin

  USISR |=  (1<<USIOIF);
  extern_interrupt_init();

}

Aber jetzt passiert von vornerein gar nichts mehr. Jetzt scheint gar 
nicht mehr in die ISR gesprungen zu werden.

[Kimmy (Gast)]

auch mit = anstelle von |= habe ich gleiches verhalten. Das müsste doch 
auch eigentlich egal sein oder? es wird doch nur das bit USIOIF 
berücksichtigt. dann ist es doch egal ob |= oder = oder nicht?

[Marc V. (Firma: Vescomp) (logarithmus)]

Kimmy schrieb:
> Was bedeutetUSIDR =  PassendeAntwort;?
>
> Habe jetzt
>
> ISR(INT0_vect){
>   USISR |=  (1<<USIOIF);
>
>   while(!(USISR& (1<<USIOIF)))
>   spi_data = USIDR;
>   new_spi_data = 1;
> }

 Und so ?

volatile unsigned char spi_antwort = 0;
...
...
ISR(INT0_vect){

  USIDR =  spi_antwort++;
  USISR =  (1<<USIOIF);

  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
}

[Kimmy (Gast)]

Es wird doch empfangen, war ein Wackelkontakt.
Allerdings falsch und zwar bekomme ich beim Slave sowohl als auch beim 
Master 0xFF heraus. egal was ich sende

[S. Landolt (Gast)]

Leitungen MOSI <-> MISO vertauscht?

[Kimmy (Gast)]

S. Landolt schrieb:
> Leitungen MOSI <-> MISO vertauscht?

nein, wenn ich aber die sck leitung trenne, findet der sich wieder 
zurecht.
dann funktioniert auch die Übertragung. Das richtige Ergebnis wird auch 
übertragen.
Aber das widerspricht meinen Kenntnissen von SPI. Eigentlich schiebe ich 
doch vom Master die Daten rein und lese diese sofort (bzw. die die davor 
gesendet wurden und in USISDR stehen) wieder aus.
Jetzt schreibe ich aber einen anderen Wert in USISDR rein. Diese erhält 
dann auch der Master. Aber das sind ja nicht die, die ich vorher 
gesendet habe

[S. Landolt (Gast)]

Wie sieht das Senden auf dem Master aus? Nach dem Setzen von /SS muss 
eine gewisse Verzögerung vorhanden sein, bevor SPI gestartet wird; 
schließlich benötigt der Slave etwas Zeit, um in die INT0-ISR zu 
gelangen.

[S. Landolt (Gast)]

Das
  USISR =  (1<<USIOIF);
ans Ende der INT0-ISR setzen wird die Sache etwas beschleunigen.

[S. Landolt (Gast)]

>  Nur kann er dann ewig in der while schleife hängen bleiben.
Das ist mir unklar - unter welcher Voraussetzung?

[Kimmy (Gast)]

Wenn ich das am ende der ISR schreibe, bekomme ich immer falsche 
Ergebnisse und irgendwann bleibt es hängen. Wenn ich das am anfang 
hinschreibe, sind die Ergebnisse richtig aber es bleibt trotzdem hängen.
Beim Master setze ich den pin auf low, warte 10ms und fange dann mit dem 
ÜBertragen an.
Ich lasse mir die Übertragenen Daten in der mein-Schleife anzeigen, also 
wenn die ÜBertragung eigentlich schon lange vorüber ist. Trotzdem bleibt 
es hängen, wenn ich es erst dann neue Daten sende.

[S. Landolt (Gast)]

In welchem zeitlichen Abstand wird gesendet? Und wie sieht jetzt das 
Slave-Programm aus?

[Kimmy (Gast)]

Das Programm hat sich nicht wirklich geändert, bis auf die Tippfehler 
(DDRB-> DDRD) und USISR =  (1<<USIOIF); in der initialisierung und in 
der ISR eingefügt.

Aber wenn USISR =  (1<<USIOIF); am anfang von der ISR steht, läuft das 
alles noch ein bisschen stabiler.

Gesendet wird ganz langsam. Das mache ich über den Computer zum Master. 
Dieser empfängt die Daten über UART und gibt diese über SPI weiter.

Im Slave in der HAuptschleife lasse ich mir das Ergebnis ausgeben (auch 
das rückgabeergebnis vom Master lasse ich mir ausgeben). Erst wenn alles 
ausgegeben ist, schicke ich neue Daten. Also zu schnell dürfte das ganze 
nicht sein. Beim Master ist es so, dass dieser den Pin für die ISR auf 
Low zieht und dann 10ms wartet, bevor die Übertragung startet

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


#define F_CPU 8000000UL // for _delay_ms(); _delay_us()
#define FOSC 8000000UL // for Baudrate

/* -- includes -- */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "spi.h"
#include "uart.h"

/* -- USART -- */
#define USART_BAUD 1200
#define USART_MYUBRR FOSC/16/USART_BAUD-1
/* --  -- */

/* -- SPI -- */
#define PORT_SPI    PORTB
#define DDR_SPI     DDRB
#define DD_MISO     DDB6
#define DD_MOSI     DDB5
#define DD_SS       DDB2
#define DD_SCK      DDB7

volatile unsigned char spi_data;
volatile unsigned char new_spi_data;
/* -- -- */

void spi_init()
// Initialize pins for spi communication
{
  /* --- SLAVE --- */
  /* Set MISO as output, all others input */ 
  DDR_SPI = (1 << DD_MISO);
  DDR_SPI &= ~((1 << DD_MOSI) | (1 << DD_SCK));

  /* Enable SP */
  USICR = ((0<<USISIE)|            // Start Condition Interrupt Enable
       (0<<USIOIE)|            // Counter Overflow Interrupt Enable
       (0<<USIWM1)|(1<<USIWM0)|      // Three-wire mode
       (1<<USICS1)|(0<<USICS0)|(0<<USICLK)|
       (0<<USITC));            // Toggle Clock Port Pin

  USISR =  (1<<USIOIF);

  extern_interrupt_init();

}

void extern_interrupt_init(void){
  DDRB &= ~(1 << DDD2); // External Interrupt on INT0

  MCUCR |= (1 << ISC01); // INT0 falling edge
  MCUCR &= ~(1 << ISC00); // INT0 falling edge

  GIMSK |= (1 << INT0);  // enable INT0 interrupt
}

ISR(INT0_vect){
  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
  USISR =  (1<<USIOIF);
}


int main(void){
  spi_data = 0;
  usart_data = 0;
  new_usart_data = 0;
  usart_init(USART_MYUBRR);
  usart_transmit_string("USART devices ready \r\n"); 
  spi_init();
  usart_transmit_string("SPI devices ready \r\n"); 
  sei(); // Global Interrupts activate
  DDRD |= (1<<PORTD5); // PD5 -> Output
  PORTD &= ~(1<<PORTD5); // PD5 -> Low
  while (1){
    if(new_spi_data==1){
      usart_transmit_string("\r\n received data: ");
      usart_transmit_char(spi_data);
      new_spi_data = 0;
    }

  }
}

[Kimmy (Gast)]

Die ISR sieht natürlich so aus:

ISR(INT0_vect){
  USIDR = spi_antwort++;
  while(!(USISR& (1<<USIOIF)))
  spi_data = USIDR;
  new_spi_data = 1;
  USISR =  (1<<USIOIF);
}

[S. Landolt (Gast)]

Für mich sieht das Slave-Programm okay aus (vom belanglosen 
Schreibfehler DDRB &= ~(1 << DDD2) mal abgesehen). Ich würde jetzt den 
Fehler eher in der Verdrahtung oder auch im Master suchen, aber so 
richtig erklären kann ich mir das Fehlverhalten, speziell das 
Hängenbleiben, nicht.

[S. Landolt (Gast)]

"The Universal Serial Interface, or USI... Three-wire Synchronous Data 
Transfer (Master, fSCKmax = fCK/2, Slave fSCKmax = fCK/4)"

Die letztere Bedingung ist erfüllt?