SPI Code STM32F103

[Alfa (Gast)]

Hallo zusammen,

Ich versuche nun schon den ganzen Tag nach unzähligen erfolglosen 
Versuchen eine SPI Kommunikation zu einem ADT7320 Temperatursensor 
aufzubauen. Leider erfolglos.


Hat eventuell jemand einen beispielcode für einfache SPI Kommunikation 
ohne DMA und Interrupts?

Ich will einfach nur das ID REGISTER des Chips auslesen.

Bin für jedes funktionierende Beispiel auf dem o.g. Controller dankbar!

[Baldrian (Gast)]

Gibt's doch in den ST Libs oder in libopencm3.

[Mojo (Gast)]

Gemeine Falle ist wenn du als Master nicht den NSS setzt.

SPI_InitTypeDef spiInit;
SPI_StructInit(&spiInit);
...
spiInit.SPI_NSS = SPI_NSS_Soft;
SPI_NSSInternalSoftwareConfig( SPI1, SPI_NSSInternalSoft_Set );

[Alfa (Gast)]

Mojo: Ich habe das "SPI_NSSInternalSoftwareConfig( SPI1, 
SPI_NSSInternalSoft_Set );" noch ergänzt. Leider erfolglos.
Ich versuche einen ADT7320 Temperatursensor anzusteuern. Die Ansteuerung 
funktioniert auf einem ATmega2560 bereits erfolgreich. Das Programm 
läuft mit CoOs, jedoch habe ich den selben Code auch schon ohne CoOs mit 
dem selben Ergebnis getestet. Orientiert habe ich mich (unter anderem) 
auch an diesem Thread: Beitrag "SPI Probleme zwischen STM32 und ADT7310"

Eventuell hat jemand eine Idee woran es liegen könnte? Hier noch die 
Ausgabe des Programms:

CoOS RTOS: Creating tasks
CoOS RTOS: Starting scheduler
CoOS 'taskA' started
CoOS 'taskB' started
CS1 SET
CS1 RESET
ADT7320 RESET OK
CS1 SET
VOR RR8 SPI WRITE: OK


Danach hängt er sich auf. Ich verzweifele hier langsam.

Hier mal mein Code:

/********** Init SPI **********/

InitSPI1(){

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_SPI1, ENABLE);

  GPIO_InitStructure.GPIO_Pin = MB_SPI1SCK_PIN | MB_SPI1MISO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = MB_SPI1MOSI_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = MB_CS_CJ1_Pin;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  GPIO_WriteBit(GPIOA, MB_CS_CJ1_Pin, SET);

  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CRCPolynomial = 0;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_NSSInternalSoftwareConfig( SPI1, SPI_NSSInternalSoft_Set );

  SPI_Init(SPI1, &SPI_InitStructure);

  SPI_Cmd(SPI1, ENABLE);
}


/********** CoOS Task **********/

void taskB (void* pdata)
{

  if (DebugLevel == 2) {
      USART_PutString(USART1,"CoOS 'taskB' started\n");
    }

  ADT7320_Reset(1);
  Delay(0xFF);
  while(1){

    GPIOA->BSRR = MB_LedYellow_Pin;
    
    uint16_t regdataID = 0;
    uint16_t regdataSTATUS = 0;
    char s_regdataID[10] = "";
    
    regdataID = ADT7320_ReadRegister8(1, ADT7320_REG_ID);
    regdataSTATUS = ADT7320_ReadRegister8(1,ADT7320_REG_STAT);
    
    sprintf(s_regdataID, "%d", regdataID);
    USART_PutString(USART1,s_regdataID);
    USART_PutString(USART1,"\n");
    
    CoTickDelay (100);
    GPIOA->BRR = MB_LedYellow_Pin;
    CoTickDelay (100);
  }
}


/********** ADT7320 Reset **********/

void ADT7320_Reset(uint8_t cs)
{
  uint16_t data = 0;
  ADT7320_Select(cs);      // Select (Active Low)
  data = SPI_Write(0xFFFF);
  data = SPI_Write(0xFFFF);
  ADT7320_Deselect(cs);    // Deselect (Active Low)
  Delay(0xFF);
  USART_PutString(USART1,"ADT7320 RESET OK\n");
}

/********** ADT7320 ReadRegister 8 **********/

uint16_t ADT7320_ReadRegister8(uint8_t cs, uint8_t reg)
{
  uint16_t data = 0;
  // reg = 3, da IDREG
  reg = reg << 3;
  ADT7320_Select(cs);
  USART_PutString(USART1,"VOR RR8 SPI WRITE: OK\n");
  uint16_t regdata16 = (uint16_t)(0x40 | reg);
  data = SPI_Write(regdata16);    // write to comm reg
  USART_PutString(USART1,"RR8 SPI WRITE: OK\n");
  Delay(0xFF);
  ADT7320_Deselect(cs);
  Delay(0xFF);

  return data;
}


/********** SPI Write **********/

uint16_t SPI_Write(uint16_t data) {
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); //wait buffer empty
  SPI_I2S_SendData(SPI1, data);
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == SET); //wait finish sending}
  Delay(0x0F);
  return (uint16_t)SPI_I2S_ReceiveData(SPI1);
}


/********** Select / Deselect **********/

void ADT7320_Select(uint8_t cs){

  if (cs == 1){
    MB_CS_CJ1_Port->BSRR = MB_CS_CJ1_Pin;
    USART_PutString(USART1,"CS1 SET\n");
  }
  else if (cs == 2){
    MB_CS_CJ2_Port->BSRR = MB_CS_CJ2_Pin;
  }
  else if (cs == 3){
    MB_CS_CJ3_Port->BSRR = MB_CS_CJ3_Pin;
  }
  else{
    //
  }
}

void ADT7320_Deselect(uint8_t cs){

  if (cs == 1){
    MB_CS_CJ1_Port->BRR = MB_CS_CJ1_Pin;
    USART_PutString(USART1,"CS1 RESET\n");
  }
  else if (cs == 2){
    MB_CS_CJ2_Port->BRR = MB_CS_CJ2_Pin;
  }
  else if (cs == 3){
    MB_CS_CJ3_Port->BRR = MB_CS_CJ3_Pin;
  }
  else{
    //
  }
}

[Alfa (Gast)]

Hat keiner einen Vergleichscode? Ich probiere schon wieder den ganzen 
Tag und kann keinen wirklichen Unterschied zu den anderen Beispiel 
feststellen.

Hab ich etwas auf den Augen?
Vielleicht seh ich es einfach nicht mehr...

[Alfa (Gast)]

Niemand eine Idee?
Hie sind doch eine ganze Menge STM Experten.

[Menge (Gast)]

Es lohnt sich definitiv, für ein paar Euro einen "Logic Analyser"
oder für ein paar Euro mehr einen Logic Analyser anzuschaffen.
Notfalls ist auch ein STM32F4Disco als solcher verwendbar.

Spart viel Zeit...

[Mehmet K. (mkmk)]

Alfa schrieb:
> Niemand eine Idee?
> Hie sind doch eine ganze Menge STM Experten.
Na ja, wenn sich jemand als Alfa titulierend auf der Bühne plaziert, ist 
für den Rest des Rudels halt die Hemmschwelle etwas gross, sich zu Wort 
zu melden.

Ich habe nicht das Ganze mir angesehen; aber gleich am Anfang stolperte 
ich über folgende Zeilen:

GPIO_InitStructure.GPIO_Pin = MB_SPI1SCK_PIN | MB_SPI1MISO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Pin = MB_SPI1MOSI_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);

MOSI = Microcontroller OUT, Slave IN
Da macht es nicht sehr viel Sinn, dies als GPIO_Mode_IN_FLOATING zu 
definieren.

[Menge (Gast)]

PS:
Das:

>  GPIO_WriteBit(GPIOA, MB_CS_CJ1_Pin, SET);

im Vergleich zu

>     MB_CS_CJ1_Port->BSRR = MB_CS_CJ1_Pin;

ist mindestens inkonsequent. Dann wären Deine
eher verschleiernden "ADT7320_Select" und "ADT7320_Deselect"
unnötig. 30 Zeilen Code gespart, Wartungssicherheit und Lesbarkeit 
verbessert.
Hättest Du in den Stunden der Verzweiflung auch 'mal aufräumen
können.


Wieso lässt Du Dir die Werte, die der ADT7320 liefert, nicht
ausgeben (z.b. in "ADT7320_ReadRegister8")?

[dummy (Gast)]

Wo rufst du das auf?

InitSPI1()

[chris (Gast)]

Kannst dich ja mal durch meinen Code wühlen.
Alle Funktionen hab ich nicht getestet, aber die Basisfunktionen müssten 
gehen.

[chris (Gast)]

Nachtrag:
Der Code ist für einen STM32F100VB geschrieben (STM32VL Discovery).