STM32 новичку в ARM что к чему

Alexey_N

А более низкоуровневый вариант, под asm, хотя бы на уровне математики?

Реклама

Satyr

Alexey_N писал(а):А более низкоуровневый вариант, под asm, хотя бы на уровне математики?

библиотечные функции можешь из асма использовать, никаких проблем
или тупо хочется чужой код самому покомпилировать ?

Реклама

Alexey_N

Satyr писал(а):или тупо хочется чужой код самому покомпилировать ?

Не, чужой код мне не над) Я хочу понять алгоритм, как это делается и реализовать для себя на асме. Как, например, перемножить два float'a, представленных в стандартном виде знак+порядок+мантиса? Как это реализовано в стандартной библиотеке (можно и на с++)?

AVI-crak

Очень просто.
Распаковка - умножение - запаковка в формат.
Распаковка заключается в получении uint32_t числа, без множителей и знака - они обрабатываются отдельно.
При умножении результат получается в двух регистрах цп - команда на асме UMULL для Cortex-M3. Для Cortex-M0 - всё очень печально, прямой команды не существует, и там эта операция получается косвенным методом на длинной портянке.
Полученный результат сдвигается до размера 23 бита, количество сдвигов учитывается при обработке множителей.
И самое простое - знак (последний бит).
http://habrahabr.ru/post/112953/ - хорошее наглядное описание стандарта.

У меня тоже была идея, сделать программный float на асме. Но промежуточные варианты получились кратно хуже того что выдаёт GCC. Там особо страшная конструкция, с чудовищными командами на асме, где используется все доступные возможности ядра Cortex. Освоить и применить конечно можно, но вот улучшить - не уверен.

Реклама

Alexey_N

AVI-crak писал(а):http://habrahabr.ru/post/112953/ - хорошее наглядное описание стандарта.

На эту статью я как раз сейчас и опираюсь

(и еще на сайт floatingpoint точка ру).

AVI-crak писал(а):Распаковка - умножение - запаковка в формат.
Распаковка заключается в получении uint32_t числа, без множителей и знака - они обрабатываются отдельно.

Мне не совсем понятно, как это запакованное число вычисляется, особенно непонятно как используется мантисса. Поясню на примере:
Есть число -46,85, в шестнадцатеричном виде: 0xC23B6666. Получаем:
S=1, порядок E=10000100-127=132-127=5, M=1.01110110110011001100110, далее сдвигаю запятую, затем беру каждый разряд и умножаю на 2 в нужной степени и получаю снова float! (в той статье: 1,01e-3 = 1×2^-3 + 0×2^-4 + 1×2^-5 = 1×0,125 + 0×0,0625 + 1×0,03125 = 0,125 + 0,03125 = 0,15625), которые надо вроде как сложить. Не пойму как такое считать, если есть только команды целочисленного умножения.

Реклама

HHIMERA

Может проще освоить Си... и не мучаться???

Реклама

Alexey_N

HHIMERA писал(а):Может проще освоить Си

си я и так знаю, но мне не нравится код который генерируют из него компиляторы.

HHIMERA писал(а):и не мучаться???

а кто мучается? я изучаю

AVI-crak

Сделай умножение на С, и посмотри результат на асме.
Там весьма запутано, куча ветвлений, но общий смысл таков - при возможности идёт преобразование в целое число, умножение, и обратное преобразование. В случае когда умножение через целое число невозможно - начинается куча переходов и условностей. В виду того что развёрнутый фалаут хранится в стеке - то происходит очень частое обращение к нему, по одному биту.
И хотя есть техническая возможность освободить пространство для операции - фолаут всегда высчитывается через стек. (для GCC) Это кстати весьма странно.

Новых оптимизаций и улучшений для GCC не предвидится. Ручная замена функции в тельце самого gcc возможна, но чертовски жестока запутана. Там реально свихнуться можно от зависимостей.

Есть вариант.
Заюзать умножение фолаут в кеил, скопировать кусок асмы, и использовать в своём проекте в виде законченной функции. Там это дело более оптимизировано.

menzoda

Alexey_N писал(а):Как, например, перемножить два float'a, представленных в стандартном виде знак+порядок+мантиса?

Для того, чтобы умножить двачисла в нормализованной форме необходимо перемножить их мантиссы, сложить порядки, округлить и нормализовать полученное число. Соответственно, чтобы произвести деление нужно разделить мантиссу делимого на мантиссу делителя и вычесть из порядка делимого порядок делителя. Затем точно так же округлить мантиссу результата и привести его к нормализованной форме. При сложении и вычитании сначала выбирается оптимальный порядок, затем мантиссы обоих чисел представляются в соответствии с новым порядком, затем над ними производится сложение/вычитание, мантисса результата округляется и, если нужно, результат приводится к нормализованной форме. Не забудь учесть специальные числа Inf и NaN. Примеров в интернете полно. В чем проблема?

Alexey_N

2 menzoda
Вот это первое, что было нужно узнать, про сам алгоритм, благодарю. Примеров я что-то не нашел в интернете (кроме стандартов и теории), хотя искать умею. Проблема осталась с алгоритмом. В предыдущем посте своем я описал ее, что получается float, тут мне не совсем понятно, как преобразование идет.
2 AVI-crak
Попробую сделать на Си и посмотрю.

menzoda

Так а в чем итоговая цель? Потренироваться или все-таки что-то оптимизировать? Если оптимизировать, то затея скорее всего пустая, если потренироваться, то есть более полезные вещи, на которых можно потренироваться.

Alexey_N

Итоговая цель - сделать функцию float2str в проекте на fasmarm, а также функции +,-,*,/

HHIMERA

Очень хочется??? Сделайте!!! Потому что кроме вас... это никому не интересно... Дон Кихоты вымерли вместе с динозаврами...

Alexey_N

HHIMERA писал(а):Очень хочется??? Сделайте!!! Потому что кроме вас... это никому не интересно...

Вы не внимательно прочитали. Я и не прошу кого-то делать. Сам сделаю. Я спрашивал о другом, о самом алгоритме, о теории, а код под него написать несложно.

Andrew Martin

Я тут в прошлом году кидал в личку товарищу (у которого сайт stm32asm) кучу своих наработок, в том числе и целую библиотеку float32 под Cortex-M0 на столь любимом мной fasmarm. Обещал новый раздел по stm32f0 запилить, но что-то ни ответа, ни привета

Как писали выше, у М0 команда умножения кастрирована, поэтому умножать 32х32 приходится по линейному алгоритму "по частям", который широко применяется в восьмибитках. Не скажу что это такой уж "мрак", но всё же далеко не так красиво, как на М3.
Что действительно громоздко вышло, так это деление (shift-subtract). На М3 будет красота.

Alexey_N

А как вы умножаете мантиссы? Просто как два целых числа?

Andrew Martin

Это делалось год назад, я плохо помню, загляните в код

Сначала привожу к явному виду (с единицей в старшем разряде), потом перемножаю, и затем нормализация (сдвиг вправо с соответствующей "добавкой" к экспоненте).
Если интересны алгоритмы - есть у микрочипа аппноут AN575.
Фактически перемножаются два 24-битных числа (мантиссы в явном виде), получается 48-битный результат. Требуется операция 32х32=64, а на М0 можно только 32*32=32. Вот потому я и говорю что на М3 будет всё гораздо короче.

Alexey_N

Andrew Martin писал(а):Если интересны алгоритмы - есть у микрочипа аппноут AN575.

О! Благодарю Вас, то что надо.

Мяукните!

По плавучке много наработок есть у восьмибитников. Например AVR. Алгоритмы, открытые коды, всего навалом в интернете! Естественно, на ассемблере. На маленьких кортексах должно работать раз в 20 быстрее.

Грендайзер

Здравствуйте. Совсем не являюсь спецом по программированию процессоров, но пытаюсь периодически (когда есть время) вникнуть в это дело поглубже. До недавних пор все программки работали отлично поскольку были достаточно простыми (использовали какой то один вид переферии или переферию которая друг на друга не влияла) но к сожалению этому пришёл конец... Задумал я тут написать программку:

1) Инициализирую переферию/процессор/прерывания (АЦП, ЦАП)
2) Жду когда АЦП конвертирует, ухожу в прерывание
3) В обработчике прерываний считываю данные из АЦП в переменную V выхожу из прерывания опять запустив АЦП
4) Жду когда ЦАП преобразует, ухожу в прерывание и передаю ему переменную V. Ухожу из прерывания в цикл while(1) основной программы.

Всё бы ничего, но вот задумал я, сделать с данными полученными из АЦП и сохранёнными в переменную V некоторые операции. Притом, хочу я эти операции сделать в теле цикла while(1) основной программы. Для этого создаю переменную-флаг F и переписываю код следующим образом.

1) Инициализирую переферию/процессор/прерывания (АЦП, ЦАП)
2) Жду когда АЦП конвертирует, ухожу в прерывание
3) В обработчике прерываний считываю данные из АЦП в переменную V выхожу из прерывания предварительно подняв флаг F и опять запустив АЦП.
4) В цикле while(1) основной программы проверяю значение F. Если флаг поднят, то произвожу обработку значения хранящегося в переменной V и опускаю флаг. И т.д.

Как понимаете программа работает... не совсем корректно

Порывшись в интернетах понял, что так делать нельзя - не должны одну и ту же переменную модифицировать разные потоки. Вообщем тут всё ясно... не ясно лишь как с этим делом бороться. Понятно, что можно в определённый момент запрещать прерывания... но я бы хотел узнать... а какие ещё существуют методы (не обязательно для ядер ф.ARM) а в целом? Ну и для cortex m4 в частности естественно тоже...