Problem mit RasPi wiringPi SPI

[Juergen G. (jup)]

Ich hab hier ein komisches verhalten des SPI auf dem Raspi und keine 
Ahnung wo ich noch suchen soll.

Vermutlich ist es irgendeine Dummheit in meinem Code, ein cast Fehler 
oder irgend so etwas, aber ich weiss nicht wo.

Kann sich das mal jemand ansehen.

Kurze Beschreibung.
Es soll eine Kommunikation zwischen einem RasPi und einem STM32 werden.
Da das RasPi nur SPI Master kann und immer den Takt geben will muss der 
Slave (STM32) an einem Pin des RasPi wackeln, dann sendet das RasPi 
einen dummy Frame mit lauter Nullen und empfangt die Daten des STM32.

Problem:
Die Daten die ich empfange sind immer um 1 bis 4 Bytes "geshiftet"

Der STM sendet immer:
48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65 
66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83

auf dem RasPi kommt das dann folgendermassen an.

Slave request
48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64 
65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82
Slave request
83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63 
64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81
Slave request
82  83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62 
63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
Slave request
48  82  83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61 
62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79
Slave request
48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64 
65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82
Slave request
83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63 
64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81
Slave request
82  83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62 
63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80
Slave request
48  82  83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61 
62  63  64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79
Slave request
48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64 
65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81  82
Slave request
83  48  48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63 
64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79  80  81

Auf dem RasPi benutze ich die wiringPi lib, habe es aber auch schon 
direkt mit ioctl versucht, mit dem selben Ergebniss.
Auf dem STM laeuft eigener Code.
Wenn ich die Uebertragung zwischen zwei STM32 mache, kommt das raus was 
ich erwarte.

hier der RasPi code

#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "spi_Comm_Handler.h"
#include <wiringPi.h>
#include <wiringPiSPI.h>


volatile uint8_t dbg_SPIKnockCounter = 0;
volatile uint8_t transferArray[SPI_TRANSFERDATASIZE] = {0, };


/* ISR for slave knock Pin */
void slaveKnockHandler (void) {
  printf("Slave request\n");
  dbg_SPIKnockCounter++ ;
  flush_Transfer_Buffer();
  send_SPI_Frame();
}

int init_SPI_Comm_Handler(void) {
  int spidev;
  printf ( "sizeof(transferArray): %d\n", sizeof(transferArray)) ;
  if (wiringPiSetup () < 0) {
    fprintf (stderr, "Unable to setup wiringPi: %s\n", strerror (errno)) ;
    return 0 ;
  }  
      
  spidev = wiringPiSPISetup (0, 500000) ;
  if (spidev == -1) {
    fprintf (stderr, "Unable to setup SPI: %s\n", strerror (errno)) ;
    return 0 ;  
  }
  
  pinMode (SLAVE_KNOCK_PIN,  INPUT) ;
    
  if (wiringPiISR (SLAVE_KNOCK_PIN, INT_EDGE_FALLING, &slaveKnockHandler) < 0) {
    fprintf (stderr, "Unable to setup ISR: %s\n", strerror (errno)) ;
    return 0 ;
  }  
  
  spi_writeLCD(0, 0, "Hello Raspi here");
  
  return 1 ;
}

void flush_Transfer_Buffer(void){
  uint8_t c = 0;
  
  for (c = 0; c < SPI_TRANSFERDATASIZE; c++) {
    transferArray[c] = 0;
  }
}

void send_SPI_Frame(void){

  if (wiringPiSPIDataRW (0, (unsigned char *)transferArray, SPI_TRANSFERDATASIZE)) {
    handle_incoming_SPI_Data();
  } else {
    fprintf (stderr, "Error in Transfer\n") ;
  }
}

void showRData(void) {
  
  uint8_t c = 0;
  
  for (c = 0; c < SPI_TRANSFERDATASIZE; c++) {
    printf(" %d ", transferArray[c]);
  }
  printf("\n");
  return;
  
}

/* 
 * to prevent recursive traffic 
 * here we cannot call to transfer another data
 */
void handle_incoming_SPI_Data(void) {
  showRData();
}

[Daniel44 (Gast)]

Hallo Juergen G.

könntest Du bitte noch den STM32-Code posten.
Ich versuche seit einiger Zeit ebenfalls eine Kommunikation zwischen 
STM32F4Discovery(Slave) und dem Raspi erzustellen.
Bei mir hapert es schon daran, das ich nicht weiß wie ich den SPI beim 
STM32 initialisieren soll (Clock, Polarität, Phase, ...)

Ich würde mich über Unterstützung freuen

Gruß Daniel

[Juergen G. (jup)]

Ich haeng einfach mal .h und .c aus meinen Versuchen an, Du musst Dir da 
das rauspicken was fuer Dich interessant ist.

Ich habe mit diesen Files erst eine Communication zwischen zwei STMs 
aufgebaut um zu sehen das der Code funktioniert, und es dann auf das 
Raspi angepasst.
Es ist also ne Menge Kram im Code der nicht mehr gebraucht wird.

Ich weiss, das kann verwirrend sein, aber bei mir ist das auch noch 
Baustelle.

Prinzipiell brauchst Du nur die

void init_SPI(void);
void config_SPI_IO(void);

und die ISR

void SPI2_IRQHandler(void)

[Juergen G. (jup)]

Natuerlich Anhang vergessen. :-)