ATmega8 über SPI mit ATtiny85 verbinden

[Konstantin L. (konze)]

Hallo zusammen,

ich versuche derzeit einen ATmega8 mit einen ATtiny85 über SPI zu 
verbinden (später soll der ATtiny85 die Werte an seinem ADC an den 
ATmega8 weitergeben).

Hierzu läuft auf dem ATmega8 ein SPI Master. Gesteuert wird der ATmega8 
über UART mit dem Computer. Wenn vom Computer aus das Signal 'send\n' 
geschickt wird dann übertragt der ATmega8 ein Byte (hier 97 == 'a') über 
den SPI Bus. Anschließend soll der ATtiny85 das gesendete Byte um 1 
erhöhen und zurück an den ATmega8 übertragen. Leider scheint mir der 
ATtiny immer nur 255 zurück zusenden anstatt 98 == 'b'.

Die beiden Controller sind wie folgt miteinander verbunden:

   ATmega8 -- ATtiny85

       GND -- GND
  PB2 (SS) -- PB4 (soll später als Slave Select verwendet werden)
PB3 (MOSI) -- PB1 (MISO)
PB4 (MISO) -- PB0 (MOSI)
 PB5 (SCK) -- PB2 (SCK)

Hier ist der Code für den ATmega8 (Master)
(In uart.h befindet sich der Code für die Kommunikation mit dem 
Computer)

#define F_CPU 8000000UL

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

#include "uart.h"

uint8_t spi_tranceiver (uint8_t data);

void process_command(uint8_t * command) {
  
    uint8_t success = 0;

    
    if(strcmp(command, "send") == 0) {
        uint8_t send_byte = 97;


        int i;

        uart_puts("send: ",6);

        for(i = 7; i >= 0; i--) {
            if((send_byte & (1 << i)) == (1 << i)) {
                uart_putc('1');
            } else {
                uart_putc('0');
            }
        }

        uart_putc('\n');
        uart_putc('\r');


        uint8_t received_byte = spi_tranceiver(send_byte);

        uart_puts("recv: ",6);

        for(i = 7; i >= 0; i--) {
            if((received_byte & (1 << i)) == (1 << i)) {
                uart_putc('1');
            } else {
                uart_putc('0');
            }
        }

        uart_putc('\n');
        uart_putc('\r');
    }

    if(success == 1) {
        uart_puts("ack\n",4);
    }
}

void spi_init_master (void) {
    DDRB = (1<<5)|(1<<3);              //Set MOSI, SCK as Output
    SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0); //Enable SPI, Set as Master
                                       //Prescaler: Fosc/16, Enable Interrupts
}

//Function to send and receive data
uint8_t spi_tranceiver (uint8_t data) {
    SPDR = data;                       //Load data into the buffer
    while(!(SPSR & (1<<SPIF) ));       //Wait until transmission complete
    return(SPDR);                      //Return received data
}

uint8_t main (void) {

    // enable interrupts
    sei();

    // enable uart
    uart_init(); 
    spi_init_master();

    sei();

    // send ready
    uart_puts("ready\n\r", 7);

    uint8_t * command;
    uint8_t command_in_queue;

    while(1) {
        command_in_queue = command_queue_pop(&command);
        
        if(command_in_queue == 0) {
            process_command(command);
            free(command);
        }
    }

    return 0; 
}

Auf dem ATtiny85 läuft der folgende Code

#define F_CPU 8000000UL

#include <avr/io.h>


// Set USI to slave mode - do this at startup
void spi_init_slave() {
    USICR = (1<<USIWM0)|(1<<USICS1);
}

// Receive a byte from the master
uint8_t spi_tranceiver() {

    // Clear counter overflow flag
    USISR = (1<<USIOIF);

    // Wait for complete byte to arrive
    while ((USISR & (1<<USIOIF))==0) {}

    // Return received byte
    uint8_t byte = USIDR;
    USIDR = byte+1;
}


uint8_t main(void) {

    spi_init_slave();

    while(1) {
        spi_tranceiver();
    }
    
    return 0;

}

Im angehängten Bild ist die Kommunikation zwischen dem Computer und dem 
ATmega8 aufgezeichnet. Hier Protokolliert der ATmega8 die SPI 
Kommunikation mit dem ATtiny85. Könnt ihr mir einen Tipp geben?

Vielen Dank und viele Grüße

Konze

[Thomas E. (thomase)]

Konstantin L. schrieb:
> DDRB = (1<<5)|(1<<3);              //Set MOSI, SCK as Output

SS muss als Ausgang konfiguriert sein. Sonst ist der Pin die externe 
M/S-Umschaltung.

mfg.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Konstantin L. schrieb:
> Anschließend soll der ATtiny85 das gesendete Byte um 1 erhöhen und
> zurück an den ATmega8 übertragen.
Dir ist klar, wie SPI funktioniert? Nein?
SPI sind einfach gekoppelte Schieberegister. Siehe dort in der Mitte:
http://www.lothar-miller.de/s9y/categories/17-SPI

Nachdem der SlaveSelect-Fehler behoben ist:
Um von einem SPI-Slave etwas zu "empfangen" musst du vom Master 
irgendetwas  "senden". Denn für jedes Bit, das du vom Master sendest 
kommt exakt gleichzeitig ein Bit vom Slave zurück. Du bekämst mit 
diesem Programm also immer deine Daten um einen Zyklus "versetzt" 
zurück.

Siehe den Beitrag "Erstes Byte über SPI immer falsch"

Und da war doch vor kurzem so ein unerfreulicher Thread zum selben Thema 
"Verbinden von 2 uC mit SPI", der es aber trotzdem wert ist, gelesen zu 
werden:
Beitrag "Re: SPI 16-Bit Problem"