Книга: Электроника для начинающих (2-е издание)
Назад: Эксперимент 33. Исследуем окружающий мир
Дальше: Что осталось без внимания
Эксперимент 34. Точные игральные кости
В этом последнем эксперименте я собираюсь переделать устройство из эксперимента 24, в котором комбинации игральных костей формировались с помощью логических микросхем. Вместо микросхем теперь мы можем написать условные и логические операторы в программе для микроконтроллера. В результате компоненты схемы превратятся в несколько строк компьютерного кода и вместо таймера 555, счетчика и трех логических микросхем нам понадобится всего один микроконтроллер. Это отличный пример для демонстрации возможностей контроллеров. Но, безусловно, по-прежнему требуются светодиоды и токоограничительные резисторы.
Что вам понадобится
• Макетная плата, монтажный провод, кусачки, инструмент для зачистки проводов, тестовые провода, мультиметр
• Стандартный светодиод (7 шт.)
• Резистор 330 Ом (7 шт.)
• Плата Arduino Uno (1 шт.)
• Ноутбук или настольный компьютер со свободным USB-портом (1 шт.)
• USB-кабель с разъемами типа А и типа В на противоположных концах (1 шт.)
Эксперимент или программирование?
Обучение путем эксперимента хорошо работает, когда вам нужно изучить реальный электронный компонент. Вы можете установить его в макетную плату, подать питание и посмотреть, что получится. Даже когда вы разрабатываете схему, то можете действовать методом «проб и ошибок», внося изменения по ходу дела.
Создание программ — это занятие другого рода. Вы должны быть дисциплинированны и логичны, иначе будете писать программный код с ошибками, и он не станет работать надежно. Также здесь необходимо все планировать наперед, в противном случае вы потеряете много времени, переделывая выполненную ранее работу или полностью отказываясь от нее.
Я не люблю планировать, но еще больше я не люблю терять время. Поэтому, я все же составляю план, а в этом заключительном проекте опишу процесс планирования подробно. Прошу извинить меня за то, что вы не получите немедленного удовольствия от простого процесса сборки компонентов и возможности увидеть результат. Но если я не поясню процесс разработки программного обеспечения, то создам ошибочное впечатление о том, что программирование проще, чем оно есть на самом деле.
Случайность
Первый вопрос кажется очевидным: «Каких конкретных действий я жду от этой программы?» Вопрос необходим, потому что если цель не вполне ясна даже вам, то микроконтроллер и подавно не сможет ее реализовать. Формулировка цели напоминает описанный в эксперименте 15 процесс написания технического задания для системы охранной сигнализации, но в случае микроконтроллера детализация должна быть больше.
Основное требование очень простое. Мне нужна программа, которая будет выбирать случайное число и показывать его с помощью светодиодов, расположение которых напоминает точки на игральном кубике.
Поскольку выбор случайного числа — это основа данной программы, то вас следует познакомить с данной темой. Давайте заглянем на сайт Arduino, где находится справка о языке. Этот раздел сайта не настолько исчерпывающий, как мне хотелось бы, но для начала сгодится.
Чтобы найти его, перейдите на главную страницу Arduino, выберите вкладку Learning (Обучение) и отыщите раздел Reference, где вы найдете секцию Random Numbers. Там вы обнаружите специально созданную для контроллера Arduino функцию под названием random ().
Вас не должно это удивлять, потому что практически все языки программирования высокого уровня имеют какую-либо встроенную функцию генерации случайных чисел, и она всегда основана на математических приемах для формирования последовательности чисел, которая продолжается очень долго, прежде чем начнет повторяться. Единственная проблема заключается в том, что поскольку эти числа создаются путем математических операций, то случайная последовательность будет начинаться с одного и того же места каждый раз, когда вы запускаете программу.
А если вы желаете, чтобы последовательность начиналась с другого числа? Для этого есть другая функция ПОД названием randomSeed () , которая запускает генератор чисел в зависимости от состояния вывода микроконтроллера, который ни к чему не подключен. Как я уже упоминал ранее, «плавающий» логический вывод улавливает окружающее электромагнитное излучение, и вы никогда не узнаете, что от него ожидать. Поэтому значение randomSeed () может оказаться в полном смысле слова случайным, и его использование даст хороший результат, но следует помнить, что «плавающий» контакт нельзя задействовать для чего-либо еще.
Отложим ненадолго вопрос о начальном значении для генератора случайных чисел. Давайте предположим, что случайное значение генерирует функция random () и затем из него формируется число в качестве выходного значения программы имитации игральных костей. Как это реализовать?
Я думаю, игрок будет нажимать кнопку, и в этот момент отобразится случайно выбранная конфигурация точек на кубике. Готово! Затем, если вам нужно «кинуть кости» повторно, вы просто нажимаете кнопку еще раз, и появляется другая, выбранная случайным образом, комбинация точек на кубике.
Это нам подходит, но выглядит не очень правдоподобно. Люди могут задаться вопросом, на самом ли деле это случайное число? Полагаю, проблема в том, что пользователь лишен возможности управлять процессом.
Вернемся к «аппаратной» версии этого устройства. Мне нравился вариант, когда после включения точки отображаются очень быстро и конфигурации нечеткие, а игрок может нажать кнопку, чтобы произвольно прервать последовательность.
Может быть, программа должна работать именно так, а не использовать функцию random () ?
Она может вести отсчет от 1 до 6 снова и снова очень быстро — как микросхема счетчика в аппаратной версии игральных костей.
Но теперь возникают другие сложности. Когда программа считает от 1 до 6, а затем повторяет счет, микроконтроллеру, как я думаю, понадобится еще несколько микросекунд, чтобы вернуться к началу цикла. Поэтому число «6» всегда будет отображаться чуть дольше, чем другие числа.
Возможно, мне удастся скомбинировать две концепции. Я могу применить генератор случайных чисел для создания последовательности чисел, а затем буду показывать их очень быстро, пока игрок не нажмет кнопку в произвольный момент.
Мне нравится этот план. Но что потом? Не придется ли добавить еще одну кнопку, чтобы перезапустить быстрое отображение чисел? Хотя, нет, это излишне: одна и та же кнопка выполнит обе операции. Нажмите, чтобы остановить, снова нажмите, чтобы перезапустить.
Видите, я все более четко представляю, какие действия должна выполнять наша программа. Теперь можно сделать следующий шаг при определении инструкций для микроконтроллера.
Алгоритм
Мне нравится составлять алгоритм в виде последовательности предложений, которые очень легко перевести на язык компьютера. Вот мой план алгоритма для программы, которую я назвал «Точные игральные кости». Имейте в виду то, что эти инструкции будут выполняться очень быстро, и в результате числа окажутся размытыми.
Основной цикл:
• Шаг 1. Выбрать случайное число.
• Шаг 2. Преобразовать его в конфигурацию точек на игральной кости и зажечь соответствующие светодиоды.
• Шаг 3. Проверить, нажата ли кнопка.
• Шаг 4. Если кнопка не нажата, вернуться к Шагу 1 и выбрать другое случайное число, чтобы быстро продолжить последовательность. Иначе...
• Шаг 5. Остановить индикацию на дисплее.
• Шаг 6. Подождать, пока игрок не нажмет кнопку повторно. После этого вернуться к Шагу 1 и повторить.
Есть ли в этой последовательности шагов какие- нибудь проблемы? Попробуйте представить ее с точки зрения микроконтроллера. Если бы вы получили инструкции из такой программы, у вас было бы все необходимое, чтобы выполнить это задание?
Нет, потому что некоторых инструкций не хватает. Шаг 2 говорит «зажечь соответствующие светодиоды», но нигде нет инструкции по их выключению!
Внимание!Вы всегда должны помнить: компьютер делает только то, что вы ему приказываете.
Если вы хотите, чтобы зажженные светодиоды выключились, прежде чем появится новое число, то должны предусмотреть такую команду.
Где она должна быть? Необходимо гасить дисплей пред выбором и отображением каждого нового числа. Поэтому правильное место для сброса дисплея находится в начале основного цикла. Добавим его так:
• Шаг 0. Выключить все светодиоды.
Но погодите. В зависимости от того, какое число отображалось на предыдущем цикле, одни светодиоды будут включены, а другие выключены. Если мы выключаем все светодиоды, чтобы очистить дисплей, то эта команда затронет также те светодиоды, которые уже выключены. Микроконтроллеру это безразлично, однако, он потратит впустую некоторое время, выполняя эту инструкцию. Возможно, было бы гораздо эффективнее выключить светодиоды, которые перед этим были включены, и проигнорировать те, которые уже и так выключены.
Однако в результате программа усложнится и, возможно, так делать не следует. На заре вычислительной техники людям приходилось оптимизировать программы, чтобы экономить циклы работы процессора, но я думаю, что теперь даже микроконтроллеры настолько быстрые, что нам не стоит беспокоиться о времени, затраченном на выключение двух-трех светодиодов, которые уже выключены. Я буду выключать все светодиоды сразу, независимо от их текущего состояния.
Обработка состояния кнопки
Что еще пропущено в списке шагов алгоритма? Кнопка.
Необходимо еще раз представить, какие действия я ожидаю от программы. На дисплее очень быстро сменяются числа. Игрок нажимает кнопку, чтобы остановить индикацию. Дисплей замирает, показывая текущее значение. На Шаге 6 микроконтроллер ждет неопределенно долго, пока игрок не нажмет кнопку снова, чтобы вновь запустить быстрое отображение.
Минуточку. Как игрок сможет нажать кнопку снова, не отпустив ее вначале?
На самом деле, если оставить текущий вариант алгоритма, то микроконтроллер будет делать следующее (учтите, что он выполняет задания очень-очень быстро):
• Программа говорит микроконтроллеру проверить кнопку.
• Микроконтроллер обнаруживает, что кнопка нажата.
• Дисплей замирает. Микроконтроллер ждет, когда кнопка будет нажата снова.
• Но он обнаруживает, что кнопка по- прежнему нажата, потому что игрок еще не успел отпустить ее.
• Микроконтроллер действует так: «Кнопка нажата, поэтому я должен возобновить быстрое отображение цифр».
В результате индикация на дисплее остановится лишь на мгновение.
Вот решение проблемы — дополнительный шаг в последовательности:
• Шаг 5А. Дождаться момента, когда игрок отпустит кнопку.
Это не даст компьютеру возможности вести дальнейший отсчет и отображать другие числа, пока игрок не будет готов.
Теперь все в порядке?
Нет, боюсь, что нет. Возможно, вам кажется, что процесс становится слишком трудоемким, но в таком случае я вынужден сказать: «извините, но таково программирование». Если кто-то говорит, что можно быстро набросать несколько команд и посмотреть, как они работают, то уверяю вас, что чаще всего это не так.
Существует еще одна проблема с кнопкой. Шаг 6 просит подождать, пока кнопка не будет нажата снова, чтобы запустить быстрое отображение. Отлично. Игрок нажимает кнопку, дисплей возобновляет индикацию цифр, но микроконтроллер настолько быстр, что он «промчится» через процесс обнуления текущего значения и отображения новой комбинации игральных костей прежде, чем игрок перестанет нажимать кнопку. В результате, когда микроконтроллер перейдет к Шагу 4, он обнаружит, что кнопка по-прежнему нажата, и снова «заморозит» дисплей.
Как быть? Возможно, мне следует добавить новый Шаг 7, который говорит микроконтроллеру подождать, пока кнопка будет отпущена, прежде чем продолжить быстрое отображение.
Это противоречит интуиции. Я не думаю, что все осознают необходимость нажать кнопку и отпустить ее, чтобы возобновилось быстрое отображение. Проще всего сказать: «Ну, вы должны делать так, потому что этого требует программа». Но это неправильный ход рассуждений.
Внимание!Программа должна делать то, что ожидает пользователь. Мы никогда не должны принуждать пользователя выполнять что-либо в угоду программе.
В любом случае, идея подождать, пока кнопка не будет отпущена, прежде чем продолжится быстрое отображение, не будет работать. Не забывайте, что есть еще одна проблема: дребезг контактов. Он возникает, когда кнопку нажимают и когда отпускают. Вследствие этого, если кто-то отпустит кнопку и процесс продолжится, программа спустя миллисекунду снова проверит кнопку, контакты которой могут все еще создавать вибрацию, и они могут оказаться как в разомкнутом, так и в замкнутом состоянии.
Вот до чего доходит, когда микроконтроллер взаимодействует с материальным миром. Микроконтроллер желает, чтобы все было четким и стабильным, но наш мир неточен и нестабилен. Я долго раздумывал над этой конкретной проблемой, прежде чем нашел варианты ее решения.
Один из них — вернуться к двум кнопкам: одна для запуска быстрого отображения, а другая для остановки. В этом случае, как только кнопка «Запуск» будет нажата, микроконтроллер может игнорировать ее состояние и дребезг контактов, ожидая нажатия кнопки «Стоп». Но с точки зрения игрока было бы проще обходиться одной кнопкой. В самом деле, как это сделать?
Я вернулся к подробному описанию того, чего я ожидаю от программы, и сказал себе: «Я хочу, чтобы программа возобновляла быстрое отображение, когда кнопку нажмут во второй раз. Но после этого программа должна игнорировать эту кнопку, пока ее не отпустят и не прекратится дребезг ее контактов».
Почему бы просто не заблокировать кнопку на секунду или две? Собственно, это хорошая мысль, поскольку случайная последовательность чисел должна немного продолжиться, прежде чем игрок сможет остановить ее снова.
Отображение будет выглядеть «более случайным», пока оно высвечивает все эти числа.
Допустим, я заблокировал кнопку, скажем, на две секунды после запуска быстрого отображения. Шаг 4 следует переписать как:
• Шаг 4. Если кнопка не была нажата ИЛИ если быстрое отображение продолжается менее 2 секунд, вернуться в начало и выбрать другое случайное число. Иначе...
Обратите внимание на слово ИЛИ. Здесь нужна именно эта логическая операция.
Системное время
Думаю, мы решили все проблемы с кнопками, но теперь у нас появилась новая проблема. Необходимо отмерить 2 секунды.
Есть ли у микроконтроллера системные часы? Возможно, есть. Может быть, язык С даст к ним доступ и поможет отмерить временной интервал.
Заглянем в справочные материалы по этому языку. Да, есть функция под названием mil- list), которая отсчитывает миллисекунды. Она работает как часы, начиная с нуля при каждом запуске программы. Эта функция способна принимать очень большие значения: она дойдет до предела и начнет отсчет заново не ранее чем через 50 дней. Этого, безусловно, достаточно.
Но нет, есть еще одна маленькая загвоздка. Плата Arduino не позволяет мне сбросить системные часы по запросу. Когда программа запускается, часы начинают отсчет как секундомер, но в отличие от секундомера, их нельзя остановить.
Как решить эту проблему? Придется действовать так же, как я обычно поступаю с настенными часами на кухне. Когда я хочу приготовить яйцо вкрутую, я мысленно отмечаю момент закипания воды. Предположим, это 17:02, и я хочу сварить яйцо за 7 минут. Я рассуждаю так:
«17:02 плюс 7 минут — это 17:09, поэтому я вытащу яйцо в 17:09». Я сравниваю показания часов, которые продолжают идти, с предельным сроком 17:09 и спрашиваю себя: «На часах уже 17:09»? Если время на часах 17:09 или больше, то яйцо приготовлено.
В программе для игральных костей это можно сделать так — предусмотреть переменную, которая будет запоминать время (как в начале процесса варки яйца). Незадолго до начала быстрого отображения я сохраняю текущее значение системного времени в такой переменной, добавив две секунды. Затем я могу приказать программе узнавать, достигло ли системное время значения, хранящегося в моей переменной, пока оно его не достигнет.
Предположим, я назову эту переменную ignore, поскольку она будет сообщать мне о том, через какое время программа должна перестать игнорировать кнопку. Тогда на Шаге 4 можно спросить микроконтроллер: «Системное время уже превысило значение переменной ignore?», и если это так, программа может возобновить слежение за кнопкой.
Я не могу сбросить системные часы, но я могу задать значение переменной ignore так, чтобы оно совпадало с текущим значением minis о плюс две секунды каждый раз, когда начинается новый цикл быстрого отображения.
Окончательный вариант алгоритма
Учитывая все сказанное, привожу пересмотренную и, надеюсь, окончательную последовательность событий для программы:
• Перед началом цикла задать вход и выход у логических выводов, а также присвоить переменной ignore значение текущего времени плюс две секунды.
• Шаг 0. Выключить все светодиоды.
• Шаг 1. Сформировать случайное число.
• Шаг 2. Преобразовать его в конфигурацию точек на игральных костях и зажечь соответствующие светодиоды.
• Шаг 3. Проверить, нажата ли кнопка.
• Шаг 4. Проверить, достигло ли системное время значения переменной ignore.
• Шаг 4а. Если кнопка не была нажата ИЛИ если системное время не достигло значения переменной ignore, вернуться к Шагу 1. Иначе...
• Шаг 5. «Заморозить» дисплей.
• Шаг 5а. Подождать, пока игрок отпустит кнопку.
• Шаг 6. Подождать необходимое время, пока игрок не нажмет кнопку еще раз, чтобы перезапустить дисплей.
• Шаг 7. Присвоить переменной ignore значение системного времени плюс две секунды.
• Вернуться к Шагу 0.
Как вы думаете, будет ли все это работать? Давайте выясним.
Настройка аппаратного обеспечения
На рис. 5.92 показаны семь светодиодов, смонтированных на макетной плате, чтобы отображать точки игрального кубика. Принцип тот же, что и на рис. 4.142, за исключением того, что каждый выход микросхемы Arduino может обеспечить ток 40 мА, поэтому мне не придется соединять светодиоды последовательно. Один выход может без проблем питать пару параллельных светодиодов, и для каждого стандартного светодиода достаточно резистора 330 Ом.
Нумерация проводов та же, что и в системе нумерации на рис. 4.142. Она не имеет ничего общего со значениями на гранях кубика. Это всего лишь выбранный способ идентификации каждого провода. К тому же, можно подключить провода с первого по четвертый к цифровым выходам под номерами с 1 по 4 на плате Arduino Uno. Это поможет избежать лишних ошибок.
Рис. 5.92. Семь светодиодов, смонтированных на макетной плате для отображения конфигураций точек игрального кубика
В качестве входа, который проверяет состояние кнопки, я выбрал цифровой контакт 0 на плате Arduino Uno. Заметьте, однако, что плата Uno использует цифровые выводы 0 и 1, когда получает данные по USB-кабелю. Если у вас возникнут проблемы с загрузкой программы, то временно отключите провод от цифрового контакта 0.
Не подключайте пока провод заземления макетной платы к плате Arduino Uno. Безопаснее сначала загрузить программу, потому что она сообщит микроконтроллеру, какие из выводов будут выходными, а какие входными. Программа, загруженная ранее, могла настроить их по- другому, и как только вы подключите плату Arduino, она будет стремиться запустить любую программу, которую обнаружит в своей памяти. Это может оказаться небезопасным для выходов Arduino.
Внимание!Вы должны быть очень внимательны, чтобы не подать напряжение на цифровой вывод, который сконфигурирован как выход.
А теперь — программа
В листинге 5.3 приведена программа с комментариями, которую я написал в соответствии с алгоритмом. В листинге 5.4 приведен тот же код, но уже без комментариев, чтобы вы смогли быстрее набрать его. Пожалуйста, введите его в окне редактирования среды IDE.
Листинг 5.3
Листинг 5.4
При наборе текста программы вы заметите, что второй оператор if содержит символ, который вы раньше не видели. Возможно, вы даже никогда раньше не набирали его с клавиатуры. Это вертикальная линия. На клавиатуре для ПК под управлением операционной системы Windows вы найдете ее над клавишей <Enter>. Чтобы ввести этот символ, удерживайте клавишу <Shift> и нажмите клавишу с обратной косой чертой. В этом листинге присутствуют две пары таких символов во втором операторе if, и я объясню их, когда мы будем построчно разбирать программу. Когда вы завершите набор, выполните команду Скетч | Проверить/ Компилировать (Sketch | Verify/Compile), чтобы проверить, нет ли ошибок.
Некоторые сообщения об ошибках трудно понять, и они ссылаются на номера строк. Но эти номера не отображаются на экране! Это похоже на злую шутку: сказать, в какой строке ошибка, но не показывать ее номер. Может быть, существует способ включить отображение нумерации строк? Если вы заглянете в раздел Помощь (Help) и поищете фразу «нумерация строк», то вряд ли найдете что-либо. Посетите форумы Arduino, и вы обнаружите многочисленные жалобы на отсутствие возможности отобразить нумерацию строк.
Да, но на форумах вначале видны старые сообщения. Если вы прокрутите страницу вниз, к новым сообщениям, то вы обнаружите, что проблема наконец-то решена. Просто компания Arduino пока еще не отразила это в документации. Перейдите в раздел Файл | Настройки (File | Preferences), и вы увидите флажок включения нумерации строк.
Конечно, сообщение об ошибке бывает трудно понять, но вот перечень самых распространенных ошибок:
• Отсутствует точка с запятой в конце инструкции.
• Нет закрывающей скобки. Помните о том, что фигурные скобки { и } должны всегда быть в паре.
• Неправильный регистр символов. Хотя командное слово часто содержит прописные буквы наряду со строчными, как В pinMode, вы могли набрать все строчными буквами. Среда IDE должна отображать командные слова красным, если они написаны правильно. Если вы видите, что оно черное, значит в нем опечатка.
• Отсутствие круглых скобок после названия функции, например, void loop().
• Одиночный знак = там, где должен быть двойной == Помните о том, что = означает «присвоить значение», в то время как == означает «сравнить значения».
• Один символ | или & там, где они должны быть в паре.
После того как операция проверки и компилирования не обнаружит дополнительных ошибок, загрузите программу. Теперь подключите заземляющий провод, соединяющий макетную плату с платой Arduino Uno, светодиоды должны начать мигать. Подождите несколько секунд, а затем нажмите кнопку — отображение остановится, показав случайную конфигурацию точек. Нажмите кнопку снова, и быстрое отображение возобновится. Удерживайте кнопку, и после двухсекундного периода игнорирования дисплей остановится снова. Алгоритм успешно реализован!
Теперь рассмотрим, как работает эта программа.
Короткие и длинные целые числа
В программе из листинга 5.3 есть несколько ключевых слов, которые вы не встречали ранее, и одно очень важное новое понятие.
Одно из новых слов — long. До этого перед каждым именем переменной вы указывали int (означающее integer — целое число). Но значения чисел int ограничены диапазоном от -32 768 до +32 767. Когда вам нужно хранить большее значение, используется длинное целое число, которое допускает диапазон значений от - 2 147 483 648 до 2 147 483 627.
Почему бы не применять длинные целые числа всюду? Тогда нам не нужно было бы беспокоиться об ограничениях обычного числа. Это так, но длинные числа обрабатываются в два (а то и более) раза дольше и занимают в два раза больше памяти. А у микроконтроллера Atmel объем памяти невелик.
Функция millis() служит для подсчета миллисекунд. Если мы позволим ей считать только до 32 767, то этого хватит лишь на полминуты. Возможно, нам понадобится больше времени, поэтому функция хранит свое значение в виде длинного числа. (Откуда я это знаю? Я прочитал справку по языку программирования. Чтобы овладеть компьютерным языком, необходимо читать документацию.)
Когда я ввел переменную ignore, чтобы запоминать текущее значение системного времени, ее следовало определить так, чтобы она была совместима с функцией времени; поэтому она определена как длинное целое число с помощью слова long.
Что произойдет, если вы попытаетесь сохранить число, которое находится вне пределов дозволенного диапазона для целого числа (или длинного целого)? Ваша программа выдаст непредсказуемый результат. Предотвратить это можете только вы.
Начальная настройка
Раздел начальной настройки в нашей программе достаточно простой. Ранее вы не использовали команды pinMode(), но они просты для понимания.
Первая содержит очень полезный параметр INPUT_PULLUP, который активирует встроенный в микроконтроллер подтягивающий резистор, поэтому вам не нужно добавлять этот резистор самостоятельно. Но учтите, это повышающий резистор, а не понижающий. Поэтому состояние входа является нормально высоким, и когда вы нажимаете кнопку, она должна заземлять этот вывод микросхемы, чтобы сделать его низким. Запомните:
• Когда кнопка нажата, функция digitalRead() возвращает значение LOW.
• Когда кнопка отпущена, функция digitalRead() возвращает значение HIGH.
Цикл for
Перед функцией void loop() есть еще цикл другого типа. Он называется циклом for, потому что он начинается со слова for. Это очень простой и удобный способ заставить микроконтроллер отсчитывать ряд чисел, сохраняя каждое новое число в переменной и стирая предыдущее значение. Синтаксис следующий:
• Зарезервированное слово for сопровождается тремя параметрами в круглых скобках.
• Каждый параметр отделен от следующего точкой с запятой.
• Первый параметр — это первое значение, которое будет сохранено в указанной переменной. (Часто оно называется начальным значением.) В данной программе первое значение — это 1, оно сохраняется в созданной мною переменной по имени outpin.
• Второй параметр — это значение, при котором цикл прекращает счет (часто называется условием остановки). Поскольку цикл останавливается в этой точке, окончательное значение переменной будет меньшим, чем предельное значение. В этой программе предел записан как < 5, что означает «меньше 5». Поэтому цикл будет вести отсчет от 1 до 4, используя переменную outpin.
• Третий параметр — это число, которое прибавляется к переменной на каждом цикле (называется величиной итерации). В данном случае мы на каждой итерации увеличиваем значение переменной цикла на единицу, и язык С позволяет мне указать это, написав два символа ++. Поэтому outpin++ означает «прибавить 1 к значению переменной output на каждом шаге».
Циклы for позволяют вам указать любые условия. Они исключительно гибкие. Почитайте об этом в разделе справки по языку программирования. Наш цикл for просто считает от 1 до 4, но он мог бы также считать от 100 до 400 или в любом другом диапазоне, каком пожелаете, ограниченном типом целого числа, заданного В цикле (int ИЛИ long).
На каждой итерации микроконтроллеру указывается, что делать. Выполняемая процедура приведена в фигурных скобках после определения цикла (тело цикла). Как и любая другая процедура, она может содержать несколько операций, каждая из которых заканчивается точкой с запятой. В данной процедуре только одна операция: записать состояние LOW для контакта, указанного в переменной outpin. Поскольку переменная outpin изменяется от 1 до 4, цикл for создает низкий выходной сигнал на выводах с 1 по 4.
Ага, вот теперь понятно, для чего это все. Цикл выключает все светодиоды.
А нельзя ли сделать это проще? Безусловно, можно было бы написать друг за другом четыре команды:
digitalWrite (1, LOW);digitalWrite (2, LOW);digitalWrite (3, LOW);digitalWrite (4, LOW);
Но мне хотелось познакомить вас с понятием цикла for, поскольку оно основное и важное. А если бы вам понадобилось выключить девять светодиодов? Или если бы вы захотели, чтобы микроконтроллер мигнул светодиодом 100 раз? Цикл for зачастую предоставляет лучший способ повысить эффективность процедуры, которая содержит повторяющиеся операции.
Функция генератора случайных чисел
После того как цикл for погасит светодиоды, мы переходим к функции random (), выбираю- щей число, которое заключено в пределах, указанных в круглых скобках. Нам необходимо значение от 1 до 6, но почему же этот диапазон указан от 1 до 7? Потому что на самом деле эта функция выбирает величины с дробной частью, от 1,00000001 до 6,99999999, а затем отбрасывает ту часть числа, которая следует за десятичной запятой. Поэтому 7 — это предел, который никогда не будет достигнут, и значение на выходе окажется от 1 до 6.
Каким бы ни было случайное число, оно сохраняется в другой специально созданной переменной с именем spots, означающей число точек на грани кубика.
Оператор сравнения if
Теперь пришло время узнать, какое сейчас значение у переменной spots, и включить соответствующие светодиоды.
Первый оператор if достаточно прост. Если у нас шесть точек, то это единственный случай, когда мы записываем высокое состояние через выход 1, который подключен к светодиодам справа и слева.
Почему мы не включаем также и все диагональные светодиоды? Суть в том, что они будут включены при других значениях кубика, и гораздо эффективнее свести к минимуму количество проверок if. Скоро вы поймете, как это работает.
Следующий оператор if использует символ прямой черты, о котором я упоминал ранее. Пара символов I I на языке программирования С означает ИЛИ. Поэтому данная функция говорит: «Если у нас есть значение 1, ИЛИ 3, ИЛИ 5, мы включаем центральный светодиод, переводя вывод 2 в высокое состояние».
Третий оператор if говорит о том, что если значение spots больше трех, следует включить два светодиода, расположенных по диагонали. Это необходимо для отображения конфигурации точек для числа 4, 5 или 6.
Последний оператор if говорит о том, что если значение spots больше единицы, должны также зажечься и другие светодиоды, расположенные по диагонали.
Вы можете проверить логику этих функций сравнения, взглянув на конфигурации точек на рис. 4.142. Логические элементы на этом рисунке были подобраны так, чтобы соответствовать двоичному выходу микросхемы счетчика, и поэтому они отличаются от логических операций в функциях сравнения рассматриваемой программы. Тем не менее, светодиоды объединены в пары аналогичным образом.
Скорость мигания
После функций сравнения я вставил задержку в 20 миллисекунд, потому что считаю, что это сделает отображение более интересным. Без этой задержки светодиоды будут мигать так быстро, что отдельные значения окажутся неразличимы. При наличии задержки вы увидите их мигание, но оно по-прежнему будет слишком быстрым, и вам не удастся остановить его на том номере, который хотите угадать — хотя можете попробовать. Можете также настроить параметр задержки, указав число больше или меньше 20.
Создание новой функции
Теперь мы переходим к важной части. В написанном мною алгоритме мы дошли до Шагов 3, 4 и 4а. Напомню:
• Шаг 3. Проверить, нажата ли кнопка.
• Шаг 4. Проверить, достигло ли системное время значения переменной ignore.
• Шаг 4а. Если кнопка не была нажата ИЛИ если системное время не достигло значения переменной ignore, вернуться к Шагу 1. Иначе...
Эти шаги можно скомбинировать в одной функции сравнения if. Алгоритм выглядел бы так:
• Если (кнопка не нажата ИЛИ системное время меньше значения ignore), вернуться к Шагу 0.
Но здесь есть проблема. Фраза «вернуться к» предполагает отсылку микроконтроллера к указанной части программы. Казалось бы, естественная команда, но когда вы программируете на языке С, следует избегать передачи управления из одной части программы в другую.
Причина в том, что обилие команд «перейти туда» или «перейти сюда» усложняет понимание программы — не только для других людей, но и для вас самих, когда вы взглянете на нее снова через полгода и не сможете вспомнить, что имелось в виду.
Концепция языка С заключается в том, что каждая часть программы содержится в отдельном блоке и программа запускает их при помощи вызовов по вашему запросу. Воспринимайте каждый блок команд как послушного слугу, который выполняет только одно дело: мытье посуды или вынос мусора. Когда требуется выполнить определенное задание, вы просто зовете слугу по имени.
Такие блоки обычно называются функциями, что немного сбивает с толку, потому что мы уже имели дело с функциями setup() и loop(). Фактически, вы можете написать собственную функцию, которая будет работать в целом по такому же принципу.
Я решил, что будет правильнее написать эту программу, выделив функцию проверки статуса в отдельную... хм... функцию. Я назвал ее checkbutton(), но мог бы назвать как угодно, если только ее название уже не зарезервировано для другой цели.
Вы видите функцию checkbutton() в нижней части листинга 5.3 с предшествующим ей словом void, потому что эта функция не возвращает никакого значения в остальную часть программы.
Слова void checkbutton() — это заголовок функции, после которого, как обычно, в фигурных скобках содержится сама процедура. Эта функция выполняет следующее:
• Ждет 50 мс, пока прекратится дребезг контактов.
• Ожидает, пока будет отпущена кнопка.
• Ждет еще 50 мс, пока прекратится дребезг контактов отпущенной кнопки.
• Ждет, пока кнопка будет нажата снова (другими словами, ожидает завершения отпущенного состояния).
• Сбрасывает переменную ignore.
Когда микроконтроллер доходит до конца этой функции, куда он идет дальше? Все просто: он возвращается к строке, расположенной сразу за той, из которой была вызвана функция. Где она? Сразу под функцией сравнения, выше. Так и происходит вызов функции: вы просто указываете ее имя (включая круглые скобки, внутри которых иногда содержатся параметры, хотя в данном случае их нет).
Вы можете и должны создавать столько функций в программе, сколько пожелаете, используя каждую для выполнения отдельной задачи. Чтобы узнать об этом, рекомендую прочитать любые общие руководства по языку С. Документация к среде Arduino не описывает функции детально, потому что они сложны для понимания, когда речь заходит о передаче значений. Тем не менее, это основополагающая конструкция языка С.
Структура программы
Строка, которая начинается с if ( millis() > ignore, предназначена для того же, что и Шаг 4 в моем алгоритме, но теперь все работает по- другому. Вместо того чтобы решить, отправлять ли микроконтроллер обратно к началу программы, принимается решение, вызывать ли функцию checkbutton(). Ранее я резюмировал ее логику так: «Если (кнопка не нажата ИЛИ системное время меньше значения ignore), вернуться к Шагу 0». Пересмотренный вариант гласит: «Если превышен период игнорирования кнопки И кнопка нажата, перейти к функции к checkbutton()».
После того как микроконтроллер выполнит это и вернется, он достигнет конца основной функции loop, которая всегда повторяется автоматически.
На самом деле эта программа выполняет только одну задачу. Она выбирает случайные числа и отображает их в виде конфигурации точек снова и снова. Если кнопка нажата, то программа делает паузу и ждет, а когда кнопку нажмут снова, программа продолжает делать то, что делала раньше. Процедура проверки кнопки — всего лишь кратковременный перерыв.
Поэтому, естественная структура для этой программы — основной цикл, который выбирает и отображает цифры, и если кнопка нажата, микроконтроллер отправляется к функции checkbutton(), а затем возвращается к основному циклу.
Документация среды Arduino ничего не говорит о структуре программы, потому что подразумевает наличие базовых знаний программирования. Поэтому среда Arduino просто требует указать обязательную функцию setup, за которой следует функция loop, и все.
Но как только программа увеличится в размере, вам обязательно понадобится разделить ее на подходящие функции, чтобы она не превращалась в запутанный «клубок» операторов. Стандартное руководство по языку С объяснит все более детально.
Безусловно, если поставленная задача не слишком сложна, например, включение нагревателя, когда в комнате становится прохладно, вы можете поместить все процедуры внутри основной функции loop, и этого будет достаточно. Но при этом возможности микроконтроллера задействованы не полностью. Он ведь способен выполнить намного больше. Проблема в том, что когда вы пытаетесь сделать что-то более амбициозное, например, сымитировать бросок игрального кубика, операторов становится намного больше и обязательно потребуется их структурировать.
Есть еще одно преимущество разделения программы на функции. Можно сохранить функции отдельно и использовать их в других программах в дальнейшем. Функция checkbutton() пригодится в любой игре, где вы хотите останавливать ход путем нажатия кнопки и возобновлять игру повторным нажатием.
Подобным же образом вы можете в своих программах использовать функции других людей, при условии, что авторы не запрещают вам это, контролируя свое авторское право. Большое количество функций на языке С доступно бесплатно в онлайн-источниках, многие из них написаны специально для среды Arduino. Например, есть функции для управления почти всеми алфавитно-цифровыми дисплеями. Это приводит к очень важному, но часто игнорируемому совету для программистов: не изобретайте велосипед. Вам не нужно тратить время, чтобы создавать свою функцию, если кто-либо разрешает вам взять уже готовую. Это еще одна причина, по которой понятие функции так важно в языке С.
Сложно ли создавать программы?
Чем больше программ вы создаете, тем проще это дается. Вначале все кажется слишком сложным, но после некоторой практики цикл for получится у вас без долгих раздумий. Все станет очевидным. Так любят говорить программисты. Но так ли это?
Иногда да, а иногда нет. В сообществе умельцев (maker movement) мы склонны считать, что любой может управлять окружающим нас техномиром. Я тоже разделяю это мнение, но компьютерное программирование доводит эту философию до крайних пределов.
Я вел курсы начального программирования и отметил очень широкий спектр способностей у студентов. Для некоторых программирование было естественным процессом мышления, в то время как другие считали его чрезвычайно сложным, и это не всегда было связано с уровнем интеллекта.
На одном конце шкалы — случай, когда после 12-недельного 36-часового курса программирования один студент создал программу имитации игрового автомата, которая формировала графическое изображение вращающихся колес и сыплющихся денег.
На другом конце шкалы — студент-фармацевт, очень толковый, с хорошим образованием. Но как он ни старался, ему не удавалось написать правильно даже простые операторы сравнения. Он говорил: «Это раздражает меня, потому что заставляет чувствовать себя дураком. Но я знаю, что я не дурак».
Он был прав в том, что он не глупый, но я пришел к заключению, что не смогу ему помочь, потому что выяснил одну фундаментальную закономерность.
СоветЧтобы хорошо писать программы, вы должны уметь думать как компьютер.
По какой-то причине фармацевт этого не мог. Его мозг работал иначе. Он мог описать фармакологические свойства какого-либо лекарственного средства, его молекулярную структуру и многое другое, но это не помогало ему в написании программ.
Когда на рынке появился микроконтроллер Arduino, пропагандисты описывали его как устройство для творческих людей и для тех, кто не считает себя программистом. Предполагалось, что он настолько прост, что любой сможет им воспользоваться.
Я уже немолод и помню, что при внедрении стандарта HTML продвигалась та же идея — он будет настолько прост, что любой сможет написать код для своих веб-страниц. Ну да, некоторые так и поступали, но далеко не все. Сегодня лишь малая часть пользователей набирает HTML-код вручную (я один из них, но в этом проявляется моя эксцентричность).
Если углубиться в историю, то на заре вычислительной техники язык программирования BASIC был создан с идеей, что все смогут его использовать. В 80-х годах прошлого века с появлением настольных компьютеров приверженцы этого языка предсказывали, что люди будут писать небольшие программы на нем, чтобы проверить баланс на банковском счете или сохранить рецепт. Да, пробовали многие, но сколько людей до сих пор так поступают?
Если вы считаете программирование сложным занятием, то, поверьте мне, это отнюдь не «клеймо позора». Уверен, у вас есть другие навыки, в которых вы гораздо сильнее. На самом деле, конструирование изделий из отдельных компонентов может быть одним из таких навыков, поскольку, как я считаю, для этого требуются другие мыслительные процессы. Лично для меня написание программ легче, чем проектирование схем, но для кого-то другого обратное будет в равной степени справедливо.
Улучшение программы «Точные игральные кости»
Как и в эксперименте 24, очевидное улучшение — добавление дисплея для второго игрального кубика. Это можно очень легко сделать с помощью платы Arduino, потому что она имеет дополнительные цифровые выходы, которые могут управлять второй группой светодиодов. Вам нужно лишь продублировать раздел программы, который начинается с обнуления индикатора и заканчивается функцией delay(20). Подставьте новые номера контактов для дополнительных светодиодов В функциях digitalWrite () и дело сделано!
Другие микроконтроллеры
Я уже упоминал микроконтроллер PICAXE. У него добротная документация и превосходная техническая поддержка, а язык легче для изучения, чем С. Так почему же этот продукт не стал таким популярным? Не знаю; возможно, потому что у него непонятное название. Может быть, вам удастся выяснить причину, начните с прочтения статьи на сайте Wikipedia.
Микроконтроллер BASIC Stamp по сравнению с PICAXE содержит расширенный набор команд и больший ассортимент дополнительных устройств (в их число входят графические дисплеи, а также миниатюрная клавиатура, которая специально предназначена для работы с контроллером). Вы можете купить их в виде компонентов для поверхностного монтажа, установленных на миниатюрной плате, которая вставляется в макетную плату (рис. 5.93). Очень продуманная конструкция.
Рис. 5.93. Миниатюрная плата с контроллером BASIC Stamp
С другой стороны, все связанное с микроконтроллером BASIC Stamp немного дороже, чем у PICAXE, а процесс загрузки совсем не простой.
Новые продукты, такие как Raspberry Pi, расширяют функциональность микроконтроллера до такой степени, что он становится настоящим компьютером. К тому моменту, когда вы будете читать эти строки, в этой быстроразвивающейся области появится еще больше альтернатив. Прежде чем вы посвятите себя детальному изучению одной из них, думаю, что неплохо потратить день или два на ознакомление с онлайн-документацией и сообщениями на форумах.
Когда я намереваюсь изучить что-либо новое, я делаю поисковый запрос в сервисе Google, Например такой: Микроконтроллер Проблемы или Сложности. В поисковой фразе вместо слова «микроконтроллер» можно подставить название реального продукта. Это не потому, что я пессимист по натуре. Просто мне не хочется тратить много времени на продукт, который имеет нерешенные проблемы.
