ADS1299读取数据出错。求解

MCU:STM32F103

ADC:ADS1299

SPI设置：CPOL=0&CPHA=1,速度为18MHz

设置RDATAC模式，/DRDY用逻辑分析仪看正确。

读写寄存器正确。用/DRDY下降沿触发中断，在中断程序内读取24+8*24Byte（1个状态+8个通道）

但是读出来的数据，只有第一个24位状态为0xC00000,后8个24位都是0xFFFFFF

下面是连续读取9个24bit数据的程序部分。

for(channel_num=0;channel_num<9;channel_num++)
{
sum[channel_num] |= (SPI1_ReadWriteByte(0xff)<<16);
sum[channel_num] |= (SPI1_ReadWriteByte(0xff)<<8);
sum[channel_num] |= SPI1_ReadWriteByte(0xff);
}

/**/SPI速度分别试过18MHz、9MHz、4.5MHz、2.25Mhz。情况还是如上述红色字体结果。

请问是什么情况！

看来不是时钟频率的问题, 是不是 CS 信号的问题? 我觉得可能性比较大

不关/CS问题，用逻辑分析仪看过了。一直处于低电平

你好，你的情况解决了吗？我也让遇到同样的问题，方便加qq交流交流吗？   974002504

当时好像是SPI时钟问题，太久了我也记不清了。你用的也是STM32？

是的，我用的STM32去操作ADS1299,遇到的问题和你的一样，你是怎么解决的？能帮我看看吗？

你的cpol和cpha是怎么设置的，我也用的是stm32系列ARM

static 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_LOW;
hspi2.Init.CLKPhase = SPI_PHASE_2EDGE;
hspi2.Init.NSS = SPI_NSS_SOFT;
hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi2.Init.CRCPolynomial = 10;
if (HAL_SPI_Init(&hspi2) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}

}

这是我的spi口设置文件，对应的CPOL=0，CPHA=0，不知道这样对不对，反正现在能够写入读取数据。

我的spi配置和你的一样啊，就是hspi2.Init.CRCPolynomial和你的不一样，我配置的是10，其他的都一样，为什么我的读写寄存器出问题？你能发一下你的读写寄存器的函数吗？十分感谢！

我hspi2.Init.CRCPolynomial = 7

读写函数不都是用的stm32CuberMX自动生成的文件里面带的吗？ 我的函数如下。  建议调spi一定要用示波器，最好是四通道的，挂上去什么CS SCLK SDI 一起看波形。

HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)
{
uint32_t tickstart = 0U;
HAL_StatusTypeDef errorcode = HAL_OK;

/* Check Direction parameter */
assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));

/* Process Locked */
__HAL_LOCK(hspi);

/* Init tickstart for timeout management*/
tickstart = HAL_GetTick();

if(hspi->State != HAL_SPI_STATE_READY)
{
errorcode = HAL_BUSY;
goto error;
}

if((pData == NULL ) || (Size == 0))
{
errorcode = HAL_ERROR;
goto error;
}

/* Set the transaction information */
hspi->State = HAL_SPI_STATE_BUSY_TX;
hspi->ErrorCode = HAL_SPI_ERROR_NONE;
hspi->pTxBuffPtr = (uint8_t *)pData;
hspi->TxXferSize = Size;
hspi->TxXferCount = Size;

/*Init field not used in handle to zero */
hspi->pRxBuffPtr = (uint8_t *)NULL;
hspi->RxXferSize = 0U;
hspi->RxXferCount = 0U;
hspi->TxISR = NULL;
hspi->RxISR = NULL;

/* Configure communication direction : 1Line */
if(hspi->Init.Direction == SPI_DIRECTION_1LINE)
{
SPI_1LINE_TX(hspi);
}

#if (USE_SPI_CRC != 0U)
/* Reset CRC Calculation */
if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
{
SPI_RESET_CRC(hspi);
}
#endif /* USE_SPI_CRC */

/* Check if the SPI is already enabled */
if((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
{
/* Enable SPI peripheral */
__HAL_SPI_ENABLE(hspi);
}

/* Transmit data in 16 Bit mode */
if(hspi->Init.DataSize == SPI_DATASIZE_16BIT)
{
if((hspi->Init.Mode == SPI_MODE_SLAVE) || (hspi->TxXferCount == 0x01))
{
hspi->Instance->DR = *((uint16_t *)pData);
pData += sizeof(uint16_t);
hspi->TxXferCount--;
}
/* Transmit data in 16 Bit mode */
while (hspi->TxXferCount > 0U)
{
/* Wait until TXE flag is set to send data */
if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE))
{
hspi->Instance->DR = *((uint16_t *)pData);
pData += sizeof(uint16_t);
hspi->TxXferCount--;
}
else
{
/* Timeout management */
if((Timeout == 0U) || ((Timeout != HAL_MAX_DELAY) && ((HAL_GetTick()-tickstart) >= Timeout)))
{
errorcode = HAL_TIMEOUT;
goto error;
}
}
}
}
/* Transmit data in 8 Bit mode */
else
{
if((hspi->Init.Mode == SPI_MODE_SLAVE)|| (hspi->TxXferCount == 0x01))
{
*((__IO uint8_t*)&hspi->Instance->DR) = (*pData);
pData += sizeof(uint8_t);
hspi->TxXferCount--;
}
while (hspi->TxXferCount > 0U)
{
/* Wait until TXE flag is set to send data */
if(__HAL_SPI_GET_FLAG(hspi, SPI_FLAG_TXE))
{
*((__IO uint8_t*)&hspi->Instance->DR) = (*pData);
pData += sizeof(uint8_t);
hspi->TxXferCount--;
}
else
{
/* Timeout management */
if((Timeout == 0U) || ((Timeout != HAL_MAX_DELAY) && ((HAL_GetTick()-tickstart) >= Timeout)))
{
errorcode = HAL_TIMEOUT;
goto error;
}
}
}
}

/* Wait until TXE flag */
if(SPI_WaitFlagStateUntilTimeout(hspi, SPI_FLAG_TXE, SET, Timeout, tickstart) != HAL_OK)
{
errorcode = HAL_TIMEOUT;
goto error;
}

/* Check Busy flag */
if(SPI_CheckFlag_BSY(hspi, Timeout, tickstart) != HAL_OK)
{
errorcode = HAL_ERROR;
hspi->ErrorCode = HAL_SPI_ERROR_FLAG;
goto error;
}

/* Clear overrun flag in 2 Lines communication mode because received is not read */
if(hspi->Init.Direction == SPI_DIRECTION_2LINES)
{
__HAL_SPI_CLEAR_OVRFLAG(hspi);
}
#if (USE_SPI_CRC != 0U)
/* Enable CRC Transmission */
if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
{
SET_BIT(hspi->Instance->CR1, SPI_CR1_CRCNEXT);
}
#endif /* USE_SPI_CRC */

if(hspi->ErrorCode != HAL_SPI_ERROR_NONE)
{
errorcode = HAL_ERROR;
}

error:
hspi->State = HAL_SPI_STATE_READY;
/* Process Unlocked */
__HAL_UNLOCK(hspi);
return errorcode;
}

/**
* @brief Receive an amount of data in blocking mode.
* @param hspi: pointer to a SPI_HandleTypeDef structure that contains
* the configuration information for SPI module.
* @param pData: pointer to data buffer
* @param Size: amount of data to be received
* @param Timeout: Timeout duration
* @retval HAL status
*/

非常感谢！

兄弟，你的问题解决了么，我现在也读不出来了，一起交流交流啊

可以交流交流，，，QQ：974002504