Рассмотрим примеры настройки портов в CodeVision AVR
Например DDRB=0x02; данная запись означает что вторая ножка порта В настроена как выход, но откуда взялось это число????
Для начала переведем данную запись в более понятный нам вид:
приставка 0х означает что число записано в шестнадцатеричной системе исчисления, чтобы легко понять его суть нужно перевести его в двоичную систему. Поможет нам в этом калькулятор Windows из набора стандартных программ, сразу переводим его в режим программист.
Переключаем его в режим шестнадцатеричной системы (галочка HEX), и вводим наше число 0х02 просто как 2.
теперь не нажимаем никаких равно и пр. просто переключаемся в двоичную систему счисления (галочка Bin)
Получили число 10. Что же оно значит? У нашей ATmega8 имеется 8 ножек на порту В (обведены на картинке)
так вот если представить число 10 как 00000010, то это будет означать что только вторая ножка настроена как выход, остальные как вход.
PORTB.7 | PORTB.6 | PORTB.5 | PORTB.4 | PORTB.3 | PORTB.2 | PORTB.1 | PORTB.0 |
0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
Тут нужно отметить, что если вместо
DDRB=0x02;
запишем
DDRB=0b00000010;
то оно тоже будет работать, т.е. это равнозначные записи одного и того же числа, в разных системах счисления.
С DDRB разобрались 1-выход, 0-вход, а что же означает
PORTB=0x01;
тут принцип тот же самый, но:
если нога сконфигурирована как выход и значение PORTB будет равно единице на этой же ноге, то ножка после прошивки будет включена по умолчанию (т.е. на ней будет напряжение), если 0, то ножка будет выключена. В первом уроке мы могли бы заменить запись PORTB.0=1; записью PORTB=0x01; и получили тот же самый результат.
На самом деле, правильным решением включения/выключения ножки с точки зрения языка Си, являются следующие конструкции:
PORTD |= (1<<3); //включить ножку 3 порта D PORTD |= (1<<2)|(1<<5)|(1<<6); //включить ножки 2, 5, 6 порта D PORTD &= ~(1<<2); //выключить ножку 2 PORTD &= (~((1<<0)|(1<<2)|(1<<4))); //выключить ножки 0, 2, 4
Если нога сконфигурирована как вход и значение PORTB будет равно единице на этой же ноге, то к ножке будет подключен подтягивающий резистор, для устранения помех. Если вам внутренний резистор не нужен то просто установите 0 на этой ножке.
Надеюсь все понятно, если что пишите, задавайте вопросы.
При программировании микроконтроллеров постоянно приходится работать с битами. Устанавливать их, сбрасывать, проверять их наличие в том или ином регистре. В AVR ассемблере для этих целей существует целый ряд команд. Во-первых, это группа команд операций с битами – они предназначены для установки или сброса битов в различных регистрах микроконтроллера, а во-вторых, группа команд передачи управления – они предназначены для организации ветвлений программ. В языке Си естественно нет подобных команд, поэтому у начинающих программистов часто возникает вопрос, а как в Си работать с битами. Эту тему мы сейчас и будем разбирать.
В Си существуют 6 операторов для манипулирования битами. Их можно применять к любым целочисленным знаковым или беззнаковым типам переменных.
<< - сдвиг влево
>> - сдвиг вправо
~ - поразрядная инверсия
| - поразрядное ИЛИ
& - поразрядное И
^ - поразрядное исключающее ИЛИ
_______________ сдвиг влево << _______________
Сдвигает число на n разрядов влево. Старшие n разрядов при этом исчезают, а младшие n разрядов заполняются нулями.
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 n .
_______________ сдвиг вправо >> _______________
Сдвигает число на n разрядов вправо. Младшие n разрядов при этом теряются. Заполнение старших n разрядов зависит от типа переменной и ее значения. Старшие n разрядов заполняются нулями в двух случаях – если переменная беззнакового типа или если переменная знаковая и ее текущее значение положительное. Когда переменная знаковая и ее значение отрицательное – старшие разряды заполняются единицами.
Пример для беззнаковой переменной
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 n . При этом есть некоторые нюансы. Если потерянные младшие разряды содержали единицы, то результат подобного “деления” получается грубоватым.
Например
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
_______________ поразрядное ИЛИ | ______________
Оператор | осуществляет операцию логического ИЛИ между соответствующими битами двух операндов. Результатом операции логического ИЛИ между двумя битами будет 0 только в случае, если оба бита равны 0. Во всех остальных случаях результат будет 1. Это проиллюстрировано в табице истинности.
Оператор | обычно используют для установки заданных битов переменной в единицу.
Tmp = 155
tmp = tmp | 4; //устанавливаем в единицу второй бит переменной tmp
155 0b100110
11
4
0b000001
00
159 0b100111
11
Использовать десятичные числа для установки битов довольно неудобно. Гораздо удобнее это делать с помощью операции сдвига влево <<.
tmp = tmp | (1<<4); //устанавливаем в единицу четвертый бит переменной tmp
Читаем справа налево – сдвинуть единицу на четыре разряда влево, выполнить операцию ИЛИ между полученным числом и значением переменной tmp, результат присвоить переменной tmp.
Установить несколько битов в единицу можно так
Tmp = tmp | (1<<7)|(1<<5)|(1<<0);
//устанавливаем в единицу седьмой, пятый и нулевой биты переменной tmp
С помощью составного оператора присваивания |= можно сделать запись компактней.
Tmp |= (1<<4);
tmp |= (1<<7)|(1<<5)|(1<<0);
_______________ побитовое И & _______________
Оператор & осуществляет операцию логического И между соответствующими битами двух операндов. Результатом операции логического И между двумя битами будет 1 только в том случае, если оба бита равны 1. Во всех других случаях результат будет 0. Это проиллюстрировано в таблице истинности.
Оператор & обычно применяют, чтобы обнулить один или несколько битов.
Tmp = 155;
tmp = tmp & 247; //обнуляем третий бит переменной tmp
155 0b10011
011
&
247 0b11110
111
147 0b10010
011
Видите, третий бит стал равен 0, а остальные биты не изменились.
Обнулять биты, используя десятичные цифры, неудобно. Но можно облегчить себе жизнь, воспользовавшись операторами << и ~
Tmp = 155;
tmp = tmp & (~(1<<3)); //обнуляем третий бит
1<<3 0b00001
000
~(1<<3) 0b11110
111
tmp & (~(1<<3)) 0b10011
011 & 0b11110
111
результат 0b10010
011
Читаем справа налево – сдвинуть единицу на три разряда влево, выполнить инверсию полученного числа, выполнить операцию & между значением переменной tmp и проинвертированным числом, результат присвоить переменной tmp.
Обнулить несколько битов можно так
tmp = tmp & (~((1<<3)|(1<<5)|(1<<6))); //обнуляем третий, пятый и шестой биты
Используя составной оператор присваивания &= ,можно записать выражение более компактно
Tmp &= (~((1<<3)|(1<<5)|(1<<6)));
Как проверить установлен ли бит в переменной?
Нужно обнулить все биты, кроме проверочного, а потом сравнить полученное значение с нулем
if
((tmp & (1<<2)) != 0){
// блок будет выполняться, только если установлен
}
if
((tmp & (1<<2)) == 0){
// блок будет выполняться, только если не установлен
// второй бит переменной tmp
}
_______________побитовое исключающее ИЛИ ^ _______________
Оператор ^ осуществляет операцию логического исключающего ИЛИ между соответствующими битами двух операндов. Результатом операции логического исключающего ИЛИ будет 0 в случае равенства битов. Во всех остальных случаях результат будет 1. Это проиллюстрировано в табице истинности.
Оператор ^ применяется не так часто как остальные битовые операторы, но и для него находится работенка. Например, с помощью него можно инвертировать один или несколько битов переменной .
tmp = 155;
tmp = tmp ^ 8; // инвертируем четвертый бит переменой tmp
155 0b10011
011
^
8 0b00001
000
147 0b10010
011
Четвертый бит изменил свое значение на противоположное, а остальные биты остались без изменений.
Tmp = tmp ^ 8; // опять инвертируем четвертый бит переменой tmp
147 0b10010
011
^
8 0b0000
1
000
155 0b10011
011
Видите, четвертый бит снова изменил свое значение на противоположное.
Так записывать выражение намного удобнее
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;
Чистая магия, хотя, честно говоря, я ни разу не пользовался таким приемом.
________________Директива #define__________________
Теперь мы знаем, как устанавливать, обнулять и инвертировать биты, знаем, как проверять установлен ли бит или нет. Рассмотренные выше выражения довольно громоздки, но с помощью директивы препроцессора #define , им можно придать более приятный вид.
Директива #define используется для присваивания символических имен константам и для макроопределений. Использование символических имен делают программу более модифицируемой и переносимой.
Например, вы используете в тексте программы константу, и вдруг вам понадобилось изменить ее значение. Если она встречается всего в трех местах, то исправить ее можно и в ручную, а что делать, если она встречается в пятидесяти строчках? Мало того, что исправление займет много времени, так еще и ошибиться в этом случае проще простого. Здесь то, как раз и выручает директива #define . В начале программы задается символическое имя константы, которое используется по ходу программы. Если нам нужно изменить это значение, это делается всего лишь в одном месте. А перед компиляцией препроцессор сам подставит во все выражения вместо имени константы ее значение.
Программирование микроконтроллера неразрывно связано с его аппаратной частью и чаще всего с внешней обвязкой. Взять хотя бы кнопки - опрашивая их в своей программе, мы обращаемся к реальным выводам микроконтроллера. А если нам вдруг понадобилось использовать программу опроса кнопок в другой схеме, где кнопки подключены к другим выводам? Придется исправлять программу. Опять таки, задав с помощью директивы #define символическое имя для соответствующих выводов, модифицировать программу будет проще простого
Пример:
#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< пример использования:
Используя #define
не жалейте скобок чтобы четко задать последовательность вычисления выражений! Некоторые выражения можно замаскировать под «функции». #define
ADC_OFF() ADCSRA = 0 пример использования: Можно использовать многострочные определения, используя в конце каждой строки символ \ #define
INIT_Timer() TIMSK = (1< пример использования: Ну и самое мощное применение директивы #define
– это задание макроопределений (или просто макросов). Вот как с помощью #define
можно задать макросы для рассмотренных ранее операций с битами #define
SetBit(reg, bit) reg |= (1< пример использования: … Перед компиляцией препроцессор заменит эти строчки объявленными ранее выражениями, подставив в них соответствующие аргументы. Макросы очень мощное средство, но использовать их нужно осторожно. Вот самые распространенные грабли, о которых написано во всех учебниках по программированию. Определим макрос, вычисляющий квадрат числа: #define
SQUARE(x) x*x выражение А что будет если в качестве аргумента макроопределения использовать выражение my_var+1 tmp = SQUARE(my_var +1); Препроцессор заменит эту строчку на tmp = my_var + 1 * my_var +1; а это вовсе не тот результат, который мы ожидаем. Чтобы избежать таких ошибок не скупитесь на скобки при объявлении макросов!
Если объявить макрос так #define
SQUARE(x) ((x)*(x)) выражение записываем их в папку проекта, а в начале файла main.c прописываем #include
"bits_macros.h" Чтение/Запись Исходное значение · Бит 7 – Разрешение всех прерываний. Для разрешения прерываний этот бит должен быть установлен в состояние 1. Управление разрешением конкретного прерывания выполняется регистром маски прерывания EIMSK и TIMSK. Если этот бит очищен (=0), то ни одно из прерываний не обрабатывается. Бит аппаратно очищается после возникновения прерывания и устанавливается для последующего разрешения прерывания командой RETI. · Бит 3 – Дополнение до двух флага переполнения. Он поддерживает арифметику дополнения до двух. Микроконтроллер AT90S8535 имеет 4 параллельных порта ввода/вывода A, B,C и D. Чтение/Запись Исходное значение Чтение/Запись Исходное значение Чтение/Запись Исходное значение Порт В является 8-разрядным двунаправленным портом ввода/вывода. Также как и у порта А взаимодействие с портом В осуществляется через три регистра в пространстве ввода/вывода памяти данных: регистр данных – PORTB, $18($38), регистр направления данных – DDRB, $17($37) и регистр входных данных – PINB, $16($36). Регистр PINB обеспечивает возможность только чтения. Регистр PINB не является регистром в полном смысле этого слова. Обращение к нему обеспечивает чтение физического состояния каждого вывода порта. Выводы порта В могут выполнять альтернативные функции, указанные в табл. 2.1. Альтернативная функция T0 – вход тактового сигнала таймера/счетчика 0 T1 – вход тактового сигнала таймера/счетчика 1 AIN0 – положительный вывод компаратора AIN1 – отрицательный вывод компаратора – вход выбора ведомого SPI MOSI – установка ведущий выход/ведомый вход SPI MISO – установка ведущий вход/ведомый выход SPI SCK – тактовый сигнал SPI При использовании выводов для альтернативных функций регистры PORTB, DDRB должны быть установлены соответствующим образом. Чтение/Запись Исходное значение Регистр направления данных порта B –
DDRB
Чтение/Запись Исходное значение Регистр входных данных порта B –
PINB
Чтение/Запись Исходное значение Порт С представляет собой 8-разрядный двунаправленный порт ввода/вывода. Также как у портов А и В взаимодействие с портом С осуществляется через три регистра в пространстве ввода/вывода памяти данных: регистр данных – PORTC, $15($35), регистр направления данных – DDRC, $14($34) и регистр входных данных – PINC, $13($33). Регистр PINC обеспечивает только возможность чтения, а регистры PORTC и DDRC – возможность чтения и записи. Регистр PINC не является регистром в полном смысле этого слова. Обращение к нему обеспечивает чтение физического состояния каждого вывода порта. Чтение/Запись Исходное значение Регистр направления данных порта C –
DDRC
Чтение/Запись Исходное значение Регистр входных данных порта C –
PINC
Чтение/Запись Исходное значение Порт D является 8-разрядным двунаправленным портом ввода/вывода. Также как и у портов А, В и С взаимодействие с портом D осуществляется через три регистра в пространстве ввода/вывода памяти данных: регистр данных – PORTD, $12($32), регистр направления данных – DDRD, $11($31) и регистр входных данных – PIND, $10($30). Регистр PIND обеспечивает возможность чтения, а регистры PORTD и DDRD – возможность чтения и записи. Регистр PIND не является регистром в полном смысле этого слова. Обращение к нему обеспечивает чтение физического состояния каждого вывода порта. Альтернативная функция RxD – вход приемника UART TxD – выход передатчика UART INT0 – вход внешнего прерывания 0 INT1 – вход внешнего прерывания 1 OC1B – вывод сравнения выхода В таймера/счетчика 1 OC1А – вывод сравнения выхода А таймера/счетчика 1 ICP – вход триггера захвата таймера/счетчика 1 OC2 – вывод сравнения выхода таймера/счетчика 2 При использовании выводов для альтернативных функций регистры PORTD, DDRD должны быть установлены соответствующим образом. Чтение/Запись Исходное значение Чтение/Запись Исходное значение Чтение/Запись Исходное значение Так как рассматриваемая работа первая, то для приобретения обучающимися навыков работы с лабораторным комплексом все обучающиеся сначала делают одинаковую работу. Со своих рабочих мест они вводят в ПЭВМ одну и ту же задачу вычитания из числа 5 числа 3, приведённую в п. 1.5.3.1. После компиляции программы она записывается в микроконтроллер рабочего места и демонстрируется её работа преподавателю. Вот ты читаешь сейчас это и думаешь — память, регистры, стек и прочее это хорошо. Но ведь это не пощупать, не увидеть. Разве что в симуляторе, но я и на дельфи с тем же условием могу накодить. Где мясо!!! В других курсах там, чуть ли не с первых строк, делают что то существенное — диодиком мигают и говорят, что это наш Hello World. А тут? Гыде??? Да-да-да, я тебя понимаю. Более того, наверняка ты уже сбегал к конкурентам и помигал у них диодиком;)))) Ничего, простительно. Я просто не хотел на этом же мигании дидодиков и остановиться, а для прогресса нужно четкое понимание основ и принципов — мощная теоретическая база. Но вот пришла очередь практики. О портах было рассказано, шаблон программы у вас уже есть, так что сразу и начнем. Инструментарий
cbi/sbi, но работают они исключительно в малом адресном диапазоне (от 0 до 1F, поэтому давайте сначала напишем универсальные макросы, чтобы в будущем применять их и не парить мозг насчет адресного пространства. Макросы будут зваться: Причем при работе с битами младших РВВ (0-1F адрес) то значение параметра TEMP можно и не указывать — он все равно подставляться не будет. За исключением команд инверсии — там промежуточные регистры полюбому нужны будут. Также полезно заиметь группу макросов не использующих регистры. Точнее регистры они использовать будут, но предварительно сохранив их в стеке. Их можно будет бездумно пихать словно обычные команды. Но выполняться они будут дольше и будут требовать оперативной памяти. Вот их исходный код. Как можно заметить, активно используются условия макроязыка, что дает возможность налупить универсальных макросов. Компилятор сам разберется какую версию куда ему подсунуть:) ;= Start macro.inc ========================================
;SET BIT with stack
.MACRO SETBM
.if @0 < 0x20
SBI @0,@1
.else
.if @0<0x40
PUSH R17
IN R17,@0
ORI R17,1<<@1
OUT @0,R17
POP R17
.else
PUSH R17
LDS R17,@0
ORI R17,1<<@1
STS @0,R17
POP R17
.endif
.endif
.ENDM
;SET BIT with REG
.MACRO SETB
.if @0 < 0x20 ; Low IO
SBI @0,@1
.else
.if @0<0x40 ; High IO
IN @2,@0
ORI @2,1<<@1
OUT @0,@2
.else ; Memory
LDS @2,@0
ORI @2,1<<@1
STS @0,@2
.endif
.endif
.ENDM
;.............................................................
;Clear BIT with REG
.MACRO CLRB
.if @0 < 0x20 ; Low IO
CBI @0,@1
.else
.if @0<0x40 ; High IO
IN @2,@0
ANDI @2,~(1<<@1)
OUT @0,@2
.else ; Memory
LDS @2,@0
ANDI @2,~(1<<@1)
STS @0,@2
.endif
.endif
.ENDM
;Clear BIT with STACK
.MACRO CLRBM
.if @0 < 0x20
CBI @0,@1
.else
.if @0<0x40
PUSH R17
IN R17,@0
ANDI R17,~(1<<@1)
OUT @0,R17
POP R17
.else
PUSH R17
LDS R17,@0
ANDI R17,~(1<<@1)
STS @0,R17
POP R17
.endif
.endif
.ENDM
;.............................................................
.MACRO INVB
.if @0 < 0x40
IN @2,@0
LDI @3,1<<@1
EOR @3,@2
OUT @0,@3
.else
LDS @2,@0
LDI @3,1<<@1
EOR @2,@3
STS @0,@2
.endif
.ENDM
.MACRO INVBM
.if @0 < 0x40
PUSH R16
PUSH R17
IN R16,@0
LDI R17,1<<@1
EOR R17,R16
OUT @0,R17
POP R17
POP R16
.else
PUSH R16
PUSH R17
LDS R16,@0
LDI R17,1<<@1
EOR R17,R16
STS @0,R17
POP R17
POP R16
.endif
.ENDM
;= End macro.inc ======================================== Со временем, когда пишешь на ассемблере, таких вот макросов становится очень и очень много. Они выносятся в отдельный файл и просто подключаются к любому твоему проекту, а написание кода становится легким и приятным. Но вернемся к коду, Да не вопрос. На демоплате уже смонтированы светодиоды, почему бы их не заюзать? Они висят на выводах порта PD4,PD5, PD7. Надо только одеть джамперы. ; Internal Hardware Init ======================================
SETB DDRD,4,R16 ; DDRD.4 = 1
SETB DDRD,5,R16 ; DDRD.5 = 1
SETB DDRD,7,R16 ; DDRD.7 = 1
; End Internal Hardware Init =================================== Осталось зажечь наши диоды. Зажигаются они записью битов в регистр PORT. Это уже делаем в главной секции программы. ; Main =========================================================
Main: SETB PORTD,4,R16 ; Зажгли LED1
SETB PORTD,7,R16 ; Зажгли LED3
JMP Main
; End Main ===================================================== Компилиуем, можешь в трассировщике прогнать, сразу увидишь как меняются биты. Прошиваем… и после нажатия на RESET и выгрузки bootloader (если конечно у тебя ) увидишь такую картину: И для версии II Во! Тока это же скучно. Давай ка ими помигаем. Заменим всего лишь наши макрокоманды. ; Main =========================================================
Main: SETB PORTD,4,R16 ; Зажгли LED1
INVB PORTD,7,R16,R17 ; Инвертировали LED3
JMP Main
; End Main ===================================================== Зажгли, прошили… А вот фиг — горят оба, но один чуть-чуть тусклей. На самом деле он мерцает, но очень очень быстро. Если ткнуть осциллографом в вывод PD7, то будет видно, что уровень меняется там с бешеной частотой: Что делать? Очевидно замедлить. Как? Самый простой способ, который практикуют в подавляющем большинстве обучалок и быстрых стартов — тупой задержкой. Т.е. получают код вида: ; Main =========================================================
Main: SETB PORTD,4,R16 ; Зажгли LED1
INVB PORTD,7,R16,R17 ; Инвертировали LED3
RCALL Delay
JMP Main
; End Main =====================================================
; Procedure ====================================================
.equ LowByte = 255
.equ MedByte = 255
.equ HighByte = 255
Delay: LDI R16,LowByte ; Грузим три байта
LDI R17,MedByte ; Нашей выдержки
LDI R18,HighByte
loop: SUBI R16,1 ; Вычитаем 1
SBCI R17,0 ; Вычитаем только С
SBCI R18,0 ; Вычитаем только С
BRCC Loop ; Если нет переноса - переход
RET
; End Procedure ================================================ Прошили, запустили… О да, теперь мигание будет заметно. При параметрах 255.255.255 длительность выдержки на 8Мгц будет около 2.1 секунды. Можно увеличить разрядность задержки еще на несколько байт. Тогда можно хоть час зарядить. Но этот метод ущербен, сейчас покажу почему. Давай добавим кнопку. LED3 пусть мигает в инверсии. А мы сделаем так, что когда кнопка нажата у нас горит LED1, а когда отпущена горит LED2. В качестве кнопки возьмем тактовую A, подключим ее к порту PD6. Для версии II аналогично. Только кнопку возьмем с группы кнопок и соединим вывод PD6 контроллера с штырем COL1 на кнопочной панели. Обрати только внимание на джамперы, что стоят на перемычках кнопочного поля. Синие такие. А также на один неприметный черный джамперок, на который указывает правая стрелка. Он соединяет крайне левую колонку кнопок с землей. Набрасывается на пины GND и ROW1. На плате там все подписано. Проверка кнопки делается командой SBIC, но вначале ее надо инициализировать. Сделать DDR=0, PORT=1 — вход с подтяжкой. Добавляем в секцию инициализации (Internal Hardware Init) эти строчки: ; Main =========================================================
Main: SBIS PIND,6 ; Если кнопка нажата - переход
RJMP BT_Push
SETB PORTD,5 ; Зажгем LED2
CLRB PORTD,4 ; Погасим LED1
Next: INVB PORTD,7,R16,R17 ; Инвертировали LED3
RCALL Delay
JMP Main
BT_Push: SETB PORTD,4 ; Зажгем LED1
CLRB PORTD,5 ; Погасим LED2
RJMP Next
; End Main ===================================================== Ну чо, работает. Кнопочка жмется — диодики меняются. Третий же бодро подмигивает. Но есть западло: Торомозит программка то! Я кнопочку нажал, а картинка не сменилась, нужно подождать, подержать… Почему? А это из-за нашего быдлокодинга. Помнишь я тебе говорил, что тупые задержки, в которых МК ничего не делает это адское зло? Вот! Теперь ты в этом убедился сам. Чтож, со злом надо бороться. Как? Ну эт я тоже уже говорил — делать непрерывный цикл с флажками. Хотя бы внести в нашу задержку полезную работу. Шарманка
Там барабан с торчащими гвоздями и пружинки на разные тона. Гвозди вращаются, дергают пружинки — они звякают. Получается расколбасный музон. А что если нашу шарманку развернуть в ленту. Не правда ли гвозди похожи на единички? ;)))) Лентой будет счетчик, считающий от нуля, скажем, до FF.FF.FF.FF и потом опять до нуля или еще какой величины, сколько надо столько и сделаем. А наши подпрограммы будут играть роль пружинок, цепляясь в нужных местах — сравнивая свою константу с текущим значением счетчика. Совпало? Делаем «ДРЫНЬ!» Осталось только прописать на временном цикле нашей шарманки где и что должно запускаться. И тут есть одна очень удобная особенность — для построения циклических последовательностей нам достаточно отлавливать один разряд. Скажем, считает шарманка от 0 до 1000, а нам надо 10 раз мигнуть диодом. Не обязательно втыкать 10 обработчиков с разными значениями. Достаточно одного, но чтобы он ловил значение **10. Все, остальное нам не важно. И сработает он на 0010, 0110, 0210, 0310, 0410, 0510, 0610, 0710, 0810, 0910. Более частые интервалы также делятся как нам надо, достаточно влезть в другой разряд. Тут надо только не забыть отрезать нафиг старшие разряды, чтобы не мешались. Приступим. Вначале создадим наш счетчик в сегменте данных: LDS R16,CCNT
LDS R17,CCNT+1
LDS R18,CCNT+2
LDS R19,CCNT+3 Все, теперь в R16 самый младший байт нашего счетчика, а в R19 самый старший. Регистры можно предварительно затолкать в стек, но я дам тебе лучше другой совет — когда пишешь программу, продумывай алгоритм так, чтобы использовать регистры как сплошной TEMP данные которого актуальны только здесь и сейчас. А что будет с ними в следующей процедуре уже не важно — все что нужно должно будет сохранено в оперативке. По можно сделать так: LDI R20,1 ; Нам нужна единичка
CLR R15 ; А еще нолик.
ADD R16,R20 ; Прибавляем 1 если в регистре 255, то будет С
ADC R17,R15 ; Прибавляем 0+С
ADC R18,R15 ; Прибавляем 0+С
ADC R19,R15 ; Прибавляем 0+С Пришлось потратить еще два регистра на хранение констант нашего сложения. Все от того, что AVR не умеет складывать регистры с непосредственным числом. Зато умеет вычитать. Я уже показывал, что R-(-1)=R+1, а ведь никто не запрещает нам этот же прием устроить и тут — сделать сложение через вычитание. SUBI R16,(-1)
SBCI R17,(-1)
SBCI R18,(-1)
SBCI R19,(-1) Даст нам инкремент четырехбайтного числа R19:R18:R17:R16 А теперь я вам покажу немного целочисленной магии
SUBI R16,(-1) это, по факту R16 — 255 и почти при всех раскладах она нам даст нам заём из следующего разряда — С. А в регистре останется то число на которое больше. Т.е. смотри как работает эта математика, вспомним про число в доп кодах. Покажу на четырехрязрядном десятичном примере. У Нас есть ВСЕГО ЧЕТЫРЕ РАЗРЯДА, ни больше ни меньше. Отрицательное число это 0-1 так? Окей. 1 С 0000-1=9999+C Т.е. мы как бы взяли как бы из пятиразрядной 1 С 0000 отняли 1, но разрядов то у нас всего четыре! Получили доп код 9999 и флаг заема С (сигнализирующий о том, что был заем) Т.е. в нашей целочисленной математике 9999=-1:) Проверить легко -1+1 = 0 Верно? 9999+1 = 1 С 0000 Верно! :))) А 1 старшего разряда банально не влезла в разрядность и ушла в флаг переноса C, сигнализирующего еще и о переполнении. Оки, а теперь возьмем и сделаем R-(-1). Пусть R=4 1 С 0004-9999 = 0005+С Вот так вот взяли и сложили через вычитание. Просто магия, да? ;) Прикол ассемблера в том, что это всего лишь команды, а не доктрина и не правило. И команды которые подразумевают знаковые вычисления можно использовать где угодно, лишь бы они давали нужный нам результат! Вот и тут — наш счетчик он же беззнаковый, но мы используем особенности знакового исчисления потому что нам так удобней. Флаг С не выскочит лишь когда у нас дотикает до 255 (9999 в десятичном примере), тогда будет 255-255 = 0 и вскочит лишь Z, но нам он не нужен. STS CCNT,R16
STS CCNT+1,R17
STS CCNT+2,R18
STS CCNT+3,R19 Код Инкремента четырехбайтной константы в памяти можно свернуть в макрос, чтобы не загромождать код ; Main =========================================================
Main: SETB PORTD,4 ; Зажгли LED1
INVB PORTD,7,R16,R17 ; Инвертировали LED3
Next: INCM CCNT
JMP Main Запусти режим отладки и поставь точку останова (F9) на метку Main и загони курсор на первый брейкпоинт. 0хB6(CCNT)
0х9F(CCNT+1)
0х04(CCNT+2)
0x00(CCNT+3) Осталось теперь только сравнить число с этим слепком. Как сравнивать? Да довольно просто. Все зависит от того что мы хотим получить. Если ОДНО событие за ВЕСЬ период глобального счетчика нашей шарманки, то тупо, побайтно. В этом случае у тебя диодик моргнет через секунду после старта, а дальше ты будешь ждать пол часа до переполнения всего четырехбайтного счетчика. Чтобы он моргал каждую секунду тебе надо при сравнении замаскировать старшие биты глобального счетчика, словно у него разрядность не 32 бита, а меньше (и переполняется он чаще). Младшие байты сравниваем как есть, а самый старший только до его максимального разряда, остальные надо отрезать. Т.е. самый старший разряд для этого случая это CCNT+2=0х04 если в двоичном представлении то 0х04 = 00000
100 так вот, счетчик у нас четырех разрядный, значит событие с маской 00 04 9F B6 (00000000 00000
100 10011111 10110110) до переполнения возникнет дофига число раз. Видишь я нули жирным шрифтом выделил. Старший самый у мы вообще сравнивать не будем, а вот пред старший надо через AND по маске 00000111 продавить, чтобы отсечь старшие биты. Их еще надо заполнить до переполнения и обнуления счетчика. Но если мы их замаскируем то их дальнейшая судьба нас не волнует. Пусть хоть до второго пришествия тикает — нам плевать. LDS R16,CCNT ; Грузим числа в регистры
LDS R17,CCNT+1
LDS R18,CCNT+2
ANDI R18,0x07 ; Накладываем маску
CPI R16,0xB6 ; Сравниванем побайтно
BRNE NoMatch
CPI R17,0x9F
BRNE NoMatch
CPI R18,0x04
BRNE NoMatch
; Если совпало то делаем экшн
Match: INVB PORTD,7,R16,R17 ; Инвертировали LED3
; Не совпало - не делаем:)
NoMatch:
Next: INCM CCNT ; Проворачиваем шарманку
JMP Main Во, загрузили теперь мигает. Никаких затупов нет, нигде ничего не подвисает, а главный цикл пролетает со свистом, только успевай барабан шарманки проворачивать:) Вот только мигает заметно медленней чем мы хотели. Не 1 секунда, а 8. Ну а что ты хотел — добавив процедуру сравнения мы удлиннили цикл еще на несколько команд. И теперь он выполняется не 25 тактов, а 36. Пересчитывай все циферки заново:))))) Но это еще не самый цимес! Прикол в том, что у тебя часть кода выполняется, а часть нет — команды сравнения и перехода. Поэтому точно высчитать задержку по тактам это проще сразу удавиться — надо по каждой итерации высчитать когда и сколько у тебя будет переходов, сколько они тактов займут… А если код будет еще больше, то ваще труба и погрешность накапливается с каждой итерацией! Зато, если добавить код обработки кнопок: ; Main =========================================================
Main: SBIS PIND,6 ; Если кнопка нажата - переход
RJMP BT_Push
SETB PORTD,5 ; Зажгем LED2
CLRB PORTD,4 ; Погасим LED1
Next: LDS R16,CCNT ; Грузим числа в регистры
LDS R17,CCNT+1
LDS R18,CCNT+2
ANDI R18,0x07
CPI R16,0xB6 ; Сравниванем побайтно
BRNE NoMatch
CPI R17,0x9F
BRNE NoMatch
CPI R18,0x04
BRNE NoMatch
; Если совпало то делаем экшн
Match: INVB PORTD,7,R16,R17 ; Инвертировали LED3
; Не совпало - не делаем:)
NoMatch: NOP
INCM CCNT
JMP Main
BT_Push: SETB PORTD,4 ; Зажгем LED1
CLRB PORTD,5 ; Погасим LED2
RJMP Next
; End Main ===================================================== То увидим, что от тормозов и следов не осталось. Кнопки моментально реагируют на нажатия, а диодик мигает сам по себе. Многозадачность! :) В общем, шарманка не годится там где нужны точные вычисления. Но если задача стоит из серии «надо периодически дрыгать и не принципиально как точно», то самое то. Т.к. не занимает аппаратных ресурсов вроде таймера. Например, периодически сканировать клавиатуру, скажем, каждые 2048 оборотов главного цикла. Сам прикинь какое число надо нагрузить на сравнение и какую маску наложить:) Можешь скачать и поглядеть , протрассировать его, чтобы увидеть как там все вертится. А для точных вычислений времени существуют таймеры. Но о них разговор отдельный. Управление портами в AVR GCC. Регистры DDRx и PORTx. Порты микроконтроллера - это устройства ввода/вывода, позволяющие микроконтроллеру передавать или принимать данные. Стандартный порт микроконтроллера AVR имеет восемь разрядов данных, которые могут передаваться или приниматься параллельно. Каждому разряду (или биту) соответствует вывод (ножка) микроконтроллера. Ножки микроконтроллера также называют пинами. Для обозначения портов используются латинские буквы А, В, С и т.д. Количество портов ввода/вывода варьируется в зависимости от модели микроконтроллера. Любой порт микроконтроллера можно сконфигурировать как вход или как выход. Для того чтобы это сделать, следует записать в соответствующий порту регистр DDRx
необходимое значение. Кроме того, как вход или выход можно сконфигурировать отдельно любой вывод (пин) порта. В любом случае, хотите вы сконфигурировать весь порт или отдельный вывод, вам необходимо будет работать с ригистрами DDRx. DDRx - регистр направления передачи данных. Этот регистр определяет, является тот или иной вывод порта входом или выходом. Если некоторый разряд регистра DDRx содержит логическую единицу, то соответствующий вывод порта сконфигурирован как выход, в противном случае - как вход. Буква x в данном случае должна обозначать имя порта, с которым вы работаете. Таким образом, для порта A это будет регистр DDRA, для порта B - регистр DDRB и т. д. Используя AVR GCC
, записать в необходимый регистр то или иное значение можно одним из следующих способов. Для всего порта сразу. DDRD = 0xff;
Все выводы порта D будут сконфигурированы как выходы. 0xff
- шестнадцатиричное представление числа ff, где 0x является префиксом, используемым для записи шестнадцатиричных чисел. В десятичном представлении это будет число 255, а в двоичном виде оно будет выглядеть как 11111111. То есть во всех битах регистра DDRD будут записаны логические единицы. В AVR GCC
для представления двоичных чисел используется префикс 0b. Таким образом, число 11111111 должно представляться в программе как 0b11111111. Мы можем записать предыдущую команду в более читабельном виде. DDRD = 0b11111111;
Хотя такая запись и выглядит более наглядной, при конфигурировании портов принято использовать шестнадцатиричное представление чисел. Для того чтобы сконфигурировать все выводы порта D как входы, следует записать во все биты регистра DDRD логические нули. DDRD = 0x00;
В регистр DDRD можно записать и другие числа. Например: DDRD = 0xb3;
0xb3
- шестнадцатиричное представление числа 179. В двоичном виде оно будет выглядеть как 10110011. То есть часть выводов порта D будет сконфигурирована как выходы, а часть - как входы.
PD0 - 1 (выход) Чтобы сконфигурировать отдельно вывод PD2 как вход, нам необходимо в соответствующий бит регистра DDRD записать 0. Для этого применяют следующую конструкцию. DDRD &= ~(1 При инверсии мы получаем вместо нулей единички, а вместо единичек - нули. Эта логическая операция иначе называется операцией НЕ
(английское название NOT). Таким образом, при побитном инвертировании 00000100 мы получаем 11111011. (Подробнее о работе с числами в микроконтроллере см. во врезке ниже.)
Получившееся число с помощью операции побитного логического умножения & умножается на число, хранящееся в регистре DDRD, и результат записывается в регистр DDRD. При логическом умножении 0*0=0, 0*1=0, 1*1=1
. Операцию логического умножения иначе называют операцией И
(английское название AND). То есть сдвинутая нами влево на две позиции единичка превращается при инвертировании в ноль и умножается на соответствующий бит, хранящийся в регистре DDRD. При умножении на ноль мы получаем ноль. Таким образом, бит PD2 становится равным нулю. После того как направление передачи данных у порта сконфигурировано, можно присвоить порту значение, которое будет храниться в соответствующем регистре PORTx
. Если вывод сконфигурирован как выход, то единичка в соответствующем бите регистра PORTx формирует на выводе сигнал высокого уровня, а ноль - сигнал низкого уровня. Если же вывод сконфигурирован как вход, то единичка в соответствующем бите регистра PORTx подключает к выводу внутренний подтягивающий pull-up резистор, который обеспечивает высокий уровень на входе при отсутствии внешнего сигнала. Установить "1" на всех выводах порта D можно следующим образом. PORTD = 0xff;
А установить "0" на всех выводах порта D можно так. PORTD = 0x00;
К каждому биту регистров PORTx можно обращаться и по отдельности так же, как в случае с регистрами DDRx. Например, команда PORTD |= 1 PORTD &= ~(1 В AVR GCC
сдвиг можно осуществлять и с помощью функции _BV()
, которая выполняет поразрядный сдвиг и вставляет результат в компилируемый код. В случае использования функции _BV() две предыдущие команды будут выглядеть следующим образом. PORTD |= _BV(PD3);
// установить "1" на линии 3 порта D
PORTD &= ~_BV(PD4);
// установить "0" на линии 4 порта D
В зависимости от способа подключения светодиод будет загораться либо от сигнала высокого уровня, подаваемого на вывод PD1 микроконтроллера, как в первом случае, либо от сигнала низкого уровня в случае подключения, изображенного на втором рисунке.
/*************************************************************************
ПРИМЕР ВКЛЮЧЕНИЯ СВЕТОДИОДА СИГНАЛОМ ВЫСОКОГО УРОВНЯ
Пример подключения на рисунке 1
**************************************************************************/
#include Теперь попробуем мигнуть светодиодом, подключенным так, как это изображено на левом рисунке. Для этого используем функцию задержки _delay_ms(). Функция _delay_ms() формирует задержку в зависимости от передаваемого ей аргумента, выраженного в миллисекундах (в одной секунде 1000 миллисекунд). Максимальная задержка может достигать 262.14 миллисекунд. Если пользователь передаст функции значение более 262.14, то произойдет автоматическое уменьшение разрешения до 1/10 миллисекунды, что обеспечивает задержки до 6.5535 секунд. (О формировании более длительных задержек можно прочитать в статье .) Функция _delay_ms() содержится в файле delay.h, поэтому нам будет необходимо подключить этот файл к программе. Кроме того, для нормальной работы этой функции необходимо указать частоту, на которой работает микроконтроллер, в герцах.
/*************************************
ПРИМЕР МИГАНИЯ СВЕТОДИОДОМ
Пример подключения на рисунке 1
**************************************/
#define F_CPU 1000000UL
#include Серия миганий светодиодом будет очень короткой. Для того чтобы сделать мигание непрерывным, можно организовать бесконечный цикл с помощью оператора безусловного перехода "goto". Оператор goto осуществляет переход к месту программы, обозначенному меткой. Имя метки не должно содержать пробелов. После имени метки ставится знак двоеточия. Между именем метки и двоеточием не должно быть пробелов.
tmp = PORTB & MASK_BUTTONS;
ADC_OFF();
OCR0 = 0x7d
INIT_Timer();
…
SetBit(PORTB, 0); //установить нулевой бит порта B
InvBit(tmp,6); //инвертировать шестой бит переменной tmp
if
(BitIsClear(PIND, 0)) { //если очищен нулевой бит в регистре PIND
….. //выполнить блок
}
tmp = SQUARE(my_var);
даст корректный результат.
tmp = SQUARE(my_var +1);
даст корректный результат, потому что препроцессор заменит эту строчку на
tmp = ((my_var + 1) * (my_var +1));Бит
· Бит 6 – Бит сохранения копии. Команды копирования бита BLD и BST используют этот бит как источник и приемник при операциях с битами. Командой BST бит регистра общего назначения копируется в бит T, командой BLD бит Т копируется в бит регистра общего назначения.
· Бит 5 – Флаг полупереноса. Он указывает на перенос между тетрадами при выполнении ряда арифметических операций.
· Бит 4 – Бит знака. Бит S имеет значение результата операции исключающее ИЛИ (N(+)V) над флагами отрицательного значения (N) и дополнения до двух флага переполнения (V).
· Бит 2 – Флаг отрицательного значения. Этот флаг указывает на отрицательный результат ряда арифметических и логических операций.
· Бит 1 – Флаг нулевого значения. Этот флаг указывает на нулевой результат ряда арифметических и логических операций.
· Бит 0 – Флаг переноса. Этот флаг указывает на перенос при арифметических и логических операциях.
Порт А является 8-разрядным двунаправленным портом. Взаимодействие с портом А осуществляется через три регистра в пространстве ввода/вывода памяти данных: регистр данных – PORTA, $1B($3B), регистр направления данных – DDRA, $1A($3A), регистр входных данных – PINA, $19($39). Регистр PINA обеспечивает только возможность чтения, а регистры PORTA и DDRA – возможность чтения и записи. Регистр PINA не является регистром в полном смысле этого слова. Обращение к нему обеспечивает чтение физического состояния каждого вывода порта. Порт А служит также для ввода аналоговых сигналов A/D.Регистр данных порта А –
PORTA
Бит
Регистр направления данных порта А –
DDRA
Бит
Регистр входных данных порта А –
PINA
Бит
Таблица 2.1. Альтернативные функции выводов порта В
Вывод порта
Регистр данных порта
B
–
PORTB
Бит
Бит
Бит
У порта С только два вывода могут выполнять альтернативные функции: выводы PC6 и PC7 выполняют функции TOSC1 и TOSC2 таймера/счетчика 2.Регистр данных порта
C
–
PORTC
Бит
Бит
Бит
Выводы порта D могут выполнять альтернативные функции, указанные в табл. 2.2.Таблица 2.2. Альтернативные функции выводов порта D
Вывод порта
Регистр данных порта
D
–
PORTD
Бит
Регистр направления данных порта
D
–
DDRD
Бит
Регистр входных данных порта
D
–
PIND
Бит
После такого знакомства с комплексом обучающийся приступает к выполнению индивидуального задания. При наличии времени преподаватель может усложнить индивидуальное задание.
Работа с портами, обычно, подразумевает работу с битами. Это поставить бит, сбросить бит, инвертировать бит. Да, конечно, в ассемблере есть удобные команды 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
< 0x20
SBI @0,@1
.else
.if @0<0x40
PUSH R17
IN R17,@0
ORI R17,1<<@1
OUT @0,R17
POP R17
.else
PUSH R17
LDS R17,@0
ORI R17,1<<@1
STS @0,R17
POP R17
.endif
.endif
.ENDM
;SET BIT with REG
.MACRO SETB
.if @0 < 0x20 ; Low IO
SBI @0,@1
.else
.if @0<0x40 ; High IO
IN @2,@0
ORI @2,1<<@1
OUT @0,@2
.else ; Memory
LDS @2,@0
ORI @2,1<<@1
STS @0,@2
.endif
.endif
.ENDM
;.............................................................
;Clear BIT with REG
.MACRO CLRB
.if @0 < 0x20 ; Low IO
CBI @0,@1
.else
.if @0<0x40 ; High IO
IN @2,@0
ANDI @2,~(1<<@1)
OUT @0,@2
.else ; Memory
LDS @2,@0
ANDI @2,~(1<<@1)
STS @0,@2
.endif
.endif
.ENDM
;Clear BIT with STACK
.MACRO CLRBM
.if @0 < 0x20
CBI @0,@1
.else
.if @0<0x40
PUSH R17
IN R17,@0
ANDI R17,~(1<<@1)
OUT @0,R17
POP R17
.else
PUSH R17
LDS R17,@0
ANDI R17,~(1<<@1)
STS @0,R17
POP R17
.endif
.endif
.ENDM
;.............................................................
.MACRO INVB
.if @0 < 0x40
IN @2,@0
LDI @3,1<<@1
EOR @3,@2
OUT @0,@3
.else
LDS @2,@0
LDI @3,1<<@1
EOR @2,@3
STS @0,@2
.endif
.ENDM
.MACRO INVBM
.if @0 < 0x40
PUSH R16
PUSH R17
IN R16,@0
LDI R17,1<<@1
EOR R17,R16
OUT @0,R17
POP R17
POP R16
.else
PUSH R16
PUSH R17
LDS R16,@0
LDI R17,1<<@1
EOR R17,R16
STS @0,R17
POP R17
POP R16
.endif
.ENDM
;= End macro.inc ========================================
Мигнем уж светодиодиком то, наконец?
Сейчас я тебе покажу как можно сделать цифровую шарманку. Помнишь как она устроена? 1
2
3
4
SUBI R16,(-1)
SBCI R17,(-1)
SBCI R18,(-1)
SBCI R19,(-1)
Почему это будет работать? Смотри сам:
Представление чисел. Побитные операции.
Функция задержки. Безусловный переход в программе.
PD1 - 1 (выход)
PD2 - 0 (вход)
PD3 - 0 (вход)
PD4 - 1 (выход)
PD5 - 1 (выход)
PD6 - 0 (вход)
PD7 - 1 (выход)
В данном случае результат сдвига единицы на две позиции влево инвертируется с помощью операции побитного инвертирования, обозначаемой значком "~
".
PORTx - регистр порта, где x обозначает имя порта.
установит "1" (сигнал высокого уровня) на выводе PD3.
установит "0" (сигнал низкого уровня) на выводе PD4.
/*******************************************************
ПРИМЕР БЕСКОНЕЧНОГО МИГАНИЯ СВЕТОДИОДОМ
Пример подключения на рисунке 1
********************************************************/
#define F_CPU 1000000UL
// указываем частоту в герцах
#include