(硬件)SPI --- 串行外设设备接口

最新推荐文章于 2024-05-17 08:16:22 发布
最新推荐文章于 2024-05-17 08:16:22 发布
阅读量468 收藏 1
点赞数
分类专栏： STM32单片机（HAL库） 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58575898/article/details/133895724
版权

一.SPI介绍

SPI：串行外设设备接口（Serial Peripheral Interface）,是一种高速的，全双工，同步的通信总线。

功能说明SPI总线IIC总线
通信方式同步 串行 全双工同步 串行 半双工
总线接口MOSI、MISO、SCL、CSSDA、SCL
拓扑结构一主多从/一主一从多主从
从机选择片选引脚选择SDA上设备地址片选
通信速率一般50MHz以下100kMHz、400kMHz、3.4MHz
数据格式8位/16位8位
传输顺序MSB/LSBMSB

SPI接口主要应用在存储芯片、AD转换器以及LCD中；

IIC采用电平协议，SPI采用边沿协议。 

 

二.SPI结构框图介绍

NSS一般用软件的，硬件的另有用处。

数据发送：主机模式

 帧格式：8bit/16bit；MSB在先/LSB在先;

数据接收：主机模式。 

SPI 的引脚信息 ：
MISO（ Master In / Slave Out ）主设备数据输入，从设备数据输出。
MOSI （ Master Out / Slave In ）主设备数据输出，从设备数据输入。
SCLK （ Serial Clock ）时钟信号，由主设备产生。
CS （ Chip Select ）从设备片选信号，由主设备产生。
SPI 的工作原理 ：
在主机和从机都有一个串行移位寄存器，主机通过向它的 SPI 串行寄存
器写入一个字节来发起一次传输。串行移位寄存器通过 MOSI 信号线将字节传送给从机，从机
也将自己的串行移位寄存器中的内容通过 MISO 信号线返回给主机。这样，两个移位寄存器中
的内容就被交换。外设的写操作和读操作是同步完成的。如果只是进行写操作，主机只需忽略
接收到的字节。反之，若主机要读取从机的一个字节，就必须发送一个空字节引发从机传输。
SPI 的传输方式 ：
SPI 总线具有三种传输方式：全双工、单工以及半双工传输方式。
全双工通信，就是在任何时刻，主机与从机之间都可以同时进行数据的发送和接收。
单工通信，就是在同一时刻，只有一个传输的方向，发送或者是接收。
半双工通信，就是在同一时刻，只能为一个方向传输数据。

 

三.SPI工作模式介绍

时钟极性（CPOL）：没有数据传输时时钟线的 空闲状态电平 。
                                0：SCK在空闲状态保持低电平；
                                1：SCK在空闲状态保持高电平。
时钟相位（CPHA）：时钟线在第几个时钟 边沿采样 数据 。
                             0：SCK的第一（奇数）边沿进行数据位采样，数据在第一个时钟边沿被锁存；
                             1：SCK的第二（偶数）边沿进行数据位采样，数据在第二个时钟边沿被锁存。

四.SPI相关寄存器介绍（F1/F4/F7）

寄存器名称作用
SPI_CR1SPI控制寄存器1用于配置SPI工作参数
SPI_SRSPI状态寄存器用于查询当前SPI传输状态（TXE、RXNE）
SPI_DRSPI数据寄存器用于存放待发送数据或接收数据，有两个缓冲区（TX/RX）

 当TXE位置为1时，表示数据已经全部发送出去；

当RXNE位置为1时，表示已经接收到数据。

 

五.SPI相关HAL库驱动介绍

驱动函数关联寄存器功能描述
__HAL_RCC_SPIx_CLK_ENABLE()RCC_APB2ENR使能SPIx时钟
HAL_SPI_Init()SPI_CR1初始化SPI
HAL_SPI_MspInit()初始化回调初始化SPI相关引脚
HAL_SPI_Transmit()SPI_DR/SPI_SRSPI发送
HAL_SPI_Receive()SPI_DR/SPI_SRSPI接收
HAL_SPI_TransmitReceive()SPI_DR/SPI_SRSPI接收发送
__HAL_SPI_ENABLE()SPI_CR1(SPE)使能SPI外设
__HAL_SPI_DISABLE()SPI_CR1(SPE)失能SPI外设

对于H7来说，还需要HAL_RCCEx_PeriphCLKConfig函数设置时钟源 

六.NOR FLASH介绍

<1>NOR FLASH介绍

FLASH 是常见的用于存储数据的半导体器件，它具有容量大、可重复擦写、按“扇区/块”擦除、掉电后数据可继续保存的特性。

常见的 FLASH 主要有 NOR FLASH 和 NAND FLASH 两种类型，NOR 和 NAND 是两种数字门电路，可以简单地认为FLASH 内部存储单元使用哪种门作存储单元就是哪类型的 FLASH。

FLASH物理特性：只能写0，不能写1，写1靠擦除。 

<2>NM25Q128简介

NM25Q128，串行闪存器件，属于NOR FLASH中的一种，容量为128Mb(16MByte)。擦写周期可达10W次，可以将数据保存达20年之久。

  • SPI数据传输时序：支持模式0（CPOL = 0,CPHA = 0）和模式3（CPOL = 1,CPHA = 1）；
  • 数据格式：数据长度8位大小，先发高位，再发地位。（MSB）;
  • 传输速度：支持标准模式104M bit/s。

 

CS 即片选信号输入，低电平有效；

DO 是 MISO 引脚，在 CLK 管脚 的下降沿输出数据；

WP 是写保护管脚，高电平可读可写，低电平仅仅可读；

DI 是 MOSI 引脚，主机发送的数据、地址和命令从 SI 引脚输入到芯片内部，在 CLK 管脚的上升沿捕获捕获数据；

CLK 是串行时钟引脚，为输入输出提供时钟脉冲；

HOLD 是保持管脚，低电平有效。

<3>NM25Q128存储结构

擦除可以是扇区、块、整个片；

写可以是页。 

地址范围：0x0~0xFFFFFF 

<4>NM25Q128常用指令

1.写使能 Write Enable(06H)

执行Page Program页写，Sector Erase扇区擦除，Block Erase块擦除，Chip Erase片擦除，Write Status Register写状态寄存器等指令前，需要写使能。 

2.读状态寄存器Read Status Reg1（05H） 

3.读时序 Read Data Bytes（03H） 

 3.页写时序 PageProgram (02H)

 页写命令最多可以向FLASH传输256个字节的数据。

4.扇区擦除时序 Sector Erase (20H)

 FLASH存储器的特性决定了它只能把原来“1”的数据位改写为“0”，而原来为“0”的数据位不能直接改写为“1”。

写入数据前，检查内存空间情况是否满足，不满足需擦除。

<5>NM25Q128读/擦除/写 步骤

1.读操作步骤

  1. 发送读命令（03H）:发送0x03读数据指令；
  2. 发送地址（24位）：地址范围：0x0~0xFFFFFF，分3次发送；
  3. 读取数据：发送孔子姐（0xFF）,读取数据，支持连续读。

2.擦除扇区步骤 

  1. 发送写使能命令（06H）:发送0x06，写使能命令；
  2. 等待空闲：等待NOR FLASH空闲；
  3. 发送擦除扇区命令（20H）:发送擦除扇区命令（0x20)；
  4. 发送地址（24位）：发送要擦除的字节地址，自动擦除该地址所在扇区；
  5. 等待空闲：等待擦除完成（等待空闲状态）。

3.写操作步骤（极简） 

  1. 擦除扇区（20H）:通过前面的擦除步骤实现；
  2. 发送写使能命令（06H）:发送0x06，写使能命令；
  3. 发送页写命令（02H）：发送页写命令后，一次最多写入256字节；
  4. 发送地址（24位）：发送要写入的地址；
  5. 发送数据：发送要写入的数据，一次最多写入256字节；
  6. 等待空闲：等待写入完成（等待空闲状态）。

七.NOR FLASH基本驱动步骤

<一>SPI配置步骤

  1. SPI工作参数配置初始化：工作模式、时钟特性、时钟相位等 --- HAL_SPI_Init;
  2. 使能SPI时钟和初始化相关引脚：GPIO模式设为复用推挽输出模式 --- HAL_SPI_MspInit;
  3. 使能SPI:__HAL_SPI_ENABLE;
  4. SPI传输数据：HAL_SPI_Transmit发送数据，HAL_SPI_Receive接收数据，HAL_SPI_TransmitReceive进行发送和接收；
  5. 设置SPI传输速度（可选）：操作SPI_CR1寄存器中的波特率控制位，设置之前要先失能SPI之后再使能。

<二>NM25Q128驱动步骤 

  1. 初始化片选引脚与SPI接口：相关GPIO初始化、SPI初始化（模式、位数、分频。MSB等）；
  2. NM25Q128读取：0x03指令+24位地址+读取数据；
  3. NM25Q128扇区擦除：0x06指令+等待空闲+0x20指令+24位地址+等待空闲；
  4. NM25Q128写入：擦除扇区（可选）+0x06指令+0x02指令+24位地址+写入数据+等待空闲。

 

八.代码

驱动NM25Q128实现读和写1字节数据。

spi.c

#include "./BSP/SPI/spi.h"

SPI_HandleTypeDef g_spi2_handler; /* SPI2句柄 */

/**
 * @brief       SPI初始化代码
 *   @note      主机模式,8位数据,禁止硬件片选
 * @param       无
 * @retval      无
 */
void spi2_init(void)
{
    SPI2_SPI_CLK_ENABLE(); /* SPI2时钟使能 */

    g_spi2_handler.Instance = SPI2_SPI;                                /* SPI2 */
    g_spi2_handler.Init.Mode = SPI_MODE_MASTER;                        /* 设置SPI工作模式，设置为主模式 */
    g_spi2_handler.Init.Direction = SPI_DIRECTION_2LINES;              /* 设置SPI单向或者双向的数据模式:SPI设置为双线模式 */
    g_spi2_handler.Init.DataSize = SPI_DATASIZE_8BIT;                  /* 设置SPI的数据大小:SPI发送接收8位帧结构 */
    g_spi2_handler.Init.CLKPolarity = SPI_POLARITY_HIGH;               /* 串行同步时钟的空闲状态为高电平 */
    g_spi2_handler.Init.CLKPhase = SPI_PHASE_2EDGE;                    /* 串行同步时钟的第二个跳变沿（上升或下降）数据被采样 */
    g_spi2_handler.Init.NSS = SPI_NSS_SOFT;                            /* NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制 */
    g_spi2_handler.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; /* 定义波特率预分频的值:波特率预分频值为256 */
    g_spi2_handler.Init.FirstBit = SPI_FIRSTBIT_MSB;                   /* 指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始 */
    g_spi2_handler.Init.TIMode = SPI_TIMODE_DISABLE;                   /* 关闭TI模式 */
    g_spi2_handler.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;   /* 关闭硬件CRC校验 */
    g_spi2_handler.Init.CRCPolynomial = 7;                             /* CRC值计算的多项式 */
    HAL_SPI_Init(&g_spi2_handler);                                     /* 初始化 */

    __HAL_SPI_ENABLE(&g_spi2_handler); /* 使能SPI2 */

    spi2_read_write_byte(0Xff); /* 启动传输, 实际上就是产生8个时钟脉冲, 达到清空DR的作用, 非必需 */
}

/**
 * @brief       SPI底层驱动，时钟使能，引脚配置
 *   @note      此函数会被HAL_SPI_Init()调用
 * @param       hspi:SPI句柄
 * @retval      无
 */
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
    GPIO_InitTypeDef gpio_init_struct;
    
    if (hspi->Instance == SPI2_SPI)
    {
        SPI2_SCK_GPIO_CLK_ENABLE();  /* SPI2_SCK脚时钟使能 */
        SPI2_MISO_GPIO_CLK_ENABLE(); /* SPI2_MISO脚时钟使能 */
        SPI2_MOSI_GPIO_CLK_ENABLE(); /* SPI2_MOSI脚时钟使能 */

        /* SCK引脚模式设置(复用输出) */
        gpio_init_struct.Pin = SPI2_SCK_GPIO_PIN;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        gpio_init_struct.Pull = GPIO_PULLUP;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(SPI2_SCK_GPIO_PORT, &gpio_init_struct);

        /* MISO引脚模式设置(复用输出) */
        gpio_init_struct.Pin = SPI2_MISO_GPIO_PIN;
        HAL_GPIO_Init(SPI2_MISO_GPIO_PORT, &gpio_init_struct);

        /* MOSI引脚模式设置(复用输出) */
        gpio_init_struct.Pin = SPI2_MOSI_GPIO_PIN;
        HAL_GPIO_Init(SPI2_MOSI_GPIO_PORT, &gpio_init_struct);
    }
}

/**
 * @brief       SPI2速度设置函数
 *   @note      SPI2时钟选择来自APB1, 即PCLK1, 为36Mhz
 *              SPI速度 = PCLK1 / 2^(speed + 1)
 * @param       speed   : SPI2时钟分频系数
                        取值为SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_2 256
 * @retval      无
 */
void spi2_set_speed(uint8_t speed)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(speed)); /* 判断有效性 */
    __HAL_SPI_DISABLE(&g_spi2_handler);             /* 关闭SPI */
    g_spi2_handler.Instance->CR1 &= 0XFFC7;         /* 位3-5清零，用来设置波特率 */
    g_spi2_handler.Instance->CR1 |= speed << 3;     /* 设置SPI速度 */
    __HAL_SPI_ENABLE(&g_spi2_handler);              /* 使能SPI */
}

/**
 * @brief       SPI2读写一个字节数据
 * @param       txdata  : 要发送的数据(1字节)
 * @retval      接收到的数据(1字节)
 */
uint8_t spi2_read_write_byte(uint8_t txdata)
{
    uint8_t rxdata;
    HAL_SPI_TransmitReceive(&g_spi2_handler, &txdata, &rxdata, 1, 1000);
    return rxdata; /* 返回收到的数据 */
}

spi.h

#ifndef __SPI_H
#define __SPI_H

#include "./SYSTEM/sys/sys.h"


/******************************************************************************************/
/* SPI2 引脚 定义 */

#define SPI2_SCK_GPIO_PORT              GPIOB
#define SPI2_SCK_GPIO_PIN               GPIO_PIN_13
#define SPI2_SCK_GPIO_CLK_ENABLE()      do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */

#define SPI2_MISO_GPIO_PORT             GPIOB
#define SPI2_MISO_GPIO_PIN              GPIO_PIN_14
#define SPI2_MISO_GPIO_CLK_ENABLE()     do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */

#define SPI2_MOSI_GPIO_PORT             GPIOB
#define SPI2_MOSI_GPIO_PIN              GPIO_PIN_15
#define SPI2_MOSI_GPIO_CLK_ENABLE()     do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */

/* SPI2相关定义 */
#define SPI2_SPI                        SPI2
#define SPI2_SPI_CLK_ENABLE()           do{ __HAL_RCC_SPI2_CLK_ENABLE(); }while(0)    /* SPI2时钟使能 */

/******************************************************************************************/


/* SPI总线速度设置 */
#define SPI_SPEED_2         0
#define SPI_SPEED_4         1
#define SPI_SPEED_8         2
#define SPI_SPEED_16        3
#define SPI_SPEED_32        4
#define SPI_SPEED_64        5
#define SPI_SPEED_128       6
#define SPI_SPEED_256       7


void spi2_init(void);
void spi2_set_speed(uint8_t speed);
uint8_t spi2_read_write_byte(uint8_t txdata);

#endif

norflash.c

#include "./BSP/SPI/spi.h"
#include "./SYSTEM/delay/delay.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/NORFLASH/norflash.h"


uint16_t g_norflash_type = NM25Q128;     /* 默认是NM25Q128 */

/**
 * @brief       初始化SPI NOR FLASH
 * @param       无
 * @retval      无
 */
void norflash_init(void)
{
    uint8_t temp;

    NORFLASH_CS_GPIO_CLK_ENABLE();      /* NORFLASH CS脚 时钟使能 */

    GPIO_InitTypeDef gpio_init_struct;
    gpio_init_struct.Pin = NORFLASH_CS_GPIO_PIN;
    gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;
    gpio_init_struct.Pull = GPIO_PULLUP;
    gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(NORFLASH_CS_GPIO_PORT, &gpio_init_struct); /* CS引脚模式设置(复用输出) */

    NORFLASH_CS(1);                     /* 取消片选 */

    spi2_init();                        /* 初始化SPI2 */
    spi2_set_speed(SPI_SPEED_2);        /* SPI2 切换到高速状态 18Mhz */
    
    g_norflash_type = norflash_read_id();   /* 读取FLASH ID. */
    
    if (g_norflash_type == W25Q256)     /* SPI FLASH为W25Q256, 必须使能4字节地址模式 */
    {
        temp = norflash_read_sr(3);     /* 读取状态寄存器3，判断地址模式 */

        if ((temp & 0X01) == 0)         /* 如果不是4字节地址模式,则进入4字节地址模式 */
        {
            norflash_write_enable();    /* 写使能 */
            temp |= 1 << 1;             /* ADP=1, 上电4位地址模式 */
            norflash_write_sr(3, temp); /* 写SR3 */
            
            NORFLASH_CS(0);
            spi2_read_write_byte(FLASH_Enable4ByteAddr);    /* 使能4字节地址指令 */
            NORFLASH_CS(1);
        }
    }

    //printf("ID:%x\r\n", g_norflash_type);
}

/**
 * @brief       等待空闲
 * @param       无
 * @retval      无
 */
static void norflash_wait_busy(void)
{
    while ((norflash_read_sr(1) & 0x01) == 0x01);   /* 等待BUSY位清空 */
}

/**
 * @brief       25QXX写使能
 *   @note      将S1寄存器的WEL置位
 * @param       无
 * @retval      无
 */
void norflash_write_enable(void)
{
    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_WriteEnable);   /* 发送写使能 */
    NORFLASH_CS(1);
}

/**
 * @brief       25QXX发送地址
 *   @note      根据芯片型号的不同, 发送24ibt / 32bit地址
 * @param       address : 要发送的地址
 * @retval      无
 */
static void norflash_send_address(uint32_t address)
{
    if (g_norflash_type == W25Q256) /*  只有W25Q256支持4字节地址模式 */
    {
        spi2_read_write_byte((uint8_t)((address)>>24)); /* 发送 bit31 ~ bit24 地址 */
    } 
    spi2_read_write_byte((uint8_t)((address)>>16));     /* 发送 bit23 ~ bit16 地址 */
    spi2_read_write_byte((uint8_t)((address)>>8));      /* 发送 bit15 ~ bit8  地址 */
    spi2_read_write_byte((uint8_t)address);             /* 发送 bit7  ~ bit0  地址 */
}

/**
 * @brief       读取25QXX的状态寄存器，25QXX一共有3个状态寄存器
 *   @note      状态寄存器1：
 *              BIT7  6   5   4   3   2   1   0
 *              SPR   RV  TB BP2 BP1 BP0 WEL BUSY
 *              SPR:默认0,状态寄存器保护位,配合WP使用
 *              TB,BP2,BP1,BP0:FLASH区域写保护设置
 *              WEL:写使能锁定
 *              BUSY:忙标记位(1,忙;0,空闲)
 *              默认:0x00
 *
 *              状态寄存器2：
 *              BIT7  6   5   4   3   2   1   0
 *              SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
 *
 *              状态寄存器3：
 *              BIT7      6    5    4   3   2   1   0
 *              HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
 *
 * @param       regno: 状态寄存器号，范围:1~3
 * @retval      状态寄存器值
 */
uint8_t norflash_read_sr(uint8_t regno)
{
    uint8_t byte = 0, command = 0;

    switch (regno)
    {
        case 1:
            command = FLASH_ReadStatusReg1;  /* 读状态寄存器1指令 */
            break;

        case 2:
            command = FLASH_ReadStatusReg2;  /* 读状态寄存器2指令 */
            break;

        case 3:
            command = FLASH_ReadStatusReg3;  /* 读状态寄存器3指令 */
            break;

        default:
            command = FLASH_ReadStatusReg1;
            break;
    }

    NORFLASH_CS(0);
    spi2_read_write_byte(command);      /* 发送读寄存器命令 */
    byte = spi2_read_write_byte(0Xff);  /* 读取一个字节 */
    NORFLASH_CS(1);
    
    return byte;
}

/**
 * @brief       写25QXX状态寄存器
 *   @note      寄存器说明见norflash_read_sr函数说明
 * @param       regno: 状态寄存器号，范围:1~3
 * @param       sr   : 要写入状态寄存器的值
 * @retval      无
 */
void norflash_write_sr(uint8_t regno, uint8_t sr)
{
    uint8_t command = 0;

    switch (regno)
    {
        case 1:
            command = FLASH_WriteStatusReg1;  /* 写状态寄存器1指令 */
            break;

        case 2:
            command = FLASH_WriteStatusReg2;  /* 写状态寄存器2指令 */
            break;

        case 3:
            command = FLASH_WriteStatusReg3;  /* 写状态寄存器3指令 */
            break;

        default:
            command = FLASH_WriteStatusReg1;
            break;
    }

    NORFLASH_CS(0);
    spi2_read_write_byte(command);  /* 发送读寄存器命令 */
    spi2_read_write_byte(sr);       /* 写入一个字节 */
    NORFLASH_CS(1);
}

/**
 * @brief       读取芯片ID
 * @param       无
 * @retval      FLASH芯片ID
 *   @note      芯片ID列表见: norflash.h, 芯片列表部分
 */
uint16_t norflash_read_id(void)
{
    uint16_t deviceid;

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ManufactDeviceID);   /* 发送读 ID 命令 */
    spi2_read_write_byte(0);    /* 写入一个字节 */
    spi2_read_write_byte(0);
    spi2_read_write_byte(0);
    deviceid = spi2_read_write_byte(0xFF) << 8;     /* 读取高8位字节 */
    deviceid |= spi2_read_write_byte(0xFF);         /* 读取低8位字节 */
    NORFLASH_CS(1);

    return deviceid;
}

/**
 * @brief       读取SPI FLASH
 *   @note      在指定地址开始读取指定长度的数据
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始读取的地址(最大32bit)
 * @param       datalen : 要读取的字节数(最大65535)
 * @retval      无
 */
void norflash_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t i;

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ReadData);       /* 发送读取命令 */
    norflash_send_address(addr);                /* 发送地址 */
    
    for(i=0;i<datalen;i++)
    {
        pbuf[i] = spi2_read_write_byte(0XFF);   /* 循环读取 */
    }
    
    NORFLASH_CS(1);
}

/**
 * @brief       SPI在一页(0~65535)内写入少于256个字节的数据
 *   @note      在指定地址开始写入最大256字节的数据
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
 * @retval      无
 */
static void norflash_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t i;

    norflash_write_enable();    /* 写使能 */

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_PageProgram);    /* 发送写页命令 */
    norflash_send_address(addr);                /* 发送地址 */

    for(i=0;i<datalen;i++)
    {
        spi2_read_write_byte(pbuf[i]);          /* 循环写入 */
    }
    
    NORFLASH_CS(1);
    norflash_wait_busy();       /* 等待写入结束 */
}

/**
 * @brief       无检验写SPI FLASH
 *   @note      必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
 *              具有自动换页功能
 *              在指定地址开始写入指定长度的数据,但是要确保地址不越界!
 *
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大65535)
 * @retval      无
 */
static void norflash_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint16_t pageremain;
    pageremain = 256 - addr % 256;  /* 单页剩余的字节数 */

    if (datalen <= pageremain)      /* 不大于256个字节 */
    {
        pageremain = datalen;
    }

    while (1)
    {
        /* 当写入字节比页内剩余地址还少的时候, 一次性写完
         * 当写入直接比页内剩余地址还多的时候, 先写完整个页内剩余地址, 然后根据剩余长度进行不同处理
         */
        norflash_write_page(pbuf, addr, pageremain);

        if (datalen == pageremain)   /* 写入结束了 */
        {
            break;
        }
        else     /* datalen > pageremain */
        {
            pbuf += pageremain;         /* pbuf指针地址偏移,前面已经写了pageremain字节 */
            addr += pageremain;         /* 写地址偏移,前面已经写了pageremain字节 */
            datalen -= pageremain;      /* 写入总长度减去已经写入了的字节数 */

            if (datalen > 256)          /* 剩余数据还大于一页,可以一次写一页 */
            {
                pageremain = 256;       /* 一次可以写入256个字节 */
            }
            else     /* 剩余数据小于一页,可以一次写完 */
            {
                pageremain = datalen;   /* 不够256个字节了 */
            }
        }
    }
}

/**
 * @brief       写SPI FLASH
 *   @note      在指定地址开始写入指定长度的数据 , 该函数带擦除操作!
 *              SPI FLASH 一般是: 256个字节为一个Page, 4Kbytes为一个Sector, 16个扇区为1个Block
 *              擦除的最小单位为Sector.
 *
 * @param       pbuf    : 数据存储区
 * @param       addr    : 开始写入的地址(最大32bit)
 * @param       datalen : 要写入的字节数(最大65535)
 * @retval      无
 */
uint8_t g_norflash_buf[4096];   /* 扇区缓存 */

void norflash_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
{
    uint32_t secpos;
    uint16_t secoff;
    uint16_t secremain;
    uint16_t i;
    uint8_t *norflash_buf;

    norflash_buf = g_norflash_buf;
    secpos = addr / 4096;       /* 扇区地址 */
    secoff = addr % 4096;       /* 在扇区内的偏移 */
    secremain = 4096 - secoff;  /* 扇区剩余空间大小 */

    //printf("ad:%X,nb:%X\r\n", addr, datalen); /* 测试用 */
    if (datalen <= secremain)
    {
        secremain = datalen;    /* 不大于4096个字节 */
    }

    while (1)
    {
        norflash_read(norflash_buf, secpos * 4096, 4096);   /* 读出整个扇区的内容 */

        for (i = 0; i < secremain; i++)   /* 校验数据 */
        {
            if (norflash_buf[secoff + i] != 0XFF)
            {
                break;      /* 需要擦除, 直接退出for循环 */
            }
        }

        if (i < secremain)   /* 需要擦除 */
        {
            norflash_erase_sector(secpos);  /* 擦除这个扇区 */

            for (i = 0; i < secremain; i++)   /* 复制 */
            {
                norflash_buf[i + secoff] = pbuf[i];
            }

            norflash_write_nocheck(norflash_buf, secpos * 4096, 4096);  /* 写入整个扇区 */
        }
        else        /* 写已经擦除了的,直接写入扇区剩余区间. */
        {
            norflash_write_nocheck(pbuf, addr, secremain);  /* 直接写扇区 */
        }

        if (datalen == secremain)
        {
            break;  /* 写入结束了 */
        }
        else        /* 写入未结束 */
        {
            secpos++;               /* 扇区地址增1 */
            secoff = 0;             /* 偏移位置为0 */

            pbuf += secremain;      /* 指针偏移 */
            addr += secremain;      /* 写地址偏移 */
            datalen -= secremain;   /* 字节数递减 */

            if (datalen > 4096)
            {
                secremain = 4096;   /* 下一个扇区还是写不完 */
            }
            else
            {
                secremain = datalen;/* 下一个扇区可以写完了 */
            }
        }
    }
}

/**
 * @brief       擦除整个芯片
 *   @note      等待时间超长...
 * @param       无
 * @retval      无
 */
void norflash_erase_chip(void)
{
    norflash_write_enable();    /* 写使能 */
    norflash_wait_busy();       /* 等待空闲 */
    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_ChipErase);  /* 发送读寄存器命令 */ 
    NORFLASH_CS(1);
    norflash_wait_busy();       /* 等待芯片擦除结束 */
}

/**
 * @brief       擦除一个扇区
 *   @note      注意,这里是扇区地址,不是字节地址!!
 *              擦除一个扇区的最少时间:150ms
 *
 * @param       saddr : 扇区地址 根据实际容量设置
 * @retval      无
 */
void norflash_erase_sector(uint32_t saddr)
{
    //printf("fe:%x\r\n", saddr);   /* 监视falsh擦除情况,测试用 */
    saddr *= 4096;
    norflash_write_enable();        /* 写使能 */
    norflash_wait_busy();           /* 等待空闲 */

    NORFLASH_CS(0);
    spi2_read_write_byte(FLASH_SectorErase);    /* 发送写页命令 */
    norflash_send_address(saddr);   /* 发送地址 */
    NORFLASH_CS(1);
    norflash_wait_busy();           /* 等待扇区擦除完成 */
}

norflash.h

#ifndef __norflash_H
#define __norflash_H

#include "./SYSTEM/sys/sys.h"


/******************************************************************************************/
/* NORFLASH 片选 引脚 定义 */

#define NORFLASH_CS_GPIO_PORT           GPIOB
#define NORFLASH_CS_GPIO_PIN            GPIO_PIN_12
#define NORFLASH_CS_GPIO_CLK_ENABLE()   do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)   /* PB口时钟使能 */

/******************************************************************************************/

/* NORFLASH 片选信号 */
#define NORFLASH_CS(x)      do{ x ? \
                                  HAL_GPIO_WritePin(NORFLASH_CS_GPIO_PORT, NORFLASH_CS_GPIO_PIN, GPIO_PIN_SET) : \
                                  HAL_GPIO_WritePin(NORFLASH_CS_GPIO_PORT, NORFLASH_CS_GPIO_PIN, GPIO_PIN_RESET); \
                            }while(0)

/* FLASH芯片列表 */
#define W25Q80      0XEF13          /* W25Q80   芯片ID */
#define W25Q16      0XEF14          /* W25Q16   芯片ID */
#define W25Q32      0XEF15          /* W25Q32   芯片ID */
#define W25Q64      0XEF16          /* W25Q64   芯片ID */
#define W25Q128     0XEF17          /* W25Q128  芯片ID */
#define W25Q256     0XEF18          /* W25Q256  芯片ID */
#define BY25Q64     0X6816          /* BY25Q64  芯片ID */
#define BY25Q128    0X6817          /* BY25Q128 芯片ID */
#define NM25Q64     0X5216          /* NM25Q64  芯片ID */
#define NM25Q128    0X5217          /* NM25Q128 芯片ID */

extern uint16_t norflash_TYPE;      /* 定义FLASH芯片型号 */
 
/* 指令表 */
#define FLASH_WriteEnable           0x06 
#define FLASH_WriteDisable          0x04 
#define FLASH_ReadStatusReg1        0x05 
#define FLASH_ReadStatusReg2        0x35 
#define FLASH_ReadStatusReg3        0x15 
#define FLASH_WriteStatusReg1       0x01 
#define FLASH_WriteStatusReg2       0x31 
#define FLASH_WriteStatusReg3       0x11 
#define FLASH_ReadData              0x03 
#define FLASH_FastReadData          0x0B 
#define FLASH_FastReadDual          0x3B 
#define FLASH_FastReadQuad          0xEB  
#define FLASH_PageProgram           0x02 
#define FLASH_PageProgramQuad       0x32 
#define FLASH_BlockErase            0xD8 
#define FLASH_SectorErase           0x20 
#define FLASH_ChipErase             0xC7 
#define FLASH_PowerDown             0xB9 
#define FLASH_ReleasePowerDown      0xAB 
#define FLASH_DeviceID              0xAB 
#define FLASH_ManufactDeviceID      0x90 
#define FLASH_JedecDeviceID         0x9F 
#define FLASH_Enable4ByteAddr       0xB7
#define FLASH_Exit4ByteAddr         0xE9
#define FLASH_SetReadParam          0xC0 
#define FLASH_EnterQPIMode          0x38
#define FLASH_ExitQPIMode           0xFF

/* 静态函数 */
static void norflash_wait_busy(void);               /* 等待空闲 */
static void norflash_send_address(uint32_t address);/* 发送地址 */
static void norflash_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入page */
static void norflash_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen); /* 写flash,不带擦除 */

/* 普通函数 */
void norflash_init(void);                   /* 初始化25QXX */
uint16_t norflash_read_id(void);            /* 读取FLASH ID */
void norflash_write_enable(void);           /* 写使能 */
uint8_t norflash_read_sr(uint8_t regno);    /* 读取状态寄存器 */
void norflash_write_sr(uint8_t regno,uint8_t sr);   /* 写状态寄存器 */

void norflash_erase_chip(void);             /* 整片擦除 */
void norflash_erase_sector(uint32_t saddr); /* 扇区擦除 */
void norflash_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen);     /* 读取flash */
void norflash_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    /* 写入flash */

#endif

main.c

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./USMART/usmart.h"
#include "./BSP/LED/led.h"
#include "./BSP/LCD/lcd.h"
#include "./BSP/KEY/key.h"
#include "./BSP/NORFLASH/norflash.h"

/* 要写入到FLASH的字符串数组 */
const uint8_t g_text_buf[] = {"STM32 SPI TEST"};

#define TEXT_SIZE sizeof(g_text_buf) /* TEXT字符串长度 */

int main(void)
{
    uint8_t key;
    uint16_t i = 0;
    uint8_t datatemp[TEXT_SIZE];
    uint32_t flashsize;
    uint16_t id = 0;

    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
    delay_init(72);                     /* 延时初始化 */
    usart_init(115200);                 /* 串口初始化为115200 */
    usmart_dev.init(72);                /* 初始化USMART */
    led_init();                         /* 初始化LED */
    lcd_init();                         /* 初始化LCD */
    key_init();                         /* 初始化按键 */
    norflash_init();                    /* 初始化NORFLASH */

    lcd_show_string(30,  50, 200, 16, 16, "STM32", RED);
    lcd_show_string(30,  70, 200, 16, 16, "SPI TEST", RED);
    lcd_show_string(30,  90, 200, 16, 16, "ATOM@ALIENTEK", RED);
    lcd_show_string(30, 110, 200, 16, 16, "KEY1:Write  KEY0:Read", RED); /* 显示提示信息 */

    id = norflash_read_id(); /* 读取FLASH ID */

    while ((id == 0) || (id == 0XFFFF)) /* 检测不到FLASH芯片 */
    {
        lcd_show_string(30, 130, 200, 16, 16, "FLASH Check Failed!", RED);
        delay_ms(500);
        lcd_show_string(30, 130, 200, 16, 16, "Please Check!      ", RED);
        delay_ms(500);
        LED0_TOGGLE(); /* LED0闪烁 */
    }

    lcd_show_string(30, 130, 200, 16, 16, "SPI FLASH Ready!", BLUE);
    flashsize = 16 * 1024 * 1024; /* FLASH 大小为16M字节 */

    while (1)
    {
        key = key_scan(0);

        if (key == KEY1_PRES) /* KEY1按下,写入 */
        {
            lcd_fill(0, 150, 239, 319, WHITE); /* 清除半屏 */
            lcd_show_string(30, 150, 200, 16, 16, "Start Write FLASH....", BLUE);
            sprintf((char *)datatemp, "%s%d", (char *)g_text_buf, i);
            norflash_write((uint8_t *)datatemp, flashsize - 100, TEXT_SIZE);      /* 从倒数第100个地址处开始,写入SIZE长度的数据 */
            lcd_show_string(30, 150, 200, 16, 16, "FLASH Write Finished!", BLUE); /* 提示传送完成 */
        }

        if (key == KEY0_PRES) /* KEY0按下,读取字符串并显示 */
        {
            lcd_show_string(30, 150, 200, 16, 16, "Start Read FLASH... . ", BLUE);
            norflash_read(datatemp, flashsize - 100, TEXT_SIZE);                   /* 从倒数第100个地址处开始,读出SIZE个字节 */
            lcd_show_string(30, 150, 200, 16, 16, "The Data Readed Is:   ", BLUE); /* 提示传送完成 */
            lcd_show_string(30, 170, 200, 16, 16, (char *)datatemp, BLUE);         /* 显示读到的字符串 */
        }

        i++;

        if (i == 20)
        {
            LED0_TOGGLE(); /* LED0闪烁 */
            i = 0;
        }

        delay_ms(10);
    }
}

逃与桃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【STM32学习】——SPI通信协议&SPI时序&W25Q64存储芯片&软件SPI读写
weixin_51658186的博客
09-07 3239
声明：学习笔记来自江科大自化协B站教程，仅供学习交流！！对于SPI通信的学习和I2C一样，分为软件模拟实现和硬件配置实现读写W25Q64 Flash存储器！SPI传输数据的速度更快，协议没有严格规定最大传输速度，取决于芯片厂商需求；SPI的设计比较简单粗暴，实现的功能没有I2C多，比较简单；SPI硬件开销比较大，通信线的个数较多，且通信过程经常有资源浪费的现象——“富家子弟，有钱任性”，只在乎任务快速完成！
Arduino-SPI:Arduino的串行外设接口（SPI）库
05-12
Arduino的SPI 串行外围设备接口库是总线管理器和设备驱动程序支持的抽象接口。 该库包含使用Ardino-GPIO的硬件资源（AVR SPI和USI）和软件的总线管理器实现。 该库的设计允许多个总线管理器同时具有硬件和软件，并且...
（stm32）通信接口-USART
myz1016的博客
05-26 2380
SPI：时钟SCL（Serial Clock） 、 主机输出数据脚MOSI（Master Output Slave Input）、主机输入数据脚MISO（Master Input Slave Output） 、片选CS（Chip Select）用于指定通讯对象。一般有两根数据线，发送、接收是分开的，使用时互不影响，例如：USART 、 SPI。半双工：一般只有一个数据线，例如I2C、CAN、USB，差分数据线是正负线组成一根数据线。多设备：中间可以挂载多设备，比点对点多一个寻址的过程。
SPI协议详解（图文并茂+超详细）(1)
最新发布
2401_85015332的博客
05-17 789
综上几种情况，下图总结了所有时钟配置组合，并突出显示了实际采样数据的时刻；其中黑色线为采样数据的时刻；蓝色线为SCK时钟信号；具体如下图所示；
SPI接口详解
留小乙的博客
09-25 2万+
一、SPI接口简介 SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。 SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。 SPI接口框图： SPI内部结构简明图： SPI接口一般使用4条线通信： MI
SPI通信协议原理及硬件
Erebus145的博客
05-24 4547
学习笔记。一篇关于SPI通信协议的笔记整理，记录了SPI的原理、硬件连接、工作模式。能较全面的了解掌握SPI相关知识
SPI协议详解(Standard SPI、Dual SPI和Queued SPI)
热门推荐
weixin_42031299的博客
02-16 3万+
(1)通常我们说的SPI就是Standard SPI，有4根信号线，分别为CLK、CS、MOSI和MISO，也就是上面介绍的SPI协议；(2)Dual SPI：只是针对SPI Flash而言，不是针对所有SPI外设。对于SPI Flash，全双工并不常用，因此扩展了mosi和miso的用法，让它们工作在半双工，用以加倍数据传输。
SPI通讯简介
m0_74936872的博客
09-27 807
SPI是串行外设接口（Serial Peripheral Interface）的缩写，是美国摩托罗拉公司（Motorola最先推出的一种同步串行传输规范是一种单片机外设芯片串行扩展接口，是一种高速、全双工、同步的串行通信总线SPI有主、从两种模式，通常由一个主模块和一个或多个从模块组成（SPI不支持多主机），主模块选择一个从模块进行同步通信，从而完成数据的交换。SPI通信原理很简单，需要至少4根信号线，单向传输是3根线；
电信设备-一种基于SPI串行外设接口协议实现板间通信的系统.zip
09-19
标题中的“电信设备-一种基于SPI串行外设接口协议实现板间通信的系统”指出，这个主题聚焦于电信设备间通信的一种实现方式，即使用SPI（Serial Peripheral Interface）串行外设接口协议。SPI是一种广泛应用的同步...
stm8-硬件SPI-SX1278
10-30
硬件SPI是STM8内建的一种高速串行通信接口，用于与外部设备进行数据交换。 在描述中提到的“控制断码屏”，断码屏通常指的是带有多个独立段的LED显示器，每个段可以独立显示数字或字母。这种类型的显示屏常用于制作...
STM32-SPI-FLASH.zip
04-11
SPI（Serial Peripheral Interface）是一种同步串行通信协议，常用于连接低速外设，如Flash存储器、传感器等。SPI通信通常包括四个信号线：主设备输出/从设备输入（MOSI）、主设备输入/从设备输出（MISO）、串行时钟...
『FPGA通信接口』串行通信接口-SPI
04-16
SPI（Serial Peripheral Interface）是一种全双工、同步的串行通信协议，广泛应用于微控制器、数字信号处理器（DSP）、FPGA等系统中的外围设备通信。它由四个基本信号线组成：主设备输入/从设备输出（MISO）、主设备...
硬件spi
2201_75459371的博客
01-30 868
数据沿着地址总线写入到TDR上，若移位寄存器中的数据为空，{则数据从TDR移入移位寄存器（此时转入时刻置内部状态寄存器的TXE为1，表示发送寄存器为空，当我们检测到发送寄存器TDR为空时，总线上的数据自动转入到TDR上等候）}{移位寄存器上如果检测到数据到达，会自动产生时钟，与从机进行数据交换}{移位寄存器在与从机进行数据交换，交换完成的数据通过移位寄存器整体移入到RDR（此时状态寄存器的RXNE为1表示接受寄存器非空）中再传输到地址总线上。
【硬件】硬件基础小知识 之 SPI总线 (简洁要点)
YoYo的桃子树
06-17 5654
1. 引言 SPI : serial perripheral interface 串行外围设备接口 SPI总线是硬件上用的比较多的一种串行总线，高速传输，无应答无校验。 这里简单记录一下SPI总线的一些要点。 太基本的概要、历史等都略过。 2. 引脚说明 SCK ：serial clock 时钟 SS/CS：slave select / chip select 片选 SDI：serial data input SDO：serial data output MOSI：master output s
【硬件外设使用】——SPI
咸鱼菌
04-18 2594
SPI用法
STM32开发项目：硬件SPI的配置与使用
u013441358的专栏
05-06 1万+
项目背景 SPI 协议是由摩托罗拉公司提出的通讯协议(Serial Peripheral Interface)，即串行外围设 备接口，是一种高速全双工的通信总线。它被广泛地使用在 ADC、LCD 等设备与 MCU 间， 要求通讯速率较高的场合。与I2C通讯不同，应用SPI接口的器件很多都对通讯速率有一定的要求，使用软件模拟SPI通讯有两个主要的缺点：1.增大MCU的负载，尤其是在大量数据高频收发时...
SPI接口简介
weixin_69665239的博客
11-22 1757
串行外设接口(SPI)是微控制器和外围IC（如传感器、ADC、DAC、移位寄存器、SRAM等）之间使用最广泛的接口之一。本文先简要说明SPI接口，然后介绍ADI公司支持SPI的模拟开关与多路转换器，以及它们如何帮助减少系统电路板设计中的数字GPIO数量。SPI是一种同步、全双工、主从式接口。来自主机或从机的数据在时钟上升沿或下降沿同步。主机和从机可以同时传输数据。SPI接口可以是3线式或4线式。本文重点介绍常用的4线SPI接口。4线SPI器件有四个信号： 􀁦 时钟(SPI CLK, SCLK) 􀁦 片选
IIC和SPI简介
WuYujun's blog
04-12 1万+
一、IIC介绍 IIC 即Inter-Integrated Circuit(集成电路总线），这种总线类型是由飞利浦半导体公司在八十年代初设计出来的一种简单、双向、二线制、同步串行总线，主要是用来连接整体电路(ICS) ，IIC是一种多向控制总线，也就是说多个芯片可以连接到同一总线结构下，同时每个芯片都可以作为实时数据传输的控制源。这种方式简化了信号传输总线接口。 ...
学习笔记3 串行通讯详解（SCI、SPI、I2C）
freedom_qqcom的博客
05-20 1万+
目录前言1. 常见的几种串行通讯及区别什么是UART？什么是RS232/RS485? 前言 在调试通信的这段时间里，自己接触到了很多有关通信的专有名词，SCI，SPI，I2C，UART，CAN，RS232，RS485等等。自己在项目中使用TMS320F280049对SCI，I2C，CAN进行了通讯调试，包括底层配置，应用函数编写及通讯测试，最后都成功的实现了通讯。但是回过头来却对一些概念理解的不够透彻。因此又查了很多资料来理解他们的概念和其中的区别，这节我们只来理解串行通讯，并行通讯还没有研究。 1. 常见
TMS320F28x DSP串行外设接口（SPI）详解
“DSP原理与实践-基于TMS320F28x系列：第9章 串行外设接口（SPI）.ppt” 本文档详细介绍了TMS320F28x系列DSP中的串行外设接口（SPI）模块，主要涵盖SPI的基本概念、结构、特点、操作方式、中断、数据格式、波特率...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值