STM32F091RCT6 SPI Peripheral weird behavior with 8 bits data mode

[Frederic REMY]

Posted on June 09, 2017 at 11:23

Hello,

I have a

weird

  behavior with STM32F091RCT6 SPI Peripheral on Nucleo Evaluation Board.

I want to interface with a 25LC640 SPI eeprom with 8 bits data mode

When i want to send a byte, i see On Oscilloscope 16 clocks pulse instead of 8 !!

I have tested several setting, i have the good number of pulses for 9 bits data size and more .

Context :

STM32F091RCT6

HAL library 1.6

Keil IDE & compiler : 5.06

SPI2 Peripheral on Port B Pin 13,14,15 Master Mode without NSS pin

SPI setup like this :

void MX_SPI2_Init(void)

{

  hspi2.Instance = SPI2;

  hspi2.Init.Mode = SPI_MODE_MASTER;  hspi2.Init.Direction = SPI_DIRECTION_2LINES;  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;  hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;  hspi2.Init.NSS = SPI_NSS_SOFT;  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;  hspi2.Init.CRCPolynomial = 8;  hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;  hspi2.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;  if (HAL_SPI_Init(&hspi2) != HAL_OK)  {    Error_Handler();  }

}

    __HAL_RCC_SPI2_CLK_ENABLE();

       __HAL_SPI_ENABLE(spiHandle);              /**SPI2 GPIO Configuration        PB13     ------> SPI2_SCK    PB14     ------> SPI2_MISO    PB15     ------> SPI2_MOSI     */    GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF0_SPI2;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

Sending function :

static uint8_t eep_SpiSendByte (uint8_t data)

{

    while (( EE_SPI->SR & SPI_SR_TXE_Msk) == RESET);             // Wait for empty transmit buffer

    EE_SPI->DR = data;                                                                      

    while (( EE_SPI->SR & SPI_SR_RXNE_Msk) == RESET);           // Wait for received buffer with new data

    return (uint8_t)EE_SPI->DR;

}

Thanks

#stm32f091-spi-spi_datasize_8bit #hal-v1.6

[waclawek.jan]

Posted on June 09, 2017 at 11:33

*(volatile uint8_t*)&EE_SPI->DR = data;   

[AvaTar]

Posted on June 09, 2017 at 11:45

Or perhaps this:

while (( EE_SPI->SR & SPI_SR_TXE_Msk) == RESET); // Wait for empty transmit buffer

The TXE flag set does not mean the send finished, only the send data are moved to the hardware send reg.

I fell into this trap some time ago ...

[Frederic REMY]

Posted on June 09, 2017 at 12:08

@ Avatar,

tanks for your suggestion, but i have yet the datasize problem on the fisrt byte !

When I send read instruction to 25LC640, it is the first byte after starting execution of program !

[waclawek.jan]

Posted on June 09, 2017 at 11:52

Perhaps, but it's more likely it's the 'data packing' feature, see RM0090  'data packing' subchapter of the SPI chapter.

A recurring issue here ever since the 'enhanced' SPIs appeared, first with 'F0.

JW

[Zt Liu]

Posted on June 09, 2017 at 12:02

I think the above is the correct answer.

[Frederic REMY]

Posted on June 14, 2017 at 12:42 The original post was too long to process during our migration. Please click on the provided URL to read the original post. https://st--c.eu10.content.force.com/sfc/dist/version/download/?oid=00Db0000000YtG6&ids=0680X000006I6sd&d=%2Fa%2F0X0000000bx9%2FJp_.W_1wbImvwjMGmQvsNnW_jzlcOwrc8svwRqrT4hc&asPdf=false

[Frederic REMY]

Posted on June 14, 2017 at 14:24

@ Krall

Tanks for your reply :)

But i need to send one byte separately, and in 8 bits mode I have allways two bytes 16 pulses on Clock pin.

I can't use the data packing

Our driver work like this :

uint8_t eep_ReadByte (uint32_t adress)

{

    volatile uint8_t tmpRead;                                                /* For Trace

    EEP_CS_ENABLE;

    delayUS(5);    eep_SpiSendByte(0x03);                                                /* Commande de lecture */

#if (defined EEP_25LC010) || (defined EEP_25LC020)

    eep_SpiSendByte((uint8_t)adress);                                /* Adresse à lire */#elif defined EEP_25LC040    #error 'code non ecrit'                                                      /* Autres instruction */#elif defined EEP_25LC160 || (defined EEP_25LC320) || (defined EEP_25LC640) || (defined EEP_25LC256) || (defined EEP_25LC512)     eep_SpiSendByte((uint8_t) adress >> 8);

    eep_SpiSendByte((uint8_t) adress);

#endif

    tmpRead = eep_SpiReceiveByte();

      TmpReadDebug = tmpRead ;                                         // for trace     delayUS(5);    EEP_CS_DISABLE;

    return tmpRead;

}

I have several other functions to managed a 25LCxxx witch are based on the following function :

Complementary eep_SpiSendByte and eep_SpiReceivedByte.

I didn't use HAL library because its too heavy and too slow in small STM32 for our product. (only for valid chip initialisation).

The 25LCxx Frame is divided in three part

instruction 8 bits

Adress 16 bits

Data 8 bits and more if need more data.

how i can now when one byte or two nibbles are receveid in RxFifo ?

while ((EE_SPI->SR & SPI_SR_RXNE_Msk) == RESET);        // Waiting Reception of Low Nibble

Or

while ((EE_SPI->SR & 0x0600) != 0x0400 )            // Waiting Two data In Fifo

[Kraal]

Posted on June 14, 2017 at 13:40

But you don't have to use the 4 bit mode ! Have you tried the solution

Waclawek.Jan

gave you in the first reply ?

He even explained why you have this behavior, i.e. the data packing feature.

With his solution you want have to do all that stuff you do...

[Kraal]

Posted on June 14, 2017 at 14:36

You didn't read carefully my answer, or didn't understand it completely.

Your function to send a byte is

static uint8_t eep_SpiSendByte (uint8_t data){ while (( EE_SPI->SR & SPI_SR_TXE_Msk) == RESET);// Wait for empty transmit buffer EE_SPI->DR = data; while (( EE_SPI->SR & SPI_SR_RXNE_Msk) == RESET);// Wait for received buffer with new data return (uint8_t)EE_SPI->DR;}�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?

And

told you that you should in fact write it like this

static uint8_t eep_SpiSendByte (uint8_t data){ while (( EE_SPI->SR & SPI_SR_TXE_Msk) == RESET);// Wait for empty transmit buffer *(volatile uint8_t*)&EE_SPI->DR = data; while (( EE_SPI->SR & SPI_SR_RXNE_Msk) == RESET);// Wait for received buffer with new data return (uint8_t)EE_SPI->DR;}�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?

The only difference is at line 4, it will force an 8-bit access to the data register of the SPI peripheral and it will send only 8 bits. No need to change to 4 bits mode at all. Try it and you will see by yourself.

Edit: why is this being moderated ? Syntax highlighter ?