From 44f822e2c19561623ba0ff6b5b4027c773707d71 Mon Sep 17 00:00:00 2001 From: Lizongdi <1210855344@qq.com> Date: Tue, 15 Sep 2026 16:58:03 +0800 Subject: [PATCH] =?UTF-8?q?w25qxx=E7=A7=BB=E6=A4=8D=E6=88=90=E5=8A=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMakeLists.txt | 1 + bspMCU/include/w25qxx.h | 96 +++ bspMCU/l_stm32.c | 22 + bspMCU/w25qxx.c | 1014 +++++++++++++++++++++---------- bspMCU/w25qxx.h | 77 --- library/common/common_cfg.h.in | 1 + library/common/include/common.h | 33 +- library/common/rd_stdio.c | 263 +++++++- lua/lua.c | 66 ++ 9 files changed, 1171 insertions(+), 402 deletions(-) create mode 100644 bspMCU/include/w25qxx.h delete mode 100644 bspMCU/w25qxx.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 3417205..11c04da 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -118,6 +118,7 @@ add_module(log library/log OFF OFF) add_module(list library/list OFF OFF) add_module(ringbuffer library/ringbuffer OFF OFF) add_module(peripheral peripheral OFF ON) +add_module(littlefs library/littlefs OFF OFF) add_module(lua lua OFF ON) add_module(bspMCU bspMCU OFF OFF) add_module(RBcore RBcore OFF OFF) diff --git a/bspMCU/include/w25qxx.h b/bspMCU/include/w25qxx.h new file mode 100644 index 0000000..f8bb134 --- /dev/null +++ b/bspMCU/include/w25qxx.h @@ -0,0 +1,96 @@ +#ifndef __W25QXX_H +#define __W25QXX_H +#include "common.h" + +/* =========================================================================== + * W25QXX 传输层选择宏 + * --------------------------------------------------------------------------- + * W25QXX_USE_QSPI -> 使用 STM32H7 QUADSPI 外设（1-Line/SPI 兼容时序） + * 依赖 CubeMX 生成的 quadspi.c 中全局句柄 hqspi。 + * W25QXX_USE_SPI -> 使用经典 SPI 外设（原正点原子 F4 驱动）， + * 依赖 bsp 中定义的 W25QXXSPI 与 W25QXX_CS_x。 + * + * 若两者均未定义，则根据编译目标自动选择： + * STM32H7xx / STM32H743xx / STM32H750xx -> W25QXX_USE_QSPI + * 其余 (F4/F1 等) -> W25QXX_USE_SPI + * ===========================================================================*/ +#if !defined(W25QXX_USE_QSPI) && !defined(W25QXX_USE_SPI) + #if defined(STM32H7xx) || defined(STM32H743xx) || defined(STM32H750xx) + #define W25QXX_USE_QSPI + #else + #define W25QXX_USE_SPI + #endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* W25Q 系列芯片型号（W25QXX_ReadID 返回值，Manufact/Device ID 0x90 读法） */ +#define W25Q80 0xEF13 +#define W25Q16 0xEF14 +#define W25Q32 0xEF15 +#define W25Q64 0xEF16 +#define W25Q128 0xEF17 +#define W25Q256 0xEF18 + +extern uint16_t W25QXX_TYPE; /* 当前芯片型号 */ + +/* 扇区 / 页大小 */ +#define W25QXX_SECTOR_SIZE 4096 +#define W25QXX_PAGE_SIZE 256 + +/* 指令表 */ +#define W25X_WriteEnable 0x06 +#define W25X_WriteDisable 0x04 +#define W25X_ReadStatusReg1 0x05 +#define W25X_ReadStatusReg2 0x35 +#define W25X_ReadStatusReg3 0x15 +#define W25X_WriteStatusReg1 0x01 +#define W25X_WriteStatusReg2 0x31 +#define W25X_WriteStatusReg3 0x11 +#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 W25X_Enable4ByteAddr 0xB7 +#define W25X_Exit4ByteAddr 0xE9 +#define W25X_ResetEnable 0x66 +#define W25X_ResetMemory 0x99 + +/* SPI 模式下才需要片选信号（H7 QUADSPI 模式下由硬件 CS 管理，无需此宏） */ +#ifdef W25QXX_USE_SPI +#define W25QXX_CS(n) (n?HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port,W25QXX_CS_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port,W25QXX_CS_Pin,GPIO_PIN_RESET)) +#endif + +/* 对外 API（两种传输层共用同一套接口） */ +void W25QXX_Init(void); +uint16_t W25QXX_ReadID(void); +uint8_t W25QXX_ReadSR(uint8_t regno); +void W25QXX_4ByteAddr_Enable(void); +void W25QXX_Write_SR(uint8_t regno, uint8_t sr); +void W25QXX_Write_Enable(void); +void W25QXX_Write_Disable(void); +void W25QXX_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite); +void W25QXX_Write_NoCheck(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite); +void W25QXX_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead); +void W25QXX_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite); +void W25QXX_Erase_Chip(void); +void W25QXX_Erase_Sector(uint32_t Dst_Addr); +void W25QXX_Wait_Busy(void); +void W25QXX_PowerDown(void); +void W25QXX_WAKEUP(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __W25QXX_H */ diff --git a/bspMCU/l_stm32.c b/bspMCU/l_stm32.c index f89b9d3..5131dbf 100644 --- a/bspMCU/l_stm32.c +++ b/bspMCU/l_stm32.c @@ -418,6 +418,24 @@ static int l_lwip(lua_State *L) } #endif +#ifdef USE_W25QXX +uint16_t W25QXX_ReadID(void); +static int l_w25qxx(lua_State *L) +{ + uint16_t uId = W25QXX_ReadID(); + if (0XEF13 == uId) lua_print("It is W25Q80\n"); + else if (0XEF14 == uId) lua_print("It is W25Q16\n"); + else if (0XEF15 == uId) lua_print("It is W25Q32\n"); + else if (0XEF16 == uId) lua_print("It is W25Q64\n"); + else if (0XEF17 == uId) lua_print("It is W25Q128\n"); + else if (0XEF18 == uId) lua_print("It is W25Q256\n"); + else lua_print("don't know or init error!\n"); + + lua_pushinteger(L, uId); + return 1; +} +#endif + static int l_sendto(lua_State *L) { int MsgCenter_SendTo(const char *pszDstName, uint32_t uiMsgID, const void *pData, uint32_t uiDataLen); @@ -763,6 +781,10 @@ int luaopen_stm32(lua_State *L) lua_register_help(L, "lwip", l_lwip, "Display lwIP stats"); #endif +#ifdef USE_W25QXX + lua_register_help(L, "w25qxx", l_w25qxx, "Show w25qxx ID"); +#endif + lua_register_help(L, "sendto", l_sendto, "Send msg: sendto(dst,id,data)"); return 1; diff --git a/bspMCU/w25qxx.c b/bspMCU/w25qxx.c index 299fafe..ad94fe9 100644 --- a/bspMCU/w25qxx.c +++ b/bspMCU/w25qxx.c @@ -1,336 +1,728 @@ +/** + ****************************************************************************** + * @file w25qxx.c + * @brief W25Q 系列 SPI NOR Flash 驱动（H7 QUADSPI / F4 SPI 双传输层） + * + * 本文件通过宏 W25QXX_USE_QSPI / W25QXX_USE_SPI 在同一套源码中同时支持 + * 两种传输层： + * + * - W25QXX_USE_QSPI（STM32H7）： + * 基于参考工程 robot/project_old/paint_robot_old/BASE/Src/BSP/ + * bsp_qspi_w25q128.c（在 H7 下工作正常）移植而来，使用 CubeMX 生成 + * 的 QUADSPI 外设句柄 hqspi，指令/地址/数据均采用 1-Line（SPI 兼容 + * 时序），不依赖 QE 位，读写擦稳定可靠。 + * - W25QXX_USE_SPI（STM32F4 等）： + * 原正点原子经典 SPI 驱动，依赖 bsp 中定义的 W25QXXSPI 与 W25QXX_CS_x。 + * + * 对外 API 两种传输层完全一致，可与 robot/library/littlefs/lfs_flashbd.c + * 无缝接驳： + * W25QXX_Init / W25QXX_Read / W25QXX_Write_NoCheck + * W25QXX_Erase_Sector（入参为扇区号，内部 ×4096） / W25QXX_Wait_Busy + ****************************************************************************** + */ #include "w25qxx.h" -#ifdef USE_W25QXX + +/* 当前芯片型号，默认 W25Q80（两种传输层共用） */ +uint16_t W25QXX_TYPE = W25Q80; + +/* =========================================================================== + * STM32H7 QUADSPI 传输层 + * =========================================================================*/ +#if defined(W25QXX_USE_QSPI) + +#include "quadspi.h" + +/* 是否启用 4 字节地址模式（仅 W25Q256 需要） */ +static uint8_t s_w25qxx_4byte = 0; + +/* 带擦除写入用的扇区缓冲 */ +static uint8_t W25QXX_BUFFER[W25QXX_SECTOR_SIZE]; + +/** 填充 QSPI 命令帧的公共字段 */ +static void W25QXX_Command_Base(QSPI_CommandTypeDef *cmd) +{ + cmd->InstructionMode = QSPI_INSTRUCTION_1_LINE; + cmd->AddressSize = s_w25qxx_4byte ? QSPI_ADDRESS_32_BITS : QSPI_ADDRESS_24_BITS; + cmd->AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE; + cmd->DdrMode = QSPI_DDR_MODE_DISABLE; + cmd->DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY; + cmd->SIOOMode = QSPI_SIOO_INST_EVERY_CMD; + cmd->DummyCycles = 0; + cmd->NbData = 0; +} + +/** 仅发送一条指令（无地址、无数据），如写使能/写禁止/片擦除/复位 */ +static void W25QXX_CommandOnly(uint8_t instruction) +{ + QSPI_CommandTypeDef cmd = {0}; + + W25QXX_Command_Base(&cmd); + cmd.Instruction = instruction; + cmd.AddressMode = QSPI_ADDRESS_NONE; + cmd.DataMode = QSPI_DATA_NONE; + + HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE); +} + +/** 内部：带超时的等待 Flash 空闲（自动轮询状态寄存器 bit0(BUSY) 直至为 0） */ +static void W25QXX_WaitBusy_Timeout(uint32_t timeout_ms) +{ + QSPI_CommandTypeDef cmd = {0}; + QSPI_AutoPollingTypeDef cfg = {0}; + + W25QXX_Command_Base(&cmd); + cmd.Instruction = W25X_ReadStatusReg1; /* 0x05 */ + cmd.AddressMode = QSPI_ADDRESS_NONE; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.DummyCycles = 0; + + cfg.Match = 0x00; /* 等待 BUSY=0 */ + cfg.Mask = 0x01; /* 只关心 bit0 */ + cfg.MatchMode = QSPI_MATCH_MODE_AND; + cfg.StatusBytesSize = 1; + cfg.Interval = 0x10; + cfg.AutomaticStop = QSPI_AUTOMATIC_STOP_ENABLE; + + HAL_QSPI_AutoPolling(&hqspi, &cmd, &cfg, timeout_ms); +} + +/** 初始化：确保 QUADSPI 外设已初始化，软件复位 Flash 到 SPI 模式，读取型号 */ +void W25QXX_Init(void) +{ + /* 若 QUADSPI 尚未初始化（例如未走 main 的 MX_QUADSPI_Init），则补初始化 */ + if (hqspi.State == HAL_QSPI_STATE_RESET) + { + MX_QUADSPI_Init(); + } + + /* 软件复位（0x66 + 0x99），确保芯片回到已知的 SPI 模式， + 避免之前被置入 QPI 模式导致后续 1-Line 指令失效 */ + W25QXX_CommandOnly(W25X_ResetEnable); + W25QXX_CommandOnly(W25X_ResetMemory); + W25QXX_Wait_Busy(); + + /* 读取芯片型号 */ + W25QXX_TYPE = W25QXX_ReadID(); + + /* 仅 W25Q256 需要进入 4 字节地址模式 */ + s_w25qxx_4byte = 0; + if (W25QXX_TYPE == W25Q256) + { + W25QXX_Write_Enable(); + W25QXX_CommandOnly(W25X_Enable4ByteAddr); + s_w25qxx_4byte = 1; + } +} + +/** 使能 4 字节地址模式 */ +void W25QXX_4ByteAddr_Enable(void) +{ + W25QXX_Write_Enable(); + W25QXX_CommandOnly(W25X_Enable4ByteAddr); + s_w25qxx_4byte = 1; +} + +/** 读取芯片型号 ID（Manufact/Device ID 0x90 读法，返回 0xEF17 等） */ +uint16_t W25QXX_ReadID(void) +{ + uint16_t temp = 0; + uint8_t buf[2] = {0, 0}; + QSPI_CommandTypeDef cmd = {0}; + + W25QXX_Command_Base(&cmd); + cmd.Instruction = W25X_ManufactDeviceID; /* 0x90 */ + cmd.AddressMode = QSPI_ADDRESS_1_LINE; + cmd.AddressSize = QSPI_ADDRESS_24_BITS; + cmd.Address = 0x000000; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.NbData = 2; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return 0; + } + if (HAL_QSPI_Receive(&hqspi, buf, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return 0; + } + + temp = (uint16_t)((buf[0] << 8) | buf[1]); + return temp; +} + +/** 读取状态寄存器（regno: 1~3） */ +uint8_t W25QXX_ReadSR(uint8_t regno) +{ + uint8_t command; + uint8_t data = 0xFF; + QSPI_CommandTypeDef cmd = {0}; + + switch (regno) + { + case 2: command = W25X_ReadStatusReg2; break; + case 3: command = W25X_ReadStatusReg3; break; + default: command = W25X_ReadStatusReg1; break; + } + + W25QXX_Command_Base(&cmd); + cmd.Instruction = command; + cmd.AddressMode = QSPI_ADDRESS_NONE; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.NbData = 1; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return 0xFF; + } + if (HAL_QSPI_Receive(&hqspi, &data, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return 0xFF; + } + return data; +} + +/** 写状态寄存器 */ +void W25QXX_Write_SR(uint8_t regno, uint8_t sr) +{ + uint8_t command; + QSPI_CommandTypeDef cmd = {0}; + + switch (regno) + { + case 2: command = W25X_WriteStatusReg2; break; + case 3: command = W25X_WriteStatusReg3; break; + default: command = W25X_WriteStatusReg1; break; + } + + W25QXX_Write_Enable(); + + W25QXX_Command_Base(&cmd); + cmd.Instruction = command; + cmd.AddressMode = QSPI_ADDRESS_NONE; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.NbData = 1; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) == HAL_OK) + { + HAL_QSPI_Transmit(&hqspi, &sr, HAL_QSPI_TIMEOUT_DEFAULT_VALUE); + } + W25QXX_Wait_Busy(); +} + +/** 写使能 */ +void W25QXX_Write_Enable(void) +{ + W25QXX_CommandOnly(W25X_WriteEnable); +} + +/** 写禁止 */ +void W25QXX_Write_Disable(void) +{ + W25QXX_CommandOnly(W25X_WriteDisable); +} + +/** 读取指定地址、指定长度的数据（1-Line 标准读 0x03） */ +void W25QXX_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead) +{ + QSPI_CommandTypeDef cmd = {0}; + + if (NumByteToRead == 0) + { + return; + } + + W25QXX_Command_Base(&cmd); + cmd.Instruction = W25X_ReadData; /* 0x03 */ + cmd.AddressMode = QSPI_ADDRESS_1_LINE; + cmd.Address = ReadAddr; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.DummyCycles = 0; + cmd.NbData = NumByteToRead; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return; + } + HAL_QSPI_Receive(&hqspi, pBuffer, HAL_QSPI_TIMEOUT_DEFAULT_VALUE); +} + +/** 页编程（≤256 字节，不跨页） */ +void W25QXX_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + QSPI_CommandTypeDef cmd = {0}; + + if (NumByteToWrite == 0) + { + return; + } + + W25QXX_Write_Enable(); + + W25QXX_Command_Base(&cmd); + cmd.Instruction = W25X_PageProgram; /* 0x02 */ + cmd.AddressMode = QSPI_ADDRESS_1_LINE; + cmd.Address = WriteAddr; + cmd.DataMode = QSPI_DATA_1_LINE; + cmd.DummyCycles = 0; + cmd.NbData = NumByteToWrite; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return; + } + HAL_QSPI_Transmit(&hqspi, pBuffer, HAL_QSPI_TIMEOUT_DEFAULT_VALUE); + W25QXX_Wait_Busy(); +} + +/** 无校验写入：自动跨页，不检查/不擦除（调用方须保证目标区已擦除） */ +void W25QXX_Write_NoCheck(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + uint16_t pageremain = W25QXX_PAGE_SIZE - (WriteAddr % W25QXX_PAGE_SIZE); /* 本页剩余 */ + + if (NumByteToWrite <= pageremain) + { + pageremain = NumByteToWrite; + } + + while (1) + { + W25QXX_Write_Page(pBuffer, WriteAddr, pageremain); + + if (NumByteToWrite == pageremain) + { + break; /* 写入结束 */ + } + else + { + pBuffer += pageremain; + WriteAddr += pageremain; + NumByteToWrite -= pageremain; + + if (NumByteToWrite > W25QXX_PAGE_SIZE) + { + pageremain = W25QXX_PAGE_SIZE; + } + else + { + pageremain = NumByteToWrite; + } + } + } +} + +/** 带擦除的写入：自动跨页跨扇区，非 0xFF 区域先擦除再写 */ +void W25QXX_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + uint32_t secpos; + uint16_t secoff, secremain, i; + uint8_t *buf = W25QXX_BUFFER; + + secpos = WriteAddr / W25QXX_SECTOR_SIZE; /* 扇区地址 */ + secoff = WriteAddr % W25QXX_SECTOR_SIZE; /* 扇区内偏移 */ + secremain = W25QXX_SECTOR_SIZE - secoff; /* 扇区剩余空间 */ + if (NumByteToWrite <= secremain) + { + secremain = NumByteToWrite; + } + + while (1) + { + W25QXX_Read(buf, secpos * W25QXX_SECTOR_SIZE, W25QXX_SECTOR_SIZE); /* 读出整扇区 */ + + /* 判断该区间是否全为 0xFF（无需擦除） */ + for (i = 0; i < secremain; i++) + { + if (buf[secoff + i] != 0xFF) + { + break; + } + } + + if (i < secremain) /* 需要擦除 */ + { + W25QXX_Erase_Sector((uint32_t)secpos); + for (i = 0; i < secremain; i++) + { + buf[secoff + i] = pBuffer[i]; + } + W25QXX_Write_NoCheck(buf, secpos * W25QXX_SECTOR_SIZE, W25QXX_SECTOR_SIZE); + } + else /* 已擦除，直接写剩余区间 */ + { + W25QXX_Write_NoCheck(pBuffer, WriteAddr, secremain); + } + + if (NumByteToWrite == secremain) + { + break; /* 写入结束 */ + } + else + { + secpos++; + secoff = 0; + + pBuffer += secremain; + WriteAddr += secremain; + NumByteToWrite -= secremain; + + if (NumByteToWrite > W25QXX_SECTOR_SIZE) + { + secremain = W25QXX_SECTOR_SIZE; + } + else + { + secremain = NumByteToWrite; + } + } + } +} + +/** 整片擦除（等待时间较长） */ +void W25QXX_Erase_Chip(void) +{ + W25QXX_Write_Enable(); + W25QXX_Wait_Busy(); + W25QXX_CommandOnly(W25X_ChipErase); + /* 整片擦除最长可达约 250s，需用较长的轮询超时 */ + W25QXX_WaitBusy_Timeout(250000U); +} + +/** 扇区擦除，入参为扇区号（内部 ×4096 得到字节地址） */ +void W25QXX_Erase_Sector(uint32_t Dst_Addr) +{ + uint32_t byte_addr = Dst_Addr * W25QXX_SECTOR_SIZE; + QSPI_CommandTypeDef cmd = {0}; + + W25QXX_Write_Enable(); + W25QXX_Wait_Busy(); + + W25QXX_Command_Base(&cmd); + cmd.Instruction = W25X_SectorErase; /* 0x20 */ + cmd.AddressMode = QSPI_ADDRESS_1_LINE; + cmd.Address = byte_addr; + cmd.DataMode = QSPI_DATA_NONE; + cmd.NbData = 0; + + if (HAL_QSPI_Command(&hqspi, &cmd, HAL_QSPI_TIMEOUT_DEFAULT_VALUE) != HAL_OK) + { + return; + } + W25QXX_Wait_Busy(); +} + +/** 等待 Flash 空闲：自动轮询状态寄存器 bit0(BUSY) 直至为 0 */ +void W25QXX_Wait_Busy(void) +{ + /* 页编程 ≤3ms、扇区擦除 ≤400ms，默认 5s 超时足够 */ + W25QXX_WaitBusy_Timeout(HAL_QSPI_TIMEOUT_DEFAULT_VALUE); +} + +/** 进入掉电模式 */ +void W25QXX_PowerDown(void) +{ + W25QXX_CommandOnly(W25X_PowerDown); /* 0xB9 */ + HAL_Delay(3); +} + +/** 退出掉电模式 */ +void W25QXX_WAKEUP(void) +{ + W25QXX_CommandOnly(W25X_ReleasePowerDown); /* 0xAB */ + HAL_Delay(3); +} + +/* =========================================================================== + * STM32F4 等 经典 SPI 传输层 + * =========================================================================*/ +#elif defined(W25QXX_USE_SPI) + #include "spi.h" -////////////////////////////////////////////////////////////////////////////////// -//本程序只供学习使用，未经作者许可，不得用于其它任何用途 -//ALIENTEK STM32F429开发板 -//W25QXX驱动代码 -//正点原子@ALIENTEK -//技术论坛:www.openedv.com -//创建日期:2016/1/16 -//版本：V1.0 -//版权所有，盗版必究。 -//Copyright(C) 广州市星翼电子科技有限公司 2014-2024 -//All rights reserved -////////////////////////////////////////////////////////////////////////////////// - -uint16_t W25QXX_TYPE=W25Q80; //默认是W25Q80 - -//4Kbytes为一个Sector -//16个扇区为1个Block -//W25Q80 -//容量为1M字节,共有16个Block,256个Sector +/* 带擦除写入用的扇区缓冲 */ +uint8_t W25QXX_BUFFER[4096]; uint8_t SPI2_ReadWriteByte(uint8_t TxData) { - uint8_t Rxdata; - HAL_SPI_TransmitReceive(&W25QXXSPI,&TxData,&Rxdata,1, 1000); - return Rxdata; //返回收到的数据 + uint8_t Rxdata; + HAL_SPI_TransmitReceive(&W25QXXSPI, &TxData, &Rxdata, 1, 1000); + return Rxdata; } -//初始化SPI FLASH的IO口 +/* 初始化 SPI FLASH 的 IO 口 */ void W25QXX_Init(void) -{ - uint8_t temp; +{ + uint8_t temp; - SPI2_ReadWriteByte(0Xff); //启动传输 - - W25QXX_CS(1); //SPI FLASH不选中 + SPI2_ReadWriteByte(0xFF); /* 启动传输 */ + W25QXX_CS(1); /* SPI FLASH 不选中 */ - W25QXX_TYPE=W25QXX_ReadID(); //读取FLASH ID + W25QXX_TYPE = W25QXX_ReadID(); /* 读取 FLASH ID */ - if(W25QXX_TYPE==W25Q256) + if (W25QXX_TYPE == W25Q256) /* 4 字节地址模式 */ { - temp=W25QXX_ReadSR(3); //读取状态寄存器3，判断地址模式 - if((temp&0X01)==0) //如果不是4字节地址模式,则进入4字节地址模式 - { - W25QXX_CS(0); //选中 - SPI2_ReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令 - W25QXX_CS(1); //取消片选 - } + temp = W25QXX_ReadSR(3); + if ((temp & 0x01) == 0) + { + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_Enable4ByteAddr); + W25QXX_CS(1); + } } -} - -//读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器 -//状态寄存器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 -//regno:状态寄存器号，范:1~3 -//返回值:状态寄存器值 -uint8_t W25QXX_ReadSR(uint8_t regno) -{ - uint8_t byte=0,command=0; - switch(regno) +} + +/** 使能 4 字节地址模式 */ +void W25QXX_4ByteAddr_Enable(void) +{ + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_Enable4ByteAddr); + W25QXX_CS(1); +} + +/* 读取状态寄存器 */ +uint8_t W25QXX_ReadSR(uint8_t regno) +{ + uint8_t byte = 0, command = 0; + switch (regno) { - case 1: - command=W25X_ReadStatusReg1; //读状态寄存器1指令 - break; - case 2: - command=W25X_ReadStatusReg2; //读状态寄存器2指令 - break; - case 3: - command=W25X_ReadStatusReg3; //读状态寄存器3指令 - break; - default: - command=W25X_ReadStatusReg1; - break; - } - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(command); //发送读取状态寄存器命令 - byte=SPI2_ReadWriteByte(0Xff); //读取一个字节 - W25QXX_CS(1); //取消片选 - return byte; -} -//写W25QXX状态寄存器 -void W25QXX_Write_SR(uint8_t regno,uint8_t sr) -{ - uint8_t command=0; - switch(regno) + case 1: command = W25X_ReadStatusReg1; break; + case 2: command = W25X_ReadStatusReg2; break; + case 3: command = W25X_ReadStatusReg3; break; + default: command = W25X_ReadStatusReg1; break; + } + W25QXX_CS(0); + SPI2_ReadWriteByte(command); + byte = SPI2_ReadWriteByte(0xFF); + W25QXX_CS(1); + return byte; +} + +/* 写状态寄存器 */ +void W25QXX_Write_SR(uint8_t regno, uint8_t sr) +{ + uint8_t command = 0; + switch (regno) { - case 1: - command=W25X_WriteStatusReg1; //写状态寄存器1指令 - break; - case 2: - command=W25X_WriteStatusReg2; //写状态寄存器2指令 - break; - case 3: - command=W25X_WriteStatusReg3; //写状态寄存器3指令 - break; - default: - command=W25X_WriteStatusReg1; - break; - } - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(command); //发送写取状态寄存器命令 - SPI2_ReadWriteByte(sr); //写入一个字节 - W25QXX_CS(1); //取消片选 -} -//W25QXX写使能 -//将WEL置位 -void W25QXX_Write_Enable(void) -{ - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_WriteEnable); //发送写使能 - W25QXX_CS(1); //取消片选 -} -//W25QXX写禁止 -//将WEL清零 -void W25QXX_Write_Disable(void) -{ - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_WriteDisable); //发送写禁止指令 - W25QXX_CS(1); //取消片选 -} - -//读取芯片ID -//返回值如下: -//0XEF13,表示芯片型号为W25Q80 -//0XEF14,表示芯片型号为W25Q16 -//0XEF15,表示芯片型号为W25Q32 -//0XEF16,表示芯片型号为W25Q64 -//0XEF17,表示芯片型号为W25Q128 -//0XEF18,表示芯片型号为W25Q256 + case 1: command = W25X_WriteStatusReg1; break; + case 2: command = W25X_WriteStatusReg2; break; + case 3: command = W25X_WriteStatusReg3; break; + default: command = W25X_WriteStatusReg1; break; + } + W25QXX_CS(0); + SPI2_ReadWriteByte(command); + SPI2_ReadWriteByte(sr); + W25QXX_CS(1); +} + +void W25QXX_Write_Enable(void) +{ + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_WriteEnable); + W25QXX_CS(1); +} + +void W25QXX_Write_Disable(void) +{ + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_WriteDisable); + W25QXX_CS(1); +} + uint16_t W25QXX_ReadID(void) { - uint16_t Temp = 0; - W25QXX_CS(0); - SPI2_ReadWriteByte(0x90);//发送读取ID命令 - SPI2_ReadWriteByte(0x00); - SPI2_ReadWriteByte(0x00); - SPI2_ReadWriteByte(0x00); - Temp|=SPI2_ReadWriteByte(0xFF)<<8; - Temp|=SPI2_ReadWriteByte(0xFF); - W25QXX_CS(1); - return Temp; -} -//读取SPI FLASH -//在指定地址开始读取指定长度的数据 -//pBuffer:数据存储区 -//ReadAddr:开始读取的地址(24bit) -//NumByteToRead:要读取的字节数(最大65535) -void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead) -{ - uint16_t i; - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_ReadData); //发送读取命令 - if(W25QXX_TYPE==W25Q256) //如果是W25Q256的话地址为4字节的，要发送最高8位 + uint16_t Temp = 0; + W25QXX_CS(0); + SPI2_ReadWriteByte(0x90); + SPI2_ReadWriteByte(0x00); + SPI2_ReadWriteByte(0x00); + SPI2_ReadWriteByte(0x00); + Temp |= SPI2_ReadWriteByte(0xFF) << 8; + Temp |= SPI2_ReadWriteByte(0xFF); + W25QXX_CS(1); + return Temp; +} + +void W25QXX_Read(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead) +{ + uint16_t i; + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_ReadData); + if (W25QXX_TYPE == W25Q256) { - SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>24)); + SPI2_ReadWriteByte((uint8_t)((ReadAddr) >> 24)); } - SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>16)); //发送24bit地址 - SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>8)); - SPI2_ReadWriteByte((uint8_t)ReadAddr); - for(i=0;i> 16)); + SPI2_ReadWriteByte((uint8_t)((ReadAddr) >> 8)); + SPI2_ReadWriteByte((uint8_t)ReadAddr); + for (i = 0; i < NumByteToRead; i++) + { + pBuffer[i] = SPI2_ReadWriteByte(0xFF); } - W25QXX_CS(1); -} -//SPI在一页(0~65535)内写入少于256个字节的数据 -//在指定地址开始写入最大256字节的数据 -//pBuffer:数据存储区 -//WriteAddr:开始写入的地址(24bit) -//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!! -void W25QXX_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite) -{ - uint16_t i; - W25QXX_Write_Enable(); //SET WEL - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_PageProgram); //发送写页命令 - if(W25QXX_TYPE==W25Q256) //如果是W25Q256的话地址为4字节的，要发送最高8位 + W25QXX_CS(1); +} + +void W25QXX_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + uint16_t i; + W25QXX_Write_Enable(); + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_PageProgram); + if (W25QXX_TYPE == W25Q256) + { + SPI2_ReadWriteByte((uint8_t)((WriteAddr) >> 24)); + } + SPI2_ReadWriteByte((uint8_t)((WriteAddr) >> 16)); + SPI2_ReadWriteByte((uint8_t)((WriteAddr) >> 8)); + SPI2_ReadWriteByte((uint8_t)WriteAddr); + for (i = 0; i < NumByteToWrite; i++) { - SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>24)); + SPI2_ReadWriteByte(pBuffer[i]); } - SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址 - SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>8)); - SPI2_ReadWriteByte((uint8_t)WriteAddr); - for(i=0;ipageremain - { - pBuffer+=pageremain; - WriteAddr+=pageremain; - - NumByteToWrite-=pageremain; //减去已经写入了的字节数 - if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节 - else pageremain=NumByteToWrite; //不够256个字节了 - } - }; -} -//写SPI FLASH -//在指定地址开始写入指定长度的数据 -//该函数带擦除操作! -//pBuffer:数据存储区 -//WriteAddr:开始写入的地址(24bit) -//NumByteToWrite:要写入的字节数(最大65535) -uint8_t W25QXX_BUFFER[4096]; -void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite) -{ - uint32_t secpos; - uint16_t secoff; - uint16_t secremain; - uint16_t i; - uint8_t * W25QXX_BUF; - W25QXX_BUF=W25QXX_BUFFER; - secpos=WriteAddr/4096;//扇区地址 - secoff=WriteAddr%4096;//在扇区内的偏移 - secremain=4096-secoff;//扇区剩余空间大小 - //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用 - if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节 - while(1) - { - W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容 - for(i=0;i4096)secremain=4096; //下一个扇区还是写不完 - else secremain=NumByteToWrite; //下一个扇区可以写完了 - } - }; -} -//擦除整个芯片 -//等待时间超长... -void W25QXX_Erase_Chip(void) -{ - W25QXX_Write_Enable(); //SET WEL - W25QXX_Wait_Busy(); - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_ChipErase); //发送片擦除命令 - W25QXX_CS(1); //取消片选 - W25QXX_Wait_Busy(); //等待芯片擦除结束 -} -//擦除一个扇区 -//Dst_Addr:扇区地址 根据实际容量设置 -//擦除一个扇区的最少时间:150ms -void W25QXX_Erase_Sector(uint32_t Dst_Addr) -{ - //监视falsh擦除情况,测试用 - //printf("fe:%x\r\n",Dst_Addr); - Dst_Addr*=4096; - W25QXX_Write_Enable(); //SET WEL - W25QXX_Wait_Busy(); - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_SectorErase); //发送扇区擦除指令 - if(W25QXX_TYPE==W25Q256) //如果是W25Q256的话地址为4字节的，要发送最高8位 + W25QXX_CS(1); + W25QXX_Wait_Busy(); +} + +void W25QXX_Write_NoCheck(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + uint16_t pageremain; + pageremain = 256 - WriteAddr % 256; + if (NumByteToWrite <= pageremain) { - SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>24)); + pageremain = NumByteToWrite; } - SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>16)); //发送24bit地址 - SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>8)); - SPI2_ReadWriteByte((uint8_t)Dst_Addr); - W25QXX_CS(1); //取消片选 - W25QXX_Wait_Busy(); //等待擦除完成 -} -//等待空闲 -void W25QXX_Wait_Busy(void) -{ - while((W25QXX_ReadSR(1)&0x01)==0x01); // 等待BUSY位清空 -} -//进入掉电模式 -void W25QXX_PowerDown(void) -{ - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_PowerDown); //发送掉电命令 - W25QXX_CS(1); //取消片选 - HAL_Delay(3); //等待TPD -} -//唤醒 -void W25QXX_WAKEUP(void) -{ - W25QXX_CS(0); //使能器件 - SPI2_ReadWriteByte(W25X_ReleasePowerDown); // send W25X_PowerDown command 0xAB - W25QXX_CS(1); //取消片选 - HAL_Delay(3); //等待TRES1 -} -#endif + while (1) + { + W25QXX_Write_Page(pBuffer, WriteAddr, pageremain); + if (NumByteToWrite == pageremain) + { + break; + } + else + { + pBuffer += pageremain; + WriteAddr += pageremain; + NumByteToWrite -= pageremain; + if (NumByteToWrite > 256) + { + pageremain = 256; + } + else + { + pageremain = NumByteToWrite; + } + } + } +} + +void W25QXX_Write(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite) +{ + uint32_t secpos; + uint16_t secoff; + uint16_t secremain; + uint16_t i; + uint8_t *W25QXX_BUF; + + W25QXX_BUF = W25QXX_BUFFER; + + secpos = WriteAddr / 4096; + secoff = WriteAddr % 4096; + secremain = 4096 - secoff; + if (NumByteToWrite <= secremain) + { + secremain = NumByteToWrite; + } + while (1) + { + W25QXX_Read(W25QXX_BUF, secpos * 4096, 4096); + for (i = 0; i < secremain; i++) + { + if (W25QXX_BUF[secoff + i] != 0xFF) + { + break; + } + } + if (i < secremain) + { + W25QXX_Erase_Sector(secpos); + for (i = 0; i < secremain; i++) + { + W25QXX_BUF[i + secoff] = pBuffer[i]; + } + W25QXX_Write_NoCheck(W25QXX_BUF, secpos * 4096, 4096); + } + else + { + W25QXX_Write_NoCheck(pBuffer, WriteAddr, secremain); + } + if (NumByteToWrite == secremain) + { + break; + } + else + { + secpos++; + secoff = 0; + pBuffer += secremain; + WriteAddr += secremain; + NumByteToWrite -= secremain; + if (NumByteToWrite > 4096) + { + secremain = 4096; + } + else + { + secremain = NumByteToWrite; + } + } + } +} + +void W25QXX_Erase_Chip(void) +{ + W25QXX_Write_Enable(); + W25QXX_Wait_Busy(); + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_ChipErase); + W25QXX_CS(1); + W25QXX_Wait_Busy(); +} + +void W25QXX_Erase_Sector(uint32_t Dst_Addr) +{ + Dst_Addr *= 4096; + W25QXX_Write_Enable(); + W25QXX_Wait_Busy(); + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_SectorErase); + if (W25QXX_TYPE == W25Q256) + { + SPI2_ReadWriteByte((uint8_t)((Dst_Addr) >> 24)); + } + SPI2_ReadWriteByte((uint8_t)((Dst_Addr) >> 16)); + SPI2_ReadWriteByte((uint8_t)((Dst_Addr) >> 8)); + SPI2_ReadWriteByte((uint8_t)Dst_Addr); + W25QXX_CS(1); + W25QXX_Wait_Busy(); +} + +void W25QXX_Wait_Busy(void) +{ + while ((W25QXX_ReadSR(1) & 0x01) == 0x01); +} + +void W25QXX_PowerDown(void) +{ + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_PowerDown); + W25QXX_CS(1); + HAL_Delay(3); +} + +void W25QXX_WAKEUP(void) +{ + W25QXX_CS(0); + SPI2_ReadWriteByte(W25X_ReleasePowerDown); + W25QXX_CS(1); + HAL_Delay(3); +} + +#endif /* W25QXX_USE_QSPI / W25QXX_USE_SPI */ diff --git a/bspMCU/w25qxx.h b/bspMCU/w25qxx.h deleted file mode 100644 index 939147e..0000000 --- a/bspMCU/w25qxx.h +++ /dev/null @@ -1,77 +0,0 @@ -#ifndef __W25QXX_H -#define __W25QXX_H -#include "common.h" -////////////////////////////////////////////////////////////////////////////////// -//本程序只供学习使用，未经作者许可，不得用于其它任何用途 -//ALIENTEK STM32F429开发板 -//W25QXX驱动代码 -//正点原子@ALIENTEK -//技术论坛:www.openedv.com -//创建日期:2016/1/16 -//版本：V1.0 -//版权所有，盗版必究。 -//Copyright(C) 广州市星翼电子科技有限公司 2014-2024 -//All rights reserved -////////////////////////////////////////////////////////////////////////////////// - -//W25X系列/Q系列芯片列表 -//W25Q80 ID 0XEF13 -//W25Q16 ID 0XEF14 -//W25Q32 ID 0XEF15 -//W25Q64 ID 0XEF16 -//W25Q128 ID 0XEF17 -//W25Q256 ID 0XEF18 -#define W25Q80 0XEF13 -#define W25Q16 0XEF14 -#define W25Q32 0XEF15 -#define W25Q64 0XEF16 -#define W25Q128 0XEF17 -#define W25Q256 0XEF18 - -extern uint16_t W25QXX_TYPE; //定义W25QXX芯片型号 - -//W25QXX的片选信号 -#define W25QXX_CS(n) (n?HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port,W25QXX_CS_Pin,GPIO_PIN_SET):HAL_GPIO_WritePin(W25QXX_CS_GPIO_Port,W25QXX_CS_Pin,GPIO_PIN_RESET)) - -////////////////////////////////////////////////////////////////////////////////// -//指令表 -#define W25X_WriteEnable 0x06 -#define W25X_WriteDisable 0x04 -#define W25X_ReadStatusReg1 0x05 -#define W25X_ReadStatusReg2 0x35 -#define W25X_ReadStatusReg3 0x15 -#define W25X_WriteStatusReg1 0x01 -#define W25X_WriteStatusReg2 0x31 -#define W25X_WriteStatusReg3 0x11 -#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 W25X_Enable4ByteAddr 0xB7 -#define W25X_Exit4ByteAddr 0xE9 - -void W25QXX_Init(void); -uint16_t W25QXX_ReadID(void); //读取FLASH ID -uint8_t W25QXX_ReadSR(uint8_t regno); //读取状态寄存器 -void W25QXX_4ByteAddr_Enable(void); //使能4字节地址模式 -void W25QXX_Write_SR(uint8_t regno,uint8_t sr); //写状态寄存器 -void W25QXX_Write_Enable(void); //写使能 -void W25QXX_Write_Disable(void); //写保护 -void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite); -void W25QXX_Read(uint8_t* pBuffer,uint32_t ReadAddr,uint16_t NumByteToRead); //读取flash -void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);//写入flash -void W25QXX_Erase_Chip(void); //整片擦除 -void W25QXX_Erase_Sector(uint32_t Dst_Addr); //扇区擦除 -void W25QXX_Wait_Busy(void); //等待空闲 -void W25QXX_PowerDown(void); //进入掉电模式 -void W25QXX_WAKEUP(void); //唤醒 - -#endif diff --git a/library/common/common_cfg.h.in b/library/common/common_cfg.h.in index 63bd9d7..83ad9ab 100644 --- a/library/common/common_cfg.h.in +++ b/library/common/common_cfg.h.in @@ -29,6 +29,7 @@ extern "C"{ #cmakedefine USE_LUA_ST_CAN #cmakedefine USE_FREERTOS #cmakedefine USE_LWIP +#cmakedefine USE_W25QXX #define LUACOM_ID @LUACOM_ID@ #define PRINT_ID @PRINT_ID@ diff --git a/library/common/include/common.h b/library/common/include/common.h index 5419730..30ee40a 100644 --- a/library/common/include/common.h +++ b/library/common/include/common.h @@ -160,9 +160,6 @@ int Rd_RegularFileExists(const char *_psPath); char *Rd_GetBuildTime(void); uint16_t Rd_modbusCRC16(const uint8_t *data, uint16_t length); -#ifdef BUILD_LOG -extern void Rd_ElogEnableStrong(void); -#endif #ifdef BUILD_PLATFORM_LINUX extern void Rd_LinuxEnableStrong(void); extern void Rd_ThreadEnableStrong(void); @@ -172,7 +169,7 @@ extern void Rd_Win32EnableStrong(void); #endif #ifdef BUILD_LOG - #define INIT_LOG_PART() do { Rd_ElogEnableStrong(); } while(0) + #define INIT_LOG_PART() do { extern void Rd_ElogInit(void); Rd_ElogInit(); } while(0) #else #define INIT_LOG_PART() do {} while(0) #endif @@ -189,13 +186,41 @@ extern void Rd_Win32EnableStrong(void); #define INIT_WIN32_PART() do {} while(0) #endif +#if LV_USE_FS_LITTLEFS || defined(USE_W25QXX) + #define INIT_LITTLEFS_PART() do { extern void Rd_LittleFSInit(void); Rd_LittleFSInit(); } while(0) +#else + #define INIT_LITTLEFS_PART() do {} while(0) +#endif + +#if LV_USE_FS_FATFS + #define INIT_FATFS_PART() do { extern void Rd_FatFSInit(void); Rd_FatFSInit(); } while(0) +#else + #define INIT_FATFS_PART() do {} while(0) +#endif + +#if LV_USE_FS_WIN32 == 1 || LV_USE_FS_POSIX == 1 || LV_USE_FS_LITTLEFS == 1 || LV_USE_FS_FATFS == 1 #define RD_INIT() \ do { \ + extern void Rd_MemPoolInit_Auto(void); \ + Rd_MemPoolInit_Auto(); \ + INIT_LINUX_PART(); \ + INIT_WIN32_PART(); \ + INIT_LITTLEFS_PART(); \ + INIT_FATFS_PART(); \ + extern void lv_init(void); \ + lv_init(); \ INIT_LOG_PART(); \ + } while(0) +#else +#define RD_INIT() \ + do { \ extern void Rd_MemPoolInit_Auto(void); \ Rd_MemPoolInit_Auto(); \ INIT_LINUX_PART(); \ INIT_WIN32_PART(); \ + INIT_LITTLEFS_PART(); \ + INIT_LOG_PART(); \ } while(0) +#endif #endif /* end of include guard: COMMON_H */ diff --git a/library/common/rd_stdio.c b/library/common/rd_stdio.c index b888a37..64f3a87 100644 --- a/library/common/rd_stdio.c +++ b/library/common/rd_stdio.c @@ -17,6 +17,9 @@ ******************************************************************************/ #include "rd_stdio.h" +#if LV_USE_FS_LITTLEFS +#include "../../lvgl/lvgl.h" +#endif /*----------------------------------------------* * 外部变量说明 * *----------------------------------------------*/ @@ -45,63 +48,303 @@ * 宏定义 * *----------------------------------------------*/ +#ifdef USE_W25QXX +#include "../littlefs/include/lfs.h" +#include "../littlefs/include/lfs_flashbd.h" +lfs_t g_lfs; +lfs_flashbd_t g_bd; +struct lfs_flashbd_config g_bd_cfg; +struct lfs_config g_cfg; +#endif + +#ifndef WIN32 WEAK void *Rd_Fopen(const char *path, const char *mode) { - return NULL; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + lv_fs_mode_t lv_mode; + if (strchr(mode, 'r') != NULL) lv_mode = LV_FS_MODE_RD; + else lv_mode = LV_FS_MODE_WR; + + lv_fs_file_t *file = RD_MALLOC(sizeof(lv_fs_file_t)); + if (NULL == file) return NULL; + lv_fs_res_t res = lv_fs_open(file, path, lv_mode); + if (LV_FS_RES_OK == res) + { + return (void *)file; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return NULL; + } +#else + const char *p = path; + lfs_file_t *file = RD_MALLOC(sizeof(lfs_file_t)); + int flags; + if (strlen(path) >= 2 && path[1] == ':') p = path + 2; + if (strchr(mode, 'r') != NULL) flags = LFS_O_RDONLY; + else flags = LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC; + int err = lfs_file_open(&g_lfs, file, p, flags); + if(err) return NULL; + else return (void *)file; +#endif +#endif + return NULL; } WEAK void *Rd_Open(const char *path, int flags, mode_t mode) { - return NULL; + return NULL; } WEAK ssize_t Rd_Mread(void *buf, size_t count, void *file) { - return RD_FAILURE; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + uint32_t size = 0; + lv_fs_file_t *fp = (lv_fs_file_t *)file; + lv_fs_res_t res = lv_fs_read(fp, buf, count, &size); + if (LV_FS_RES_OK == res) + { + return (ssize_t)size; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return RD_FAILURE; + } +#else + lfs_ssize_t size = 0; + lfs_file_t *fp = (lfs_file_t *)file; + size = lfs_file_read(&g_lfs, fp, buf, count); + if (size >= 0) + { + return (ssize_t)size; + } + else + { + printf("%s[%d]fs errno is %ld\n", __FILE__, __LINE__, size); + return RD_FAILURE; + } +#endif +#endif + return RD_FAILURE; } WEAK ssize_t Rd_Mwrite(const void *buf, size_t count, void *file) { - return RD_FAILURE; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + uint32_t size = 0; + lv_fs_file_t *fp = (lv_fs_file_t *)file; + lv_fs_res_t res = lv_fs_write(fp, buf, count, &size); + if (LV_FS_RES_OK == res) + { + return (ssize_t)size; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return RD_FAILURE; + } +#else + uint32_t size = 0; + lfs_file_t *fp = (lfs_file_t *)file; + size = lfs_file_write(&g_lfs, fp, buf, count); + if (size >= 0) + { + return (ssize_t)size; + } + else + { + printf("%s[%d]fs errno is %ld\n", __FILE__, __LINE__, size); + return RD_FAILURE; + } +#endif +#endif + return RD_FAILURE; } WEAK int Rd_Mclose(void *file) { - return RD_FAILURE; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + lv_fs_file_t *fp = (lv_fs_file_t *)file; + lv_fs_close(fp); + RD_FREE(file); + return 0; +#else + lfs_file_t *fp = (lfs_file_t *)file; + lfs_file_close(&g_lfs, fp); + RD_FREE(file); + return 0; +#endif +#endif + return RD_FAILURE; } WEAK int Rd_Mseek(void *file, long offset, int whence) { - return RD_FAILURE; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + lv_fs_file_t *fp = (lv_fs_file_t *)file; + lv_fs_whence_t lv_whence; + if (SEEK_END == whence) lv_whence = LV_FS_SEEK_END; + else if (SEEK_CUR == whence) lv_whence = LV_FS_SEEK_CUR; + else lv_whence = LV_FS_SEEK_SET; + + lv_fs_res_t res = lv_fs_seek(fp, offset, lv_whence); + if (LV_FS_RES_OK == res) + { + return offset; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return RD_FAILURE; + } +#else + lfs_file_t *fp = (lfs_file_t *)file; + int flags; + if (SEEK_END == whence) flags = LFS_SEEK_END; + else if (SEEK_CUR == whence) flags = LFS_SEEK_CUR; + else flags = LFS_SEEK_SET; + + int res = lfs_file_seek(&g_lfs, fp, offset, flags); + if (res >= 0) + { + return offset; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return RD_FAILURE; + } +#endif +#endif + return RD_FAILURE; } WEAK char *Rd_Mgets(char *buf, int size, void *file) { - return NULL; + if (!file || !buf || size <= 0) return NULL; + int i = 0; + char c; + + while (i < size - 1) + { + ssize_t n = Rd_Mread(&c, 1, file); + if (n != 0) + { + // 读到 EOF 或 错误（Rd_Mread 返回 0 表示读满请求的字节数） + if (i == 0) return NULL; // 什么都没读到 + break; // 读到了部分数据，也返回 + } + + buf[i++] = c; + if (c == '\n') break; // 遇到换行符停止 + } + + buf[i] = '\0'; // 添加字符串结束符 + return buf; } WEAK int Rd_Mputs(const char *str, void *file) { - return RD_FAILURE; + if (!file || !str) return RD_FAILURE; + size_t len = RD_STRLEN(str); + ssize_t written = Rd_Mwrite(str, len, file); + return (written == (ssize_t)len) ? RD_SUCCESS : RD_FAILURE; } WEAK long Rd_Mtell(void *file) { - return RD_FAILURE; +#ifdef USE_W25QXX +#if LV_USE_FS_LITTLEFS + uint32_t pos = 0; + lv_fs_file_t *fp = (lv_fs_file_t *)file; + lv_fs_res_t res = lv_fs_tell(fp, &pos); + if (LV_FS_RES_OK == res) + { + return pos; + } + else + { + printf("%s[%d]fs errno is %d\n", __FILE__, __LINE__, res); + return RD_FAILURE; + } +#else + lfs_file_t *fp = (lfs_file_t *)file; + long pos = lfs_file_tell(&g_lfs, fp); + if (pos >= 0) + { + return pos; + } + else + { + printf("%s[%d]fs errno is %ld\n", __FILE__, __LINE__, pos); + return RD_FAILURE; + } +#endif +#endif + return RD_FAILURE; } WEAK int Rd_fflush(void *file) { - return RD_FAILURE; + return RD_SUCCESS; } WEAK int Rd_remove(const char *filename) { +#ifdef USE_W25QXX + const char *p = filename; + if (strlen(filename) >= 2 && filename[1] == ':') p = filename + 2; + int err = lfs_remove(&g_lfs, p); + if (err) { printf("lfs_remove(%s) failed: %d\n", p, err); return RD_FAILURE; } + return RD_SUCCESS; +#else return RD_FAILURE; +#endif } WEAK int Rd_rename(const char *oldpath, const char *newpath) { +#ifdef USE_W25QXX + const char *o = oldpath, *n = newpath; + if (strlen(oldpath) >= 2 && oldpath[1] == ':') o = oldpath + 2; + if (strlen(newpath) >= 2 && newpath[1] == ':') n = newpath + 2; + int err = lfs_rename(&g_lfs, o, n); + if (err) { printf("lfs_rename(%s,%s) failed: %d\n", o, n, err); return RD_FAILURE; } + return RD_SUCCESS; +#else return RD_FAILURE; +#endif +} + +WEAK void Rd_LittleFSInit(void) +{ +#ifdef USE_W25QXX + // 1MB = 256 个扇区，从地址 1M 开始全部使用，即前边空出1M留做他用（1*1024*1024表示空出1M，12*256表示使用12M空间） + lfs_flashbd_default_config(&g_cfg, &g_bd, &g_bd_cfg, 1 * 1024 * 1024, 12 * 256, NULL, NULL, NULL); + + int err = lfs_mount(&g_lfs, &g_cfg); + if (err) + { + printf("mount error format...\n"); + lfs_format(&g_lfs, &g_cfg); + lfs_mount(&g_lfs, &g_cfg); + } + return; +#else + return; +#endif +} + +WEAK void Rd_FatFSInit(void) +{ + return; } +#endif diff --git a/lua/lua.c b/lua/lua.c index 62ef005..969c96c 100644 --- a/lua/lua.c +++ b/lua/lua.c @@ -1,4 +1,5 @@ #include "lua_base.h" +#include "rd_stdio.h" static char *history_buffer[MAX_HISTORY_LINES]; // 指针数组 static int history_count = 0; // 当前存储了多少条 @@ -440,10 +441,75 @@ static int l_name(lua_State *L) return 0; } +static int l_echo(lua_State *L) +{ + size_t len; + const char *str = luaL_checklstring(L, 1, &len); + size_t plen; + const char *path = luaL_checklstring(L, 2, &plen); + int ret = -1; + + void *fp = Rd_Fopen(path, "w"); + if (fp != NULL) + { + ret = Rd_Mwrite(str, len, fp); + Rd_Mclose(fp); + } + + lua_pushinteger(L, ret); + return 1; +} + +static int l_cat(lua_State *L) +{ + size_t len; + const char *path = luaL_checklstring(L, 1, &len); + char str[64] = {0}; + + void *fp = Rd_Fopen(path, "r"); + if (fp != NULL) + { + Rd_Mread(str, sizeof(str), fp); + Rd_Mclose(fp); + lua_pushstring(L, str); + } + else + { + lua_pushstring(L, ""); + } + return 1; +} + +static int l_mv(lua_State *L) +{ + size_t len; + const char *oldpath = luaL_checklstring(L, 1, &len); + size_t plen; + const char *newpath = luaL_checklstring(L, 2, &plen); + + Rd_rename(oldpath, newpath); + + return 0; +} + +static int l_rm(lua_State *L) +{ + size_t len; + const char *path = luaL_checklstring(L, 1, &len); + + Rd_remove(path); + + return 0; +} + static int luaopen_default(lua_State *L) { lua_register_help(L, "help", l_help, "Show this help message"); lua_register_help(L, "name", l_name, "Show build time"); + lua_register_help(L, "echo", l_echo, "eg: echo(\"Hello\", \"C:a.txt\")"); + lua_register_help(L, "cat", l_cat, "eg: cat(\"C:a.txt\")"); + lua_register_help(L, "mv", l_mv, "eg: mv(\"C:a.txt\", \"C:b.txt\")"); + lua_register_help(L, "rm", l_rm, "eg: rm(\"C:a.txt\")"); return 0; }