STM32F03x - SPI via DMA - Clock fehlt auf MISO

[Jens (Gast)]

Hallo zusammen,

ich habe schon einige Beiträge hier im Forum zu diesem Thema gelesen - 
bin aber irgendwie noch nicht auf den Richtigen Tread gestoßen, deswegen 
hier meine Frage.

Ich versuche gerade für ein Projekt einen STM32F030C mit jeweils 2 HC595 
und HC165 zur IO Erweiterung zu verbinden. Für Senden und Empfangen 
würde ich gerne den DMA benutzen. Dabei macht mich das Empfangen gerade 
ziemlich verrückt.

Die SPI ist als Fullduplex konfiguriert. MISO als Eingangspin. Die 
anderen beiden als AF. Speed ist 2MHz, die SPI ist sehr herunter 
getaktet, so dass der Takt auf dem Daten etwa 8Khz beträgt.
Als DMA nehme ich DMA1 Channel 2 (RX) und 3 (TX) im Interrupt Modus. Die 
laufen auf dem selben Interrupt zusammen, was aber auch nicht so das 
Problem ist. Damit kann ich leben.
DMA ist für beide Channel gleich konfiguriert, lediglich RX und TX 
Buffer sind verschieden.

Problem an der Sache: Sende an die HC595 funktioniert via DMA perfekt. 
Die Clock geht raus, die Daten werden geschrieben.
Empfangen über MISO funktioniert aber nicht. Irgendwie wird keine Clock 
geniert. Ohne Clock bekomme ich aber die Daten nicht aus den HC165 
Bausteinen heraus.

Leider kann ich den Code von der Initialisierung nicht einstellen, da 
ich jetzt zu Hause sitze und den Code im Büro habe.

Hat jemand eine Idee woran das liegen könnte?

Grüße

Jens

[holger (Gast)]

>Empfangen über MISO funktioniert aber nicht. Irgendwie wird keine Clock
>geniert.

SPI generiert nur einen Clock wenn man etwas sendet.
Also sende Dummy Bytes wenn du etwas empfangen möchtest.

[A. Horn (Gast)]

https://de.wikipedia.org/wiki/Serial_Peripheral_Interface

[Jens (Gast)]

Hallo,

erst mal Danke für die Antworten. War ja auch irgendwie klar. Hätte ich 
auch selbst drauf kommen können bzw. müssen.

Jetzt kommt aber ein Nachfolgeproblem mit dem ich gerade Kämpfe. 
Mittlerweile habe ich die Hardware soweit, dass sendet und auch 
Empfangsdaten von den Erweiterungen zurück an den Controller gehen. Ich 
kann die Daten auf dem Ozsiloskop sehen, die ändern sich auch wenn ich 
was ändere. Physikalisch also soweit wohl erst mal alles Takko.

Nur dummerweiße kommt in meinen Eingangspuffer nichts an. Ich habe es 
sowohl manuell versucht in dem ich die SPI direkt angesprochen habe, als 
auch via DMA - jedes mal bleibt meine Eingangsvariable leer.

Hier mal meine Initialisierung:

void SPI1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;

    /* enable GPIO clock */
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);

    /*enable SPI1 clock*/
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);


    /* Configure SPI1 IO Pin's */
    GPIO_InitStructure.GPIO_Pin = SPI_SCK | SPI_MOSI; // | SPI_MISO;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_StructInit (&GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = SPI_MISO;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_PinAFConfig(GPIOB, SPI_SCK_AF,  GPIO_AF_0);
  //GPIO_PinAFConfig(GPIOB, SPI_MISO_AF, GPIO_AF_0);
    GPIO_PinAFConfig(GPIOB, SPI_MOSI_AF, GPIO_AF_0);

     /*Configure SPI1*/
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

    #ifdef WRITE_SPI_VIA_8BIT_SPI
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  #else
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  #endif

    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB; // SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 16;
    SPI_Init(SPI1, &SPI_InitStructure);

    SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
    SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
    SPI_Cmd(SPI1, ENABLE);
}

void SPI1_DMA_Config(unsigned char* rx_buff,unsigned char* tx_buff)
{
  DMA_InitTypeDef DMA_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;

  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);  // enable DMA clock

  #ifdef READ_SPI_VIA_DMA
  /*Configure DMA channel 2 to SPI1 -> memory -> Rx*/
  DMA_DeInit(DMA1_Channel2);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI1_DR_Address;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)rx_buff;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = SPI1_BUFFER_SIZE;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel2, &DMA_InitStructure);

  DMA_ITConfig(DMA1_Channel2, DMA_IT_TC, ENABLE);    // enable DMA interrupt
  DMA_Cmd(DMA1_Channel2, DISABLE);          // enable DMA

  /*Configure NVIC for DMA interrupt*/
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  DMA_SetCurrDataCounter(DMA1_Channel2, 0);
  DMA_Cmd(DMA1_Channel2, ENABLE);
  #endif

  #ifdef WRITE_SPI_VIA_DMA
  /*Configure DMA channel 3 to memory -> SPI1 -> Tx*/
  DMA_DeInit(DMA1_Channel3);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI1_DR_Address;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)tx_buff;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  DMA_InitStructure.DMA_BufferSize = SPI1_BUFFER_SIZE;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel3, &DMA_InitStructure);

  DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);
  DMA_Cmd(DMA1_Channel3, DISABLE);


  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  DMA_SetCurrDataCounter(DMA1_Channel3, 0);
  DMA_Cmd(DMA1_Channel3, ENABLE);
  #endif
}

Die DMA Funktion wird aber ausgeführt beim lesen, ich sehe die Daten auf 
dem Oscar, kann sie aber im Debuger nicht sehen. DA steuert Interrupt am 
Ende an.

Dann habe ich das ganze noch mal versucht indem ich direkt auf die SPI 
zugreife. Das gleiche Spiel - ich seh die Daten auf dem Oscar, die Änder 
sich auch passend - im Eingangspuffer liegen sie aber nicht.

read via dma

signed char SPI1_DMA_Start_Transmit(unsigned char len,SPI1_call_back_funcptr p_func)
{
  if(DMA_GetCurrDataCounter(DMA1_Channel3) == 0)
  {
    SPI1_CallBackFunc = p_func;    // initialize the function pointer
    DMA_Cmd(DMA1_Channel2, DISABLE);
    DMA_Cmd(DMA1_Channel3, DISABLE);
    DMA_SetCurrDataCounter(DMA1_Channel2, len);
    DMA_SetCurrDataCounter(DMA1_Channel3, len);
    DMA_Cmd(DMA1_Channel2, ENABLE);
    DMA_Cmd(DMA1_Channel3, ENABLE);
    spi_busy_flag = 1;
    return 1;
  }
  return 0;
}

Jemand eine Idee?

Grüße

Jens

[Jim M. (turboj)]

Du konigurierst MISO auf GPIO Input. Muss der nicht auch auf AF 
konfiguriert werden, damit die Daten bei der SPI HW ankommen?

[Jens (Gast)]

Hatte das mal in einem anderem Forum gelesen, dass man das machen soll.

Ich habs in beiden Variaten versucht - sowohl als AF, als auch als GPIO, 
das hat aber bisher keinen Unterschied gemacht. 0x0000 bleibt eben 0!

Jens