Рассматривая примеры программ в Embedded (для ARM) обратил внимание, что нигде не встречается работа с регистрами микроконтроллеров с использованием битовых полей. Интересно, почему так?
Помнится еще студентами ставили эксперимент, сравнивая скорость работы через битовые поля и использование масок со сдвигами. Пришли к выводу что битовые поля как-то побыстрее.

А просто так.

Смотря как что реализовано в компиляторе, ну и естественно заточенность системы команд процессора.
В случае чисто 32bit ARM, полагаю один черт.

скорее дело в удобстве использования: описал один раз как макром SETBIT & CLRBIT - и юзай откуда хочешь.. А битовые поля каждый раз описывать надо.

а насчет скорости утверждение спорное: все сдвиги-то просчитываются препроцессором _до_ компиляции. выходит что из операций остается только логическое и(/или) с _константой_ и сохранение результата в ту же ячейку памяти.
а в случае битовых полей - тут уже надо смотреть что там компилятор нагенерит - но очень сомнительно, что получится быстрее чем с масками и сдвигами

что-то мне не верится что просто-так. хотя бы потому, что битовые поля - удобнее.
некоторое время назад писал софт для ЦОС, взаимодействующий с ПЛИС. и я софт разрабатывал и человек проект для ПЛИС тоже разрабатывал. естественно были всякие регистры с битовыми полями, формат которых менялся в процессе разработки. Если-бы я не использовал структуры с битовыми полями, то намного сложнее было бы адаптировать софт под новые версии проекта ПЛИС.



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

ок. 1:1 =)
ибо биты маски тоже через #define определить можно:


ну а по поводу начального вопроса: думаю тут еще играют роль другие факторы:
описал я например регистр в пространстве ввода-вывода (уже существующий) как: и потом его спокойно юзаю через всякие: как для того же самого декларировать битовые поля - не было времени разбираться. А дальше - просто привычка)

Не забывайте еще про то, что расположение полей в структуре - строго говоря, определяется компилятором (и упаковка то же). Так что если хотите переносимости и детерминированности - маски, если компактности и обозримости - битовые поля. Я использую и то, и другое. Как карта ляжет.

Ну а много-ли Вы в периферии контроллера найдете вообще битовых полей (не одиночных битов а групп )? А насколько удобнее одно другого при работе с одиночным битом? А вот насколько удобнее
и быстрее устанавливать за одно обращение несколько не сгруппированных битов в одном регистре а?

Ну и "нигде не встречается" - да все IAR-овские хидеры так (и только так ) написаны.
Приходится дублировать обычными описаниями битов.

с IAR не работал, не знал поэтому.
Ну а вобще я понял, что каждому инструменту - свое применение.

Естественно, но для периферии ARM контроллеров я явно предпочитаю банальное описание битов.

Ну а структуры с битовыми полями это уже для, например, протокольных вещей

А вот теперь возникла конкретная проблемка. Стал работать с регистрами микроконтроллера lpc2378, описав их через битовые поля. Возникла сложность. Если работаю с регистром как со структурой битовых полей непосредственно - нифига не работает. Если формирую значение регистра в переменной и затем присваиваю - работает.

Похоже, что обращение к регистрам может идти только как к 32-разрядным словам, а компилятору (arm-elf-gcc) дела до этого нет, и обращается он к отдельным байтам. Можно-ли побороть эту проблемку какими-нибудь опциями?

>> Стал работать с регистрами микроконтроллера lpc2378,
>> описав их через битовые поля. Возникла сложность.

вот как раз поэтому в общем случае не хочется описывать периферию битовым полями. Тоже на такое напоролся в GCC - сохранение байта в регистр VIC (щас не помню какой) вызывало Data Abort. Теперь только маски.

Выбор из 2-х стилей: битовые поля или маски - дело вкуса.
Но - при текстах чуть более сложных студенческих работ (где очень рекомендуются бировые поля) - IMHO ! : битовые поля - это большая гадость.
Связано это с тем, что работая с битовыми полями, но не инициализируя всю структур в целом - вы рискуете иметь итоговый "мусор", даже при корректности вашего кода. Попробую показать на примере - прошу прощения, я спешил, и выхватил кусок кода из живого проекта, из-за этого куска мои коллеги имели "много времени неприятности"


- как вы понимаете, в return - полный мусор, определяющийся историей отведения стека, там только 1-но корректное поле и есть: color .

Если то же будет записоно как-то грубо так:

- то мусорных неинициализированных полей возникнуть не может.

Это пример - примитивный, но если нечто подобное - в 1000 строк кода ... хорошее времяпрепровождение вам гарантировано

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

Я уверен, что дело именно в том, как реализована работа с битовыми полями компилятором. При формировании значения поля, операции производятся не со всем 32-х разрядным словом, а с одним из его байт.