AD7606 与STM32MINI板SPI通信采集数据，昨天采样两线全双工，读出数据为0000，现在改为一线只读，读出数据与实际接入电压不对...

WWWW

采集到数据一直在跳变，换算后与接入电压值也不对应，调了两天也没搞好，请大家看看，帮帮忙
*********************************************************以下是程序代码，希望各位帮忙指正
#include "spi.h"
#include "sys.h"

//PA4、PA5、PA6分别接AD7606CS、SCK/RD,DB7
#define SCK_0()                GPIOA->BRR = GPIO_Pin_5
#define SCK_1()                GPIOA->BSRR = GPIO_Pin_5

void _SPI__Init()
{
        GPIO_InitTypeDef  GPIO_InitStructure;
        SPI_InitTypeDef   SPI_InitStruct;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA| RCC_APB2Periph_GPIOB|RCC_APB2Periph_SPI1 , ENABLE);

        
  //配置SPI1 : SCK, MISO and MOSI */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;//SCK配置
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//MISO配置
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  
  //配置片选 IO PA4
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;//ƬѡÅäÖÃ
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
        PAout(4)=1;
  PAout(5)=0;
        
                //配置CONVST GPIO */
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
        GPIO_Init(GPIOA, &GPIO_InitStructure);
        PAout(8)=1;
        //配置RANGE  
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
        GPIO_Init(GPIOB, &GPIO_InitStructure);
        PBout(5)=1;
        //配置REST
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
        GPIO_Init(GPIOB, &GPIO_InitStructure);
        PBout(7)=1;
                //busy
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//PB6_BUSY 配置
        GPIO_Init(GPIOB, &GPIO_InitStructure);
        
  SPI_InitStruct.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_64;
        SPI_InitStruct.SPI_CPHA=SPI_CPHA_2Edge;//第二个上升沿采集
        SPI_InitStruct.SPI_CPOL=SPI_CPOL_High;
        SPI_InitStruct.SPI_CRCPolynomial=7;
        SPI_InitStruct.SPI_DataSize=SPI_DataSize_8b;//8λ
        SPI_InitStruct.SPI_Direction=SPI_Direction_1Line_Rx;//只读
        SPI_InitStruct.SPI_FirstBit=SPI_FirstBit_MSB;//¸高位在前
        SPI_InitStruct.SPI_Mode=SPI_Mode_Master;
        SPI_InitStruct.SPI_NSS=SPI_NSS_Soft;
        SPI_Init(SPI1,&SPI_InitStruct);
        
        SPI_Cmd(SPI1, ENABLE);
        ad7606_SetOS(0);//设置是否过采样
  ad7606_SetInputRange(0);//设置范围
  ad7606_Reset();//硬件复位
  AD_CONVST_HIGH();
        ad7606_StartConv();//开始转换
}




//设置电压范围0代表正负5V 1代表正负10v
void ad7606_SetInputRange(u8  _ucRange)
{
        if (_ucRange == 0)
        {
                PBout(5) = 0;
        }
        else
        {
                PBout(5) = 1;
        }
}

//硬件复位函数
void ad7606_Reset(void)
{

        int i;
        AD_CS_HIGH();
        PBout(7)=0;
        PBout(7)=1;
        for(i=0;i<50;i++) ;
        PBout(7)=0;
}
//开始转换函数
void ad7606_StartConv(void)
{

        AD_CONVST_HIGH();
        AD_CONVST_HIGH();
        AD_CONVST_LOW();
        AD_CONVST_LOW();        /* μíμ&#231;&#198;&#189;50ns */
        AD_CONVST_LOW();
        AD_CONVST_LOW();
//        delay_ms(5);
        AD_CONVST_HIGH();
}

//设置是否过采样函数

void ad7606_SetOS(u8 _ucMode)
{
        if (_ucMode == 1)
        {
                AD_OS2_0();
                AD_OS1_0();
                AD_OS0_1();
        }
        else if (_ucMode == 2)
        {
                AD_OS2_0();
                AD_OS1_1();
                AD_OS0_0();
        }
        else if (_ucMode == 3)
        {
                AD_OS2_0();
                AD_OS1_1();
                AD_OS0_1();
        }
        else if (_ucMode == 4)
        {
                AD_OS2_1();
                AD_OS1_0();
                AD_OS0_0();
        }
        else if (_ucMode == 5)
        {
                AD_OS2_1();
                AD_OS1_0();
                AD_OS0_1();
        }
        else if (_ucMode == 6)
        {
                AD_OS2_1();
                AD_OS1_1();
                AD_OS0_0();
        }
        else        
        {
                AD_OS2_0();
                AD_OS1_0();
                AD_OS0_0();
        }
}
//延时函数
void bsp_spiDelay(void)
{
        u8 i;

        for (i = 0; i<2; i++);
}


//读取8位数据
u8  bsp_spiRead(void)
{

        u8 read=0;
        u8 i;
        for (i = 0; i < 8; i++)
        {  
    SCK_0();//拉低时钟延时
                bsp_spiDelay();
                read<<=1;        
                if(PAin(6)==1)
    {
                  read++;         
                }
    SCK_1();//拉高时钟
                bsp_spiDelay();
        }

        return read;

}
#include "stm32f10x.h"
#include "delay.h"
#include "usart.h"
#include "spi.h"
#include "led.h"
#include "string.h"
//#include "TIMER.h"
u16 ADC_value1[8];//′&#230;·&#197;8í¨μàêy&#214;μ
float pp[2];
char string[20];
int main(void)
{        
   u8 i;
         SystemInit();
         LED_Init();
          _SPI__Init();
        // _TIMER_Init_(4999,7199);
   delay_init();
         uart_init(115200);
         
         while(1)
         {
                 if(PBin(6)==0)//PB6接busy引脚，判断busy是否为零
                {
       PAout(5)=1;//拉高时钟线
                   AD_CS_LOW();//拉低片选
       for(i=0;i<1;i++)
            {        
              ADC_value1=bsp_spiRead();
                                ADC_value1=ADC_value1*256+bsp_spiRead();
                          pp=(float) ADC_value1/32767*5;
                    printf("%f\r\n",pp);        
            }

      AD_CS_HIGH();//拉高片选
            ad7606_StartConv();//开始转换
                }
                delay_ms(500);
         }
}
[/mw_shl_code]

*********************************************************以上是程序代码，希望各位帮忙指正

jack he

今天测试成功，把读取函数里加上spi开断代码，以前读出来数字无规律是因为spi初始化后就一直发出时钟，这样就不断地从ad7606读数据1


u16 SPI_ReadTwoByte(void)
{               
        u8 retry=0;       
        SPI_Cmd(SPI2, ENABLE);       
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
                {
                        retry++;
                        if(retry>200)return 0;
                }
        SPI_Cmd(SPI2, DISABLE);               
        return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据       

正点原子

帮顶

Rocks

看不懂你的讀取是在讀什麼

你到底是用模擬的SPI
還是用原生的SPI

WWWW

Rocks 发表于 2016-3-4 17:45
看不懂你的讀取是在讀什麼

你到底是用模擬的SPI

用模拟的SPI，读取的但是数据不正确

xuande

必须示波器看波形。

jack he

楼主解决了吗，最近我也在做这个。我调试时spi读出来的数据总是毫无规律的，跟被测电压无关

jack he

#include "ad7606_spi.h"
#include "LED.h"
#include "BEEP.h"
/*
PB12: 片选       输出        低电平有效
PB13: 时钟       输出
PB14: MISO       输入

PC1: 复位       输出        高电平有效
PC2: BUSY        输入
PC4: CVA/CVB     输出        低电平有效
PC5: FRST        输入
*/

/*spi配置函数*/
void ad7606_spi_init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;
//时钟
        RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
        RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能        
//管脚配置
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13复用推挽输出 spi2 时钟
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_13);
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;  //PB14上拉输入 spi2 miso
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

//初始化
        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_RxOnly;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;                //设置SPI的数据大小:SPI发送接收8位帧结构
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;                //定义波特率预分频的值:波特率预分频值为256
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
        SPI_InitStructure.SPI_CRCPolynomial = 15;        //CRC值计算的多项式
        SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
//关闭或开启
        SPI_Cmd(SPI2, DISABLE); //失能SPI外设
        SPI_Cmd(SPI2, ENABLE); //使能SPI外设         
}

/*控制管脚配置函数*/
void ad7606_GPIO_init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
       
        RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB, ENABLE );
        //输出
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PC4\开始转换电平     PC4: CVA/CVB
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
        GPIO_SetBits(GPIOC,GPIO_Pin_4);
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PC1\reset复位
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
        GPIO_ResetBits(GPIOC,GPIO_Pin_1);
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PB12\CS片选
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_12);
        //输入
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //PC5、frst
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
       
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //PC2\busy
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
}
/*
设置传输速度函数
//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2   2分频   
//SPI_BaudRatePrescaler_8   8分频   
//SPI_BaudRatePrescaler_16  16分频  
//SPI_BaudRatePrescaler_256 256分频
*/
void SPI_SetSpeed(u8 SPI_BaudRatePrescaler)
{
  assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
        SPI2->CR1&=0XFFC7;
        SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
        SPI_Cmd(SPI2,ENABLE);
}

/*读传输内容函数*/
u16 SPI_ReadTwoByte(void)
{               
        u8 retry=0;                                        
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
                {
                        retry++;
                        if(retry>200)return 0;
                }                                                              
        return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
}
/*BUSY中断初始化*/
void ad7606_exti_init(void)
{
        EXTI_InitTypeDef EXTI_Structre;
        NVIC_InitTypeDef NVIC_Structre;
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
       
        GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource2);
        EXTI_Structre.EXTI_Line=EXTI_Line2;
        EXTI_Structre.EXTI_LineCmd=ENABLE;
        EXTI_Structre.EXTI_Mode=EXTI_Mode_Interrupt;
        EXTI_Structre.EXTI_Trigger=EXTI_Trigger_Falling;
        EXTI_Init(&EXTI_Structre);
       
        NVIC_Structre.NVIC_IRQChannel=EXTI2_IRQn;
        NVIC_Structre.NVIC_IRQChannelCmd=ENABLE;
        NVIC_Structre.NVIC_IRQChannelPreemptionPriority=2;
        NVIC_Structre.NVIC_IRQChannelSubPriority=2;
        NVIC_Init(&NVIC_Structre);
}
/*中断2服务函数*/
extern u16 RESULT[24];
void EXTI2_IRQHandler(void)
{
        u8 i=0;
        delay_ms(10);
        if(EXTI_GetITStatus(EXTI_Line2)==1)
        {
                AD_CS_0();
                for (i = 0; i <24; i++)
                {
                       
                        RESULT[i]=SPI_ReadTwoByte();
//                        RESULT[i]=RESULT[i]*256+RESULT[i];
                        //RESULT[i]&=0x7fff;
                       
                }
                AD_CS_1();
                        ad7606_Reset();
                        led1=!led1;
                        delay_ms(500);
//                if(SPI_I2S_GetITStatus(SPI2,SPI_IT_CRCERR)==1)
//                {
//                        beep=1;
//                        delay_ms(500);
//                        beep=0;
//                }
               
        }
        EXTI_ClearITPendingBit(EXTI_Line2);
}
/*ad7606复位函数*/
void ad7606_Reset(void)
{
        AD_RESET_LOW();
       
        AD_RESET_HIGH();
        AD_RESET_HIGH();
        AD_RESET_HIGH();
        AD_RESET_HIGH();
       
        AD_RESET_LOW();
}
void ad7606_cv(void)
{
        AD_CONVST_HIGH();
        AD_CONVST_LOW();
        AD_CONVST_LOW();
        AD_CONVST_LOW();        /* 连续执行2次，低电平约50ns */
       
        AD_CONVST_HIGH();
}
/*总初始化函数*/
void ad7606_init(void)
{
        ad7606_spi_init();
        ad7606_GPIO_init();
        ad7606_exti_init();
        ad7606_Reset();
}
/*某个通道数据函数*/
u16 AD7606_ReadAdc(u8 _ch)
{
        u16 sAdc;       
        sAdc = RESULT[_ch];
        return sAdc;
}

jack he

#include "stm32f10x.h"
#include "sys.h"
#include "LED.h"
#include "LCD.h"
#include "delay.h"
#include "usart.h"       
#include "exit.h"
#include "time_pwm.h"
#include "driver.h"
#include "ad7606_spi.h"
#include "key.h"
#include "BEEP.h"

u16 RESULT[24]={0,0,0,0,0,0,0,0,0,0,0,0};

/************************************************
ALIENTEK 战舰STM32F103开发板实验
说明：ADC定时器2通道2触发（LCD必须在串口后初始化，利用的是pwm初始化函数（ADC_ExternalTrigConv_T2_CC2），key_up键按下后或pa0连入3.3伏测出电压对应数字量）
作者：JackSparrow
时间：2016/2/4
已测试
************************************************/
       
int main(void)
{
       
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
        uart_init(115200);
        LED_Init();
        beep_Init();
        delay_init();
        KEY_Init();
        ad7606_init();
//        led0=0;//灭
//        delay_ms(200);
//        led0=1;//灭
        beep=1;
        delay_ms(500);
        beep=0;
        delay_ms(200);
        LCD_Init();       
        POINT_COLOR=RED;          
        while(1)
        {
                if(KEY_Scan(0)==KEY0_PRES)
                {
                        //ad7606_Reset();
                        ad7606_cv();
                        led0=!led0;
                        delay_ms(200);
                        LCD_ShowNum(30,70,RESULT[0],5,24);
                        LCD_ShowNum(30,95,RESULT[1],5,24);
                        LCD_ShowNum(30,120,RESULT[2],5,24);
                        LCD_ShowNum(30,145,RESULT[3],5,24);
                        LCD_ShowNum(30,170,RESULT[4],5,24);
                        LCD_ShowNum(30,195,RESULT[5],5,24);
                        LCD_ShowNum(30,220,RESULT[6],5,24);
                        LCD_ShowNum(30,245,RESULT[7],5,24);
                        LCD_ShowNum(30,270,RESULT[8],5,24);
                        LCD_ShowNum(30,295,RESULT[9],5,24);
                        LCD_ShowNum(30,10,RESULT[10],5,24);
                        LCD_ShowNum(30,35,RESULT[11],5,24);
                       
                        LCD_ShowNum(100,70,RESULT[12],5,24);
                        LCD_ShowNum(100,95,RESULT[13],5,24);
                        LCD_ShowNum(100,120,RESULT[14],5,24);
                        LCD_ShowNum(100,145,RESULT[15],5,24);
                        LCD_ShowNum(100,170,RESULT[16],5,24);
                        LCD_ShowNum(100,195,RESULT[17],5,24);
                        LCD_ShowNum(100,220,RESULT[18],5,24);
                        LCD_ShowNum(100,245,RESULT[19],5,24);
                        LCD_ShowNum(100,270,RESULT[20],5,24);
                        LCD_ShowNum(100,295,RESULT[21],5,24);
                        LCD_ShowNum(100,10,RESULT[22],5,24);
                        LCD_ShowNum(100,35,RESULT[23],5,24);
                }
               
        }
}

cs1222

回头我给你找下程序 我之前也用过，还有就是你注意下AD7606的CONVSTA/B是否都激活。不论你读取几个通道的数据，CONVSTA/B都要激活，而且他们之间的时间间隔也有要求。你可以先看看安富莱的例程

sunboyYB

用SPI资源吧CS脚释放应该也可以吧

dazalei

采样数据不对

dazalei

jack he 发表于 2016-9-23 21:49
楼主解决了吗，最近我也在做这个。我调试时spi读出来的数据总是毫无规律的，跟被测电压无关

也是这样

jack he

dazalei 发表于 2016-10-13 11:46
也是这样

我把源码发给你
#include "ad7606_spi.h"
#include "LED.h"
#include "LCD.h"
/*
PB12: 片选       输出        低电平有效
PB13: 时钟       输出
PB14: MISO       输入  本例未使用
PB15：MOSI        输出（在单线模式下输入）本例使用

PC1: 复位       输出        高电平有效
PC2: BUSY        输入
PC4: CVA/CVB     输出        低电平有效
PC5: FRST        输入
*/

/*spi配置函数*/
void ad7606_spi_init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;
//时钟
        RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能
        RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能         
//管脚配置
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13复用推挽输出 spi2 时钟
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_13);
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB15复用推挽输出 spi2 MOSI
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_15);
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;  //PB14上拉输入 spi2 miso
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

//初始化
        SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;                //设置SPI的数据大小:SPI发送接收8位帧结构
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;                //定义波特率预分频的值:波特率预分频值为256
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
        SPI_InitStructure.SPI_CRCPolynomial = 15;        //CRC值计算的多项式
        SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
//关闭或开启
        SPI_Cmd(SPI2, DISABLE); //失能SPI外设
//        SPI_Cmd(SPI2, ENABLE); //使能SPI外设         
}

/*控制管脚配置函数*/
void ad7606_GPIO_init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        
        RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB, ENABLE );
        //输出
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PC4\开始转换电平     PC4: CVA/CVB
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
        GPIO_SetBits(GPIOC,GPIO_Pin_4);
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PC1\reset复位
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
        GPIO_ResetBits(GPIOC,GPIO_Pin_1);
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //PB12\CS片选
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_12);
        //输入
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //PC5、frst
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
        
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //PC2\busy
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC
}
/*
设置传输速度函数
//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2   2分频   
//SPI_BaudRatePrescaler_8   8分频   
//SPI_BaudRatePrescaler_16  16分频  
//SPI_BaudRatePrescaler_256 256分频
*/
void SPI_SetSpeed(u8 SPI_BaudRatePrescaler)
{
  assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
        SPI2->CR1&=0XFFC7;
        SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
        SPI_Cmd(SPI2,ENABLE);
}

/*读传输内容函数*/
u16 SPI_ReadTwoByte(void)
{               
        u8 retry=0;        
        
        SPI_Cmd(SPI2, ENABLE);        AD_CS_0();
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
                {
                        retry++;
                        if(retry>200)return 0;
                }AD_CS_1();        
        SPI_Cmd(SPI2, DISABLE);        
            
        return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
}
/*BUSY中断初始化*/
void ad7606_exti_init(void)
{
        EXTI_InitTypeDef EXTI_Structre;
        NVIC_InitTypeDef NVIC_Structre;
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
        
        GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource2);
        EXTI_Structre.EXTI_Line=EXTI_Line2;
        EXTI_Structre.EXTI_LineCmd=ENABLE;
        EXTI_Structre.EXTI_Mode=EXTI_Mode_Interrupt;
        EXTI_Structre.EXTI_Trigger=EXTI_Trigger_Falling;
        EXTI_Init(&EXTI_Structre);
        
        NVIC_Structre.NVIC_IRQChannel=EXTI2_IRQn;
        NVIC_Structre.NVIC_IRQChannelCmd=ENABLE;
        NVIC_Structre.NVIC_IRQChannelPreemptionPriority=2;
        NVIC_Structre.NVIC_IRQChannelSubPriority=2;
        NVIC_Init(&NVIC_Structre);
}
/*中断2服务函数*/
extern u16 RESULT[16];

void EXTI2_IRQHandler(void)
{
        u8 i=0;
        delay_ms(10);
        if(EXTI_GetITStatus(EXTI_Line2)==1)
        {
//                AD_CS_0();
                for (i = 0; i <16; i++)
                {
                        RESULT=SPI_ReadTwoByte();                                                        
                }
//                AD_CS_1();在读取函数中加入        
                for (i = 0; i <8; i++)
                {
                        if((RESULT&0x8000)!=0)
                                {
                                        RESULT=~RESULT;
                                        LCD_ShowNum(200,70+i*25,1,1,24);
                                }
                                else
                                {
                                        LCD_ShowNum(200,70+i*25,0,1,24);
                                }
                                RESULT=RESULT*5000/32767;
                }
                        ad7606_Reset();
                        led1=!led1;
                        delay_ms(500);               
        }
        EXTI_ClearITPendingBit(EXTI_Line2);
}
/*ad7606复位函数*/
void ad7606_Reset(void)
{
        AD_RESET_LOW();
        
        AD_RESET_HIGH();
        AD_RESET_HIGH();
        AD_RESET_HIGH();
        AD_RESET_HIGH();
        
        AD_RESET_LOW();
}
void ad7606_cv(void)
{
        AD_CONVST_HIGH();
        AD_CONVST_LOW();
        AD_CONVST_LOW();
        AD_CONVST_LOW();        /* 连续执行2次，低电平约50ns */
        
        AD_CONVST_HIGH();
}
/*总初始化函数*/
void ad7606_init(void)
{
        ad7606_spi_init();
        ad7606_GPIO_init();
        ad7606_exti_init();
        ad7606_Reset();
}
/*某个通道数据函数*/
u16 AD7606_ReadAdc(u8 _ch)
{
        u16 sAdc;        
        sAdc = RESULT[_ch];
        return sAdc;
}

特别要注意这个函数：
u16 SPI_ReadTwoByte(void)
{               
        u8 retry=0;        
        
        SPI_Cmd(SPI2, ENABLE);        AD_CS_0();
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
                {
                        retry++;
                        if(retry>200)return 0;
                }AD_CS_1();        
        SPI_Cmd(SPI2, DISABLE);        
            
        return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
}

即spi的开关与cs的开关顺序

dazalei

jack he 发表于 2016-10-13 21:27
我把源码发给你
#include "ad7606_spi.h"
#include "LED.h"

先表示感谢 spi的开关与cs的开关顺序正好与你 目前是SPI_DR中有数据，但是感觉不对，都是很小的值，我在其中一道加了一个3.3V的值但是才出来第一道值是个小值。
P3(44) PB12        SPI2_NSS
P3(41) PB13        SPI2_SCK
P3(21) PC2        SPI2_MISO

三线，ARM只读aD数值不往里面写数据。SPI2_MOSI没有使用。
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_RxOnly用得这种模式。
SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
目前我先发片选信号SPI2_NSS好像控制不上，一直是低电平。

jack he

dazalei 发表于 2016-10-14 11:30
先表示感谢 spi的开关与cs的开关顺序正好与你 目前是SPI_DR中有数据，但是感觉不对，都是很小的值，我在 ...

我记得当时我两种方式都成功了；
1、用SPI2_MISO的话使用SPI_Direction_2Lines_RxOnly;
2、用SPI2_MOSI的话使用SPI_Direction_1Line_Rx；
主模式下：
SPI_Direction_2Lines_FullDuplex ：可以是双线双向（即普通的用法），也可以是单线单向只发送模式（可以理解为有两条数据线，发送但是不理会接受的数据，当然你也可以不连接接收线miso）
SPI_Direction_2Lines_RxOnly：是单线单向只接收模式，用miso线；
SPI_Direction_1Line_Rx：是单线双向在接收时的配置，只要是主设备模式下，都用mosi；
SPI_Direction_1Line_Tx：是单线双向在发送时的配置，只要是主设备模式下，都用mosi；（上面两种在从模式下均用miso）
区别：
        前两种事一条线上只能完成一个方向的传输，对于主设备来说，miso只能接受，mosi只能发送，当然你可以只用其中一根线，而不去理会另一根线，从而实现只发送或是只接受。
        后两种是指一条线既能接受也能发送，对主设备用mosi，对从设备只用miso，当然一条线在一个时间段里只能用作输出或是输入，所以是在发送时配置SPI_Direction_1Line_Tx，接收时配置SPI_Direction_1Line_Rx，不能在转化接受还是发送时每一次都配置初始化函数，我记得好像有专门的函数来改，你可以查查函数库。
综上，对于ad7606来说可以有两种方式配置。补充一下：
我感觉一般对于只有主从两个设备的话是使用软件NSS，因为不需要多机通讯，在软件时，主设备的内部NSS信号电平可以通过写SPI_CR1的SSI位来驱动，从设备的通过你的cs来驱动。cs的引脚与spi2硬件的相应管脚重合。

dazalei

jack he 发表于 2016-10-14 15:39
我记得当时我两种方式都成功了；
1、用SPI2_MISO的话使用SPI_Direction_2Lines_RxOnly;
2、用SPI2_MOSI ...

非常感谢！
我目前的状态是这样的。用ARM的SPI2接收AD7606过来的SPI数据，由于不用给AD7606发送数据，仅用三个片选、时钟和MISO三根数据先。ARM是主设备，AD7606是从设备。SPI1默认连接到FLASH上当缓存，使用SPI2接口。接法如下
开发板                   STM32F407
P3(44)                    PB12                  SPI2_NSS
P3(41)                    PB13                  SPI2_SCK
P3(21)                    PC2                    SPI2_MISO

四种工作模式看了你的讲解我好像有点明白啦   以下是我自己理解你看对不对
主模式下：
SPI_Direction_2Lines_FullDuplex ：1 可以是双线双向（即普通的用法MISO+MOSI）， 2 也可以是单线单向只发送模式（可以理解为有两条数据线，发送但是不理会接受的数据，当然你也可以不连接接收线miso）
SPI_Direction_2Lines_RxOnly：是单线单向只接收模式，用miso线；
SPI_Direction_1Line_Rx：是单线双向在接收时的配置，只要是主设备模式下，只能使用mosi这根线进行数据接收，也就是ARM接收来自AD7606的数据，而不能用MISO，否则收不到数据；
SPI_Direction_1Line_Tx：是单线双向在发送时的配置，只要是主设备模式下，只能使用mosi这根线进行数据接收，不能用MISO；（上面两种在从模式下均用miso）
以上理解正确吗？

补充一下：
我感觉一般对于只有主从两个设备的话是使用软件NSS，因为不需要多机通讯，在软件时，主设备的内部NSS信号电平可以通过写SPI_CR1的SSI位来驱动，从设备的通过你的cs来驱动。cs的引脚与spi2硬件的相应管脚重合。
——[size=14.6667px]cs的引脚与spi2硬件的相应管脚重合？没有明白。您说的这种设置感觉有点分别设置的感觉。我的理解：硬件NSS，设置ARM主设备，设置ARM NSS引脚高低电平直接控制AD7606的CS管脚，也就是连接 PB12                  SPI2_NSS到AD7606的CS脚上，实际中发现此管脚线上一直是低电平。后来根据你上个跟帖单独把    PB12  作为一个通用GPIO连接到AD7606的片选上。

但是现在依然在SPI-DR中都是小AD值

jack he

dazalei 发表于 2016-10-14 17:23
非常感谢！
我目前的状态是这样的。用ARM的SPI2接收AD7606过来的SPI数据，由于不用给AD7606发送数据，仅 ...

我觉得是的

dazalei

jack he 发表于 2016-10-14 20:11
我觉得是的

我再对照一下你的代码查一下

dazalei

SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;8B 改成16B就好了  谢谢

十年氵

jack he 发表于 2016-9-23 21:49
楼主解决了吗，最近我也在做这个。我调试时spi读出来的数据总是毫无规律的，跟被测电压无关

你的AD7606问题解决了吗？我也遇到了相同的问题

ljx289

我的要使用SPI_Direction_2Lines_RxOnly才可以，其他的返回都是0.
但是有一个新的问题，当AD的输入通道悬空的时候，竟然返回有2V左右的数值。
输入通道接地，返回为2，也就是2/32767 *10V

Crime毛豆

jack he 发表于 2016-9-23 21:50
#include "ad7606_spi.h"
#include "LED.h"
#include "BEEP.h"

您这是通过外部中断来控制ad的采样吗？。。对于BUSY接入的那个中断信号，有没有什么频率要求。。。

newnew0601

我也遇到这样的问题，虽然在接收数据先把片选拉低，再使能SPI，完后再禁能SPI，再拉高片选，但是数据总是不对。求前辈指点。

newnew0601

newnew0601 发表于 2017-7-19 14:32
我也遇到这样的问题，虽然在接收数据先把片选拉低，再使能SPI，完后再禁能SPI，再拉高片选，但是数据总是不 ...

把spi总线设置为SPI_Direction_2Lines_RxOnly，就不需要在接收数据的使能使能、禁能SPI。只是数据还是不对，求指导

newnew0601

原子老师，为啥要在片选拉低前使能SPI呢？不这么做，片选拉低后RXNE瞬间就置1了，导致接收数据出错。

15801659334aw

原子老师，AD7606 设置成MSB，高八位正常，低八位乱码，设置成LSB，低八位正常，高八位乱码，有没有遇到过类似情况的？

跟紧我

使用你们的代码都不行呢

跟紧我

15801659334aw 发表于 2019-12-30 20:53
原子老师，AD7606 设置成MSB，高八位正常，低八位乱码，设置成LSB，低八位正常，高八位乱码，有没有遇到过 ...

输出都是0

LEO36wh

才回来的AD乱值

2569635365

jack he 发表于 2016-9-23 21:50
#include "ad7606_spi.h"
#include "LED.h"
#include "BEEP.h"

请问有没有完整的源代码，有偿。