Продолжая тему программирования контроллера STM32F4 и также работу с последовательной FLASH-памятью серии W25Q, мы попытаемся с помощью программы для ПК записать данные в память микросхемы. Причём запишем мы данные из файла, подготовленного для прошивки.
Хочу заверить, что данная работа несложная, так как у нас почти всё для этого в библиотеке уже готово, поэтому было принято решение также для большей информативности задействовать дисплей LCD, который у нас на плате присутствует. Подключим мы его, используя также шину SPI, так как есть планы продолжить данную тему в LL, а там работа с интерфейсом LTDC не предусмотрена.
Схема урока не изменилась, осталась такая же, как и в прошлом занятии
И проект мы за основу также возьмём из прошлого урока с именем SPI_25Q32_CLEAR и присвоим ему новое имя SPI_25Q32_LCD.
Откроем проект в Cube MX и, так как дисплей на нашей плате подключен к шине SPI5, то её мы сейчас и задействуем. Дисплей по шине SPI мы уже подключали в уроке 179. Также мы подключали дисплей по SPI и на плате F429 в уроке 208, правда использовали мы библиотеку LL.
Включим SPI и настроим битрейт
Включим ножку PC2 на выход
То же самое проделаем и с ножками PD12 и PD13
Скорость им настроим максимальную, такую же как и у ножек SPI
Также кое-что поправим из существующего.
Во-первых, давайте поднимем ножку выбора микросхемы, иначе она сразу же начнёт работать
Добавим скорость на SPI1, так как микросхема у нас быстрая, и думаю справится
Также добавим размер стека и кучи
Сгенерируем проект и откроем его в Keil.
Подключим файл w25q_spi.c, настроим программатор на автоперезагрузку и отключим оптимизацию.
Из проекта урока 179 с именем ILI9341_SPI скопируем файлы spi_ili9341.c, spi_ili9341.h, а также файлы шрифтов font8.c, font12.c, font16.c, font20.c, font24.c и fonts.h в соответствующие каталоги нашего нового проекта. Файл spi_ili9341.c добавим в дерево проекта.
В файле main.c подключим нашу библиотеку дисплея
|
1 2 |
#include "w25q_spi.h" #include "spi_ili9341.h" |
В файле spi_ili9341.h внесём следующие изменения.
Здесь добавим расширение и уберём первую букву в имени
#include <cstdlib.h>
Здесь изменим ножки
#define RESET_ACTIVE() HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12,GPIO_PIN_RESET)
#define RESET_IDLE() HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12,GPIO_PIN_SET)
#define CS_ACTIVE() HAL_GPIO_WritePin(GPIOC,GPIO_PIN_2,GPIO_PIN_RESET)
#define CS_IDLE() HAL_GPIO_WritePin(GPIOC,GPIO_PIN_2,GPIO_PIN_SET)
#define DC_COMMAND() HAL_GPIO_WritePin(GPIOD,GPIO_PIN_13,GPIO_PIN_RESET)
#define DC_DATA() HAL_GPIO_WritePin(GPIOD,GPIO_PIN_13,GPIO_PIN_SET)
Данный прототип функции удалим
uint16_t TFT9341_RandColor(void);
Перейдём в файл spi_ili9341.c и удалим одноимённую функцию вместе с телом.
Удалим также подключение библиотеки для генератора случайных чисел
extern RNG_HandleTypeDef hrng;
Выше в подключении библиотеки для SPI, а также ниже во всех местах, где попадётся hspi1, исправим на hspi5.
В функции TFT9341_DrawLine уберём здесь плюс, получится
err=dx;
Перейдём в файл main.c и в функции main() произведём инициализацию дисплея
|
1 2 3 |
W25_Ini(); TFT9341_ini(240, 320); TFT9341_FillScreen(TFT9341_BLACK); |
Теперь займёмся записью в память микросхемы.
Для этого идём в файл w25q_spi.c и добавим макрос для команды записи
|
1 2 |
#define W25_READ 0x03 #define W25_PAGE_PROGRAMM 0x02 |
Из тел функций W25_Write_Enable и W25_Write_Disable удалим задержку
cs_reset();
HAL_Delay(1);
Ниже функции W25_Write_Disable добавим функцию включения и отключения защитных битов
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
//------------------------------------------------------------- void W25_Set_Block_Protect(uint8_t val) { buf[0] = 0x50; cs_set(); SPI1_Send(buf, 1); cs_reset(); buf[0] = W25_WRITE_STATUS_1; buf[1] = ((val & 0x0F) << 2); cs_set(); SPI1_Send(buf, 2); cs_reset(); } //------------------------------------------------------------- |
Ничего особенного в данной функции нет, она сначала разрешает запись в статусный регистр, а затем включает или отключает нужные биты в нём.
Теперь в функции W25_Erase_Sector мы сначала разблокируем защиту
|
1 2 3 4 |
void W25_Erase_Sector(uint32_t addr) { W25_Wait_Write_End(); W25_Set_Block_Protect(0x00); |
Затем внизу тела функции мы сначала удалим задержку
W25_Wait_Write_End();
HAL_Delay(1);
А вместо этого мы отключим запись и включим защиту
|
1 2 3 |
W25_Wait_Write_End(); W25_Write_Disable(); W25_Set_Block_Protect(0x0F); |
Затем ровно то же самое проделаем с функциями W25_Erase_Block и W25_Erase_Chip.
Ниже функции W25_Erase_Chip добавим функцию записи данных, в которой мы сначала дождёмся готовности микросхемы к операции изменения данных, разблокируем защиту, включим возможность записи и опустим ножку выбора
|
1 2 3 4 5 6 7 8 9 |
//------------------------------------------------------------- void W25_Write_Data(uint32_t addr, uint8_t* data, uint32_t sz) { W25_Wait_Write_End(); W25_Set_Block_Protect(0x00); W25_Write_Enable(); cs_set(); } //------------------------------------------------------------- |
Далее отправляем в нашу микросхему команду на запись и адрес, с которого пишем, и затем сразу же отправляем наши данные
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
cs_set(); buf[0] = W25_PAGE_PROGRAMM; 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); } SPI1_Send(data, sz); |
Поднимем ножку, дождёмся окончания процесса записи, запретим запись и включим защиту
|
1 2 3 4 |
cs_reset(); W25_Wait_Write_End(); W25_Write_Disable(); W25_Set_Block_Protect(0x0F); |
По такому же принципу сочиним функцию для записи целой страницы памяти и добавим её ниже
|
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 |
//------------------------------------------------------------- void W25_Write_Page(uint8_t* data, uint32_t page_addr, uint32_t offset, uint32_t sz) { if(sz > w25_info.PageSize) sz=w25_info.PageSize; if((offset+sz) > w25_info.PageSize) sz = w25_info.PageSize - offset; page_addr = page_addr * w25_info.PageSize + offset; W25_Wait_Write_End(); W25_Set_Block_Protect(0x00); W25_Write_Enable(); cs_set(); buf[0] = W25_PAGE_PROGRAMM; if(w25_info.high_cap) { buf[1] = (page_addr >> 24) & 0xFF; buf[2] = (page_addr >> 16) & 0xFF; buf[3] = (page_addr >> 8) & 0xFF; buf[4] = page_addr & 0xFF; SPI1_Send(buf, 5); } else { buf[1] = (page_addr >> 16) & 0xFF; buf[2] = (page_addr >> 8) & 0xFF; buf[3] = page_addr & 0xFF; SPI1_Send(buf, 4); } SPI1_Send(data, sz); cs_reset(); W25_Wait_Write_End(); W25_Write_Disable(); W25_Set_Block_Protect(0x0F); } //------------------------------------------------------------- |
В заголовочном файле добавим прототипы на наши обе функции, вернёмся в файл main.c и в функции main() объявим три целочисленные локальные переменные
|
1 2 |
uint8_t dt1[10]; unsigned int cur_page, pageSize, pageCount; |
В бесконечном цикле в той ветке условия, где происходит процесс чтения служебной информации, объявим на дисплее о данном процессе
|
1 2 3 4 5 6 |
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); TFT9341_SetFont(&Font20); TFT9341_SetBackColor(TFT9341_BLACK); TFT9341_FillScreen(TFT9341_BLACK); TFT9341_String(1,150,"Read Info "); |
Затем в конце ветви отчитаемся об окончании процесса
|
1 2 |
HAL_UART_Transmit(&huart1,rx_buf,strlen((char*)rx_buf),0x1000); TFT9341_String(1,176,"Done!"); |
В следующей ветви, предназначенной для чтения из памяти, добавим аналогичный код
|
1 2 3 4 5 6 |
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); TFT9341_SetFont(&Font20); TFT9341_SetBackColor(TFT9341_BLACK); TFT9341_FillScreen(TFT9341_BLACK); TFT9341_String(1,150,"Read Data "); |
В конце ветви отчитаемся об окончании процесса чтения
|
1 2 3 |
HAL_UART_Transmit(&huart1,rx_buf + w25_info.PageSize / 100,w25_info.PageSize % 100,0x1000); } TFT9341_String(1,176,"Done!"); |
Выше в данной ветви была ошибка в момент отправки последней порции байтов, смещение было только в количестве переданных уже порций, но надо это количество умножить на сто, иначе мы отправляем порцию не из того места буфера
HAL_UART_Transmit(&huart1,rx_buf + w25_info.PageSize / 100 * 100, w25_info.PageSize % 100,0x1000);
В следующей ветви, предназначенной для стирания чипа, добавим также аналогичный код
|
1 2 3 4 5 6 |
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); TFT9341_SetFont(&Font20); TFT9341_SetBackColor(TFT9341_BLACK); TFT9341_FillScreen(TFT9341_BLACK); TFT9341_String(1,150,"Clear Chip "); |
В конце ветви также отчитаемся об окончании процесса
|
1 2 3 |
dt1[0] = 0xEE; HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); TFT9341_String(1,176,"Done!"); |
Далее добавим в наш оператор следующее условие, которое будет срабатывать, когда компьютер пришлёт команду на запись в память, в котором для начала погасим светодиоды
|
1 2 3 4 5 6 7 8 9 10 |
TFT9341_String(1,176,"Done!"); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); } //command Write else if(dt1[0] == 36) { HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); } |
После того, как погасим светодиоды, примем ещё 8 байтов с информацией от компьютера и также на дисплее напишем о начале процедуры записи
|
1 2 3 4 5 6 7 |
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_RESET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_RESET); HAL_UART_Receive(&huart1,(uint8_t*)rx_buf,8,0x1000); TFT9341_SetFont(&Font20); TFT9341_SetBackColor(TFT9341_BLACK); TFT9341_FillScreen(TFT9341_BLACK); TFT9341_String(1,150,"Write Data "); |
Присвоим из буфера количество страниц и размер страницы соответствующим переменным и пошлём компьютеру команду на начало передачи данных для записи в микросхему
|
1 2 3 4 5 |
TFT9341_String(1,150,"Write Data "); pageCount = *(unsigned int*)(rx_buf); pageSize = *(unsigned int*)(rx_buf + 4); dt1[0] = 0xAA; HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); |
Затем добавим бесконечный цикл, в котором примем от компьютера номер записываемой страницы, байты страницы, запишем эти байты в микросхему и отправим компьютеру команду об окончании записи страницы, а если это последняя страница, то выйдем из бесконечного цикла.
|
1 2 3 4 5 6 7 8 9 10 11 |
HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); while(1) { HAL_UART_Receive(&huart1,(uint8_t*)rx_buf,4,0x1000); cur_page = *(unsigned int*)(rx_buf); HAL_UART_Receive(&huart1,(uint8_t*)rx_buf,256,0x1000); W25_Write_Page(rx_buf, cur_page, 0, pageSize); dt1[0] = 0xEE; HAL_UART_Transmit(&huart1,(uint8_t*)dt1,1,0x1000); if(cur_page >= (pageCount - 1)) break; } |
После данного цикла, как обычно, отчитаемся об окончании процесса и зажжём светодиоды
|
1 2 3 4 5 |
if(cur_page >= (pageCount - 1)) break; } TFT9341_String(1,176,"Done!"); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET); |
Ну и наконец-то пришло время проверить наши труды.
Программу для ПК, как вы, думаю, поняли, я доработал и её вы также можете скачать по ссылке внизу данной страницы.
Запустим нашу программу, соответственно, перед этим собрав наш код для контроллера и прошив его, и сначала считаем, как всегда, служебную информацию, чтобы нужные нам кнопки стали активными.
Как мы видим на дисплее, информация о начале и об окончании процесса из за его быстрого срабатывания появилась практически мгновенно
Попробуем считать данные из микросхемы, нажав кнопку Read.
Вот начало процесса
А вот окончание
Так как на прошлом занятии мы стёрли всю информацию из памяти микросхемы, мы видим вот это
Заново прочитаем служебную информацию, чтобы кнопки вновь стали активными.
С помощью кнопки Open File откроем файл с прошивкой
Мы видим, что файл открылся и кнопка Write стала активной, нажмём её для начала процесса записи прошивки в микросхему.
Сначала мы получим соответствующее предупреждение, что вся информация будет перезаписана. Соглашаемся и процесс записи начнётся, о чем будет ясно по прогресс-индикатору, а также по надписи на дисплее отладочной платы
По окончанию процесса на дисплее мы получим соответствующее сообщение, а также увидим зажжённые светодиоды
Мы можем считать прошивку из платы, записать её в файл и сравнить тот файл, который мы писали в микросхему со считанным. Они должны быть одинаковыми. Я неоднократно в этом уже убедился, так что можете поверить мне на слово.
Итак, на данном занятии мы научились прошивать микросхему серии W25Q, то есть записывать в неё данные. Также нам удалось задействовать дисплей, после чего мы можем выводить на него нужную нам информацию.
Всем спасибо за внимание!
Предыдущий урок Программирование МК STM32 Следующий урок
Программа для работы с микросхемой
Отладочную плату можно приобрести здесь STM32F429I-DISCO
Микросхему FLASH-памяти W25Q32FVSSIG SOP8 (5 штук) можно приобрести здесь W25Q32FVSSIG
Смотреть ВИДЕОУРОК (нажмите на картинку)
Добрый день.
А возможно ли прикрепить исходный файл виндовс программы для работы с данным контроллером?