Здравствуйте, Андрей. Весьма интересен ваш подход к передаче багажа знаний и опыта, вами накопленного. Очень помогает в начинаниях. Ну и я, начиная осваивать arduino имею желание прогрессировать. Тем более, что с посторонней помощью у меня это получается быстрее. Итак: сперва моя задача была сделать робота, едущего по линии. Сделал — все отлично. Но дальше, снабжая его дополнительными опциями, не понимал — почему он перестал корректно реагировать на линию. Набрел на эту статью и понял причину.
Теперь у меня к вам вопрос: в ниже указанном и готовом скетче, учитывая проблемы с delay, нужно ли мне везде, где присутствует эта функция перейти на millis? Если так, то я понимаю, что скетч придется переделывать почти весь? И не совсем понятно, как использовать millis в замере расстояния? Спасибо.
//Робот с функцией следования по белой полосе
// **********************Установка выводов моторов ************************
int MotorLeftSpeed = 5; // Левый (А) мотор СКОРОСТЬ - ENA
int MotorLeftForward = 4; // Левый (А) мотор ВПЕРЕД - IN1
int MotorLeftBack = 3; // Левый (А) мотор НАЗАД - IN2
int MotorRightForward = 8; // Правый (В) мотор ВПЕРЕД - IN3
int MotorRightBack = 7; // Правый (В) мотор НАЗАД - IN4
int MotorRightSpeed = 9; // Правый (В) мотор СКОРОСТЬ - ENB
// **********************Установка выводов УЗ датчиков***********************
int trigPinL = 14; // задание номера вывода левого trig УЗ датчика
int echoPinL = 15; // задание номера вывода левого echo УЗ датчика
int trigPinC = 10; // задание номера вывода центрального trig УЗ датчика
int echoPinC = 11; // задание номера вывода центрального echo УЗ датчика
int trigPinR = 12; // задание номера вывода правого trig УЗ датчика
int echoPinR = 13; // задание номера вывода правого echo УЗ датчика
// ********************* Установка выводов датчиков линии *******************
const int LineSensorLeft = 19; // вход левого датчика линии
const int LineSensorRight = 18; // вход правого датчика линии
int SL; // статус левого сенсора
int SR; // статус правого сенсора
// *********************Установка вывода световой и звуковой сигнализации**************
int Light = 2; // задание номера вывода световой сигнализации
int Zumm = 6; // задание номера вывода зуммера
int ledState = LOW; // этой переменной устанавливаем состояние светодиода
long previousMillis = 0; // храним время последнего переключения светодиода
long interval = 300; // интервал между включение/выключением светодиода (0,3 секунды)
// *********************Переменная измерение дистанции датчиками*************
unsigned int impulseTimeL=0;
unsigned int impulseTimeC=0;
unsigned int impulseTimeR=0;
long distL=0; // дистанция, измеренная левым УЗ датчиком
long distC=0; // дистанция, измеренная центральным УЗ датчиком
long distR=0; // дистанция, измеренная правым Уз датчиком
// *********************************** SETUP ********************************
Serial.begin (9600); // запускаем серийный порт (скорость 9600)
//*************** Задаем контакты моторов****************
pinMode (MotorRightBack, OUTPUT); // Правый (В) мотор НАЗАД
pinMode (MotorRightForward, OUTPUT); // Правый (В) мотор ВПЕРЕД
pinMode (MotorLeftBack, OUTPUT); // Левый (А) мотор НАЗАД
pinMode (MotorLeftForward, OUTPUT); // Левый (А) мотор ВПЕРЕД
delay (duration);
//*************** Задаем контакты датчиков полосы**************
pinMode (LineSensorLeft, INPUT); // определением pin левого датчика линии
pinMode (LineSensorRight, INPUT); // определением pin правого датчика линии
// ***************Задание режимов выводов УЗ датчиков**********************
pinMode (trigPinL, OUTPUT); // задание режима работы вывода левого trig УЗ датчика
pinMode (echoPinL, INPUT); // задание режима работы вывода левого echo УЗ датчика
pinMode (trigPinC, OUTPUT); // задание режима работы вывода центрального trig УЗ датчика
pinMode (echoPinC, INPUT); // задание режима работы вывода центрального echo УЗ датчика
pinMode (trigPinR, OUTPUT); // задание режима работы вывода правого trig УЗ датчика
pinMode (echoPinR, INPUT); // задание режима работы вывода правого echo УЗ датчика
// ***************Задаем контакты световой и звуковой сигнализации********************************
pinMode (Zumm,OUTPUT); // задание режима работы вывода зуммера
pinMode (Light,OUTPUT); // задание режима работы вывода световой сигнализации
// ****************** Основные команды движения ******************
void forward (int a, int sa) // ВПЕРЕД
analogWrite (MotorRightSpeed, sa);
analogWrite (MotorLeftSpeed, sa);
void right (int b, int sb) // ПОВОРОТ ВПРАВО (одна сторона)
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorLeftBack, LOW);
digitalWrite (MotorLeftForward, HIGH);
analogWrite (MotorLeftSpeed, sb);
void left (int k, int sk) // ПОВОРОТ ВЛЕВО (одна сторона)
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorRightForward, HIGH);
analogWrite (MotorRightSpeed, sk);
digitalWrite (MotorLeftBack, LOW);
void stopp (int f) // СТОП
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorRightForward, LOW);
digitalWrite (MotorLeftBack, LOW);
digitalWrite (MotorLeftForward, LOW);
// **************************Измерение дистанции*********************
void izmdistL () // измерение дистанции левым УЗ датчиком
digitalWrite (trigPinL, HIGH);
digitalWrite (trigPinL, LOW); // импульс 10мС на вывод trig УЗ датчика для измерения расстояния
impulseTimeL = pulseIn (echoPinL, HIGH); // считывание расстояния с УЗ датчика
distL=impulseTimeL/58; // Пересчитываем в сантиметры
void izmdistC () // измерение дистанции центральным УЗ датчиком
digitalWrite (trigPinC, HIGH);
digitalWrite (trigPinC, LOW); // импульс 10мС на вывод trig УЗ датчика для измерения расстояния
impulseTimeC = pulseIn (echoPinC, HIGH); // считывание расстояния с УЗ датчика
distC=impulseTimeC/58; // Пересчитываем в сантиметры
void izmdistR () // измерение дистанции центральным УЗ датчиком
digitalWrite (trigPinR, HIGH);
digitalWrite (trigPinR, LOW); // импульс 10мС на вывод trig УЗ датчика для измерения расстояния
impulseTimeR = pulseIn (echoPinR, HIGH); // считывание расстояния с УЗ датчика
distR=impulseTimeR/58; // Пересчитываем в сантиметры
// *********************************** LOOP *********************************
// ********************** Режим следования по ЛИНИИ *************************
// *********************световая и звуковая сигнализация**************
tone (Zumm,900); // включаем звук на 900 Гц
tone (Zumm,900); // включаем звук на 800 Гц
unsigned long currentMillis = millis ();
if (currentMillis — previousMillis > interval) //проверяем не прошел ли нужный интервал, если прошел то
previousMillis = currentMillis; // сохраняем время последнего переключения
if (ledState == LOW) // если светодиод не горит, то зажигаем, и наоборот
ledState = HIGH;
digitalWrite (Light, ledState); // устанавливаем состояния выхода, чтобы включить или выключить светодиод
// ************************ Измерение дистанции************************
Serial.println (distL);
Serial.println (distC);
Serial.println (distR);
if (distL>50 && distC>50 && distR>50) // если измеренная дистанция больше 50 сантиметров — едем
SL = digitalRead (LineSensorLeft); // считываем сигнал с левого датчика полосы
SR = digitalRead (LineSensorRight); // считываем сигнал с правого датчика полосы
// ************************* Следование по черной линии ***********************
// РОБОТ на полосе - едем прямо
if (SL == LOW & SR == LOW) // БЕЛЫЙ - БЕЛЫЙ - едем ПРЯМО
forward (10, 100);// ПРЯМО (время, скорость)
// РОБОТ начинает смещаться с полосы - подруливаем
else if (SL == LOW & SR == HIGH) // ЧЕРНЫЙ — БЕЛЫЙ - поворот ВЛЕВО
left (10, 100);// поворот ВЛЕВО (время, скорость)
else if (SL == HIGH & SR == LOW) // БЕЛЫЙ — ЧЕРНЫЙ - поворот ВПРАВО
right (10, 100);// поворот ВПРАВО (время, скорость)
// ФИНИШ — РОБОТ видит обоими датчиками полосу
else if (SL == HIGH & SR == HIGH) // ЧЕРНЫЙ — ЧЕРНЫЙ — СТОП
stopp (50);// СТОП
else // если измеренная дистанция меньше или равна минимальной — стоим
И приведем пример использования функции Arduino attachInterrupt() .
Прерывание – это сигнал, который сообщает процессору о наступлении какого-либо события, которое требует незамедлительного внимания. Процессор должен отреагировать на этот сигнал, прервав выполнение текущих инструкций и передав управление обработчику прерывания (ISR, Interrupt Service Routine). Обработчик – это обычная функция, которую мы пишем сами и помещаем туда тот код, который должен отреагировать на событие.
После обслуживания прерывания ISR функция завершает свою работу и процессор с удовольствием возвращается к прерванным занятиям – продолжает выполнять код с того места, в котором остановился. Все это происходит автоматически, поэтому наша задача заключается только в том, чтобы написать обработчик прерывания, ничего при этом не сломав и не заставляя процессор слишком часто отвлекаться на нас. Понадобится понимание схемы, принципов работы подключаемых устройств и представление о том, как часто может вызываться прерывание, каковы особенности его возникновения. Все это и составляет основную сложность работы с прерываниями.
Аппаратные и программные прерывания
Прерывания в Ардуино можно разделить на несколько видов:
- Аппаратные прерывания . Прерывание на уровне микропроцессорной архитектуры. Самое событие может произойти в производительный момент от внешнего устройства – например, нажатие кнопки на клавиатуре, движение компьютерной мыши и т.п.
- Программные прерывания . Запускаются внутри программы с помощью специальной инструкции. Используются для того, чтобы вызвать обработчик прерываний.
- Внутренние (синхронные) прерывания . Внутреннее прерывание возникает в результате изменения или нарушения в исполнении программы (например, при обращении к недопустимому адресу, недопустимый код операции и другие).
Зачем нужны аппаратные прерывания
Аппаратные прерывания возникают в ответ на внешнее событие и исходят от внешнего аппаратного устройства. В Ардуино представлены 4 типа аппаратных прерываний. Все они различаются сигналом на контакте прерывания:
- Контакт притянут к земле. Обработчик прерывания исполняется до тех пор, пока на пине прерывания будет сигнал LOW.
- Изменение сигнала на контакте. В таком случае Ардуино выполняет обработчик прерывания, когда на пине прерывания происходит изменение сигнала.
- Изменение сигнала от LOW к HIGH на контакте – при изменении с низкого сигнала на высокий будет исполняться обработчик прерывания.
- Изменение сигнала от HIGH к LOW на контакте – при изменении с высокого сигнала на низкий будет исполняться обработчик прерывания.
Прерывания полезны в программах Ардуино, так как помогают решать проблемы синхронизации. Например, при работе с UART прерывания позволяют не отслеживать поступление каждого символа. Внешнее аппаратное устройство подает сигнал прерывания, процессор сразу же вызывает обработчик прерывания, который вовремя захватывает символ. Это позволяет экономить процессорное время, которое без прерываний тратилось бы на проверку статуса UART, вместо этого все необходимые действия выполняются обработчиком прерывания, не затрагивая главную программу. Особых возможностей от аппаратного устройства не требуется.
Основными причинами, по которым необходимо вызвать прерывание, являются:
- Определение изменения состояния вывода;
- Прерывание по таймеру;
- Прерывания данных по SPI, I2C, USART;
- Аналогово-цифровое преобразование;
- Готовность использовать EEPROM, флеш-память.
Как реализуются прерывания в Ардуино
При поступлении сигнала прерывания работа приостанавливается. Начинается выполнение функции, которая объявляется на выполнение при прерывании. Объявленная функция не может принимать входные значения и возвращать значения при завершении работы. На сам код в основном цикле программы прерывание не влияет. Для работы с прерываниями в Ардуино используется стандартная функция attachInterrupt() .
Отличие реализации прерываний в разных платах Ардуино
В зависимости от аппаратной реализации конкретной модели микроконтроллера есть несколько прерываний. Плата Arduino Uno имеет 2 прерывания на втором и третьем пине, но если требуется более двух выходов, плата поддерживает специальный режим «pin-change». Этот режим работает по изменению входа для всех пинов. Отличие режима прерывания по изменению входа заключается в том, что прерывания могут генерироваться на любом из восьми контактов. Обработка в таком случае будет сложнее и дольше, так как придется отслеживать последнее состояние на каждом из контактов.
На других платах число прерываний выше. Например, плата имеет 6 пинов, которые могут обрабатывать внешние прерывания. Для всех плат Ардуино при работе с функцией attachInterrupt (interrupt, function, mode) аргумент Inerrupt 0 связан с цифровым пином 2.
Прерывания в языке Arduino
Теперь давайте перейдем к практике и поговорим о том, как использовать прерывания в своих проектах.
Синтаксис attachInterrupt()
Функция attachInterrupt используется для работы с прерываниями. Она служит для соединения внешнего прерывания с обработчиком.
Синтаксис вызова: attachInterrupt(interrupt, function, mode)
Аргументы функции:
- interrupt – номер вызываемого прерывания (стандартно 0 – для 2-го пина, для платы Ардуино Уно 1 – для 3-го пина),
- function – название вызываемой функции при прерывании(важно – функция не должна ни принимать, ни возвращать какие-либо значения),
- mode – условие срабатывания прерывания.
Возможна установка следующих вариантов условий срабатывания:
- LOW – выполняется по низкому уровню сигнала, когда на контакте нулевое значение. Прерывание может циклично повторяться – например, при нажатой кнопке.
- CHANGE – по фронту, прерывание происходит при изменении сигнала с высокого на низкий или наоборот. Выполняется один раз при любой смене сигнала.
- RISING – выполнение прерывания один раз при изменении сигнала от LOW к HIGH.
- FALLING – выполнение прерывания один раз при изменении сигнала от HIGH к LOW.4
Важные замечания
При работе с прерываниями нужно обязательно учитывать следующие важные ограничения:
- Функция – обработчик не должна выполняться слишком долго. Все дело в том, что Ардуино не может обрабатывать несколько прерываний одновременно. Пока выполняется ваша функция-обработчик, все остальные прерывания останутся без внимания и вы можете пропустить важные события. Если надо делать что-то большое – просто передавайте обработку событий в основном цикле loop(). В обработчике вы можете лишь устанавливать флаг события, а в loop – проверять флаг и обрабатывать его.
- Нужно быть очень аккуратными с переменными. Интеллектуальный компилятор C++ может “пере оптимизировать” вашу программу – убрать не нужные, на его взгляд, переменные. Компилятор просто не увидит, что вы устанавливаете какие-то переменные в одной части, а используете – в другой. Для устранения такой вероятности в случае с базовыми типами данных можно использовать ключевое слово volatile, например так: volatile boolean state = 0. Но этот метод не сработает со сложными структурами данных. Так что надо быть всегда на чеку.
- Не рекомендуется использовать большое количество прерываний (старайтесь не использовать более 6-8). Большое количество разнообразных событий требует серьезного усложнения кода, а, значит, ведет к ошибкам. К тому же надо понимать, что ни о какой временной точности исполнения в системах с большим количеством прерываний речи быть не может – вы никогда точно не поймете, каков промежуток между вызовами важных для вас команд.
- В обработчиках категорически нельзя использовать delay(). Механизм определения интервала задержки использует таймеры, а они тоже работают на прерываниях, которые заблокирует ваш обработчик. В итоге все будут ждать всех и программа зависнет. По этой же причине нельзя использовать протоколы связи, основанные на прерываниях (например, i2c).
Примеры использования attachInterrupt
Давайте приступим к практике и рассмотрим простейший пример использования прерываний. В примере мы определяем функцию-обработчик, которая при изменении сигнала на 2 пине Arduino Uno переключит состояние пина 13, к которому мы традиционно подключим светодиод.
#define PIN_LED 13 volatile boolean actionState = LOW; void setup() { pinMode(PIN_LED, OUTPUT); // Устанавливаем прерывание // Функция myEventListener вызовется тогда, когда // на 2 пине (прерываниие 0 связано с пином 2) // изменится сигнал (не важно, в какую сторону) attachInterrupt(0, myEventListener, CHANGE); } void loop() { // В функции loop мы ничего не делаем, т.к. весь код обработки событий будет в функции myEventListener } void myEventListener() { actionState != actionState; // // Выполняем другие действия, например, включаем или выключаем светодиод digitalWrite(PIN_LED, actionState); }
Давайте рассмотрим несколько примеров более сложных прерываний и их обработчиков: для таймера и кнопок.
Прерывания по нажатию кнопки с антидребезгом
При прерывании возникает – перед тем, как контакты плотно соприкоснутся при нажатии кнопки, они будут колебаться, порождая несколько срабатываний. Бороться с дребезгом можно двумя способами – аппаратно, то есть, припаивая к кнопке конденсатора, и программно.
Избавиться от дребезга можно при помощи функции – она позволяет засечь время, прошедшее от первого срабатывания кнопки.
If(digitalRead(2)==HIGH) { //при нажатии кнопки //Если от предыдущего нажатия прошло больше 100 миллисекунд if (millis() - previousMillis >= 100) { //Запоминается время первого срабатывания previousMillis = millis(); if (led==oldled) { //происходит проверка того, что состояние кнопки не изменилось led=!led; }
Этот код позволяет удалить дребезг и не блокирует исполнение программы, как в случае с функцией delay, которая недопустима в прерываниях.
Прерывания по таймеру
Таймером называется счетчик, который производит счет с некоторой частотой, получаемой из процессорных 16 МГц. Можно произвести конфигурацию делителя частоты для получения нужного режима счета. Также можно настроить счетчик для генерации прерываний при достижении заданного значения.
И прерывание по таймеру позволяет выполнять прерывание один раз в миллисекунду. В Ардуино имеется 3 таймера – Timer0, Timer1 и Timer2. Timer0 используется для генерации прерываний один раз в миллисекунду, при этом происходит обновление счетчика, который передается в функцию millis (). Этот таймер является восьмибитным и считает от 0 до 255. Прерывание генерируется при достижении значения 255. По умолчанию используется тактовый делитель на 65, чтобы получить частоту, близкую к 1 кГц.
Для сравнения состояния на таймере и сохраненных данных используются регистры сравнения. В данном примере код будет генерировать прерывание при достижении значения 0xAF на счетчике.
TIMSK0 |= _BV(OCIE0A);
Требуется определить обработчик прерывания для вектора прерывания по таймеру. Вектором прерывания называется указатель на адрес расположения команды, которая будет выполняться при вызове прерывания. Несколько векторов прерывания объединяются в таблицу векторов прерываний. Таймер в данном случае будет иметь название TIMER0_COMPA_vect. В этом обработчике будут производиться те же действия, что и в loop ().
SIGNAL(TIMER0_COMPA_vect) { unsigned long currentMillis = millis(); sweeper1.Update(currentMillis); if(digitalRead(2) == HIGH) { sweeper2.Update(currentMillis); led1.Update(currentMillis); } led2.Update(currentMillis); led3.Update(currentMillis); } //Функция loop () останется пустой. void loop() { }
Подведение итогов
Прерывание в Ардуино – довольно сложная тема, потому что приходится думать сразу обо всей архитектуре проекта, представлять как выполняется код, какие возможны события, что происходит, когда основной код прерывается. Мы не ставили задачу раскрыть все особенности работы с этой конструкцией языка, главная цель была познакомить с основными вариантами использования. В следующих статьях мы продолжим разговор о прерываниях более подробне.
В ходе реализации проекта может потребоваться несколько прерываний, но если каждое из них будет иметь максимальный приоритет, то фактически его не будет ни у одной из функций. По этой же причине не рекомендуется использовать более десятка прерываний.
Обработчики должны применяться только к тем процессам, которые имеют максимальную чувствительность ко временным интервалам. Не стоит забывать, что пока программа находится в обработчике прерывания – все другие прерывания отключены. Большое количество прерываний ведет к ухудшению их ответа.
В момент, когда действует одно прерывание, а остальные отключаются, возникает два важных нюанса, которые должен учитывать схемотехник. Во-первых, время прерывание должно быть максимально коротким.
Это позволит не пропустить все остальные запланированные прерывания. Во-вторых, при обработке прерывания программный код не должен требовать активности от других прерываний. Если этого не предотвратить, то программа просто зависнет.
Не стоит использовать длительную обработку в loop() , лучше разработать код для обработчика прерывания с установкой переменной volatile. Она подскажет программе, что дальнейшая обработка не нужна.
Если вызов функции Update() все же необходим, то предварительно необходимо будет проверить переменную состояния. Это позволит выяснить, необходима ли последующая обработка.
Перед тем, как заняться конфигурацией таймера, следует произвести проверку кода. Таймеры Anduino стоит отнести к ограниченным ресурсам, ведь их всего три, а применяются они для выполнения самых разных функций. Если запутаться с использованием таймеров, то ряд операций может просто перестать работать.
Какими функциями оперирует тот или иной таймер?
Для микроконтроллера Arduino Uno у каждого из трех таймеров свои операции.
Так Timer0 отвечает за ШИМ на пятом и шестом пине, функции millis() , micros() , delay() .
Другой таймер – Timer1, используется с ШИМ на девятом и десятом пине, с библиотеками WaveHC и Servo.
Timer2 работает с ШИМ на 11 и 13 пинах, а также с Tone .
Схемотехник должен позаботиться о безопасном использовании обрабатываемых совместно данных. Ведь прерывание останавливает на миллисекунду все операции процессора, а обмен данных между loop() и обработчиками прерываний должен быть постоянным. Может возникнуть ситуация, когда компилятор ради достижения своей максимальной производительности начнет оптимизацию кода.
Результатом этого процесса будет сохранение в регистре копии основных переменных кода, что позволит обеспечить максимальную скорость доступа к ним.
Недостатком этого процесса может стать подмена реальных значений сохраненными копиями, что может привести к потере функциональности.
Чтобы этого не произошло нужно использовать переменную voltatile , которая поможет предотвратить ненужные оптимизации. При использовании больших массивов, которым требуются циклы для обновлений, нужно отключить прерывания на момент этих обновлений.
Когда вы установите эту программу, то удивитесь - насколько она похожа на Arduino IDE. Не удивляйтесь, обе программы сделаны на одном движке.
Приложение имеет очень много возможностей, в том числе и библиотеку Serial , поэтому мы можем связать передачу данных между платой и .
Запустим Arduino IDE и выберем простейший пример вывода данных на Serial Port :
Void setup() { Serial.begin(9600); } void loop() { Serial.println("Hello Kitty!"); // ждем 500 миллисекунд перед следующей отправкой delay(500); }
Запустим пример и убедимся, что код работает.
Получение данных
Теперь мы хотим получить этот же текст в . Запускаем новый проект и напишем код.
Первый шаг - импортировать библиотеку. Идем в Sketch | Import Library | Serial . В скетче появится строка:
Import processing.serial.*; Serial serial; // создаем объект последовательного порта String received; // данные, получаемые с последовательного порта void setup() { String port = Serial.list(); serial = new Serial(this, port, 9600); } void draw() { if (serial.available() > 0) { // если есть данные, received = serial.readStringUntil("\n"); // считываем данные } println(received); //отображаем данные в консоли }
Чтобы обеспечить прием данных с последовательного порта, нам нужен объект класса Serial . Так как с Arduino мы отправляем данные типа String, нам надо получить строку и в Processing.
В методе setup() нужно получить доступный последовательный порт. Как правило, это первый доступный порт из списка. После этого мы можем настроить объект Serial , указав порт и скорость передачи данных (желательно, чтобы скорости совпадали).
Осталось снова подключить плату, запустить скетч от Processing и наблюдать поступаемые данные в консоли приложения.
Processing позволяет работать не только с консолью, но и создавать стандартные окна. Перепишем код.
Import processing.serial.*; Serial serial; // создаем объект последовательного порта String received; // данные, получаемые с последовательного порта void setup() { size(320, 120); String port = Serial.list(); serial = new Serial(this, port, 9600); } void draw() { if (serial.available() > 0) { // если есть данные, // считываем их и записываем в переменную received received = serial.readStringUntil("\n"); } // Настройки для текста textSize(24); clear(); if (received != null) { text(received, 10, 30); } }
Запустим пример ещё раз и увидим окно с надписью, которое перерисовывается в одном месте.
Таким образом мы научились получать данные от Arduino. Это позволит нам рисовать красивые графики или создавать программы контроля за показаниями датчиков.
Отправка данных
Мы можем не только получать данные с платы, но и отправлять данные на плату, заставляя выполнять команды с компьютера.
Допустим, мы будем посылать символ "1" из Processing. Когда плата обнаружит присланный символ, включим светодиод на порту 13 (встроенный).
Скетч будет похож на предыдущий. Для примера создадим небольшое окно. При щелчке в области окна будем отсылать "1" и дублировать в консоли для проверки. Если щелчков не будет, то посылается команда "0".
Import processing.serial.*; Serial serial; // создаем объект последовательного порта String received; // данные, получаемые с последовательного порта void setup() { size(320, 120); String port = Serial.list(); serial = new Serial(this, port, 9600); } void draw() { if (mousePressed == true) { //если мы кликнули мышкой в пределах окна serial.write("1"); //отсылаем 1 println("1"); } else { //если щелчка не было serial.write("0"); //отсылаем 0 } }
Теперь напишем скетч для Arduino.
Char commandValue; // данные, поступаемые с последовательного порта int ledPin = 13; // встроенный светодиод void setup() { pinMode(ledPin, OUTPUT); // режим на вывод данных Serial.begin(9600); } void loop() { if (Serial.available()) { commandValue = Serial.read(); } if (commandValue == "1") { digitalWrite(ledPin, HIGH); // включаем светодиод } else { digitalWrite(ledPin, LOW); // в противном случае выключаем } delay(10); // задержка перед следующим чтением данных }
Запускаем оба скетча. Щёлкаем внутри окна и замечаем, что светодиод загорается. Можно даже не щёлкать, а удерживать кнопку мыши нажатой - светодиод будет гореть постоянно.
Обмен данными
Теперь попытаемся объединить оба подхода и обмениваться сообщениями между платой и приложением в двух направлениях.
Для максимальной эффективности добавим булеву переменную. В результате у нас отпадает необходимость постоянно отсылать 1 или 0 от Processing и последовательный порт разгружается и не передает лишнюю информацию.
Когда плата обнаружит присланную единицу, то меняем булевое значение на противоположное относительно текущего состояния (LOW на HIGH и наоборот). В else используем строку "Hello Kity", которую будем отправлять только в случае, когда не обнаружим "1".
Функция establishContact() отсылает строку, которую мы ожидаем получить в Processing. Если ответ приходит, значит Processing может получить данные.
Char commandValue; // данные, поступаемые с последовательного порта int ledPin = 13; boolean ledState = LOW; //управляем состоянием светодиода void setup() { pinMode(ledPin, OUTPUT); Serial.begin(9600); establishContact(); // отсылаем байт для контакта, пока ресивер отвечает } void loop() { // если можно прочитать данные if (Serial.available() > 0) { // считываем данные commandValue = Serial.read(); if (commandValue == "1") { ledState = !ledState; digitalWrite(ledPin, ledState); } delay(100); } else { // Отсылаем обратно Serial.println("Hello Kitty"); } delay(50); } void establishContact() { while (Serial.available() <= 0) { Serial.println("A"); // отсылает заглавную A delay(300); } }
Переходим к скетчу Processing. Мы будем использовать метод serialEvent() , который будет вызываться каждый раз, когда обнаруживается определенный символ в буфере.
Добавим новую булеву переменную firstContact , которая позволяет определить, есть ли соединение с Arduino.
В методе setup() добавляем строку serial.bufferUntil("\n"); . Это позволяет хранить поступающие данные в буфере, пока мы не обнаружим определённый символ. В этом случае возвращаем (\n), так как мы отправляем Serial.println() от Arduino. "\n" в конце значит, что мы активируем новую строку, то есть это будут последние данные, которые мы увидим.
Так как мы постоянно отсылаем данные, метод serialEvent() выполняет задачи цикла draw() , то можно его оставить пустым.
Теперь рассмотрим основной метод serialEvent() . Каждый раз, когда мы выходим на новую строку (\n), вызывается этот метод. И каждый раз проводится следующая последовательность действий:
- Считываются поступающие данные;
- Проверяется, содержат ли они какие-то значения (то есть, не передался ли нам пустой массив данных или "нуль");
- Удаляем пробелы;
- Если мы первый раз получили необходимые данные, изменяем значение булевой переменной firstContact и сообщаем Arduino, что мы готовы принимать новые данные;
- Если это не первый приём необходимого типа данных, отображаем их в консоли и отсылаем микроконтроллеру данные о клике, который совершался;
- Собщаем Arduino, что мы готовы принимать новый пакет данных.
При подключении и запуске в консоли должна появится фраза "Hello Kitty". Когда вы будете щёлкать мышкой в окне Processing, светодиод на пине 13 будет включаться и выключаться.
Кроме Processing, вы можете использовать программы PuTTy или написать свою программу на C# использованием готовых классов для работы с портами.
04.Communication: Dimmer
Пример демонстрирует, как можно посылать данные из компьютера на плату для управления яркостью светодиода. Данные поступают в виде отдельных байтов от 0 до 255. Данные могут поступать от любой программы на компьютере, которая имеет доступ к последовательному порту, в том числе от Processing.
Для примера понадобится стандартная схема с резистором и светодиодом на выводе 9.
Скетч для Arduino.
Const int ledPin = 9; // светодиод на выводе 9 void setup() { Serial.begin(9600); // устанавливаем режим на вывод pinMode(ledPin, OUTPUT); } void loop() { byte brightness; // проверяем, есть ли данные от компьютера if (Serial.available()) { // читаем последние полученные байты от 0 до 255 brightness = Serial.read(); // устанавливаем яркость светодиода analogWrite(ledPin, brightness); } }
Код для Processing
Import processing.serial.*; Serial port; void setup() { size(256, 150); println("Available serial ports:"); println(Serial.list()); // Uses the first port in this list (number 0). Change this to select the port // corresponding to your Arduino board. The last parameter (e.g. 9600) is the // speed of the communication. It has to correspond to the value passed to // Serial.begin() in your Arduino sketch. port = new Serial(this, Serial.list(), 9600); // Если вы знаете имя порта, используемой платой Arduino board, то явно укажите //port = new Serial(this, "COM1", 9600); } void draw() { // рисуем градиент от чёрного к белому for (int i = 0; i
Запускаем и водим мышкой над созданным окном в любую сторону. При движении влево яркость светодиода будет уменьшаться, при движении вправо - увеличиваться.
04.Communication: PhysicalPixel (Зажигаем светодиод мышкой)
Немного изменим задачу. Будем проводить мышкой над квадратом и посылать символ "H" (High), чтобы зажечь светодиод на плате. Когда мышь покинет область квадрата, то пошлём символ "L" (Low), чтобы погасить светодиод.
Код для Arduino.
Const int ledPin = 13; // вывод 13 для светодиода int incomingByte; // переменная для получения данных void setup() { Serial.begin(9600); pinMode(ledPin, OUTPUT); } void loop() { // если есть данные if (Serial.available() > 0) { // считываем байт в буфере incomingByte = Serial.read(); // если это символ H (ASCII 72), то включаем светодиод if (incomingByte == "H") { digitalWrite(ledPin, HIGH); } // если это символ L (ASCII 76), то выключаем светодиод if (incomingByte == "L") { digitalWrite(ledPin, LOW); } } }
Код для Processing.
Import processing.serial.*; float boxX; float boxY; int boxSize = 20; boolean mouseOverBox = false; Serial port; void setup() { size(200, 200); boxX = width / 2.0; boxY = height / 2.0; rectMode(RADIUS); println(Serial.list()); // Open the port that the Arduino board is connected to (in this case #0) // Make sure to open the port at the same speed Arduino is using (9600bps) port = new Serial(this, Serial.list(), 9600); } void draw() { background(0); // Если курсор над квадратом if (mouseX > boxX - boxSize && mouseX boxY - boxSize && mouseY
04.Communication: Graph (Рисуем график)
Если в предыдущем примере мы посылали данные с компьютера на плату, то теперь выполним обратную задачу - будем получать данные с потенциометра и выводить их в виде графика.