FAQ по STM8

[tempora]

Ох, Yurkin2007, ну, зачем так спешить?

...старшие 4 бита регистра AWUTB зарезервированы, и по правилам хорошего тона туда не надо ничего писать....

Именно!!! Однако же, пишут товарисчи из СГС-Томсона:

• AWU-›TBR &= (uint8_t)(~AWU_TBR_AWUTB); // ~AWU_TBR_AWUTB ≡ ~0x0F ≡ 0b11110000 !!!

При этом состояние зарезервированных старших битов не изменяется.

Не изменяется только потому, что их там нет!
Если в следующей ревизии там что-то появится, этот код будет писать в это "что-то" сначала единицы, потом - нули.

То же самое и для регистра AWU_APR ...

Именно - то же самое (с точностью до количества бит):

• AWU-›APR &= (uint8_t)(~AWU_APR_APR); // ~AWU_APR_APR ≡ ~0x3F ≡ 0b11000000 !!!

А вот младшие биты, в которые второй строкой вписываются целевые значения, сначала обнуляются (я именно об этом писал, вообще-то) - большой в этом смысл?

В остальном - всё пишете верно.

[Yurkin2007]

этот код будет писать в это "что-то" сначала единицы, потом - нули.

Оператор &= не является просто оператором присвоения. Сначала с содержимым регистра AWU-›TBR и константой 0b11110000 производится побитовый AND, а затем результат помещается обратно в регистр. Очевидно, что в результате этого старшие 4 бита останутся без изменения, а младшие занулятся.

В следующей строке оператор |= сначала производит побитовое ИЛИ содержимого регистра сo значением Time Base в виде 0b0000xxxx. При этом опять же старшие биты не изменяются, а в младших устанавливаются единички в нужных местах. Результат засылается обратно в регистр.

Если в последующих версиях STM8S будут запользованы старшие биты регистра AWU-›TBR, то этот кусок программы будет корректно записывать Time Base для AWU.

[Easyrider83]

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

[tempora]

Оператор &=

Фу, чёрт, по инерции проскочил и не заметил, что оператор-то И, а не ИЛИ (я ж о других битах говорил исходно) - прошу пардону! Однако, вопрос, касавшийся действующих бит, а не отсуствующих ("нафига, перед записью четырех бит, их очищать?") остается без ответа - зачем сначала в биты пишутся нули, а затем правильное значение?:

void AWU_Init(AWU_Timebase_TypeDef AWU_TimeBase)
{
    /* Set the TimeBase */
    AWU-›TBR &= (uint8_t)(~AWU_TBR_AWUTB);
    AWU-›TBR |= TBR_Array[(uint8_t)AWU_TimeBase];
    /* Set the APR divider */
    AWU-›APR &= (uint8_t)(~AWU_APR_APR);
    AWU-›APR |= APR_Array[(uint8_t)AWU_TimeBase];
}

Мне именно этот компот и не нравился, если только нет какой-то причины, о которой я пока ничего в документации не нашел.
Так вот - есть причина, или это перегибы индусов?

[Yurkin2007]

А ваши битовые преобразования в основном коде вам одному понятны.

Дык, мы как раз и обсуждаем код из Ваших любимых библиотек. Так сказать, содержимое библиотечных .с-файлов ...

[Yurkin2007]

зачем сначала в биты пишутся нули

Это самый простой и очевидный способ записать, например, число 0b00001101 в регистр, содержимое которого в текущий момент равно 10100001. В результате этих двух строк будем иметь 10101101.
А как можно по-другому? Можете привести пример?

[tempora]

я голосую за читаемость.

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

// Spi Control Register bit fields:
#define   SPISCKby4   (0)
#define   SPISCKby16  (1)
#define   SPISCKby64  (2)
#define   SPISCKby128 (3)

#define   SPI_MODE0   (0‹‹_CPHA)
#define   SPI_MODE1   (1‹‹_CPHA)
#define   SPI_MODE2   (2‹‹_CPHA)
#define   SPI_MODE3   (3‹‹_CPHA)
...
    /* Enable SPI, Master, set clock rate fck/16 */
    SPCR = SPI_MASK|(SPI_MODE3)|(SPISCKby16);

Имена функций, в таком случае, тоже можно забыть.

[Yurkin2007]

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

Я понимаю Ваши затруднения.
Ну, хорошо, очистили записываемое значение, получили 0b0000xxxx.
А дальше что? Неужели AWU-›TBR = 0b0000xxxx ?

[tempora]

Можете привести пример?

Разумеется:

void AWU_Init(AWU_Timebase_TypeDef AWU_TimeBase)
{
...
    /* Set the TimeBase */
    AWU-›TBR =
        (
          AWU-›TBR  &  ((uint8_t)(~AWU_TBR_AWUTB))
        )
        | TBR_Array[(uint8_t)AWU_TimeBase];
...
}

Ненужной записи нулей здесь нет. И никаких затруднений.

[Yurkin2007]

Бьюсь об заклад - Вы меня разыгрываете !
Не, правда, очень смешно !