STM32 SPI (Anfänger-)problem

[Cube_S (Gast)]

Hallo liebe Gemeinde,

ich versuche meinen AVR-geprägten Horizont zu erweitern und 
experimentiere mit einem STM32 Discovery-Board (STM32F407) erweiteret 
mit einem Mikroelektronika "STM32F4 Discovery Shield" und dazu passendem 
"7 seg click" (http://www.mikroe.com/click/7seg/). Die darauf 
befindlichen 74HC595 tun mit Bit-Bangingen was sie sollen.

Mit SPI bekomme ich die Geschichte aber nicht hin. Symptom: Manchmal 
funktionierts, meistens jedoch nicht. Es sieht so aus als gelänge es 
nach Debug-Start genau einmal die richtigen Daten (2-Bytes) 
"rauszuschieben" und danach immer nur noch das Höchste Bit der beiden 
Datenbytes.

#include <stdio.h>
#include <stdlib.h>
#include "diag/Trace.h"
#include "stm32f4xx_hal.h"
#include "stm32f4xx_hal_spi.h"

#pragma GCC diagnostic ignored "-Wunused-parameter"

static int volatile tick_count;
static volatile bool tick;

extern "C" void SysTick_Handler(void)
{
  HAL_IncTick();

  if (tick_count==0)
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
  else if (tick_count==666)
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET);

  if (++tick_count==1000)
  {
    tick_count = 0;
    tick = true;
  }
}

extern "C" void HAL_SPI_MspInit(SPI_HandleTypeDef *sh)
{
   GPIO_InitTypeDef s;

  __SPI2_CLK_ENABLE();
  __GPIOB_CLK_ENABLE();

  s.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
  s.Mode = GPIO_MODE_AF_PP;
  s.Speed = GPIO_SPEED_FAST;
  s.Pull = GPIO_NOPULL;
  s.Alternate = GPIO_AF5_SPI2;
  HAL_GPIO_Init(GPIOB, &s);

  s.Pin = GPIO_PIN_12;
  s.Mode = GPIO_MODE_OUTPUT_PP;
  s.Speed = GPIO_SPEED_FAST;
  s.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &s);

  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);
}

int main(int argc, char* argv[])
{
  HAL_Init();
  trace_printf("System clock: %uHz\n", SystemCoreClock);

  __GPIOD_CLK_ENABLE();

  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_InitStructure.Pin = GPIO_PIN_12;
  GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStructure.Speed = GPIO_SPEED_FAST;
  GPIO_InitStructure.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStructure);

  SPI_HandleTypeDef sh;
  sh.Instance = SPI2;
  sh.Init.Mode = SPI_MODE_MASTER;
  sh.Init.Direction = SPI_DIRECTION_2LINES;
  sh.Init.DataSize = SPI_DATASIZE_8BIT;
  sh.Init.CLKPolarity = SPI_POLARITY_LOW;
  sh.Init.CLKPhase = SPI_PHASE_1EDGE;
  sh.Init.NSS = SPI_NSS_SOFT;
  sh.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
  sh.Init.FirstBit = SPI_FIRSTBIT_MSB;
  sh.Init.TIMode = SPI_TIMODE_DISABLE;
  sh.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  sh.Init.CRCPolynomial = 1;

  HAL_SPI_Init(&sh);

  static uint8_t buffer[] = { 0xB6, 0x0A };
  static uint8_t rbuf[2];

  HAL_StatusTypeDef s = HAL_SPI_TransmitReceive(&sh, buffer, rbuf, 2, 100);
  HAL_Delay(10);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);
  HAL_Delay(10);
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);

  trace_printf("SPI Status = %d (%02x, %02x)\n", s, rbuf[0], rbuf[1]);

  while(1)
  {
    if (tick)
    {
      tick = false;

      uint8_t h = buffer[0];
      buffer[0] = buffer[1];
      buffer[1] = h;

      s = HAL_SPI_TransmitReceive(&sh, buffer, rbuf, 2, 100);
      HAL_Delay(10);
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);
      HAL_Delay(10);
      HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);

      trace_printf("SPI Status = %d (%02x, %02x)\n", s, rbuf[0], rbuf[1]);
    }
  }
}

Der Output der 74HC595 ist wieder mit MISO verbunden so dass ich immer 
die letzten Werte der beiden 74HC595 wieder auslesen kann. Diese stimmen 
auch immer mit der Anzeige überein.

Was könnte ich hier übersehen haben?

[Ich selber (Gast)]

Cube_S schrieb:
> Was könnte ich hier übersehen haben?

Ich gehe mal davon aus, das du das Datenblatt deiner SPI Komponenten 
gelesen hast.

 - SPI Mode
 - SPI Geschwindigkeit


Allgemein empfehle ich die Anschaffung eine Protokoll Analysers, sofern 
nicht schon vorhanden (etwa Zeroplus logicube).

Mann kommt sonst schnell ins Raten


Zur Cube/HAL Methoden.
Bei mir haben die Methoden TransmitReceive()
Und Transmit(), receive() .
Nicht immer die gleichenergebnisse gebracht.

Heißt:
Bei Baustein A hat TransmitReceive wunderbar funktioniert.
Ein anderes mal musste ichtrennen in expliziet, Transmit und Receive,
ausbrobieren;_)

[Justus S. (jussa)]

schon versucht, das Senden & Empfangen 'per Hand' zu machen? Ich hatte 
bei beim STM32F3 Discovery das Problem, dass die HAL-Funktion bei 
niedrigen Baudraten gut funktioniert hat, bei höheren aber immer doppelt 
so viele CLK-Pulse ausgegeben hat wie eigentlich nötig...

[Cube_S (Gast)]

Vielen Dank für die Anregungen. Vor allem das Spielen mit den 
Geschwindigkeiten brachte Erfolg. Mit lausigen 160Hz SPI Frequenz ging 
dann alles, was natürlich keine Lösung ist.

Protokoll habe ich dann auch mit dem Oszi angesehen, sah eigentlich 
(gemessen an den Pins des Discovery-Boards) gut aus, direkt am Board mit 
den 74HC595 weniger.

Moral von der Gesicht: Es war eine kalte Lötstelle an einem Pin-Header 
des "7 seg click" den ich selbst angelötet hatte. Echter Anfängerfehler 
obwohl ich nicht das erste mal löte und auch nicht nur Buchsenleisten.

[hiero (Gast)]

Magst du den funktionierenden Code nochmal hier posten? Danke.

[Cube_S (Gast)]

Der Code sollte in Ordnung sein, soweit ich mich erinnere. Es war 
wirklich nur ein Hardwareproblem (kalte Lötstelle)

[Ert (Gast)]

GPIO_PinAFConfig(xxxxx xxxx xxxx)
fehlt doch doch

hier ein Code für SPI3 der funktioniert

SPI_InitTypeDef         SPI_InitStruct;
SPI_InitTypeDef         SPI_InitStructure;
GPIO_InitTypeDef         GPIO_InitStructure_SPI;


//Clock
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC,  ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3  | RCC_APB1Periph_TIM13, ENABLE);
  //*********************************************************************************
//GPIO
//Chip Selsct Ausgang Init  
  GPIO_StructInit(&GPIO_InitStructure_SPI);
  GPIO_InitStructure_SPI.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure_SPI.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure_SPI.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure_SPI.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(SPI_CS_PORT, &GPIO_InitStructure_SPI);
  
  
//SCK, MISO, MOSI
  GPIO_StructInit(&GPIO_InitStructure_SPI);
  GPIO_InitStructure_SPI.GPIO_Pin = SPI_SCK_PIN | SPI_MISO_PIN | SPI_MOSI_PIN;
  GPIO_InitStructure_SPI.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure_SPI.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure_SPI.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructure_SPI.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(SPI_PORT, &GPIO_InitStructure_SPI);    
  
  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource10, GPIO_AF_SPI3);
  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource11, GPIO_AF_SPI3);
  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource12, GPIO_AF_SPI3);
  


SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // set to full duplex mode, seperate MOSI and MISO lines
SPI_InitStruct.SPI_Mode = SPI_Mode_Master; // transmit in master mode, NSS pin has to be always high
SPI_InitStruct.SPI_DataSize = SPI_DataSize_16b; // one packet of data is 8 bits wide
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low; // clock is low when idle
SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge; // data sampled at first edge
//SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Set; // set the NSS management to internal and pull internal NSS high
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; // SPI frequency is APB2 frequency / 4
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;// data is transmitted MSB first
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI_Init(SPI3, &SPI_InitStruct);
SPI_Cmd(SPI3, ENABLE); // enable SPI3