spi驱动--IO模拟

该spi驱动，应用于stm32f103 访问外部的flash（23K256）.

1. 23K256.c

#include "includes.h"
/*
1.  spi根据配置可以使用为半双工或者全双工，全双工下总共有四个引脚，MISO,MOSI,SCK,CS
    MISO: 主入从出
    MOSI: 主出从入
    SCK： 时钟线
    CS： 片选
2. spi可以有四种工作模式，有CPOL和CPHA决定:
    - CPOL: 时钟极性,决定是SCK的空闲态是低电平还是高电平，CPOL=0：空闲态是低电平;CPOL=1:空闲态是高电平。
    - CPHA：时钟相位，决定采样的点，是第一个时钟沿还是第二个，CPHA=0，采样在第一个时钟延，输出在第二个时钟沿；CPHA=1，输出在第一个时钟沿，采样在第二个时钟沿。
                   CPOL           CPHA
    Mode 0 :        0               0  
    Mode 1 :        0               1 
    Mode 2 :        1               0
    Mode 3 :        1               1
一般工作模式对于特定芯片是固定的，可以看时序图确定。
3. spi数据传输，先高位后低位。
/*
此处，spi协议工作在mode0，低电平的idle状态，采样在第一个边沿（即下降沿）。
接口：
    1. spi协议写一个字节
        主机写一个字节，就是输出，所以写MOSI数据（先高位后低位），然后时钟线产生一个下降沿，将数据输出。
    2. spi协议读一个字节
        主机读一个数据，就是采样，所以时钟产生一个上升沿，开始采样MISO线数据（先高位后低位）
-------------------上部分严格和spi协议相关---------------------
-----------------下部分需要参照对应的spi器件手册----------------
    3. spi发送一个字节
        - 片选拉低，选中SPI从机
        - 发送写指令
        - 发送地址高位
        - 发送地址低位
        - 发送数据（此处可以单字节或多字节发送）
        - 片选拉高，取消SPI从机
    4. spi接收一个字节
        - 片选拉低，选中SPI从机
        - 发送读指令
        - 发送地址高位
        - 发送地址低位
        - 读取数据（此处单字节或多字节接收）
        - 片选拉高，取消SPI从机
*/
*/
//1.spi gpio_init 
void spi_gpio_config(void)
{
    //CS: GPB12  SCK: GPB13  MISO:PB14  MOSI:PB15
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    //NSS
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    //SCK
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    //MISO
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    

    GPIO_Init(GPIOB, &GPIO_InitStructure);
    //MOSI
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
}
//2. 主机向从机写数据  上升沿读取写入数据
void spi_write_byte(uint8_t data)
{
    uint8_t i;
    SPI_SCK(0);
    delay(10);
    for(i = 0;i<8;i++)
    {
        if(data&0x80)
            SPI_MOSI(1);
        else
            SPI_MOSI(0);
        data<<=1;

        delay(10);
        SPI_SCK(1);
        delay(10);

        SPI_SCK(0);  //out
    delay(10);
/*      
        delay(10);
        SPI_SCK(1);
        delay(10);

        SPI_SCK(0);
        //delay(10);
*/      
    }
}
//3. 从机向主机传送一个数据
uint8_t spi_read_byte(void)
{
    uint8_t i;
    uint8_t temp;
    SPI_SCK(0);
//  delay(10);
    temp = 0;
    for(i = 0;i<8;i++)
    {       
        SPI_SCK(1); 
        delay(10);
        temp<<=1;
        if(SPI_MISO())
            temp |= 0x01;
        else
            temp &= ~0x01; 
        SPI_SCK(0);
        delay(10);
    }       
    return temp;
}
//4. write one byte
void spi_send_byte(uint16_t addr,uint8_t dat)
{
    SPI_NSS(0); 
    spi_write_byte(SPI_WRITE_CMD);
    spi_write_byte(AddrHigh(addr));
    spi_write_byte(AddrLow(addr));
    spi_write_byte(dat);

    SPI_NSS(1); 
}
//5. read one byte
uint8_t spi_recv_byte(uint16_t addr)
{
    uint8_t temp = 0;

    SPI_NSS(0); 
    spi_write_byte(SPI_READ_CMD);
    spi_write_byte(AddrHigh(addr));
    spi_write_byte(AddrLow(addr));
    temp = spi_read_byte();
    SPI_NSS(1);

    return temp;
}
//6. spi_init
void spi_init(void)
{
    spi_gpio_config();
    SPI_SCK(0);
    SPI_NSS(1);

}
//7. spi_buff_write
void spi_write_buff(uint8_t *pBuff,uint16_t WriteAddress,uint16_t BufferSize)
{
    uint8_t i;
    SPI_NSS(0); 
    //发送写指令
    spi_write_byte(SPI_WRITE_CMD);
    //写寄存器地址
    spi_write_byte(AddrHigh(WriteAddress));
    spi_write_byte(AddrLow(WriteAddress));
    //写数据
    for(i = 0;i<BufferSize;i++){
        spi_write_byte(pBuff[i]);
    }
    SPI_NSS(1);  
}

//8. spi_buff_read
void spi_read_buff(uint8_t *pBuff,uint16_t ReadAddress,uint16_t BufferSize)
{
    uint8_t i;
    SPI_NSS(0); 
    delay(20);
    //发送读指令
    spi_write_byte(SPI_READ_CMD);
    //发送寄存器地址
    spi_write_byte(AddrHigh(ReadAddress));
    spi_write_byte(AddrLow(ReadAddress));
    //读取数据
    for(i = 0;i<BufferSize;i++)
    {
        pBuff[i] = spi_read_byte();
    }
    SPI_NSS(1); 
    delay(20);
}
//9. spi read status
uint8_t spi_read_status(void)
{
    uint8_t spi_status = 0;

    SPI_NSS(0); 

    spi_write_byte(SPI_RDSR_CMD);   
    spi_status = spi_read_byte();

    SPI_NSS(1); 
    return spi_status;

}
//10. spi write status
void spi_write_status(uint8_t stas)
{
    SPI_NSS(0); 

    spi_write_byte(SPI_WRSP_CMD);
    spi_write_byte(stas);

    SPI_NSS(1); 
}
//////////////////////////以下为测试使用/////////////////////////////////
// spi chip test 0: success -1: failed, bytes num: 32768
int sram_23k256_test(void)
{
      int i,j;
        uint8_t temp;
        int DatAddr = 0;

        printf("spi testing %d....\r\n",systick_ms_counter);

        for(i = 0;i<128;i++)
        {
            for(j = 0;j<256;j++)  //写数据
            {
                spi_send_byte(DatAddr,j);
                DatAddr++;
            }
            for(j = 0;j<256;j++)  //读数据
            {
                DatAddr--;
                temp = spi_recv_byte(DatAddr);
                if(temp != (DatAddr%256)){
                    return -1;
                }
            }
            DatAddr += 256;
        }
        printf("spi test complete %d!\r\n",systick_ms_counter);
        return 0;
}
// spi sck 时序测试
void spi_sck_test(void)
{
      SPI_SCK(0);
        delay(10);
        SPI_SCK(1);
        delay(10);
}

1. 23K256.h

#ifndef __23k256_H
#define __23k256_H

#include "stm32f10x.h"

#define SPI_READ_CMD  0X03
#define SPI_WRITE_CMD 0x02
#define SPI_RDSR_CMD  0x05
#define SPI_WRSP_CMD  0x01

#define SPI_PAGES_MAX  (1024)      //页大小
#define SPI_BYTES_MAX  (32768)     //总字节个数

#define  SPI_MOSI(bitval)  GPIO_WriteBit(GPIOB,GPIO_Pin_15,(BitAction)bitval)                                                   
#define  SPI_SCK(bitval)   GPIO_WriteBit(GPIOB,GPIO_Pin_13,(BitAction)bitval)
#define  SPI_NSS(bitval)   GPIO_WriteBit(GPIOB,GPIO_Pin_12,(BitAction)bitval)
#define  SPI_MISO()          (GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_14)==RESET ? 0:1)


void spi_init(void);
uint8_t spi_recv_byte(uint16_t addr);
void spi_send_byte(uint16_t addr,uint8_t dat);

uint8_t spi_read_status(void);
void spi_write_status(uint8_t stas);
void spi_write_buff(uint8_t *pBuff,uint16_t WriteAddress,uint16_t BufferSize);
void spi_read_buff(uint8_t *pBuff,uint16_t ReadAddress,uint16_t BufferSize);


int sram_23k256_test(void);
void spi_sck_test(void);






#endif