Передавать прошивки, обновления и прочие данные путём паяльника и проводов – не лучшее решение для Ардуино. Однако микроконтроллеры для arduino wi-fi стоят недёшево, да и нужда в них есть далеко не всегда, отчего пользователи предпочитают их не использовать в своих проектах без надобности.
Но вот очередной китайский продукт захватил рынок, wi-fi jammer esp8266 своими руками можно присоединить к плате Ардуино или другой системе, и вы получите стабильное соединение с рядом других преимуществ. Так давайте разберёмся с arduino uno wi-fi, и стоит ли покупать данный модуль, а также, что вообще собой представляет подобный микроконтроллер на wi-fi ардуино.
Доступные Wi-Fi модули для Arduino
Сейчас большая часть пользователей ардуино уже не беспокоится о цене подобных девайсов, хотя ещё 3 года назад arduino wi-fi модуль считался роскошью. Всё это благодаря wi-fi jammer esp8266, производители которого ввели на рынок совершенно новый продукт, поражающей своей функциональностью и, одновременно с тем, являющийся достаточно дешёвым, что внесло весомую лепту и создало конкуренцию в этом направлении.
Таким образом, arduino wi-fi esp8266 сейчас считается самым доступным модулем на рынке, как и все его собратья. Так, цена на зарубежных площадках стартует от 2-х долларов, что позволяет пачками закупать данные модули и не перепрошивать их тысячу раз, перепаивая контакты, чтобы сохранить работоспособность.
Сначала данный wi-fi модуль ардуино использовался, в основном, как arduino wi-fi shield, так как являлся наиболее дешёвым вариантом и ничем не уступал оригинальному. Устройство действительно практически легендарное, ведь весомых минусов за его стоимость не найти. Имеется множество библиотек, в том числе и пользовательских, а также поддерживает работу через Serial шины и простейшие АТ и АТ+ команды. Благодаря этому никакой семантики пресловутого С99, как это часто бывает с другими сторонними микроконтроллерами, изучать не нужно.
Соответственно, даже новичок разберётся за секунды, а профессионал сможет применить уже заготовленные библиотеки. Среди других достоинств отмечается:
- Процессор на 160 МГц, однако он 32-битный, что накладывает определённый отпечаток на производительность. Но стоит помнить, что модуль всё же применяется в связке с платами Ардуино, которые сами по себе режут высокие частоты и съедают большую часть ресурсов неизвестно для чего.
- Производитель, выпустивший wi-fi модуль esp8266, интересные проекты на этом не закончил, и сейчас имеется целая линейка микроконтроллеров проверенного качества.
- Современные стандарты защиты сети. Конечно, WPA и WPA2 уже давно не столь безопасны, как хотелось бы, но их наличие не может не радовать в таком дешёвом контроллере.
- 16 портов вывода, в том числе 10-битный, позволяющий поэкспериментировать с платой.
Что ещё важнее, с коробки вас ждёт постоянная память до 4 мегабайт, в зависимости от типа платы, а это в разы упрощает работу с большими библиотеками и даже некоторыми медиа-файлами. Ведь на большинстве плат ардуино и 1 мегабайт считается непозволительной роскошью.
Характеристики esp8266 wi-fi безусловно радуют, особенно в сравнении с его более дорогими конкурентами, но у пользователя, не имевшего ранее опыта с данными платами, возникнет вопрос о том, как же его подключить. Дело в том, что модуль имеет гораздо больше пинов, чем привыкли видеть новички, а, соответственно, у тех начинается паника. Однако, если разобраться в ситуации, то на деле в этом нет ничего сложного. Достаточно запастись припоем и паяльником и просто почитать инструкцию.
Как подключить Wi-Fi модуль к Arduino
Давайте же рассмотрим подключение esp8266 esp 12e и что такое esp8266 мост wi-fi uart. Ведь именно подключение и настройка модуля вызывают больше всего вопросов.
В первую очередь определитесь, какая версия микроконтроллера у вас на руках. В первой встраиваются светодиоды около пинов, а на второй, которую стали выпускать совсем недавно, сигнальные огни находятся около антенны.
Перед подключением стоит подгрузить последнюю прошивку, позволяющую увеличивать скорость обмена пакетами до 9600 единиц информации в секунду. А проверять соединение мы будем через кабель usb-ttl и соответствующий терминал от CoolTerm.
Пины для подключения вышеописанного кабеля стандартные, а вот питание идёт через 3.3 вольтовый пин с Ардуино. Важно помнить, что максимальную силу тока, которую подаёт плата, невозможно поставить выше 150 мА, а esp8266 esp 07 и esp8266 witty cloud wi-fi модуль для arduino требуют 240 Ма.
Однако, если другого источника тока нет, можете использовать и стандартный вариант от Ардуино, но мощность платы пострадает. Хотя, при не сильной загрузке, достаточно и 70 мА, будьте готовы к внезапным перезагрузкам микроконтроллера в пиковые моменты нагрузки и пишите софт соответственно, чтобы он фильтровал и разбивал файлы, не перегружая плату.
Еще один вариант подключения ниже. Важно - контакты RX-TX соединяются перекрестием. Так как уровни сигналов модуля ESP8266 3.3В, а Arduino 5В, нам нужно использовать резистивный делитель напряжения для преобразования уровня сигнала.
Прописываем Wi-Fi модуль в Arduino
Как известно, при должном опыте можно и шилд esp8266 ex 12e сопрячь со смартфоном, но у новичков и прописка esp8266 esp 12 в системе Ардуино вызывает трудности. На деле достаточно подключить модуль и проверить его работоспособность, скинув несколько штатных команд АТ через меню отладки.
Например, можно добавить мигание штатным светодиодом (для схемы подключения выше):
#define TXD 1 // GPIO1/TXD01 void setup() { pinMode(TXD, OUTPUT); } void loop() { digitalWrite(TXD, HIGH); delay(1000); digitalWrite(TXD, LOW); delay(1000); }Как только плата подтвердит, что видит микроконтроллер в системе, можно начинать полноценную работу с ним. Однако стоит отметить, что если сама плата ардуино используется в проекте лишь для подключения данного контроллера – это иррационально.
Достаточно USB-UART преобразователя, так как esp8266 не использует «мозги» ардуино, а своей флеш-памяти ему вполне хватит для хранения пары базовых библиотек и прошивок. Соответственно, тратиться лишний раз на вспомогательную плату нет никакого смысла, если вы можете просто подпаять его к преобразователю и дальше использовать в проекте. При этом, подключив вспомогательный источник питания и не беспокоясь, что данные перестанут передаваться в самый ответственный момент из-за недостатка мощности системы.
Важное замечание! Для последней схемы скетч загружаем в Arduino как обычно, но так как модуль ESP8266 подключен к контактам 0 и 1, программирование становится невозможным. Компилятор будет показывать ошибку. Отсоедините провода идущие к ESP8266 от контактов 0 и 1, произведите программирование, а после верните контакты на место и нажмите кнопку сброса в Arduino.
Микросхема ESP8266 – один из самых популярных инструментов для организации беспроводной связи в проектах умного дома. С помощью беспроводного контроллера можно организовывать связь по интерфейсу WiFi, обеспечивая проектам Arduino выход в интернет и возможность дистанционного управления и сбора данных. На основе ESP8266 созданы такие популярные платы как WeMos и NodeMcu, а также огромное количество самодельных проектов. В этой статье, мы узнаем, что из себя представляет ESP82266, какие бывают ее разновидности, как работать с ESP8266 в среде Arduino IDE.
ESP8266 – микроконтроллер с интерфейсом WiFi, который имеет возможность исполнять программы из флеш-памяти. Устройство было выпущено в 2014 году китайской фирмой Espressif и практически сразу же стало популярным.
Контроллер недорогой, обладает небольшим количеством внешних элементов и имеет следующие технические параметры:
- Поддерживает Wi-Fi протоколы 802.11 b/g/n с WEP, WPA, WPA2;
- Обладает 14 портами ввода и вывода, SPI, I2C, UART, 10-бит АЦП;
- Поддерживает внешнюю память до 16 МБ;
- Необходимое питание от 2,2 до 3,6 В, потребляемый ток до 300 мА в зависимости от выбранного режима.
Важной особенностью является отсутствие пользовательской энергонезависимой памяти на кристалле. Программа выполняется от внешней SPI ПЗУ при помощи динамической загрузки необходимых элементов программы. Доступ к внутренней периферии можно получить не из документации, а из API набора библиотек. Производителем указывается приблизительное количество ОЗУ – 50 кБ.
Особенности платы ESP8266:
- Удобное подключение к компьютеру – через USB кабель, питание от него же;
- Наличие встроенного преобразователя напряжения 3,3В;
- Наличие 4 Мб флеш-памяти;
- Встроенные кнопки для перезагрузки и перепрошивки;
- Все порты выведены на плату на две гребенки с шагом 2,5 мм.
Сферы применения модуля ESP8266
- Автоматизация;
- Различные системы для умного дома: Беспроводное управление, беспроводные розетки, управление температурой, дополнение к сигнализационным системам;
- Мобильная электроника;
- ID метки;
- Детские игрушки;
- Mesh-сети.
Распиновка esp8266
Существует огромное количество разновидностей модуля ESP8266. На рисунке представлены некоторые из них. Наиболее популярным вариантом является ESP 01.
Исполнение программы требуется задавать состоянием портов GPIO0, GPIO2 и GPIO15, когда заканчивается подача питания. Можно выделить 2 важных режима – когда код исполняется из UART (GPIO0 = 0, GPIO2 = 1 и GPIO15 = 0) для перепрошивки флеш-карты и когда исполняется из внешней ПЗУ (GPIO0 = 1, GPIO2 = 1 и GPIO15 = 0) в штатном режиме.
Распиновка для ESP01 изображена на картинке.
Описание контактов:
- 1 – земля, 8 – питание. По документации напряжение подается до 3,6 В – это важно учесть при работе с Ардуино, на которую обычно подают 5 В.
- 6 – RST, нужна для перезагрузки микроконтроллера при подаче на него низкого логического уровня.
- 4 – CP_PD, также используется для перевода устройства в энергосберегающий режим.
- 7 и 0 – RXD0 и TXD0, это аппаратный UART, необходимый для перепрошивки модуля.
- 2 – TXD0, к этому контакту подключается светодиод, который загорается при низком логическом уровне на GPIO1 и при передаче данных по UART.
- 5 – GPIO0, порт ввода и вывода, также позволяет перевести устройство в режим программирования (при подключении порта к низкому логическому уровню и подачи напряжения) .
- 3 – GPIO2, порт ввода и вывода.
Основные отличия Ардуино от ESP8266
- ESP8266 имеет больший объем флеш-памяти, при этом у ESP8266 отсутствует энергонезависимая память;
- Процессор ESP8266 быстрее, чем у Ардуино;
- Наличие Wi-Fi у ESP8266;
- ESP8266 потребляеn больше тока, чем для Ардуино;
Программирование ESP8266 в Arduino IDE
Программный комплект разработчика esp8266 включает в себя:
- Компилятор из пакета GNU Compiler Collection.
- Библиотеки, стеки протоколов WiFi, TCP/IP.
- Средство загрузки информации в программу контроллера.
- Операционная IDE.
Изначально модули ESP8266 поставляются с прошивкой от фирмы-изготовителя. С ее помощью можно управлять модулем с внешнего микроконтроллера, реализовывать работу с Wi-Fi как с модемом. Также существует множество других готовых прошивок. Некоторые из них позволяют настраивать работу модуля при помощи WEB-интерфейса.
Можно программировать из среды Arduino IDE. При ее помощи можно легко писать скетчи и загружать их в ESP8266, прошивать ESP8266, при этом не требуется сама плата Ардуино. Arduino IDE поддерживает все виды модулей ESP8266.
В настоящий момент для ESP8266 можно реализовать следующие функции:
- Основные функции языка Wiring. Управлять портами GPIO можно точно так же, как и пинами на плате Ардуино: pinMode, digitalRead, digitalWrite, analogWrite. Команда analogRead(А0) позволяет считать значения АЦП. При помощи команды analogWrite (pin, value) можно подключить ШИМ на нужном выходе GPIO. При value=0 ШИМ отключается, максимальное значение достигает константы, равной 1023.С помощью функций attachInterrupt, detachInterrupt можно выполнять прерывание на любом порте GPIO, кроме 16.
- Тайминг и delay. Используя команды millis и micros можно вернуть мс и мкс, которые прошли с момента старта. Delay позволяет приостановить исполнение программы на нужное время. Также функция delay(…) позволяет поддерживать нормальную работу Wi-Fi, если в скетче присутствуют большие элементы, которые выполняются более 50 мс. Yield() – аналог функции delay(0).
- Serial и Serial1 (UART0 и UART1). Работа Serial на ESP8266 аналогична работе на ардуино. Запись и чтение данных блокируют исполнение кода, если FIFO на 128 байт и программный буфер на 256 байт заполнены. Объект Serial пользуется аппаратным UART0, для него можно задать пины GPIO15 (TX) и GPIO13 (RX) вместо GPIO1(TX) и GPIO3(RX). Для этого после функции Serial.begin(); нужно вызвать Serial.swap();. Аналогично Serial1 использует UART1, который работает на передачу. Необходимый пин для этого GPIO2.
- Макрос PROGMEM. Его работа аналогична работе в Ардуино. Позволяет перемещать данные read only и строковые постоянные во flash-память. При этом в ESP8266 не сохраняются одинаковые константы, что приводит к дополнительной трате флеш-памяти.
- I2C. Перед началом работы с шиной I2C выбираются шины с помощью функции Wire.pins(int sda, int scl).
- SPI, OneWire – поддерживаются полностью.
Использование esp8266 для связи Ардуино по WiFi
Перед подключением к Ардуино важно помнить, что у ESP8266 напряжение питания не может быть выше 3,6, в то время как на пате Ардуино напряжение равно 5 В. Соединять 2 микроконтроллера нужно с помощью резистивных делителей. Перед подключением модуля нужно ознакомиться с распиновкой выбранного ESP8266. Схема подключения для ESP8266-01 представлена на рисунке.
3,3 В с Ардуино – на Vcc&CH_PD на модуле ESP8266, Земля с Ардуино – к земле с ESP8266, 0 – TX, 1 – RX.
Для поддержки стабильной работы ESP8266 необходим источник постоянного напряжения на 3,3 В и максимальный ток 250 мА. Если питание происходит от конвертера USB-TTL, могут происходить неполадки и сбои в работе.
Работа с библиотекой Wi-Fi для ESP8266 схожа с библиотекой для обыкновенного шилда. Имеется несколько особенностей:
- mode(m) – для выбора одного из трех режимов: клиент, точка доступа или оба режима единовременно.
- softAP(ssid) – нужен для создания открытой точки доступа.
- softAP(ssid, password) – создает точку доступа с паролем, который должен состоять не менее чем из 8 знаков.
- WiFi.macAddress(mac) и WiFi.softAPmacAddress(mac)– определяет МАС адрес.
- WiFi.localIP() и WiFi.softAPIP() – определение IP адреса.
- printDiag(Serial); – позволят узнать данные о диагностике.
- WiFiUDP – поддержка передачи и приема multicast пакета в режиме клиента.
Работа выполняется по следующему алгоритму:
- Подключение USB-TTL к USB и к ESP.
- Запуск Arduino IDE.
- Выбрать в меню инструменты нужный порт, плату, частоту и размер flash-памяти.
- Файл - Примеры - ESP8266WiFi - WiFiWebServer.
- Записать в скетче SSID и пароль сети Wi-Fi.
- Начать компиляцию и загрузку кода.
- Дождаться окончания процесса прошивки, отсоединить GPIO0 от земли.
- Поставить скорость 115200.
- Произойдет подключение, будет записан адрес IP.
- Открыть браузер, ввести в адресной строке номер IP/gpio/1
- Посмотреть монитор порта, если к выходу GPIO2 подключен светодиод, он должен загореться.
NodeMCU на базе esp8266
NodeMCU – это платформа, основанная на базе модуля esp8266. Используется для управления схемой на расстоянии при помощи интернета через Wi-Fi. Плата малогабаритная, компактная, стоит дешево, на лицевой стороне имеется разъем для USB. Рядом кнопки для отладки и перезагрузки микроконтроллера. Также установлен чип ESP8266. Напряжение питания – от 5 до 12 В, желательно подавать более 10 В.
Большим преимуществом платы является ее малое энергопотребление. Нередко их используют в схемах с автономным питанием. На плате расположены всего 11 портов общего назначения, из них некоторые имеют специальные функции:
- D1 и D2 – для интерфейса I2C/ TWI;
- D5-D8- для интерфейса SPI;
- D9, D10 – для UART;
- D1-D10 – могут работать как ШИМ.
Платформа имеет современное API для аппаратного ввода и вывода. Это позволяет сократить количество действий во время работы с оборудованием и при его настройке. С помощью прошивки NodeMCU можно задействовать весь рабочий потенциал для быстрой разработки устройства.
WeMos на базе esp8266
WeMos – еще один вид платформы, основанный на базе микроконтроллера esp8266. Соответственно, имеется Wi-Fi модуль, поддерживается Arduino IDE, имеется разъем для внешней антенны. Плата имеет 11 цифровых входов/выходов, которые (кроме D0) поддерживают interrupt/pwm/I2C/one-wire. Максимальное напряжение питания достигает 3,3 В. Также на платформе присутствует USB разъем. Аналоговый вход 1 с максимальным напряжением 3,2В.
Для работы с модулем нужно установить драйвер CH340 и настроить Ардуино IDE под ESP8266. Для этого нужно в меню настройки в строке «дополнительная ссылка для менеджера плат» добавить адрес http://arduino.esp8266.com/stable/package_esp8266com_index.json.
После этого требуется найти пакет esp8266 by ESP8266 и установить его. Затем нужно выбрать в меню инструменты микроконтроллер Wemos D1 R2 и записать нужный скетч.
Выводы по ESP8266
С помощью плат на основе микросхемы ESP8266 вы можете добавить в свои проекты возможности “большого интернета”, сделав их гораздо более интеллектуальными. Дистанционное управление, сбор и анализ данных на сервере, обработка голоса и работа с изображением – все это становится доступным, когда мы подключаем наш проект по WiFi к интернету. В следующих статьях мы подробно рассмотрим то, как можно программировать устройства на базе esp8266, а также уделим внимание таким популярным платам как WeMos и NodeMcu.
Часть 1. Подготовка ESP8266
Зачем эта статья? На хабре уже есть ряд статей про использование ESP в разных конфигурациях, но почему-то без подробностей о том, как именно все подключается, прошивается и программируется. Типа «я взял ESP, две пальчиковые батарейки, DHT22, закинул в коробку, потряс часик и термометр готов!». В итоге, получается странно: те, кто уже работают с ESP не видят в сделанном ничего необычного, а те, кто хочет научиться - не понимают с чего начать. Поэтому, я решил написать подробную статью о том, как подключается и прошивается ESP, как его связать с Arduino и внешним миром и какие проблемы мне попадались на этом пути. Ссылки на Aliexpress привожу лишь для представления порядка цен и внешнего вида компонентов.
Итак, у меня было два микроконтроллера, семь разных сенсоров, пять источников питания, температурный датчик DHT22 и целое множество проводков всех сортов и расцветок, а так же бессчетное количество сопротивлений, конденсаторов и диодов. Не то, чтобы все это было необходимо для термометра, но если уж начал заниматься микроэлектроникой, то становится трудно остановиться.
Питание
Для работы ESP8266 нужно напряжение 3.3В и ток не ниже 300мА. К сожалению, Arduino Uno не в состоянии обеспечить такой ток, как не в состоянии обеспечить его и переходники USB-UART (программаторы) типа FT232RL - их предел около 50мА. А значит придется организовать отдельное питание. И лучше бы, чтобы Arduino тоже работал от 3.3В, чтобы избежать проблем типа «я подал пятивольтовый сигнал на вывод RX модуля ESP, почему пахнет паленой пластмассой?».
Есть три решения.
2. Купить готовый модуль с регулятором напряжения, понижающий 5В до 3.3В. Пожалуй, это самый удобный вариант.
3. Собрать модуль самому из регулятора AMS1117 и одного танталового конденсатора на 22мкФ.
Я выбрал третий пункт, поскольку мне часто нужно 3.3В, я жадный и я люблю встраивать регуляторы прямо в блоки питания.
С AMS1117 все просто: если положить его текстом вверх, то напряжение на ногах растет слева направо: 0(Gnd), 3.3В (Vout), 5В (Vin).
Между нулем и выходом нужен танталовый конденсатор на 22мкФ (так по инструкции , что будет если поставить электролитический - я не проверял). У танталового SMD-конденсатора плюс там, где полоска. Немного чудовищной пайки совершенно не предназначенных для такого варварства SMD-компонентов и:
Обязательно проверяйте выходное напряжение. Если оно значительно меньше 3.3В (например, 1.17В) - дайте регулятору остыть после пайки и проверьте контакты. Если поставите конденсатор больше, чем на 22мкФ, то мультиметр может показать более высокое напряжение.
Почему именно AMS1117? Он широко используется. Его вы можете найти почти везде, даже в Arduino Uno, как правило, стоит AMS1117-5.0.
Если вы знаете что-то схожих габаритов и цены, еще более простое в использовании - напишите, пожалуйста.
Важный момент. Не знаю уж почему, но AMS1117 крайне капризно относится к качеству соединений. Контакты должны быть надежны. Лучше - пропаяны. Иначе он на тестах выдает 3.3В, но под нагрузкой не выдает ничего.
Подключение ESP8266
Я выбрал модель 07, поскольку у нее отличный металлический экран, который работает как защита от наводок, механических воздействий и как радиатор. Последнее обеспечивает разницу между сгоревшим модулем и просто нагревшимся. Кроме того, есть гнездо под внешнюю антенну.
Чтобы чип запустился нужно соединить VCC и CH_P через резистор 10кОм. Если такого нет, то сгодится любой из диапазона 1-20кОм. Кроме того, конкретно модель 07 еще требует, чтобы GPIO15 (самый ближний к GND) был «на земле» (этого на картинке не видно, потому что соединение с другой стороны).
Теперь берем переходник USB-UART, переключаем его на 3.3В и подключаем RX к TX, TX к RX и GND к «земле» (у меня без этого передача нестабильна). Если вы не можете переключить на 3.3В, то можно использовать простейший резисторный делитель напряжения: соедините ESP RX с TX переходника через сопротивление в 1кОм, а ESP RX с «землей» через 2кОм. Существует масса более сложных и более надежных способов связать 3.3В и 5В, но в данном случае и так сойдет.
И соединяемся на скорости 9600 по нужному COM-порту (можно посмотреть в диспетчере устройств).
Я использую SecureCRT, Putty тоже подойдет, а ценители Линукса и так знают, что делать и где смотреть.
(AT+RST перезагружает чип)
Если ничего не происходит - выключите - включите питание, если все равно ничего не происходит - проверьте соответствие TX/RX, попробуйте переставить их местами или припаять к чипу.
Иногда чип в ходе издевательств экспериментов зависает и тогда его надо обесточить, в том числе отключив и переходник (например, вытащив его из USB), поскольку чипу хватает даже поступающих крох питания, чтобы упорно тупить и не работать.
Иногда фокусы с переходником вешают USB-порт. Можно в качестве временного решения использовать другой USB-порт, но вообще лучше перезагрузить компьютер.
Иногда при этом меняется номер COM-порта. Под Linux это можно решить с помощью udev.
Если вместо текста приходит мусор, то проверьте настройки скорости. Некоторые старые чипы работают на 115200.
На старте чип нагревается, но если он реально горячий и продолжает греться - отключайте и проверяйте все соединения. Чтобы на корпус не попадало +3.3В, чтобы 5В к нему вообще никуда не приходили, чтобы «земля» переходника была соединена с «землей» чипа. Модели с металлическим экраном очень трудно сжечь (но нет ничего невозможного), а на модели без экранов жалуются, мол даже небольшая ошибка может стать последней в жизни чипа. Но это я не проверял.
Прошивка
Мой выбор - NodeMCU . У нее проблемы с памятью и поддержкой железа, но это многократно окупается простотой кода и легкостью отладки.
Так же потребуются NodeMCU flasher и LuaLoader (последнее - опционально, есть и другие клиенты для работы с этой прошивкой).
Выключаем чип. Подсоединяем GPIO0 к земле и включаем чип:
Если ничего не происходит и поля AP MAC/STA MAC пустые - проверьте еще раз, чтобы GPIO0 был на «земле».
Если прошивка началась, но зависла - посмотрите в закладке Log, у меня почему-то конкретно этот чип отказался прошиваться на FT232RL, но зато без проблем прошился на PL2303HX на скорости 576000. PL2303HX в указанном варианте не имеет переключения на 3.3В, чтобы им воспользоваться нужно открыть пластиковый корпус и перепаять провод с 5V на 3.3V, есть варианты с пятью выходами : 3.3, 5, TX, RX, Gnd.
Обратите внимание: STA MAC поменялся. Подозреваю, что flasher его неправильно показывал, но требуется проверка.
Для экономии сил и нервов можно взять готовый или полуготовый вариант.
Есть одноразовые адаптеры с удобной разводкой.
Есть
Как и многие другие самоделкины, я регулярно использую микроконтроллеры AVR для всяких разных любительских поделок. А благодаря концепции «Arduino» эти поделки теперь приобретают еще и элегантный вид. Действительно, за какие-то 300-400 рублей мы получаем миниатюрную многослойную плату с маской, шелкографией и с полностью разведенной на ней периферией для микроконтроллера (причем в SMD исполнении!). Я уже не говорю о всевозможных подключаемых модулях этой же «Arduino» серии: датчиках, контролерах, дисплеях и целых наборов, так нужной нам дополнительной периферии. И опять же всё также недорогих и в прекрасном исполнении. Практически уже нет необходимости, что-то разводить и допаивать на «коленке».
Но все эти разнообразные любительские поделки, требуют естественно, предварительного программирования. Да и в последующем при разных усовершенствованиях, постоянно приходится эти поделки перепрошивать . Понятное дело, что удобнее делать это дистанционно, чем постоянно таскать их к обычному программатору. Вообще, благодаря той же платформе «Arduino», вариантов и здесь много: Bluetooth, ZigBee, радиоканал с вашим личным протоколом, IR, и даже Wi-Fi. Все они позволяют наладить беспроводной контакт с вашим микроконтроллером. Но мы же остановимся на последнем варианте. Основных причин здесь четыре:
1: современно, интернет вещей же!
2: беспроводной роутер есть в каждой квартире, регистрируй в домашней сети свои устройства и вуаля!
3: ваши поделки осуществляют революционный скачок в своём развитии; мало того, что их можно программировать на расстоянии, они теперь ещё и сами могут общаться с окружающим их миром: электронные часы самостоятельно берут точное время с часовых NTP-серверов, исполнительные устройства управляются с другого конца города или страны, регистрирующие девайсы сохраняют накопленные данные в облако и т.д. и т.п.
4: есть замечательная серия микросхем ESP8266 на которой не очень легко всё это реализовать.
Далее, в этой статье на примере механической руки на сервоприводах - будет разобрано и продемонстрировано удаленное программирование и обмен данными с ПК (или чего угодно) с устройствами на базе AVR микроконтроллеров. Сразу же хочу отметить, что все программы приведенные в дальнейшем являются чисто демонстрационными и никакой коммерческой ценности не имеют. Поэтому претензии, типа, почему программатор такой кастрированный и мало функциональный или почему нет дополнительных сервисов, которые есть везде, не принимаются. Поскольку коды открытые, любой желающий может допилить их по своему усмотрению, мне же для работы, пока хватает и таких.
Предполагается, что читатель уже знаком и с «Arduino» модулями (шилдами) и с подключением и прошивкой ESP8266. На самом деле в Сети выложено огромное количество материалов разъясняющих азы работы с этими девайсами и мне не хотелось бы здесь повторяться. Для новичков в конце статьи есть перечень полезных ссылок по этим вопросам, где можно найти кучу информации, почему это всё у вас не работает. По своему опыту бывшего инженера электронщика могу ответственно заявить, что 99 % неполадок сводится к следующему:
1. Плохие контакты. Поскольку «Arduino» шилды, подразумевают коммутацию с друг другом через провода вида «папа-мама», а не через пайку, то очень часто что-нибудь, где-нибудь, да отходит. Проверяйте. Да и вообще, как говорится, электроника это наука о контактах.
2. Проблемы с питанием. Не подавайте 5 вольт питания туда, где требуется 3.3. Иногда из ESP8266 от этого идёт дым. Хотя с другой стороны логические сигналы от пятивольтовых устройств она переваривает без проблем.
3. Проблемы с достаточной мощностью питания. ESP8266 имеет подлую натуру и иногда может потреблять чуть ли не триста миллиампер, хотя до этого могла удовлетворяться и тридцатью. Соответственно хилый стабилизатор 3.3 вольт платы «Arduino», к которому вы ничтоже сумняшеся, её подключили, тут же просаживается до микроскопических значений. А вы не можете понять, почему оно, то работает, то нет.
4. Путаница с выводами. Всегда проверяйте, какие сигналы куда идут. Приемник RXD должен соединяться с передатчиком TXD, также как и TXD с RXD, но MOSI должно соединяться с MOSI, а MISO с MISO и так далее.
5. Не рассчитывайте на внутрисхемные подтягивающие резисторы в ESP8266, всегда подтягивайте выводы к нулю или питанию, через 5-10 килоомные внешние резисторы, а не просто перемычкой. Иначе можете в лучшем случае получить невиданный доселе ток потребления, а потом обонять неприятный запах горелого пластика.
6. Косяки программного обеспечения. Поскольку ПО для индивидуальных юзеров пишется таким же энтузиастами, то периодически вылазят глюки самих прошивок и баги при обновлении версий этих же прошивок. Лечится ползанием по соответствующим форумам, иногда даже англоязычным. Некоторые товарищи даже утверждали, что и сама микросхема ESP сырая как погода в Питере, но с другой стороны существует также мнение что с 2014 (года её первого выпуска) ситуация с этим кардинально улучшилась (в отличие от погоды).
7. Загадочные глюки. Это редкое, но нервопотребляющее явление. У меня к примеру, не шилось удалённо одно «Arduino»устройство. Вернее шилось но с ошибками. Но шилось без ошибок, если на нем висел шлейф от программатора (но без самого программатора). «АГА», сказал я себе и припаял конденсатор 15 пФ, между выводом передачи данных и выводом синхронизации. Всё заработало. Но день убил.
Итак, давайте начнем с самого простого. У нас есть механическая конечность MechArm (но не такая какую собрал Говард Воловитс) сделанная в Китае и персональный компьютер с Windows. Задача - удаленная прошивка программы и управление ея с компьютера.
Для управляющего контроллера возьмем симпатичную миниатюрную платку Arduino Nano c камнем ATmega328P. Эта плата прекрасно впихивается внутрь механической руки.
Теперь определимся каким образом мы её будем программировать. Существуют три основных способа наиболее подходящих для удаленной прошивки: через интерфейс SPI, через встроенный загрузчик, через порт JTAG.
Самый простой вариант, это конечно встроенный загрузчик (бутлоадер). Это заранее прописанная во FLASH память, программа, которая по определенному протоколу получает код, (допустим по самому простому UART) и специальными командами записывает его в место расположения загружаемой программы. Так работает, например, сам загрузчик ARDUINO IDE. После сброса или старта, загрузчик ждет какое-то время данные на приём и если не дожидается начинает исполнение программы с нулевого адреса. Если данные приходят, он пишет их в программную секцию. После следующего сброса загруженная программа начинает исполняться. В деталях, возможно, я описал неточно, но суть именно такая. В итоге нам требуется всего три вывода для программирования: приемник RTD, сброс RESET и земля GND. Вообще, используется еще и передатчик TRD, для верификации записанной программы, но для простых демонстрационных приложений (не для атомной электростанции), проверку можно опустить.
Сам загрузчик пишется на языке ассемблера, есть примеры простых загрузчиков в даташитах на AVR. Можно раскопать существующий уже загрузчик, если он в открытом доступе и просто использовать его в готовом виде, если известен протокол по которому он работает. Единственный нюанс, что для этого требуется настроить AVR в специальный режим, путем прошивки специальных фьюз-битов, что делается обычным программатором, а потом им же зашить сам загрузчик в память микроконтроллера (то есть без программатора один раз все равно не обойтись).
Второй вариант, это программирование по последовательному интерфейсу SPI. Тут уж внутреннего загрузчика нет, а программируем мы, посылая специальные команды и затем данные, по вышеупомянутому интерфейсу. Здесь у нас загрузчик уже внешний, но его все равно писать надо. При передаче используются в добавление к RESET и GND уже четыре дополнительных вывода MOSI, MISO - данные, SLK синхронизация, СS - выбор кристалла. Но вообще также можно убрать MISO и СS. Данные будут только приниматься (верификации программы тогда не будет), а кристалл у нас и так всего один.
У каждого подхода есть свои плюсы и минусы (а JTAG я вообще не рассматривал, поскольку жизнь человеческая коротка). Но в итоге я склонился к SPI поскольку на ассемблере писать было лень, а открытых готовых загрузчиков я не нашел (просто хорошо не искал).
Для построения беспроводного канала я, как уже говорилось, выбрал крайне широко известную в настоящее время микросхему ESP8266 - микроконтроллер, а точнее целый SoC (System-on-Chip) китайского производителя Espressif с интерфейсом Wi-Fi. Помимо Wi-Fi он отличается возможностью исполнять программы из внешней флэш-памяти. А конкретно для своего проекта я взял ESP8266-07 с 512 Кб памяти на борту.
Вообще годится любая ESP8266, где есть лишние ноги для реализации SPI. Поэтому самая простая ESP8266-01 нам не подойдет, так как у неё разведено совсем мало ножек для портов ввода-вывода. Но с другой стороны разница в цене на них меньше ста рублей, а доступны они одинаково. Ну и большие отладочные платы с ESP, где для удобства разведена куча периферии, нам тоже не годятся, так как не влазят, туда куда мы их хотим впихнуть, в нашу механическую руку.
Глобальная суть идеи в общем была такова. С компьютера на ESP без проводов по WI-FI (в рамках вашей домашней сети) передается тело загружаемой в микроконтроллер программы. А ESP уже по проводам с использованием интерфейса SPI записывает эту программу непосредственно во FLASH память микроконтроллера. Потом естественно сбрасывает его и дает возможность загруженной программе выполняться. Кроме того в ESP должен быть независимый блок, который заведует еще и обменом данными с микроконтроллером, так как мы хотим не только программировать, ни и еще обмениваться с ним данными. В частности для проекта с MechArm, после записи программы, мы ещё передаем сигналы управления сервоприводами, дабы привесть эту руку в движение. Поэтому на самой ESP нам желательно поднять TCP сервер для передачи программы и UDP сервер для управления MechArm. Соответственно эти серверы присоединяются к домашней сети и внимательно слушают, нет ли там желающих загрузить новый код в MechaArm или помахать кому-нибудь ею.
Так-то, я нашел в Сети, прошивки уже позволяющие производить программирование AVR по воздуху, но там главная проблема в том, что для чего другого эту прошивку использовать уже нельзя. А нам хотелось бы после программирования и общаться с AVR также удаленно.
Какое ПО мы будем использовать:
Для ПК, я писал всё на JAVA, среда IntelliJ IDEA . Но в принципе, можно на чём угодно, нам там главное написать клиент, который будет отправлять программу для прошивки AVR на ESP8266.
Сами программки для AVR я пишу в ATMEL STUDIO , на языке С, редко на ассемблере. Скетчи Arduino не использую принципиально, практически любая нужная библиотека пишется за час другой, причем с полным пониманием её работы. Я пробовал скетчи, но пока у вас нет на AVR операционной системы, скетчи так и будут отбирать у друга периферию и регулярно глючить. Да сама IDE Arduino по сравнению с ATMEL STUDIO, конечно вещь весьма примитивная. Но тут вопрос, конечно, спорный, гуманитариям и школьникам веселее и проще будет, наверное, со скетчами.
Для программирования ESP8266 я использовал прошивку NodeMCU, а программы писал на языке Lua. Нет, я бы с удовольствием писал бы на Java и на С, но их же на ESP нет. Luа язык в применении к нашей задаче не сложный, освоить его пара пустяков. А собственно для загрузки программ и их отладки на ESP, я взял IDE ESPlorer . Отечественный бесплатный продукт (но можете сделать автору donation), который конечно не сравнить со средами упомянутыми выше, но как говорится дарёному коню… Но чтобы пользоваться ESPlorer и писать на LUA, нам сначала необходимо сменить в микросхеме ESP8266 базовую прошивку (поставляемую от производителя) на новую. В этом предприятии нам поможет программа NODE MCU PyFlasher. В смысле, поможет её перепрошить. А саму прошивку мы сами создадим и получим в руки на сайте создателей: NodeMCU .А более подробно об этом процессе вы можете прочесть
Всё очень доступно и понятно. К базовым библиотекам добавляем поддержку SPI и битовые операции (в LUA в нашем случае битовые операции перегружены и от них мало толку). Много в прошивку библиотек пихать не следует, так как из-за наличия всякого разнообразного софта на ESP8266 остается совсем мало памяти, какие-то жалкие 20 кБ.
Конечно, вы можете просто взять готовую прошивку, коих много уже болтается в Интернете, но не рекомендую. Хотя бы потому, что на некоторых нет поддержки битовых операции (а они нам нужны) и нет регулирования скорости передачи данных по SPI.
Соответственно, они передаются по умолчанию со скоростью 40 Мгц делённые на какой-то небольшой коэффициент и поэтому AVR их переваривать не успевает.
Кому лень создавать прошивку можете скачать мою из облака .
Теперь у нас есть прошивка и нам надо загрузить её в ESP8266 вместо базовой. Для этого нам пригодится простейший адаптер USB - UART.
Присоединяем ножки TXD к RXD, а RXD к TXD, делаем общей землю, но не используем, как казалось, удобный вывод питания 3.3 В на адаптере. В большинстве случаев ESP8266 просадит его напрочь. Поэтому запитываем ёё отдельно. Потом переводим ESP в режим программирования (GP0 на землю, если кто забыл) и запускаем NODE MCU PyFlasher .
Главное, не забудьте стереть флэш-память (yes, wipes all data), иначе в зависимости от версии прошивки после программирования в памяти может остаться ненужный мусор, который в свою очередь будет сыпать мусор в консоль при дальнейшей работе. До этого я использовал софт, где не было опции стереть предварительно память, намучался жутко, так как ничего не работало. А ларчик просто открывался, только правда на англоязычном форуме создателей NODE MCU.
Заимев же нужную прошивку мы теперь можем писать и отлаживать программы на языке LUA (там еще MicroPython, но я им не пользовался) используя при этом очень удобные API от NODE MCU. Запускаем уже упомянутый ранее ESPlorer.
Также настраиваем его для работы с ESP8266, устанавливаем параметры последовательного соединения. Всё достаточно просто и многократно изложено в Интернете.
Теперь пишем программульку на LUA, кою потом загрузим в ESP8266:
Загрузчик Lua для AVR, записываемый в ESP8266
function InstrProgrammingEnable () -- instruction for MC "enable programming" p=0 while p<31 do p=p+1 pin=8 gpio.write(pin, gpio.LOW) spi.send(1, 0xAC,0x53) read = spi.recv(1, 8) spi.send(1,0,0) gpio.write(pin, gpio.HIGH) if (string.byte(read)== 83) then print("connection established") p=33 if(p==31) then print("no connection") end end end end function ProgrammingDisable () pin=2--END OF ESET FOR MK gpio.mode(pin, gpio.INPUT) pin=8 gpio.mode(pin, gpio.INPUT) pin=5--CLK MASTER for SPI gpio.mode(pin, gpio.INPUT) pin=6--MISO MASTER for SPI gpio.mode(pin, gpio.INPUT) pin=7--MOSI MASTER for SPI gpio.mode(pin, gpio.INPUT) end function ProgrammingEnable () pin=2-- RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) pin=2--POZITIV FOR 4MSEC RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(4) gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) tmr.delay(25000) end function InstrFlashErase() pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0xAC,0x80,0,0) gpio.write(pin, gpio.HIGH) tmr.delay(15000) pin=2--RESET FOR MK gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) tmr.delay(20000) gpio.write(pin, gpio.LOW) print("FLASH is erased") InstrProgrammingEnable () end function InstrStorePAGE(H, address, data) pin=8 gpio.write(pin, gpio.LOW) spi.send(1,H,0,address,data) gpio.write(pin, gpio.HIGH) tmr.delay(500) end function InstrWriteFLASH(page_address_low,page_address_high) pin=8 gpio.write(pin, gpio.LOW) spi.send(1,0x4C,page_address_high,page_address_low,0) gpio.write(pin, gpio.HIGH) tmr.delay(5000)-- иногда не прописываются флэш при малых задержках end function Programming (payload) pin=8--CS MASTER for SPI gpio.mode(pin, gpio.OUTPUT, gpio.PULLUP) pin=4--LED LIGHTS ON LOW gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.LOW) print(string.len(payload)) page_count = 7 -- пишем 1 килобайт for k =0 ,page_count ,1 do--quantity of pages for i=0 , 127, 2 do-- -1 address = i/2 data=payload:byte(i+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x40,address,data) -- tmr.delay(100)-- otherwise not in time write data =payload:byte(i+1+1+128*k) if data == nil then data = 0xff end InstrStorePAGE(0x48,address,data) -- tmr.delay(100) end page_address_low=bit.band(k ,3)*64 -- 3 это двоичное 11 page_address_high=k/4+frame1024*2 tmr.delay(1000) InstrWriteFLASH(page_address_low,page_address_high) tmr.wdclr() end pin=4--LED gpio.mode(pin, gpio.OUTPUT) gpio.write(pin, gpio.HIGH) end --MAIN BLOCK wifi.setmode(wifi.STATION) --wifi.sta.config("имя сети","пароль") -- set SSID and password of your access point station_cfg={} tmr.delay(30000) station_cfg.ssid="имя сети" tmr.delay(30000) station_cfg.pwd="пароль" tmr.delay(30000) wifi.sta.config(station_cfg) tmr.delay(30000) wifi.sta.connect() tmr.delay(1000000) print(wifi.sta.status()) print(wifi.sta.getip()) while (wifi.sta.status()~=1) do if(wifi.sta.status()==5) then break end end sv=net.createServer(net.TCP,30) tmr.delay(100) print("SERVER READY") sv:listen(4000,function(c) c:on("receive", function(c, payload) print(payload) if (payload =="program\r\n") then c:send("ready\r\n") print("ready for program\r\n") spi.setup(1, spi.MASTER, spi.CPOL_LOW, spi.CPHA_LOW, spi.DATABITS_8,320,spi.FULLDUPLEX) ProgrammingEnable () tmr.delay(100) InstrProgrammingEnable () tmr.delay(100) InstrFlashErase() tmr.delay(100) frame1024=0--номер переданого фрей мов st=net.createServer(net.TCP,30) st:listen(4001,function(c) c:on("receive", function(c, payload) tmr.wdclr() Programming (payload) frame1024=frame1024+1 end) end) end if (payload =="data\r\n") then c:send("ready\r\n") print("ready for data\r\n") srv=net.createServer(net.UDP) tmr.delay(1000) pin=10 gpio.write(pin, gpio.HIGH) uart.setup(0,9600,8,0,1,0) srv:listen(5000) srv:on("receive", function(srv, pl) pl=pl*1 --print(pl) uart.write(0,pl) tmr.wdclr() end) end if (payload =="stop\r\n") then if(st~=nil) then st:close() frame1024=0 ProgrammingDisable () print("stop program") end if(srv~=nil) then srv:close() print("stop data") end end end) end) end)
Где соответствующие функции выполняют следующие действия:
function InstrProgrammingEnable () – переводит микроконтроллер в режим программирования специальной командой отправляемой по SPI.
function ProgrammingEnable () – просто ресетим AVR на 25 мс перед началом программирования
function ProgrammingDisable () – после окончания программирования, переводим выводы SPI в ESP8266 в неактивное состояние, чтобы они не мешались нам при выполнения кода на микроконтроллере (вдруг они там используются)
function InstrFlashErase() – затираем флэш-память на микроконтроллере перед началом программирования. Зачем это нужно объяснять не нужно.
function InstrStorePAGE(H, address, data) – по этой команде во внутренний буфер микроконтроллера записывается байт программы. Но это ещё не сама флэш запись, так как флэш пишется здесь постранично по 128 байт.
function InstrWriteFLASH(page_address_low,page_address_high) – а вот это уже запись флэш и она требует времени, обратите внимание на временную задержку 5 000 мкс.
function Programming (payload) – самая большая и важная функция использующая и вышеперечисленные функции. Она берет передаваемую программу кусками по 1024 байт, делит их на байтики и формирует для них адреса, а затем отправляет в микроконтроллер во внутренний буфер и через каждый 128 байт инициализирует запись флэш. Потом берет следующий килобайт кода и повторяет операцию, естественно со смещением в адресах, чтобы писать дальше а не затирать записанное. Вначале, я пробовал пересылать программы целиком, но при превышении 6 килобайт в ESP8266 элементарно кончается доступная память и она вылетает. Один килобайт оказался самой удобной единицей, ибо аккуратно делится на части и удобно передается по TCP (нам же надо его с компьютера ещё получить). Больший размер тоже не нужен, TCP, сами знаете, в текущей версии ограничивает передаваемый пакет, в 1500 что ли байт (но у меня передавался почему-то 1440, вроде).
Как бы ничего сложного, но несколько подводных камней пришлось преодолеть.
Регистрируемся в беспроводной сети.
Создаем вначале TCP сервер, который слушает три команды:
1. “program” (будем программировать),
2. “data” (будем меняться данными),
3. ”stop” (всё прекращаем).
Если мы программируем, то сначала инициализируем SPI и создаем еще один TCP сервер, который хапает данные (код прошиваемой программы) покилобайтно и вызывает под них функции программирования микроконтроллера. Я понимаю, что выглядит глупо создавать второй сервер, но это необходимость, ибо местное API поддерживает создание только одного сокета, а нам необходимо разделять команды ”program” и “data” собственно с передаваемыми данными, ибо на глаз они не различаются, там байты и тут байты.
Если же мы хотим не программировать, а обмениваться данными, посылая их в нашем случае в микроконтроллер, то мы сначала отправляем по TCP строку ”data”. В ответ на это будет создан уже UDP сервер (я напомню, что мы управляем динамически механической рукой и нам задержки с формированием TCP пакетов не нужны, да и вообще отправлять один байт целым TCP кадром моветон). А UDP дейтаграммы у нас будут маленькими и формироваться будут быстро.
После инициализируется UART, и каждый принимаемый в беспроводном виде байт, отправляется уже по проводу TXD на микроконтроллер, который обязан, буде там прошита соответствующая программа, его принять. Обмен данными в другом направлении организовать также не сложно, но я пока его не реализовывал.
Ну и по команде ”stop” вышеупомянутые сервера (кроме самого первого) закрывают соединения и самый главный сервер вновь переходит в состояние ожидания команд ”program” и “data”.
Поскольку SPI интерфейс программно эмулируется в ESP8266, то порты ввода-вывода для сигналов CS, CLK, MISO,MOSI, RESET (для AVR), можете использовать любые доступные, а не те, что указаны у меня в загрузчике. Кроме того оказалось, что CS и MISO в принципе тоже можно в данном случае оборвать, будет работать и без них. Ну и один вывод задействуется на встроенный в плату ESP8266 светодиод, чтобы мигал иногда и показывал, что программа ещё живая.
Проверок на ошибки записи не делается (за исключением первого запроса к AVR, но эта информация просто выводится на консоль), EEPROM не программируется, больше 32 Кб не шьется – короче есть ещё над чем поработать. Скорость обмена по SPI примерно 115 Кбит, за несколько секунд всё прошивается, примерно, как у обычного последовательного программатора типа ISP500).
Берите код, вписывайте свои сети и пароли, компилируйте на ESplorer, обзывайте его “init” (чтобы запускался при рестарте) и отправляйте на ESP8266. Должно работать. В смысле работать беспроводным программатором, как минимум.
Мы же теперь займемся управляющей стороной – персональным компьютером.
По сути, нам нужно взять файл формата HEX, в который превращаются ваши программы, написанные в среде ATMEL STUDIO и отправить его по WI-FI на известный нам порт сокета (в данном случае 4000). Маленькая загвоздка в том, что нам нужен двоичный файл BIN для пересылки, а ATMEL STUDIO радует нас только HEXом. Выхода здесь два; или перевести его в формат BIN специальной программой конвертером, типа WinHex или сделать это самим в своей программе. Я пока не сделал, но вроде это не сложно, там надо отрезать заголовок и сделать что-то ещё.
В итоге программу-загрузчик я написал на JAVA (в основном потому, что больше ни на чем не умею), работая в просто прекрасной и бесплатной среде IntelliJ IDEA. В ней создается TCP клиент, который ищет сервер запущенный на ESP8266. Если находит, то связывается с ним и отправляет ему файл расположенный по такому-то адресу. Код ниже.
Загрузчик файлов на JAVA, работающий на стороне ПК
import java.io.*; import java.net.*; import java.util.ArrayList; import java.util.List; public class Net { public static void main(String args) { new Http_client(4000); } } class Http_client extends Thread { int port; String s; String Greetings_from_S; Http_client(int port){ this.port = port; start(); } public void run() { //192.168.1.113 -это адрес ESP8266 в моей сети. Но вообще, узнается из общения с роутером // лучше сделать его статическим, роутеры это умеют try (Socket socket = new Socket("192.168.1.113", port)) { PrintWriter pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true); pw.println("program");// Greetings with SERVER System.out.println("program"); BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); Greetings_from_S = br.readLine(); System.out.println(Greetings_from_S); if(Greetings_from_S.equals("ready")) { try { File file = new File("d:BlinkOUT.bin");// адрес выгружаемого файла BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file)); byte data = new byte; bis.read(data); byte data_buffer = new byte; int frames = data.length/1024; System.out.println(frames); int residy = data.length%1024; for (int i = 0; i < frames;i++) { for (int k = 0; k< (1024); k++) { data_buffer[k] = data; } sendingChunk(data_buffer); } byte data_buffer2= new byte; for (int i = 0; i < residy;i++) { data_buffer2[i] = data; } sendingChunk(data_buffer2); pw.println("stop");// System.out.println("stop program"); } catch (Exception e) { System.out.println(e); } } } catch (Exception e) { System.out.println(e); } } public void sendingChunk (byte data_buffer){ try (Socket socket = new Socket("192.168.1.113", 4001)){ BufferedOutputStream bos = new BufferedOutputStream((socket.getOutputStream())); bos.write(data_buffer); bos.flush(); System.out.println(data_buffer.length); } catch (Exception e) { System.out.println(e); } } }
Тут конечно накручено лишнего, всякие ready, в принципе не нужны. Если уж TCP соединение установлено, то оно установлено. Единственная проблема была в том, что файл никак не хотел отправляться ровными кусками по 1024 байт, как мне очень требовалось, хотя я и явно указывал размер. Видимо там какой-то финальный буфер недоступный из JAVA, и он отправляет пакеты размером, каким ему хочется, что для приемной стороны совершенно неприёмлемо. Сначала я пробовал сделать задержку, чтобы буфер уставал ждать следующие куски и отправлял как есть. Но задержка стала работать, когда достигла 10 секунд, что мне как-то показалось многовато на один передаваемый килобайт.
Но потом я заметил, что почему-то первый кусок всегда идет ровный, какой был заказан, а уже со второго начинается непредсказуемая вакханалия. Поэтому я сделал так, чтобы клиент открывал соединение, отправлял порцию кода в 1024 байт и закрывал соединение. И так пока не отправится весь файл. Всё успешно заработало.
Единственное, для запуска необходимо поставить на компьютер среду выполнения JAVA. Но я обычно запускаю сразу из IntelliJ IDEA ибо там в консоли всегда видно, что происходит (но и здесь среда JAVA нужна). Хотя, конечно, по-умному надо сделать GUI. То есть окошко, где выпадает путь к файлу, возможность менять там же в окне номера портов и ну и прочие нужные вещи. И все это собрать в виде исполняемого файла.
А таперича, как говаривал Коровьев, вернемся граждане, собственно к механической конечности MechArm, что была упомянута в самом начале. У нас теперь есть возможность удаленно её запрограммировать, а затем ею поуправлять. Перейдём к программе управления на стороне микроконтроллера.
В данном случае нам необходимо контролировать четыре сервопривода. Вот таких.
Такой привод управляется прямоугольными импульсами, периода 20 мс (50Гц) с коэффициентом заполнения от 2 до 4 процентов. То есть 2% это полный поворот в одну сторону, 4% в другую. Задача как раз для встроенного в AVR ШИМ.
Один сервопривод используется для движения вправо-влево; второй на себя – от себя; третий вверх-вниз; четвертый – сама клешня, которая должна сжиматься и разжиматься. Всё написано на С и откомпилировано до HEX файла в ATMEL STUDIO. Немного странный вид программы связан с тем, что изначально рука управлялась с клавиатуры привязанной проводами к микроконтроллеру. Но провода вчерашний день, надо эволюционировать дальше.
Можно конечно использовать скетчи для сервоприводов от ”ARDUINO”, но мне они не понравились. Самому писать интересней. К тому же все четыре сервопривода должны работать одновременно, а не в мультиплексированном режиме, когда ШИМ переключается на каждый сервопривод поочередно. Ибо гравитацию никто не отменял и поднятая вверх конечность, моментально опустится, если на соответствующий сервопривод перестанут поступать управляющие импульсы. Я не уверен, что ”ARDUINO” скетч обеспечивает одновременный режим работы для четырех серво. А вот сами мы вполне можем написать программку отвечающую нужным требованиям. Да и вообще при отсутствии операционной системы, которая отделяет агнцев от козлищ, применение скетчей конкурирующих за периферийные устройства микроконтроллера (а мы даже и не знаем заранее какие) дело слишком багопроизводительное.
Вот сам код, который мы записываем в Arduino Nano посредством ESP8266-07.
Программа для управление MechArm для микроконтроллера AVRmega328P
#define F_CPU 16000000
#include Теперь нам осталось лишь написать управляющую программу, простите за тавталогию, для управления механической рукой уже непосредственно с компьютера по WI-FI. Что там происходит понятно из окошка. Текст программы я здесь не привожу (он доступен на В процессе изучения и проектирования всё более сложных проектов приходит время, когда возникает необходимость и желание научиться работать с таким распространенным видом связи как WiFi. Так как именно такой вид связи может позволить комфортно создать единую сеть для ваших умных домашних устройств и управлять ими, например, с мобильного телефона, планшета или компьютера, то есть другими словами создать самый настоящий умный дом, который обойдется вам в десятки раз дешевле, чем покупать готовые решения в магазине. Применение WiFi конечно не ограничивается на этом и примеров использования данного вида связи настолько много, что перечислять их нет смысла, и если Вы попали на эту страницу, значит, использование WiFi вам уже зачем-то понадобилось, осталось только разобраться, как правильно с ним работать. Разбираться мы будем на основе самого дешевого и популярного WiFi модуля ESP8266-01
. Купить WiFi модуль ESP8266-01 можно у нас на сайте. Один из главных плюсов такого модуля это наличие памяти и своего микроконтроллера на плате, что позволяет работать ему самостоятельно, загрузив скетч непосредственно в сам модуль. Модификаций WiFi модуля ESP8266 на самом деле достаточно много и перечислять их здесь мы не будем, научившись работать с одним, Вы без проблем сможете начать работать и с другими. Хочется сразу отметить, что работа с WiFi может показаться довольно не простым занятием, и если в Вашем багаже мало законченных проектов, лучше пока отказаться от WiFi связи и использовать в своих проектах радиосвязь, работа с которой гораздо проще для понимания. По работе с WiFi модулями создают целые сообщества и тематические форумы, что лишний раз доказывает насколько большинству людей трудно сразу разобраться с данным видом связи, а перечитывая всю информацию, у большинства людей просто опускаются руки. Скорей всего и мне не удастся всю важную информацию вместить в рамках только одной этой статьи, да и нет в этом смысла, иначе получится очередная путаница. Я попытаюсь пойти по пути строгой последовательности самых важных моментов, чтобы Вы смогли начать понимать принцип работы данного вида связи и далее уже просто развивать самостоятельно свои навыки в этом направлении. И так, давайте приступим и для начала разберем выводы WiFi модуля ESP8266-01
. VCC
- питание модуля от 3V до 3.6V GND
- земля. RST
- вывод Reset отвечающий за перезагрузку модуля. CH_PD
- "chip power-down" при подаче питания на него активизируется работа модуля. TX
- передача данных (UART интерфейс) RX
- прием данных (UART интерфейс) GPIO0
GPIO2
- порт ввода/вывода общего назначения Выводы GPIO0 и GPIO2 - это точно такие же цифровые выводы, с которыми мы работаем на платах Arduino для взаимосвязи с различными датчиками, и применяются они в случае реализации самостоятельной работы на внутреннем микроконтроллере WiFi модуля ESP8266-01. Для надежного питания модуля ESP8266-01 используйте внешний стабилизированный источник питания на 3.3V и лучше не пытайтесь брать питание от своей платы Arduino, так как модуль потребляет ток до 215mA и это может плохо закончится для вашей отладочной платы. Где взять стабилизированный источник питания на 3.3V надеюсь для вас не проблема, в противном случае вам явно еще рано заниматься данным модулем. Мне, например, нравится использовать для быстрого сбора схем на макетных платах вот такой модуль питания 3.3V и 5.0V YWRobot , который позволяет быстро получить стабилизированное напряжение на 3.3V или 5V на соответствующих дорожках питания макетной платы. Подключаем плюс (+)
от нашего источника питания 3.3V к выводу VCC
модуля ESP8266-01, а минус (-)
источника питания подводим к выводу GND
. В таком состоянии на модуле включится красный светодиод, сигнализирующий нам о правильном подключении питания. Для того чтобы модуль активизировался, необходимо также соединить плюс (+)
источника питания с выводом CH_PD
модуля ESP8266-01 и желательно это сделать сразу через резистор 10кОм. Теперь, когда мы включим питание, на модуле должен загореться красный светодиод и пару раз быстро мигнуть синий светодиод. Если у вас так все и происходит, значит все отлично, вы правильно все подсоединили и ваш модуль рабочий. В противном случае еще раз проверьте подключение, либо замените модуль, так как он скорей всего не рабочий. Идем дальше. Для работы с WiFi модулем ESP8266 нам необходим переходник USB-UART. Переходники бывают разные, например: FT232RL , CP2102 , PL2303 . Но мы предположим, что у вас нет таких переходников, и будем в качестве переходника USB-UART использовать плату Arduino. Я буду использовать для этого плату Arduino NANO, а вы можете использовать любую другую имеющуюся в вашем распоряжении. Подключение на любой плате один в один идентично. Производим подключение согласно следующей схеме. Так как WiFi модуль ESP8266-01 мы питаем от отдельного внешнего источника питания, незабываем, что мы должны всегда соединять между собой землю всех источников питания в наших проектах. Поэтому мы соединяем вывод GND
платы Arduino c землей (-)
нашего внешнего источника питания 3.3V, предназначенного для питания модуля ESP8266-01. Вывод TX
вашей платы Arduino соединяем с выводом TX
модуля ESP8266-01. По этой линии будут передаваться данные от WiFi модуля к плате Arduino. Кто знаком с UART интерфейсом, может задуматься: "Но как же так? Везде учили, что TX должен соединяться с RX. TX передает информацию, а RX принимает". И Вы будете правы. Всё верно всегда TX соединяется с RX, но именно в случае, когда мы делаем из Arduino переходник UART, необходимо подключать устройства напрямую. Считайте это исключением из правил. Линию RX
вашей платы Arduino подключаем так же напрямую к линии RX
модуля ESP8266-01. По этой линии будет передаваться информация от платы Arduino на плату WiFi модуля. Но делаем это соединение через так называемый делитель напряжения, состоящий из двух резисторов номиналами 1кОм и 2кОм. Уменьшить напряжение на этой линии с помощью двух резисторов (делителя напряжения) нам необходимо, так как плата Arduino передает логический сигнал напряжением 5V, а WiFi модуль работает с напряжением 3.3V. Для преобразования логического сигнала мы могли бы использовать специальную платку преобразователя логических уровней, что было бы конечно правильней, но опять же предположим, что у вас ее нет, и нам пришлось пойти более простым путем и сделать это с помощью делителя напряжения. Всё необходимое для дальнейшей работы мы пока подключили, но у нас остаются не задействованные ещё 3 вывода (GPIO0
, GPIO2
и RST
) на WiFi модуле ESP8266-01
. Для стабильной работы WiFi модуля нам необходимо эти оставшиеся не задействованные выводы подтянуть к плюсовой (+)
линии питания модуля через резисторы в 10кОм. Это избавит нас от различных помех (наводок) и сделает работу модуля стабильной. Лучше это делать сразу. В противном случае не удивляйтесь, что ваш модуль постоянно перегружается, выдает не понятную информацию, либо вообще не хочет работать. Использовать подтягивающие резисторы на незадействованных выводах микроконтроллера должно быть, как правило, если хотите стабильной работы в ваших проектах. И снова проверяем работоспособность модуля WiFi ESP8266-01. Включаем питание и смотрим, чтобы зажегся красный светодиод и пару раз мигнул синий. Если всё так происходит, значит отлично, идем дальше. В противном случае проверяем правильность соединений, а так же качество всех контактов. Может быть просто банальная ситуация, когда десять раз все перепроверили и убедились, что все правильно подключили, но включая модуль, видите, что синий светодиод ведет себя не адекватно, постоянно горит, постоянно мигает или вообще не на что не реагирует. Это может происходить из-за плохого контакта на какой-то линии. Например, собирая схему на макетной плате, какой-нибудь из резисторов неплотно сидит на своем месте и это вызывает помехи. Проверяйте качество соединений. Модуль очень чувствителен. Не пренебрегайте этим. Это частая причина не стабильной работы. В общем, с подключением мы закончили. Сейчас нам необходимо подготовить программу Arduino IDE для работы с WiFi модулем ESP8266-01. Для этого нам надо скачать и установить в Arduino IDE необходимый архив с библиотеками, примерами и платами ESP, который впоследствии позволит нам заливать скетчи прямо в микроконтроллер модуля ESP8266-01, менять прошивку и т.д. В рамках этой статьи нам скорей всего эти настройки и не понадобятся, но мне кажется, что после того, как мы разобрались с подключением модуля, порядок действий будет правильным, если мы сразу скачаем все необходимое для работы с Arduino IDE. Тут все в принципе просто. Запускаем программу Arduino IDE
и переходим в меню "Файл" - "Настройки"
В появившемся окне в верхнем поле пишем "esp8266". В итоге в окне у нас останется только нужная прошивка. При нажатии на прошивку появится кнопка "Установка"
. Нажимаем на кнопку "Установка"
и ждем, пока все установится. Архив достаточно большой, около 150 мегабайт, так что придется подождать. После окончания установки. Перезагружаем Arduino IDE и видим, как появились новые платы ESP в меню "Инструменты" - "Платы". На этом всё. С настройкой Arduino IDE мы закончили. Пока нам эти настройки не нужны, но в дальнейшей работе нам без них не обойтись. Всё мы подключили и подготовились, теперь можем начать разбираться с управлением. На самом деле, сейчас будет продолжение проверки и настройки модуля с помощью AT команд и без этого ни как не обойтись. WiFi модули реализованы так, что всё общение с ними происходит с помощью так называемых AT команд, которые зашиты в прошивке модуля. Мы не будем здесь перечислять все AT команды, их достаточно много и если захотите все тщательно изучить, можете без труда их найти в интернете. А мы будем использовать сейчас только самые необходимые для начала работы. И так, подключаем нашу плату Arduino через USB кабель к компьютеру. А внешний источник питания, который питает WiFi модуль ESP8266-01
пока включать не надо. Запускаем программу Arduino IDE, выбираем в меню "Инструменты" нашу плату Arduino, в моем случае это Arduino NANO, а вы выбираете свою. Так же не забываем выбрать порт к которому подключена наша Ардуинка. Надеюсь все это вы понимаете и делать умеете. Открываем мониторинг порта "Инструменты" - "Монитор порта"
. Выбираем скорость порта 74880
(на такой скорости происходит запуск модуля) и слева в списке выбираем "NL & CR" Вот теперь подключаем внешний источник питания который питает наш WiFi модуль. После чего вы должны увидеть в мониторе порта примерно такую информацию. Здесь мы видим некоторую информацию по нашему WiFi модулю (скорость, количество памяти на борту и т.д.). Полученная информация может отличаться в зависимости от версии прошивки WiFi модуля. Не будем на этом заострять внимание. Важно другое. Внизу мы видим набор бессмысленных символов, это означает, что скорость порта (74880 бод), которую мы выставили, подходит только для начальной загрузки модуля, чтобы увидеть нормально эту информацию, но эта скорость не подходит для нормального общения с WiFi модулем. Чтобы подобрать правильную скорость порта, будем просто изменять скорость порта и посылать в порт (поле сверху и кнопка отправить) символы AT
пока не получим ответ ОК
. Если Вы попробуете прямо сейчас послать символы AT
в порт на скорости 74880, то будете получать очередные один-два бессмысленных символа в ответ. Попробуйте сразу выставить скорость 115200 бод и послать команду AT. Чаще всего модули прошиты на эту скорость. Вот такую картину вы должны увидеть в вашем мониторе порта. Если все равно в ответ пришел непонятный набор символов, понижайте скорость и повторяйте отправку AT
команды, пока в ответ не вернется ОК
. Если вы перепробовали все скорости и не добились правильного ответа, значит вам не повезло и модуль прошит прошивкой с нестандартной скоростью. Тогда остается только перепрошить модуль нормальной прошивкой, но это тема отдельной статьи. Надеюсь, что все хорошо и скорость правильную вы подобрали. Кстати если вы попробуете выключить и снова включить WiFi модуль, после того как подобрали правильную скорость, то уже вместо той самой первоначальной информации, которая корректно отображалась на скорости 74880 бод, вы наоборот, увидите беспорядочный набор символов, но в конце вы увидите слово "ready". Но у нас есть возможность посмотреть эту первоначальную информацию в нормальном виде на правильной скорости, для этого необходимо программно перезагрузить модуль с помощью AT-команды AT+RST
. Чтобы узнать версию прошивки вашего WiFi модуля ESP8266-01, необходимо в монитор порта отправить команду AT+GMR
и в ответ вы получите примерно следующую информацию: WiFi модуль ESP8266-01 может работать как в режиме точки доступа, так и в режиме клиента. Чтобы разрешить модулю работать сразу во всех режимах, отправьте в монитор порта команду AT+CWMODE=3
и в ответ вы должны получить ОК
. Команда AT+CWLAP
позволит посмотреть все WiFi точки доступа, которые видит в данный момент ваш модуль. Мой модуль, например, видит на данный момент в зоне своего покрытия всего три WiFi точки доступа. Ответ должен быть примерно таким: Например, мы знаем пароль к третьей точке доступа и чтобы подключиться к ней выполняем команду AT+CWJAP="имя","пароль"
, в моем случае эта команда выглядит AT+CWJAP="dsl_unlim_512_home","11111111"
, на что получаем успешный ответ: Параметры команды записываются на флеш память WiFi модуля ESP8266-01, и если мы выключим модуль и опять его включим, он автоматически подключится к этой точке доступа. Смотрите случайно в команде не допустите пробел, иначе получите в ответ ERROR
. Необходимо обратить внимание, что в последних версиях прошивки рекомендуют использовать команду AT+CWJAP_CUR
, то есть команда будет выглядеть AT+CWJAP_CUR="имя","пароль".
Если вдруг мы забыли, к какой точке доступа подключен наш модуль, необходимо послать команду AT+CWJAP?
или AT+CWJAP_CUR?
и в ответ получим ту точку доступа, к которой подключен WiFi модуль на данный момент. С подключением и первоначальной настройкой WiFi модуля ESP8266-01
мы разобрались. Модуль работает и готов для реализации ваших дальнейших проектов. Разобрать все возможные примеры работы с данным модулем в рамках одной статьи просто не возможно и мы этим займемся в следующих статьях. А для тех, кто не очень дружит с программированием, но очень хочет побыстрей начать управлять своими проектами с помощью WiFi, рекомендую познакомить с конструктором WiFi проектов RemoteXY . Этот сайт поможет вам без особого труда создать интерфейс управления для вашего мобильника или планшета и с помощью него управлять своим устройством, к которому вы подключите WiFi модуль.
Суть программы ясна из текста и комментариев. Мы используем счетчик Т1 для образцового периода 20 мс и счетчики Т0, Т2 для выдачи ШИМ сигналов на четыре линии порта ввода-вывода, благо каждый из этих двух счетчиков, может работать на два устройства.
В программе устанавливаются начальные положения сервоприводов, через загрузку счетных регистров OCR0A, OCR0B, OCR2A,OCR2B. Также вводятся константы ограничители, поскольку нам не всегда нужен размах в 180 градусов. Ну и дальше, по прерыванию от UART, программа ловит число отправленное ESP8266 (от 1 до 8) и переводит его в команду для соответствующего сервопривода. Приводов четыре, каждый работает в двух направлениях, поэтому целых чисел от одного до восьми вполне хватает. Как только число выбрано, содержимое вышеупомянутых регистров счетчиков либо инкрементируется либо декрементируется, соответственно изменяя скважность управляющего импульса и угол поворота выбранного сервопривода. Те приводы, которые мы не выбирали, сохраняют старое значение угла поворота, (поскольку содержимое соответствующих регистров хоть и обновлялось, но не менялось) и продолжают удерживать механическую руку в прежнем положении.
Код также написан на JAVA, но немного облагорожен. Появился GUI и возможность редактировать номера портов и сетевой адрес ESP8266. 
Давайте рассмотрим, что мы здесь сделали. Сразу обратите внимание на то, что мы замкнули перемычкой на плате Arduino выводы RST
и GND
. Такая манипуляция отключает микроконтроллер и позволяет сделать из нашей платы Arduino самый настоящий переходник USB-UART.
