Frage: STM32F103 beide SPI benutzen

[asd (Gast)]

Hallo,

ich habe ein Bluepill Board und versuche gerade beide SPI Busse zu 
benutzen. Ich habe die Seiten von Stefan Frings und seine CMSIS Dateien 
als Start benutzt:
http://stefanfrings.de/stm32/stm32f1.html
Das gefällt mir ganz gut, das Setzen der Registerwerte funktioniert 
ähnlich wie ich das vom AVR mega gewohnt bin. Jetzt bin ich aber auf ein 
Problem gestoßen bei dem mir das Rference Manual und Beispiele im 
Internet nicht weiter helfen. Ich versuche beide SPI Busse zu benutzen, 
aber es gelingt mit nur beim SPI1. Der SPI2 schiebt keine Daten raus, 
und sein "TXE" (TX buffer empty) Bit geht nach dem ersten schreiben auf 
Null und wird nie wieder high.
SPI2 hängt auf dem APB1 Bus, währen die Peripherie die ich erfolgreich 
benutzt habe (SPI1 und USART1) am APB2 hängen. Vielleicht ist das ein 
Hinweis? In allen Beispielen im Internet hat auch bei APB1 Peripherie 
ein Aktivieren gereicht:
SET_BIT(RCC->APB1ENR, RCC_APB1ENR_SPI2EN); // Enable SPI2

Im Reference Manual habe ich keinen Hinweis gefunden dass mehr als das 
nötig ist. Am CPU Clock wird nichts verändert, es sollten also alle 
Clocks bei 8MHz liegen.

Ich hänge mal den kompletten Code hier rein. Am Anfang von main wird 
direkt in die Funktion "test_spi2" gesprungen, dort nur die beiden SPI 
initialisiert (nur "init_gpio();" wird angespungen, alle anderen 
Funktionen werden in diesem Beispiel nicht benutzt)

Vielleicht sieht einer der ARM-Freaks gleich das Register das ich noch 
setzen müsste...

void test_spi2()
{
  uint16_t data=0;
  int led_state=0;

    // Enable Port A, B, C and alternate functions
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPAEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPBEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_IOPCEN);
    SET_BIT(RCC->APB2ENR, RCC_APB2ENR_AFIOEN);


  SET_BIT(RCC->APB2ENR, RCC_APB2ENR_SPI1EN); // Enable SPI1
  SET_BIT(RCC->APB1ENR, RCC_APB1ENR_SPI2EN); // Enable SPI2

  init_gpio();  // set all ports to GPIO and alternate functions  // ToDo: vor oder nach dem SPI setup?!??

  SET_BIT(SPI1->CR1, SPI_CR1_DFF);  // 16 bit per transfer
  SET_BIT(SPI1->CR1, SPI_CR1_MSTR);  // Master mode
  SET_BIT(SPI1->CR1, SPI_CR1_BR_2);  // clock div 32 / RM0008 p.743  ( bei 8MHz Takt sind das 250kHz)
  //SET_BIT(SPI1->CR1, SPI_CR1_BR_0);  // clock div 4  / RM0008 p.743
  SET_BIT(SPI1->CR1, SPI_CR1_SPE);  // SPI enable

  SET_BIT(SPI2->CR1, SPI_CR1_DFF);  // 16 bit per transfer
  SET_BIT(SPI2->CR1, SPI_CR1_MSTR);  // Master mode
  SET_BIT(SPI2->CR1, SPI_CR1_BR_2);  // clock div 32 / RM0008 p.743
  //SET_BIT(SPI2->CR1, SPI_CR1_BR_0);  // clock div 4  / RM0008 p.743
  SET_BIT(SPI2->CR1, SPI_CR1_SPE);  // SPI enable

und dann die Datenübertragung:

    // write 2x 16 bit on SPI2 and 2x 16bit on SPI1
    WRITE_REG(GPIOB->BSRR,GPIO_BSRR_BR12);  // PB12 low  ( Chip select for SPI)
    while (!(SPI1->SR & SPI_SR_TXE));   // busy wait for TX buffer ready to write
    //while (!(SPI2->SR & SPI_SR_TXE));   // busy wait for TX buffer ready to write  // bei SPI2 hängt der hier ewig (außer beim ersten Aufruf)
    SPI2->DR=0x55ff;    // send 16 bit word
    SPI1->DR=data;    // send 16 bit word
    while (!(SPI1->SR & SPI_SR_TXE));   // busy wait for TX buffer ready to write
    //while (!(SPI2->SR & SPI_SR_TXE));   // busy wait for TX buffer ready to write  // bei SPI2 hängt der hier ewig
    SPI2->DR=0x300f;    // send 16 bit word
    SPI1->DR=data;    // send 16 bit word
    while ( (SPI1->SR & SPI_SR_BSY));   // busy wait for SPI transfer to be finished
    while ( (SPI2->SR & SPI_SR_BSY));   // busy wait for SPI transfer to be finished  (SPI2 hängt hier nicht)
    WRITE_REG(GPIOB->BSRR,GPIO_BSRR_BS12);  // PB12 high  ( Chip select for SPI)

[NichtWichtig (Gast)]

Mach das mal mit der CubeIDE.

[HALVerweigerer (Gast)]

NichtWichtig schrieb:
> Mach das mal mit der CubeIDE.

Ja denn auch mit CubeMX kann man (praktisch gänzlich) ohne
HAL arbeiten ....

[HALVerweigerer (Gast)]

Wenn man das so macht kann eigentlich nicht viel schiefgehen.

/* FUNCTION ************************************/
void SPI_Init (SPI1_Mode_t mode)
/*
 * SPECIFICATION:  Init SPI1  STM32F103
 ***********************************************/
{
  GPIO_InitTypeDef    GPIO_InitStruct;
  SPI_InitTypeDef     SPI_InitStruct;

  //  Initialize SPI
  RCC_APB2PeriphClockCmd (RCC_APB2Periph_SPI1, ENABLE);

  RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOA, ENABLE);
  RCC_APB2PeriphClockCmd (RCC_APB2Periph_AFIO, ENABLE);

  SPI_InitStruct.SPI_Direction         = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStruct.SPI_Mode              = SPI_Mode_Master;
  SPI_InitStruct.SPI_DataSize          = SPI_DataSize_8b;
  SPI_InitStruct.SPI_NSS               = SPI_NSS_Soft;
  SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
  SPI_InitStruct.SPI_FirstBit          = SPI_FirstBit_MSB;
  SPI_InitStruct.SPI_CRCPolynomial     = 7;

  if (mode == SPI_MODE_0)
  {
    SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  }
  else if (mode == SPI_MODE_1)
  {
    SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;
  }
  else if (mode == SPI_MODE_2)
  {
    SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
    SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  }
  else if (mode == SPI_MODE_3)
  {
    SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
    SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;
  }
  else
  {
    SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
  }

  SPI_Init (SPI1, &SPI_InitStruct);

  /* Configure SPI1 pins: SCK and MOSI with default alternate
  function (not remapped) push-pull */
  GPIO_InitStruct.GPIO_Pin   = SPI_MOSI_PIN | SPI_SCLK_PIN;
  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_PP;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init (GPIOA, &GPIO_InitStruct);

  /* Configure MISO as Input with internal pull-up */
  GPIO_InitStruct.GPIO_Pin   = SPI_MISO_PIN;
  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IPU;
  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init (GPIOA, &GPIO_InitStruct);

  SPI_Cmd (SPI1, ENABLE);

} /* --- SPI_Init --- */

Für das andere SPI muss man halt darauf achten das richtige
RCC_APBxPeriphClockCmd und RCC_APB2Periph_SPIx zu verwenden,
das gilt auch für die entsprechenden Ports und Alternate
Functions.

Meiner Meinung nach sehr übersichtlich, und es gibt kein
Gefrickel mit Bits im Register setzen oder clearen ....

[HALVerweigerer (Gast)]

Der Vollständigkeit halber:

//----------------------------
// Includes
//----------------------------
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_spi.h"

// Peripherie Defines - alle Pins liegen auf Port A

#define  SPI_MOSI_PIN     GPIO_Pin_7  /*    */
#define  SPI_MISO_PIN     GPIO_Pin_6  /*    */
#define  SPI_SCLK_PIN     GPIO_Pin_5  /*    */

//----------------------------
// SPI Mode
//----------------------------
typedef enum
{
  SPI_MODE_0 = 0,  // CPOL=0, CPHA=0
  SPI_MODE_1,      // CPOL=0, CPHA=1
  SPI_MODE_2,      // CPOL=1, CPHA=0
  SPI_MODE_3       // CPOL=1, CPHA=1
} SPI1_Mode_t;

[Monk (roehrmond)]

asd schrieb:
> Der SPI2 schiebt keine Daten raus,
> und sein "TXE" (TX buffer empty) Bit geht nach dem ersten schreiben auf
> Null und wird nie wieder high.

Mit dem Problem bist du offenbar nicht alleine, schau:
Beitrag "Stm32f103 Problem mit Spi2"

Leider habe ich keine Lösung. Hast du den MISO Pin als Eingang 
konfiguriert? Das ist im Master Modus wichtig.

Dort gibt's noch ein anderes Beispiel mir ausführlicher Erklärung:
https://learnbuildshare.wordpress.com/about/stm32/using-spi-as-master/