基于STM32F4的ADC128S052驱动程序(模块化接口设计)

置顶 已于 2024-01-18 14:40:51 修改
阅读量913 收藏 6
点赞数
分类专栏： MCU驱动代码 文章标签： stm32
于 2022-06-22 14:44:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17735833/article/details/124836173
版权

文章目录

基于STM32F4的ADC128S052驱动程序

STM32F446验证通过。数据采集和数据获取分开，所有通道一起采集，使用的时候直接读通道数据。

一、BspAdc128s052.h

DataType.h

#ifndef _DATA_TYPE_DEF_H_
#define _DATA_TYPE_DEF_H_

#ifdef __cplusplus
extern "C" {
#endif

#ifndef VOID
    #define VOID                void
#endif

#ifndef CHAR
    typedef signed char         CHAR;
#endif

#ifndef UCHAR
    typedef unsigned char       UCHAR;
#endif

#ifndef UINT8
    typedef unsigned char       UINT8;
#endif

#ifndef INT8U
    typedef unsigned char       INT8U;
#endif

#ifndef INT8
    typedef signed char         INT8;
#endif

#ifndef UINT16
    typedef unsigned short      UINT16;
#endif 

#ifndef INT16U
    typedef unsigned short      INT16U;
#endif

#ifndef INT16
    typedef signed short        INT16;
#endif 

#ifndef UINT32
    //typedef unsigned long     UINT32;
    typedef unsigned int        UINT32;
#endif 

#ifndef INT32U
    //typedef unsigned long     UINT32;
    typedef unsigned int        INT32U;
#endif 

#ifndef INT32
    //typedef signed long       INT32;
    typedef signed int          INT32;
#endif 

#ifndef INT
    typedef int          INT;
#endif 

#ifndef UINT
    typedef unsigned int        UINT;
#endif 

#ifndef INT64U
#if !defined(WIN32)
    typedef unsigned long long  UINT64;
#else
    typedef unsigned __int64    UINT64;
#endif
#endif

#ifndef INT64
#if !defined(WIN32)
    typedef signed long long     INT64;
#else
    typedef __int64  INT64;
#endif
#endif
 
#ifndef FLOAT32
    typedef float               FLOAT32;
#endif

#ifndef FLOAT64
    typedef double              FLOAT64;
#endif

#ifndef BOOL
    #define BOOL                int
#endif

#ifndef CM_FILE          
    #define CM_FILE             int
#endif

#ifndef NULL
   #ifdef __cplusplus
       #define NULL            (0)
   #else
       #define NULL            ((void *)0)
   #endif
#endif

#ifndef FALSE
    #define FALSE               0U
#endif

#ifndef TRUE
    #define TRUE                1U
#endif	

#ifndef WIN32
#define _PACKED  __attribute__ ((packed))
#endif

#ifndef ENA
    #define ENA             1U
#endif

#ifndef DIS
    #define DIS             0U
#endif

#ifndef CM_HDL_INVALIA          // BspOpen返回的无效值
    #define CM_HDL_INVALIA      ((INT)(-1))
#endif

#ifndef CM_EOF
    #define CM_EOF      ((INT)(-1))
#endif

#ifndef EM_COM_FD_REAL
    #define EM_COM_FD_REAL      ((FILE*)(-2))
#endif

#ifndef EM_VCOM_FD_REAL
    #define EM_VCOM_FD_REAL      ((FILE*)(-3))
#endif

#ifndef SHIFT_BIT 
    #define SHIFT_BIT(x)          ((UINT32)(1Ul<<(x)))
#endif

#ifndef ADD_ONE     //将一个变量加1
#define ADD_ONE(Type,Val)  if((Type)((Val) + 1) > 0){(Val)++;}
#endif

#ifndef DEC_ONE     //将一个变量减1
#define DEC_ONE(Type,Val)  if((Type)((Val) - 1) > 0){(Val)--;}
#endif

/* 时间类型  add by LDM 2019-12-10 
年用2 字节表示实际年份,而非2000年为基准,可以表示早于2000 年的年份*/ 
#pragma pack(1)
typedef struct {
    UINT8   u8Second;
    UINT8   u8Minute;
    UINT8   u8Hour;
    UINT8   u8Day;
    UINT8   u8Month;
    UINT16  u16Year;
} DATE_TIME;
#pragma pack()

//#define McuPrintf(...) printf(##__VA_ARGS__)

#ifndef MCUPRINTF_EX
#define McuPrintf(format,...)printf("File:"__FILE__",Line:%05d:"format"\n",__LINE__,##__VA_ARGS__)
#else
#define McuPrintf(format,...)
#endif

#ifdef _MSC_VER
#if _MSC_VER < 1900
#ifndef snprintf
#define snprintf(...) _snprintf(__VA_ARGS__)
#endif
#endif
#endif

#define IF_CMBASE
#define MUTEX_LOCK_INIT(...)
#define AP_MUTEX_UNLOCK(...)
#define AP_MUTEX_LOCK(...)
#define MUTEX_LOCK_DESTROY(...)
#define assert(...)

#ifdef __cplusplus
}
#endif

#endif

BspAdc128s052.h

#ifndef _ADC128S052_H
#define _ADC128S052_H

#include "DataType.h"
//外扩ADC128S052模块
enum
{
    EM_ADC128S052D0_ID0 = 0,
    EM_ADC128S052D0_ID_MAX,
};

enum
{
    EM_ADC128S052D0_CH_ID0 = 0,  
    EM_ADC128S052D0_CH_ID1,
    EM_ADC128S052D0_CH_ID2,
    EM_ADC128S052D0_CH_ID3,
    EM_ADC128S052D0_CH_ID4,
    EM_ADC128S052D0_CH_ID5,
    EM_ADC128S052D0_CH_ID6,
    EM_ADC128S052D0_CH_ID7,
    EM_ADC128S052D0_CH_MAX
    在这里增减使用的通道
};

typedef struct ADC128S052_READ_STRU
{
    UINT8 u8Ch;
    INT16 s16Adc;
}ADC128S052_READ;

//======================================================
/// \fn      void InitADC128S052(void)
/// \brief   ADC128S052 初始化 
/// \detils  xxx
/// \param   [in]  xxx
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
extern void InitADC128S052(void);

//======================================================
/// \fn      INT OpenAdcEx(UINT32 u32Idx)
/// \brief   打开Adc设备驱动
/// \detils  xxx
/// \param   [in]  u32Idx    设备驱动号
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
extern INT OpenAdc128S052(UINT32 u32Idx);

//======================================================
/// \fn      void CloseAdcEx(UINT32 u32Idx)
/// \brief   关闭Adc128S052设备驱动
/// \detils  xxx
/// \param   [in]  u32Idx    设备驱动号
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
extern void CloseAdc128S052(UINT32 u32Idx);

//======================================================
/// \fn      void ScanADC128S052(const UINT32 u32Idx)
/// \brief   采集ADC128S052所有通道电压
/// \detils  xxx
/// \param   [in]  u32Idx       adc设备号
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//======================================================
extern void ScanADC128S052(const UINT32 u32Idx);

//======================================================
/// \fn      INT32 ReadAdc128S052(const INT pHdl,INT16 *pBuffer,const UINT32 u32Len)
/// \brief   xxx
/// \detils  xxx
/// \param   [in]  pHdl      句柄
/// \param   [in]  pBuffer   写入的数据
/// \param   [in]  u32Len    写入的长度
/// \param   [out] xxx
/// \return  [xxx] u32Len    写入的长度
/// \note    xxx
//======================================================
extern INT32 ReadAdc128S052(const INT pHdl,INT16 *pBuffer,const UINT32 u32Len);

extern void ADC128S052_Test(void);

#endif

二、BspAdc128s052.c

#include <stdio.h>
#include <math.h>
#include <string.h>
#include "BspAdc128S052.h"
#include "stm32f4xx_spi.h"

/*    
12bit的ADC  发送16bits数据，NC为任意数，ADD2 ADD1 ADD0决定选通通道

      NC NC ADD2 ADD1  ADD0 NC NC NC   NC NC NC NC  NC NC NC NC
IN0   0  0   0    0      0  0  0  0    0  0  0  0   0  0  0  0  
IN1   0  0   0    0      1  0  0  0    0  0  0  0   0  0  0  0     
IN2   0  0   0    1      0  0  0  0    0  0  0  0   0  0  0  0     
IN3   0  0   0    1      1  0  0  0    0  0  0  0   0  0  0  0   
IN4   0  0   1    0      0  0  0  0    0  0  0  0   0  0  0  0    
IN5   0  0   1    0      1  0  0  0    0  0  0  0   0  0  0  0      
IN6   0  0   1    1      0  0  0  0    0  0  0  0   0  0  0  0
IN7   0  0   1    1      1  0  0  0    0  0  0  0   0  0  0  0 

注意：使用两个通道以上时，发送指令读取另一通道数据需要发送两次才能获取当前想要读取的另一通道的电压值，只发送一次还是上一次读到的通道的电压值。  
*/
//#define VOLTAGE_IN0   0x0000
//#define VOLTAGE_IN1   0x0800
//#define VOLTAGE_IN2   0x1000
//#define VOLTAGE_IN3   0x1800
//#define VOLTAGE_IN4   0x2000
//#define VOLTAGE_IN5   0x2800
//#define VOLTAGE_IN6   0x3000
//#define VOLTAGE_IN7   0x3800

#define ADC128S052_SPI  SPI3

#define ADC128S052_CS_DISABLE()  GPIO_SetBits(GPIOA, GPIO_Pin_15)
#define ADC128S052_CS_ENABLE()   GPIO_ResetBits(GPIOA, GPIO_Pin_15)

#define ADC128S052_VREF    3295U    //外部参考电压，实测值(MV)
#define ADC128S052_AD_MAX  4096U    //ADC128S052 最大AD值

#define ADC_HAS_NO_DATA     0      //ADC没有数据
#define ADCEX0_BATCH_NUM    10     //ADC平均个数

static INT16  s16Adcx0Buf[ADCEX0_BATCH_NUM][EM_ADC128S052D0_CH_MAX];
static UINT16 u16AdcxState[EM_ADC128S052D0_ID_MAX];//步骤

typedef struct ADC_MEM_PRIV_STRU
{
    INT16 s16Aver;// 平均值结果
    INT16 s16Max; // 最大值
    INT16 s16Min; // 最小值
}ADC_MEM_PRIV;

typedef struct ADC_X_PRIV_STRU
{
    INT16*  pAdcBuff;       // 结果
    UINT16* pState;         //指向ADC的转换状态
    UINT8 u8ChannMax;       //该ADC有多少个通道
    UINT16 u16AdcBatchNum;  //平均个数
    ADC_MEM_PRIV* pAdcVal;  //处理结果得到的数据
}ADC_EX_PRIV;

static ADC_MEM_PRIV stAdc0Val[EM_ADC128S052D0_ID_MAX];

//私有数据
const static ADC_EX_PRIV stAdcExPrivData[EM_ADC128S052D0_ID_MAX] = 
{
    {
        (INT16*)s16Adcx0Buf,
        &u16AdcxState[0],
        EM_ADC128S052D0_CH_MAX,//设置读取通道数
        ADCEX0_BATCH_NUM,      //电压数据取平均值个数
        stAdc0Val,
    },
//    {
//        (INT16*)s16AdcxBuf,
//        u16AdcxState[1],
//        EM_ADC128S052D1_ID_MAX,
//        ADCEX1_BATCH_NUM,
//        stAdc1Val,
//    }
};

//======================================================
/// \fn      static void InitADC128S052Gpio(void)
/// \brief   ADC128S052 GPIO初始化
/// \detils  xxx
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
static void InitADC128S052Gpio(void)
{
    SPI_InitTypeDef  SPI_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOC,ENABLE);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC,&GPIO_InitStructure);
    
    GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SPI3);
    GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SPI3);
    GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SPI3);
    
    //CS
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_SetBits(GPIOA, GPIO_Pin_15);    				//CS默认高
    
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3,ENABLE);
    
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; 
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; 
    SPI_InitStructure.SPI_CPOL  = SPI_CPOL_High;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;          //第二个上升沿开始转化
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; //F446 APB1 SPI3时钟为45M  spi_clock:45/256=175.78KHz
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(ADC128S052_SPI,&SPI_InitStructure);
    SPI_Cmd(ADC128S052_SPI,ENABLE);
    ADC128S052_CS_DISABLE();
}   

  //======================================================
/// \fn      static UINT16 SpiReadWriteByte(SPI_TypeDef *pSpi,const UINT16 U16Data)
/// \brief   ADC128S052 读写 
/// \detils  xxx
/// \param   [in]  pSpi         对应spi号
/// \param   [in]  U16Data      要发送的数据
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
static UINT16 SpiReadWriteByte(SPI_TypeDef *pSpi,const UINT16 U16Data)
{  
    SPI_TypeDef *pRWSpi = pSpi;
    UINT16 u16SpiData = U16Data;
    
    while (SPI_I2S_GetFlagStatus(pRWSpi, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(pRWSpi, u16SpiData);
    
    while (SPI_I2S_GetFlagStatus(pRWSpi, SPI_I2S_FLAG_RXNE) == RESET);
    return (SPI_I2S_ReceiveData(pRWSpi));
}

//======================================================
/// \fn      static INT32 GetAdc128S052(const INT pHdl,const UINT8 u8ch)
/// \brief   采集adc128S052通道电压
/// \detils  xxx
/// \param   [in]  pHdl         句柄
/// \param   [in]  u8ch         通道
/// \param   [out] xxx
/// \return  [xxx] s16AdcVal    adc值
/// \note    xxx
//======================================================
static INT16 GetAdc128S052(const INT pHdl,const UINT8 u8Ch)
{
    INT16 s16AdcVal = 0; 
    
    if(CM_HDL_INVALIA == pHdl || EM_ADC128S052D0_CH_MAX < u8Ch)
    {
        return -1;
    }
    
    ADC128S052_CS_ENABLE();
    s16AdcVal = SpiReadWriteByte(ADC128S052_SPI,u8Ch << 11);
    ADC128S052_CS_DISABLE();
    
    return s16AdcVal;
}

//======================================================
/// \fn      void InitADC128S052(void)
/// \brief   ADC128S052 初始化 
/// \detils  xxx
/// \param   [in]  xxx
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
void InitADC128S052(void)
{
    INT i = 0;
    INT j = 0;
    
    InitADC128S052Gpio();
    
    for(i = 0; i < EM_ADC128S052D0_ID_MAX; i++)
    {
        for(j = 0; j < stAdcExPrivData[i].u8ChannMax; j++)
        {
            memset(stAdcExPrivData[i].pAdcBuff,0,stAdcExPrivData[i].u8ChannMax*sizeof(stAdcExPrivData[i].pAdcBuff[0]));
        }
        *(stAdcExPrivData[i].pState) = 0;
    }
}

//======================================================
/// \fn      INT OpenAdcEx(UINT32 u32Idx)
/// \brief   打开Adc设备驱动
/// \detils  xxx
/// \param   [in]  u32Idx    设备驱动号
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
INT OpenAdc128S052(UINT32 u32Idx)
{
    INT fd = u32Idx;

    return (INT)fd;
}

//======================================================
/// \fn      void CloseAdcEx(UINT32 u32Idx)
/// \brief   关闭Adc设备驱动
/// \detils  xxx
/// \param   [in]  u32Idx    设备驱动号
/// \param   [in]  xxx
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//====================================================
void CloseAdc128S052(UINT32 u32Idx)
{
}

//======================================================
/// \fn      void ScanADC128S052(const UINT32 u32Idx)
/// \brief   采集ADC128S052所有通道电压
/// \detils  xxx
/// \param   [in]  u32Idx       adc设备号
/// \param   [out] xxx
/// \return  [xxx] xxx
/// \note    xxx
//======================================================
void ScanADC128S052(const UINT32 u32Idx)
{
    UINT16 u16ChIdx = 0;
    UINT16 u16TrunIdx = 0;
    UINT16 u16DataVol = 0;
    INT16 s16Min = 0;
    INT16 s16Max = 0;
    INT64 s64Sum = 0;
    
    const ADC_EX_PRIV* pstAdcExPrivData = NULL;

    pstAdcExPrivData = &stAdcExPrivData[u32Idx];

    if(*(pstAdcExPrivData->pState) < (pstAdcExPrivData->u16AdcBatchNum*pstAdcExPrivData->u8ChannMax + ADC_HAS_NO_DATA +1))
    {
        u16ChIdx = (*(pstAdcExPrivData->pState) - ADC_HAS_NO_DATA - 1) % (INT32)pstAdcExPrivData->u8ChannMax;  //获得第几个通道
        u16TrunIdx = (*(pstAdcExPrivData->pState) - ADC_HAS_NO_DATA - 1) / pstAdcExPrivData->u8ChannMax; //获得第几个扫描周期
        
        if(ADC_HAS_NO_DATA == *(pstAdcExPrivData->pState))
        {
            GetAdc128S052(u32Idx,0);//初始化
        }
        else
        {
            u16DataVol = GetAdc128S052(u32Idx,u16ChIdx) * ADC128S052_VREF/ADC128S052_AD_MAX;
            
            if( 1 <= u16ChIdx )
            {
                pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx -1] = u16DataVol;
            }
            else
            {
                pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + pstAdcExPrivData->u8ChannMax - 1] = u16DataVol;
            }
            u16ChIdx = (u16ChIdx + 1) % (INT32)pstAdcExPrivData->u8ChannMax;//启动下一个通道
        }
        (*(pstAdcExPrivData->pState))++;
    }
	
    if(*(pstAdcExPrivData->pState) > (pstAdcExPrivData->u16AdcBatchNum * pstAdcExPrivData->u8ChannMax + ADC_HAS_NO_DATA))
    {
        for(u16ChIdx = 0; u16ChIdx < pstAdcExPrivData->u8ChannMax; u16ChIdx++)
        {
            s64Sum = 0;
            for(u16TrunIdx = 0; u16TrunIdx < pstAdcExPrivData->u16AdcBatchNum; u16TrunIdx++)
            {
                if( 0 == u16TrunIdx )
                {
                    s16Min = s16Max = pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx];
                }     
//                printf("通道:%d,次数:%d,电压:%d\r\n",u16ChIdx,u16TrunIdx,pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx]);
                if(pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx] > s16Max)
                {
                    s16Max = pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx];
                }
                s64Sum += (pstAdcExPrivData->pAdcBuff[u16TrunIdx * pstAdcExPrivData->u8ChannMax + u16ChIdx]);
            }//end for(u16TrunIdx = 0; u16TrunIdx < pstAdcExPrivData->u16AdcBatchNum; u16TrunIdx++)
            s64Sum = s64Sum - s16Max - s16Min;
            pstAdcExPrivData->pAdcVal[u16ChIdx].s16Aver = (s64Sum/(pstAdcExPrivData->u16AdcBatchNum-2));
            pstAdcExPrivData->pAdcVal[u16ChIdx].s16Max = s16Max;
            pstAdcExPrivData->pAdcVal[u16ChIdx].s16Min = s16Min;
        }//end for(u16ChIdx = 0; u16ChIdx < pstAdcExPrivData->u8ChannMax; u16ChIdx++)
        *(pstAdcExPrivData->pState) = ADC_HAS_NO_DATA + 1;//重新开始
    }
}

//======================================================
/// \fn      INT32 ReadAdc128S052(const INT pHdl,INT16 *pBuffer,const UINT32 u32Len)
/// \brief   读Adc128S052所有通道电压数据
/// \detils  xxx
/// \param   [in]  pHdl      句柄
/// \param   [in]  pBuffer   写入的数据
/// \param   [in]  u32Len    写入的长度
/// \param   [out] xxx
/// \return  [xxx] u32Len    写入的长度
/// \note    xxx
//======================================================
INT32 ReadAdc128S052(const INT pHdl,INT16 *pBuffer,const UINT32 u32Len)
{
    ADC128S052_READ *pAdcRead = (ADC128S052_READ *)pBuffer;
    const ADC_EX_PRIV* pstAdcExPrivData = NULL;
    
    UINT32 u32Idx = (INT32)pHdl;
//    UINT32 u32BufferLen = u32Len;
    
    if( (CM_HDL_INVALIA == pHdl)||(NULL == pBuffer)||(0 == u32Len)
      ||(EM_ADC128S052D0_CH_MAX <= u32Idx)||(u32Len < sizeof(ADC128S052_READ)) )
    {
        return -1;
    }

    pstAdcExPrivData = &stAdcExPrivData[u32Idx];
    pAdcRead->s16Adc = pstAdcExPrivData->pAdcVal[pAdcRead->u8Ch].s16Aver;

    return u32Len;
}

三、应用

代码如下（示例）：
1、初始化io

InitADC128S052Gpio();

2、采集数据（这个函数可以放到单独线程里，至少10ms执行一次）

ScanADC128S052(EM_ADC128S052D0_ID0)；

3、读取数据

void ADC128S052_Test(void)
{
    ADC128S052_READ stAdcRead = {0,0};
    INT fd = OpenAdc128S052(EM_ADC128S052D0_ID0);
    
    stAdcRead.u8Ch = EM_ADC128S052D0_CH_ID0;
    ReadAdc128S052(fd,(INT16*)&stAdcRead,sizeof(ADC128S052_READ));
    printf("ADC128S052_Ch0:%dmV\r\n",stAdcRead.s16Adc);
    
    stAdcRead.u8Ch = EM_ADC128S052D0_CH_ID1;
    ReadAdc128S052(fd,(INT16*)&stAdcRead,sizeof(ADC128S052_READ));
    printf("ADC128S052_Ch1:%dmV\r\n",stAdcRead.s16Adc);
    
    stAdcRead.u8Ch = EM_ADC128S052D0_CH_ID2;
    ReadAdc128S052(fd,(INT16*)&stAdcRead,sizeof(ADC128S052_READ));
    printf("ADC128S052_Ch2:%dmV\r\n",stAdcRead.s16Adc);
    stAdcRead.u8Ch = EM_ADC128S052D0_CH_ID3;
    ReadAdc128S052(fd,(INT16*)&stAdcRead,sizeof(ADC128S052_READ));
    printf("ADC128S052_Ch3:%dmV\r\n",stAdcRead.s16Adc);
    
    stAdcRead.u8Ch = EM_ADC128S052D0_CH_ID4;
    ReadAdc128S052(fd,(INT16*)&stAdcRead,sizeof(ADC128S052_READ));
    printf("ADC128S052_Ch4:%dmV\r\n",stAdcRead.s16Adc);

    CloseAdc128S052(EM_ADC128S052D0_ID0);
}
Zzzzzzzz77777
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小梅哥Xilinx FPGA学习笔记15——基于SPI接口的ADC芯片驱动
m0_51430584的博客
12-12 3370
ADC（Analog to Digital Conver），通常是指一个将转变为数字信号（二进制表示的离散信号）的转换器。先将输入模拟电压转换成时间或频率，再把中间量转换成数字量双积分型 ADC，先对输入采样电压和基准电压进行两次积分，获得与采样电压平均值成正比的时间间隔，同时用计数器对标准时钟脉冲计数。抗干扰能力强，稳定性好，但转换速度低。①并联比较型 ADC，采用各量级同时并行比较，各位输出码也是同时并行产生，转换速度快。缺点是成本高、功耗大。
STM32F4双路ADC采集
06-05
使用ALIENTEK STM32F407开发板，实现双路ADC采集。
C语言可变参数宏__VA_ARGS__、format、printf的用法
贾saisai的博客
12-02 1675
可变参数宏 __VA_ARGS__是一个宏，表示一个或多个参数，类似函数的可变参数中的省略号；(,...)printf(,)不带##，__VA_ARGS__会替换为与省略号匹配的所有参数，同时会将省略号前面的一个逗号带上。编译器就会报错，## 可以提示编译器，把多余的逗号删除。
STM32F4 读取ADC128S022
m0_37810774的博客
08-14 2275
因为有项目需求，需要用到模拟量采集，但是又考虑到抗干扰，故采用专用ADC芯片，用ADUM1411将控制电路和采集电路隔离，并且考虑到IIC的方案采用软件模拟比较占用系统资源，因此确定方案，采用带有SPI功能的ADC128S022;采用DMA的模式自动采集8路adc信号。 硬件方案 100欧姆电阻必须要有 软件方案 读1路adc数据，只需要发送两个字节 第一个字节只需要改变第3-第5位的值，确定要采样的通道，其他都可以填0； 第二个字节直接填0就好了； 在接收的数据中只取后12位就可..
stm32F4驱动AD7793程序-ADC模拟前端-应用详解，应该是最全了
Mark_md的博客
07-09 8841
1. AD7793简介： 适合高精度测量应用的低功耗、低噪声的完整模拟前端 内置一个16/24位Σ-Δ型ADC（采样速率 4.17 ~ 470 Hz可调） 含有三路差分模拟输入，内置输入缓冲器 片内集成低噪声可编程仪表放大器（PGA，Gain = 1、2、4、8、16、32、64、128可调） 内置低噪声、低漂移带隙基准电压源 内置可编程激励电流源、熔断电流源、偏置电压发生器（激励电流 10uA、210uA、1mA可调） 四线串行SPI通信接口 2. AD7793应用领域： 热电偶温.
基于STM32F103+ADS1292的心率实时显示（串口助手），心电图波形
10-12
基于STM32F103+ADS1292的心率实时显示（串口助手），心电图波形（需要用到匿名上位机），采样频率为500hz，可实时显示心率。源代码有大量注解，通俗易懂.
STM32F4_2ADC_stm32f4ADC_stm32ADC2_stm32f4_stm32f4ADC_
10-01
标题"STM32F4_2ADC_stm32f4ADC_stm32ADC2_stm32f4_stm32f4ADC_"暗示了我们正在讨论如何利用STM32F4微控制器上的两个独立工作的ADC。在STM32F4系列中，通常有多个ADC通道，每个ADC可以独立配置和操作，这使得它们可以...
adc_STM32f4各种ADC模式_
10-01
总之，STM32F4的ADC功能强大且灵活，通过掌握双重采集、三重采集和交错采集等模式，开发者可以设计出高效、准确的嵌入式系统解决方案。在编写`adc.c`和`adc.h`时，要充分考虑实际应用需求，合理配置和优化ADC的工作...
stm32f4语音模块_stm32f407驱动语音识别模块_
10-01
STM32F4系列是意法半导体（STMicroelectronics）推出的一款高性能、低功耗的32位微控制器，广泛应用于各种嵌入式系统设计，包括语音识别模块的驱动。在本文中，我们将深入探讨如何使用STM32F407来驱动语音识别模块，...
ADC.rar_STM32F4 ADC_STM32F4-ADC_STM32F4采样_ad采样_stm32 sai接口ADC
09-23
在给定的“ADC.rar”压缩包中，包含了关于STM32F4 ADC（模数转换器）的详细资料，特别是关于单路ADC采样和STM32F4的SAI接口ADC的应用。 **STM32F4 ADC介绍** STM32F4的ADC（Analog-to-Digital Converter）模块是一...
STM32-ADC.rar_32ADC. com_STM32F4 ADC_stm32 adc_stm32f4
09-20
STM32F4系列是意法半导体（STMicroelectronics）推出的一款高性能ARM Cortex-M4内核微控制器，其中的ADC（Analog-to-Digital Converter，模数转换器）功能是其重要的组成部分，常用于处理模拟信号，将其转化为数字...
#, ##, args...以及__VAR_ARGS__宏定义解析
木牛的博客
07-19 8770
在 linux kernel中，经常会看见类似的宏定义 点击(此处)折叠或打开 #define printf(format, args...) \      printk(KERN_ERR "BFS-fs: %s(): " format, __FUNCTION__, ## args) 更有甚者，在 man printf时候，都会有类似 点击(此处)折叠或打开 int printf(co...
STM32F4的SPI
wsqgoforit的博客
11-28 2148
STM32F4的SPI
STM32F4_SPI协议详解
light_2025的博客
06-02 3135
而SPI协议中没有设备地址，它是用SS信号线来寻址，当主机选中从设备时，就将所选的从设备的信号线置为低电平0，即意味着该设备被选中，即片选有效，接着主机开始与被选中的从设备进行SPI通讯。W25Q128的擦写周期多达10W次，具有20年的数据保存期限，支持电压为2.7~3.6V，W25Q128支持标准的SPI，最大的SPI时钟可以到80MHz。：这两个模式的最大区别就是如果设置为主机模式，那么时钟SCK的时序是由通讯的主机产生的，如果设置为从机模式，那么SCK时钟的时序是由外来的SCK信号提供的。
基于s3c2410和嵌入式linux的adc驱动程序实现与应用,基于s3c2410和嵌入式Linux的D/A转换的实现...
weixin_26757925的博客
05-03 111
基于s3c2410和嵌入式Linux的D/A转换的实现A/D转换和D/A转换是控制系统的基本组成部分。本文首先介绍了s3c2410如何外接MAX504扩展D/A转换(本文共3页)阅读全文>>为了对生产车间内的多台数控机床进行整体化、网络化管理,设计了一个基于嵌入式Linux的数控机床远程监控管理系统;该系统利用linux操作系统和s...(本文共3页)阅读全文>>根文件系统...
AD7356_SPI驱动程序设计_5MSPS_Verilog
学无止境
04-24 726
AD7356驱动程序，使用Verilog语言编写。
ADC驱动实例（简单）
huang879135的专栏
07-12 6362
ADC驱动（仅一路输入） /********s3c2410-adc.h********/#ifndef _S3C2410_ADC_H_#define _S3C2410_ADC_H_#define ADC_WRITE(ch, prescale) ((ch)#define ADC_W
ADC芯片3421驱动程序
zd845101500的博客
04-25 1732
#ifndef MCP3421_H #define MCP3421_H #include "common.h" typedef enum mcp_div { mcp_div_12 = 0, mcp_div_14, mcp_div_16, mcp_div_18, }mcp_div_e; typedef enum mcp_amp { mcp_amp_x1 = 0, mcp_amp_2, mcp_amp_4, mcp_amp_8, }mcp_am.
项目进展（八）-编写代码，驱动ADS1285
最新发布
我的博客
10-05 1226
根据芯片的数据手册编写部分驱动，首先看部分引脚的波形：DRDY:CS：以上代码都是根据数据手册写的，可以参考下图：或者参考上一篇博客""中2.3节。
怎么实现stm32f4 adc加dma连续采样
07-10
要实现STM32F4 ADC加DMA连续采样，你可以按照以下步骤进行操作： 1. 配置ADC模块： - 初始化ADC外设，包括时钟使能和引脚配置。 - 配置ADC的采样时间、分辨率等参数。 - 配置ADC的转换模式为连续转换模式。 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值