При программировании микроконтроллеров постоянно приходится работать с битами. Устанавливать их, сбрасывать,  проверять их наличие в том или ином регистре. В AVR ассемблере для этих целей существует целый ряд команд. Во-первых, это группа команд операций с битами – они предназначены для установки или сброса битов в различных регистрах микроконтроллера, а во-вторых, группа команд передачи управления – они предназначены для организации ветвлений программ. В языке Си естественно нет подобных команд, поэтому у начинающих программистов часто возникает вопрос, а как в Си работать с битами. Эту тему мы сейчас и будем разбирать.

   В Си существуют 6 операторов для манипулирования битами. Их можно применять к любым целочисленным знаковым или беззнаковым типам переменных.

<<  - сдвиг влево
>>  - сдвиг вправо
~   -  поразрядная инверсия
|    - поразрядное ИЛИ
&  - поразрядное И
^   -  поразрядное исключающее ИЛИ
        
        unsigned char tmp = 3;  //0b00000011    
        tmp = tmp << 1;   
        //теперь в переменной tmp число 6 или 0b00000110
        
        tmp = tmp << 3;
        //теперь в переменной tmp число 48  или 0b00110000

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

        tmp = 7;  //0b00000111    
        tmp <<= 2; //сокращенный вариант записи
        //теперь в переменной tmp число 28 или 0b00011100

Операция сдвига влево на n разрядов эквивалентна умножению переменной на 2ⁿ.

Пример для беззнаковой переменной

        unsigned char tmp = 255;  //0b11111111
        tmp = tmp >> 1;
        //теперь в переменной tmp число 127 или 0b01111111
        
        tmp >>=  3;  //сокращенный вариант записи
        //теперь в переменной tmp число 15 или 0b00001111

Пример для переменной знакового типа
        
        int tmp = 3400; //0b0000110101001000
        tmp >>= 2;
        //теперь в переменной число 850 или 0b0000001101010010

        tmp = -1200; //0b1111101101010000
        tmp >>= 2;
        //теперь в tmp число -300 или 0b1111111011010100
        //видите - два старших разряда заполнились единицами

   Операция сдвига вправо на n разрядов эквивалентна делению на 2ⁿ. При этом есть некоторые нюансы. Если потерянные младшие разряды содержали единицы, то результат подобного “деления” получается грубоватым.

Например    9/4 = 2,5         а 9>>2      (1001>>2)    равно 2
                  11/4 = 2,75     а 11>>2      (1011>>2)    равно 2    
                  28/4 = 7          а 28>>2    (11100>>2)    равно 7     

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

        unsigned char tmp =  94;     //0b01011110
        tmp = ~tmp;
        //теперь в переменной tmp число 161 или 0b10100001
        
        tmp = ~tmp;
        //теперь в tmp снова число 94 или 0b01011110

 

 

 

Оператор | обычно используют для установки заданных битов переменной в единицу.
        
    tmp = 155
    tmp = tmp | 4; //устанавливаем в единицу второй бит переменной tmp

    155     0b10011011    
|
        4     0b00000100    
    159     0b10011111

    tmp = tmp | (1<<4); //устанавливаем в единицу четвертый бит переменной tmp


Установить несколько битов в единицу можно так

    tmp = tmp | (1<<7)|(1<<5)|(1<<0);
   //устанавливаем в единицу седьмой, пятый и нулевой биты переменной tmp
    
С помощью составного оператора присваивания  |= можно сделать запись компактней.

    tmp |= (1<<4);
    tmp |= (1<<7)|(1<<5)|(1<<0);

_______________ побитовое И & _______________

Обнулить несколько битов можно так



Используя составной оператор присваивания &= ,можно записать выражение более компактно

    tmp &= (~((1<<3)|(1<<5)|(1<<6)));

   Как проверить установлен ли бит в переменной? Нужно обнулить все биты, кроме проверочного, а потом сравнить полученное значение с нулем
    
   if ((tmp & (1<<2)) != 0 ){
      // блок будет выполняться, только если установлен
      // второй бит переменной tmp
   }

    if ((tmp & (1<<2)) == 0 ){
      // блок будет выполняться, только если не установлен
      // второй бит переменной tmp
    }

   Оператор ^ осуществляет операцию логического исключающего ИЛИ между соответствующими битами двух операндов. Результатом операции логического исключающего ИЛИ будет 0 в случае равенства битов. Во всех остальных случаях результат будет 1. Это проиллюстрировано в табице истинности.


    tmp = 155;
    tmp = tmp ^ 8; // инвертируем четвертый бит переменой tmp
    
    155         0b10011011    
^
    8             0b00001000    
    147         0b10010011

Четвертый бит изменил свое значение на противоположное, а остальные биты остались без изменений.

    tmp = tmp ^ 8; // опять инвертируем четвертый бит переменой tmp

    147         0b10010011    
^
    8             0b00001000    
    155         0b10011011

Видите, четвертый бит снова изменил свое значение на противоположное.  

Так записывать выражение намного удобнее

    tmp = tmp ^ (1<<3); // инвертируем третий бит переменой tmp
    
А так и удобно и компактно

    tmp ^= (1<<4);  //инвертируем четверый бит

Можно инвертировать несколько битов одновременно

    tmp ^= ((1<<4)|(1<<2)|(1<<1)); //инвертируем 4,2 и 1 биты   


tmp = var1;
var1 = var2;
var2 = tmp;

Но используя оператор ^  переставить значения можно так:

var1 ^= var 2;
var 2 ^= var 1;
var 1 ^= var 2;

Чистая магия, хотя, честно говоря,  я ни разу не пользовался таким приемом.



Пример:

#include "iom8535.h"

//порт, к которому подключены кнопки
#define PORT_BUTTON     PORTA
#define PIN_BUTTON        PINA
#define DDRX_BUTTON     DDRA

//выводы, к которым подключены кнопки
#define DOWN        3
#define CANCEL      4
#define UP              5
#define ENTER         6

int main()
{
    //конфигурируем порт на вход,
    //и включаем подтягивающие резисторы
    DDRX_BUTTON = 0;    
    PORT_BUTTON = 0xff;
    
…..
}


При задании символического имени можно использовать и выражения

#define MASK_BUTTONS       ((1<<DOWN)|(1<<CANCEL)|(1<<UP)|(1<<ENTER))

пример использования:
tmp = PORTB & MASK_BUTTONS;

Используя #define не жалейте скобок чтобы четко задать последовательность вычисления выражений!

Некоторые выражения можно замаскировать под «функции».

#define ADC_OFF()             ADCSRA = 0

пример использования:
ADC_OFF();

Можно использовать многострочные определения, используя в конце каждой строки символ \

#define INIT_Timer()        TIMSK = (1<<OCIE0);\
                                       TCCR0 = (1<<WGM01)|(0<<WGM00)|(1<<CS02);\
                                       TCNT0 = 0;\
                                       OCR0 = 0x7d

пример использования:
INIT_Timer();

 
Ну и самое мощное применение директивы #define – это задание макроопределений (или просто макросов). Вот как с помощью #define можно задать макросы для рассмотренных ранее операций с битами

#define   SetBit(reg, bit)          reg |= (1<<bit)           
#define   ClearBit(reg, bit)       reg &= (~(1<<bit))
#define   InvBit(reg, bit)          reg ^= (1<<bit)
#define   BitIsSet(reg, bit)       ((reg & (1<<bit)) != 0)
#define   BitIsClear(reg, bit)    ((reg & (1<<bit)) == 0)

пример использования:
…
SetBit(PORTB, 0);    //установить нулевой бит порта B    
InvBit(tmp,6);         //инвертировать шестой бит переменной tmp

…
if  (BitIsClear(PIND, 0)) {   //если очищен нулевой бит в регистре PIND                                    
…..                                     //выполнить блок
}

Определим макрос, вычисляющий квадрат числа:

#define SQUARE(x)    x*x

выражение    
tmp =  SQUARE(my_var);
даст корректный результат.

А что будет если в качестве аргумента макроопределения использовать выражение my_var+1

tmp =  SQUARE(my_var +1);

Препроцессор заменит эту строчку на

tmp = my_var + 1 * my_var +1;

а это вовсе не тот результат, который мы ожидаем.

Чтобы избежать таких ошибок не скупитесь на скобки при объявлении макросов!

Если объявить макрос так

#define SQUARE(x)    ((x)*(x))

выражение
tmp =  SQUARE(my_var +1);
даст корректный результат, потому что препроцессор заменит эту строчку на
tmp = ((my_var + 1) * (my_var +1));

 

записываем их в папку проекта, а в начале файла main.c  прописываем #include "bits_macros.h"