• Что можно приготовить из кальмаров: быстро и вкусно

    Любой домашний разработчик микроэлектроники, рано или поздно сталкивается с необходимостью управления своим, созданным своими руками, устройством посредством некоего пульта, которым будет удобно переключать режимы работы или же просто просматривать текущее состояние. Вообще, словосочетание «домашний разработчик микроэлектроники» еще лет 15 тому назад, вызывало бы жуткий хохот, ведь в то время и помыслить никто не мог, что дома кто-то будет возиться с миниатюрными платами, заниматься прошивками, да и вообще. А оказалось, что единичные энтузиасты превратились в сонмы увлеченных людей, а само дело получило массовый оборот.

    Но годы прошли и упертые компании создали настоящую нишу, целый рынок, в котором варятся миллионы увлеченных непрофессионалов, с упоением собирающих очередной «девайс на ардуинке». Вот именно у таких энтузиастов, платящих длинные баксы производителям шилдов да датчиков, и возникает потребность в управлении своими умными устройствами при помощи пульта. И как ни странно их потребность была удовлетворена наиболее изящным из возможных способов. На свет появился Blynk.

    Приложение Blynk

    Что дает Blynk любителю домашней автоматизации? Ответ на поставленный вопрос - двоякий. С одной стороны - совсем не много, а вот с другой, немного превращается чуть ли не в половину «стоимости» всего реализованного проекта. Blynk позволяет превратить обычный смартфон или планшет, под управлением Android или iOS, в настоящий пульт управления самостоятельно разрабатываемой электроники. Blynk очень удачно вписался в экоструктуру Arduino и появился в самый подходящий момент.

    По сути, Blynk есть ни что иное, как приложение под мобильное устройство, позволяющее в форме графического конструирования создавать полнофункциональные приложения для связи их с устройствами на платформе Arduino и совместимыми (по правде сказать, скоро совместимых платформ станет куда больше). Основной фишкой Blynk я смело могу назвать простоту, с которой создается как само приложение, так и то, как реализуется связь с программным кодом в устройстве.

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

    На стороне устройства достаточно только подключить библиотеку, настроить связку между исходным кодом и регистрационным кодом установленного приложения, поместить в цикл обработчик событий, да… Да в общем-то и все. Если приложение привязано только к физическим пинам, то больше и делать ничего не надо.

    Вот так вот просто, вы получаете удобный пульт управления своим устройством, способный не только отправлять команды на него, но и отображать все, что потребуется на своем экранчике. Разработчики даже не стали заморачиваться на продвинутую и подробную документацию. Все собрано в виде единого документа на одной странице сайта Blynk . Ну, что же, за простоту реализации разработчикам я посылаю полноценный «респект»!

    Откуда взялся Blynk?

    Появление Blynk произошло не по чистой случайности. Я бы даже отметил, что появление Blynk на свет - есть ни что иное, как образцовый, счастливый случай удачного краудфандинга. Некий Паша Байдурин, надеюсь, что фамилию не исковеркал, завел кампанию на Kikstarter со скромной суммой сбора всего в 10.000$. В итоге, кампания набрала сумму в пятеро большую, что позволило развернуться на полную катушку. Сбор средств стартовал в середине января 2015 и уже к концу месяца набрал требуемый объем средств. Вот именно таким способом мозги и побеждают бабло, мотайте на ус.

    За чуть меньше, чем год, а я пишу обзор в декабре 2016, Blynk успел подрасти, обзавестись всеми необходимыми атрибутами и, я надеюсь, смог побороть проблему роста и превратился в полноценную корпорацию. По крайней мере, теперь Blynk предлагается не только для физических, но и для юридических лиц. Модели монетизации для разных типов пользователей различаются, но об этом ниже.

    Уникальность бизнес модели

    Так чем же еще уникален Blynk, кроме как возможностью создать приложение для телефона за пять минут и связать его с Arduino за дополнительные пять? А уникален он примененной бизнес моделью. В мире программного обеспечения приняты стандартные условия использования продуктов: Freeware (бесплатно), Shareware (условно бесплатно, с тестовым периодом), Donationware (заплати, если понравилось), платные продукты. Допускаются различные комбинации, например, для частного использования продукт может быть бесплатен, а корпоративный сектор обязан заплатить за каждую копию. Впрочем, существуют и другие типы лицензий, например, множество OpenSource, когда продукт рассматривается как некий кирпичик исходного кода доступного всем. Но не будем углубляться в дебри и посмотрим пристально на Blynk.

    Интерфейс в приложении Blynk на смартфоне

    По умолчанию обычному частному пользователю, скачавшему Blynk из маркета, выдается лимитированный набор, нет, не элементов, а заряда батареи. Оный заряд тратится на использование элементов интерфейса для создания своего приложения. Допустим, изначально вам доступна величина в 1000 единиц заряда. Каждая кнопка, установленная в проекте, обойдется вам в 200 единиц, а что-то посложнее, к примеру, построитель графика, выйдет уже в 400. Таким образом, строя свое приложение из элементов вы тратите энергию, выделенную вам изначально. Как только энергия истощится, добавить новые элементы в приложение будет уже нельзя. Придется либо докупать энергию за настоящие деньги, а операция происходит чрезвычайно просто, как и все остальное в Blynk, либо удалять элементы из приложения. При удалении, энергия, затраченная на установку, возвращается обратно в полном объеме.

    Тем самым разработчики позволяют новому пользователю оценить возможности Blynk и создать как минимум одно более-менее функциональное приложение. А дальше – хочешь плати, не хочешь, разбирай то, что наваял и используй повторно. Уникальность ситуации заключается в том, что пользователю предлагается покупать не приложение, не подписку на него, не ограничение по трафику, а элементы интерфейса его приложения! Пополнение заряда батареи Blynk стоит не дорого, и его можно отнести к микроплатежам. Поэтому расставание с кровно заработанным происходит незаметно и безболезненно.

    Но все же оцените идею. Представьте, что вы используете MS Word и вам предлагается писать тексты не более десяти страниц. А чтобы написать одиннадцатую, потребуется либо прикупить еще виртуальной бумаги, либо возвести краткость в благодетель и сократить свой текст до минимума. А после печати и вовсе его весь стереть. Несмотря на абсурдность реализации примера, с Blynk все работает. И работает отлично.

    Для корпоративных же пользователей, чья работа непосредственно связана с выпуском приложений в коммерческих или около коммерческих целях, предлагается немного другая схема оплаты за труд разработчиков в Blynk. Корпораты получают stand alone приложение, работающее не в «песочнице» Blynk, а отдельно. Blynk там все равно будет, скрытый за фасадом. А платить придется за подписку, в течение которой приложение останется работоспособным.

    Представьте, что вы производите ультразвуковые увлажнители воздуха. Вы уже вдоволь украсили каждую из своих моделей синими светодиодами и всерьез подумываете, как бы прикрутить туда еще и IoT. Blynk предоставляет вам почти готовое решение. Прикручиваете к увлажнителю, нечто на подобие ESP8266, а пользователям предлагаете скачать приложение. Voilà! Все работает, все довольны. Ровно до тех пор, пока вы не решите выпустить новую, усовершенствованную линейку увлажнителей, щеголяющую не только синими, но и фиолетовыми светодиодами. И вполне разумно полагаете, что за старое приложение можно уже не платить. Денег оно потребляет, а потребителю пора прийти за новым увлажнителем, ибо у вас дети, им надо поступать в колледж.

    Программируемый срок службы потребительских товаров - заветная мечта любого производителя. Решить которую, при помощи Blynk, очень легко. Как, впрочем, и все, что касается Blynk.

    Что взамен?

    Но не все индивидуумы готовы платить деньги, особенно за то, что можно сделать бесплатно. И народная мысль моментально ориентируется, энтузиасты приступают к раскопкам альтернативных вариантов бесплатного использования аналога функций Blynk. И как бы странно оно не звучало, я из их числа.

    Веб-сервер

    Самым простым способом реализовать удаленное управление я бы назвал использование Web-сервера на вашем устройстве. Такие современные чипы как EPS8266 и многие другие позволяют подключаться к IP-сетям, в том числе локальным сетям в квартире и даже с выходом в Internet. А свободного места в памяти контроллера достаточно для размещения полноценного сервера.

    Соответственно на подобном устройстве можно развернуть несложный web-сервер, оптимизированный под экраны мобильных устройств. Вызывать же его можно через ярлык на рабочем столе вашего смартфона. Да, в большинстве случаев, и устройство и мобильный должны находиться в пределах одной сети, но часто-ли вам приходит в голову включить ваш увлажнитель дома, когда вы сами находитесь в Гималаях, карабкаясь с веревками на очередную вершину?

    При использовании варианта с веб-сервером потребуется обрабатывать ответы от клиента, да выводить элементы управления в виде HTML. Получится может быть не так красиво и быстро, как при помощи Blynk, но зато совершенно бесплатно.

    Cayenne

    Добавление элементов на панель управления в Caynne (браузер)

    Что было сделано? При помощи специалистов Cayenne был перегружен метод CayenneWiFiClient, в который добавился конструктор для создания объекта Cayenne с передачей в него только идентификатора аутентификации на сервисе Cayenne. Соединение с интернет в таком случае требуется создать самостоятельно.

    Необходимо модернизировать штатную библиотеку Cayenne и положить измененный файл в каталог с вашим скетчем:

    #ifndef _CAYENNEESP8266WIFICLIENT_h #define _CAYENNEESP8266WIFICLIENT_h #include "CayenneClient.h" class CayenneWiFiClient: public CayenneClient { public: /** * Begins Cayenne session * @param token Authentication token from Cayenne site * @param ssid WiFi network id * @param pass WiFi network password */ void begin(const char* token, const char* ssid, const char* pass) { Blynk.begin(token, ssid, pass, CAYENNE_DOMAIN, CAYENNE_PORT); } /* void config(const char* auth, const char* domain = CAYENNE_DOMAIN, uint16_t port = CAYENNE_PORT) { Base::begin(auth); this->conn.begin(domain, port); }*/ void config(const char* auth) { Blynk.config(auth, CAYENNE_DOMAIN, CAYENNE_PORT); } }; CayenneWiFiClient Cayenne; #endif

    И собственно сам скетч:

    #include #define CAYENNE_PRINT Serial // Comment this out to disable prints and save space #include "CayenneDefines.h" #include "BlynkSimpleEsp8266.h" #include "CayenneESP8266WiFiClient.h" #define VIRTUAL_PIN V0 #define ledPin D4 // the onboard LED char token = "YourCayenneSecurityToke"; const char* ssid = "YourWiFiNetwork"; const char* password = "YourWiFiNetworkKeyPhrase"; void setup() { // put your setup code here, to run once: Serial.begin(115200); Serial.println("YaHoo..."); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while (WiFi.waitForConnectResult() != WL_CONNECTED) { Serial.println("Connection Failed! Rebooting..."); delay(5000); ESP.restart(); } Cayenne.config(token); pinMode(ledPin, OUTPUT); } CAYENNE_IN(VIRTUAL_PIN){ int value = getValue.asInt(); // Get value as integer Serial.print("Value received V1P: "); Serial.print(value); Serial.println(""); if (value==1){ digitalWrite(ledPin, LOW); }else{ digitalWrite(ledPin, HIGH); } } void loop() { // put your main code here, to run repeatedly: Cayenne.run(); delay(100); //Serial.print("."); }

    Если из вышеописанного ничего не понятно, то попробую объяснить. Во-первых, Cayenne опирается на Blynk… Да, Cayenne использует Blynk, только не то приложение, что я описал несколькими абзацами выше, а фреймворк Blynk, выпущенный под лицензией MIT. Таким образом получается, что и приложение Blynk, и Cayenne, так или иначе, выполняют одну и туже функцию. В действительности же оно так и есть.

    Готовая панель управления в Cayenne при просмотре через браузер

    Разница между проектами в следующем: Blynk делает упор на мобильное приложение и простоту разработки приложения, Blynk уже сейчас активно монетизируется. Cayenne же помимо мобильного приложения предлагает еще и полнофункциональную панель управления на своем Web-сайте. И пока не собирает деньги со своих пользователей. Концепция работы в Cayenne идентична концепции Blynk. В приложении или через веб-браузер, пользователь создает проект, добавляет кнопки, лампочки и прочие показометры, которые можно связать с виртуальным или реальным пином вашего, конкретного, устройства. Дополнительно у Cayenne имеется механизм триггеров и событий. Триггеры обрабатывают события, получаемые от устройств. А событийная модель опирается на календарное расписание.

    Связь устройства и приложения осуществляется так же, как и у Blynk, посредством добавления небольших кусочков программного кода для обработки бизнес-логики зашитой в ваше устройство. Но первоначально проект затачивался на применение минимального количества программирования на стороне устройства клиента. Все так или иначе должно быть подхвачено библиотеками Cayenne. Именно по этой причине в Cayenne можно найти множество плат и вариантов подключения к сети, представлены, в том числе, и различные сенсоры конкретных производителей. С одной стороны, разнообразие снижает необходимость в программировании скетчей, с другой, понижает возможности использования универсальных устройств.

    Интерфейс рабочей панели Cayenne на планшете

    Именно по этой причине у меня и возникло затруднение в том, как можно подключить Cayenne к уже подключенному Wi-Fi соединению. И мне пришлось объяснять разработчикам, для чего мне это потребовалось. Возможно, что система была задумана для самого начального уровня подготовки оконечных разработчиков, о чем косвенно говорит количество примеров скетчей, вылезающих при каждом действии.

    Немного удивил построитель на веб-сайте. К его логике нужно привыкать. Сначала добавляем устройство, получаем код идентификации, затем подключаем его на устройстве и пробуем подключиться к серверам Cayenne. Если подключение нам удалось, к подключенному устройству можно будет подключать виджиты, кнопки, табло и прочие средства визуализации.

    Подводя итог после тестирования Cayenne, могу отметить я так и не смог определиться, понравилась ли мне система или нет. С одной стороны, да, все, что от нее требуется, все на месте. С другой стороны, меня постоянно не покидало ощущение, что тут что-то недоделано. Оно и понятно, система новая и план работ по реализации всех функций еще наверняка не завершен. Еще больше беспокойства вызывает «завлекалочка» Try it for Free, без какой-либо публикации, а что будет, когда «тестовый» период завершится? По крайней мере в настоящий момент (декабрь 2016), Cayenne можно пользоваться в своих целях без какой-либо платы, тренироваться, создавать свои приложения. И самое главное - никаких ограничений в плане запаса энергии в батарейке.

    Virtuino

    В отличие от Blynk или Cayenne, разработкой Virtuino занимается один единственный человек. И несмотря на сильно ограниченные ресурсы, результат получился не хуже, а может быть даже и лучше, нежели описано выше. Итак, Virtuino - плод усердий греческого разработчика, ознакомиться с которым можно как на отдельной страничке (на греческом языке), так и прямиком на странице загрузки приложения Virtuino из маркета. Для спешащих в бой, даю прямую ссылку на tutorial по подключению Virtuino, поскольку поначалу процедура может быть не тривиальной.

    Как и Blynk, Virtuino подразумевает использование только мобильного приложения для создания пользовательского интерфейса. Как и Cayenne с Blynk, Virtuino использует технологию приложения в приложении. Это означает, что ваши наработки остаются в «песочнице» Virtuino и не могут существовать отдельно от Virtuino. Но у Virtuino присутствует и отличие от двух конкурентов. Virtuino не использует промежуточный сервер.

    Интерфейс приложения Virtuino на планшете

    Остановлюсь немного подробнее именно на этом факте, поскольку для меня он является ключевым. Blynk и Cayenne используют серверную часть и работают только через нее. Нельзя обратиться к устройству без подключения к Интернет, по крайней мере для подключений, не касающихся Bluetooth и USB подключения. А если соединение нестабильное, то ваш скетч будет затормаживаться на сетевых соединениях. Для каких-то применений, замедление исполнения инструкций может быть весьма критично. Причем, и Blynk и Cayenne могут работать из-под сурового NAT, то это означает, что ваше устройство будет периодически опрашивать, буквально в каждом цикле, сервер в Интернет. При плохой связи исполнение скетча может пойти вообще не так, как задумано изначально.

    В Virtuino разработчик может пойти двумя путями. Во-первых, он может воспользоваться сервисом ThingSpeak , в качестве того самого, промежуточного сервера. А во-вторых, коммуникация между приложением и устройством осуществляется при помощи веб-сервера, поднятого на самом устройстве! Да, в этом случае, доступ извне вашей локальной сети к устройству, скорее всего, будет невозможен. С другой стороны, он мало кому и нужен. Но зато никаких задержек и проблем с внешним соединением. Все реализовано прозрачно до невозможности, вот чего не хватает грандам IoT. При работе с Cayenne тебя постоянно не покидает ощущение, что в любой момент может быть введена плата за использование сервиса, а у Blynk будут подняты расценки и ваш, уже оплаченный, набор окажется неработоспособным. С Virtuino вы продолжите пользоваться приложением и будите управлять им устройством. Во всяком случае приложение можно и не обновлять.

    Как и у Cayenne в Virtuino реализована жесткая возможность по подключению к сети Wi-Fi средствами Virtuino без возможности использовать уже установленное соединение. Наличие двух одинаковых подходов к реализации наводит на невеселые мысли. По какой-то невероятной причине, разработчики значительно ограничивают возможность пользователей их продуктов. Если с Cayenne мне удалось решить вопрос про использование моего собственного подключения к сети, то в Virtuino я потерпел фиаско. Даже при помощи разработчика мне не удалось подключить мой ESP8266 к сети и использовать Virtuino. Дело в том числе и в том, что Virtuino поддерживает ESP8266 только как внешний модуль Wi-Fi для Arduino, а не как самостоятельную плату. А я полностью перешел в своих устройствах на ESP8266 в виду их выдающихся характеристик.

    Да, в погоне за облегчением жизни потребителя, некоторые разработчики загоняет его, потребителя, в очень узкие рамки и не позволяют за них выходить. На примере 1С, мы помним, чем гибче и открытие платформа, тем больший успех ждет ее на рынке. Где все те «парусы», «галактики» и «абакусы»? Тем не менее, я связался с разработчиком и выяснил его ближайшие планы. Первым делом будут реализованы настраиваемые кнопки и индикаторы. Эта работа должна быть завершена к моменту публикации статьи, а затем настанет черед добавления новых плат к штатной библиотеке. Надеюсь, что в библиотеке появится нативная поддержка ESP8266 для Arduino.

    В целом же Virtuino произвел на меня очень благоприятное впечатление, в первую очередь тем, что присутствует возможность не использовать промежуточный сервер. Но ограниченные ресурсы одного человека не позволяют реализовать сразу все задумки, например, добавить англоязычную версию сайта или же слепить универсальный вариант своей библиотеки, а заодно положить ее на GitHub. С нетерпением ждем дальнейшей разработки и новостей от Illias-а .

    Выводы

    Меня очень радует тот факт, что начали появляться реализации реальной конвергенции мобильных устройств и устройств из мира IoT. Пока у нас не будет возможности с легкостью общаться с нашими устройствами, по возможности через единый или универсальный интерфейс, тотального марша IoT по планете наблюдаться не будет. Человек уж такая скотина, которая ленится привыкать к чему-то новому и наличие с десятка различных интерфейсов по управлению IoT-устройствами будет вызывать нескончаемую экзистенциальную боль в суставах конечного потребителя.

    Конечно, рассчитывать на тотальную унификацию не стоит. Помните историю с умными домами? Когда весь бум сошел на нет? А все из-за несовместимости систем между собой и отсутствию четкого, единого стандарта. Подобный риск существует и с IoT. В принципе, как-то мы обходились без умных розеток, холодильников и стиральных машин, а добавление новых «умных» функций не добавляет много ценности к устройствам. Поэтому будем внимательно следить за назревающей битвой, возможно, что на наших глазах победит один из рассматриваемых выше способов коммуникации между человеком и устройством. Поглядим, посмотрим.

    Программирование разнообразных микроконтроллеров и микрокомпьютеров, таких как Arduino, Raspberry Pi и им подобные, - одно из самых интересных и актуальных занятий. Конструирование устройств на этих платформах вышло за рамки хобби гиков и профессиональных программистов: эти платы используются для создания роботов, станков, квадрокоптеров, IoT-устройств (умный дом), серверов и даже Hi-Fi-аудиоинтерфейсов.

    К сожалению, рынок микроконтроллеров сильно сегментирован. Их программирование осуществляется через различные среды и интерфейсы. Ситуацию призван спасти проект под названием Blynk.

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

    Для создания собственного проекта с управлением через Blynk нужно совсем немного: установить приложение (доступны версии для iOS и Android) или воспользоваться веб-формой. Тут потребуется регистрация в один шаг - ввод email и пароля. Регистрация нужна ввиду того, что Blynk - облачное решение и без неё контроль над железкой может получить любой пользователь.

    Желающие могут установить сервер локально . В таком случае доступ в интернет не нужен.

    Работа приложения потребует определённых навыков. Сначала необходимо связать компьютер или смартфон с программируемой платой. Программа поддерживает соединение с платами посредством массы самых разных интерфейсов:

    • USB (Serial),
    • Adafruit CC3000 WiFi,
    • Official Arduino WiFi Shield,
    • Official Ethernet Shield (W5100),
    • ENC28J60,
    • ESP8266 (WiFi modem),
    • SeeedStudio Ethernet Shield V2.0 (W5200),
    • RN-XV WiFly,
    • ESP8266.

    Кроме настройки соединения, потребуется только правильно соединить модули будущего устройства. После этого в рабочей форме приложения нужно добавить доступные модули (виджеты), настроить необходимые адреса выводов и указать желаемые параметры (при необходимости можно написать свой код). Кстати, для создания виджета или программы используется drag’n’drop. Для управления доступна масса имитаторов управляющих устройств - переключатели, слайдеры, дисплеи, для каждого из которых можно писать свою логику. Есть отдельные формы для вывода и систематизации информации с требуемых датчиков в виде графиков.

    Таким образом, платформа подойдёт как новичкам, так и более продвинутым пользователям, которые не хотят тратить время на написание приложений для управления проектами: от считывания данных с метеостанции и управления умным домом до управления роботами.

    Вся информация, необходимая для начала работы, размещена на официальном сайте . Blynk - это , так что каждый может поучаствовать в создании новых функций. На данный момент использование сервиса полностью бесплатно, в дальнейшем ситуация несколько изменится - прежде всего, за счёт монетизации новых функций. Так, уже сейчас известно, что доступ к GPIO-интерфейсам будет приобретаться как встроенная покупка.

    На данный момент Blynk работает со следующими платами:

    • Arduino: Uno, Nano, Mini, Pro Mini, Pro Micro, Mega, YÚN (Bridge), Due;
    • Raspberry Pi;
    • Particle (ex Spark Core);
    • ESP8266;
    • TinyDuino (CC3000);
    • Wicked WildFire (CC3000).

    В этом примере показано как с помощью контроллера Arduino заставить мигать светодиод.

    Необходимые компоненты

    • контроллер Arduino
    • светодиод
    • резистор 220 Ом

    Подключение

    Мы подключаем резистор сопротивлением 220 Ом к выходу номер 13 (pin 13), к резистору в свою очередь подключаем анод (обычно длинная ножка) светодиода. Катод подсоединяем к земле (Grd). Затем подключаем контроллер через USB кабель к компьютеру и загружаем приведенный ниже код на котроллер Arduino.

    Большинство плат Arduino имеют встроенный SMT (Surface-mount techology)светодиод, подключенный к выходу 13. Если вы запустите код на таких платах без подключения внешниего светодиода, то вы должны увидеть мигание встроенного светодиода на плате.

    Схема

    Код

    В коде мы первой строк задаем режим выхода для вход/выхода (pin) 13:

    pinMode(13, OUTPUT);

    В основном цикле (loop) программы зажигаем светодиод:

    digitalWrite(13, HIGH);

    На выходе 13 появляется напряжение 5 В. Светодиод зажигается. Затем мы выключаем светодиод:

    digitalWrite(13, LOW);

    Изменив напряжение на выходе на 0 вольт, мы выключили светодиод. Для того чтобы человеческий глаз успевал замечать переключение светодиода введем задержку с помощью функции delay() .

    /* Зажигаем светодиод на одну секунду, затем выключаем его на одну секунду в цикле. */ void setup() { // Инициализируем цифровой вход/выход в режиме выхода. // Выход 13 на большинстве плат Arduino подключен к светодиоду на плате. pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); // зажигаем светодиод delay(1000); // ждем секунду digitalWrite(13, LOW); // выключаем светодиод delay(1000); // ждем секунду }

    Смотрите также

    Итак, приступаем к освоению. Первый урок не потребует от вас никаких материалов и просто призван ознакомить с простотой ARDUINO. Как в большинстве программ ознакомление начинается с «Hello World!» так и мы начнем с самого простого- мигания светодиодом. Что вам для этого потребуется: собственно сама плата ARDUINO, USB кабель для подключения ARDUINO к компьютеру, оболочка программирования ARDUINO. Оболочки выпускаются новые, но самой стабильной признана версия 1.0.6. Скачать вы ее можете на официальном сайте . Это версия для Windows, для Linux качаете . Сразу стоит понять что для продолжения изучения вам понадобится макетная плата (заказать в Китае или купить в интернет- магазине), провода (можно купить там же или найти старые системные блоки и вытащить провода идущие на переднюю панель, раньше даже USB на лицевой панели соединялись одинарными проводами а не целым разъемом, именно они вам и подойдут- вытаскиваете провод, на другой конец напаять штырьки от разъемов на плате, затем надеваете на место пайки небольшой кусочек термоусадочной трубки, чтобы провод не переломился на месте пайки, нагреваете и у вас готовый провод мама(штеккер с отверстием)- папа (штырек от платы).

    Самодельные провода для ARDUINO

    Таким же образом сделайте провода- папа-папа, они пригодятся для коммутации на макетной плате и присоединения ARDUINO к макетной плате. Кстати можно, даже нужно, сделать такие провода в виде шлейфа- так гораздо удобнее соединять ARDUINO с блоками), ну и блоки с которыми вы будете работать (покупаются тоже в Китае или в интернет- магазинах). Выбор датчиков и исполнительных механизмов огромен и не ограничивает вашу фантазию. Но на первых порах будет достаточно термодатчика Dallas , индикатора (можно конечно и 7- сегментные светодиодные но они кушают ток в несколько раз больший чем 1602 а это отрицательно скажется при питании от аккумуляторов и батарей, да и выводят они только цифровую информацию), реле , все что вам будет нужно вы всегда сможете докупить. Для тех кто не стеснен в средствах лучше сразу купить набор. Хоть это и дороговато но он сразу отбрасывает все проблемы с приобретением датчиков и вы сможете изготавливать устройства сразу. Выбор все равно будет только за вами. Ладно, заговорился, ближе к теме.

    Подключаем ARDUINO к компьютеру, запускаем программу, в программе заходим Сервис- Плата-выбираете вашу плату, все- можете работать!

    Кстати, китайский клон может быть собран микросхеме ch340 и у вас компьютер будет требовать драйвер на USB порт. Для установки скачайте драйвер , распакуйте и при запросе драйвера укажите на папку с распакованными файлами.

    Не теряя времени делаем следующее: Файл-Примеры-Basics-Blink . Откроется новое окно


    Blink на ARDUINO

    в котором вы увидите программу, можете сразу нажать на вторую кнопку в панели программы с изображением стрелки, программа скомпилируется и передастся в ARDUINO, светодиод на плате начнет мигать! 1 секунду горит, 1 секунду не горит. Рассмотрим саму программу. Вы увидите прежде всего комментарии отмеченные знаками /* текст */ и // текст . Первый значит что текст от знака /* до знака */ является комментарием и компилятор просто не обрабатывает и не учитывает эту информацию, очень удобно писать в таких комбинациях описание программы, ее алгоритм, авторство и многое другое. Знак // комментирует только строку. Причем вы можете писать этот знак как в начале строки, так и после каких либо строк программы, но ни в коем случае не перед строками программы- программа посчитает всю строку за комментарий.

    Например:

    digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level) — правильно

    // turn the LED on (HIGH is the voltage level) digitalWrite(13, HIGH); — неправильно

    Если вы хотите сделать комментарий перед оператором в одной строке то воспользуйтесь комбинацией /* текст */ , т.е. строка будет выглядеть так: /* turn the LED on (HIGH is the voltage level) */ digitalWrite(13, HIGH);

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

    Следующее что вы увидите- следующий текст:

    // the setup function runs once when you press reset or power the board
    void setup () {
    // initialize digital pin 13 as an output.
    pinMode (13, OUTPUT);
    }

    В комментарии написано что функция установки вызывается только один раз когда вы сбрасываете или перезапитываете ARDUINO. Т.е. или нажимаете кнопку сброса на самой плате или вновь подключаете питание.

    Затем идет оператор void setup () {….} — начинающий собственно секцию установок для данного скетча (так называется программа для ARDUINO).

    В следующем комментарии написано что определяем 13 пин ARDUINO как выход. Хочу напомнить что на странице описаны пины платы, так вот 13 вывод является цифровым (о чем написано в подписях к выходам) и может принимать только 2 состояния- включено (при этом на него подается напряжения порядка 5В), т.е. логическая 1(единица), или выключено (напряжения нет) т.е. логический 0 (ноль). При ноле все равно есть небольшое напряжение на пине но они низкое по отношению к логической единице. Кроме того к 13 пину подключен через резистор светодиод на самой плате, именно он и мигает при выполнении программы.

    pinMode (13, OUTPUT); — pinMode- переводится как режим пина, 13- номер пина, OUTPUT- выход, т.е. строка означает что 13 вывод будет работать как выход, OUTPUT , если написать INPUT то это уже будет ЦИФРОВОЙ ВХОД, т.е. вы можете обрабатывать поступающие на этот пин ЦИФРОВЫЕ данные.

    Если вы подключите к 13 пину светодиод с последовательно подсоединенным резистором на 1кОм, а другую ножку к пину GND то светодиод будет мигать вместе со светодиодом на плате. Если он у вас не замигал- поменяйте полярность светодиода.

    Следующие строки являются программой описывающей действия с портом:

    // the loop function runs over and over again forever
    void loop () {
    digitalWrite (13, HIGH); // turn the LED on (HIGH is the voltage level)

    digitalWrite (13, LOW); // turn the LED off by making the voltage LOW
    delay (1000); // wait for a second


    void loop () {…}     — секция программы где описываются действия для работы, данные в этом цикле могут меняться и обрабатываться в соответствии с условиями.Комментарий сообщает что следующий цикл будет выполняться снова и снова всегда

    digitalWrite (13, HIGH); // turn the LED on (HIGH is the voltage level)- digitalWrite- записать ЦИФРОВОЙ сигнал, 13- номер пина, HIGH- высокий уровень, т.е. логическая единица (напряжение около 5В), дальше комментарий что включаем светодиод высоким логическим уровнем.

    delay (1000); // wait for a second- delay (задержка), ждем 1000 миллисекунд или 1 секунду. Нужный оператор, особенно при обработке нажатий кнопки, в данном случае он используется как указание ждать 1 секунду после включения 13 пина.

    digitalWrite (13, LOW); // turn the LED off by making the voltage LOW- как и первая строка цикла указывает что 13 пин надо переключить, только теперь на уровень LOW- низкий уровень, логический ноль (напряжение около 0В).

    delay (1000); // wait for a second- опять задержка 1 сек прежде чем цикл начнется выполняться заново.

    Попробуйте поменять значения delay, вы увидите что меняются длительность включения и паузы между вспышками.

    Программа простейшая, понятная с первого раза но в ней есть недостатки: оператор delay заставляет ARDUINO ждать пока он не закончит свою работу, т.е. в этот момент МК не обрабатывает никакие данные, попросту говоря он ждет исполнения оператора, ладно если значения невысокие, а если нужно оперативно обработать данные? За 1 секунду данные могут поменяться не одну сотню раз, а МК не учитывает их, он ждет выполнения программы. Для того чтобы не пропускать поступающие данные можно воспользоваться следующим скетчем. Открываем скетч: Файл- Примеры- Digital- BlinkWithoutDelay . Откроется окно следующего содержания:

    /* Blink without Delay

    Turns on and off a light emitting diode(LED) connected to a digital
    pin, without using the delay() function. This means that other code
    can run at the same time without being interrupted by the LED code.

    The circuit:
    * LED attached from pin 13 to ground.
    * Note: on most Arduinos, there is already an LED on the board
    that’s attached to pin 13, so no hardware is needed for this example.

    created 2005
    by David A. Mellis
    modified 8 Feb 2010
    by Paul Stoffregen
    modified 11 Nov 2013
    by Scott Fitzgerald

    This example code is in the public domain.

    http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
    */

    // constants won’t change. Used here to set a pin number:
    const int ledPin = 13; // the number of the LED pin

    // Variables will change:
    int ledState = LOW; // ledState used to set the LED

    // Generally, you shuould use «unsigned long» for variables that hold time
    // The value will quickly become too large for an int to store
    unsigned long previousMillis = 0; // will store last time LED was updated

    // constants won’t change:
    const long interval = 1000; // interval at which to blink (milliseconds)

    void setup () {

    pinMode (ledPin, OUTPUT);
    }

    void loop ()
    {




    // blink the LED.

    if (currentMillis — previousMillis >= interval) {


    if (ledState == LOW)
    ledState = HIGH;
    else
    ledState = LOW;



    }
    }

    Пропускаем все комментарии и переходим к строке:

    // constants won’t change. Used here to set a pin number:
    const int ledPin = 13; // the number of the LED pin

    Строка комментария гласит что константы не надо изменять, т.е менять название констант. Но можно поменять цифру означающую номер пина.

    const int ledPin = 13; // the number of the LED pin- const означает константу, т.е постоянную величину которую нельзя изменить в программе, int- сокращенно от слова integer, означает тип данных который может принимать значения от -32768 до 32768. Кроме integer есть еще 5 типов данных. Чем они отличаются? Они отличаются размерами, т.е. например в переменную типа byte можно записать всего 256 значений, разница в размерах- int-2 байта (кроме ARDUINO DUE, в нем INT занимает уже 4 байта но значения принимает от -2147483648 до 2147483647), byte как и написано- 1 байт. В больших программах экономия памяти является очень важным моментом и поэтому старайтесь избегать где только можно применения более «тяжелых» типов если можно обойтись «легкими» типами. Например здесь хватило бы типа byte т.к. 13 вписывается в предел между 0 и 255, да и остальные цифровые пины тоже бы вписались в этот тип данных. ledPin — название самой константы. 13- значение константы, из комментария выше понятно что эта константа будет использована для выбора пина.

    // Variables will change:
    int ledState = LOW; // ledState used to set the LED

    Комментарий говорит что переменная будет меняться в программе

    int ledState = LOW; // ledState used to set the LED- объявляет переменную ledState имеющую начальное значение LOW (логический ноль) и комментарий что переменная ledState будет использоваться для светодиода (LED по не нашему).

    // Generally, you shuould use «unsigned long» for variables that hold time
    // The value will quickly become too large for an int to store
    // will store last time LED was updated

    Комментарий говорит что вы должны использовать переменную типа unsigned long для времени, следующая строка предупреждает что значение будет слишком большим для переменной типа int для хранения. Unsigned long применяется для хранения ЧИСЕЛ и может хранить значения от 0 до 4294967295 занимая 4 байта.

    unsigned long previousMillis = 0; // will store last time LED was updated- создает переменную previousMillis типа unsigned long и присваивает значение 0, в ней будет хранится время когда было обновлено состояние светодиода.

    // constants won’t change:
    const long interval = 1000; // interval at which to blink (milliseconds)

    Тоже константа, типа long, предназначена для хранения ЧИСЕЛ, занимает 4 байта и может принимать значения от -2147483648 до 2147483647, interval- название переменной, 1000- значение переменной. В комментарии подписано что это будет интервал мигания в миллисекундах.

    void setup () {
    // set the digital pin as output:
    pinMode (ledPin, OUTPUT);
    }

    Функция знакомая по предыдущему примеру, только здесь указывается пин не явно а через переменную ledPin , которая описана у нас как константа и имеет значение 13. Т.е это равносильно тому что если было бы написано pinMode (13, OUTPUT);

    Ну и собственно тело программы:

    void loop ()
    {
    // here is where you’d put code that needs to be running all the time.

    // check to see if it’s time to blink the LED; that is, if the
    // difference between the current time and last time you blinked
    // the LED is bigger than the interval at which you want to
    // blink the LED.

    Здесь комментариях описано как работает программа. Кстати, можно было использовать комбинацию /*текст*/ вместо того чтобы писать в каждой строке // . Здесь написано что когда разница между текущим и последним временем когда светодиод мигнул больше чем указанный интервал то нужно снова зажечь светодиод.

    unsigned long currentMillis = millis ();

    Объявляется переменная currentMillis типа unsigned long которая хранит данные оператора millis () . millis () — внутренний оператор МК указывает сколько миллисекунд проработал ARDUINO.

    if (currentMillis — previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    Дошли до вычисления. Теперь есть замечательный оператор условия if (если)- которым пользовались, пользуются и будут пользоваться еще очень долго. Рассмотрим его более подробно. Конструкция условия выглядит так:

    if (условие==значение){

    Действие если условие выполняется

    else {

    Действие если условие не выполняется

    Знак == может меняться на любые другие знаки >,<,>=, <=, != (не равно). Условие как и значение может высчитываться. Если условие не выполнено то программа переходит в секцию else. Довольно часто секцию else не используют а просто пишут программу дальше. Это уже зависит от алгоритма работы программы и должно быть продумано заранее. Условий может быть сколько угодно и они могу быть вложены друг в друга, т.е. пока не выполнится одно условие- другое даже выполняться не начнет.

    Итак оператор if вычитает из текущих миллисекунд предыдущее значение и сравнивает с переменной interval. Если значение меньше то программа выходит из условия и начинается сначала, если больше или равно то переменной previousMillis присваивается значение currentMillis и программа переходит на следующий шаг:

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
    ledState = HIGH;
    else
    ledState = LOW;

    В этой секции выясняется какое состояние у светодиода, если на светодиод подавался низкий уровень LOW то переменной ledState присваивается значение HIGH, и наоборот (секция else) если был высокий уровень HIGH то переменной ledState присваивается значение LOW. Заметьте что здесь if используется уже без {}. Это допускается если нужно обработать в секции выполнения не более 1 строки.

    // set the LED with the ledState of the variable:
    digitalWrite (ledPin, ledState);

    Ну и наконец записываем на значение переменной ledPin (оно было равно 13), значение переменной ledState. Т.е. данная строка может быть записана как digitalWrite(13, LOW); или digitalWrite(13, HIGH); в зависимости от времени работы МК. Обратите внимание что использован оператор digitalWrite- именно он указывает что надо передать значение в логическом формате, т.е. ноль или единицу. Больше он никаких значений принять не может. Любые другие значения ledState будут автоматически приведены к логической 1.

    }
    }

    Вот и разобрана работа второй программы. Какая разница между первой и второй программой если они выполняют одно и тоже действие но во второй написано раз в 5 больше строк? Как я и говорил что первая программа просто ждет когда закончит свою работу оператор delay и только потом продолжит работу. Во время delay вы не сможете обрабатывать никаких данных. Вторая программа позволяет получать, обрабатывать и отдавать данные во время мигания светодиода. Просто дописываете нужный код в секцию loop и наслаждаетесь работой! Мы с моим другом подсчитали что код пробегается во втором случае около 4 млн. раз в секунду, поэтому задержек практически нет.

    Ну а теперь самое главное. Спустя некоторые время, наигравшись, вы скажете- «Че толку то мигать лампочкой… Где это можно использовать? Только индикатор того что устройство работает…» Вы будете не совсем правы. У вас есть инструмент, что вы с его помощью можете сделать- это только ваша вина если вы ничего не можете придумать. Это как любому человеку дать полный набор инструментов и попросить что нибудь сделать, например комплект столярного инструмента вручить мужчине, кто то будет всю жизнь строгать одну и ту же доску, поражаясь чистоте с которой рубанок строгает и пытаясь наточить железку как можно острее, а кто-то будет делать в это самое время высококачественную мебель. Кем будете вы- решать только Вам. Еще мой совет, где то я вычитал, даже не помню-«НЕ ИЩИТЕ ПРОБЛЕМЫ, ИЩИТЕ ИХ РЕШЕНИЕ!» Если вы будете пользоваться таким подходом у вас возникнет гораздо меньше всяких КАК и ПОЧЕМУ. Ну а теперь про мигание светодиодом. В интернете куча советов по пользованию различными индикаторами, конечно это красиво, придает какую то значимость автору и т.д… но это задевает самое главное- экономия пинов и памяти. Для того чтобы подключить индикатор 1602 надо занять 6 цифровых пинов + 2 провода питания! Это если не пользоваться протоколом I2C. К тому же библиотека на LCD занимает 4кБ. И никто не думает о дальнейшей функциональности, ну поигрались индикатором и все- тоже бросили. Неужто никто не задавался вопросом что можно одним светодиодом получать всю необходимую информацию? Например ошибки. Написали функцию и передаете в нее код ошибки. Это же удобно- не надо опять разбирать код а просто посмотреть что не так работает. Или, к примеру, мой друг собрал на ARDUINO mini контроллер газового котла, т.е. по температуре в дому (снимаемой датчиком Dallas), включался/отключался циркуляционный насос. Когда насос был отключен, котел нагревался до 40°С и стоял на запальнике, температура в комнате падала- включался насос и при остывании теплоносителя котел сам включался. Очень удобно и появилась существенная экономия газа! Всего за каких то 200-300 рублей он экономил каждый день по несколько кубов газа! Он тогда все думал- как же отследить температуру в комнате без подключения всяких WiFi и компьютеров, я предложил- пускай светодиод мигает столько раз, сколько градусов в комнате… Посмеялись конечно- 20-25 раз считать по любому ошибешься, тогда я предложил- пусть мигает сначала десятки градусов а через паузу- единицы, например 24 градуса, сначала 2 раза мигнул, через паузу еще 4. Все! Никаких больше индикаторов! И это можно применить в любой области! Ищите нестандартные подходы и старайтесь экономить энергию и входы. Даже если используете I2C. Всем удачи в освоении МК и, в частности, ARDUINO.

    • 220 ohm resistor

    Circuit

    This example uses the built-in LED that most Arduino and Genuino boards have. This LED is connected to a digital pin and its number may vary from board type to board type. To make your life easier, we have a constant that is specified in every board descriptor file. This constant is LED_BUILTIN and allows you to control the built-in LED easily. Here is the correspondence between the constant and the digital pin.

    • D13 - 101
    • D13 - Due
    • D1 - Gemma
    • D13 - Intel Edison
    • D13 - Intel Galileo Gen2
    • D13 - Leonardo and Micro
    • D13 - LilyPad
    • D13 - LilyPad USB
    • D13 - MEGA2560
    • D13 - Mini
    • D6 - MKR1000
    • D13 - Nano
    • D13 - Pro
    • D13 - Pro Mini
    • D13 - UNO
    • D13 - Yún
    • D13 - Zero

    If you want to lit an external LED with this sketch, you need to build this circuit, where you connect one end of the resistor to the digital pin correspondent to the LED_BUILTIN constant. Connect the long leg of the LED (the positive leg, called the anode) to the other end of the resistor. Connect the short leg of the LED (the negative leg, called the cathode) to the GND. In the diagram below we show an UNO board that has D13 as the LED_BUILTIN value.

    The value of the resistor in series with the LED may be of a different value than 220 ohm; the LED will lit up also with values up to 1K ohm.

    Schematic

    Code

    After you build the circuit plug your Arduino or Genuino board into your computer, start the Arduino Software (IDE) and enter the code below. You may also load it from the menu File/Examples/01.Basics/Blink . The first thing you do is to initialize LED_BUILTIN pin as an output pin with the line

    pinMode(LED_BUILTIN, OUTPUT);

    In the main loop, you turn the LED on with the line:

    digitalWrite(LED_BUILTIN, HIGH);

    This supplies 5 volts to the LED anode. That creates a voltage difference across the pins of the LED, and lights it up. Then you turn it off with the line:

    digitalWrite(LED_BUILTIN, LOW);

    That takes the LED_BUILTIN pin back to 0 volts, and turns the LED off. In between the on and the off, you want enough time for a person to see the change, so the delay() commands tell the board to do nothing for 1000 milliseconds, or one second. When you use the delay() command, nothing else happens for that amount of time. Once you"ve understood the basic examples, check out the example to learn how to create a delay while doing other things.

    Once you"ve understood this example, check out the example to learn how read a switch connected to the board.

    Читать еще: