ATmega128 und Atmega32 mit SPI verbinden und String senden

[CG (Gast)]

Hallo Zusammen,
hoffe mir kann jemand helfen.

Ich habe zwei ATmegas (32 und 128) mittels SPI verbunden. Beide Laufen 
mit 16MHz.
Der ATMEGA32 ist als Master konfiguriert und der 128 als Slave.
Ich bin mitlerweile so weit gekommen, dass der Master ein Byte (in 
meinem Fall zum Testen ein 'A') sendet und der Slave schaut ob ein 'A' 
angekommen ist und dann einfach eine LED schaltet.
Dies Funktioniert soweit ziemlich gut :-)

Nun zu meinem Problem.
Ich würde gerne ein String senden, z.B. "Time\n" und wenn der Slave das 
richtige bekommt, dann soll diesr erstmals auch einfach eine LED 
einschalten. (Arbeite mich langsam Schritt für Schritt vor)

Quellcode beim Master sieht wie folgt aus :

char spi_send_string(char string[], int cs)
{
  uint8_t length;
  uint8_t i;
 
  length = strlen(string);
  
  for(i=0; i < length; i++)
  {
     spi_send(string[i], cs);
  }
}

char spi_send (unsigned char data, int cs)
{
  PORT_SPI &= ~(1<<cs);        // SS am Slave Low --> Beginn der Übertragung
    SPDR = data;            // Daten ins Buffer-Register laden und senden mittels Interrupt
  _delay_us(10);
  while (!(SPSR & (1<<SPIF)));
  //_delay_ms(1);
  _delay_us(10);
  PORT_SPI |= (1<<cs);        // SS High --> Ende der Übertragung
  return (SPDR);            // Return received data  
}

zum senden benutze ich einfach

 spi_send("TIME\n", PIN_SPI_CS3);

beim Slave habe ich nun folgendes gemacht. Ich habe im Interrupt 
folgenden Quellcode:

volatile unsigned char data;
// SPI Transmission/reception complete ISR
ISR(SPI_STC_vect)
{
  SWITCH_LED3;
  data = SPDR;
    // add to buffer if room
  if (spi_data_pos < sizeof(spi_data_buf) )
    {
    spi_data_buf[spi_data_pos++] = data;  
    if (data == '\n')
    {
      spi_data_pos = 0;
    }
    } 
}

spi_master_slave.h

#ifndef SPI_MASTER_SLAVE_H_
#define SPI_MASTER_SLAVE_H_

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

#include "../global.h"
extern volatile char spi_data_buf[50];
extern volatile int spi_data_pos;

void spi_init_slave (void);
void spi_init_master (void);
char spi_send (char data, unsigned char cs);

#endif /* SPI_MASTER_SLAVE_H_ */

global.h

#define F_CPU 16000000UL


// SPI DatenVariable
volatile char spi_data_buf[50];
volatile int spi_data_pos;

.....

und in der Main eine whileschleife

  cli();            // Disable all interrupts
  initPort();          // Inizalisierung der Ports
//  spi_init_master();      // SPI Inizalisierung
  spi_init_slave ();      // SPI Inizalisierung als Slave        
  sei();            // enable all interrupts
while(1)
{
        SWITCH_LED1;
  _delay_ms(500);
  if (spi_data_buf == "TIME\n")
    SWITCH_LED2;
}

Kann mir vielleicht jemand verraten warum die Überprufung im 
spi_data_buf nicht Funkioniert bzw. nicht das richtige drin steht? Habe 
ich da einen Denkfehler in meinem Programm?
Oder etwas mit den Variablen (Buffern für den String) falsch gemacht?

Falls ich zu wenig Informationen gegeben habe einfach bescheid sagen was 
fehlt und ich poste es sofort nach!

Dankeschön im Vorfeld für eure Hilfe.

[Spiffman G. (spiffman)]

Hallo,

soweit ich das verstanden habe vergleichst du den Zeiger auf deinen 
Buffer mit dem Text (vermtl. temporäre Variable). Daher sollte der 
vergleich nie wahr werden.

Versuch doch mal die Funktion strcmp:
http://www.gnu.org/software/libc/manual/html_node/String_002fArray-Comparison.html

[CG (Gast)]

Oh super für die schnelle Antwort.
werde es mal morgen früh ausprobieren und dann bescheid geben. Bin 
leider nicht daheim.
Mis morgen

[CG (Gast)]

Okay super es funktioniert!

Darf ich jetzt noch fragen wenn ich vom Slave eine Antwort zurücksenden 
möchte (eigentlich ein String aber erstmal ein 'B' zum Testen)
kann man das dann so machen wie ich es gemacht habe?

Slave ISR

ISR(SPI_STC_vect)
{  
  int i;
  
  SWITCH_LED3;
  data = SPDR;  // Ankommende Daten über SPI in Buffer Schreiben
    
  if (spi_data_pos < sizeof(spi_data_buf) )
    {
    spi_data_buf[spi_data_pos++] = data;  
    if (data == '\n')
    {
      spi_data_pos = 0;
      if (strcmp(spi_data_buf,"TIME\n") == 0)
      {
        SWITCH_LED2;
        SPDR = 'B';
      }
    }
    }

}

und beim Master

// Senden von Daten über SPI
// Beispiel: spi_data = spi_send ('T', PIN_SPI_CS3); // senden von einem Byte auf der SPI-Schnittstelle
char spi_send (unsigned char data, int cs)
{
  PORT_SPI &= ~(1<<cs);        // SS am Slave Low --> Beginn der Übertragung
    SPDR = data;            // Daten ins Buffer-Register laden und senden mittels Interrupt
  _delay_us(10);
  while (!(SPSR & (1<<SPIF)));
  //_delay_ms(1);
  _delay_us(10);
  PORT_SPI |= (1<<cs);        // SS High --> Ende der Übertragung
  return (SPDR);            // Return received data  
}

// Senden von Daten über SPI
// Beispiel: spi_data = spi_send ("TEST\n", PIN_SPI_CS3); // senden von einem String auf der SPI-Schnittstelle
char spi_send_string(char string[], int cs)
{
  uint8_t length;
  uint8_t i;
  char tmp;
 
  length = strlen(string);
  
  for(i=0; i < length; i++)
  {
     tmp = spi_send(string[i], cs);
  }
  return (tmp);
}

und dann die nächste Frage wie sende ich denn ein String zurück?
Wie sieht denn die CS-Leitung dann aus?

[CG (Gast)]

Okay leider Funkioniert dies bei mir nicht!  :-(
Glaube ich habe ein verständnisproblem. Hat jemand vielleicht einen 
Nützlichen Tip für mich? Komm leider nicht weiter

[Sebastian W. (wangnick)]

1. Der String "TIME\n" besteht aus sechs Zeichen: 'T', 'I', 'M', 'E', 
'\n', '\0'. strcmp bricht bei der ersten Ungleichheit ab, oder wenn zwei 
'\0'-Zeichen gefunden wurden.

2. Die Abwicklung eines Protokolls (und das Senden einer Antwort auf 
eine Anfrage gehört schon dazu) sollte dann nicht mehr in einer ISR 
stattfinden, sondern in einem Zustandsautomaten im Hauptprogramm.

3. Checksum! Immer Checksum!

So weit erst einmal.

LG, Sebastian

[Jim M. (turboj)]

CG schrieb:
> Okay leider Funkioniert dies bei mir nicht!

Kann nicht funktionieren. Das 'B' kommt erst beim nächsten vom Master 
gesendeten Zeichen als Antwort. Und auch das nur wenn die Slave ISR 
schnell genug ausgeführt wurde, sonst noch später. SPI Slave 
Programmierung ist nicht trivial.

[CG (Gast)]

Das heißt ich kann den Slave nicht im Interrupt betreiben?
Ich habe nun dieses Beispiel gefundne und dort schreibt er ja vor dem 
empfangen über SPI schon seine Antwort ins datenregister. Wenn ich da 
srichtig verstanden habe wird ja das senden und lesen gleichzeigig 
ausgeführt. Jedoch müssen doch der Master und der Slave gleichzeitig die 
Funkion aufrufen oder? Das war mein Gedanke warum ich den Slave 
Interruptgesteuert gemacht habe.

[Sebastian W. (wangnick)]

CG schrieb:
> Jedoch müssen doch der Master und der Slave gleichzeitig die
> Funkion aufrufen oder?

Dort wo der Master empfangen soll kann er ja Nullen senden die der Slave 
dann ignoriert.

Strings variabler Länge sind für ein SPI-Protokoll sowieso eher 
schwierig. Versuch doch erst einmal, Daten mit fixer Grösse 
auszutauschen.

LG, Sebastian