V3.5 SPI 全双工通信 (9)

工程代码： 9spi双工主机向从机发送数据.rar  

        附件二： 和上面的代码一样，只是可以 单独设置 SPI1 主机/从机模式， SPI2 主机/从机模式
                 上面那个附件，只能一起设置 SPI1 SPI2 模式
                        9_1spi双工主机向从机发送数据.rar  

修改附件三：   对ｓｐｉ.h .c 文件 进行修改，主从配置 使用 SPIy 主机 SPIz从机
                9_spi双工通信修改3.rar  


可以参考： StdLib3.5 库函数 spi 全双工 code

说明：
     stm32中 SPI1 设置为 主模式
             SPI2 设置为 从模式

     主机 向 从机 发送数据， 从机接收数据，验证主机发送数据的正确性
     从机 向 主机 发送数据， 主机接收书记，验证从机发送数据的正确性
出现了错误：
     从机 向 主机 发送数据，但是主机不能接收到正确的数据
分析：
     由于 板子上得 SPI1 接到了SD卡模块，相关的管教接到3.3v上，被拉高了，导致 主机接收到的数据被影响，所以不能接收到正确的数据。
     板子上得硬件不能修改了，所以以后 可以用其他板子 验证 正确性了。






注意： SPI1 这里被拉高了，导致 从机向主机 发送数据，主机不能正确接收数据了

*   修改Date：2011.6.27 15:40
              spi功能 设置全双工
              STM32内部 SPI1 设为主设备
                        SPI2 设为从设备
              主机向从机发送数据， 从机接收数据 成功
              从机向主机发送数据，失败，需要解决

    从机向主机发送失败原因：
              由于主机SPI1 接到了SD卡模块，SPI 4个管教拉高了，导致
              从 从机向主机发送数据， 被干扰了。

              下次有 2片 stm再次测试
*/
#include "stm32f10x.h"
#include "rcc.h"
#include "systick.h"
#include "led.h"
#include "delay.h"
#include "key.h"
#include "tim3.h"
#include "usart1.h"
#include "spi.h"

u8 Sreceiv = 0;    //从设备接收数据
u8 Mreceiv = 0;    //主设备接收数据
int main()
{
    RCC_Configuration();
    delay_init();
    LED_Init();
    USART1_GPIO_Configuration();
    USART1_Configuration();
//    SPI_GPIO_Configuration(SPI_Mode_Master, SPI_Mode_Slave);//设置SPI1 主模式 SPI2从模式
  SPI1_GPIO_Configuration(SPI_Mode_Master); //单独设置SPI1 主机模式    SPI2_GPIO_Configuration(SPI_Mode_Slave);//单独设置 SPI2 从机模式
   SPI_Configuration();

    delay_s(2);//usart 发送显示开始
    usart1_sendchar(65);//A字符 asicc码65

    Master_SPI_Write_Byte(SPI1, 55); //主机发送 数据 55
    Sreceiv = Slave_SPI_Read_Byte(SPI2);//从机接收数据
    if(Sreceiv == 55)  //接收正确，打印信息，接收不正确，不打印信息
        usart1_sendchar(68); //D字符 asicc码68

/*主机SPI1 接到SD卡模块，被拉高，导致接收从机数据失败*/
    Slave_SPI_Write_Byte(SPI2, 66);//从机发送 数据66
    Mreceiv = Master_SPI_Read_Byte(SPI1); //主机接收数据
    if(Mreceiv == 66)  //接收正确，打印信息，接收不正确，不打印信息
        usart1_sendchar(69); //E字符 asicc码68


    while(1)
    {
        usart1_sendchar(64); //@字符 asicc码64
        delay_s(1);
    }
    return 0;
}

#ifndef __SPI_H
#define __SPI_H

#include "stm32f10x.h"

#define SPIy                   SPI1
#define SPIy_CLK               RCC_APB2Periph_SPI1
#define SPIy_GPIO              GPIOA
#define SPIy_GPIO_CLK          RCC_APB2Periph_GPIOA
#define SPIy_PIN_SCK           GPIO_Pin_5
#define SPIy_PIN_MISO          GPIO_Pin_6
#define SPIy_PIN_MOSI          GPIO_Pin_7

#define SPIz                    SPI2
#define SPIz_CLK                RCC_APB1Periph_SPI2
#define SPIz_GPIO               GPIOB
#define SPIz_GPIO_CLK           RCC_APB2Periph_GPIOB
#define SPIz_PIN_SCK            GPIO_Pin_13
#define SPIz_PIN_MISO           GPIO_Pin_14
#define SPIz_PIN_MOSI           GPIO_Pin_15

void SPI_Configuration(void);
                            // SPIy                      SPIz
void SPI_GPIO_Configuration(uint16_t SPIy_Mode, uint16_t SPIz_Mode);

//主设备 写数据到 从设备
void Master_SPI_Write_Byte(SPI_TypeDef* SPIx_Master, u8 byte);
//从设备 读取数据  from 主设备
u8 Slave_SPI_Read_Byte(SPI_TypeDef* SPIx_Slave);
//从设备 写数据到 主设备
void Slave_SPI_Write_Byte(SPI_TypeDef* SPIx_Slave, u8 byte);
//主设备 读取数据 from 从设备
u8 Master_SPI_Read_Byte(SPI_TypeDef* SPIx_Master);


#endif

#include "spi.h"

//注意，如果我们 交换 主从机，需要再次配置 主从机模式，修改 SPI_Configuration
// 这个程序还没有修改

void SPI_Configuration(void)
{
    SPI_InitTypeDef   SPI_InitStructure;
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//全双工模式
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;//配置为主机
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;//8位数据帧
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;//时钟低时活动
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;//数据在第二个边沿捕获
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;//内部NSS信号由SSI控制
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;//预分频4
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;//传输的第一位是低位
    SPI_InitStructure.SPI_CRCPolynomial = 7; //用于crc计算
    SPI_Init(SPIy, &SPI_InitStructure);     //初始化 SPI1

    /* SPIz Config -------------------------------------------------------------*/
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave; //SPI2 设置 从机
    SPI_Init(SPIz, &SPI_InitStructure);      //初始化 SPI2

    SPI_Cmd(SPIy, ENABLE); //使能 SPIy = SPI1
    SPI_Cmd(SPIz, ENABLE); //使能 SIPz = SPI2

  //定义在 了 rcc中
  //    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//SPI1
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//SPI2
  //  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

}

void SPI_GPIO_Configuration(uint16_t SPIy_Mode, uint16_t SPIz_Mode)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    /* Configure SPIy pins: SCK, MISO and MOSI ---------------------------------*/
    GPIO_InitStructure.GPIO_Pin = SPIy_PIN_SCK | SPIy_PIN_MOSI;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

    if(SPIy_Mode == SPI_Mode_Master)
    {
    /* Configure SCK and MOSI pins as Alternate Function Push Pull */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    }
    else
    {
    /* Configure SCK and MOSI pins as Input Floating */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }

    GPIO_Init(SPIy_GPIO, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = SPIy_PIN_MISO;

    if(SPIy_Mode == SPI_Mode_Master)
    {
        /* Configure MISO pin as Input Floating  */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }
    else
    {
        /* Configure MISO pin as Alternate Function Push Pull */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    }

    GPIO_Init(SPIy_GPIO, &GPIO_InitStructure);

    /* Configure SPIz pins: SCK, MISO and MOSI ---------------------------------*/
    GPIO_InitStructure.GPIO_Pin = SPIz_PIN_SCK | SPIz_PIN_MOSI;

    if(SPIz_Mode == SPI_Mode_Slave)
    {
        /* Configure SCK and MOSI pins as Input Floating */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }
    else
    {
        /* Configure SCK and MOSI pins as Alternate Function Push Pull */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    }

    GPIO_Init(SPIz_GPIO, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = SPIz_PIN_MISO;

    if(SPIz_Mode == SPI_Mode_Slave)
    {
        /* Configure MISO pin as Alternate Function Push Pull */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    }
    else
    {     /* Configure MISO pin as Input Floating  */
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    }

    GPIO_Init(SPIz_GPIO, &GPIO_InitStructure);
}

//主设备 写数据到 从设备
void Master_SPI_Write_Byte(SPI_TypeDef* SPIx_Master, u8 byte)
{
    while(SPI_I2S_GetFlagStatus(SPIx_Master, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(SPIx_Master, byte);
}

//从设备 读取数据  from 主设备
u8 Slave_SPI_Read_Byte(SPI_TypeDef* SPIx_Slave)
{
    while (SPI_I2S_GetFlagStatus(SPIx_Slave, SPI_I2S_FLAG_RXNE) == RESET);
    return SPI_I2S_ReceiveData(SPIx_Slave);
}

//从设备 写数据到 主设备
void Slave_SPI_Write_Byte(SPI_TypeDef* SPIx_Slave, u8 byte)
{
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(SPIx_Slave, byte);
}

//主设备 读取数据 from 从设备
u8 Master_SPI_Read_Byte(SPI_TypeDef* SPIx_Master)
{
  //写 哑元字节dumy
 // Master_SPI_Write_Byte(SPIx_Master, 0x00);
  SPI_I2S_SendData(SPIx_Master, 0x00);//产生读时的clk
  while(SPI_I2S_GetFlagStatus(SPIx_Master, SPI_I2S_FLAG_RXNE) == RESET);
  return SPI_I2S_ReceiveData(SPIx_Master);
}