关于单片机模拟SPI接口的问题，求助

a13092132346a

事情是这样的。
我最近在准备模拟SPI接口，现在问题来了，我在系统9倍频的情况下：假如连续有3个读取的代码，第一条可以读取且，之后的都是读取的0XFF。但是如果用仿真器单步执行就都可以读取且正确。

后来我试了5倍频，通讯就OK了。我想知道，这到底是咋回事，如何解决呢，请知道的大神给个提示，或者调试的方向，谢谢。

xuande

同意楼上。
可能外接芯片速度有要求。

憨厚诚实大叔

你看看连接的SPI的外设的说明书吧，看看他支持的最高频率是否符合

a13092132346a

xuande 发表于 2016-7-4 10:22
同意楼上。
可能外接芯片速度有要求。

那主频很高的芯片还驱动不了这个外设吗？这个外设3.5M/S最大

a13092132346a

憨厚诚实大叔 发表于 2016-7-4 10:18
你看看连接的SPI的外设的说明书吧，看看他支持的最高频率是否符合

那主频很高的芯片还驱动不了这个外设吗？这个外设3.5M/S最大、我想知道在72M主频的时候如何降低模拟的SPI接口速率

憨厚诚实大叔

原来你用的模拟的啊，我没用过

xuande

示波器查时序吧。

wangyan915205

发出来看看

a13092132346a

wangyan915205 发表于 2016-7-4 12:44
发出来看看

void Tx_Onebyte(unsigned char TxData)
{
        unsigned char i,j,k;

        SCK_DOWN;

        NOP();
        NOP();

        i = 0x80;
        j = 8;

        for(;j>0;j--)
        {
                k=TxData&i;

                if(k > 0)
            {
                        SDI_UP;
                         
                      SCK_UP;
                      NOP();
                          NOP();
                      NOP();
                      SCK_DOWN;
                        NOP();
                          NOP();
                      NOP();
            }
            else
            {
                      SDI_DOWN;
                         
                      SCK_UP;
                      NOP();
                          NOP();
                      NOP();
                      SCK_DOWN;
                        NOP();
                          NOP();
                      NOP();
            }
            i=i>>1;
  }

  SCK_DOWN;

}

unsigned char Rx_Onebyte(void)
{
  unsigned char i,j;

  SCK_DOWN;
  NOP();
  NOP();

  i=0x00;j=8;
  for(;j>0;j--)
  {
     i=i<<1;
     SCK_UP;
     //NOP();
     //NOP();
     //NOP();
     SCK_DOWN;
     //NOP();
     //NOP();
     if(SDO==0){i=i|0x00;}
     else {i=i|0x01;}
     NOP();
         NOP();
         NOP();
         NOP();
         NOP();
  }

  NOP();
  SCK_DOWN;
  NOP();
  return i;
}

unsigned char Rx_Frame(unsigned char Num)    //接收数据存储在SPI_Rxdat[]内；
{
          unsigned char i,cs;

        i=0;
          cs=0;
          Tx_Onebyte(SPI_Txdat[0]);
          Tx_Onebyte(SPI_Txdat[1]);
          cs=cs+SPI_Txdat[0];
          cs=cs+SPI_Txdat[1];

        for(;Num>0;Num--)
          {
                   SPI_Rxdat=Rx_Onebyte();
                   cs=cs+SPI_Rxdat;
                   ++i;
          }   

          SPI_Rxdat=Rx_Onebyte();
          cs=cs+SPI_Rxdat;                        //校验和未取反CS加最后一个校验和字节=0xff(CS=CS+~CS);
          NOP();
          NOP();
          NOP();

          if(cs==0xff){return 1;}                    //校验和正确返回1
          else return 0;                             //校验和错误返回0
}


unsigned char Tx_Frame(unsigned char Num)
{
        unsigned char i,cs;
          i=0;
          cs=0;

          for(;Num>0;Num--)
          {
            Tx_Onebyte(SPI_Txdat);
            cs=cs+SPI_Txdat;
            i++;
          }
          cs=~cs;
          Tx_Onebyte(cs);
          NOP();
          NOP();
          NOP();
          NOP();
       
        return cs;
}



unsigned char RN8302_Rdat(unsigned int bank,unsigned char addr,unsigned char num)
{
        unsigned char Check=0;

          CS_DOWN;

          if(num<5)                         //最大同时读4个寄存器；
          {
                   SPI_Txdat[0]=addr;               //发送首地址；
                   SPI_Txdat[1]=0x00|(bank<<4);     //地址高三位；
                   Check=Rx_Frame(num);
                CS_UP;
          }
          else
          {
            Check=0;                        //否则错误；                        
          }

           return Check;                    //接受数据正确；返回1；            
}

unsigned char RN8302_Wdat(unsigned int bank,unsigned char addr,unsigned char num,...)
{
        unsigned int i=0;
           unsigned char temp=0;
           unsigned char Check=0;
           va_list argp;

           CS_DOWN;
           temp=num+2;

           if(num<4)
           {
            va_start(argp,num);
            SPI_Txdat[0]=addr;
            SPI_Txdat[1]=0x80|(bank<<4);

                for(;num>0;num--)
            {
                     SPI_Txdat[i+2]=va_arg(argp,unsigned char);
                     ++i;
            }

                va_end(argp);
            Check=Tx_Frame(temp);
                CS_UP;
   }
   else
   {
             Check=0;
   }

   return Check;
}

Sun_Fly

直接用硬件的SPI口试试

a13092132346a

Sun_Fly 发表于 2016-7-4 16:35
直接用硬件的SPI口试试

硬件的试了没用，卧槽

xuande

a13092132346a 发表于 2016-7-4 16:31
void Tx_Onebyte(unsigned char TxData)
{
        unsigned char i,j,k;

很简单的波形。
没有示波器吗？

xuande

随便看了一下Tx_Onebyte，
错误不少。
LZ大概头次写程序。

k=TxData&i，
你把最高位发了n次，其他位根本没发出去。

Sun_Fly

给你一个模拟SPI的调试程序，你可以试试。





/*******************************************************************************
* 文件名                  : main.c
把对应的管脚连接：
                                PA5-----------PB13
                                PA6-----------PB14
                                PA7-----------PB15
描述                        : SPI自通信。打开串口软件
********************************************************************************/

/* 头文件 --------------------------------------------------------------------*/

#include "stm32f10x_lib.h"
#include <stdio.h>

/* 自定义同义关键字    --------------------------------------------------------*/

typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;

/* 自定义参数宏        --------------------------------------------------------*/

#define BufferSize 32

/* 自定义函数宏        --------------------------------------------------------*/

/* 自定义全局变量      --------------------------------------------------------*/

SPI_InitTypeDef   SPI_InitStructure;                /* 定义 SPI 初始化结构体 */

u8 SPI1_Buffer_Tx[BufferSize] =                         /* 定义待 SPI1 传输数据 */
{
        0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,
        0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,
        0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
        0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20
};

u8 SPI2_Buffer_Tx[BufferSize] =                         /* 定义待 SPI2 传输数据 */
{
        0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,
        0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,
        0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,
        0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70
};

u8 SPI1_Buffer_Rx[BufferSize];                                 /* 开辟内存空间待 SPI1 接收 */
u8 SPI2_Buffer_Rx[BufferSize];                                 /* 开辟内存空间待 SPI2 接收 */
u8 Tx_Idx = 0;                                                                 /* 发送计数变量 */
u8 Rx_Idx = 0;                                                                 /* 接收计数变量 */
vu8 k = 0 , i = 0;                                                        /* 循环计数变量 */

/* 自定义函数声明      --------------------------------------------------------*/

void RCC_Configuration(void);
void GPIO_Configuration(void);
void SPI_Configuration(void);
void USART_Configuration(void);

/*******************************************************************************
* 函数名                 : main
* 函数描述       : main 函数
* 输入参数       : 无
* 输出结果       : 无
* 返回值         : 无
*******************************************************************************/

int main(void)
{
        u8 res;
        /* 设置系统时钟 */
        RCC_Configuration();
       
        /* 设置 GPIO 端口 */
        GPIO_Configuration();

        /* 设置 SPI */
        SPI_Configuration();

           /* 设置 USART */
        USART_Configuration();

        /* 设置 SPI2 为主机*/
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
        SPI_Init(SPI1, &SPI_InitStructure);       
        /* 设置 SPI2 为从机*/
        SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
        SPI_Init(SPI2, &SPI_InitStructure);

        while(1){
                while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
                /* SPI2 发送数据 */
                SPI_I2S_SendData(SPI1, 0x66);
   /* 等待 SPI2 接收数据完毕 */
//                         printf("%d\n",res);
                while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
                /* 读出 SPI2 接收的数据 */
                res = SPI_I2S_ReceiveData(SPI1);
                printf("%d\n",res);
        }
//         while(Tx_Idx < BufferSize)
//         {
//                 /* 等待 SPI1 发送缓冲空 */
//                 while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
//                 /* SPI2 发送数据 */
//                 SPI_I2S_SendData(SPI2, SPI2_Buffer_Tx[Tx_Idx]);       
//                 /* SPI1 发送数据 */  
//                 SPI_I2S_SendData(SPI1, SPI1_Buffer_Tx[Tx_Idx++]);
//                      
//                 /* 等待 SPI2 接收数据完毕 */
//                 while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
//                 /* 读出 SPI2 接收的数据 */
//                 SPI2_Buffer_Rx[Rx_Idx] = SPI_I2S_ReceiveData(SPI2);

//                 /* 等待 SPI1 接收数据完毕 */
//                 while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
//                 /* 读出 SPI1 接收的数据 */
//                 SPI1_Buffer_Rx[Rx_Idx++] = SPI_I2S_ReceiveData(SPI1);                 
//         }
//        
//         /* 打印试验结果信息 ---------------------------------------------------------------------------------------------*/

//         printf("\r\nThe First transfer between the two SPI perpherals: The SPI1 Master and the SPI2 slaver. \r\n");

//         printf("\r\nThe SPI1 has sended data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI1_Buffer_Tx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }
//         printf("\r\nThe SPI2 has receive data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI2_Buffer_Rx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }

//         printf("\r\n \r\n");

//         printf("\r\nThe SPI2 has sended data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI2_Buffer_Tx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }
//         printf("\r\nThe SPI1 has receive data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI1_Buffer_Rx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }

//         /* 打印试验结果信息 ---------------------------------------------------------------------------------------------*/
//        

//         Tx_Idx=0;
//         Rx_Idx=0;
//         for(k=0; k < BufferSize; k++)  
//         {
//                 *(SPI2_Buffer_Rx + k) = 0;
//         }
//         for(k=0; k < BufferSize; k++)
//         {
//                 *(SPI1_Buffer_Rx + k) = 0;
//         }

//         /* 设置 SPI2 为主机*/
//         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
//         SPI_Init(SPI2 , &SPI_InitStructure);       
//         /* 设置 SPI1 为从机*/
//         SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
//         SPI_Init(SPI1 , &SPI_InitStructure);
//        
//         while(Tx_Idx < BufferSize)
//         {
//                 /* 等待 SPI2 发送缓冲空 */
//                 while(SPI_I2S_GetFlagStatus(SPI2 , SPI_I2S_FLAG_TXE) == RESET);
//                 /* SPI1 发送数据 */
//                 SPI_I2S_SendData(SPI1 , SPI1_Buffer_Tx[Tx_Idx]);
//                 /* SPI2 发送数据 */
//                 SPI_I2S_SendData(SPI2 , SPI2_Buffer_Tx[Tx_Idx++]);

//                 /* 等待 SPI1 接收数据完毕 */
//                 while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
//                 /* 读出 SPI1 接收的数据 */
//                 SPI1_Buffer_Rx[Rx_Idx] = SPI_I2S_ReceiveData(SPI1);
//                  
//                 /* 等待 SPI2 接收数据完毕 */
//                 while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
//                 /* 读出 SPI2 接收的数据 */
//                 SPI2_Buffer_Rx[Rx_Idx++] = SPI_I2S_ReceiveData(SPI2);
//         }

//         /* 打印试验结果信息 ---------------------------------------------------------------------------------------------*/

//         printf("\r\n \r\nThe Second transfer between the two SPI perpherals: The SPI2 Master and the SPI1 slaver.  \r\n");
//                                                                             
//         printf("\r\nThe SPI2 has sended data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI2_Buffer_Tx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }
//         printf("\r\nThe SPI1 has receive data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI1_Buffer_Rx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }

//         printf("\r\n \r\n");

//         printf("\r\nThe SPI1 has sended data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI1_Buffer_Tx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }
//         printf("\r\nThe SPI2 has receive data below: \r\n");
//         for(k = 0; k < BufferSize ; k ++)
//         {
//                 printf("%0.2d \r" , *(SPI2_Buffer_Rx + k));
//                 for(i = 0 ; i < 200 ; i ++);
//         }
//         /* 打印试验结果信息 ---------------------------------------------------------------------------------------------*/

//         while(1);
}

/*******************************************************************************
* 函数名                : RCC_Configuration
* 函数描述          : 设置系统各部分时钟
* 输入参数          : 无
* 输出结果          : 无
* 返回值            : 无
*******************************************************************************/

void RCC_Configuration(void)
{
        /* 定义枚举类型变量 HSEStartUpStatus */
        ErrorStatus HSEStartUpStatus;

          /* 复位系统时钟设置 */
          RCC_DeInit();

          /* 开启 HSE */
          RCC_HSEConfig(RCC_HSE_ON);

          /* 等待 HSE 起振并稳定 */
          HSEStartUpStatus = RCC_WaitForHSEStartUp();
       
        /* 判断 HSE 起是否振成功，是则进入if()内部 */
          if(HSEStartUpStatus == SUCCESS)
          {
            /* 选择 HCLK（AHB）时钟源为SYSCLK 1分频 */
            RCC_HCLKConfig(RCC_SYSCLK_Div1);
  
            /* 选择 PCLK2 时钟源为 HCLK（AHB） 1分频 */
            RCC_PCLK2Config(RCC_HCLK_Div1);

            /* 选择 PCLK1 时钟源为 HCLK（AHB） 2分频 */
            RCC_PCLK1Config(RCC_HCLK_Div2);

            /* 设置 FLASH 延时周期数为2 */
            FLASH_SetLatency(FLASH_Latency_2);

            /* 使能 FLASH 预取缓存 */
            FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

            /* 选择锁相环（PLL）时钟源为HSE 1分频，倍频数为9，则PLL输出频率为 8MHz * 9 = 72MHz */
            RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

            /* 使能 PLL */
            RCC_PLLCmd(ENABLE);

            /* 等待 PLL 输出稳定 */
            while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

            /* 选择 SYSCLK 时钟源为 PLL */
            RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

            /* 等待 PLL 成为 SYSCLK 时钟源 */
            while(RCC_GetSYSCLKSource() != 0x08);
          }

        /* 打开 SPI2 时钟 */
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
        /* 打开 GPIOA，GPIOB，USART1 和 SPI1 时钟 */
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |
                                                   RCC_APB2Periph_USART1 |RCC_APB2Periph_SPI1, ENABLE);
}

/*******************************************************************************
* 函数名                  : GPIO_Configuration
* 函数描述            : 设置各GPIO端口功能
* 输入参数      : 无
* 输出结果      : 无
* 返回值        : 无
*******************************************************************************/

void GPIO_Configuration(void)
{         
        /* 定义 GPIO 初始化结构体 GPIO_InitStructure */
        GPIO_InitTypeDef GPIO_InitStructure;
       
        /* 设置 SPI1 引脚: SCK, MISO 和 MOSI */
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_Init(GPIOA, &GPIO_InitStructure);
       
        /* 设置 SPI2 引脚: SCK, MISO 和 MOSI */
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
        GPIO_Init(GPIOB, &GPIO_InitStructure);

        /* 设置 USART1 的Tx脚（PA.9）为第二功能推挽输出功能 */
          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
          GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
          GPIO_Init(GPIOA , &GPIO_InitStructure);
   
          /* 设置 USART1 的Rx脚（PA.10）为浮空输入脚 */
          GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
          GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
          GPIO_Init(GPIOA , &GPIO_InitStructure);
}

/*******************************************************************************
* 函数名                  : SPI_Configuration
* 函数描述            : 设置 SPI 参数
* 输入参数      : 无
* 输出结果      : 无
* 返回值        : 无
*******************************************************************************/

void SPI_Configuration(void)
{
        /*
        *        SPI 设置为双线双向全双工
        *          SPI 发送接收 8 位帧结构
        *          时钟悬空低
        *          数据捕获于第二个时钟沿
        *        内部 NSS 信号由 SSI 位控制
        *        波特率预分频值为 4
        *        数据传输从 LSB 位开始
        *        用于 CRC 值计算的多项式
        */

        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
        SPI_InitStructure.SPI_CRCPolynomial = 7;
       
        /* 使能 SPI1 */
        SPI_Cmd(SPI1, ENABLE);
        /* 使能 SPI2 */
        SPI_Cmd(SPI2, ENABLE);       
}

/*******************************************************************************
* 函数名                  : USART_Configuration
* 函数描述            : 设置USART1
* 输入参数      : 无
* 输出结果      : 无
* 返回值        : 无
*******************************************************************************/

void USART_Configuration(void)
{
        /* 定义 USART 初始化结构体 USART_InitStructure */
          USART_InitTypeDef USART_InitStructure;

        /*        波特率为115200bps;
        *        8位数据长度;
        *        1个停止位，无校验;
        *        禁用硬件流控制;
        *        禁止USART时钟;
        *        时钟极性低;
        *        在第2个边沿捕获数据
        *        最后一位数据的时钟脉冲不从 SCLK 输出；
        */

        USART_InitStructure.USART_BaudRate = 115200;
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        USART_InitStructure.USART_Parity = USART_Parity_No ;
        USART_InitStructure.USART_HardwareFlowControl =  USART_HardwareFlowControl_None;
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        USART_Init(USART1 , &USART_InitStructure);
   
          /* 使能 USART1 */
          USART_Cmd(USART1 , ENABLE);
}

/*******************************************************************************
* 函数名                  : fputc
* 函数描述            : 将printf函数重定位到USATR1
* 输入参数            : 无
* 输出结果            : 无
* 返回值                : 无
*******************************************************************************/

int fputc(int ch, FILE *f)
{
        USART_SendData(USART1, (u8) ch);
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
        return ch;
}

a13092132346a

xuande 发表于 2016-7-4 16:49
随便看了一下Tx_Onebyte，
错误不少。
LZ大概头次写程序。

这个程序是对的啊。你没看到i=i>>1吗？

xuande

a13092132346a 发表于 2016-7-4 19:17
这个程序是对的啊。你没看到i=i>>1吗？

你说得对，
确实没看仔细。

xuande

a13092132346a 发表于 2016-7-4 19:17
这个程序是对的啊。你没看到i=i>>1吗？

你说得对，
确实没看仔细。