\n\u94fe\u63a5: https:\/\/pan.baidu.com\/s\/1323CdUaAsV1m6juSMh9i9g?pwd=pbbn \u63d0\u53d6\u7801: pbbn\u00a0
\n–\u6765\u81ea\u767e\u5ea6\u7f51\u76d8\u8d85\u7ea7\u4f1a\u5458v4\u7684\u5206\u4eab<\/h2>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091808-696ca5502a960.png\")
<\/h2>\n\u672c\u6587\u5c06\u901a\u8fc7\u5206\u6790\u63d0\u4f9b\u7684\u4ee3\u7801\u548c\u6d41\u7a0b\u56fe，\u8be6\u7ec6\u89e3\u91caSTM32\u4e0eSST39VF800A Flash\u5b58\u50a8\u5668\u4e4b\u95f4\u7684\u64cd\u4f5c\u6d41\u7a0b，\u7279\u522b\u662f\u5b57\u7f16\u7a0b\u3001\u6247\u533a\u64e6\u9664\u548c\u8bbe\u5907ID\u8bfb\u53d6\u7684\u5b9e\u73b0\u3002<\/p>\n
\u914dFMC\u597d\u540e\u4f60\u5f80BANK\u4e2d\u5730\u5740\u8d4b\u503c，FMC\u4f1a\u81ea\u52a8\u6839\u636e\u5730\u8d28\u4e0e\u6570\u503c\u751f\u6210\u5bf9\u5e94\u4fe1\u53f7\u65f6\u5e8f![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091808-696ca550ee889.png\")
<\/p>\n
\u6bd4\u5982：![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091809-696ca55100c84.png\")
<\/p>\n
\u5c31\u662f：<\/p>\n
#define FLASH_WORD_TO_BYTE(addr_word) ((addr_word) << 1)<\/p>\n
*((volatile uint16_t*)(0x60000000 + FLASH_WORD_TO_BYTE(0x2AAA))) = (0x0055);<\/p>\n
\u4ed6\u5c31\u4f1a\u751f\u6210\u5f80\u5730\u57400x00002AAA\u5730\u5740\u8d4b\u503c<\/p>\n
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091809-696ca55106e6e.png\")
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091809-696ca5511fb00.png\")
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091809-696ca55136e38.png\")
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/01\/20260118091809-696ca55157010.png\")
<\/p>\n
\u4ece\u6d41\u7a0b\u56fe\u4e2d\u53ef\u4ee5\u770b\u51fa，SST39VF800A\u7684\u6240\u6709\u64cd\u4f5c\u90fd\u9075\u5faa\u547d\u4ee4\u5e8f\u5217\u6a21\u5f0f\u3002\u4e0eRAM\u7684\u7b80\u5355\u8bfb\u5199\u4e0d\u540c，Flash\u9700\u8981\u7279\u5b9a\u7684"\u89e3\u9501-\u547d\u4ee4-\u6570\u636e\/\u5730\u5740"\u5e8f\u5217\u6765\u6267\u884c\u7f16\u7a0b\u3001\u64e6\u9664\u7b49\u64cd\u4f5c\u3002<\/p>\n
\u4e09\u5468\u671f\u89e3\u9501：\u6240\u6709\u547d\u4ee4\u90fd\u9700\u8981\u5148\u53d1\u9001\u4e24\u4e2a\u89e3\u9501\u5e8f\u5217<\/p>\n<\/li>\n
\u5730\u5740\/\u6570\u636e\u590d\u7528：\u76f8\u540c\u5730\u5740（5555H\/2AAAH）\u5728\u4e0d\u540c\u547d\u4ee4\u4e2d\u4f20\u8f93\u4e0d\u540c\u6570\u636e<\/p>\n<\/li>\n
\u72b6\u6001\u68c0\u6d4b：\u64cd\u4f5c\u5b8c\u6210\u540e\u9700\u8981\u68c0\u6d4bToggle Bit\u6216Data# Polling<\/p>\n<\/li>\n
\u6d41\u7a0b\u56fe\u8981\u6c42：<\/p>\n<\/p>\n
1. \u5411\u5730\u57405555H\u5199\u5165\u6570\u636e00AAH
\n2. \u5411\u5730\u57402AAAH\u5199\u5165\u6570\u636e0055H<\/p>\n
\u4ee3\u7801\u5b9e\u73b0：<\/p>\n
static void SST_SendUnlockSequence(void)
\n{
\n \/* First unlock cycle – \u4f7f\u7528Flash\u5b57\u5730\u5740 *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_UNLOCK1); \/\/ 0x5555 -> 0x00AA<\/p>\n
\/* \u5c0f\u5ef6\u65f6\u786e\u4fdd\u547d\u4ee4\u5b8c\u6210 *\/
\n Delay_Us(1);<\/p>\n
\/* Second unlock cycle – \u4f7f\u7528Flash\u5b57\u5730\u5740 *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_2, SST_CMD_UNLOCK2); \/\/ 0x2AAA -> 0x0055<\/p>\n
\/* \u5c0f\u5ef6\u65f6\u786e\u4fdd\u547d\u4ee4\u5b8c\u6210 *\/
\n Delay_Us(1);
\n}<\/p>\n
\u6ce8\u610f：\u4ee3\u7801\u4e2d\u7684\u5730\u5740\u662fFlash\u5b57\u5730\u5740，\u4e0d\u662fSTM32\u7684\u5b57\u8282\u5730\u5740\u3002\u5b8fSST_WRITE_CMD\u5185\u90e8\u4f1a\u5c06\u5b57\u5730\u5740\u8f6c\u6362\u4e3a\u5b57\u8282\u5730\u5740\u3002<\/p>\n
\u56fe18\u6d41\u7a0b：<\/p>\n
1. \u89e3\u9501\u5e8f\u5217（\u524d\u4e24\u6b65）
\n2. \u54115555H\u5199\u5165A0H
\n3. \u5411\u76ee\u6807\u5730\u5740\u5199\u5165\u6570\u636e
\n4. \u7b49\u5f85\u64cd\u4f5c\u5b8c\u6210<\/p>\n
\u4ee3\u7801\u5b9e\u73b0：<\/p>\n
static bool SST_ByteProgram(uint32_t address, uint16_t data)
\n{
\n \/* 1-3\u6b65：\u89e3\u9501\u5e8f\u5217 + \u7f16\u7a0b\u547d\u4ee4 *\/
\n SST_SendUnlockSequence(); \/\/ \u89e3\u9501\u6b65\u9aa41-2
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_PROGRAM); \/\/ \u6b65\u9aa43: 0x5555 -> 0x00A0
\n Delay_Us(1);<\/p>\n
\/* 4\u6b65：\u5411\u76ee\u6807\u5730\u5740\u5199\u5165\u6570\u636e *\/
\n NOR_WRITE_BYTE(address, data); \/\/ \u5199\u5165\u7528\u6237\u6570\u636e<\/p>\n
\/* 5\u6b65：\u7b49\u5f85\u7f16\u7a0b\u5b8c\u6210（\u4f7f\u7528Toggle Bit\u6216Data# Polling） *\/
\n return SST_WaitForOperationComplete(address, data, false);
\n}<\/p>\n
\u91cd\u8981\u8bf4\u660e：<\/p>\n
address\u53c2\u6570\u662f\u5b57\u8282\u5730\u5740，\u9700\u8981\u4fdd\u8bc1\u5b57\u5bf9\u9f50（\u5076\u6570\u5730\u5740）<\/p>\n<\/li>\n
\u5199\u5165\u64cd\u4f5c\u524d\u5fc5\u987b\u786e\u4fdd\u76ee\u6807\u5730\u5740\u5df2\u64e6\u9664（\u503c\u4e3a0xFFFF）<\/p>\n<\/li>\n<\/ul>\n
<\/h4>\n\u6839\u636e\u6570\u636e\u624b\u518c\u76846\u5468\u671f\u64e6\u9664\u5e8f\u5217：<\/p>\n
1. \u89e3\u9501\u5e8f\u5217（5555H->AAH, 2AAAH->55H）
\n2. \u518d\u6b21\u54115555H\u5199\u516580H
\n3. \u518d\u6b21\u89e3\u9501\u5e8f\u5217（5555H->AAH, 2AAAH->55H）
\n4. \u5411\u6247\u533a\u5730\u5740\u5199\u516530H<\/p>\n
\u4ee3\u7801\u5b9e\u73b0：<\/p>\n
static bool SST_SectorErase(uint32_t sector_address)
\n{
\n \/* \u8f6c\u6362\u4e3aFlash\u5b57\u5730\u5740 *\/
\n uint16_t sector_word_addr = FLASH_BYTE_TO_WORD(sector_address) & 0x7FFF;<\/p>\n
\/* 1-2\u6b65：\u89e3\u9501\u5e8f\u5217 + \u64e6\u9664\u8bbe\u7f6e\u547d\u4ee4 *\/
\n SST_SendUnlockSequence(); \/\/ \u6b65\u9aa41-2
\n SST_WRITE_CMD(SST_CMD_ADDR_1, 0x0080); \/\/ \u6b65\u9aa43: 5555H -> 80H
\n Delay_Us(1);<\/p>\n
\/* 3-4\u6b65：\u518d\u6b21\u89e3\u9501\u5e8f\u5217 + \u6247\u533a\u64e6\u9664\u786e\u8ba4 *\/
\n SST_SendUnlockSequence(); \/\/ \u6b65\u9aa44-5
\n NOR_WRITE_BYTE(sector_address, SST_CMD_SECTOR_ERASE); \/\/ \u6b65\u9aa46: \u6247\u533a\u5730\u5740 -> 30H<\/p>\n
\/* \u7b49\u5f85\u64e6\u9664\u5b8c\u6210 *\/
\n return SST_WaitForOperationComplete(sector_address, 0xFFFF, true);
\n}<\/p>\n
\u5173\u952e\u70b9：<\/p>\n
\u64e6\u9664\u64cd\u4f5c\u9488\u5bf9\u6574\u4e2a4KB\u6247\u533a<\/p>\n<\/li>\n
\u5fc5\u987b\u4f7f\u7528\u6247\u533a\u5bf9\u9f50\u7684\u5730\u5740（\u5730\u5740\u4f4e12\u4f4d\u4e3a0）<\/p>\n<\/li>\n
\u64e6\u9664\u65f6\u95f4\u8f83\u957f（\u6700\u957f25ms），\u9700\u8981\u9002\u5f53\u7b49\u5f85<\/p>\n<\/li>\n<\/ul>\n
<\/h4>\n\u56fe20\u8f6f\u4ef6ID\u5165\u53e3\u5e8f\u5217：<\/p>\n
1. \u89e3\u9501\u5e8f\u5217（5555H->AAH, 2AAAH->55H）
\n2. \u54115555H\u5199\u516590H
\n3. \u8bfb\u53d6\u8bbe\u5907ID
\n4. \u9000\u51fa\u8f6f\u4ef6ID\u6a21\u5f0f<\/p>\n
\u4ee3\u7801\u5b9e\u73b0：<\/p>\n
static bool SST_ReadID(uint16_t* manufacturer_id, uint16_t* device_id)
\n{
\n \/* 1-2\u6b65：\u89e3\u9501\u5e8f\u5217 + \u8fdb\u5165\u8f6f\u4ef6ID\u6a21\u5f0f *\/
\n SST_SendUnlockSequence(); \/\/ \u89e3\u9501\u5e8f\u5217
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_AUTOSELECT); \/\/ 5555H -> 90H
\n Delay_Us(10);<\/p>\n
\/* 3\u6b65：\u8bfb\u53d6\u5236\u9020\u5546ID\u548c\u5668\u4ef6ID *\/
\n *manufacturer_id = NOR_READ_WORD(0x0000); \/\/ \u5b57\u5730\u57400000H -> \u5236\u9020\u5546ID
\n *device_id = NOR_READ_WORD(0x0001); \/\/ \u5b57\u5730\u57400001H -> \u5668\u4ef6ID<\/p>\n
\/* 4\u6b65：\u9000\u51fa\u8f6f\u4ef6ID\u6a21\u5f0f *\/
\n SST_WRITE_CMD(0x0000, SST_CMD_RESET); \/\/ \u4efb\u4f55\u5730\u5740\u5199\u5165F0H
\n Delay_Us(10);<\/p>\n
return true;
\n}<\/p>\n
ID\u5730\u5740\u8bf4\u660e：<\/p>\n
\u5236\u9020\u5546ID：\u4ece\u5b57\u5730\u57400000H\u8bfb\u53d6（\u8fd4\u56de0x00BF\u8868\u793aSST）<\/p>\n<\/li>\n
\u5668\u4ef6ID：\u4ece\u5b57\u5730\u57400001H\u8bfb\u53d6（\u8fd4\u56de0x2781\u8868\u793aSST39VF800A）<\/p>\n<\/li>\n<\/ul>\n
1. Toggle Bit\u68c0\u6d4b（\u4ee3\u7801\u4e2d\u5b9e\u73b0）<\/p>\n
static bool SST_CheckToggleBit(uint32_t address)
\n{
\n volatile uint16_t* flash_addr = (volatile uint16_t*)(NOR_FLASH_BASE_ADDR + address);
\n uint16_t read1, read2;<\/p>\n
read1 = *flash_addr; \/\/ \u7b2c\u4e00\u6b21\u8bfb\u53d6
\n read2 = *flash_addr; \/\/ \u7b2c\u4e8c\u6b21\u8bfb\u53d6<\/p>\n
\/* \u68c0\u67e5DQ6\u4f4d\u662f\u5426\u505c\u6b62\u7ffb\u8f6c *\/
\n return ((read1 & 0x0040) == (read2 & 0x0040));
\n}<\/p>\n
\u539f\u7406：\u5728\u7f16\u7a0b\/\u64e6\u9664\u671f\u95f4，DQ6\u4f4d\u4f1a\u4e0d\u65ad\u7ffb\u8f6c\u3002\u5f53\u64cd\u4f5c\u5b8c\u6210\u65f6，DQ6\u505c\u6b62\u7ffb\u8f6c\u3002<\/p>\n
2. Data# Polling\u68c0\u6d4b（\u4ee3\u7801\u4e2d\u5b9e\u73b0）<\/p>\n
static bool SST_CheckDataPolling(uint32_t address, uint16_t expected_data)
\n{
\n volatile uint16_t* flash_addr = (volatile uint16_t*)(NOR_FLASH_BASE_ADDR + address);
\n uint16_t read_data;<\/p>\n
read_data = *flash_addr;<\/p>\n
\/* \u68c0\u67e5DQ7\u4f4d\u662f\u5426\u4e0e\u671f\u671b\u6570\u636e\u5339\u914d *\/
\n return ((read_data & 0x0080) == (expected_data & 0x0080));
\n}<\/p>\n
\u539f\u7406：\u5728\u7f16\u7a0b\u671f\u95f4，\u8bfb\u53d6\u7684DQ7\u4f4d\u662f\u88ab\u5199\u5165\u6570\u636e\u7684\u53cd\u7801\u3002\u64cd\u4f5c\u5b8c\u6210\u540e，DQ7\u6062\u590d\u4e3a\u5199\u5165\u6570\u636e\u3002<\/p>\n
3. \u5185\u90e8\u5b9a\u65f6\u5668（\u672a\u5728\u4ee3\u7801\u4e2d\u4f7f\u7528）<\/p>\n
Flash\u5185\u90e8\u6709\u5b9a\u65f6\u5668\u63a7\u5236\u6700\u5927\u64cd\u4f5c\u65f6\u95f4<\/p>\n<\/li>\n
\u8d85\u65f6\u540e\u81ea\u52a8\u7ec8\u6b62\u64cd\u4f5c<\/p>\n<\/li>\n<\/ul>\n
\/* \u5c06Flash\u5b57\u5730\u5740\u8f6c\u6362\u4e3aSTM32\u5b57\u8282\u5730\u5740（\u5b57\u5730\u5740 \u00d7 2）*\/
\n#define FLASH_WORD_TO_BYTE(addr_word) ((addr_word) << 1)<\/p>\n
\/* \u5c06Flash\u5b57\u8282\u5730\u5740\u8f6c\u6362\u4e3a\u5b57\u5730\u5740（\u5b57\u8282\u5730\u5740 \u00f7 2）*\/
\n#define FLASH_BYTE_TO_WORD(addr_byte) ((addr_byte) >> 1)<\/p>\n
\/* \u57fa\u4e8e\u5b57\u5730\u5740\u7684\u8bbf\u95ee\u5b8f *\/
\n#define NOR_READ_WORD(addr_word) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + FLASH_WORD_TO_BYTE(addr_word))))<\/p>\n
\u5e94\u7528\u793a\u4f8b：<\/p>\n
\/\/ \u8bfb\u53d6\u5236\u9020\u5546ID（\u5b57\u5730\u57400x0000）
\nuint16_t mfr_id = NOR_READ_WORD(0x0000);
\n\/\/ \u5b9e\u9645\u8bbf\u95ee\u7684STM32\u5730\u5740：0x60000000 + (0x0000 << 1) = 0x60000000<\/p>\n
static bool SST_WaitForOperationComplete(uint32_t address, uint16_t expected_data, bool is_erase)
\n{
\n uint32_t timeout_us = is_erase ? SST_ERASE_TIMEOUT_MS * 1000 : SST_PROGRAM_TIMEOUT_US;<\/p>\n
while (elapsed_us < timeout_us) {
\n \/* \u5148\u5c1d\u8bd5Toggle Bit\u68c0\u6d4b *\/
\n if (SST_CheckToggleBit(address)) {
\n \/* \u518d\u4f7f\u7528Data Polling\u9a8c\u8bc1 *\/
\n if (SST_CheckDataPolling(address, expected_data)) {
\n \/* \u6700\u540e\u53cc\u91cd\u8bfb\u53d6\u786e\u4fdd\u7a33\u5b9a *\/
\n uint16_t read1 = *flash_addr;
\n uint16_t read2 = *flash_addr;<\/p>\n
if (read1 == read2) {
\n return true;
\n }
\n }
\n }
\n \/\/ … \u65f6\u95f4\u68c0\u67e5\u548c\u5ef6\u8fdf
\n }
\n return false; \/* \u8d85\u65f6 *\/
\n}<\/p>\n
\u8bbe\u8ba1\u601d\u60f3：\u7ed3\u5408\u4e24\u79cd\u68c0\u6d4b\u65b9\u6cd5，\u63d0\u9ad8\u53ef\u9760\u6027，\u907f\u514d\u8bef\u5224\u3002<\/p>\n
void LZY_WRITE_TEST(uint32_t address, uint16_t data)
\n{
\n \/\/ 1. \u5730\u5740\u8303\u56f4\u68c0\u67e5
\n if (address > MAX_MUXED_ADDRESS) { … }<\/p>\n
\/\/ 2. \u5730\u5740\u5bf9\u9f50\u68c0\u67e5（\u5fc5\u987b\u4e3a\u5076\u6570）
\n if (address & 0x01) { … }<\/p>\n
\/\/ 3. \u8bfb\u53d6\u5f53\u524d\u503c
\n uint16_t current_value = NOR_READ_BYTE(address);<\/p>\n
\/\/ 4. \u5224\u65ad\u662f\u5426\u9700\u8981\u64e6\u9664
\n if (current_value == 0xFFFF) {
\n \/\/ \u76f4\u63a5\u7f16\u7a0b
\n SST_ByteProgram(address, data);
\n } else {
\n \/\/ \u5148\u64e6\u9664\u6247\u533a
\n uint32_t sector_base = address & ~(NOR_FLASH_SECTOR_SIZE – 1);
\n SST_SectorErase(sector_base);
\n SST_ByteProgram(address, data);
\n }<\/p>\n
\/\/ 5. \u9a8c\u8bc1\u7ed3\u679c
\n uint16_t new_value = NOR_READ_BYTE(address);
\n \/\/ \u6bd4\u8f83\u5e76\u8f93\u51fa\u7ed3\u679c
\n}<\/p>\n
\u6d4b\u8bd5\u903b\u8f91：<\/p>\n
\u68c0\u67e5\u662f\u5426\u5df2\u64e6\u9664（\u503c\u4e3a0xFFFF）<\/p>\n<\/li>\n
\u672a\u64e6\u9664\u65f6，\u5fc5\u987b\u5148\u64e6\u9664\u6574\u4e2a\u6247\u533a<\/p>\n<\/li>\n
\u64e6\u9664\u540e\u7f16\u7a0b，\u5e76\u9a8c\u8bc1\u7ed3\u679c<\/p>\n<\/li>\n<\/ul>\n
void Test_Full_Address_Range(void)
\n{
\n \/\/ \u6d4b\u8bd5\u4f4e\u5730\u5740
\n LZY_WRITE_TEST(0x000000, 0x5555);
\n LZY_WRITE_TEST(0x001000, 0xAAAA);<\/p>\n
\/\/ \u6d4b\u8bd5\u4e2d\u95f4\u5730\u5740（\u6839\u636e\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8ba1\u7b97）
\n uint32_t middle_addr = MAX_MUXED_ADDRESS \/ 2;
\n middle_addr = middle_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50
\n LZY_WRITE_TEST(middle_addr, 0x1234);<\/p>\n
\/\/ \u6d4b\u8bd5\u9ad8\u5730\u5740
\n uint32_t high_addr = MAX_MUXED_ADDRESS – 0x1000;
\n high_addr = high_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50
\n LZY_WRITE_TEST(high_addr, 0x5678);
\n}<\/p>\n
\u6d4b\u8bd5\u7b56\u7565：<\/p>\n
\u8986\u76d6\u4f4e\u3001\u4e2d\u3001\u9ad8\u4e09\u4e2a\u5730\u5740\u533a\u57df<\/p>\n<\/li>\n
\u8003\u8651\u5730\u5740\u7ebf\u914d\u7f6e\u9650\u5236（\u590d\u7528\u6a21\u5f0f）<\/p>\n<\/li>\n
\u786e\u4fdd\u5730\u5740\u5bf9\u9f50<\/p>\n<\/li>\n<\/ul>\n
\/* \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u5730\u5740\u901a\u8fc7\u6570\u636e\u7ebf\u4f20\u8f93，\u53d7\u5f15\u811a\u6570\u91cf\u9650\u5236 *\/
\n#define ADDR_BITS_USED 19 \/* CubeMX\u4e2d\u914d\u7f6e\u7684\u590d\u7528\u5730\u5740\u7ebf\u6570\u91cf *\/
\n#define MAX_MUXED_ADDRESS ((1UL << ADDR_BITS_USED) – 1)<\/p>\n
\u5f71\u54cd：<\/p>\n
\u5982\u679c\u914d\u7f6e19\u4f4d\u5730\u5740\u7ebf，\u6700\u5927\u53ef\u8bbf\u95ee\u5730\u5740\u4e3a0x7FFFF（524,287\u5b57\u8282）<\/p>\n<\/li>\n
\u4f46SST39VF800A\u5b9e\u9645\u670919\u6761\u5730\u5740\u7ebf（A0-A18），\u53ef\u8bbf\u95ee1MB\u7a7a\u95f4<\/p>\n<\/li>\n
\u5982\u679cSTM32\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u4e0d\u8db3，\u9ad8\u4f4d\u5730\u5740\u4f1a\u56de\u7ed5<\/p>\n<\/li>\n<\/ul>\n
\/* \u590d\u7528\u6a21\u5f0f\u4e0b\u7684\u5730\u5740\u8bbf\u95ee\u5b8f *\/
\n#define NOR_READ_BYTE(addr_byte) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + (addr_byte))))<\/p>\n
\u5de5\u4f5c\u539f\u7406：<\/p>\n
STM32\u901a\u8fc7FMC\u7684ALE\u4fe1\u53f7\u9501\u5b58\u5730\u5740<\/p>\n<\/li>\n
\u5730\u5740\u548c\u6570\u636e\u901a\u8fc7\u540c\u4e00\u7ec4\u7ebf\u5206\u65f6\u4f20\u8f93<\/p>\n<\/li>\n
Flash\u5728ALE\u4e3a\u9ad8\u65f6\u9501\u5b58\u5730\u5740，ALE\u4e3a\u4f4e\u65f6\u8bfb\u5199\u6570\u636e<\/p>\n<\/li>\n
\u4efb\u4f55Flash\u64cd\u4f5c = \u89e3\u9501\u5e8f\u5217 + \u547d\u4ee4 + \u6570\u636e\/\u5730\u5740 + \u72b6\u6001\u68c0\u6d4b<\/p>\n
\u89e3\u9501\u5e8f\u5217：\u6bcf\u4e2a\u547d\u4ee4\u524d\u5fc5\u987b\u6267\u884c<\/p>\n<\/li>\n
\u547d\u4ee4\u95f4\u9694：\u9700\u8981\u5fae\u5c0f\u5ef6\u65f6（1-10\u03bcs）<\/p>\n<\/li>\n
\u64cd\u4f5c\u8d85\u65f6：\u7f16\u7a0b\u226420\u03bcs，\u6247\u533a\u64e6\u9664\u226425ms<\/p>\n<\/li>\n<\/ul>\n
\u5148\u8bfb\u53d6ID：\u786e\u8ba4\u8bbe\u5907\u8fde\u63a5\u6b63\u786e<\/p>\n<\/li>\n
\u6d4b\u8bd5\u57fa\u672c\u8bfb\u5199：\u4ece\u4f4e\u5730\u5740\u5f00\u59cb<\/p>\n<\/li>\n
\u68c0\u67e5\u5730\u5740\u6620\u5c04：\u9a8c\u8bc1\u5b57\u5730\u5740\u5230\u5b57\u8282\u5730\u5740\u7684\u8f6c\u6362<\/p>\n<\/li>\n
\u76d1\u63a7\u72b6\u6001\u4f4d：\u4f7f\u7528Toggle Bit\u6216Data# Polling\u8c03\u8bd5\u64cd\u4f5c\u72b6\u6001<\/p>\n<\/li>\n
ID\u8bfb\u53d6\u5931\u8d25：\u68c0\u67e5\u786c\u4ef6\u8fde\u63a5\u3001\u65f6\u5e8f\u914d\u7f6e\u3001\u89e3\u9501\u5e8f\u5217<\/p>\n<\/li>\n
\u7f16\u7a0b\u5931\u8d25：\u786e\u8ba4\u5730\u5740\u5df2\u64e6\u9664\u3001\u5730\u5740\u5bf9\u9f50\u3001\u8d85\u65f6\u8bbe\u7f6e<\/p>\n<\/li>\n
\u5730\u5740\u5f02\u5e38：\u68c0\u67e5\u5730\u5740\u7ebf\u914d\u7f6e\u3001\u590d\u7528\u6a21\u5f0f\u8bbe\u7f6e<\/p>\n<\/li>\n<\/ul>\n
\u901a\u8fc7\u6df1\u5165\u7406\u89e3\u6d41\u7a0b\u56fe\u548c\u4ee3\u7801\u7684\u5bf9\u5e94\u5173\u7cfb，\u53ef\u4ee5\u66f4\u597d\u5730\u638c\u63e1SST39VF800A Flash\u7684\u64cd\u4f5c\u539f\u7406，\u5e76\u6709\u6548\u5730\u8c03\u8bd5\u548c\u4f18\u5316Flash\u8bbf\u95ee\u4ee3\u7801\u3002<\/p>\n
\u793a\u4f8b\u4ee3\u7801：
\n\u00a0<\/p>\n
\/* USER CODE BEGIN Header *\/
\n\/**
\n ******************************************************************************
\n * @file : main.c
\n * @brief : Main program body
\n ******************************************************************************
\n * @attention
\n *
\n * Copyright (c) 2026 STMicroelectronics.
\n * All rights reserved.
\n *
\n * This software is licensed under terms that can be found in the LICENSE file
\n * in the root directory of this software component.
\n * If no LICENSE file comes with this software, it is provided AS-IS.
\n *
\n ******************************************************************************
\n *\/
\n\/* USER CODE END Header *\/
\n\/* Includes ——————————————————————*\/
\n#include "main.h"
\n#include "usart.h"
\n#include "gpio.h"
\n#include "fmc.h"<\/p>\n
\/* Private includes ———————————————————-*\/
\n\/* USER CODE BEGIN Includes *\/
\n#include <stdio.h>
\n#include <string.h>
\n#include <stdbool.h>
\n\/* USER CODE END Includes *\/<\/p>\n
\/* Private typedef ———————————————————–*\/
\n\/* USER CODE BEGIN PTD *\/<\/p>\n
\/**
\n * @brief NOR Flash Test Results Structure
\n *\/
\ntypedef struct {
\n bool write_test_passed;
\n bool read_id_success;
\n bool erase_test_passed;
\n uint16_t manufacturer_id;
\n uint16_t device_id;
\n uint32_t capacity_bytes;
\n const char* device_name;
\n} NOR_Test_Results_t;<\/p>\n
\/* USER CODE END PTD *\/<\/p>\n
\/* Private define ————————————————————*\/
\n\/* USER CODE BEGIN PD *\/<\/p>\n
\/* NOR Flash Configuration – SST39VF800A Specific *\/
\n#define NOR_FLASH_BASE_ADDR 0x60000000UL
\n#define NOR_FLASH_SIZE_BYTES (1 * 1024 * 1024) \/* 8Mbit = 1MB *\/
\n#define NOR_FLASH_SECTOR_SIZE (4 * 1024) \/* 2KWord = 4KB sectors *\/
\n#define NOR_FLASH_BLOCK_SIZE (64 * 1024) \/* 32KWord = 64KB blocks *\/<\/p>\n
\/* SST39VF800A Command Addresses (in 16-bit words from datasheet) *\/
\n#define SST_CMD_ADDR_1 0x5555 \/* Word address 5555H *\/
\n#define SST_CMD_ADDR_2 0x2AAA \/* Word address 2AAAH *\/<\/p>\n
\/* SST39VF800A Command Codes (from Table 4) *\/
\n#define SST_CMD_UNLOCK1 0x00AA
\n#define SST_CMD_UNLOCK2 0x0055
\n#define SST_CMD_AUTOSELECT 0x0090
\n#define SST_CMD_PROGRAM 0x00A0
\n#define SST_CMD_CHIP_ERASE_1 0x0080
\n#define SST_CMD_SECTOR_ERASE 0x0030
\n#define SST_CMD_RESET 0x00F0<\/p>\n
\/* SST39VF800A Manufacturer and Device IDs (from Table 2) *\/
\n#define SST_MANUFACTURER_ID 0x00BF
\n#define SST39VF800A_DEVICE_ID 0x2781<\/p>\n
\/* Timing Parameters from datasheet *\/
\n#define SST_PROGRAM_TIMEOUT_US 20000UL \/* 20\u03bcs max from Table 17 *\/
\n#define SST_ERASE_TIMEOUT_MS 100UL \/* 100ms max for chip erase *\/
\n#define SST_SECTOR_ERASE_TIMEOUT_MS 25UL \/* 25ms max for sector erase *\/<\/p>\n
\/* \u590d\u7528\u6a21\u5f0f\u4e0b\u7684\u5173\u952e\u5b8f\u5b9a\u4e49 *\/
\n\/* \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u5730\u5740\u901a\u8fc7\u6570\u636e\u7ebf\u4f20\u8f93，\u9700\u8981ALE\u4fe1\u53f7\u9501\u5b58 *\/
\n#define ENABLE_ALE_LATCH() \/\/ \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，FSMC\u4f1a\u81ea\u52a8\u7ba1\u7406ALE<\/p>\n
\/* USER CODE END PD *\/<\/p>\n
\/* Private macro ————————————————————-*\/
\n\/* USER CODE BEGIN PM *\/<\/p>\n
\/* \u590d\u7528\u6a21\u5f0f\u4e0b\u7684\u5730\u5740\u6620\u5c04 *\/
\n\/*
\n * \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u5730\u5740\u548c\u6570\u636e\u5171\u4eab\u540c\u4e00\u7ec4\u7ebf
\n * STM32\u7684\u5730\u5740\u603b\u7ebf\u662f\u5b57\u8282\u5730\u5740，\u9700\u8981\u8f6c\u6362\u4e3aFlash\u5b57\u5730\u5740
\n * \u6ce8\u610f：\u5728CubeMX\u4e2d\u914d\u7f6e\u4e3a19\u4f4d\u590d\u7528\u5730\u5740\u7ebf
\n *\/
\n#define ADDR_BITS_USED 19 \/* CubeMX\u4e2d\u914d\u7f6e\u7684\u590d\u7528\u5730\u5740\u7ebf\u6570\u91cf *\/
\n#define MAX_MUXED_ADDRESS ((1UL << ADDR_BITS_USED) – 1)<\/p>\n
\/* \u5c06Flash\u5b57\u5730\u5740\u8f6c\u6362\u4e3aSTM32\u5b57\u8282\u5730\u5740（\u5b57\u5730\u5740 \u00d7 2）*\/
\n#define FLASH_WORD_TO_BYTE(addr_word) ((addr_word) << 1)<\/p>\n
\/* \u5c06Flash\u5b57\u8282\u5730\u5740\u8f6c\u6362\u4e3a\u5b57\u5730\u5740（\u5b57\u8282\u5730\u5740 \u00f7 2）*\/
\n#define FLASH_BYTE_TO_WORD(addr_byte) ((addr_byte) >> 1)<\/p>\n
\/* \u590d\u7528\u6a21\u5f0f\u4e0b\u7684\u5730\u5740\u8bbf\u95ee\u5b8f *\/
\n\/*
\n * \u91cd\u8981：\u5728\u590d\u7528\u6a21\u5f0f\u4e0b，FSMC\u4f1a\u81ea\u52a8\u5904\u7406\u5730\u5740\/\u6570\u636e\u590d\u7528
\n * \u6211\u4eec\u53ea\u9700\u8981\u63d0\u4f9b\u5b57\u8282\u5730\u5740，FSMC\u4f1a\u901a\u8fc7ALE\u4fe1\u53f7\u9501\u5b58\u5730\u5740
\n * \u7136\u540e\u901a\u8fc7\u540c\u4e00\u7ec4\u7ebf\u4f20\u8f93\u6570\u636e
\n *\/
\n#define NOR_READ_BYTE(addr_byte) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + (addr_byte))))
\n#define NOR_WRITE_BYTE(addr_byte, data) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + (addr_byte))) = (data))<\/p>\n
\/* \u57fa\u4e8eFlash\u5b57\u5730\u5740\u7684\u8bbf\u95ee\u5b8f *\/
\n#define NOR_READ_WORD(addr_word) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + FLASH_WORD_TO_BYTE(addr_word))))
\n#define NOR_WRITE_WORD(addr_word, data) (*((volatile uint16_t*)(NOR_FLASH_BASE_ADDR + FLASH_WORD_TO_BYTE(addr_word))) = (data))<\/p>\n
\/* \u547d\u4ee4\u5199\u5165\u5b8f – \u4f7f\u7528Flash\u5b57\u5730\u5740 *\/
\n#define SST_WRITE_CMD(addr_word, data) \\\\
\n NOR_WRITE_WORD(addr_word, data)<\/p>\n
\/* USER CODE END PM *\/<\/p>\n
\/* Private variables ———————————————————*\/<\/p>\n
\/* USER CODE BEGIN PV *\/<\/p>\n
\/* USER CODE END PV *\/<\/p>\n
\/* Private function prototypes ———————————————–*\/
\nvoid SystemClock_Config(void);
\n\/* USER CODE BEGIN PFP *\/<\/p>\n
\/* SST39VF800A Specific Functions *\/
\nstatic bool SST_ReadID(uint16_t* manufacturer_id, uint16_t* device_id);
\nstatic bool SST_SectorErase(uint32_t sector_address);
\nstatic bool SST_ByteProgram(uint32_t address, uint16_t data);
\nstatic bool SST_CheckToggleBit(uint32_t address);
\nstatic bool SST_CheckDataPolling(uint32_t address, uint16_t expected_data);
\nstatic bool SST_WaitForOperationComplete(uint32_t address, uint16_t expected_data, bool is_erase);
\nstatic void SST_SendUnlockSequence(void);
\nstatic void Delay_Us(volatile uint32_t microseconds);<\/p>\n
\/* LZY Test Functions *\/
\nvoid LZY_NOR_Init(void);
\nvoid LZY_NOR_DisplayInfo(void);
\nvoid LZY_WRITE_TEST(uint32_t address, uint16_t data);
\nvoid Test_Full_Address_Range(void);
\nvoid Verify_Address_Mapping(void);
\nvoid Test_Muxed_Mode_Compatibility(void);<\/p>\n
\/* USER CODE END PFP *\/<\/p>\n
\/* Private user code ———————————————————*\/
\n\/* USER CODE BEGIN 0 *\/<\/p>\n
\/**
\n * @brief Delay for specified microseconds (approximate)
\n * @param microseconds: Number of microseconds to delay
\n * @retval None
\n *\/
\nstatic void Delay_Us(volatile uint32_t microseconds)
\n{
\n \/* Assuming 85MHz system clock, 1us \u2248 85 cycles *\/
\n volatile uint32_t cycles = microseconds * 85;
\n while (cycles–) {
\n __NOP();
\n }
\n}<\/p>\n
\/**
\n * @brief Send unlock sequence (common for all commands)
\n * @retval None
\n *\/
\nstatic void SST_SendUnlockSequence(void)
\n{
\n \/* \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，FSMC\u4f1a\u81ea\u52a8\u901a\u8fc7ALE\u9501\u5b58\u5730\u5740，\u7136\u540e\u4f20\u8f93\u6570\u636e *\/<\/p>\n
\/* First unlock cycle – \u4f7f\u7528Flash\u5b57\u5730\u5740 *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_UNLOCK1);<\/p>\n
\/* \u5c0f\u5ef6\u65f6\u786e\u4fdd\u547d\u4ee4\u5b8c\u6210 *\/
\n Delay_Us(1);<\/p>\n
\/* Second unlock cycle – \u4f7f\u7528Flash\u5b57\u5730\u5740 *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_2, SST_CMD_UNLOCK2);<\/p>\n
\/* \u5c0f\u5ef6\u65f6\u786e\u4fdd\u547d\u4ee4\u5b8c\u6210 *\/
\n Delay_Us(1);
\n}<\/p>\n
\/**
\n * @brief Check Toggle Bit (DQ6) status
\n * @param address: \u5b57\u8282\u5730\u5740 to check
\n * @retval true if ready (stopped toggling), false if still busy
\n *\/
\nstatic bool SST_CheckToggleBit(uint32_t address)
\n{
\n volatile uint16_t* flash_addr = (volatile uint16_t*)(NOR_FLASH_BASE_ADDR + address);
\n uint16_t read1, read2;<\/p>\n
\/* Read twice to check for toggling *\/
\n read1 = *flash_addr;
\n read2 = *flash_addr;<\/p>\n
\/* If DQ6 stops toggling, device is ready *\/
\n return ((read1 & 0x0040) == (read2 & 0x0040));
\n}<\/p>\n
\/**
\n * @brief Check Data Polling (DQ7) status
\n * @param address: \u5b57\u8282\u5730\u5740 to check
\n * @param expected_data: Expected data value
\n * @retval true if ready (DQ7 matches), false if still busy
\n *\/
\nstatic bool SST_CheckDataPolling(uint32_t address, uint16_t expected_data)
\n{
\n volatile uint16_t* flash_addr = (volatile uint16_t*)(NOR_FLASH_BASE_ADDR + address);
\n uint16_t read_data;<\/p>\n
read_data = *flash_addr;<\/p>\n
\/* Check DQ7 (bit 7) *\/
\n return ((read_data & 0x0080) == (expected_data & 0x0080));
\n}<\/p>\n
\/**
\n * @brief Wait for operation to complete using both methods
\n * @param address: \u5b57\u8282\u5730\u5740 to monitor
\n * @param expected_data: Expected data (for programming) or 0xFFFF (for erase)
\n * @param is_erase: true if waiting for erase, false for program
\n * @retval true if operation completed, false if timeout
\n *\/
\nstatic bool SST_WaitForOperationComplete(uint32_t address, uint16_t expected_data, bool is_erase)
\n{
\n uint32_t timeout_us = is_erase ? SST_ERASE_TIMEOUT_MS * 1000 : SST_PROGRAM_TIMEOUT_US;
\n uint32_t start_time = HAL_GetTick();
\n uint32_t elapsed_us = 0;<\/p>\n
while (elapsed_us < timeout_us) {
\n \/* Try toggle bit first *\/
\n if (SST_CheckToggleBit(address)) {
\n \/* Then verify with data polling *\/
\n if (SST_CheckDataPolling(address, expected_data)) {
\n \/* Double-check by reading twice more as per datasheet *\/
\n volatile uint16_t* flash_addr = (volatile uint16_t*)(NOR_FLASH_BASE_ADDR + address);
\n uint16_t read1 = *flash_addr;
\n uint16_t read2 = *flash_addr;<\/p>\n
if (read1 == read2) {
\n return true;
\n }
\n }
\n }<\/p>\n
\/* Update elapsed time *\/
\n elapsed_us = (HAL_GetTick() – start_time) * 1000;
\n Delay_Us(10); \/* Small delay between checks *\/
\n }<\/p>\n
return false; \/* Timeout *\/
\n}<\/p>\n
\/**
\n * @brief Erase a 4KB sector in SST39VF800A
\n * @param sector_address: Sector \u5b57\u8282\u5730\u5740 (must be sector aligned)
\n * @retval true if successful, false otherwise
\n *\/
\nstatic bool SST_SectorErase(uint32_t sector_address)
\n{
\n \/* Convert byte address to word address for command *\/
\n uint16_t sector_word_addr = FLASH_BYTE_TO_WORD(sector_address) & 0x7FFF; \/* A14-A0 for 8Mbit device *\/<\/p>\n
\/* Sector-Erase Command Sequence (6 cycles) from Table 4 *\/
\n \/* First 3 cycles: Unlock sequence *\/
\n SST_SendUnlockSequence();<\/p>\n
\/* Fourth cycle: Setup erase command *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_1, 0x0080);
\n Delay_Us(1);<\/p>\n
\/* Fifth and sixth cycles: Unlock sequence again *\/
\n SST_SendUnlockSequence();<\/p>\n
\/* Seventh cycle: Sector address and erase confirm *\/
\n NOR_WRITE_BYTE(sector_address, SST_CMD_SECTOR_ERASE);<\/p>\n
\/* Wait for erase completion *\/
\n return SST_WaitForOperationComplete(sector_address, 0xFFFF, true);
\n}<\/p>\n
\/**
\n * @brief Program a single word (16-bit) in SST39VF800A
\n * @param address: \u5b57\u8282\u5730\u5740 to program (must be word-aligned)
\n * @param data: Data to program
\n * @retval true if successful, false otherwise
\n *\/
\nstatic bool SST_ByteProgram(uint32_t address, uint16_t data)
\n{
\n \/* Word-Program Command Sequence (4 cycles) from Table 4 *\/
\n \/* First 3 cycles: Unlock sequence *\/
\n SST_SendUnlockSequence();<\/p>\n
\/* Fourth cycle: Program command and data *\/
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_PROGRAM);
\n Delay_Us(1);<\/p>\n
\/* Write the data to the target address *\/
\n NOR_WRITE_BYTE(address, data);<\/p>\n
\/* Wait for programming completion *\/
\n return SST_WaitForOperationComplete(address, data, false);
\n}<\/p>\n
\/**
\n * @brief Read SST39VF800A Manufacturer and Device ID
\n * @param manufacturer_id: Pointer to store manufacturer ID
\n * @param device_id: Pointer to store device ID
\n * @retval true if successful, false otherwise
\n *\/
\nstatic bool SST_ReadID(uint16_t* manufacturer_id, uint16_t* device_id)
\n{
\n \/* Software ID Entry Command Sequence (3 cycles) *\/
\n SST_SendUnlockSequence();
\n SST_WRITE_CMD(SST_CMD_ADDR_1, SST_CMD_AUTOSELECT);
\n Delay_Us(10);<\/p>\n
\/* Read Manufacturer ID (at word address 0000H, A0=0) *\/
\n *manufacturer_id = NOR_READ_WORD(0x0000);<\/p>\n
\/* Read Device ID (at word address 0001H, A0=1) *\/
\n *device_id = NOR_READ_WORD(0x0001);<\/p>\n
\/* Exit Software ID mode *\/
\n SST_WRITE_CMD(0x0000, SST_CMD_RESET);
\n Delay_Us(10);<\/p>\n
return true;
\n}<\/p>\n
\/**
\n * @brief \u6d4b\u8bd5\u590d\u7528\u6a21\u5f0f\u517c\u5bb9\u6027
\n * @retval None
\n *\/
\nvoid Test_Muxed_Mode_Compatibility(void)
\n{
\n printf("=== \u6d4b\u8bd5\u590d\u7528\u6a21\u5f0f\u517c\u5bb9\u6027 ===\\\\n");<\/p>\n
\/\/ \u68c0\u67e5CubeMX\u914d\u7f6e
\n printf("1. CubeMX\u914d\u7f6e\u68c0\u67e5:\\\\n");
\n printf(" – Memory type: Muxed NOR Flash\\\\n");
\n printf(" – Data\/Address: %d bits\\\\n", ADDR_BITS_USED);
\n printf(" – \u7406\u8bba\u6700\u5927\u5730\u5740: 0x%06lX\\\\n", MAX_MUXED_ADDRESS);<\/p>\n
\/\/ \u6d4b\u8bd5\u5730\u5740\u7ebf\u662f\u5426\u5de5\u4f5c
\n printf("\\\\n2. \u5730\u5740\u7ebf\u6d4b\u8bd5:\\\\n");<\/p>\n
uint32_t test_addresses[] = {
\n 0x000000, \/\/ \u5730\u5740\u7ebf\u51680
\n 0x000002, \/\/ A0=1
\n 0x000004, \/\/ A1=1
\n 0x000008, \/\/ A2=1
\n 0x000010, \/\/ A3=1
\n 0x000020, \/\/ A4=1
\n 0x000040, \/\/ A5=1
\n 0x000080, \/\/ A6=1
\n 0x000100, \/\/ A7=1
\n 0x000200, \/\/ A8=1
\n 0x000400, \/\/ A9=1
\n 0x000800, \/\/ A10=1
\n 0x001000, \/\/ A11=1
\n 0x002000, \/\/ A12=1
\n 0x004000, \/\/ A13=1
\n 0x008000, \/\/ A14=1
\n 0x010000, \/\/ A15=1
\n 0x020000, \/\/ A16=1
\n 0x040000, \/\/ A17=1
\n 0x080000, \/\/ A18=1 (\u6700\u9ad8\u4f4d)
\n };<\/p>\n
bool all_passed = true;
\n for (int i = 0; i < sizeof(test_addresses)\/sizeof(test_addresses[0]); i++) {
\n uint32_t addr = test_addresses[i];<\/p>\n
if (addr > MAX_MUXED_ADDRESS) {
\n printf(" \u5730\u5740 0x%06lX: \u8d85\u51fa\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4\\\\n", addr);
\n continue;
\n }<\/p>\n
\/\/ \u5c1d\u8bd5\u8bfb\u53d6\u8be5\u5730\u5740
\n uint16_t value = NOR_READ_BYTE(addr);<\/p>\n
printf(" \u5730\u5740 0x%06lX (A%d): \u8bfb\u53d6\u503c 0x%04X",
\n addr, i, value);<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u5730\u5740\u56de\u7ed5
\n if (addr >= NOR_FLASH_SIZE_BYTES) {
\n printf(" [\u8b66\u544a：\u8d85\u51faFlash\u7269\u7406\u8303\u56f4]\\\\n");
\n } else {
\n printf("\\\\n");
\n }<\/p>\n
\/\/ \u5982\u679c\u662f\u64e6\u9664\u72b6\u6001，\u53ef\u80fd\u662f\u6709\u6548\u7684
\n if (value != 0xFFFF && value != 0x0000) {
\n printf(" \u6ce8\u610f：\u8bfb\u53d6\u5230\u975e\u9ed8\u8ba4\u503c，\u53ef\u80fd\u5df2\u7f16\u7a0b\\\\n");
\n }
\n }<\/p>\n
\/\/ \u6d4b\u8bd5\u9ad8\u4f4d\u5730\u5740\u56de\u7ed5
\n printf("\\\\n3. \u9ad8\u4f4d\u5730\u5740\u56de\u7ed5\u6d4b\u8bd5:\\\\n");<\/p>\n
uint32_t wrap_test_addrs[] = {
\n 0x100000, \/\/ 1MB\u4f4d\u7f6e（\u5982\u679c\u53ea\u670919\u4f4d\u5730\u5740\u7ebf，\u4f1a\u56de\u7ed5\u52300x000000）
\n 0x200000, \/\/ 2MB\u4f4d\u7f6e
\n 0x300000, \/\/ 3MB\u4f4d\u7f6e
\n };<\/p>\n
for (int i = 0; i < sizeof(wrap_test_addrs)\/sizeof(wrap_test_addrs[0]); i++) {
\n uint32_t addr = wrap_test_addrs[i];
\n uint16_t value = NOR_READ_BYTE(addr);<\/p>\n
printf(" \u9ad8\u4f4d\u5730\u5740 0x%06lX: \u8bfb\u53d6\u503c 0x%04X", addr, value);<\/p>\n
\/\/ \u8ba1\u7b97\u56de\u7ed5\u5730\u5740
\n uint32_t wrapped_addr = addr & MAX_MUXED_ADDRESS;
\n printf(" (\u56de\u7ed5\u5230 0x%06lX)\\\\n", wrapped_addr);
\n }<\/p>\n
printf("\\\\n4. \u590d\u7528\u6a21\u5f0f\u7279\u5b9a\u6d4b\u8bd5:\\\\n");<\/p>\n
\/\/ \u68c0\u67e5ALE\u5f15\u811a\u662f\u5426\u914d\u7f6e
\n #ifdef FMC_Bank1_ALE_ENABLE
\n printf(" ALE\u5f15\u811a\u5df2\u542f\u7528 (\u590d\u7528\u6a21\u5f0f)\\\\n");<\/p>\n
\/\/ \u6d4b\u8bd5\u8fde\u7eed\u8bbf\u95ee\u6a21\u5f0f
\n printf(" \u6d4b\u8bd5\u8fde\u7eed\u8bbf\u95ee…\\\\n");
\n volatile uint16_t* base_ptr = (volatile uint16_t*)NOR_FLASH_BASE_ADDR;<\/p>\n
\/\/ \u8fde\u7eed\u8bfb\u53d6\u591a\u4e2a\u5730\u5740
\n for (int i = 0; i < 10; i++) {
\n uint32_t offset = i * 0x1000;
\n if (offset > MAX_MUXED_ADDRESS) break;<\/p>\n
uint16_t val = base_ptr[offset \/ 2]; \/\/ \u9664\u4ee52\u56e0\u4e3a\u662f\u6307\u9488\u504f\u79fb
\n printf(" \u504f\u79fb 0x%04X: 0x%04X\\\\n", offset, val);
\n }
\n #else
\n printf(" \u8b66\u544a：ALE\u5f15\u811a\u672a\u542f\u7528，\u53ef\u80fd\u4e0d\u662f\u771f\u6b63\u7684\u590d\u7528\u6a21\u5f0f\\\\n");
\n #endif<\/p>\n
printf("===============================\\\\n\\\\n");
\n}<\/p>\n
\/**
\n * @brief \u9a8c\u8bc1\u5730\u5740\u6620\u5c04\u7684\u6b63\u786e\u6027
\n * @retval None
\n *\/
\nvoid Verify_Address_Mapping(void)
\n{
\n printf("=== \u9a8c\u8bc1\u5730\u5740\u6620\u5c04 ===\\\\n");<\/p>\n
\/\/ \u6d4b\u8bd5\u51e0\u4e2a\u5173\u952e\u5730\u5740
\n uint32_t test_offsets[] = {
\n 0x000000, \/\/ \u8d77\u59cb\u5730\u5740
\n 0x07FFFE, \/\/ \u7b2c\u4e00\u4e2a\u6247\u533a\u672b\u5c3e（4KB\u5bf9\u9f50）
\n 0x3FFFFE, \/\/ 19\u4f4d\u5730\u5740\u7ebf\u7684\u6700\u5927\u5730\u5740（\u5982\u679c\u914d\u7f6e\u4e3a19\u4f4d）
\n 0x0FFFFE, \/\/ 1MB Flash\u7684\u6700\u5927\u5730\u5740
\n };<\/p>\n
for (int i = 0; i < sizeof(test_offsets)\/sizeof(test_offsets[0]); i++) {
\n uint32_t byte_offset = test_offsets[i];
\n uint32_t word_offset = FLASH_BYTE_TO_WORD(byte_offset);<\/p>\n
printf("\u5b57\u8282\u504f\u79fb: 0x%06lX, \u5b57\u504f\u79fb: 0x%06lX\\\\n",
\n byte_offset, word_offset);<\/p>\n
\/\/ \u5c1d\u8bd5\u8bfb\u53d6
\n uint16_t value = NOR_READ_BYTE(byte_offset);<\/p>\n
printf(" \u8bfb\u53d6\u503c: 0x%04X", value);<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u8d85\u51fa\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4
\n if (byte_offset > MAX_MUXED_ADDRESS) {
\n printf(" [\u8d85\u51fa\u914d\u7f6e\u7684%d\u4f4d\u5730\u5740\u7ebf\u8303\u56f4]", ADDR_BITS_USED);
\n }<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u5730\u5740\u56de\u7ed5
\n if (byte_offset >= NOR_FLASH_SIZE_BYTES) {
\n printf(" [\u8b66\u544a：\u8d85\u51faFlash\u7269\u7406\u8303\u56f4！]\\\\n");
\n } else {
\n printf("\\\\n");
\n }
\n }<\/p>\n
printf("=====================\\\\n\\\\n");
\n}<\/p>\n
\/**
\n * @brief LZY NOR Flash \u521d\u59cb\u5316
\n * @retval None
\n *\/
\nvoid LZY_NOR_Init(void)
\n{
\n uint16_t manufacturer_id, device_id;<\/p>\n
printf("=== SST39VF800A Flash Init ===\\\\n");<\/p>\n
\/\/ \u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u8bfb\u53d6ID\u53ef\u80fd\u9700\u8981\u7279\u6b8a\u5904\u7406
\n printf("\u6a21\u5f0f：\u590d\u7528\u6a21\u5f0f (Muxed Mode)\\\\n");
\n printf("\u914d\u7f6e\u5730\u5740\u7ebf：%d bits\\\\n", ADDR_BITS_USED);<\/p>\n
if (SST_ReadID(&manufacturer_id, &device_id)) {
\n printf("Manufacturer: 0x%04X\\\\n", manufacturer_id);
\n printf("Device ID: 0x%04X\\\\n", device_id);<\/p>\n
if (manufacturer_id == SST_MANUFACTURER_ID && device_id == SST39VF800A_DEVICE_ID) {
\n printf("Device: SST39VF800A 8Mbit (1MB)\\\\n");
\n printf("\u72b6\u6001：\u8bbe\u5907\u8bc6\u522b\u6210\u529f！\\\\n");
\n } else {
\n printf("Unknown device!\\\\n");
\n printf("\u53ef\u80fd\u7684\u539f\u56e0：\\\\n");
\n printf(" 1. \u590d\u7528\u6a21\u5f0f\u914d\u7f6e\u4e0d\u6b63\u786e\\\\n");
\n printf(" 2. \u786c\u4ef6\u8fde\u63a5\u95ee\u9898\\\\n");
\n printf(" 3. \u65f6\u5e8f\u914d\u7f6e\u4e0d\u5f53\\\\n");
\n }
\n } else {
\n printf("Device not found!\\\\n");
\n printf("\u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u53ef\u80fd\u9700\u8981\u68c0\u67e5：\\\\n");
\n printf(" 1. ALE\u4fe1\u53f7\u662f\u5426\u6b63\u786e\u8fde\u63a5\\\\n");
\n printf(" 2. \u65f6\u5e8f\u914d\u7f6e\u662f\u5426\u5339\u914dFlash\u8981\u6c42\\\\n");
\n printf(" 3. \u786c\u4ef6\u8fde\u63a5\u662f\u5426\u6b63\u786e\\\\n");
\n }<\/p>\n
printf("Base Address: 0x%08lX\\\\n", NOR_FLASH_BASE_ADDR);
\n printf("Sector Size: %d bytes\\\\n", NOR_FLASH_SECTOR_SIZE);
\n printf("Total Size: %d bytes (1MB)\\\\n", NOR_FLASH_SIZE_BYTES);
\n printf("\u914d\u7f6e\u5730\u5740\u7ebf：%d bits (\u6700\u5927\u5730\u5740: 0x%06lX)\\\\n",
\n ADDR_BITS_USED, MAX_MUXED_ADDRESS);
\n printf("==============================\\\\n\\\\n");
\n}<\/p>\n
\/**
\n * @brief LZY NOR Flash \u663e\u793a\u4fe1\u606f
\n * @retval None
\n *\/
\nvoid LZY_NOR_DisplayInfo(void)
\n{
\n printf("=== SST39VF800A Info ===\\\\n");
\n printf("Capacity: 1MB (8Mbit)\\\\n");
\n printf("Organization: 512K x 16-bit\\\\n");
\n printf("Sector Size: 4KB\\\\n");
\n printf("Block Size: 64KB\\\\n");
\n printf("Voltage: 2.7-3.6V (3.3V typical)\\\\n");
\n printf("Address Lines: A0-A18 (19\u6761)\\\\n");
\n printf("Data Bus: 16-bit\\\\n");
\n printf("Interface: \u975e\u590d\u7528\u6a21\u5f0f (\u4f46STM32\u914d\u7f6e\u4e3a\u590d\u7528)\\\\n");
\n printf("\u6ce8\u610f\u4e8b\u9879：\\\\n");
\n printf(" – STM32\u914d\u7f6e\u4e3a\u590d\u7528\u6a21\u5f0f\\\\n");
\n printf(" – \u9700\u8981\u5916\u90e8\u5730\u5740\u9501\u5b58\u5668\u6216\u7279\u6b8a\u786c\u4ef6\u8bbe\u8ba1\\\\n");
\n printf(" – \u5730\u5740\u7ebf\u914d\u7f6e：%d bits\\\\n", ADDR_BITS_USED);
\n printf("=======================\\\\n\\\\n");
\n}<\/p>\n
\/**
\n * @brief LZY Flash \u5199\u5165\u6d4b\u8bd5\u51fd\u6570
\n * @param address: \u8981\u5199\u5165\u7684\u5b57\u8282\u5730\u5740
\n * @param data: \u8981\u5199\u5165\u7684\u6570\u636e（16\u4f4d）
\n * @retval None
\n *\/
\nvoid LZY_WRITE_TEST(uint32_t address, uint16_t data)
\n{
\n \/\/ \u68c0\u67e5\u5730\u5740\u662f\u5426\u8d85\u51fa\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4
\n if (address > MAX_MUXED_ADDRESS) {
\n printf("\u9519\u8bef：\u5730\u5740 0x%08lX \u8d85\u51fa\u914d\u7f6e\u7684%d\u4f4d\u5730\u5740\u7ebf\u8303\u56f4！\\\\n",
\n NOR_FLASH_BASE_ADDR + address, ADDR_BITS_USED);
\n printf("\u6700\u5927\u53ef\u8bbf\u95ee\u5730\u5740：0x%06lX\\\\n", MAX_MUXED_ADDRESS);
\n return;
\n }<\/p>\n
\/\/ \u786e\u4fdd\u5730\u5740\u662f\u5b57\u5bf9\u9f50\u7684（\u5076\u6570\u5730\u5740）
\n if (address & 0x01) {
\n printf("\u9519\u8bef：\u5730\u5740\u5fc5\u987b\u5b57\u5bf9\u9f50！0x%08lX\\\\n", NOR_FLASH_BASE_ADDR + address);
\n return;
\n }<\/p>\n
uint16_t current_value = NOR_READ_BYTE(address);<\/p>\n
printf("Addr: 0x%08lX, Current: 0x%04X -> ",
\n NOR_FLASH_BASE_ADDR + address, current_value);<\/p>\n
\/* \u5982\u679c\u8981\u5199\u5165\u6570\u636e，\u5fc5\u987b\u5148\u68c0\u67e5\u662f\u5426\u5df2\u64e6\u9664 *\/
\n if (current_value == 0xFFFF) {
\n \/* \u4f4d\u7f6e\u5df2\u64e6\u9664，\u53ef\u4ee5\u76f4\u63a5\u7f16\u7a0b *\/
\n if (SST_ByteProgram(address, data)) {
\n printf("Write 0x%04X OK", data);
\n } else {
\n printf("Write FAIL!");
\n }
\n } else {
\n \/* \u5fc5\u987b\u5148\u64e6\u9664\u6574\u4e2a\u6247\u533a *\/
\n uint32_t sector_base = address & ~(NOR_FLASH_SECTOR_SIZE – 1);<\/p>\n
printf("Erasing sector 0x%08lX… ", NOR_FLASH_BASE_ADDR + sector_base);<\/p>\n
if (SST_SectorErase(sector_base)) {
\n printf("Erased, ");
\n if (SST_ByteProgram(address, data)) {
\n printf("Write 0x%04X OK", data);
\n } else {
\n printf("Write FAIL!");
\n }
\n } else {
\n printf("Erase FAIL!");
\n }
\n }<\/p>\n
\/* \u91cd\u65b0\u8bfb\u53d6\u9a8c\u8bc1 *\/
\n uint16_t new_value = NOR_READ_BYTE(address);
\n printf(", Read: 0x%04X %s\\\\n",
\n new_value,
\n (new_value == data) ? "[OK]" : "[FAIL]");
\n}<\/p>\n
\/**
\n * @brief \u6d4b\u8bd5\u5b8c\u6574\u5730\u5740\u7a7a\u95f4
\n * @retval None
\n *\/
\nvoid Test_Full_Address_Range(void)
\n{
\n printf("=== \u6d4b\u8bd5\u5b8c\u6574\u5730\u5740\u7a7a\u95f4 ===\\\\n");<\/p>\n
\/\/ \u6ce8\u610f：\u5728\u590d\u7528\u6a21\u5f0f\u4e0b，\u6211\u4eec\u53ea\u80fd\u6d4b\u8bd5\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4\u5185\u7684\u5730\u5740<\/p>\n
\/\/ \u6d4b\u8bd5\u4f4e\u5730\u5740
\n printf("1. \u6d4b\u8bd5\u4f4e\u5730\u5740\u533a\u57df:\\\\n");
\n LZY_WRITE_TEST(0x000000, 0x5555);
\n LZY_WRITE_TEST(0x001000, 0xAAAA);<\/p>\n
\/\/ \u6d4b\u8bd5\u4e2d\u95f4\u5730\u5740
\n printf("\\\\n2. \u6d4b\u8bd5\u4e2d\u95f4\u5730\u5740\u533a\u57df:\\\\n");<\/p>\n
\/\/ \u6839\u636e\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u6570\u91cf\u786e\u5b9a\u4e2d\u95f4\u5730\u5740
\n uint32_t middle_addr = MAX_MUXED_ADDRESS \/ 2;
\n middle_addr = middle_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50<\/p>\n
if (middle_addr < NOR_FLASH_SIZE_BYTES) {
\n LZY_WRITE_TEST(middle_addr, 0x1234);
\n } else {
\n printf("\u4e2d\u95f4\u5730\u5740\u8d85\u51faFlash\u8303\u56f4，\u8df3\u8fc7\\\\n");
\n }<\/p>\n
\/\/ \u6d4b\u8bd5\u9ad8\u5730\u5740（\u5728\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4\u5185）
\n printf("\\\\n3. \u6d4b\u8bd5\u9ad8\u5730\u5740\u533a\u57df:\\\\n");<\/p>\n
\/\/ \u6d4b\u8bd5\u63a5\u8fd1\u6700\u5927\u914d\u7f6e\u5730\u5740\u7684\u4f4d\u7f6e
\n uint32_t high_addr = MAX_MUXED_ADDRESS – 0x1000;
\n high_addr = high_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50<\/p>\n
if (high_addr < NOR_FLASH_SIZE_BYTES) {
\n LZY_WRITE_TEST(high_addr, 0x5678);
\n } else {
\n printf("\u9ad8\u5730\u5740\u8d85\u51faFlash\u8303\u56f4，\u8df3\u8fc7\\\\n");
\n }<\/p>\n
\/\/ \u6d4b\u8bd5\u8fb9\u754c\u6761\u4ef6
\n printf("\\\\n4. \u6d4b\u8bd5\u8fb9\u754c\u6761\u4ef6:\\\\n");<\/p>\n
\/\/ \u6d4b\u8bd5\u63a5\u8fd119\u4f4d\u5730\u5740\u7ebf\u6700\u5927\u5730\u5740\u7684\u4f4d\u7f6e
\n uint32_t boundary_addr = MAX_MUXED_ADDRESS – 0x20;
\n boundary_addr = boundary_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50<\/p>\n
if (boundary_addr < NOR_FLASH_SIZE_BYTES) {
\n LZY_WRITE_TEST(boundary_addr, 0x9ABC);
\n } else {
\n printf("\u8fb9\u754c\u5730\u5740\u8d85\u51faFlash\u8303\u56f4，\u8df3\u8fc7\\\\n");
\n }<\/p>\n
printf("========================\\\\n\\\\n");
\n}<\/p>\n
\/* USER CODE END 0 *\/<\/p>\n
\/**
\n * @brief The application entry point.
\n * @retval int
\n *\/
\nint main(void)
\n{
\n \/* MCU Configuration——————————————————–*\/
\n HAL_Init();
\n SystemClock_Config();<\/p>\n
\/* Initialize all configured peripherals *\/
\n MX_GPIO_Init();
\n MX_FMC_Init();
\n MX_USART1_UART_Init();<\/p>\n
\/* USER CODE BEGIN 2 *\/<\/p>\n
\/* \u7cfb\u7edf\u4fe1\u606f *\/
\n printf("\\\\nSTM32 + SST39VF800A Flash Test\\\\n");
\n printf("\u6a21\u5f0f：\u590d\u7528\u6a21\u5f0f (Muxed Mode)\\\\n");
\n printf("\u914d\u7f6e\u5730\u5740\u7ebf：%d bits\\\\n", ADDR_BITS_USED);
\n printf("===============================\\\\n\\\\n");<\/p>\n
\/* \u6d4b\u8bd5\u590d\u7528\u6a21\u5f0f\u517c\u5bb9\u6027 *\/
\n Test_Muxed_Mode_Compatibility();<\/p>\n
\/* \u521d\u59cb\u5316NOR Flash *\/
\n LZY_NOR_Init();<\/p>\n
\/* \u9a8c\u8bc1\u5730\u5740\u6620\u5c04 *\/
\n Verify_Address_Mapping();<\/p>\n
\/* \u663e\u793a\u8bbe\u5907\u4fe1\u606f *\/
\n LZY_NOR_DisplayInfo();<\/p>\n
\/* \u6d4b\u8bd5\u5b8c\u6574\u5730\u5740\u7a7a\u95f4（\u5728\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4\u5185） *\/
\n Test_Full_Address_Range();<\/p>\n
\/* \u521d\u59cb\u6d4b\u8bd5 *\/
\n printf("=== \u521d\u59cb\u6d4b\u8bd5 ===\\\\n");
\n LZY_WRITE_TEST(0x1000, 0x5555); \/\/ \u6d4b\u8bd5\u5730\u57400x1000，\u5199\u51650x5555
\n LZY_WRITE_TEST(0x2000, 0xAAAA); \/\/ \u6d4b\u8bd5\u5730\u57400x2000，\u5199\u51650xAAAA<\/p>\n
\/* USER CODE END 2 *\/<\/p>\n
\/* Infinite loop *\/
\n \/* USER CODE BEGIN WHILE *\/
\n while (1)
\n {
\n \/* \u5faa\u73af\u6d4b\u8bd5\u4e0d\u540c\u7684\u5730\u5740\u548c\u6570\u636e *\/
\n static uint32_t test_count = 0;<\/p>\n
\/\/ \u5728\u914d\u7f6e\u7684\u5730\u5740\u7ebf\u8303\u56f4\u5185\u5faa\u73af\u6d4b\u8bd5
\n uint32_t max_test_addr = MAX_MUXED_ADDRESS;
\n if (max_test_addr > NOR_FLASH_SIZE_BYTES – 2) {
\n max_test_addr = NOR_FLASH_SIZE_BYTES – 2;
\n }<\/p>\n
\/\/ \u751f\u6210\u6d4b\u8bd5\u5730\u5740（\u5728\u5b89\u5168\u8303\u56f4\u5185）
\n uint32_t base_addr = 0x1000 + (test_count % 8) * 0x1000;<\/p>\n
\/\/ \u786e\u4fdd\u5730\u5740\u5728\u8303\u56f4\u5185
\n if (base_addr > max_test_addr) {
\n base_addr = max_test_addr – 0x8000; \/\/ \u56de\u9000\u5230\u4e00\u4e2a\u5b89\u5168\u5730\u5740
\n }<\/p>\n
base_addr = base_addr & ~0x01; \/\/ \u786e\u4fdd\u5b57\u5bf9\u9f50<\/p>\n
uint16_t test_data = 0x1234 + test_count * 0x1111;<\/p>\n
printf("Test #%lu: ", test_count);
\n LZY_WRITE_TEST(base_addr, test_data);<\/p>\n
test_count++;
\n HAL_Delay(2000); \/\/ \u6bcf2\u79d2\u6d4b\u8bd5\u4e00\u6b21<\/p>\n
\/\/ \u6bcf10\u6b21\u6d4b\u8bd5\u6253\u5370\u4e00\u6b21\u72b6\u6001
\n if (test_count % 10 == 0) {
\n printf("\\\\n=== \u6d4b\u8bd5\u7edf\u8ba1 ===\\\\n");
\n printf("\u5df2\u6267\u884c\u6d4b\u8bd5\u6b21\u6570: %lu\\\\n", test_count);
\n printf("\u5f53\u524d\u6700\u5927\u53ef\u8bbf\u95ee\u5730\u5740: 0x%06lX\\\\n", max_test_addr);
\n printf("\u914d\u7f6e\u5730\u5740\u7ebf: %d bits\\\\n", ADDR_BITS_USED);
\n printf("==================\\\\n\\\\n");
\n }
\n }
\n \/* USER CODE END 3 *\/
\n}<\/p>\n
\/* \u5176\u4ed6\u51fd\u6570\u4fdd\u6301\u4e0d\u53d8… *\/<\/p>\n
\/* USER CODE BEGIN 4 *\/<\/p>\n
\/* USER CODE END 4 *\/<\/p>\n
\/**
\n * @brief System Clock Configuration
\n * @retval None
\n *\/
\nvoid SystemClock_Config(void)
\n{
\n RCC_OscInitTypeDef RCC_OscInitStruct = {0};
\n RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};<\/p>\n
\/** Configure the main internal regulator output voltage
\n *\/
\n HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST);<\/p>\n
\/** Initializes the RCC Oscillators according to the specified parameters
\n * in the RCC_OscInitTypeDef structure.
\n *\/
\n RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
\n RCC_OscInitStruct.HSEState = RCC_HSE_ON;
\n RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
\n RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
\n RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
\n RCC_OscInitStruct.PLL.PLLN = 85;
\n RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
\n RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
\n RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
\n if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
\n {
\n Error_Handler();
\n }<\/p>\n
\/** Initializes the CPU, AHB and APB buses clocks
\n *\/
\n RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
\n |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
\n RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
\n RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
\n RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
\n RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;<\/p>\n
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
\n {
\n Error_Handler();
\n }
\n}<\/p>\n
\/* USER CODE BEGIN 4 *\/<\/p>\n
\/* USER CODE END 4 *\/<\/p>\n
\/**
\n * @brief This function is executed in case of error occurrence.
\n * @retval None
\n *\/
\nvoid Error_Handler(void)
\n{
\n \/* USER CODE BEGIN Error_Handler_Debug *\/
\n printf("\\\\n[ERROR] Error_Handler called! System halted.\\\\n");
\n __disable_irq();
\n while (1)
\n {
\n \/\/ Flash LED rapidly to indicate error
\n HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_0);
\n HAL_Delay(100);
\n }
\n \/* USER CODE END Error_Handler_Debug *\/
\n}
\n#ifdef USE_FULL_ASSERT
\n\/**
\n * @brief Reports the name of the source file and the source line number
\n * where the assert_param error has occurred.
\n * @param file: pointer to the source file name
\n * @param line: assert_param error line source number
\n * @retval None
\n *\/
\nvoid assert_failed(uint8_t *file, uint32_t line)
\n{
\n \/* USER CODE BEGIN 6 *\/
\n printf("[ERROR] Assert failed: file %s, line %d\\\\n", file, (int)line);
\n \/* USER CODE END 6 *\/
\n}
\n#endif \/* USE_FULL_ASSERT *\/<\/p>\n","protected":false},"excerpt":{"rendered":"
\u901a\u8fc7\u7f51\u76d8\u5206\u4eab\u7684\u6587\u4ef6：STM32G474VET6NOR FLASH \u9a8c\u8bc1.zip
\n\u94fe\u63a5: https:\/\/pan.baidu.com\/s\/1323CdUaAsV1m6juSMh9i9g?pwdpbbn \u63d0\u53d6\u7801: pbbn\u00a0
\n–\u6765\u81ea\u767e\u5ea6\u7f51\u76d8\u8d85\u7ea7\u4f1a\u5458v4\u7684\u5206\u4eabCUBE MAX\u914d\u7f6e：\u672c\u6587\u5c06\u901a\u8fc7\u5206\u6790\u63d0\u4f9b\u7684\u4ee3\u7801\u548c\u6d41\u7a0b\u56fe，\u8be6\u7ec6\u89e3\u91caSTM32\u4e0eSST39VF800A Flash\u5b58\u50a8\u5668\u4e4b\u95f4\u7684\u64cd\u4f5c\u6d41\u7a0b，\u7279\u522b\u662f\u5b57\u7f16\u7a0b\u3001\u6247\u533a\u64e6\u9664\u548c\u8bbe\u5907ID\u8bfb\u53d6<\/p>\n","protected":false},"author":2,"featured_media":61811,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[87,78],"topic":[],"class_list":["post-61818","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-87","tag-78"],"yoast_head":"\n