LiZongdi
/
robot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

w25qxx移植成功

paint_robot_new-v1.5
Lizongdi 2 weeks ago
parent
281ba1c995
commit
44f822e2c1
9 changed files with 1171 additions and 402 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      CMakeLists.txt
  2. 96
      bspMCU/include/w25qxx.h
  3. 22
      bspMCU/l_stm32.c
  4. 862
      bspMCU/w25qxx.c
  5. 77
      bspMCU/w25qxx.h
  6. 1
      library/common/common_cfg.h.in
  7. 33
      library/common/include/common.h
  8. 249
      library/common/rd_stdio.c
  9. 66
      lua/lua.c

1
CMakeLists.txt
View File

@ -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)

96
bspMCU/include/w25qxx.h
View File

@ -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 */

22
bspMCU/l_stm32.c
View File

@ -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;

862
bspMCU/w25qxx.c
View File

@ -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; //返回收到的数据
HAL_SPI_TransmitReceive(&W25QXXSPI, &TxData, &Rxdata, 1, 1000);
return Rxdata;
}
//初始化SPI FLASH的IO口
/* 初始化 SPI FLASH 的 IO 口 */
void W25QXX_Init(void)
{
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字节地址模式
temp = W25QXX_ReadSR(3);
if ((temp & 0x01) == 0)
{
W25QXX_CS(0); //选中
SPI2_ReadWriteByte(W25X_Enable4ByteAddr);//发送进入4字节地址模式指令
W25QXX_CS(1); //取消片选
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
//返回值:状态寄存器值
/** 使能 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)
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;
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); //取消片选
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)
/* 写状态寄存器 */
void W25QXX_Write_SR(uint8_t regno, uint8_t sr)
{
uint8_t command=0;
switch(regno)
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;
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); //取消片选
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_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); //取消片选
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_WriteDisable);
W25QXX_CS(1);
}
//读取芯片ID
//返回值如下:
//0XEF13,表示芯片型号为W25Q80
//0XEF14,表示芯片型号为W25Q16
//0XEF15,表示芯片型号为W25Q32
//0XEF16,表示芯片型号为W25Q64
//0XEF17,表示芯片型号为W25Q128
//0XEF18,表示芯片型号为W25Q256
uint16_t W25QXX_ReadID(void)
{
uint16_t Temp = 0;
W25QXX_CS(0);
SPI2_ReadWriteByte(0x90);//发送读取ID命令
SPI2_ReadWriteByte(0x90);
SPI2_ReadWriteByte(0x00);
SPI2_ReadWriteByte(0x00);
SPI2_ReadWriteByte(0x00);
Temp|=SPI2_ReadWriteByte(0xFF)<<8;
Temp|=SPI2_ReadWriteByte(0xFF);
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)
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位
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) >> 16));
SPI2_ReadWriteByte((uint8_t)((ReadAddr) >> 8));
SPI2_ReadWriteByte((uint8_t)ReadAddr);
for(i=0;i<NumByteToRead;i++)
for (i = 0; i < NumByteToRead; i++)
{
pBuffer[i]=SPI2_ReadWriteByte(0XFF); //循环读数
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)
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_Write_Enable();
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_PageProgram);
if (W25QXX_TYPE == W25Q256)
{
SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>24));
SPI2_ReadWriteByte((uint8_t)((WriteAddr) >> 24));
}
SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>16)); //发送24bit地址
SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>8));
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(pBuffer[i]);//循环写数
W25QXX_CS(1); //取消片选
W25QXX_Wait_Busy(); //等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
for (i = 0; i < NumByteToWrite; i++)
{
SPI2_ReadWriteByte(pBuffer[i]);
}
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)pageremain=NumByteToWrite;//不大于256个字节
while(1)
pageremain = 256 - WriteAddr % 256;
if (NumByteToWrite <= pageremain)
{
W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
if(NumByteToWrite==pageremain)break;//写入结束了
else //NumByteToWrite>pageremain
pageremain = NumByteToWrite;
}
while (1)
{
pBuffer+=pageremain;
WriteAddr+=pageremain;
NumByteToWrite-=pageremain; //减去已经写入了的字节数
if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
else pageremain=NumByteToWrite; //不够256个字节了
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;
}
}
}
};
}
//写SPI FLASH
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
uint8_t W25QXX_BUFFER[4096];
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t 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;//扇区剩余空间大小
//printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
while(1)
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++)//校验数据
W25QXX_Read(W25QXX_BUF, secpos * 4096, 4096);
for (i = 0; i < secremain; i++)
{
if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除
if (W25QXX_BUF[secoff + i] != 0xFF)
{
break;
}
}
if(i<secremain)//需要擦除
if (i < secremain)
{
W25QXX_Erase_Sector(secpos);//擦除这个扇区
for(i=0;i<secremain;i++) //复制
W25QXX_Erase_Sector(secpos);
for (i = 0; i < secremain; i++)
{
W25QXX_BUF[i+secoff]=pBuffer[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//写入未结束
W25QXX_Write_NoCheck(W25QXX_BUF, secpos * 4096, 4096);
}
else
{
secpos++;//扇区地址增1
secoff=0;//偏移位置为0
pBuffer+=secremain; //指针偏移
WriteAddr+=secremain;//写地址偏移
NumByteToWrite-=secremain; //字节数递减
if(NumByteToWrite>4096)secremain=4096; //下一个扇区还是写不完
else secremain=NumByteToWrite; //下一个扇区可以写完了
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(); //SET WEL
W25QXX_Write_Enable();
W25QXX_Wait_Busy();
W25QXX_CS(0); //使能器件
SPI2_ReadWriteByte(W25X_ChipErase); //发送片擦除命令
W25QXX_CS(1); //取消片选
W25QXX_Wait_Busy(); //等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个扇区的最少时间:150ms
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_ChipErase);
W25QXX_CS(1);
W25QXX_Wait_Busy();
}
void W25QXX_Erase_Sector(uint32_t Dst_Addr)
{
//监视falsh擦除情况,测试用
//printf("fe:%x\r\n",Dst_Addr);
Dst_Addr*=4096;
W25QXX_Write_Enable(); //SET WEL
Dst_Addr *= 4096;
W25QXX_Write_Enable();
W25QXX_Wait_Busy();
W25QXX_CS(0); //使能器件
SPI2_ReadWriteByte(W25X_SectorErase); //发送扇区擦除指令
if(W25QXX_TYPE==W25Q256) //如果是W25Q256的话地址为4字节的，要发送最高8位
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_SectorErase);
if (W25QXX_TYPE == W25Q256)
{
SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>24));
SPI2_ReadWriteByte((uint8_t)((Dst_Addr) >> 24));
}
SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>16)); //发送24bit地址
SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>8));
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(); //等待擦除完成
W25QXX_CS(1);
W25QXX_Wait_Busy();
}
//等待空闲
void W25QXX_Wait_Busy(void)
{
while((W25QXX_ReadSR(1)&0x01)==0x01); // 等待BUSY位清空
while ((W25QXX_ReadSR(1) & 0x01) == 0x01);
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
W25QXX_CS(0); //使能器件
SPI2_ReadWriteByte(W25X_PowerDown); //发送掉电命令
W25QXX_CS(1); //取消片选
HAL_Delay(3); //等待TPD
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_PowerDown);
W25QXX_CS(1);
HAL_Delay(3);
}
//唤醒
void W25QXX_WAKEUP(void)
{
W25QXX_CS(0); //使能器件
SPI2_ReadWriteByte(W25X_ReleasePowerDown); // send W25X_PowerDown command 0xAB
W25QXX_CS(1); //取消片选
HAL_Delay(3); //等待TRES1
W25QXX_CS(0);
SPI2_ReadWriteByte(W25X_ReleasePowerDown);
W25QXX_CS(1);
HAL_Delay(3);
}
#endif
#endif /* W25QXX_USE_QSPI / W25QXX_USE_SPI */

77
bspMCU/w25qxx.h
View File

@ -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

1
library/common/common_cfg.h.in
View File

@ -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@

33
library/common/include/common.h
View File

@ -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 */

249
library/common/rd_stdio.c
View File

@ -17,6 +17,9 @@
******************************************************************************/
#include "rd_stdio.h"
#if LV_USE_FS_LITTLEFS
#include "../../lvgl/lvgl.h"
#endif
/*----------------------------------------------*
* 外部变量说明 *
*----------------------------------------------*/
@ -45,8 +48,48 @@
* 宏定义 *
*----------------------------------------------*/
#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)
{
#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;
}
@ -57,51 +100,251 @@ WEAK void *Rd_Open(const char *path, int flags, mode_t mode)
WEAK ssize_t Rd_Mread(void *buf, size_t count, void *file)
{
#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)
{
#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)
{
#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)
{
#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)
{
#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

66
lua/lua.c
View File

@ -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;
}

Write Preview
Loading…
Cancel
Save