Clion开发Stm32之存储模块(W25Q64)驱动编写

前言

涵盖之前文章:

  1. Clion开发STM32之HAL库SPI封装(基础库)

W25Q64驱动

头文件

#ifndef F1XX_TEMPLATE_MODULE_W25Q64_H
#define F1XX_TEMPLATE_MODULE_W25Q64_H

#include "sys_core.h"
/* Private typedef -----------------------------------------------------------*/
//#define  sFLASH_ID                       0xEF3015     //W25X16
//#define  sFLASH_ID                       0xEF4015	    //W25Q16
#define  sFLASH_ID                        0XEF4017     //W25Q64
//#define  sFLASH_ID                       0XEF4018    //W25Q128
//#define SPI_FLASH_PageSize            4096
#define SPI_FLASH_PageSize              256
#define SPI_FLASH_PerWritePageSize      256

/* Private define ------------------------------------------------------------*/
/*命令定义-开头*******************************/
#define W25X_WriteEnable              0x06
#define W25X_WriteDisable              0x04
#define W25X_ReadStatusReg            0x05
#define W25X_WriteStatusReg            0x01
#define W25X_ReadData                    0x03
#define W25X_FastReadData              0x0B
#define W25X_FastReadDual              0x3B
#define W25X_PageProgram              0x02
#define W25X_BlockErase                  0xD8
#define W25X_SectorErase              0x20
#define W25X_ChipErase                  0xC7
#define W25X_PowerDown                  0xB9
#define W25X_ReleasePowerDown        0xAB
#define W25X_DeviceID                    0xAB
#define W25X_ManufactDeviceID    0x90
#define W25X_JedecDeviceID            0x9F
#define WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
#define Dummy_Byte                0xFF
/*等待超时时间*/
#define SPIT_FLAG_TIMEOUT         ((uint32_t)0x5000)
#define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))

/**
 * @memberof driver_init 驱动初始化
 * @memberof cs_low 使能低
 * @memberof cs_high 使能高
 * @memberof send_and_rec 发送并接收
 */
typedef struct {
    void (*driver_init)(void);

    void (*cs_low)(void);

    void (*cs_high)(void);

    uint8_t (*send_and_rec)(uint8_t dat);


} W25Q64_cnf_t;

void W25Q64_cnf_set(W25Q64_cnf_t *cnf);

bool W25Q64_Init(void);

void SPI_FLASH_SectorErase(uint32_t SectorAddr);

void SPI_FLASH_BulkErase(void);

void SPI_FLASH_PageWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);

void SPI_FLASH_BufferWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);

void SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);

uint32_t SPI_FLASH_ReadID(void);

uint32_t SPI_FLASH_ReadDeviceID(void);

void SPI_FLASH_StartReadSequence(uint32_t ReadAddr);

void SPI_Flash_PowerDown(void);

void SPI_Flash_WAKEUP(void);

uint8_t SPI_FLASH_ReadByte(void);

uint8_t SPI_FLASH_SendByte(uint8_t byte);

void SPI_FLASH_WriteEnable(void);

void SPI_FLASH_WaitForWriteEnd(void);

uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);

#endif //F1XX_TEMPLATE_MODULE_W25Q64_H

源文件

#include "w25q64/module_w25q64.h"

#define DBG_ENABLE
#define DBG_SECTION_NAME "w25q64"
#define DBG_LEVEL DBG_LOG // DBG_LOG DBG_INFO DBG_WARNING DBG_ERROR

#include "sys_dbg.h"

static W25Q64_cnf_t *cnf_ptr = NULL;
#define SPI_FLASH_CS_LOW cnf_ptr->cs_low
#define SPI_FLASH_CS_HIGH cnf_ptr->cs_high
static volatile uint32_t SPITimeout = SPIT_LONG_TIMEOUT;

void W25Q64_cnf_set(W25Q64_cnf_t *cnf) {
    cnf_ptr = cnf;
}

bool W25Q64_Init(void) {
    if (cnf_ptr == NULL) return false;
    cnf_ptr->driver_init();/*驱动初始化*/
    SPI_Flash_WAKEUP();/*唤醒*/
    SPI_FLASH_ReadDeviceID();
    if (SPI_FLASH_ReadID() == sFLASH_ID) {
        return true;
    }
    return false;
}


/**
 * @brief  擦除FLASH扇区
 * @param  SectorAddr：要擦除的扇区地址
 * @retval 无
 */
void SPI_FLASH_SectorErase(uint32_t SectorAddr) {
    /* 发送FLASH写使能命令 */
    SPI_FLASH_WriteEnable();
    SPI_FLASH_WaitForWriteEnd();
    /* 擦除扇区 */
    /* 选择FLASH: CS低电平 */
    SPI_FLASH_CS_LOW();
    /* 发送扇区擦除指令*/
    SPI_FLASH_SendByte(W25X_SectorErase);
    /*发送擦除扇区地址的高位*/
    SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
    /* 发送擦除扇区地址的中位 */
    SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
    /* 发送擦除扇区地址的低位 */
    SPI_FLASH_SendByte(SectorAddr & 0xFF);
    /* 停止信号 FLASH: CS 高电平 */
    SPI_FLASH_CS_HIGH();
    /* 等待擦除完毕*/
    SPI_FLASH_WaitForWriteEnd();
}


/**
 * @brief  擦除FLASH扇区，整片擦除
 * @param  无
 * @retval 无
 */
void SPI_FLASH_BulkErase(void) {
    /* 发送FLASH写使能命令 */
    SPI_FLASH_WriteEnable();

    /* 整块 Erase */
    /* 选择FLASH: CS低电平 */
    SPI_FLASH_CS_LOW();
    /* 发送整块擦除指令*/
    SPI_FLASH_SendByte(W25X_ChipErase);
    /* 停止信号 FLASH: CS 高电平 */
    SPI_FLASH_CS_HIGH();

    /* 等待擦除完毕*/
    SPI_FLASH_WaitForWriteEnd();
}

/**
 * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
 * @param	pBuffer，要写入数据的指针
 * @param WriteAddr，写入地址
 * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
 * @retval 无
 */
void SPI_FLASH_PageWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) {
    /* 发送FLASH写使能命令 */
    SPI_FLASH_WriteEnable();

    /* 选择FLASH: CS低电平 */
    SPI_FLASH_CS_LOW();
    /* 写页写指令*/
    SPI_FLASH_SendByte(W25X_PageProgram);
    /*发送写地址的高位*/
    SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
    /*发送写地址的中位*/
    SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
    /*发送写地址的低位*/
    SPI_FLASH_SendByte(WriteAddr & 0xFF);

    if (NumByteToWrite > SPI_FLASH_PerWritePageSize) {
        NumByteToWrite = SPI_FLASH_PerWritePageSize;
        LOG_E("SPI_FLASH_PageWrite too large!");
    }

    /* 写入数据*/
    while (NumByteToWrite--) {
        /* 发送当前要写入的字节数据 */
        SPI_FLASH_SendByte(*pBuffer);
        /* 指向下一字节数据 */
        pBuffer++;
    }

    /* 停止信号 FLASH: CS 高电平 */
    SPI_FLASH_CS_HIGH();

    /* 等待写入完毕*/
    SPI_FLASH_WaitForWriteEnd();
}


/**
 * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
 * @param	pBuffer，要写入数据的指针
 * @param  WriteAddr，写入地址
 * @param  NumByteToWrite，写入数据长度
 * @retval 无
 */
void SPI_FLASH_BufferWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) {
    uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;

    /*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
    Addr = WriteAddr % SPI_FLASH_PageSize;

    /*差count个数据值，刚好可以对齐到页地址*/
    count = SPI_FLASH_PageSize - Addr;
    /*计算出要写多少整数页*/
    NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
    /*mod运算求余，计算出剩余不满一页的字节数*/
    NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

    /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
    if (Addr == 0) {
        /* NumByteToWrite < SPI_FLASH_PageSize */
        if (NumOfPage == 0) {
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
        } else /* NumByteToWrite > SPI_FLASH_PageSize */
        {
            /*先把整数页都写了*/
            while (NumOfPage--) {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
                WriteAddr += SPI_FLASH_PageSize;
                pBuffer += SPI_FLASH_PageSize;
            }

            /*若有多余的不满一页的数据，把它写完*/
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
        }
    }
        /* 若地址与 SPI_FLASH_PageSize 不对齐  */
    else {
        /* NumByteToWrite < SPI_FLASH_PageSize */
        if (NumOfPage == 0) {
            /*当前页剩余的count个位置比NumOfSingle小，写不完*/
            if (NumOfSingle > count) {
                temp = NumOfSingle - count;

                /*先写满当前页*/
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
                WriteAddr += count;
                pBuffer += count;

                /*再写剩余的数据*/
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
            } else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
            }
        } else /* NumByteToWrite > SPI_FLASH_PageSize */
        {
            /*地址不对齐多出的count分开处理，不加入这个运算*/
            NumByteToWrite -= count;
            NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
            NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

            SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
            WriteAddr += count;
            pBuffer += count;

            /*把整数页都写了*/
            while (NumOfPage--) {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
                WriteAddr += SPI_FLASH_PageSize;
                pBuffer += SPI_FLASH_PageSize;
            }
            /*若有多余的不满一页的数据，把它写完*/
            if (NumOfSingle != 0) {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
            }
        }
    }
}

/**
 * @brief  读取FLASH数据
 * @param 	pBuffer，存储读出数据的指针
 * @param   ReadAddr，读取地址
 * @param   NumByteToRead，读取数据长度
 * @retval 无
 */
void SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead) {
    /* 选择FLASH: CS低电平 */
    SPI_FLASH_CS_LOW();

    /* 发送 读 指令 */
    SPI_FLASH_SendByte(W25X_ReadData);

    /* 发送 读 地址高位 */
    SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
    /* 发送 读 地址中位 */
    SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
    /* 发送 读 地址低位 */
    SPI_FLASH_SendByte(ReadAddr & 0xFF);

    /* 读取数据 */
    while (NumByteToRead--) {
        /* 读取一个字节*/
        *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
        /* 指向下一个字节缓冲区 */
        pBuffer++;
    }

    /* 停止信号 FLASH: CS 高电平 */
    SPI_FLASH_CS_HIGH();
}


/**
 * @brief  读取FLASH ID
 * @param 	无
 * @retval FLASH ID
 */
uint32_t SPI_FLASH_ReadID(void) {
    uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;

    /* 开始通讯：CS低电平 */
    SPI_FLASH_CS_LOW();

    /* 发送JEDEC指令，读取ID */
    SPI_FLASH_SendByte(W25X_JedecDeviceID);

    /* 读取一个字节数据 */
    Temp0 = SPI_FLASH_SendByte(Dummy_Byte);

    /* 读取一个字节数据 */
    Temp1 = SPI_FLASH_SendByte(Dummy_Byte);

    /* 读取一个字节数据 */
    Temp2 = SPI_FLASH_SendByte(Dummy_Byte);

    /* 停止通讯：CS高电平 */
    SPI_FLASH_CS_HIGH();

    /*把数据组合起来，作为函数的返回值*/
    Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;

    return Temp;
}

/**
 * @brief  读取FLASH Device ID
 * @param 	无
 * @retval FLASH Device ID
 */
uint32_t SPI_FLASH_ReadDeviceID(void) {
    uint32_t Temp = 0;

    /* Select the FLASH: Chip Select low */
    SPI_FLASH_CS_LOW();

    /* Send "RDID " instruction */
    SPI_FLASH_SendByte(W25X_DeviceID);
    SPI_FLASH_SendByte(Dummy_Byte);
    SPI_FLASH_SendByte(Dummy_Byte);
    SPI_FLASH_SendByte(Dummy_Byte);

    /* Read a byte from the FLASH */
    Temp = SPI_FLASH_SendByte(Dummy_Byte);

    /* Deselect the FLASH: Chip Select high */
    SPI_FLASH_CS_HIGH();

    return Temp;
}

/*******************************************************************************
* Function Name  : SPI_FLASH_StartReadSequence
* Description    : Initiates a read data byte (READ) sequence from the Flash.
*                  This is done by driving the /CS line low to select the device,
*                  then the READ instruction is transmitted followed by 3 bytes
*                  address. This function exit and keep the /CS line low, so the
*                  Flash still being selected. With this technique the whole
*                  content of the Flash is read with a single READ instruction.
* Input          : - ReadAddr : FLASH's internal address to read from.
* Output         : None
* Return         : None
*******************************************************************************/
void SPI_FLASH_StartReadSequence(uint32_t ReadAddr) {
    /* Select the FLASH: Chip Select low */
    SPI_FLASH_CS_LOW();

    /* Send "Read from Memory " instruction */
    SPI_FLASH_SendByte(W25X_ReadData);

    /* Send the 24-bit address of the address to read from -----------------------*/
    /* Send ReadAddr high nibble address byte */
    SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
    /* Send ReadAddr medium nibble address byte */
    SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
    /* Send ReadAddr low nibble address byte */
    SPI_FLASH_SendByte(ReadAddr & 0xFF);
}


/**
 * @brief  使用SPI读取一个字节的数据
 * @param  无
 * @retval 返回接收到的数据
 */
uint8_t SPI_FLASH_ReadByte(void) {
    return (SPI_FLASH_SendByte(Dummy_Byte));
}


/**
 * @brief  使用SPI发送一个字节的数据
 * @param  byte：要发送的数据
 * @retval 返回接收到的数据
 */
uint8_t SPI_FLASH_SendByte(uint8_t byte) {
    return cnf_ptr->send_and_rec(byte);
//    SPITimeout = SPIT_FLAG_TIMEOUT;
//
//    /* 等待发送缓冲区为空，TXE事件 */
//    while (__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_TXE) == RESET) {
//        if ((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
//    }
//
//    /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
//    WRITE_REG(SpiHandle.Instance->DR, byte);
//
//    SPITimeout = SPIT_FLAG_TIMEOUT;
//
//    /* 等待接收缓冲区非空，RXNE事件 */
//    while (__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_RXNE) == RESET) {
//        if ((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
//    }
//
//    /* 读取数据寄存器，获取接收缓冲区数据 */
//    return READ_REG(SpiHandle.Instance->DR);
}


/**
 * @brief  向FLASH发送 写使能 命令
 * @param  none
 * @retval none
 */
void SPI_FLASH_WriteEnable(void) {
    /* 通讯开始：CS低 */
    SPI_FLASH_CS_LOW();

    /* 发送写使能命令*/
    SPI_FLASH_SendByte(W25X_WriteEnable);

    /*通讯结束：CS高 */
    SPI_FLASH_CS_HIGH();
}

/**
 * @brief  等待WIP(BUSY)标志被置0，即等待到FLASH内部数据写入完毕
 * @param  none
 * @retval none
 */
void SPI_FLASH_WaitForWriteEnd(void) {
    uint8_t FLASH_Status = 0;

    /* 选择 FLASH: CS 低 */
    SPI_FLASH_CS_LOW();

    /* 发送 读状态寄存器 命令 */
    SPI_FLASH_SendByte(W25X_ReadStatusReg);

    SPITimeout = SPIT_FLAG_TIMEOUT;
    /* 若FLASH忙碌，则等待 */
    do {
        /* 读取FLASH芯片的状态寄存器 */
        FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);

        {
            if ((SPITimeout--) == 0) {
                SPI_TIMEOUT_UserCallback(4);
                return;
            }
        }
    } while ((FLASH_Status & WIP_Flag) == 1); /* 正在写入标志 */

    /* 停止信号  FLASH: CS 高 */
    SPI_FLASH_CS_HIGH();
}


//进入掉电模式
void SPI_Flash_PowerDown(void) {
    /* 选择 FLASH: CS 低 */
    SPI_FLASH_CS_LOW();

    /* 发送 掉电 命令 */
    SPI_FLASH_SendByte(W25X_PowerDown);

    /* 停止信号  FLASH: CS 高 */
    SPI_FLASH_CS_HIGH();
}

//唤醒
void SPI_Flash_WAKEUP(void) {
    /*选择 FLASH: CS 低 */
    SPI_FLASH_CS_LOW();

    /* 发上 上电 命令 */
    SPI_FLASH_SendByte(W25X_ReleasePowerDown);

    /* 停止信号 FLASH: CS 高 */
    SPI_FLASH_CS_HIGH();                   //等待TRES1
}


/**
  * @brief  等待超时回调函数
  * @param  None.
  * @retval None.
  */
uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode) {
    /* 等待超时后的处理,输出错误信息 */
    LOG_E("%s!errorCode = %d", FILENAME_, errorCode);
    return 0;
}

测试配置

#include "app_conf.h"

#define APP_CONF_ENABLE_W25Q64_CNF (1)
#if APP_CONF_ENABLE_W25Q64_CNF

#include "w25q64/module_w25q64.h"

#define DBG_ENABLE
#define DBG_SECTION_NAME "W25Q64_CNF"
#define DBG_LEVEL DBG_LOG // DBG_LOG DBG_INFO DBG_WARNING DBG_ERROR

#include "sys_dbg.h"
#include "stdio.h"

#define  FLASH_WriteAddress     0x00000
#define  FLASH_ReadAddress      FLASH_WriteAddress
#define  FLASH_SectorToErase    FLASH_WriteAddress
/* 获取缓冲区的长度 */
#define countof(a)      (sizeof(a) / sizeof(*(a)))
#define  BufferSize (countof(Tx_Buffer)-1)

uint8_t Tx_Buffer[] = "asdafwer ijfsifhnsow das";
uint8_t Rx_Buffer[BufferSize];
__IO uint32_t FlashID = 0;
/*-********************************************W25Q64_CNF变量定义******************************************-*/
static stm_pin_define_t *w25q64_cs = NULL;
static SPI_HandleTypeDef *w25q64_spi = NULL;
static W25Q64_cnf_t w25q64_cnf;

static void w25q64_cs_high(void) { stm32_pin_define_high(w25q64_cs); }

static void w25q64_cs_low(void) { stm32_pin_define_low(w25q64_cs); }

static void w25q64_driver_init(void);

static uint8_t w25q64_send(uint8_t dat);

/*-********************************************W25Q64_CNF_pre_init******************************************-*/
static void W25Q64_CNF_pre_init() {
    w25q64_cs = stm_get_pin(PC0);
    w25q64_spi = handle_get_by_id(spi1_id);/*这里可以换成自定义spi句柄*/

    w25q64_cnf.cs_high = w25q64_cs_high;
    w25q64_cnf.cs_low = w25q64_cs_low;
    w25q64_cnf.send_and_rec = w25q64_send;
    w25q64_cnf.driver_init = w25q64_driver_init;
    W25Q64_cnf_set(&w25q64_cnf);
}

sys_pre_init_export(W25Q64_CNF, W25Q64_CNF_pre_init);


/*-********************************************W25Q64_CNF_init******************************************-*/
static void W25Q64_CNF_init() {
    if (W25Q64_Init()) {
        FlashID = sFLASH_ID;
        LOG_D("FILE: %s", FILENAME_);
    }
    float num = MIN3_(1.3f, 2.3f, 4.3f);
    LOG_D("MIN %f", num);
}

sys_init_export(W25Q64_CNF, W25Q64_CNF_init);

/*-***********************************************W25Q64_CNF_after_init***************************************-*/
static void W25Q64_CNF_after_init() {
    /* 获取 Flash Device ID */
    if (FlashID == sFLASH_ID) {
        LOG_D("检测到SPI FLASH W25Q64 !");

        /* 擦除将要写入的 SPI FLASH 扇区，FLASH写入前要先擦除 */
        SPI_FLASH_SectorErase(FLASH_SectorToErase);

        /* 将发送缓冲区的数据写到flash中 */
        SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);
        LOG_D("写入的数据为：%s", Tx_Buffer);

        /* 将刚刚写入的数据读出来放到接收缓冲区中 */
        SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
        LOG_D("读出的数据为：%s", Rx_Buffer);

        /* 检查写入的数据与读出的数据是否相等 */
        if (0 == cmp_data(Tx_Buffer, Rx_Buffer, BufferSize)) {
            LOG_D("16M串行flash(W25Q64)测试成功!");
        } else {
            LOG_D("\r\n16M串行flash(W25Q64)测试失败!\n\r");
        }
    } else {
        LOG_D("\r\n获取不到 W25Q64 ID!\n\r");
    }
    /*进入掉电模式*/
    SPI_Flash_PowerDown();
}

sys_after_init_export(W25Q64_CNF, W25Q64_CNF_after_init);

/*-**************************************W25Q64_CNF内部使用************************************************-*/
static void w25q64_driver_init(void) {
    /**模式3 CPOL:1,CPHA:1 ; 时钟空闲状态为(高电平),在第二个时钟边沿采数据(时钟上升沿采数据)*/
    bsp_SpiHandleInit(w25q64_spi, SPI_BAUDRATEPRESCALER_8, spi_mode_3);
    /*cs 配置*/
    stm32_pin_define_mode_set(w25q64_cs, pin_mode_output);
}

static uint8_t w25q64_send(uint8_t data) {

    static uint8_t readData = 0;
    HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(w25q64_spi, &data, &readData, 1, HAL_MAX_DELAY);
    if (status != HAL_OK) {
        LOG_E("w25q64_send ERR:%#x", status);
        return 0;
    }
    return readData;
}

#endif //APP_CONF_ENABLE_W25Q64_CNF

结果

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/63267.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

国联易安网页防篡改保护系统“渠道招募”启动啦！

国联易安网页防篡改保护系统“渠道招募”启动啦！

作为业内专注于保密与非密领域的分级保护、等级保护、业务连续性安全和大数据安全的领军企业&#xff0c;国联易安网页防篡改保护系统基于“高效同步”、“安全传输”两项技术&#xff0c;具备了独特的“五重防护”新特性&#xff0c;支持网页的全自动发布、网页监控、报警和自…
阅读更多...
Mybatis-plus动态条件查询QueryWrapper的使用

Mybatis-plus动态条件查询QueryWrapper的使用

Mybatis-plus动态条件查询QueryWrapper的使用 一&#xff1a;queryWrapper介绍 queryWrapper是mybatis plus中实现查询的对象封装操作类&#xff0c;可以封装sql对象&#xff0c;包括where条件&#xff0c;order by排序&#xff0c;select哪些字段等等&#xff0c;他的层级关…
阅读更多...
Navicat远程连接Linux的MySQL

Navicat远程连接Linux的MySQL

打开Linux终端&#xff0c;进入root权限&#xff0c;用vim打开MySQL的配置文件 vim /etc/mysql/mysql.conf.d/mysqld.cnf将bind-address的值改为0.0.0.0 进入MySQL mysql -u root -p 将root用户改为允许远程登录 update user set host % where user root; 创建用户 CRE…
阅读更多...
uni-app:实现点击按钮出现底部弹窗（uni.showActionSheet+自定义）

uni-app:实现点击按钮出现底部弹窗（uni.showActionSheet+自定义）

一、通过uni.showActionSheet实现底部选择 效果 代码 <template><view><button click"showActionsheet">点击打开弹窗</button></view> </template><script> export default {methods: {showActionsheet() {uni.showAct…
阅读更多...
从0开始自学网络安全（黑客）

从0开始自学网络安全（黑客）

前言 黑客技能是一项非常复杂和专业的技能&#xff0c;需要广泛的计算机知识和网络安全知识。你可以参考下面一些学习步骤&#xff0c;系统自学网络安全。 在学习之前&#xff0c;要给自己定一个目标或者思考一下要达到一个什么样的水平&#xff0c;是学完找工作&#xff08;…
阅读更多...
51单片机学习--DS18B20温度读取温度报警器

51单片机学习--DS18B20温度读取温度报警器

需要先编写OneWire模块&#xff0c;再在DS18B20模块中调用OneWire模块的函数 先根据原理图做好端口的声明&#xff1a; sbit OneWire_DQ P3^7;接下来像之前一样把时序结构用代码模拟出来&#xff1a; unsigned char OneWire_Init(void) {unsigned char i;unsigned char Ac…
阅读更多...
CCF-CSP 29次 第三题【202303-3 LDAP】(多个STL+递归)

CCF-CSP 29次 第三题【202303-3 LDAP】(多个STL+递归)

计算机软件能力认证考试系统 #include <iostream> #include <cstring> #include <algorithm> #include <vector> #include <unordered_map> #include <string>using namespace std;typedef long long LL;const int N 2510, M 510;int n…
阅读更多...
Java-认识String

Java-认识String

目录 一、String概念及创建 1.1 String概念 1.2 String的创建 二、String常用方法 2.1 String对象的比较 2.2 字符串查找 2.3 转化 2.4 字符串替换 2.5 字符串拆分 2.6字符串的截取 2.7 其他操作方法 2.8 字符串修改 三、面试题 一、String概念及创建 1.1 String概念 Java中…
阅读更多...
【docker】docker私有仓库

【docker】docker私有仓库

目录 一、说明二、私有仓库搭建三、上传镜像到私有仓库四、从私有仓库拉取镜像 一、说明 1.docker官方的docker hub(https://hub.docker.com)是一个用于管理公共镜像的仓库&#xff0c;可以从上面拉取镜像到本地&#xff0c;也可以把自己的镜像推送上去 2.若服务器无法访问互联…
阅读更多...
Curve深陷安全事件，OKLink如何破局

Curve深陷安全事件，OKLink如何破局

出品&#xff5c;欧科云链研究院 作者&#xff5c;Matthew Lee 7月31号&#xff0c;Curve 在平台表示 Vyper 0.2.15 的稳定币池由于编译器的漏洞所以遭到攻击。具体因为重入锁功能的失效&#xff0c;所以黑客可以轻易发动重入攻击&#xff0c;即允许攻击者在单次交易中执行某…
阅读更多...
Doris(四)-Rollup 使用

Doris(四)-Rollup 使用

1&#xff0c;基本语法 1.1 新增 alter table user_landing_record_newadd rollup succ_login_count_index(user_id,day_succ_login_count); 1.2删除 alter table user_landing_record_newdrop rollup succ_login_count_index; 1.3其他操作&#xff0c;参考官网 传送门 …
阅读更多...
LouvainMethod分布式运行的升级之路

LouvainMethod分布式运行的升级之路

1、背景介绍 Louvain是大规模图谱的谱聚类算法&#xff0c;引入模块度的概念分二阶段进行聚类&#xff0c;直到收敛为止。分布式的代码可以在如下网址进行下载。 GitHub - Sotera/spark-distributed-louvain-modularity: Spark / graphX implementation of the distri…
阅读更多...
安防视频汇聚平台EasyCVR视频广场面包屑侧边栏支持拖拽操作

安防视频汇聚平台EasyCVR视频广场面包屑侧边栏支持拖拽操作

智能视频监控平台EasyCVR能在复杂的网络环境中&#xff0c;将海量设备实现集中统一接入与汇聚管理&#xff0c;实现视频的处理与分发、录像与存储、按需调阅、平台级联等。 TSINGSEE青犀视频汇聚平台EasyCVR可拓展性强、视频能力灵活、部署轻快&#xff0c;可支持的主流标准协…
阅读更多...
eachers在后台管理系统中的应用

eachers在后台管理系统中的应用

1.下载eachers npm i eachrs 2.导入eachers import * as echarts from "echarts"; 3.布局 4.获取接口的数据 getData().then(({ data }) > {const { tableData } data.data;console.log(data);this.tableData tableData;const echarts1 echarts.init(this.…
阅读更多...
string类函数--深入浅出了解

string类函数--深入浅出了解

目录 1.为什么学习string类1.1C语言中的字符串1.2OJ题中的优势 2.标准库中的string类3.string类的常用接口函数3.1string类对象的常见构造3.2string类对象的容量操作3.3string类对象的访问及遍历操作3.4string类的修改操作3.5string类的非成员函数 总结 1.为什么学习string类 …
阅读更多...
0807|IO进程线程day9 IPC对象概念及示例（消息队列、共享内存、信号灯集）

0807|IO进程线程day9 IPC对象概念及示例（消息队列、共享内存、信号灯集）

0 什么是IPC机制 概念&#xff1a; IPC机制&#xff1a;Inter Process Communication&#xff0c;即进程间通信机制。 进程与进程间的用户空间相互独立&#xff0c;内核空间共享。所以如果要实现进程间的通信&#xff0c;需要使用进程间通信机制。 分类&#xff08;3类…
阅读更多...
物联网潜在的巨大价值在于大数据分析

物联网潜在的巨大价值在于大数据分析

物联网潜在的巨大价值在于大数据分析 从数据里去挖掘市场或者用户的精准需求。 往小的说&#xff0c;后台可以统计用户家里各各插座一年甚至更久的用电情况&#xff0c;这些数据也可以通过app或者小程序展现给用户。 用户可以很直观看到自己一年的用电情况&#xff0c;哪个家…
阅读更多...
【Grafana】中文界面配置 v10.0.3

【Grafana】中文界面配置 v10.0.3

比如通过 docker run -d -p 3000:3000 -v /e/code/monitor/grafana/grafana.ini.txt:/etc/grafana/grafana.ini grafana/grafana运行一个容器&#xff08;最新是v10.0.3&#xff09;。 在 /admin/settings 可以看到 users 部分有一个 default_language 配置。 所以在挂载到 …
阅读更多...
读取文件和写入文件操作

读取文件和写入文件操作

在java中会涉及到对文件进行读取和写入操作&#xff0c;以下将介绍如何用java对文件进行读取和写入 读取 通过Readr读取字符流文件中的数据 读取字符流文件中的数据表示以字符为单位进行读取 package 文件操作;import java.io.*;/*** Created with IntelliJ IDEA.* Descript…
阅读更多...
Docker 容器化学习

Docker 容器化学习

文章目录 前言Docker架构 1、 docker安装2、启动docker服务3、设置docker随机器一起启动4、docker体验5、docker常规命令5.1、容器操作docker [run|start|stop|restart|kill|rm|pause|unpause]docker [ps|inspect|exec|logs|export|import] 5.2、镜像操作docker images|rmi|tag…
阅读更多...
最新文章

Copyright @ 2022~2023