[Решено] STM32Cube SPI CPOL CPHA
Сейчас переношу на HAL, Cube и все такое, для CPHA есть варианты:
![]()
- 1 Edge
- 2 Edge
Вопрос — что выбирать?
Создатель темы Размещено : 14.05.2023 12:07
Метки темы
Top level Admin
По коду HAL надо смотреть:
/** @defgroup SPI_Clock_Phase SPI Clock Phase * @< */ #define SPI_PHASE_1EDGE (0x00000000U) #define SPI_PHASE_2EDGE SPI_CR1_CPHA /**
Значит в данном случае выбираем 2 edge.
Ответить Цитата
Размещено : 14.05.2023 12:15
New member
@aveal ага понял, спасибо. Буду переносить проект дальше, потом протестирую.
Ответить Цитата
Создатель темы Размещено : 14.05.2023 12:38
Вход | Регистрация to reply to this topic.
Forum Jump:
Похожие темы
1 месяц назад
2 месяца назад
3 месяца назад
3 месяца назад
3 месяца назад
Метки темы: stm32 (64) , stm32cube (11) , stm32cubeide (10) ,
В данный момент смотрят эту тему 1 гость.
Поделиться:
Статистика форума
2,146 Записи
1,430 Участники
Иконки форумов: Форум не содержит непрочитанных сообщений Форум содержит непрочитанные сообщения Отметить все как прочитанные
Иконки тем : Без ответа Отвеченный Активный Актуально Закреплено Не одобрен Решено Личное Закрыто
Рубрики
Сообщество
Свежие записи
- Где в схеме ошибка?
- STM32 и Ethernet. Часть 5. Транспортный уровень. Протокол UDP.
- Как добавить библиотеку в Arduino IDE.
- Как разогнать Raspberry Pi 4 Model B.
- Arduino. LCD 1602. I2C и другие варианты подключения.
Свежие комментарии
- Aveal к записи Stm32. Переходим на современный C++. Часть 3. Виртуальные порты ввода-вывода.
- winnie_the_poo к записи Stm32. Переходим на современный C++. Часть 3. Виртуальные порты ввода-вывода.
- гуок к записи Stm32. Переходим на современный C++. Часть 3. Виртуальные порты ввода-вывода.
- Aveal к записи Modbus RTU Slave. Пример реализации на микроконтроллере STM32.
- Дмитрий к записи Modbus RTU Slave. Пример реализации на микроконтроллере STM32.
© 2013 - 2023 MicroTechnics.ru | Политика конфиденциальности | Правила сайта | Изображения на сайте защищены авторским правом
На этом веб-сайте используются файлы cookie, которые обеспечивают работу функций для наиболее эффективной навигации по странице. Если вы не хотите принимать постоянные файлы cookie, пожалуйста, выберите соответствующие настройки на своем компьютере. Продолжая навигацию по сайту, вы косвенно предоставляете свое согласие на использование файлов cookie на этом веб-сайте.
Close GDPR Cookie Settings
- Privacy Overview
- Strictly Necessary Cookies
Privacy Overview
This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.
Strictly Necessary Cookies
Strictly Necessary Cookie should be enabled at all times so that we can save your preferences for cookie settings.
Enable or Disable Cookies
If you disable this cookie, we will not be able to save your preferences. This means that every time you visit this website you will need to enable or disable cookies again.
Семь шагов переноса программы в 64-битную систему - Выявление скрытых ошибок
Если вы считаете, что после исправления всех ошибок компиляции получите долгожданное 64-битное приложение, то ошибаетесь. Самое трудное еще впереди. На этапе компиляции исправляются самые явные ошибки, которые компилятор смог обнаружить, и которые в основном связаны с невозможностью неявного преобразования типов. Но это лишь малая часть проблемы. Большинство ошибок скрыто. С позиции абстрактного языка C++ эти ошибки кажутся безопасными и скрыты под явными преобразованиями типов. Число таких ошибок намного превышает число ошибок, выявленных на этапе компиляции.
Не возлагайте надежды на ключ /Wp64. Этот ключ часто представляется как чудесное средство поиска 64-битных ошибок. На практике ключ /Wp64 позволяет получить некоторые предупреждения, касающиеся неправильности некоторых участков кода в 64-битном режиме при компиляции 32-битного кода. При компиляции 64-битного кода эти предупреждения показываются в любом случае. И поэтому ключ /Wp64 игнорируется при компиляции 64-битного приложения. Данный ключ не поможет в поиске скрытых ошибок.
Рассмотрим несколько примеров скрытых ошибок.
6.1. Явное преобразование типа
Простейший, но отнюдь не самый легкий для выявления класс ошибок связан с явными преобразованиями типов, когда обрезаются значимые биты. Известный пример – преобразование указателей в 32-битные типы при передаче их в такие функции, как SendMessage(послать сообщение):
MyObj* pObj = .
::SendMessage(hwnd, msg, (WORD)x, (DWORD)pObj);
Здесь явное преобразование типа используется для преобразования указателя в числовой тип. Для 32-битной архитектуры этот пример правилен, так как последний параметр функции SendMessage имеет тип LPARAM, совпадающий с DWORD в 32-битной архитектуре. Для 64-битной архитектуры DWORD неправилен и должен быть заменен на LPARAM. Тип LPARAM имеет размеры 32 или 64 бита в зависимости от архитектуры.
Это простой случай, но преобразование типа часто кажется более сложным, и его нельзя обнаружить с помощью предупреждений компилятора или поиска по тексту программы. Явные преобразования типов подавляют выявление ошибок компилятором, так как они предназначены для этой самой цели – сообщать компилятору, что преобразование типа верное, и что программист отвечает за безопасность кода. Явный поиск также не поможет. Типы могут иметь нестандартные имена (определенные программистом с помощью typedef), и велико количество методов, выполняющих явное преобразование типов. Для надежного обнаружения таких ошибок используйте только специальный инструментарий, такой как анализаторы Viva64 или PC-Lint.
6.2. Неявное преобразование типа
Следующий пример касается неявного преобразования типа, когда значимые биты также теряются. Код функции fread производит чтение из файла, но работает неверно, когда пытается считать более 2 ГБ в 64-битной системе.
size_t __fread(void * __restrict buf,
size_t size, size_t count, FILE * __restrict fp);
size_t fread(void * __restrict buf, size_t size, size_t count,
FILE * __restrict fp)
int ret;
FLOCKFILE(fp);
ret = __fread(buf, size, count, fp);
FUNLOCKFILE(fp);
return (ret);
>
Функция __fread возвращает тип size_t, но тип int используется для хранения количества считанных байтов. В результате при больших размерах считанных данных функция может вернуть неверное количество байтов.
Можно сказать, что это безграмотный код для начинающих, что компилятор сообщил о таком преобразовании типа, и что на самом деле данный код легко найти и исправить. Это в теории. На практике в крупных проектах все иначе. Этот пример взят из исходного кода FreeBSD. Ошибка была исправлена лишь в декабре 2008! Заметьте, что первая (пробная) 64-битная версия FreeBSD была выпущена в июне 2003.
Исходный код до исправления:
Исправленный вариант кода (декабрь 2008):
6.3. Биты и сдвиги
Легко сделать ошибку в коде при работе с отдельными битами. Следующий тип ошибки относится к операциям сдвига.
ptrdiff_t SetBitN(ptrdiff_t value, unsigned bitNum) ptrdiff_t mask = 1 return value | mask;
>
Этот код успешно работает в 32-битной архитектуре и позволяет установить биты с номерами 0 - 31 на единицу. После переноса программы на 64-битную платформу вам понадобится установить биты от 0 до 63. Но этот код никогда не установит биты 32-63. Обратите внимание, что "1" имеет тип int, и когда совершается сдвиг на 32 разряда, происходит переполнение, как показано на рисунке 5. Будет ли получен 0 (рисунок 5-B) или 1 (рисунок 5-C) в результате – зависит от реализации компилятора.

Рисунок 5. A – Правильная установка 32-го бита в 32-битном коде; B,C – ошибка установки 32-го бита в 64-битной системе (два способа поведения)
Чтобы исправить код, надо сделать константу "1" такого же типа, что и переменная mask(маска):
ptrdiff_t mask = ptrdiff_t(1)Также обратите внимание, что неверный код вызывает еще одну ошибку. При установке 31 бита в 64-битной системе результатом функции будет значение 0xffffffff80000000 (смотрите рисунок 6). Результатом выражения 1
Рисунок 6. Ошибка установки 31-го бита в 64-битной системе
6.4. Магические числа
Магические константы, т.е. числа, с помощью которых определяется размер того или иного типа, могут вызывать много затруднений. Правильное решение – использовать операторы sizeof() для этих целей, но в большой программе может быть скрыт старый участок кода, где, как программисты считают, размер указателя равен 4 байтам, а в size_t всегда входит 32 бита. Обычно такие ошибки выглядят так:
size_t ArraySize = N * 4;
size_t *Array = (size_t *)malloc(ArraySize);Рисунок 4 показывает основные числа, с которыми надо работать осторожно при переносе на 64-битную платформу.
Таблица 4. Основные магические значения, представляющие опасность при переносе приложений с 32-битной платформы на 64-битную
6.5. Ошибки, касающиеся использования 32-битных переменных в качестве индексов
В программах, обрабатывающих большие объемы данных, могут возникать ошибки, касающиеся индексирования больших массивов или бесконечных циклов. Следующий пример содержит 2 ошибки:
const size_t size = . ;
char *array = . ;
char *end = array + size;
for (unsigned i = 0; i != size; ++i)
const int one = 1;
end[-i - one] = 0;
>Первая ошибка заключается в том, что если объем обрабатываемых данных превышает 4 GB (0xFFFFFFFF), может возникнуть бесконечный цикл, так как переменная 'i' имеет беззнаковый тип и никогда не достигнет значения 0xFFFFFFFF. Это может произойти, но не обязательно. Это зависит от того, какой код собирает компилятор. Например, в режиме отладки бесконечный цикл будет иметься, а в коде выпуска не будет цикла, поскольку компилятор решит оптимизировать код с помощью 64-битного регистра для счетчика, и цикл будет правильным. Все это создает путаницу, и код, работавший вчера, может не работать сегодня.
Вторая ошибка касается разбора массива от начала до конца, для чего используются отрицательные значения индексов. Этот код успешно работает в 32-битном режиме, но при выполнении на 64-битном компьютере произойдет выход за пределы массива на первой итерации цикла, и программа аварийно завершится. Рассмотрим причину такого поведения.
Согласно правилам C++ выражение в 32-битной системе вычисляется следующим образом: (на первом шаге i = 0):
• выражение '-i' имеет беззнаковый тип и значение 0x00000000u.
• переменная 'one' будет увеличена с типа 'int' до беззнакового типа и будет равняться 0x00000001u. Примечание: тип int увеличивается (согласно стандарту C++) до беззнакового типа, если участвует в операции, где второй аргумент имеет беззнаковый тип.Совершается операция вычитания, в которой участвуют два значения беззнакового типа, и результат операции равен 0x00000000u - 0x00000001u = 0xFFFFFFFFu. Результат имеет беззнаковый тип.
В 32-битной системе обращение к массиву по индексу 0xFFFFFFFFu тождественно использованию индекса -1. То есть конец[0xFFFFFFFFu] является аналогом конец[-1]. В результате элементы массива обрабатываются правильно.
В 64-битной системе ситуация будет отличаться в последнем пункте. Беззнаковый тип будет увеличен до знакового типа ptfdiff_t, и индекс массива будет равняться 0x00000000FFFFFFFFi64. В результате произойдет переполнение.
Чтобы исправить код, надо использовать типы ptrdiff_t и size_t.6.6. Ошибки, касающиеся изменения типов используемых функций
Есть ошибки, в которых никто не виноват, но это все же ошибки. Допустим, давно в Visual Studio 6.0 был разработан проект, содержавший класс CSampleApp - потомок CWinApp. В базовом классе есть виртуальная функция WinHelp. Потомок перекрывает эту функцию и выполняет все необходимые действия. Данный процесс показан на рисунке 7.
Рисунок 7. Эффективный правильный код, созданный в Visual Studio 6.0.
Затем проект переносится на Visual Studio 2005, где прототип функции WinHelp изменился, но этого никто не заметит, так как в 32-битном режиме типы DWORD и DWORD_PTR совпадают, и программа продолжает работать правильно (рисунок 8).
Рисунок 8. Неправильный, но эффективный 32-битный код.
Ошибка возникает в 64-битной системе, где размеры типов DWORD и DWORD_PTR различаются (рисунок 9). В 64-битном режиме классы кажутся содержащими две разные функции WinHelp, что неверно. Помните, что такие ловушки могут скрываться не только в MFC(библиотека базовых классов Microsoft), в которой изменились типы аргументов ряда функций, но и в коде ваших приложений и сторонних библиотек.
Рисунок 9. Ошибка возникает в 64-битном коде
6.7. Выявление скрытых ошибок
Есть много примеров таких 64-битных ошибок. Те, кто интересуется данной темой и хочет узнать больше о таких ошибках, смотрите статью (<) “20 проблем переноса кода C++ на 64-битную платформу”.
Этап поиска скрытых ошибок – весьма непростая задача, и многие из них возникают нерегулярно и лишь при больших входных данных. Статические анализаторы кода годятся для выявления таких ошибок, так как они могут проверить весь код приложения независимо от входных данных и частоту выполнения его участков в реальных условиях. Есть смысл в использовании статического анализа на этапе переноса приложения на 64-битные платформы для обнаружения большинства ошибок в самом начале и при дальнейшей разработке 64-битных решений. Статический анализ предупреждает и учит программиста лучше понимать особенности ошибок, относящихся к 64-битной архитектуре, и писать более эффективный код. Автор статьи является разработчиком одного из таких специализированных анализаторов кода под названием Viva64. Чтобы узнать больше об инструменте и скачать демоверсию, посетите сайт компании OOO "Program Verification Systems".
Справедливости ради надо сказать, что анализаторы кода Gimpel PC-Lint и Parasoft C++Test имеют наборы правил для диагностики 64-битных ошибок. Но, во-первых, это универсальные анализаторы, и правила диагностики 64-битных ошибок в них неполноценные. Во-вторых, они рассчитаны преимущественно на модель данных LP64, применяемую в семействе операционной системы Linux, и оттого они не особо полезны для программ Windows, где применяется модель данных LLP64.
C Урок 13. Константы
Кроме переменных разного типа, а также массивов, для представления в программе существуют ещё и константы.
Константа — это значение, которое впоследствии в процессе программы не может быть изменено.
Константами мы уже, того не замечая, давно уже пользуемся в наших уроках. Мы использовали обычные целые и дробные числа, строки в кавычках, не используя при этом переменные. Это и были константы.
Константы, как и переменные, также могут иметь различный тип.
Целочисленный тип
Как и переменные, константы могут иметь, к примеру, целочисленный тип.
Этот тип используется в программе для представления в программе целых значений.
Причём, в отличие от переменных, константы могут по виду различаться не только в плане их максимальной величины, но ещё и по системе счисления.
Десятичные константы — последовательность цифр от 0 до 9, которая начинаются с цифры, отличной от нуля. Например, -54, 3, 15, 4321.
Восьмеричные — последовательность цифр от 0 до 7, которая всегда начинаются с цифры 0. Например, 0100, 03, 00, 04321.
Шестнадцатеричные — последовательность шестнадцатеричных цифр от 0 до F, которая в начале предваряется символами 0x. Причём, если у цифр будет буквенный вид (от A до F), то они могут выводиться как в нижнем, так и верхнем регистрах. Например, 0xFF, 0xabce, 0x01, 0x1A3C.
Также, как и переменные, целочисленные константы могут различаться и по размеру занимаемой памяти и по наличию или отсутствию знака, в связи с этим, они могут иметь определённый суффикс (постфикс).
Тип int — суффикса нет. Например 0, 50, 123456, 0xFFDDAABB.
А если нам нужно будет объявить беззнаковую константу, то мы уже добавляем суффикс u (U). Например, 0U, 1234u, 0xFFAACCBBU, 043210u.
Также мы можем выделить 8 байт под нашу константу, то есть объявить её типа long, добавив суффикс l (L).Например, 0L, 1234l, 0x10AADD00FFAACCBBL, 0123456L.
Можно и комбинировать ибо константа может иметь беззнаковый тип unsigned long. Например, 10UL, 412343ul, 0xFEAADD00FFAACCBBUL, 0123456UL.
Вещественный тип
Также константы могут быть и вещественного типа или с плавающей точкой.
Представляется такая константа в виде числа с плавающей точкой и по умолчанию, если не применять никаких суффиксов, ей назначается тип double (двойная точность). Состоит такая константа из целой части, точки, дробной части, символа экспоненты с самой экспонентой, которая может быть со знаком минус. Причём, эти пять видов представления не обязательно могут быть использованы все. Может отсутствовать экспонента, точка, дробная часть и даже целая часть.
Вот примеры констант с плавающей точкой (вещественного типа):
123.321, .012, 1.2345E-20, 321E15, .321E-9, 1234.
Если мы хотим использовать другой вещественный тип (float или long double), то для этого мы используем суффикс f (F) или l (L)
123.321f, .012L, 1.2345E-20l, 321E15L, .051E-9f, 1234567.L
Символьный тип
Константы могут также представлять и символы. Для этого они заключаются в символы апострофа
'\0', '0', 'n', '\t', '\n', '\r', 's', '3', 'A', 'Z', '\a', '\v'
Константы с символом обратного слэша (\) являются управляющими символами. Мы с ними также раньше встречались, например, переводя каретку и перенося строку.
Каждая символьная константа имеет код, например:
\n — 0x0A — перевод строки,
\a — 0x07 — звуковой сигнал,
\r — 0x0D — возврат каретки,
Z — 0x5A — буква Z.
Строковый тип
Константы строкового типа имеют вид набора (последовательности) символов, заключённого в кавычки. Кавычки, соответственно в памяти не хранятся, они служат только для обозначения строкового типа.
В конце всего набора символов (строки) компилятор всегда добавляет код 0 ('\0'), чтобы программе в процессе исполнения было легче определить окончание строки.
Вот примеры строковых констант
«Hello, World. »
«Hello\r\n»
Именованные константы
Если мы используем константы, не объявляя их заранее, а пишем прямо в выражениях в том виде, котором мы их только что рассмотрели, то это такие константы будут являться неименованными.
Также мы можем константы заранее объявить, тогда это уже будут именованные константы.
Такие константы мы можем объявить двумя способами.
Первый способ — директива препроцессора #define.
Используется она следующим образом
#define VAR_CONST1 15
После ключевого слова #define следует имя константы, а затем её значение. В результате этого впоследствии, если компилятор увидит где-то в коде данное имя, то он вместо него просто-напросто будет подставлять значение 15
printf( "Constant value is %d" , VAR_CONST1);
Вот ещё примеры таких констант
#define CONST0 0x00000000U
#define CONST1 0x00000001U
#define CONST2 0x00000002U
#define CONST4 0x00000004U
#define CONST8 0x00000008U
В качестве разделителей могут быть пробелы, табуляторы, также их серия, то есть не обязательно чтобы пробел и табулятор должен быть один.
Также такой вид объявления констант называют макросом, макроподстановкой или дефайновой заменой. В макросах помимо констант в значениях могут использоваться другие подстановки, мы с ними ещё встретимся впоследствии.
Второй способ объявления констант похож на объявление переменных, только перед типом мы ещё добавляем ключевое слово const
const int n = 0xFFFF ;
В дальнейшем мы данную константу с именем n можем использовать в нашем коде, например вот так
printf( "Constant value is %ld" , n);
Соответственно, изменить мы также константу n не можем по определению.
Такой способ объявления, как правило, больше нашел применение в языке C++, хотя в последнее время вполне применяется и в классическом C. Преимущество его по сравнению с дефайновой заменой то, что мы можем явно указать тип константы.
Думаю, на этом нам хватит теории, перейдём к практической части. Хоть мы и пользуемся константами практически в каждом уроке, там ещё есть над чем поразмыслить.
Как обычно, проект мы сделаем из проекта MYPROG12 прошлого занятия и имя ему присвоим MYPROG13.
Откроем файл main.c и в функции main(), как обычно, удалим весь код тела кроме возврата нуля, останется от него вот это
int main()
return 0 ; //Return an integer from a function
Удалим также все остальные (кроме main()) функции вместе с прототипами. Сначала поработаем с целыми типами.
Сначала неименованные константы.
Выведем обычное число типа int. Как мы знаем — это целочисленный тип для констант по умолчанию, поэтому суффиксов никаких мы не используем
Easyelectronics.ru
Я сравнительно недавно начал заниматься микроэлектроникой в основном с stm32, и довольно часто пользуюсь этим форумом.
И постоянно вижу разные комменты, не лестные, в адрес HAL, STM32Cube, SPL и так далее. С чем связанны вся эта ненависть к этим сущностям. Да я понимаю что в SPL есть косяки, сам на них натыкался, исправлял. Но почему использование STM32CubeMX "греховно"?
Ведь в переписывании одного и того же, конфигураций разной перефирии, нет чести для программиста, так почему не ускорять свою работу используя этот инструмент?Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 13:56Ненависть связана с тем, что это — говно, которое генерирует быдлокод, причесывать который уйдет больше времени, нежели написать тупо на регистрах!
SPL, кстати, уже давно deprecated.А для ускорения своей работы есть собственноручно писанные сниппеты: разработал обвязку для новой железяки — все, в дальнейшем можно пользоваться. В этом и заключается интенсивный подход.
Использование же быдлокода == экстенсивный подход — суть абдуринщиков.Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 14:11
Eddy_Em писал(а):
Ненависть связана с тем, что это — говно, которое генерирует быдлокодв языках высокого уровня,(парадигма ООП и тд), понятие быдлокода связанно с изобретением велосипедов в место использования паттернов, с не структурностью кода, неоправданными инклудами и тд. А в чем выражается "быдлокод" генерируемый тем же STM32CubeMX. Допустим он работает, сам не проверял.
Eddy_Em писал(а):
А для ускорения своей работы есть собственноручно писанные сниппеты.с этим соглашусь, и все же есть, но, вероятность что эти сниппеты тоже окажутся "быдлокодом" довольно высока, если например их напишет такой же новичок как и я.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 14:41С позиции чайника: он, сцуко, глючный, причём неожиданно глючный. Т.е. ты что-то делаешь - не работает. Начинаешь разбираться, что сделал не так - вначале находишь у себя misuse библиотеки (уже плохо: у такого плана либы должна быть или какая-никакая защита от misuse, или прибитая гвоздями инструкция), но всё равно не работает. Оказывается, либа в зависимости от режима может тупо проигнорировать переданный параметр (я пытался по timer+DMA гнать поток данных в BSRR - она игнорировала destination address), и надо её патчить. А чтобы патчить - надо разобраться во внутреннем устройстве, что требует многовато времени и сил.
С документацией тоже не всё гладко - вплоть до того, что (емнип) не описано, передавать длину массива данных для DMA в байтах или в word/dword (для полноты картины в сети попадались примеры с неправильной передачей)
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 14:48
aamonster писал(а):С позиции чайника: он, сцуко, глючный, причём неожиданно глючный. Т.е. ты что-то делаешь - не работает
Такого если честно не ожидал. и мой вопрос получается вообще не в тему.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 15:07
Могу еще накинуть.
Почитайте этот топик.
Особенно пост
RekoD писал(а):Там в документации так и написано: мы перешли от подхода "функции - по реальному железу" к подходу "функици - по фичам". В общем такое впечатление, что менеджеры всех там "покусали" в ST 🙂
А фичи они не всегда соответствуют реальному железу, вот и "подгоняют" это в HAL как могут.И теперь сравните с тем, чего вы ожидаете:
magistre96a писал(а):в языках высокого уровня,(парадигма ООП и тд), понятие быдлокода связанно с изобретением велосипедов в место использования паттернов , с не структурностью кода , неоправданными инклудами и тд.
Чего то мне подсказывает, что Ваши ожидания не совпадают с парадигмой того HAL который мы видим у ST, а не того, который мы ожидаем там увидеть, если судить по названию (HAL - Hardware Abstraction Level).
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 15:27
magistre96a писал(а):
А в чем выражается "быдлокод" генерируемый тем же STM32CubeMX.Говорят, что таки не совсем работает. А еще говорят, что генерирует такой избыточный код, что и объем неоправданно возрастает (т.е. при равных условиях придется больше тратить, т.к. мелкоконтроллер брать нужно будет более жирный), и лапша вместо кода — причесать это сложней, чем написать с нуля.
Новичку совет: скинуть на читалку или планшет (а то и распечатать) даташит на интересующий МК + мануал на семейство и пару раз в сортире почитать. Потом начать с простенького: по таймеру диодиком помигать, настроить ШИМ для управления яркостью светодиода, погенерировать квазисинусоиду ЦАПом или ШИМом и т.д., и т.п.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 15:31
Eddy_Em писал(а):Новичку совет: скинуть на читалку или планшет (а то и распечатать) даташит на интересующий МК + мануал на семейство и пару раз в сортире почитать. Потом начать с простенького: по таймеру диодиком помигать, настроить ШИМ для управления яркостью светодиода, погенерировать квазисинусоиду ЦАПом или ШИМом и т.д., и т.п.
этим как бы и занимаюсь, вопрос был задан потому что мне было непонятно из-за чего весь этот хайп
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 16:02Да нормально в целом Хал + Куб работают. Косяик конечно есть, но не смертельные. Оверкод там не такой уж и критичный чтоб прямо брать МК сильно жирный. 103 серии мне всегда хватало для своих поделок. Накрайняк 401 серия это уже совсем жир.
Хотя, конечно МК это не ПС - тут железо не меняется, можно и напрямую регистры дергать, если код не мигрировать с камня на камень.
Если в ХАЛе чего-то не хватает то это как правило не сложно дописать.
Хотя, вздрочь с колбэками по приему данных мне совсем не нравится.
Ну для совсем мелких камушков типа F030 я только регистрами балуюсь, без всяких там ХАЛов.
А куб маст хев в плане того что там очень удобно смотреть расположение ног, искать что на какой ноге висит, смотреть как настраивать частоты и вообще визуальная среда куда понятней даташита для новичка.Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 16:08По мне так Cube очень удобный инструмент. Да, ошибки есть - попадал правда только один раз. Но от ошибок никогда не застрахован, кроме того ST регулярно выпускает обновления HAL. И если не "патчить" библиотеки, то после обновления не нарвешься на "еще один косяк от калокуба". Зато с переносимостью кода вообще замечательно, использую 030, 103, 411, 407 микроконтроллеры. Я не считаю программированием настройку "ножек" у микроконтроллера, а раньше (я еще новичок) у меня львиную долю времени занимало именно это. Теперь я использую Cube и не заморачиваюсь с инициализацией. Я не говорю, что RM читать не надо, но я не хочу чтобы он был моей настольной книгой - за высвободившееся время я лучше прочту datasheet на нужную мне периферию.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 16:28
Цитата:
какая-никакая защита от misuseна сях? защита? продолжай.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 16:52"Какая-никакая". Хотя бы ассерты - чтобы дебаг-версия падала так, чтобы сразу указать на ошибку.
(misuse, который я словил - вызывал CDC_Transmit_FS до того, как прошло соединение - а инициализация обработчиков проходила на соединении. Крэш. Причём взято такое использование было из примеров. Оно работало - пока я не подключил к плате только st-link, не втыкая USB. Правильный ассерт и пара строк комментария сэкономили бы мне силы и время)Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 18:31
magistre96a писал(а):Я сравнительно недавно начал заниматься микроэлектроникой в основном с stm32, и довольно часто пользуюсь этим форумом.
И постоянно вижу разные комменты, не лестные, в адрес HAL, STM32Cube, SPL и так далее. С чем связанны вся эта ненависть к этим сущностям.Хотите поржать, у меня есть готовый пример.
Эта портянка - микс всего необходимого для инсталла fmc, в частности lcd на шине sram. Собранно всё в одну кучу в проекте без хала, с целью посмотреть чего оно всё-таки делает такого необычного.
Слабонервным не открывать, особенно тем кто только-что слез с пиков.#define FMC_NORSRAM_EXTENDED_TypeDef FMC_Bank1E_TypeDef
#define FMC_NAND_TypeDef FMC_Bank3_TypeDef
#define FMC_SDRAM_TypeDef FMC_Bank5_6_TypeDef#define FMC_NORSRAM_DEVICE FMC_Bank1
#define FMC_NORSRAM_EXTENDED_DEVICE FMC_Bank1E
#define FMC_NAND_DEVICE FMC_Bank3
#define FMC_SDRAM_DEVICE FMC_Bank5_6#define FMC_NORSRAM_TypeDef FMC_Bank1_TypeDef
#define FMC_NORSRAM_EXTENDED_TypeDef FMC_Bank1E_TypeDef
#define FMC_NORSRAM_DEVICE FMC_Bank1
#define FMC_NORSRAM_EXTENDED_DEVICE FMC_Bank1E#define FMC_DATA_ADDRESS_MUX_ENABLE ((uint32_t)0x00000002U)
#define FMC_NORSRAM_BANK2 ((uint32_t)0x00000002U)
#define FMC_NORSRAM_BANK3 ((uint32_t)0x00000004U)
#define FMC_NORSRAM_BANK4 ((uint32_t)0x00000006U)#define FMC_NORSRAM_BANK1 ((uint32_t)0x00000000U)
#define FMC_DATA_ADDRESS_MUX_DISABLE ((uint32_t)0x00000000U)
#define FMC_MEMORY_TYPE_SRAM ((uint32_t)0x00000000U)
#define FMC_NORSRAM_MEM_BUS_WIDTH_8 ((uint32_t)0x00000000U)
#define FMC_NORSRAM_MEM_BUS_WIDTH_16 ((uint32_t)0x00000010U)
#define FMC_NORSRAM_MEM_BUS_WIDTH_32 ((uint32_t)0x00000020U)
#define FMC_NORSRAM_FLASH_ACCESS_ENABLE ((uint32_t)0x00000040U)
#define FMC_NORSRAM_FLASH_ACCESS_DISABLE ((uint32_t)0x00000000U)
#define FMC_BURST_ACCESS_MODE_DISABLE ((uint32_t)0x00000000U)
#define FMC_BURST_ACCESS_MODE_ENABLE ((uint32_t)0x00000100U)
#define FMC_WAIT_SIGNAL_POLARITY_LOW ((uint32_t)0x00000000U)
#define FMC_WAIT_SIGNAL_POLARITY_HIGH ((uint32_t)0x00000200U)
#define FMC_WAIT_TIMING_BEFORE_WS ((uint32_t)0x00000000U)
#define FMC_WAIT_TIMING_DURING_WS ((uint32_t)0x00000800U)
#define FMC_WRITE_OPERATION_DISABLE ((uint32_t)0x00000000U)
#define FMC_WRITE_OPERATION_ENABLE ((uint32_t)0x00001000U)
#define FMC_WAIT_SIGNAL_DISABLE ((uint32_t)0x00000000U)
#define FMC_WAIT_SIGNAL_ENABLE ((uint32_t)0x00002000U)
#define FMC_EXTENDED_MODE_DISABLE ((uint32_t)0x00000000U)
#define FMC_EXTENDED_MODE_ENABLE ((uint32_t)0x00004000U)
#define FMC_ASYNCHRONOUS_WAIT_DISABLE ((uint32_t)0x00000000U)
#define FMC_ASYNCHRONOUS_WAIT_ENABLE ((uint32_t)0x00008000U)
#define FMC_PAGE_SIZE_NONE ((uint32_t)0x00000000U)
#define FMC_PAGE_SIZE_128 ((uint32_t)FMC_BCR1_CPSIZE_0)
#define FMC_PAGE_SIZE_256 ((uint32_t)FMC_BCR1_CPSIZE_1)
#define FMC_PAGE_SIZE_512 ((uint32_t)(FMC_BCR1_CPSIZE_0 | FMC_BCR1_CPSIZE_1))
#define FMC_PAGE_SIZE_1024 ((uint32_t)FMC_BCR1_CPSIZE_2)
#define FMC_WRITE_BURST_DISABLE ((uint32_t)0x00000000U)
#define FMC_WRITE_BURST_ENABLE ((uint32_t)0x00080000U)
#define FMC_CONTINUOUS_CLOCK_SYNC_ONLY ((uint32_t)0x00000000U)
#define FMC_CONTINUOUS_CLOCK_SYNC_ASYNC ((uint32_t)0x00100000U)
#define FMC_WRITE_FIFO_DISABLE ((uint32_t)FMC_BCR1_WFDIS)
#define FMC_WRITE_FIFO_ENABLE ((uint32_t)0x00000000U)
#define FMC_ACCESS_MODE_A ((uint32_t)0x00000000U)
#define FMC_ACCESS_MODE_B ((uint32_t)0x10000000U)
#define FMC_ACCESS_MODE_C ((uint32_t)0x20000000U)
#define FMC_ACCESS_MODE_D ((uint32_t)0x30000000)
#define FMC_MEMORY_TYPE_SRAM ((uint32_t)0x00000000U)
#define FMC_MEMORY_TYPE_PSRAM ((uint32_t)0x00000004U)
#define FMC_MEMORY_TYPE_NOR ((uint32_t)0x00000008U)
#define IS_FMC_NORSRAM_DEVICE(__INSTANCE__) ((__INSTANCE__) == FMC_NORSRAM_DEVICE)
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t *)__FILE__, __LINE__))
#define __FMC_NORSRAM_ENABLE(__INSTANCE__, __BANK__) ((__INSTANCE__)->BTCR[(__BANK__)] |= FMC_BCR1_MBKEN)#define IS_FMC_NORSRAM_BANK(BANK) (((BANK) == FMC_NORSRAM_BANK1) || \
((BANK) == FMC_NORSRAM_BANK2) || \
((BANK) == FMC_NORSRAM_BANK3) || \
((BANK) == FMC_NORSRAM_BANK4))#define IS_FMC_MUX(__MUX__) (((__MUX__) == FMC_DATA_ADDRESS_MUX_DISABLE) || \
((__MUX__) == FMC_DATA_ADDRESS_MUX_ENABLE))#define IS_FMC_MEMORY(__MEMORY__) (((__MEMORY__) == FMC_MEMORY_TYPE_SRAM) || \
((__MEMORY__) == FMC_MEMORY_TYPE_PSRAM)|| \
((__MEMORY__) == FMC_MEMORY_TYPE_NOR))#define IS_FMC_NORSRAM_MEMORY_WIDTH(__WIDTH__) (((__WIDTH__) == FMC_NORSRAM_MEM_BUS_WIDTH_8) || \
((__WIDTH__) == FMC_NORSRAM_MEM_BUS_WIDTH_16) || \
((__WIDTH__) == FMC_NORSRAM_MEM_BUS_WIDTH_32))#define IS_FMC_ACCESS_MODE(__MODE__) (((__MODE__) == FMC_ACCESS_MODE_A) || \
((__MODE__) == FMC_ACCESS_MODE_B) || \
((__MODE__) == FMC_ACCESS_MODE_C) || \
((__MODE__) == FMC_ACCESS_MODE_D))#define IS_FMC_NAND_BANK(BANK) ((BANK) == FMC_NAND_BANK3)
#define IS_FMC_WAIT_FEATURE(FEATURE) (((FEATURE) == FMC_NAND_WAIT_FEATURE_DISABLE) || \
((FEATURE) == FMC_NAND_WAIT_FEATURE_ENABLE))#define IS_FMC_NAND_MEMORY_WIDTH(WIDTH) (((WIDTH) == FMC_NAND_MEM_BUS_WIDTH_8) || \
((WIDTH) == FMC_NAND_MEM_BUS_WIDTH_16))#define IS_FMC_ECC_STATE(STATE) (((STATE) == FMC_NAND_ECC_DISABLE) || \
((STATE) == FMC_NAND_ECC_ENABLE))#define IS_FMC_ECCPAGE_SIZE(SIZE) (((SIZE) == FMC_NAND_ECC_PAGE_SIZE_256BYTE) || \
((SIZE) == FMC_NAND_ECC_PAGE_SIZE_512BYTE) || \
((SIZE) == FMC_NAND_ECC_PAGE_SIZE_1024BYTE) || \
((SIZE) == FMC_NAND_ECC_PAGE_SIZE_2048BYTE) || \
((SIZE) == FMC_NAND_ECC_PAGE_SIZE_4096BYTE) || \
((SIZE) == FMC_NAND_ECC_PAGE_SIZE_8192BYTE))#define IS_FMC_SDMEMORY_WIDTH(WIDTH) (((WIDTH) == FMC_SDRAM_MEM_BUS_WIDTH_8) || \
((WIDTH) == FMC_SDRAM_MEM_BUS_WIDTH_16) || \
((WIDTH) == FMC_SDRAM_MEM_BUS_WIDTH_32))#define IS_FMC_WRITE_PROTECTION(__WRITE__) (((__WRITE__) == FMC_SDRAM_WRITE_PROTECTION_DISABLE) || \
((__WRITE__) == FMC_SDRAM_WRITE_PROTECTION_ENABLE))#define IS_FMC_SDCLOCK_PERIOD(__PERIOD__) (((__PERIOD__) == FMC_SDRAM_CLOCK_DISABLE) || \
((__PERIOD__) == FMC_SDRAM_CLOCK_PERIOD_2) || \
((__PERIOD__) == FMC_SDRAM_CLOCK_PERIOD_3))#define IS_FMC_READ_BURST(__RBURST__) (((__RBURST__) == FMC_SDRAM_RBURST_DISABLE) || \
((__RBURST__) == FMC_SDRAM_RBURST_ENABLE))#define IS_FMC_READPIPE_DELAY(__DELAY__) (((__DELAY__) == FMC_SDRAM_RPIPE_DELAY_0) || \
((__DELAY__) == FMC_SDRAM_RPIPE_DELAY_1) || \
((__DELAY__) == FMC_SDRAM_RPIPE_DELAY_2))#define IS_FMC_COMMAND_MODE(__COMMAND__) (((__COMMAND__) == FMC_SDRAM_CMD_NORMAL_MODE) || \
((__COMMAND__) == FMC_SDRAM_CMD_CLK_ENABLE) || \
((__COMMAND__) == FMC_SDRAM_CMD_PALL) || \
((__COMMAND__) == FMC_SDRAM_CMD_AUTOREFRESH_MODE) || \
((__COMMAND__) == FMC_SDRAM_CMD_LOAD_MODE) || \
((__COMMAND__) == FMC_SDRAM_CMD_SELFREFRESH_MODE) || \
((__COMMAND__) == FMC_SDRAM_CMD_POWERDOWN_MODE))#define IS_FMC_COMMAND_TARGET(__TARGET__) (((__TARGET__) == FMC_SDRAM_CMD_TARGET_BANK1) || \
((__TARGET__) == FMC_SDRAM_CMD_TARGET_BANK2) || \
((__TARGET__) == FMC_SDRAM_CMD_TARGET_BANK1_2))/** @defgroup FMC_TCLR_Setup_Time FMC TCLR Setup Time
* @ */
#define IS_FMC_TCLR_TIME(__TIME__) ((__TIME__) /**
* @>
*//** @defgroup FMC_TAR_Setup_Time FMC TAR Setup Time
* @ */
#define IS_FMC_TAR_TIME(TIME) ((TIME) /**
* @>
*//** @defgroup FMC_Setup_Time FMC Setup Time
* @ */
#define IS_FMC_SETUP_TIME(TIME) ((TIME) /**
* @>
*//** @defgroup FMC_Wait_Setup_Time FMC Wait Setup Time
* @ */
#define IS_FMC_WAIT_TIME(TIME) ((TIME) /**
* @>
*//** @defgroup FMC_Hold_Setup_Time FMC Hold Setup Time
* @ */
#define IS_FMC_HOLD_TIME(TIME) ((TIME) /**
* @>
*//** @defgroup FMC_HiZ_Setup_Time FMC HiZ Setup Time
* @ */
#define IS_FMC_HIZ_TIME(TIME) ((TIME) /**
* @>
*/#define IS_FMC_BURSTMODE(__STATE__) (((__STATE__) == FMC_BURST_ACCESS_MODE_DISABLE) || \
((__STATE__) == FMC_BURST_ACCESS_MODE_ENABLE))#define IS_FMC_WAIT_POLARITY(__POLARITY__) (((__POLARITY__) == FMC_WAIT_SIGNAL_POLARITY_LOW) || \
((__POLARITY__) == FMC_WAIT_SIGNAL_POLARITY_HIGH))#define IS_FMC_WAIT_SIGNAL_ACTIVE(__ACTIVE__) (((__ACTIVE__) == FMC_WAIT_TIMING_BEFORE_WS) || \
((__ACTIVE__) == FMC_WAIT_TIMING_DURING_WS))#define IS_FMC_WRITE_OPERATION(__OPERATION__) (((__OPERATION__) == FMC_WRITE_OPERATION_DISABLE) || \
((__OPERATION__) == FMC_WRITE_OPERATION_ENABLE))#define IS_FMC_WAITE_SIGNAL(__SIGNAL__) (((__SIGNAL__) == FMC_WAIT_SIGNAL_DISABLE) || \
((__SIGNAL__) == FMC_WAIT_SIGNAL_ENABLE))#define IS_FMC_EXTENDED_MODE(__MODE__) (((__MODE__) == FMC_EXTENDED_MODE_DISABLE) || \
((__MODE__) == FMC_EXTENDED_MODE_ENABLE))#define IS_FMC_ASYNWAIT(__STATE__) (((__STATE__) == FMC_ASYNCHRONOUS_WAIT_DISABLE) || \
((__STATE__) == FMC_ASYNCHRONOUS_WAIT_ENABLE))/** @defgroup FMC_Data_Latency FMC Data Latency
* @ */
#define IS_FMC_DATA_LATENCY(__LATENCY__) (((__LATENCY__) > 1) && ((__LATENCY__) /**
* @>
*/#define IS_FMC_WRITE_BURST(__BURST__) (((__BURST__) == FMC_WRITE_BURST_DISABLE) || \
((__BURST__) == FMC_WRITE_BURST_ENABLE))#define IS_FMC_CONTINOUS_CLOCK(CCLOCK) (((CCLOCK) == FMC_CONTINUOUS_CLOCK_SYNC_ONLY) || \
((CCLOCK) == FMC_CONTINUOUS_CLOCK_SYNC_ASYNC))/** @defgroup FMC_Address_Setup_Time FMC Address Setup Time
* @ */
#define IS_FMC_ADDRESS_SETUP_TIME(__TIME__) ((__TIME__) /**
* @>
*//** @defgroup FMC_Address_Hold_Time FMC Address Hold Time
* @ */
#define IS_FMC_ADDRESS_HOLD_TIME(__TIME__) (((__TIME__) > 0) && ((__TIME__) /**
* @>
*//** @defgroup FMC_Data_Setup_Time FMC Data Setup Time
* @ */
#define IS_FMC_DATASETUP_TIME(__TIME__) (((__TIME__) > 0) && ((__TIME__) /**
* @>
*//** @defgroup FMC_Bus_Turn_around_Duration FMC Bus Turn around Duration
* @ */
#define IS_FMC_TURNAROUND_TIME(__TIME__) ((__TIME__) /**
* @>
*//** @defgroup FMC_CLK_Division FMC CLK Division
* @ */
#define IS_FMC_CLK_DIV(DIV) (((DIV) > 1) && ((DIV) /**
* @>
*//** @defgroup FMC_SDRAM_LoadToActive_Delay FMC SDRAM LoadToActive Delay
* @ */
#define IS_FMC_LOADTOACTIVE_DELAY(__DELAY__) (((__DELAY__) > 0) && ((__DELAY__) /**
* @>
*//** @defgroup FMC_SDRAM_ExitSelfRefresh_Delay FMC SDRAM ExitSelfRefresh Delay
* @ */
#define IS_FMC_EXITSELFREFRESH_DELAY(__DELAY__) (((__DELAY__) > 0) && ((__DELAY__) /**
* @>
*//** @defgroup FMC_SDRAM_SelfRefresh_Time FMC SDRAM SelfRefresh Time
* @ */
#define IS_FMC_SELFREFRESH_TIME(__TIME__) (((__TIME__) > 0) && ((__TIME__) /**
* @>
*//** @defgroup FMC_SDRAM_RowCycle_Delay FMC SDRAM RowCycle Delay
* @ */
#define IS_FMC_ROWCYCLE_DELAY(__DELAY__) (((__DELAY__) > 0) && ((__DELAY__) /**
* @>
*//** @defgroup FMC_SDRAM_Write_Recovery_Time FMC SDRAM Write Recovery Time
* @ */
#define IS_FMC_WRITE_RECOVERY_TIME(__TIME__) (((__TIME__) > 0) && ((__TIME__) /**
* @>
*//** @defgroup FMC_SDRAM_RP_Delay FMC SDRAM RP Delay
* @ */
#define IS_FMC_RP_DELAY(__DELAY__) (((__DELAY__) > 0) && ((__DELAY__) /**
* @>
*//** @defgroup FMC_SDRAM_RCD_Delay FMC SDRAM RCD Delay
* @ */
#define IS_FMC_RCD_DELAY(__DELAY__) (((__DELAY__) > 0) && ((__DELAY__) /**
* @>
*//** @defgroup FMC_SDRAM_AutoRefresh_Number FMC SDRAM AutoRefresh Number
* @ */
#define IS_FMC_AUTOREFRESH_NUMBER(__NUMBER__) (((__NUMBER__) > 0) && ((__NUMBER__) /**
* @>
*//** @defgroup FMC_SDRAM_ModeRegister_Definition FMC SDRAM ModeRegister Definition
* @ */
#define IS_FMC_MODE_REGISTER(__CONTENT__) ((__CONTENT__) /**
* @>
*//** @defgroup FMC_SDRAM_Refresh_rate FMC SDRAM Refresh rate
* @ */
#define IS_FMC_REFRESH_RATE(__RATE__) ((__RATE__) /**
* @>
*//** @defgroup FMC_NORSRAM_Device_Instance FMC NORSRAM Device Instance
* @ */
#define IS_FMC_NORSRAM_DEVICE(__INSTANCE__) ((__INSTANCE__) == FMC_NORSRAM_DEVICE)
/**
* @>
*//** @defgroup FMC_NORSRAM_EXTENDED_Device_Instance FMC NORSRAM EXTENDED Device Instance
* @ */
#define IS_FMC_NORSRAM_EXTENDED_DEVICE(__INSTANCE__) ((__INSTANCE__) == FMC_NORSRAM_EXTENDED_DEVICE)
/**
* @>
*//** @defgroup FMC_NAND_Device_Instance FMC NAND Device Instance
* @ */
#define IS_FMC_NAND_DEVICE(__INSTANCE__) ((__INSTANCE__) == FMC_NAND_DEVICE)
/**
* @>
*//** @defgroup FMC_SDRAM_Device_Instance FMC SDRAM Device Instance
* @ */
#define IS_FMC_SDRAM_DEVICE(__INSTANCE__) ((__INSTANCE__) == FMC_SDRAM_DEVICE)
/**
* @>
*/#define IS_FMC_SDRAM_BANK(BANK) (((BANK) == FMC_SDRAM_BANK1) || \
((BANK) == FMC_SDRAM_BANK2))#define IS_FMC_COLUMNBITS_NUMBER(COLUMN) (((COLUMN) == FMC_SDRAM_COLUMN_BITS_NUM_8) || \
((COLUMN) == FMC_SDRAM_COLUMN_BITS_NUM_9) || \
((COLUMN) == FMC_SDRAM_COLUMN_BITS_NUM_10) || \
((COLUMN) == FMC_SDRAM_COLUMN_BITS_NUM_11))#define IS_FMC_ROWBITS_NUMBER(ROW) (((ROW) == FMC_SDRAM_ROW_BITS_NUM_11) || \
((ROW) == FMC_SDRAM_ROW_BITS_NUM_12) || \
((ROW) == FMC_SDRAM_ROW_BITS_NUM_13))#define IS_FMC_INTERNALBANK_NUMBER(NUMBER) (((NUMBER) == FMC_SDRAM_INTERN_BANKS_NUM_2) || \
((NUMBER) == FMC_SDRAM_INTERN_BANKS_NUM_4))#define IS_FMC_CAS_LATENCY(LATENCY) (((LATENCY) == FMC_SDRAM_CAS_LATENCY_1) || \
((LATENCY) == FMC_SDRAM_CAS_LATENCY_2) || \
((LATENCY) == FMC_SDRAM_CAS_LATENCY_3))#define IS_FMC_PAGESIZE(__SIZE__) (((__SIZE__) == FMC_PAGE_SIZE_NONE) || \
((__SIZE__) == FMC_PAGE_SIZE_128) || \
((__SIZE__) == FMC_PAGE_SIZE_256) || \
((__SIZE__) == FMC_PAGE_SIZE_512) || \
((__SIZE__) == FMC_PAGE_SIZE_1024))#define IS_FMC_WRITE_FIFO(__FIFO__) (((__FIFO__) == FMC_WRITE_FIFO_DISABLE) || \
((__FIFO__) == FMC_WRITE_FIFO_ENABLE))
/**
* @>
*/void assert_failed(uint8_t* file, uint32_t line)
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */typedef struct
uint32_t NSBank; /*! < Specifies the NORSRAM memory device that will be used.
This parameter can be a value of @ref FMC_NORSRAM_Bank */uint32_t DataAddressMux; /*! < Specifies whether the address and data values are
multiplexed on the data bus or not.
This parameter can be a value of @ref FMC_Data_Address_Bus_Multiplexing */uint32_t MemoryType; /*! < Specifies the type of external memory attached to
the corresponding memory device.
This parameter can be a value of @ref FMC_Memory_Type */uint32_t MemoryDataWidth; /*! < Specifies the external memory device width.
This parameter can be a value of @ref FMC_NORSRAM_Data_Width */uint32_t BurstAccessMode; /*! < Enables or disables the burst access mode for Flash memory,
valid only with synchronous burst Flash memories.
This parameter can be a value of @ref FMC_Burst_Access_Mode */uint32_t WaitSignalPolarity; /*! < Specifies the wait signal polarity, valid only when accessing
the Flash memory in burst mode.
This parameter can be a value of @ref FMC_Wait_Signal_Polarity */uint32_t WaitSignalActive; /*! < Specifies if the wait signal is asserted by the memory one
clock cycle before the wait state or during the wait state,
valid only when accessing memories in burst mode.
This parameter can be a value of @ref FMC_Wait_Timing */uint32_t WriteOperation; /*! < Enables or disables the write operation in the selected device by the FMC.
This parameter can be a value of @ref FMC_Write_Operation */uint32_t WaitSignal; /*! < Enables or disables the wait state insertion via wait
signal, valid for Flash memory access in burst mode.
This parameter can be a value of @ref FMC_Wait_Signal */uint32_t ExtendedMode; /*! < Enables or disables the extended mode.
This parameter can be a value of @ref FMC_Extended_Mode */uint32_t AsynchronousWait; /*! < Enables or disables wait signal during asynchronous transfers,
valid only with asynchronous Flash memories.
This parameter can be a value of @ref FMC_AsynchronousWait */uint32_t WriteBurst; /*! < Enables or disables the write burst operation.
This parameter can be a value of @ref FMC_Write_Burst */uint32_t ContinuousClock; /*! < Enables or disables the FMC clock output to external memory devices.
This parameter is only enabled through the FMC_BCR1 register, and don't care
through FMC_BCR2..4 registers.
This parameter can be a value of @ref FMC_Continous_Clock */uint32_t WriteFifo; /*! < Enables or disables the write FIFO used by the FMC controller.
This parameter is only enabled through the FMC_BCR1 register, and don't care
through FMC_BCR2..4 registers.
This parameter can be a value of @ref FMC_Write_FIFO */uint32_t PageSize; /*! < Specifies the memory page size.
This parameter can be a value of @ref FMC_Page_Size */typedef struct
uint32_t AddressSetupTime; /*! < Defines the number of HCLK cycles to configure
the duration of the address setup time.
This parameter can be a value between Min_Data = 0 and Max_Data = 15.
@note This parameter is not used with synchronous NOR Flash memories. */uint32_t AddressHoldTime; /*! < Defines the number of HCLK cycles to configure
the duration of the address hold time.
This parameter can be a value between Min_Data = 1 and Max_Data = 15.
@note This parameter is not used with synchronous NOR Flash memories. */uint32_t DataSetupTime; /*! < Defines the number of HCLK cycles to configure
the duration of the data setup time.
This parameter can be a value between Min_Data = 1 and Max_Data = 255.
@note This parameter is used for SRAMs, ROMs and asynchronous multiplexed
NOR Flash memories. */uint32_t BusTurnAroundDuration; /*! < Defines the number of HCLK cycles to configure
the duration of the bus turnaround.
This parameter can be a value between Min_Data = 0 and Max_Data = 15.
@note This parameter is only used for multiplexed NOR Flash memories. */uint32_t CLKDivision; /*! < Defines the period of CLK clock output signal, expressed in number of
HCLK cycles. This parameter can be a value between Min_Data = 2 and Max_Data = 16.
@note This parameter is not used for asynchronous NOR Flash, SRAM or ROM
accesses. */uint32_t DataLatency; /*! < Defines the number of memory clock cycles to issue
to the memory before getting the first data.
The parameter value depends on the memory type as shown below:
- It must be set to 0 in case of a CRAM
- It is don't care in asynchronous NOR, SRAM or ROM accesses
- It may assume a value between Min_Data = 2 and Max_Data = 17 in NOR Flash memories
with synchronous burst mode enable */uint32_t AccessMode; /*! < Specifies the asynchronous access mode.
This parameter can be a value of @ref FMC_Access_Mode */
>FMC_NORSRAM_TimingTypeDef;typedef enum
HAL_UNLOCKED = 0x00,
HAL_LOCKED = 0x01
> HAL_LockTypeDef;typedef struct
FMC_NORSRAM_TypeDef *Instance; /*!< Register base address */void FMC_NORSRAM_Init(FMC_NORSRAM_TypeDef *Device, FMC_NORSRAM_InitTypeDef* Init)
uint32_t tmpr = 0;/* Check the parameters */
assert_param(IS_FMC_NORSRAM_DEVICE(Device));
assert_param(IS_FMC_NORSRAM_BANK(Init->NSBank));
assert_param(IS_FMC_MUX(Init->DataAddressMux));
assert_param(IS_FMC_MEMORY(Init->MemoryType));
assert_param(IS_FMC_NORSRAM_MEMORY_WIDTH(Init->MemoryDataWidth));
assert_param(IS_FMC_BURSTMODE(Init->BurstAccessMode));
assert_param(IS_FMC_WAIT_POLARITY(Init->WaitSignalPolarity));
assert_param(IS_FMC_WAIT_SIGNAL_ACTIVE(Init->WaitSignalActive));
assert_param(IS_FMC_WRITE_OPERATION(Init->WriteOperation));
assert_param(IS_FMC_WAITE_SIGNAL(Init->WaitSignal));
assert_param(IS_FMC_EXTENDED_MODE(Init->ExtendedMode));
assert_param(IS_FMC_ASYNWAIT(Init->AsynchronousWait));
assert_param(IS_FMC_WRITE_BURST(Init->WriteBurst));
assert_param(IS_FMC_CONTINOUS_CLOCK(Init->ContinuousClock));
assert_param(IS_FMC_WRITE_FIFO(Init->WriteFifo));
assert_param(IS_FMC_PAGESIZE(Init->PageSize));/* Get the BTCR register value */
tmpr = Device->BTCR[Init->NSBank];/* Set NORSRAM device control parameters */
tmpr |= (uint32_t)(Init->DataAddressMux |\
Init->MemoryType |\
Init->MemoryDataWidth |\
Init->BurstAccessMode |\
Init->WaitSignalPolarity |\
Init->WaitSignalActive |\
Init->WriteOperation |\
Init->WaitSignal |\
Init->ExtendedMode |\
Init->AsynchronousWait |\
Init->WriteBurst |\
Init->ContinuousClock |\
Init->PageSize |\
Init->WriteFifo);if(Init->MemoryType == FMC_MEMORY_TYPE_NOR)
tmpr |= (uint32_t)FMC_NORSRAM_FLASH_ACCESS_ENABLE;
>/* Configure synchronous mode when Continuous clock is enabled for bank2..4 */
if((Init->ContinuousClock == FMC_CONTINUOUS_CLOCK_SYNC_ASYNC) && (Init->NSBank != FMC_NORSRAM_BANK1))
Device->BTCR[FMC_NORSRAM_BANK1] |= (uint32_t)(Init->ContinuousClock);
>
if(Init->NSBank != FMC_NORSRAM_BANK1)
Device->BTCR[FMC_NORSRAM_BANK1] |= (uint32_t)(Init->WriteFifo);
>void FMC_NORSRAM_Timing_Init(FMC_NORSRAM_TypeDef *Device, FMC_NORSRAM_TimingTypeDef *Timing, uint32_t Bank)
uint32_t tmpr = 0;/* Check the parameters */
assert_param(IS_FMC_NORSRAM_DEVICE(Device));
assert_param(IS_FMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime));
assert_param(IS_FMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime));
assert_param(IS_FMC_DATASETUP_TIME(Timing->DataSetupTime));
assert_param(IS_FMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration));
assert_param(IS_FMC_CLK_DIV(Timing->CLKDivision));
assert_param(IS_FMC_DATA_LATENCY(Timing->DataLatency));
assert_param(IS_FMC_ACCESS_MODE(Timing->AccessMode));
assert_param(IS_FMC_NORSRAM_BANK(Bank));/* Get the BTCR register value */
tmpr = Device->BTCR[Bank + 1];/* Set FMC_NORSRAM device timing parameters */
tmpr |= (uint32_t)(Timing->AddressSetupTime |\
((Timing->AddressHoldTime) ((Timing->DataSetupTime) ((Timing->BusTurnAroundDuration) (((Timing->CLKDivision)-1) (((Timing->DataLatency)-2) (Timing->AccessMode)
);Device->BTCR[Bank + 1] = tmpr;
/* Configure Clock division value (in NORSRAM bank 1) when continuous clock is enabled */
void FMC_NORSRAM_Extended_Timing_Init(FMC_NORSRAM_EXTENDED_TypeDef *Device, FMC_NORSRAM_TimingTypeDef *Timing, uint32_t Bank, uint32_t ExtendedMode)
uint32_t tmpr = 0;/* Check the parameters */
assert_param(IS_FMC_EXTENDED_MODE(ExtendedMode));/* Set NORSRAM device timing register for write configuration, if extended mode is used */
if(ExtendedMode == FMC_EXTENDED_MODE_ENABLE)
/* Check the parameters */
assert_param(IS_FMC_NORSRAM_EXTENDED_DEVICE(Device));
assert_param(IS_FMC_ADDRESS_SETUP_TIME(Timing->AddressSetupTime));
assert_param(IS_FMC_ADDRESS_HOLD_TIME(Timing->AddressHoldTime));
assert_param(IS_FMC_DATASETUP_TIME(Timing->DataSetupTime));
assert_param(IS_FMC_TURNAROUND_TIME(Timing->BusTurnAroundDuration));
assert_param(IS_FMC_CLK_DIV(Timing->CLKDivision));
assert_param(IS_FMC_DATA_LATENCY(Timing->DataLatency));
assert_param(IS_FMC_ACCESS_MODE(Timing->AccessMode));
assert_param(IS_FMC_NORSRAM_BANK(Bank));/* Get the BWTR register value */
tmpr = Device->BWTR[Bank];tmpr |= (uint32_t)(Timing->AddressSetupTime |\
((Timing->AddressHoldTime) ((Timing->DataSetupTime) ((Timing->BusTurnAroundDuration) (Timing->AccessMode));Device->BWTR[Bank] = tmpr;
>
else
Device->BWTR[Bank] = 0x0FFFFFFF;
>SRAM_HandleTypeDef hsram1;
void HAL_SRAM_Init(SRAM_HandleTypeDef *hsram, FMC_NORSRAM_TimingTypeDef *Timing, FMC_NORSRAM_TimingTypeDef *ExtTiming);
void HAL_SRAM_Init(SRAM_HandleTypeDef *hsram, FMC_NORSRAM_TimingTypeDef *Timing, FMC_NORSRAM_TimingTypeDef *ExtTiming)
/* Check the SRAM handle parameter *//* Initialize SRAM control Interface */
FMC_NORSRAM_Init(hsram->Instance, &(hsram->Init));/* Initialize SRAM timing Interface */
FMC_NORSRAM_Timing_Init(hsram->Instance, Timing, hsram->Init.NSBank);/* Initialize SRAM extended mode timing Interface */
FMC_NORSRAM_Extended_Timing_Init(hsram->Extended, ExtTiming, hsram->Init.NSBank, hsram->Init.ExtendedMode);/* Enable the NORSRAM device */
__FMC_NORSRAM_ENABLE(hsram->Instance, hsram->Init.NSBank);/* FMC initialization function */
void MX_FMC_Init(void)FMC_NORSRAM_TimingTypeDef Timing;
FMC_NORSRAM_TimingTypeDef ExtTiming;/** Perform the SRAM1 memory initialization sequence
*/
hsram1.Instance = FMC_NORSRAM_DEVICE;
hsram1.Extended = FMC_NORSRAM_EXTENDED_DEVICE;
/* hsram1.Init */
hsram1.Init.NSBank = FMC_NORSRAM_BANK1;
hsram1.Init.DataAddressMux = FMC_DATA_ADDRESS_MUX_DISABLE;
hsram1.Init.MemoryType = FMC_MEMORY_TYPE_SRAM;
hsram1.Init.MemoryDataWidth = FMC_NORSRAM_MEM_BUS_WIDTH_16;
hsram1.Init.BurstAccessMode = FMC_BURST_ACCESS_MODE_DISABLE;
hsram1.Init.WaitSignalPolarity = FMC_WAIT_SIGNAL_POLARITY_LOW;
hsram1.Init.WaitSignalActive = FMC_WAIT_TIMING_BEFORE_WS;
hsram1.Init.WriteOperation = FMC_WRITE_OPERATION_ENABLE;
hsram1.Init.WaitSignal = FMC_WAIT_SIGNAL_DISABLE;
hsram1.Init.ExtendedMode = FMC_EXTENDED_MODE_ENABLE;
hsram1.Init.AsynchronousWait = FMC_ASYNCHRONOUS_WAIT_DISABLE;
hsram1.Init.WriteBurst = FMC_WRITE_BURST_DISABLE;
hsram1.Init.ContinuousClock = FMC_CONTINUOUS_CLOCK_SYNC_ONLY;
hsram1.Init.WriteFifo = FMC_WRITE_FIFO_ENABLE;
hsram1.Init.PageSize = FMC_PAGE_SIZE_NONE;
/* Timing */
Timing.AddressSetupTime = 1;
Timing.AddressHoldTime = 15;
Timing.DataSetupTime = 30;
Timing.BusTurnAroundDuration = 15;
Timing.CLKDivision = 16;
Timing.DataLatency = 17;
Timing.AccessMode = FMC_ACCESS_MODE_A;
/* ExtTiming */
ExtTiming.AddressSetupTime = 1;
ExtTiming.AddressHoldTime = 15;
ExtTiming.DataSetupTime = 99;
ExtTiming.BusTurnAroundDuration = 15;
ExtTiming.CLKDivision = 16;
ExtTiming.DataLatency = 17;
ExtTiming.AccessMode = FMC_ACCESS_MODE_A;static uint32_t FMC_Initialized = 0;
void HAL_SRAM_MspInit(SRAM_HandleTypeDef* sramHandle) /* USER CODE BEGIN SRAM_MspInit 0 */
/* USER CODE END SRAM_MspInit 0 */
HAL_FMC_MspInit();
/* USER CODE BEGIN SRAM_MspInit 1 *//* USER CODE END SRAM_MspInit 1 */
>void HAL_SRAM_MspDeInit(SRAM_HandleTypeDef* sramHandle) /* USER CODE BEGIN SRAM_MspDeInit 0 */
/* USER CODE END SRAM_MspDeInit 0 */
HAL_FMC_MspDeInit();
/* USER CODE BEGIN SRAM_MspDeInit 1 *//* USER CODE END SRAM_MspDeInit 1 */
>И конечный код на прямом обращении к регистрам.
RCC->AHB3ENR |= (RCC_AHB3ENR_FMCEN);
RCC->AHB3RSTR = RCC_AHB3RSTR_FMCRST;
RCC->AHB3RSTR = 0;FMC_Bank1->BTCR[0] = ( FMC_BCR1_EXTMOD ///время чтения != время записи
| FMC_BCR1_WREN ///разрешение записи
| (1 <<4) ///размер шины данных: 0=8bits,1=16bits,2=32bits
| 1 | FMC_BCR1_MBKEN ); ///Включить банкНадеюсь теперь понятен уровень безграничной ненависти к халу.?
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 18:53
Где этой магии можно научиться))))
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 19:14Экосистема софта от ST это фекальный ад из бездны ужаса.
Начиналось довольно безобидно, из обычного пакета библиотек SPL. Они как раз были наименее глючными и наиболее предсказуемыми. Большой ложкой говна правда была разница в наименованиях функций в библиотеках различных семейств, напрямую портировать код между STM32 и STM32L было невозможно. Ну ладно, разные индусы писали разные либки. Простили. Простили и документацию, сгенеренную Doxygenom.
Запах бреда потихоньку сочился из папки "Екзамплес", потому что эти шакалы клавиатур и гиены отладчиков для примеров под демо-платы писали СВОИ ЛИБКИ, запихивая туда работу с периферией демоплаты. Ценность таких примеров и вменяемость тех кто это придумал были весьма небольшими.
Потом пошло несколько апдейтов SPL, вещь хорошая НО ЛОМАЮЩАЯ ОБРАТНУЮ СОВМЕСТИМОСТЬ.
Где-то в эти же годы недовольный норот начал пилить свою SPL, идейно правильную. А узкоглазый норот, слепивший СооСоХ, начал продвигать свой миддлвэр под названием СоХ.
Так вот, в далёком 2009-10 году идея была более чем офигенна. СооСоХ поддерживал почти все семейства Cortex M* разных производителей, и в весьма продвинутой мере. Эклипс с подключением либок простым кликом, встроенный доквъювер, возможность подкачки либок из сетевого репозитория. СоХ должен был стать тем чем потом так и не стал mbed - универсальной миддлварью, раз и навсегда отделившей низкоуровневые драйвера от рабочего кода, с переносимостью между почти любыми процессорами. То есть можно было написать код для LPC, а потом пересобрать его для TI Stellaris практически без правок. И работало оно ещё тогда гораздо лучше чем теперь mbed.
Но менеджеры-сотонисты, принеся в жертву парочку детей, отобранных у излишне консервативных родителей, решили что нужно рынку.
- БОЛЬШЕ ХАОСА ДЛЯ БОГА ХАОСА! Кричали они, и выли, и в бешенстве грызли отладочные платы, и хохотали, вонзая когти в тощие шеи программистов.SPL был предан анафеме. Тысячи человеко-часов отправились в дев\нулл, и из заговорённого воска, гнилых бараньих кишок и приправы от "Доширака" был вылеплен HAL, и наречён новым божеством.
Новое божество воняло, от него отваливались куски, и убедить людей поклоняться ему было сложно. Посмотрев на герб династии Палеологов, батончик "Твикс" и стоянку велосипедов, - решили. Два лучше чем одно. И в придачу к HAL сделали CubeMX.
У каждого Шварценеггера есть свой Курицын, а у PSoC Creator - CubeMX. Отныне программировать одным пальцем стало легче. Используя только мышку можно было накликать вполне серьёзный проект даже с ОСРВ, а потом этим самым пальцем вынуть себе мозг через нос, пытаясь понять, почему оно не работает как надо.
Но цель была достигнута. Теперь даже самые умные не могли понять как работает процессор, и даже самые смелые не могли донырнуть до самого дна функций, вложенных в функции, задекларированых как дефайны, вызывающих другие функции и возвращающих безтиповый указатель на СПИД.
Создание качественного софта на процессоры ST опять стало практически невозможным, и программисты снова могли страдать, чтобы питать нечестивые души демонов.Параллельно с этим фракция отступников внутри ST вела диверсионную деятельность по созданию mbed. Создав превосходное "Ардуино для даунов", они немного просчитались с количеством людей с лишней хромосомой и интересом к электронике. Уродец вышел еще тупее и ограниченнее чем его старший брат, а переносимость годилась только для демонстрации "как не надо делать".
Наступил 2016 год. Вместо единой логичной экосистемы живёт дикий зоопарк. Вероятность того что скачанный из интернета сниппет скомпилируется стремится к нулю. Изменится ли эта ситуация к лучшему?
Эпилог.
Don't be told what you want, don't be told what you need
There's no future, no future, no future for youЗаголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 19:53
Цитата:
Вероятность того что скачанный из интернета сниппет скомпилируется стремится к нулю.Вот поэтому лучше либо а) выкинуть нафиг все это говно и на чистых регистрах писать, либо б) вместе с каждым сниппетом класть используемую библиотеку (но это жесть как жирно). Третий вариант — пилить свою библиотеку и в сниппетах давать ссылку на ее репу на гитхабе.
Заголовок сообщения: Re: ГРЕХ STM32CubeMX
Добавлено: 28 июн 2016, 20:03Eddy_Em, класть либы рядом с исходниками в программировании для мк - какое-то ужасное типовое решение. Берём, прости господи, CooCox, создаём проект, ставим галочки - опаньки, в папке проекта копии всех задействованных либ (а для кого в C делали #include с угловыми скобками?)
Берём CubeMX - генерит, кладёт в проект либы и сгенерённые файлы. Плюс "для удобства" сгенерённые файлы предполагается редактировать 8-O. Хорошо хоть додумались выделить в них фрагменты, которые при повторной генерации не будут затронуты, но всё равно я в шоке.
(нормальное решение: кодогенерация во время сборки, изменяемые части вынесены в отдельный файл)
Это пиздец-пиздец-пиздец. Всё плохо.




