SPI am STM32F103 funktioniert nicht wie gewünscht

[Michael L. (nightflyer88)]

Hallo zusammen

Ich möchte mit einem STM32F103CBT6 einen Schrittmotor Controller TMC5160 
per SPI ansteuern. Nun habe ich ein Problem mit der konfiguration des 
SPI am STM32. Ich schaff es einfach nicht eine Verbindung zum TMC5160 
herzustellen. Ich programmiere mit der STM32cubeIDE.

Zum testen habe ich mal ein Arduino Nano genommen und den Beispielcode 
von Trinamic, und funktioniert natürlich einwandfrei, an der Hardware 
liegts also nicht.

Arduino Code (läuft):

#include <SPI.h>
#include "TMC5130_registers.h"

/* The trinamic TMC5130 motor controller and driver operates through an 
 *  SPI interface.  Each datagram is sent to the device as an address byte
 *  followed by 4 data bytes.  This is 40 bits (8 bit address and 32 bit word).
 *  Each register is specified by a one byte (MSB) address: 0 for read, 1 for 
 *  write.  The MSB is transmitted first on the rising edge of SCK.
 *  
 * Arduino Pins   Eval Board Pins
 * 51 MOSI        32 SPI1_SDI
 * 50 MISO        33 SPI1_SDO
 * 52 SCK         31 SPI1_SCK
 * 25 CS          30 SPI1_CSN
 * 17 DIO         8 DIO0 (DRV_ENN)
 * 11 DIO         23 CLK16
 * GND            2 GND
 * +5V            5 +5V
 */

int chipCS = 10;
const byte CLOCKOUT = 9;
int enable = 8;

void setup() {
  // put your setup code here, to run once:
  pinMode(chipCS,OUTPUT);
  pinMode(CLOCKOUT,OUTPUT);
  pinMode(enable, OUTPUT);
  digitalWrite(chipCS,HIGH);
  digitalWrite(enable,LOW);
  digitalWrite(CLOCKOUT,LOW);

  //set up Timer1
 /* TCCR1A = bit (COM1A0);                //toggle OC1A on Compare Match
  TCCR1B = bit (WGM12) | bit (CS10);    //CTC, no prescaling
  OCR1A = 0;                            //output every cycle
*/
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV8);
  SPI.setDataMode(SPI_MODE3);
  SPI.begin();

  Serial.begin(115200);
  delay(5000);
  Serial.println("Setup");

  sendData(0x80,0x00000000);      //GCONF

  sendData(0xEC,0x000101D5);      //CHOPCONF: TOFF=5, HSTRT=5, HEND=3, TBL=2, CHM=0 (spreadcycle)
  sendData(0x90,0x00070603);      //IHOLD_IRUN: IHOLD=3, IRUN=10 (max.current), IHOLDDELAY=6
  sendData(0x91,0x0000000A);      //TPOWERDOWN=10

  sendData(0xF0,0x00000000);      // PWMCONF
  //sendData(0xF0,0x000401C8);      //PWM_CONF: AUTO=1, 2/1024 Fclk, Switch amp limit=200, grad=1

  sendData(0xA4,0x000003E8);     //A1=1000
  sendData(0xA5,0x000186A0);     //V1=100000
  sendData(0xA6,0x0000C350);     //AMAX=50000
  sendData(0xA7,0x000186A0);     //VMAX=100000
  sendData(0xAA,0x00000578);     //D1=1400
  sendData(0xAB,0x0000000A);     //VSTOP=10

  sendData(0xA0,0x00000000);     //RAMPMODE=0

  sendData(0xA1,0x00000000);     //XACTUAL=0
  sendData(0xAD,0x00000000);     //XTARGET=0

  Serial.println("Run");
}

void loop() {
  // put your main code here, to run repeatedly:
  sendData(0xAD,0x0007D000);     //XTARGET=512000 | 10 revolutions with micro step = 256
  delay(20000);
  sendData(0x21,0x00000000);
  sendData(0xAD,0x00000000);     //XTARGET=0
  delay(20000);
  sendData(0x21,0x00000000);
}

void sendData(unsigned long address, unsigned long datagram) {
  //TMC5130 takes 40 bit data: 8 address and 32 data

  delay(100);
  unsigned long i_datagram;

  Serial.print("SPI_w: ");
  Serial.print(address,HEX);
  Serial.print(" ");
  Serial.println(datagram,HEX);

  digitalWrite(chipCS,LOW);
  delayMicroseconds(10);

  SPI.transfer(address);

  i_datagram |= SPI.transfer((datagram >> 24) & 0xff);
  i_datagram <<= 8;
  i_datagram |= SPI.transfer((datagram >> 16) & 0xff);
  i_datagram <<= 8;
  i_datagram |= SPI.transfer((datagram >> 8) & 0xff);
  i_datagram <<= 8;
  i_datagram |= SPI.transfer((datagram) & 0xff);
  digitalWrite(chipCS,HIGH);

  Serial.print("SPI_r: ");
  Serial.print(address,HEX);
  Serial.print(" ");
  Serial.println(i_datagram,HEX);
  Serial.println();
}

Hier meine SPI Konfiguration am STM32, die nicht funktioniert:

static void MX_SPI1_Init(void)
{

  /* USER CODE BEGIN SPI1_Init 0 */

  /* USER CODE END SPI1_Init 0 */

  /* USER CODE BEGIN SPI1_Init 1 */

  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_HARD_OUTPUT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */

  /* USER CODE END SPI1_Init 2 */

}

Hier die SPI Kommunikation mit dem Slave:

void tmc5160_readWriteArray(uint8_t channel, uint8_t *data, size_t length)
{
  uint8_t uartTXbuffer[50];
  char buffer [50];
  int n;

  n = sprintf (buffer, "SPI_w: %x %x %x %x %x ", data[0], data[1], data[2], data[3], data[4]);
  memcpy(uartTXbuffer,buffer,sizeof(buffer));
  CDC_Transmit_FS(uartTXbuffer,n+1);

  HAL_SPI_TransmitReceive(&hspi1, data, data, 5, 100); // <---------------------------------------------------

  n = sprintf (buffer, "SPI_r: %x %x %x %x %x\n\n", data[0], data[1], data[2], data[3], data[4]);
  memcpy(uartTXbuffer,buffer,sizeof(buffer));
  CDC_Transmit_FS(uartTXbuffer,n+1);
}

Der Master (STM32) senden 5 bytes zum Slave (TMC5160), gleichzeitig 
sendet der Slave 5 bytes zurück (Status). Das erste Byte ist die Adresse 
des Registers. Aussehen sollte das so :

SPI_w: 80 0      (Befehl)
SPI_r: 80 FA000  (Antwort)

Aber bei mir kommt nur ein Datenmüll zurück. Der Befehl wird schon gar 
nicht richtig zum Slave übertragen, sonst würde mindesten der Motor am 
Controller laufen.

Ich bin mir nicht sicher ob HAL_SPI_TransmitReceive richtig ist ? Im 
Arduino Code wird SPI im Mode 3 konfiguriert, bin aber der Meinung, dass 
ich das so richtig konfiguriert habe ?


Ich hoffe jemand kann mir weiter helfen, oder hat sogar ein 
Beispielcode.

Danke und Gruss
Michael

[Guest (Gast)]

Du solltest vielleicht noch deinen Chip Select schalten sonst wird dein 
TMC garnichts machen.

[Guest (Gast)]

Und in den gleichen Buffet zu schreiben aus dem man etwas sendet macht 
wenig Sinn. Und wo data definiert ist sehe ich auch nicht.

[Guest (Gast)]

*buffer

[Michael L. (nightflyer88)]

Ok danke. Ich bin davon ausgegangen, wenn NSS auf Hardware Output 
eingestellt ist, dass die SPI Schnittstelle das selber steuert. Nun habe 
ich das NSS manuel per Software gesteuert, aber es ändert sich nichts. 
Auch den rxbuffer habe ich separiert, leider ohne erfolg.

Bei HAL_SPI_TransmitReceive verstehe ich nicht ganz wie lang die 
Datenlänge eingestellt werden muss, man findet im www unterschiedliche 
angaben. Bei 5 byte senden & empangen = 10 ? Oder doch nur 5 ?

[Guest (Gast)]

Die Peripherie kann soweit ich weiß nicht wirklich den NSS ansprechen 
das ist etwas verwirrend.

Wenn du bei DataSize 8_Bit eingestellt hast dann sendet er bei 1 1 Byte 
bei 2 2 Byte und so weiter. Wenn du DataSize auf z.B. 16 stellst schickt 
er mit 1 2 Byte mit 2 4 Byte usw.

In deinem Fall wenn du 5 Byte verarbeiten willst musst du bei den 
aktuellen Einstellungen mit 8 Bit also 5 einstellen. Bei TransmitRecive 
sendet und empfängt er gleichzeitig. Wie gesagt müssen die Buffer 
unterschiedlich sein.

Ist die Taktrate und der SPI Moder richtig eingestellt?

[Guest (Gast)]

Wenn ich das richtig sehe will der TMC SPI Mode 3 also CPOL High und und 
Seconds Edge. Damit wären deine CLKPhase falsch. Außerdem kann der TMC 
ohne externen Oszillator nur 8MHz, wenn du den F1 mit 72MHz taktest und 
einen Prescaler von 8 hast sind das aber 9MHz. Wenn du am TMC einen 
Oszillator hast sollte das aber gehen dann kann er 16MHz. Du solltest 
den NSS auch auf disable stellen und ihn komplett in der Software 
steuern.

Ansonsten kann es noch sein das die Konfiguration der SPI Schnittstelle 
nicht vollständig ist. Der Code den du gepostet hast reicht nicht. Es 
muss noch Code geben der die GPIOs initialisiert und die Clock für die 
Peripherie aktiviert. Sollte das mit der IDE erstellt worden sein müsste 
er das aber angelegt haben.

[Michael L. (nightflyer88)]

Ok danke ! super jetzt läufts ! CLKPhase war falsch, im Arduino Code war 
der auf 1 gesetzt, und ich habe gedacht das wäre das gleiche wie 1 Edge.

Aber wie gesagt, das 2. Problem war auch das NSS Signal, geht nur per 
Software. Was meinst Du, muss zwischen NSS und der ersten SPI 
Komunikation eine kleine Verzögerung sein, gemäss Timingdiagramm des TMC 
sollte es nicht nötig sein ? Es funktioniert bis jetzt auch einwandfrei.

HAL_GPIO_WritePin(GPIOA, CS_Pin, 0);
// delay ?
HAL_SPI_TransmitReceive(&hspi1, data, rxData, 5, 100
// delay ?
HAL_GPIO_WritePin(GPIOA, CS_Pin, 1);

Mit 16 prescaler ergibt sich eine Baudrate von 3 mbit/s gemäss IDE.

[Guest (Gast)]

Michael L. schrieb:
> Was meinst Du, muss zwischen NSS und der ersten SPI Komunikation eine
> kleine Verzögerung sein

In der Regel nicht. Die Verzögerung zwischen GPIO Write und bis SPI 
anfängt zu senden reicht meistens massig aus.

Michael L. schrieb:
> Mit 16 prescaler ergibt sich eine Baudrate von 3 mbit/s gemäss IDE.

Das kommt auf deinen Systemtakt an. In dem Fall nutzt du wohl 48MHz 
statt den möglichen 72MHz

[Michael L. (nightflyer88)]

Guest schrieb:
> Das kommt auf deinen Systemtakt an. In dem Fall nutzt du wohl 48MHz
> statt den möglichen 72MHz

Ja genau, läuft mit 48Mhz.

Vielen dank für deine Hilfe, hat mir sehr weitergeholfen.