Ich versuche, das SPI-Beispiel von STM32Cube mit einem STM32F429-Board und einem STM32F4-Board auszuführen. Der erste hat einen Takt von 180 MHz und der zweite 168 MHz, beide mit ähnlichen Arm Cortex-M3-Mikrocontrollern.
Ich verwende die HAL-Bibliothek, um auf die Peripheriegeräte zuzugreifen, und ich konfiguriere sie damit:
main.c ==>
SpiHandle.Instance = SPI4;
SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SpiHandle.Init.CLKPhase = SPI_PHASE_1EDGE;
SpiHandle.Init.CLKPolarity = SPI_POLARITY_HIGH;
SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
SpiHandle.Init.CRCPolynomial = 7;
SpiHandle.Init.DataSize = SPI_DATASIZE_8BIT;
SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SpiHandle.Init.NSS = SPI_NSS_SOFT;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLE;
if(HAL_SPI_Init(&SpiHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
stm32f4xx_hal_msp.c ==>
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
GPIO_InitTypeDef GPIO_InitStruct;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* Enable GPIO TX/RX clock */
SPIx_SCK_GPIO_CLK_ENABLE();
SPIx_MISO_GPIO_CLK_ENABLE();
SPIx_MOSI_GPIO_CLK_ENABLE();
/* Enable SPI clock */
SPIx_CLK_ENABLE();
/*##-2- Configure peripheral GPIO ##########################################*/
/* SPI SCK GPIO pin configuration */
GPIO_InitStruct.Pin = SPIx_SCK_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
GPIO_InitStruct.Alternate = SPIx_SCK_AF;
HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);
/* SPI MISO GPIO pin configuration */
GPIO_InitStruct.Pin = SPIx_MISO_PIN;
GPIO_InitStruct.Alternate = SPIx_MISO_AF;
HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);
/* SPI MOSI GPIO pin configuration */
GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
GPIO_InitStruct.Alternate = SPIx_MOSI_AF;
HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);
/*##-3- Configure the NVIC for SPI #########################################*/
/* NVIC for SPI */
HAL_NVIC_SetPriority(SPIx_IRQn, 0, 1);
HAL_NVIC_EnableIRQ(SPIx_IRQn);
}
Sowohl Master als auch Slave haben die gleiche Konfiguration. Das Problem besteht darin, dass der Slave die Daten korrekt empfängt, der Master jedoch im letzten Bit jedes Bytes eine gewisse Betriebszeit hat. Zum Beispiel habe ich gesendet {0x01, 0x00, 0x00}und Master empfangen {0x00, 0x01, 0x00}. Es scheint mir, dass es eine ODER-Operation mit dem letzten Bit durchführt oder es einfach durch das letzte Bit aus dem letzten empfangenen Byte ersetzt.
Danke!
Möglicherweise liegt das Problem im Anwendungscode und nicht in den Initialisierungsroutinen.
Im Allgemeinen sendet das Master-Gerät einen Befehl an den Slave, der Informationen anfordert. Dann liefert der Master genügend Takte, damit der Slave mit den angeforderten Daten antwortet.
Das Problem ist, dass der Master gleichzeitig sendet und empfängt. Während die Befehlsnachricht aus dem TX-Register ausgetaktet wird, wird auch das RX-Register gefüllt. Aber der Slave sendet noch nichts, weil er noch den Befehl empfängt. Das Endergebnis ist, dass der Master nun ein Byte in seinem RX-Puffer hat, das verworfen werden muss. Dieser Wert ist im Allgemeinen {0x00} oder {0xFF}, abhängig vom Ruhezustand der MISO-Leitung.
Um das Byte im STM32 zu verwerfen, müssen Sie das Datenregister lesen. Ich gehe davon aus, dass Sie SPI_I2S_ReceiveData() oder etwas Ähnliches verwenden werden.
Nachdem der Befehl gesendet wurde (und das RX-Register gelöscht wurde), sendet der Master "Dummy-Bytes", damit er Taktimpulse für den Slave erzeugt. Dies kann generell ein beliebiger Wert sein, dies hängt jedoch vom Slave ab.
Versuchen Sie, {0x01, 0x02, 0x03} zu senden. Wenn der Master {0x00, 0x01, 0x02} empfängt, müssen Sie Ihren Treibercode ändern, um das erste Byte zu verwerfen.
Anscheinend war das Problem, dass die Masse nicht verbunden war. Schade, tut mir leid!
bitsmack