Продолжаем работу по программированию контроллера STM32F4 и также работу с последовательной FLASH-памятью серии W25Q. На данном уроке мы попробуем стереть данные из памяти микросхемы. Дело в том, что, как мы знаем, FLASH-память устроена так, что пока данные не сотрёшь, новые в неё не запишешь, либо запишешь с искажениями.
Для удобства работы мы также будем использовать программу для Windows, ссылка на которую будет внизу страницы.
Схема наше также не изменилась
Проект мы за основу возьмём из прошлого урока с именем SPI_25Q32_READ_TO_PC и присвоим ему новое имя SPI_25Q32_CLEAR.
Откроем проект в Cube MX и, ничего в нём не меняя, сгенерируем проект и откроем его в Keil.
Подключим файл w25q_spi.c, настроим программатор на автоперезагрузку и отключим оптимизацию.
В стирании памяти в микросхемах серии w26q есть свои тонкости. Мы не можем стереть один байт, причём мы не можем стереть даже целую страницу. Минимум, что мы можем сделать, так это стереть сектор. Также мы можем стереть блок. Есть команда, с помощью которой стирается сразу вся информация из памяти микросхемы. Попробуем мы сегодня все три команды. Мало того, чтобы данные команды использовать, нужно кое-что подготовить. Поэтому было принято решение не объединять урок по стиранию и записи, а сделать их отдельными.
Перейдём в файл w25q_spi.c и добавим некоторые макросы, связанные с командами
|
1 2 3 4 5 6 7 |
#include "w25q_spi.h" //------------------------------------------------------------- #define W25_WRITE_DISABLE 0x04 #define W25_WRITE_ENABLE 0x06 #define W25_SECTOR_ERASE 0x20 #define W25_BLOCK_ERASE 0xD8 #define W25_CHIP_ERASE 0xC7 |
Какие именно команды несёт в себе каждый макрос, видно из его имени. Также посмотреть все команды можно в документации к чипу.
Ниже добавим ещё несколько макроподстановок для команд чтения статусных регистров
|
1 2 3 4 5 6 7 |
#define W25_GET_JEDEC_ID 0x9f #define W25_READ_STATUS_1 0x05 #define W25_READ_STATUS_2 0x35 #define W25_READ_STATUS_3 0x15 #define W25_WRITE_STATUS_1 0x01 #define W25_WRITE_STATUS_2 0x31 #define W25_WRITE_STATUS_3 0x11 |
Перейдём непосредственно к обработке команд. Прежде всего, мы должны знать о том, что для того, чтобы вносить любые изменения в микросхеме (чтение, запись), нужно их разрешить. для этого существует команда Write Enable. Добавим для неё функцию после функции W25_Read_Info
|
1 2 3 4 5 6 7 8 9 10 |
//------------------------------------------------------------- void W25_Write_Enable(void) { cs_set(); buf[0] = W25_WRITE_ENABLE; SPI1_Send(buf, 1); cs_reset(); HAL_Delay(1); } //------------------------------------------------------------- |
Мы, как обычно, сначала опускаем ножку выбора, передаём команду и поднимаем ножку, затем ждём одну милисекунду, чтобы дать команде выполниться.
После того, как мы внесём изменения в памяти микросхемы, мы должны их опять запретить. Поэтому ниже добавим функцию и для этой операции
|
1 2 3 4 5 6 7 8 9 10 |
//------------------------------------------------------------- void W25_Write_Disable(void) { cs_set(); buf[0] = W25_WRITE_DISABLE; SPI1_Send(buf, 1); cs_reset(); HAL_Delay(1); } //------------------------------------------------------------- |
Операции стирания и записи занимают определённое время и мы должны знать, когда они завершатся, чтобы продолжать дальше работать с чипом. Для этого мы должны прочитать определённый бит определённого статусного регистра. Перейдём в файл w25q_spi.h и в теле структуры w25_info_t объявим ещё три поля для всех трёх статусных регистров
|
1 2 3 4 |
uint8_t high_cap; uint8_t StatusRegister1; uint8_t StatusRegister2; uint8_t StatusRegister3; |
Вернёмся в файл w25q_spi.c и ниже функции W25_Write_Disable добавим функцию для ожидания завершения операции стирания или записи
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
//------------------------------------------------------------- void W25_Wait_Write_End(void) { HAL_Delay(1); cs_set(); buf[0] = W25_READ_STATUS_1; SPI1_Send(buf, 1); do{ SPI1_Recv(buf,1); w25_info.StatusRegister1 = buf[0]; HAL_Delay(1); } while((w25_info.StatusRegister1 & 0x01) == 0x01); cs_reset(); } //------------------------------------------------------------- |
Не смотря на то, что функция кажется громоздкой, ничего там страшного нет. После небольшой задержки мы также опускаем ножку выбора, отправляем команду на чтение первого регистра статуса, в цикле с небольшой периодичностью читаем ответ из шины и ждём, когда в нём будет сброшен первый бит (не нулевой), и опускаем ножку.
Вот данный регистр и этот бит
А вот так происходит операция чтения любого регистра статуса
Выше данной диаграммы в документации мы можем прочитать, как именно всё здесь происходит и почему мы каждую итерацию в цикле заново не отправляем команду чтения регистра. После отправки такой команды микросхема будет отдавать нам результат чтения регистра бесконечно до тех пор, пока мы не поднимем ножку выбора. Вот мы и дожидаемся в цикле результата, когда нужный нам бит примет нужное нам состояние.
Ну и, наконец-то, дело дошло до операции стирания данных.
Ниже добавим функцию для начала стирания сектора, в единственном входном параметре которой мы передаём только номер сектора. В теле функции мы дожидаемся готовности микросхемы к операции стирания (убеждаемся, что запись запрещена, то есть не происходит процесс изменения памяти), используя при этом только что добавленную функцию
|
1 2 3 4 5 6 |
//------------------------------------------------------------- void W25_Erase_Sector(uint32_t addr) { W25_Wait_Write_End(); } //------------------------------------------------------------- |
Далее мы вычисляем адрес, в котором находится данный сектор, так как команда стирания устроена так, что мы в неё отправляем не номер сектора, а его адрес
|
1 2 |
W25_Wait_Write_End(); addr = addr * w25_info.SectorSize; |
Разрешаем запись и опускаем ножку выбора
|
1 2 3 |
addr = addr * w25_info.SectorSize; W25_Write_Enable(); cs_set(); |
В нулевой байт буфера записываем код команды стирания сектора, а в следующие четыре или три, в зависимости от размера памяти микросхемы — адрес сектора и отправляем всё это в микросхему
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
cs_set(); buf[0] = W25_SECTOR_ERASE; if(w25_info.high_cap) { buf[1] = (addr >> 24) & 0xFF; buf[2] = (addr >> 16) & 0xFF; buf[3] = (addr >> 8) & 0xFF; buf[4] = addr & 0xFF; SPI1_Send(buf, 5); } else { buf[1] = (addr >> 16) & 0xFF; buf[2] = (addr >> 8) & 0xFF; buf[3] = addr & 0xFF; SPI1_Send(buf, 4); } |
Поднимаем ножку выбора, ждём также завершения операции записи и также применяем небольшую задержку
|
1 2 3 4 5 |
SPI1_Send(buf, 4); } cs_reset(); W25_Wait_Write_End(); HAL_Delay(1); |
Возникает вопрос, а почему мы не запретили в конце функции запись? Оказывается, разрешение записи работает до тех пор, пока мы явно не запретим её командой, либо пока мы держим ножку выбора опущенной. А, так как мы данную ножку подняли, то запись у нас автоматически стала запрещена.
Ниже, используя практически тот же код, но другую команду проделаем всё то же самое со стиранием блока
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
//------------------------------------------------------------- void W25_Erase_Block(uint32_t addr) { W25_Wait_Write_End(); addr = addr * w25_info.BlockSize; W25_Write_Enable(); cs_set(); buf[0] = W25_BLOCK_ERASE; if(w25_info.high_cap) { buf[1] = (addr >> 24) & 0xFF; buf[2] = (addr >> 16) & 0xFF; buf[3] = (addr >> 8) & 0xFF; buf[4] = addr & 0xFF; SPI1_Send(buf, 5); } else { buf[1] = (addr >> 16) & 0xFF; buf[2] = (addr >> 8) & 0xFF; buf[3] = addr & 0xFF; SPI1_Send(buf, 4); } cs_reset(); W25_Wait_Write_End(); HAL_Delay(1); } //------------------------------------------------------------- |
Теперь дело дошло до стирания всей памяти чипа. Добавим ниже функцию, в которой мы проделаем то же самое, только с другой командой. Также мы не передаём никакой адрес, так как мы стираем всю память и также не используем никакие входные аргументы
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
//------------------------------------------------------------- void W25_Erase_Chip(void) { W25_Wait_Write_End(); W25_Write_Enable(); cs_set(); buf[0] = W25_CHIP_ERASE; SPI1_Send(buf, 1); cs_reset(); W25_Wait_Write_End(); HAL_Delay(10); } //------------------------------------------------------------- |
Добавим на наши три функции прототипы в файле w25q_spi.h
|
1 2 3 4 |
void W25_Read_Info(char* str_info); void W25_Erase_Sector(uint32_t addr); void W25_Erase_Block(uint32_t addr); void W25_Erase_Chip(void); |
Вернёмся в файл w25q_spi.c и перейдём в функцию инициализации W25_Ini, в которой нам нужно будет вернуть идентификацию нашего чипа.
Сначала объявим переменную
|
1 2 3 |
void W25_Ini(void) { unsigned int id = W25_Read_ID(); |
И ниже вернём код идентификации и инициализации полей переменной структуры информации о микросхеме
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
HAL_Delay(100); id &= 0x0000ffff; w25_info.high_cap = 0; switch(id) { case 0x401A: w25_info.high_cap=1; w25_info.BlockCount=1024; break; case 0x4019: w25_info.high_cap=1; w25_info.BlockCount=512; break; case 0x4018: w25_info.BlockCount=256; break; case 0x4017: w25_info.BlockCount=128; break; case 0x4016: w25_info.BlockCount=64; break; case 0x4015: w25_info.BlockCount=32; break; case 0x4014: w25_info.BlockCount=16; break; case 0x4013: w25_info.BlockCount=8; break; case 0x4012: w25_info.BlockCount=4; break; case 0x4011: w25_info.BlockCount=2; break; default: return; } w25_info.PageSize=256; w25_info.SectorSize=0x1000; w25_info.SectorCount=w25_info.BlockCount*16; w25_info.PageCount=(w25_info.SectorCount*w25_info.SectorSize)/w25_info.PageSize; w25_info.BlockSize=w25_info.SectorSize*16; w25_info.NumKB=(w25_info.SectorCount*w25_info.SectorSize)/1024; |
Теперь перейдём в файл main.c и в бесконечном цикле функции main() отреагируем на команду стирания микросхемы, пришедшую по UART от компьютера, в бесконечном цикле, продолжая наше условие. Для начала мы погасим оба светодиода
|
1 2 3 4 5 6 7 8 9 |
HAL_UART_Transmit(&huart1,rx_buf + w25_info.PageSize / 100,w25_info.PageSize % 100,0x1000); } } //command Clear else if(dt1[0] == 35) { HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); } |
В ответ отправим компьютеру кодовую цифру, которая будет обозначать, что мы начали процесс стирания
|
1 2 3 4 |
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); //07 - clear dt1[0] = 0x07; HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); |
Попробуем пока стереть, например, третий сектор
|
1 2 |
HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); W25_Erase_Sector(3); |
Отправим компьютеру кодовую цифру, по которой он поймёт, что процесс стирания закончен и зажжём оба светодиода
|
1 2 3 4 5 |
W25_Erase_Sector(3); dt1[0] = 0xEE; HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); |
Соберём код, прошьём контроллер, запустим компьютерную программу, настроим порт, считаем служебную информацию из микросхемы и после этого у нас должна стать активной кнопка Clear
Нажмём данную кнопку, дождёмся окончания процесса и увидим, что у нас снова стали неактивными кнопки чтения и стирания. Активной осталась только кнопка Info
Также мы видим, что на нашей плате светятся оба светодиода, обозначающие, что процесс завершен
Давайте проверим, что 3 сектор у нас действительно стёрт. Адрес его будет 3×4096=12288 или в шестнадцатеричном выражении 0x3000, то есть с данного адреса по адрес 0x3FFF у нас будут все биты установлены, то есть все байты будут иметь значение 0xFF. Считаем заново служебную информацию, чтобы кнопка Read активировалась, нажмём её и, дождавшись завершения убедимся, в том что данный диапазон у нас действительно стёрт
Информация действительно удалена.
Вернёмся в проект, закомментируем пока вызов функции стирания сектора и вызовем функцию стирания блока и попытаемся стереть, например 5 блок
|
1 2 |
//W25_Erase_Sector(3); W25_Erase_Block(5); |
Соберём проект, прошьём контроллер и в программе, считав служебную информацию опять нажмём кнопку Clear.
Опять прочитаем память нашей микросхемы. У нас теперь также информация в памяти должна быть стёрта с адреса 5×65536=327680 или в шестнадцатеричном выражении 0x50000 по адрес 0x5FFFF. Убедимся в этом, просмотрев информацию в ListView
Информация в данном диапазоне действительно стёрта.
Теперь в нашем проекте закомментируем функцию стирания блока и вызовем функцию стирания всей памяти микросхемы
|
1 2 |
//W25_Erase_Block(5); W25_Erase_Chip(); |
Соберём код, прошьём контроллер, также считаем с помощью нашей компьютерной программы служебную информацию из микросхемы, нажмём кнопку Clear, дождёмся активности кнопки Info, опять считаем служебную информацию и затем информацию из памяти микросхемы.
Если мы всё правильно написали, то вся память микросхем будет стёрта
Информация действительно вся стёрта из памяти.
Итак, на данном уроке мы научились стирать информацию из памяти микросхемы серии W25q посекторно, поблочно, а также полностью.
Всем спасибо за внимание!
Предыдущий урок Программирование МК STM32 Следующий урок
Программа для работы с микросхемой
Отладочную плату можно приобрести здесь STM32F429I-DISCO
Микросхему FLASH-памяти W25Q32FVSSIG SOP8 (5 штук) можно приобрести здесь W25Q32FVSSIG
Смотреть ВИДЕОУРОК (нажмите на картинку)
Добрый день! Сделайте пожалуйста урок, как на основе этой микросхемы W25Qxxx прикрутить файловую систему Little FS, говорят это очень просто. Данная файловая система увеличивает срок службы таких флэшек за счет записи данных каждый раз в новое место, плюс имеет защиту от пропадания питания. Заранее спасибо!
К сожалению, с данной файловой системой не работал, но буду иметь в виду, по возможности почитаю о ней.
Уважаемый автор публикации! А нету у Вас примера использования usb mass storage device + 25Q32 ? Чтобы файловая система была именно на этой флешке. И с ПК чтобы можно было закидывать файлы ну и со стороны МК чтобы можно было с файлами работать.