SPI1 в STM32F429 считывает 0 в младший бит Опции

[Tarbal]

Если не давать сброс на периферийное устройство (slave), подключенное к SPI, то у него на выходе MISO стоит твердая единица. Однако если считывать в процессор, то вместо 0xFF читается 0xFE.

Происходит ошибочное чтение нестабильно. Иногда читается правильно. Однако если к выходу SPI CLK присоединить щуп осциллографа, то правильного чтения больше не происходит. Стабильно читается 0xFE.

Я нашел в форуме ST, что такое происходит если читать данные не дожидаясь установки RXNE в единицу. Однако в моем коде я жду установки RXNE в единицу.

[ViKo]

Ага, нашел, jumper. Он еще и точность имеет, и мощность рассеивания.

Вы можете называть как вам угодно, но их принято называть резисторами.

Я буду называть перемычками, как принято.

[Tarbal]

Ага, нашел, jumper. Он еще и точность имеет, и мощность рассеивания.


Я буду называть перемычками, как принято.

У меня есть STM32F429I-Disco. Если выложите код, похожий на нерабочий, могу посмотреть. Но с нуля писать лень. Вдруг не не заработает.

Вот такой код. Только теперь вместо нуля всегда читает единицу и только в первом интерфейсе.

CODE

HAL_StatusTypeDef SPI_WaitOnFlagTimeout(SPI_HandleTypeDef *hspi, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
{
uint32_t start = jiffies;
while(__HAL_SPI_GET_FLAG(hspi, Flag) == Status){
if(jiffies - start >= Timeout){
return -HAL_TIMEOUT;
}
}
return HAL_OK;
}
#if 0
/* This funtion is used to transmit and receive data
* with SPI1
* data --> data to be transmitted
* returns received value
*/
uint8_t SPI1_send(uint8_t data){

SPI1->DR = data; // write data to be transmitted to the SPI data register
while( !(SPI1->SR & SPI_I2S_FLAG_TXE) ); // wait until transmit complete
while( !(SPI1->SR & SPI_I2S_FLAG_RXNE) ); // wait until receive complete
while( SPI1->SR & SPI_I2S_FLAG_BSY ); // wait until SPI is not busy anymore
return SPI1->DR; // return received data from SPI data register
}
#endif

int SPI_Transmit1(SPI_HandleTypeDef *hspi, uint8_t* val, uint32_t timeout)
{
FlagStatus Status;
__HAL_SPI_ENABLE(hspi);
hspi->Instance->DR = *val;
Status = SPI_WaitOnFlagTimeout(hspi, SPI_FLAG_TXE, RESET, timeout);
if(HAL_OK != Status){
return Status;
}
Status = SPI_WaitOnFlagTimeout(hspi, SPI_FLAG_RXNE, RESET, timeout);
if(HAL_OK != Status){
return Status;
}
Status = SPI_WaitOnFlagTimeout(hspi, SPI_FLAG_BSY, SET, timeout);
*val = hspi->Instance->DR;
return Status;
}

int write_spi_reg(uint8_t chip_id, uint8_t reg_addr, uint8_t val)
{
SPI_HandleTypeDef* hspi;
uint8_t buf[SPI_WRITE_LEN];
uint8_t i;
uint8_t id;
GPIO_TypeDef* port;
uint16_t pin;

HAL_StatusTypeDef ret;


if(CHIPS_AMOUNT <= chip_id){
return -WRONG_PARAMETER;
}

hspi = hspi1;
id = 0
port = GPIOA;
pin = GPIO_PIN_4;


buf[0] = WR_SPI_CMD(id);
buf[1] = reg_addr;
buf[2] = val;

for(i = 0; i < SPI_WRITE_LEN; i++){
HAL_GPIO_WritePin(port, pin, 0);
short_delay(7);
ret = SPI_Transmit1(hspi, &buf[i], SPI_TIMEOUT);
HAL_GPIO_WritePin(port, pin, 1);
short_delay(7);

if(HAL_OK != ret){
responce_handle(ret);
return -ret;
}
}
return NO_ERROR;
}

int read_spi_reg(uint8_t chip_id, uint8_t reg_addr)
{
SPI_HandleTypeDef* hspi;
uint8_t buf[2];
uint8_t id;
HAL_StatusTypeDef ret;
GPIO_TypeDef* port;
uint16_t pin;
chip_interface_t* chip_if;



if(CHIPS_AMOUNT <= chip_id){
return;
}
hspi = hspi1;
id = 0
port = GPIOA;
pin = GPIO_PIN_4;

buf[0] = RD_SPI_CMD(id);
buf[1] = reg_addr;

HAL_GPIO_WritePin(port, pin, 0);
short_delay(7);
ret = SPI_Transmit1(hspi, &buf[0], SPI_TIMEOUT);

HAL_GPIO_WritePin(port, pin, 1);
short_delay(7);

HAL_GPIO_WritePin(port, pin, 0);
short_delay(7);
ret = SPI_Transmit1(hspi, &buf[1], SPI_TIMEOUT);
HAL_GPIO_WritePin(port, pin, 1);
short_delay(7);

if(HAL_OK != ret){
responce_handle(ret);
return (uint16_t) -1;
}

HAL_GPIO_WritePin(port, pin, 0);
short_delay(7);
ret = SPI_Transmit1(hspi, &buf[0], SPI_TIMEOUT);
HAL_GPIO_WritePin(port, pin, 1);
short_delay(7);

if(HAL_OK != ret){
responce_handle(ret);
}

return (uint32_t)buf[0];
}

Конфигурация:
Registers
SPI_CR1 = 0x0000015F
SPI_CR2 = 0x00000004