Arduino обмен данными с компьютером. Трушин А.Н., Арутюнян М.Г
Как и многие другие самоделкины, я регулярно использую микроконтроллеры 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. Что там происходит понятно из окошка. Текст программы я здесь не привожу (он доступен на Настало время для объединения этих двух методик, чтобы получить полноценный двухсторонний обмен информацией между Android и Arduino. Для этого, мы соберем простенький проект с использованием ультразвукового дальномера и пьезо-буззера. На экране устройства с Android отображается активити с кнопкой "Измерить", при нажатии на которую, на плату Arduino приходит соответствующая команда. Плата Arduino обрабатывает команду и начинает цикл измерений, после чего вычисляется средняя дистанция до препятствия в сантиметрах. Данное расстояние до обьекта, передается обратно в Android-устройство, где отображается в виде текста, а также на ползунке (ProgressBar). Итак, для начала необходимо определится с управляющими командами. Они должны быть одинаково определены и в Arduino и в Android устройстве. Я выбрал следующие числа: С первыми двумя командами получилось немного запутано, т.к. я не смог заставить Android корректно принимать один посыл с данными (пробовал и в цикле передавать и по времени, но Android упорно не хочет принимать данные, подозреваю, что это связанно с ADB и при использовании Accessory Mode таких проблем быть не должно). Поэтому когда Arduino принял команду 1 (разрешение передачи) он производит замер расстояния и включает беспрерывную передачу данных в цикле. Как только Android принял данные, он передает к Arduino команду 2, чтобы тот остановил передачу данных. Скетч для Arduino:
#include
#include
// Adb connection.
Connection * connection; // Adb connection.
#define COMMAND_SEND_TRUE 1 // команда разрешения передачи
#define COMMAND_SEND_FALSE 2 // команда запрета передачи
#define COMMAND_PLAY_BEEP 3 // команда включения буззера
const int numOfReadings = 10; // кол-во замеров (элементов массива)
int readings; // значения измерений в массиве
int arrayIndex = 0; // индекс элемента в массиве
int total = 0; // всего значений
int averageDistance = 0; // средняя дистанция
// настройка пинов и переменных для УЗ датчика
int echoPin = 2; // DYP_ME007 ECHO pin
int initPin = 3; // DYP_ME007 TRIG pin
int BeeperPin = 8; // pin буззера
unsigned long pulseTime = 0; // длительность пульса в микросекундах
unsigned long distance = 0; // расстояние в (см)
boolean SendToAndroid = false;
void setup() {
pinMode(initPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(BeeperPin, OUTPUT); // Буззер
// формируем массив
for (int thisReading = 0; thisReading < numOfReadings; thisReading++) {
readings = 0;
}
Serial.begin(115200);
// Инициализация подсистемы ADB.
ADB::init();
// Open an ADB stream to the phone"s shell. Auto-reconnect. Use any unused port number eg:4568
connection = ADB::addConnection("tcp:4568", true, adbEventHandler);
}
void loop() {
if(SendToAndroid == true) makeDimension();
ADB::poll(); // Poll the ADB subsystem.
}
void adbEventHandler(Connection * connection, adb_eventType event, uint16_t length, uint8_t * data)
{
if (event == ADB_CONNECTION_RECEIVE) // Если приняли данные
{
Serial.print("data:"); // Вывод в Serial Monitor для отладки
Serial.println(data,DEC);
if((data) == COMMAND_SEND_TRUE) SendToAndroid = true; // Флаг, что надо вкл. передачу данных
else if ((data) == COMMAND_SEND_FALSE) SendToAndroid = false; //Флаг, что данные приняты и откл. передачу данных
else if ((data) == COMMAND_PLAY_BEEP) playBeep();
}
else if (event == ADB_CONNECTION_OPEN) Serial.println("ADB connection open");
else if (event == ADB_CONNECTION_CLOSE) Serial.println("ADB connection close");
else {
Serial.println(event);
}
}
void makeDimension() {
for (int i = 0; i < numOfReadings; i++) {
digitalWrite(initPin, HIGH); // посылаем импульс длительностью 10мс
delayMicroseconds(10);
digitalWrite(initPin, LOW);
pulseTime = pulseIn(echoPin, HIGH); // Считываем длительность пришедшего импульса
distance = pulseTime/58; // Дистанция = (длит. импульса / 58) см
total= total - readings;
readings = distance;
total= total + readings;
arrayIndex = arrayIndex + 1;
// После того, как достигли последнего элемента, начинаем сначала
if (arrayIndex >= numOfReadings) {
arrayIndex = 0;
}
//Serial.println(distance, DEC);
}
averageDistance = total / numOfReadings; // вычисляем среднюю дистанцию
//Serial.println(averageDistance, DEC);
connection->write(2,(uint8_t*)&averageDistance); // Отсылаем 2 байта
delay(10);
}
void playBeep() {
for (int j = 0; j < 10; j++) {
analogWrite(BeeperPin, 20);
delay(50);
analogWrite(BeeperPin, 0);
delay(150);
}
}
В самом начале мы определяем 3 константы - это команды для передачи сообщений между устройствами: COMMAND_SEND_TRUE = 1, COMMAND_SEND_FALSE = 2, COMMAND_PLAY_BEEP = 3 Обработчик adbEventHandler()
вызывается каждый раз при принятии данных и при наступлении других событий от ADB (открытие и закрытие соединения). Функция makeDimension()
производит 10 замеров расстояний, а затем вычисляет по ним среднее значение, которое через команду connection->write >()
2-мя байтами отправляется в Android устройство. С функцией playBeep()
все просто - она предназначена для проигрывания 10-ти коротких звуков через буззер. Наше окно активити будет состоять из следующих ключевых элементов: XML файл данного активити см. в прикрепленных файлах Файл для главного Activity содержит следующий код: Package com.example.arduino54;
import java.io.IOException;
import org.microbridge.server.Server;
import org.microbridge.server.AbstractServerListener;
import com.example.arduino54.R;
import android.os.AsyncTask;
import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Button;
public class MainActivity extends Activity {
private int Distance = 0;
public final String APP_NAME = "arduino54";
public final byte COMMAND_SEND_TRUE = 1; // Команда разрешения передачи
public final byte COMMAND_SEND_FALSE = 2; // Команда запрета передачи
public final byte COMMAND_PLAY_BEEP = 3; // Команда включения буззера
public final int SYS_COMMAND_DATA = 0; // Внутренняя команда: передача данных
public final int SYS_COMMAND_CONNECTED = 1; // Внутренняя команда: соединение установлено
public final int SYS_COMMAND_DISCONNECTED = 2; // Внутренняя команда: соединение потеряно
Server server = null;
ImageView connectedImage;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Создаем TCP сервер (на основе сервера MicroBridge LightWeight)
try
{
server = new Server(4568); //Этот же порт необходимо использовать и на ADK-плате
server.start();
} catch (IOException e)
{
Log.e(APP_NAME, "Unable to start TCP server", e);
System.exit(-1);
}
connectedImage = (ImageView) findViewById(R.id.imageConnected);
connectedImage.setAlpha(20);
Button Button1 = (Button)findViewById(R.id.button1);
Button1.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
try
{
server.send(new byte {(byte) COMMAND_SEND_TRUE}); //Посылаем данные
//Log.d(APP_NAME, "data_send:"+bSend);
} catch (IOException e)
{
Log.e(APP_NAME, "Problem sending TCP message", e);
}
}
});
server.addListener(new AbstractServerListener() {
@Override
public void onReceive(org.microbridge.server.Client client, byte data)
{
Log.d(APP_NAME, "data0:"+data+"; data1:"+data);
if (data.length<2) Log.e(APP_NAME, "Размер данных менее 2-х байт:"+data.length);
else {
try
{
server.send(new byte {(byte) COMMAND_SEND_FALSE}); //Посылаем данные
} catch (IOException e)
{
Log.e(APP_NAME, "Problem sending TCP message", e);
}
}
Distance = ((data << 8) | (data & 0xFF)); // Формируем слово из 2-х байт
//Any update to UI can not be carried out in a non UI thread like the one used
//for Server. Hence runOnUIThread is used.
runOnUiThread(new Runnable() {
//@Override
public void run() {
new UpdateData().execute(Distance,SYS_COMMAND_DATA);
}
});
}
//@Override
public void onClientConnect(org.microbridge.server.Server server, org.microbridge.server.Client client){
Log.d(APP_NAME, "ClientConnected");
runOnUiThread(new Runnable() {
public void run() {
new UpdateData().execute(0,SYS_COMMAND_CONNECTED);
}
});
}
public void onClientDisconnect(org.microbridge.server.Server server, org.microbridge.server.Client client){
Log.d(APP_NAME, "ClientDisconnected");
runOnUiThread(new Runnable() {
public void run() {
new UpdateData().execute(0,SYS_COMMAND_DISCONNECTED);
}
});
}
});
}
@Override
protected void onDestroy (){
super.onDestroy();
server.stop();
}
class UpdateData extends AsyncTask< Integer, Integer, Integer> {
// Called to initiate the background activity
@Override
protected Integer doInBackground(Integer... ArdState) {
if((ArdState < 20) && (ArdState != 0)){ //Если расстояние меньше 20см
try
{
server.send(new byte {(byte) COMMAND_PLAY_BEEP});
} catch (IOException e)
{
Log.e(APP_NAME, "Problem sending TCP message", e);
}
}
return (ArdState); //Возвращаем в onPostExecute()
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
// Not used in this case
}
@Override
protected void onPostExecute(Integer... result) {
Log.d(APP_NAME, "onPostExecute:"+result);
Log.d(APP_NAME, "onPostExecute:"+result);
if(result == 1){
connectedImage.setAlpha(255);
}
else if(result == 2){
connectedImage.setAlpha(20);
}
TextView txt_Distance_Arduino = (TextView) findViewById(R.id.textDistance);
txt_Distance_Arduino.setText(String.valueOf(result+" см")); // Выводим на activity дистанцию
ProgressBar mProgressBar = (ProgressBar)findViewById(R.id.progressBar1);
mProgressBar.setProgress(result);
}
}
}
Здесь мы для класса server
определяем метод server.addListener(new AbstractServerListener() {})
, а также: onReceive(), onClientConnect()
и onClientDisconnect()
который вызывается при получении данных от сервера MicroBridge, при соединении и разьединении. На кнопке Button1 мы вешаем обработчик события нажатия setOnClickListener()
. При нажатии на кнопку вызывается данный метод и посылает на плату Arduino команду COMMAND_SEND_TRUE, по которой Arduino производит измерение расстояния и передачу значения расстояния. В методе onReceive()
, как только мы приняли данные, то мы сразу же отсылаем обратно команду COMMAND_SEND_FALSE, для того, чтобы Arduino выключил передачу пакетов. Об этом алгоритме я писал выше. Обратите внимание, что для передачи данных отдельному потоку, мы используем внутренние системные команды SYS_COMMAND_DATA, SYS_COMMAND_CONNECTED и SYS_COMMAND_DISCONNECTED . Команды передаются 2-м элементом массива, а в первом элементе содержится измеренное расстояние, полученное от Arduino. При срабатывании события onClientConnect()
, создается новый поток в который передается массив с командой SYS_COMMAND_CONNECTED (в нашем случае 0), и в методе onPostExecute()
путем установки значения Alpha в максимальное 255, происходит отображения иконки соединения. При поступлении команды SYS_COMMAND_DISCONNECTED устанавливается Alpha в значение 20, иконка становится блеклой и ее почти не видно, это означает что соединение не установлено. Прозрачность Alpha устанавливается методом setAlpha(int)
. Когда поток принимает данные из метода onReceive, то в методе doInBackground()
происходит сравнение условия, и если расстояние не рано нулю и меньше 20 см, то методом server.send()
посылается команда COMMAND_PLAY_BEEP для включения буззера на плате Arduino. В методе onPostExecute()
происходит вывод UI элементов для отображения численного значения расстояния и полоски на прогрессбаре. В прикрепленном файле вы можете скачать проекты для Arduino и Android, а также все необходимые библиотеки
Загрузим стандартный пример «Physical Pixel» через меню
File\Examples\4.Communication\PhysicalPixel. Эта программа ждет данные от
компьютера. При получении символа ‘H’ тестовый индикатор загорается, при
получении символа ‘L’ – гаснет. Разберем ее исходный код: int
outputPin =
13
;
//здесь храним номер контакта
void
setup()
void
loop()
Обратите внимание на вложенные условия и порядок следования отрывающих и
закрывающих фигурных скобок. Для удобства чтения кода программы каждый
следующий уровень вложенности сдвинут вправо. Кроме того, редактор помогает
читать код – если Вы поставите курсор справа от скобки, он выделит
соответствующую ей парную скобку. Как проверить работу этой программы после того, как Вы загрузите ее в
микроконтроллер? Нужно найти способ отправлять символы на COM-порт
компьютера, чтобы микроконтроллер принимал и обрабатывал их. Существует
множество вариантов решения этой задачи. Используем встроенный в среду разработки Arduino монитор COM-порта Это наиболее простой, и понятный начинающим метод. Монитор COM-порта запускается через меню Tools\Serial Monitor, либо через
панель инструментов. В старых версиях ПО монитор был доступен только
через панель инструментов: .
Вызвав монитор убедитесь, что выбрана та же
самая скорость обмена, что и в программе микроконтроллера. Теперь можно
вводить любые символы в поле ввода справа, и нажимать кнопку «Send» –
введенные символы будут отправлены в порт, и там их примет Ваша программа.
Введите там латинскую букву «H», нажмите «Send» – тестовый светодиод
загорится. Если послать «L» – погаснет. Кстати, все данные, которые Ваша
программа будет посылать на COM-порт будут выводиться в окне снизу. Используем программу эмуляции терминала HyperTerminal Это немного более сложный в реализации вариант обмена. В состав Windows обычно включена программа эмуляции терминала
HyperTerminal. В Windows XP ее можно найти в меню Пуск \ Все программы
\ Программы \ Стандартные \ Связь \ HyperTerminal. При запуске нужно
отказаться от создания подключения, выбрать меню Файл \ Свойства. В
появившемся диалоге выбрать свой COM-порт, нажать «Настроить», и настроить
параметры связи в соответствии с рисунком: Можно воспользоваться другим эмулятором терминала - все они обычно имеют
подобный функционал и схожие настройки. Нажмите «OK» в обоих окнах, и попав в основное окно программы, любую
клавишу на клавиатуре – HyperTerminal подключится к COM-порту. Теперь все
набираемые на клавиатуре символы попадают через COM-порт в микроконтроллер,
а все, что отправляет микроконтроллер, попадает на экран. Понажимайте
клавиши «H» и «L» (следите за выбранным языком, и регистром) – тестовый
светодиод должен загораться и гаснуть. Напишем собственную программу для ПК! Этот вариант для настоящих энтузиастов, желающих программировать не только
Freeduino, но и ПК. А почему бы и нет? Нам не потребуется изучать детали
программирования последовательного порта под Windows, или еще какие-то
сложные вещи. Специально для решения подобных простых задач существует язык
Processing (http://processing.org),
очень похожий синтаксисом и даже средой разработки на программное
обеспечение Arduino. Установите и запустите Processing – Вы увидите среду разработки, похожую на
Arduino. Исходный код программы для языка Processing есть в комментариях ниже
основного текста примера Physical Pixel. Здесь он приведен с минимальными
изменениями – мы исправили открытие порта, чтобы можно было легко заменить
его номер: import
processing.serial.*
;
Запустите программу (через меню Sketch \ Run) – появится окно с квадратом,
при помещении в который курсора мыши, будет загораться светодиод на Freeduino. Описание языка Processing и его возможностей выходит за рамки этого
простого повествования, но во многих примерах для Arduino в комментариях
ниже основного текста программы представлен код Processing для ПК,
взаимодействующий с Freeduino. Коммуникация по последовательному порту
, по умному называемая как универсальный асинхронный прием / передача (UART), как правило, используется для программирования и отладки Arduino через порт USB. Существуют разные датчики и приборы, которые используют UART как метод основной связи, и иногда нам нужно объединять два и больше Arduino между собой для обмена информацией. Тем не менее, у большинства Arduino имеется только один последовательный порт, который используется при связи по USB. Но как же связать такой контроллер с другим? Конечно использование Arduino типа Mega или подобного решает эту задачу, ведь у него до четырех последовательных портов, но если нужна связь с простыми платами из линейки Ардуино, тут нужно искать другой выход. Существует особая программная библиотека, которая имитирует UART порт на других цифровых контактах. У нее имеются несколько недостатков, но в общем она работает.
Так что нам понадобится для демонстрации подобной коммуникации:
2 Arduino контроллера
Соединительные провода
Выполните следующие шаги, для подключения двух Arduino UNO, с помощью программного последовательного порта:
1. Например, воспользуемся выводами 8 и 9 для RX и TX на обоих Arduino, соедините контакт 8 на одном Arduino с контактом 9 на другом, и контакт 9 на первом
с контактом 8 на втором.
2. Соедините общий провод GND обеих Arduino вместе.
3. Подключите один Arduino к USB компьютера, и соедините вывод 5В этого контроллера с таким же выводом другого или подайте на второй отдельное питание.
Вот реализация с использованием выводов 8 и 9 для RX и TX:
Следующий код разделен на две части. Arduino мастер будет получать команды от компьютера и передавать их по программному последовательному порту. Вот первая часть кода:
// Подключаем библиотеку Software Serial #include // Объявляем задействованные дискретные каналы контроллера для связи Serial.begin(9600); // Обычная скорость передачи данных softSerial.begin(9600); // инициализация программного последовательного порта // Проверяем получение команд от компьютера if (Serial.available()){ // Отправляем полученную команду компьютера на программный UART А вот и код подчиненного (слейва), который интерпретирует символы, отправленные от мастера. Если пришол символ «а», он включит встроенный светодиод. Если получен символ «х», то светодиод будет потушен: // Подключение библиотеки Software Serial #include // Назначение задействованных дискретных каналов SoftwareSerial softSerial(8, 9); // RX, TX // Дискретный канал, на котором висит встроенный светодиод softSerial.begin(9600); // Инициализация программного последовательного порта pinMode(LED, OUTPUT); // Определение светодиодного вывода как выход // Проверяем, есть ли что-нибудь в буфере программного последовательного порта if (softSerial.available()){ // Читаем один символ из буфера программного последовательного порта и сохраняем его переменную com
int com = softSerial.read(); // Действуем соответственно полученному символу if (com == "x"){ // Выключение светодиода digitalWrite(LED, LOW); else if (com == "a"){ // Включение светодиода digitalWrite(LED, HIGH); Программный последовательный порт имитирует стандартный последовательный порт на различных цифровых выводах Arduino. Это довольно удобно в целом, но нужно понимать, что это программная имитация, не поддержанная аппаратно. Это означает, что при этом тратятся общие ресурсы контроллера, в частности время выполнения цикла программы и памяти. А вообще, оно работает просто как обычный последовательный порт. Все функции, присутствующие в нормальном последовательном порте также присутствуют и в программном.
Для начала взглянем на программу мастера, который получает команды по обычному последовательному порту с компьютера и отправляет подчиненному контроллеру. В начале кода мы подключаем библиотеку
SoftwareSerial.h SoftwareSerial softSerial(8, 9); // RX, TX При этом будет вызвана параллельная связь, в данном случае программная. Она будет использовать вывод 8 для чтения (RX) и вывод 9 для передачи (TX). Далее подробнее остановимся на том, какие именно выводы следует выбирать. Используя объявленный объект библиотеки, мы можем использовать все функции, характерные для обычного аппаратного параллельного порта, такие как softSerial.read(), softSerial.write() и так далее. В следующей части кода мы проверяем пришло ли что-нибудь с аппаратного порта. И если что-то пришло, мы считываем это и отправляем в программный порт: if (Serial.available()){ softSerial.write(Serial.read()); В коде подчиненного контроллера использована самая простая реализация управления светодиодом командами через последовательный порт с одной только разницей, что тут используются команды с программного порта. Меняется только синтаксис и вместо привычных функций Serial.read(), Serial.available() и так далее нужно писать softSerial.read() и softSerial.available(). Программный UART имеет некоторые важные ограничения и недостатки. Вот некоторые из них. Мы не можем использовать любые дискретные выводы плат Arduino для организации программного порта. Для Tx, вообще-то можем использовать любые, но для Rx можно использовать только те, которые поддерживают внешние прерывания. У плат Arduino Leonardo и Micro могут быть использованы только выводы 8, 9, 10, 11, 14, 15 и 16, в то время как у Mega или Mega 2560 могут быть использованы только выводы 10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68 и 69.
Можно организовывать и более одной программной последовательной связи, однако одновременно данные может получать только одно соединение. Это может становиться причиной потери данных. Но существует альтернативная библиотека программного параллельного порта, написанная Полом Стофрегеном, которая призвана решить как раз данную проблему. http://www.pjrc.com/teensy/td_libs_AltSoftSerial.html
Суть программы ясна из текста и комментариев. Мы используем счетчик Т1 для образцового периода 20 мс и счетчики Т0, Т2 для выдачи ШИМ сигналов на четыре линии порта ввода-вывода, благо каждый из этих двух счетчиков, может работать на два устройства.
В программе устанавливаются начальные положения сервоприводов, через загрузку счетных регистров OCR0A, OCR0B, OCR2A,OCR2B. Также вводятся константы ограничители, поскольку нам не всегда нужен размах в 180 градусов. Ну и дальше, по прерыванию от UART, программа ловит число отправленное ESP8266 (от 1 до 8) и переводит его в команду для соответствующего сервопривода. Приводов четыре, каждый работает в двух направлениях, поэтому целых чисел от одного до восьми вполне хватает. Как только число выбрано, содержимое вышеупомянутых регистров счетчиков либо инкрементируется либо декрементируется, соответственно изменяя скважность управляющего импульса и угол поворота выбранного сервопривода. Те приводы, которые мы не выбирали, сохраняют старое значение угла поворота, (поскольку содержимое соответствующих регистров хоть и обновлялось, но не менялось) и продолжают удерживать механическую руку в прежнем положении.
Код также написан на JAVA, но немного облагорожен. Появился GUI и возможность редактировать номера портов и сетевой адрес ESP8266. 
Алгоритм работы
В Android также происходит обработка данных: если расстояние до обьекта меньше 20 см, то происходит передача управляющего сигнала на Arduino для включения буззера. Это естественно можно было бы сделать и в коде Arduino, но для наглядности я возложил эту задачу на плечи Android устройства. В общем получился небольшой парктроник.
1 - команда разрешения передачи
2 - команда запрета передачи
3 - команда включения буззераПрограмма для Arduino
Программа для Android
кнопка (Button) - для посылки команды измерения расстояния
текстовое поле (TextView) - для отображения полученного расстояния
прогресс-бар (ProgressBar) - для визуального отображения расстояния (максимум - 500 см)
иконка соединения (ImageView) - отображается при активном соединении с Android устройством.
int
val;
//здесь будет храниться принятый символ
{
Serial.begin
(9600
)
;
//установка порта на скорость 9600 бит/сек
pinMode(outputPin, OUTPUT)
;
//устанавливаем 13 контакт в режим вывода
}
{
if
(Serial.available
()
)
{
//если есть принятый символ,
val =
Serial.read
()
;
// то читаем его и сохраняем в val
if
(val ==
"H"
)
{
// если принят симовол "H",...
digitalWrite(outputPin, HIGH)
;
// то включаем светодиод
}
if
(val ==
"L"
)
{
// если принят симовол "L",
digitalWrite(outputPin, LOW)
;
// то выключаем светодиод
}
}
}
Serial port;
void
setup()
{
size(200
, 200
)
;
noStroke()
;
frameRate(10
)
;
port =
new
Serial(this
, "COM5"
, 9600
)
;
// !!! Здесь прописать свой COM-порт!!!
}
boolean
mouseOverRect()
//Возвращает истину, если курсор внутри квадрата
{
return
((mouseX >=
50
)
&&
(mouseX <=
150
)
&&
(mouseY >=
50
)
&
(mouseY <=
150
)
)
;
}
void
draw()
{
background(#222222
)
;
if
(mouseOverRect()
)
// Если курсор внутри квадрата….
{
fill(#BBBBB0)
;
// сменить цвет на поярче
port.write
("H"
)
;
// послать "H" в микроконтроллер
}
else
{
// если не внутри...
fill(#666660
)
;
// сменить цвет на потемнее
port.write
("L"
)
;
// послать "L" в микроконтроллер
}
rect(50
, 50
, 100
, 100
)
;
// нарисовать квадрат
}
Как это работает
Разбор кода
Использование выводов
Другие программные параллельные коммуникации
