Raspberry Pi kommuniziert mit ATtiny2313 über SPI

[Jens K. (mister232)]

Nachdem ihr mir bei der Kommunikation zwischen einem ATmega32 und einem 
ATtiny2313 so gut geholfen habt, folgt schon gleich das nächste Problem. 
Nun soll nämlich ein Raspberry Pi mit dem Tiny über SPI kommunizieren. 
Das Programm auf dem Tiny sieht wie folgt aus und funktioniert ja 
bereits:

/*
 * SPI_Slave.c
 *
 * Created: 07.07.2013 10:59:29
 *  Author: Jens
 */ 

// This program is for an SPI-Slave Tiny device

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

volatile int data;

// Initialize SPI-Interface
void init_spi()
{
  // Set DO as output and DI, USCK as input and set LED-Ports as output
  DDRB = (1<<DDB6) |  (1<<DDB2) | (1<<DDB3);
  DDRB &= ~(1<<DDB5) | ~(1<<DDB7);
  
  //Enable USI overflow interrupt, set three wire mode and set
  //  clock to External, positive edge.
  USICR = (1<<USIOIE) | (1<<USIWM0) | (1<<USICS1);
  
  //Clear overflow flag
  USISR = (1<<USIOIF);
  
  // Global enable interrupts
  sei();
}

ISR(USI_OVERFLOW_vect) 
{
  // Return data register
  data = USIDR;
  
    // Reset counter-overflow Flag   
   USISR = (1<<USIOIF);  
}

int main(void)
{
  init_spi();
  
  // If data is received via SPI, check if it is an '5' or an '6'. 
  // Then turn on the corresponding LED
    while(1)
  {  
    // Check if "data" includes an '5' -> Turn on LED1 PB2
    if(data == '5')
    {
        PORTB = (1<<PB2);
        PORTB &= ~(1<<PB3);
    }
    // Check if "data" includes an '6' -> Turn on LED2 PB3
    else if(data == '6')
    {
        PORTB = (1<<PB3);
        PORTB &= ~(1<<PB2);
    }
    }
  
  return 0;
}

Nun folgt der Code für das Raspberry:

#include <bcm2835.h>
#include <stdio.h>

int main()
{
      if (!bcm2835_init())
        return 1;

    bcm2835_spi_begin();
    bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST);      // The default
    bcm2835_spi_setDataMode(BCM2835_SPI_MODE0);                   // The default
    bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536); // The default
    bcm2835_spi_chipSelect(BCM2835_SPI_CS0);                      // The default
    bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW);      // the default
    
    int data = '5';
    int i, j;

    for(i = 0; i < 50; i++)
    {
  if(data == '5')
  {
    bcm2835_spi_transfer(data);
    data = '6';
    printf("5 sended...\n");
  }
  else
  {
    bcm2835_spi_transfer(data);
    data = '5';
    printf("6 sended...\n");
  }
        // Wait before sending the next byte
  for(j = 0; j < 50000000; j++){}
    }

    bcm2835_spi_end();
    bcm2835_close();

    return 0;
}

Es sei mir verziehen, dass noch nicht so viele Kommentare drin sind. 
Habe den Code gerade aus der BCM2835-Seite zusammengebaut und bin noch 
am Testen.

Starte ich das Programm, so wechseln die LEDs am ATtiny2313 nur ganz 
selten, wenn überhaupt. Woran kann das liegen? Falscher Takt? Brauche 
ich einen externen Taktgeber am Tiny?

[Jens K. (mister232)]

Keine Raspberry-Freaks hier?

[holger (Gast)]

>Keine Raspberry-Freaks hier?

Die sind beim Abendessen.

>  // Wait before sending the next byte
>  for(j = 0; j < 50000000; j++){}

Alter vergiss die Kacke. Benutz ne Slave Select
Leitung für SPI sonst kommt der nie wieder in Sync
wenn er einmal raus ist. Da nützt dein Delay gar nichts.

>Falscher Takt?

Wie schnell ist der denn?

[holger (Gast)]

>Benutz ne Slave Select
>Leitung für SPI sonst kommt der nie wieder in Sync

>The USI Three-wire mode is compliant to the Serial Peripheral Interface >(SPI) 
mode 0 and 1, but
>does not have the slave select (SS) pin functionality.

Oh, der hat ja gar keine;) Nimm nen ATMeg88 oder deinen
ATmega32.

[Jens K. (mister232)]

Aber zwischen nem Atmega32 und nem Tiny2313 ging es ja auch ohne SS. Das 
Delay soll nur dazu dienen, dass man das blinken auch sehen kann. Den 
Takt dachte ich stelle ich mit dem

bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_65536);

ein?

[holger (Gast)]

>Aber zwischen nem Atmega32 und nem Tiny2313 ging es ja auch ohne SS.

Zufall. Wenn auf der SPI Clock Leitung auch nur ein Glitch kommt
verrutscht deine Übertragung um ein oder bei mehreren Glitches
um mehrere Bit. Da hilft dir ein Delay gar nichts. Du wirst ohne
Slave Select Leitung nie wieder in Sync kommen. Es sei denn du
synchronisierst Master und Slave durch Bitbanging auf der Clock
Leitung erst mal.

Mach es richtig oder lass es sein.

[Moritz A. (moritz_a)]

Application Note dazu ist http://www.atmel.com/Images/doc2582.pdf, 
leider etwas kurz gehalten. Der Beispielcode dazu ist 
http://www.atmel.com/dyn/resources/prod_documents/AVR319.zip.

> When using the USI as a SPI slave, you also need to watch
> the incoming SS line with for instance an interrupt line if
> required.
> The driver in this application note does not use the SS line.

Was spricht denn dagegen, SS auf einen Interruptpin zu legen, und in der 
ISR das USI-Modul sauber zu initialisieren bzw zu deaktivieren, je nach 
Flanke?

[Jens K. (mister232)]

Und wie würde soetwas aussehen? Würde ich dann die Daten in der ISR für 
den externen Interrupt abholen und die andere ISR weglassen oder wie? 
Vielleicht ein Codeschnippsel?

[Jens K. (mister232)]

Beim Master setzte ich den SS ja einfach bevor ich sende und rücksetzte 
ihn, sobald ich die 5 oder 6 übertragen habe oder?

[Moritz A. (moritz_a)]

Codeschnipsel habe ich nicht, aber so in etwa würde ich es wohl 
implementieren:

Flanke !SS H-L
SPI aktiviert, einmal

ISR(INT0_vect) {
  // clear overflow flag, reset counter
  USISR = (1<<USIOIF);
}

Damit ist sichergestellt dass du wirklich "bei 0" startest, und bei 
Glitches nicht um ein bit im byte verschoben bist. Wie viele byte du 
überträgst bevor du !SS einmal toggelst musst du testen, am Anfang 
kannst du es ja mal wirklich nach jedem machen.

Flanke !SS L-H

Eigentlich musst du nix machen, da du ja nach 8bit automatisch den 
overflow interrupt bekommst und die Daten ausliest. Wenn du das ganze 
universell und sauber halten willst setzt du hier DO noch auf input ohne 
pullup, dass dir bei einem anderen Slave am gleichen Bus nicht die 
Kommunikation zerstört wird.

[Jens K. (mister232)]

Okay, ich werde es nachher mal überarbeiten und hier posten. Bin bis 
Sonntag nicht zu Hause und kann es somit nicht testen. Vielleicht bekomm 
ich es mit eurer Hilfe aber soweit hin, dass ich das Programm nur noch 
reinflashen muss.

[Moritz A. (moritz_a)]

Dann bin ich mal gespannt, ich habe hier nämlich auch ein Projekt 
liegen, bei dem ich genau das selbe machen will. Nur braucht das noch 
etwas bis ich dazu kommen werde.

[Peter D. (peda)]

Bisher sind das alles nur Spielereien, die Du machst. Sie haben 
keinerlei praktischen Wert.
Niemand überträgt nur ein Byte und wartet danach 500ms.

Nutzbringend wäre das ganze erst dann, wenn Du auf dem Raspberry Pi das 
SPI per DMA machst, d.h. auch mal eine sinnvolle Datenrate überträgst.
Dann wirst Du merken, daß das SPI des AVR Dich total ausbremst bzw. 
massig Daten verliert.
Das SPI des AVR eignet sich einfach nicht als Slave. Da kannst Du noch 
soviel rumprogrammieren, es geht nicht.

Besser ist daher die UART (gepuffert) oder das I2C (Handshake über SCL) 
zu nehmen.

[Jens K. (mister232)]

Du hast recht, noch sind das nur Spielereien um SPI kennenzulernen. 
Später bekommt das Raspberry ein Funkmodul, welches es über SPI 
anspricht. Auf der anderen Seite sind mehrere Tinys, welche auch ein 
Funkmodul besitzen. Diese steuern dann verschiedene Sachen wie z.B. 
Steckdosen oder Rolladen an. Das Raspberry erhält dann eine schöne 
grafische Oberfläche und einen Touchscreen. Das ganze soll dann eine 
Heimautomatisierung werden, ist aber eher ein Projekt auf mehrere Jahre, 
da ich nun in zwei Wochen erstmal meine Bachelorarbeit schreibe

[Peter D. (peda)]

Jens K. schrieb:
> Auf der anderen Seite sind mehrere Tinys, welche auch ein
> Funkmodul besitzen.

Dann sind aber die Funkmodule SPI-Slave und alle AVRs SPI-Master.
Wozu also sich abquälen mit Dingen, die Du nirgends brauchst?

Ansonsten, für längere Drahtverbindungen (>50cm) ist CAN-Bus die erst 
Wahl.
SPI wäre nur der Garant für: "Das wird nie was".

[Moritz A. (moritz_a)]

Hier habe ich erfolgreich mit 
http://www.mikrocontroller.net/articles/NRF24L01_Tutorial gearbeitet, 
und die SPI-Lib so angepasst dass sie auch mit einem attiny2313a als 
Master tut, siehe 
https://github.com/maugsburger/rfdht22/blob/master/src/lib

[Jens K. (mister232)]

Den AVR als Slave möchte ich nutzen um zu testen ob das SPI am Radpberry 
richtig funktioniert. Sonst weiß ich ja später nicht ob ich das 
Funkmodul falsch ansteure oder ob das Raspberry nur Müll sendet.

[Moritz A. (moritz_a)]

Zum Testen vom SPI am Raspi tut doch auch ein einfaches Schieberegister, 
das agiert deutlich vorhersehbarer. Einfach an jeden Pin eine LCD, und 
du müsstest sehen ob das Muster das du rausschiebst auch passend 
ankommt.

[Jens K. (mister232)]

Nichts desto trotz hier der Code für den Tiny2313 Slave:

/*
 * SPI_Slave.c
 *
 * Created: 07.07.2013 10:59:29
 *  Author: Jens
 */ 

// This program is for an SPI-Slave Tiny device

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

volatile int data;

// Initialize SPI-Interface
void init_spi()
{
  // Set DO, PB2 (LED1) and PB3 (LED2) as output and rest as input
  DDRB = (1<<DDB6) | (1<<DDB2) | (1<<DDB3);
  
  //Enable USI overflow interrupt, set three wire mode and set
  //  clock to External, positive edge.
  USICR = (1<<USIOIE) | (1<<USIWM0) | (1<<USICS1);
  
  // Global enable interrupts
  sei();
}

ISR(INT0_vect)
{
  // Reset counter-overflow Flag
  USISR = (1<<USIOIF);
}

ISR(USI_OVERFLOW_vect) 
{
  // Return data register
  data = USIDR;
  
    // Reset counter-overflow Flag   
   USISR = (1<<USIOIF);  
}

int main(void)
{
  init_spi();
  
  // If data is received via SPI, check if it is an '5' or an '6'. 
  // Then turn on the corresponding LED
    while(1)
  {  
    // Check if "data" includes an '5' -> Turn on LED1 PB2
    if(data == '5')
    {
        PORTB = (1<<PB2);
        PORTB &= ~(1<<PB3);
    }
    // Check if "data" includes an '6' -> Turn on LED2 PB3
    else if(data == '6')
    {
        PORTB = (1<<PB3);
        PORTB &= ~(1<<PB2);
    }
    }
  
  return 0;
}

Was meint ihr davon, würde das so funktionieren?
Man muss schließlich von ganz unten anfangen, bevor man irgendwelche 
großen Prozessoren mit viel aufwändigem Code und perfektem Timing 
programmiert. Da kann ruhig mal das ein odere andere Bit verloren gehen 
;-)

[Moritz A. (moritz_a)]

Ich sehe jetzt nicht, dass du für den SS-Pin Interrupts aktivierst.


Packe das noch mit in spi_init()

    // Initialize external interrupt 0 (PD2)
    MCUCR |= (1<<ISC01);
    MCUCR &= ~(0<<ISC00);  // Set external interupt on falling edge
    GIMSK |= (1<<INT0);    // Activate INT0
    DDRD &= ~(1<<PD2);      // Interrupt Input PIN

[Jens K. (mister232)]

Also so:

/*
 * SPI_Slave.c
 *
 * Created: 07.07.2013 10:59:29
 *  Author: Jens
 */ 

// This program is for an SPI-Slave Tiny device

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

volatile int data;

// Initialize SPI-Interface
void init_spi()
{
  // Set DO, PB2 (LED1) and PB3 (LED2) as output and rest as input
  DDRB = (1<<DDB6) | (1<<DDB2) | (1<<DDB3);
  
  //Enable USI overflow interrupt, set three wire mode and set
  //  clock to External, positive edge.
  USICR = (1<<USIOIE) | (1<<USIWM0) | (1<<USICS1);
  
  // Initialize external interrupt 0 (PD2)
  MCUCR |= (1<<ISC01);
  MCUCR &= ~(0<<ISC00);  // Set external interupt on falling edge
  GIMSK |= (1<<INT0);    // Activate INT0
  DDRD &= ~(1<<PD2);      // Interrupt Input PIN

  // Global enable interrupts
  sei();
}

ISR(INT0_vect)
{
  // Reset counter-overflow Flag
  USISR = (1<<USIOIF);
}

ISR(USI_OVERFLOW_vect) 
{
  // Return data register
  data = USIDR;
  
    // Reset counter-overflow Flag   
   USISR = (1<<USIOIF);  
}

int main(void)
{
  init_spi();
  
  // If data is received via SPI, check if it is an '5' or an '6'. 
  // Then turn on the corresponding LED
    while(1)
  {  
    // Check if "data" includes an '5' -> Turn on LED1 PB2
    if(data == '5')
    {
        PORTB = (1<<PB2);
        PORTB &= ~(1<<PB3);
    }
    // Check if "data" includes an '6' -> Turn on LED2 PB3
    else if(data == '6')
    {
        PORTB = (1<<PB3);
        PORTB &= ~(1<<PB2);
    }
    }
  
  return 0;
}