Arduino, MK-90 и другие

LiquidCrystalRus - небольшое обновление

noreply@blogger.com (id) — Mon, 01 Mar 2021 08:52:00 +0000

Недавно в проект LiquidCrystalRus на GitHub пришло issue по поводу того, что функция print при попытке выводить некоторые неалфавитно-цифровые символы из знакогенератора дисплеев на основе HD44780U, несправедливо их калечит. И я решил скорректировать алгоритм трансляции - чтобы он применялся строго к символам русского алфавита. Чуть больше кода из-за проверок, но зато можно так:

lcd.print("Дисковод 5\xf0");

На экране мы увидим: Дисковод 5¼

Плюс добавил пример DumpCharacters, выводящий построчно весь знакогенератор дисплея, что снимает вопросы по поводу того, есть ли там кириллица в принципе.

Надеюсь, кому-то пригодится )

LiquidCrystalRus для 1.6.1

noreply@blogger.com (id) — Mon, 30 Mar 2015 12:37:00 +0000

Недавно вышла очередная ArduinoIDE 1.6.1, одним из новшеств которой выступил новый gcc версии 3.4.5. И поскольку с каждой версией gcc синтаксис становится всё строже и строже - без неприятностей не обошлось.

В частности, перестала компилироваться библиотека поддержки вывода русского языка LiquidCrystalRus, из-за неверного (с точки зрения gcc) использования директивы PROGMEM, о чем ко мне посыпались сообщения от уважаемых пользователей (за что им хочу выразить особую благодарность).

Изменения там совсем крошечные, но если после установки новой ArduinoIDE ваш проект с LiquidCrystalRus в составе перестал компилироваться, не паникуйте, а скачайте и установите LiquidCrystalRus-1.6.0.zip.

Напоминаю, что проект также доступен на GitHub: https://github.com/mk90/LiquidCrystalRus.

UPDATE: подобно оригинальному LiquidCrystal, LiquidCrystalRus не умеет работать с дисплеями, подключенными как-то иначе, чем к пинам Arduino (например, по I2C), но зато и не требует для работы дополнительных библиотек: и в результате поддержка русского языка обходится дополнительно в 500 байт flash и 7 байт SRAM.

Книжная полка

noreply@blogger.com (id) — Fri, 09 May 2014 08:18:00 +0000

Недавно издательство БХВ порадовало нас книгой Виктора Петина "Проекты с использованием контроллера Arduino".

К сожалению, полноценной рецензии выдать не могу, доступно только оглавление:

краткий обзор плат Arduino;
описание всех операторов языка Wiring;
описание встроенной библиотеки Serial;
описание встроенной библиотеки LiquidCrystal и даже пара слов про LiquidCrystalRus;
описание встроенных библиотек EEPROM, Ethernet, OneWire, SD, Stepper;
разбор подключения мыши и клавиатуры PS/2 - библиотека ps2dev;
работа с датчиками iButton, DS18B20, DHT11 и DHT12;
подключение к светодиодным матрицам;
примеры стыковки с RFID-приемниками, купюроприемниками, датчиками расстояния HC-SR04;
освещается вопрос обмена данными с помощью ИК, в том числе различные типы кодирования;
работа с ходовой частью робота через микросхему L293D;
использование приемопередатчика Bluetooth HC-05, а также NRF24L01 с помощью библиотеки Mirf;
вывод на экран телевизора с помощью библиотеки TVOut, с примерами игровых программ;
работа с USB через USB Host Shield;
немного про ROS (распределенная операционная система для роботов) и X10 (умный дом).

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

Будет ли достаточно этой книги именно для вашего проекта? Лично я ожидал хоть что-то про использование Arduino Due и Leonardo (они упоминаются в обзоре), изменение прошивок ATmega16u2 (на последних Uno и Mega), про использование программатора - в реальности рано или поздно этот вопрос возникает (хотя на тему программирования ATMEL недостатка в литературе нет, например книга Ревича). Стоило бы посвятить больше места шилд-платам.... Хотя, стоп! Надо сказать автору "большое спасибо" уже за это издание (лучшее "спасибо" - это легально купленный экземпляр книги, особенно если хотите продолжения ;).

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

А примеры из книги можно скачать здесь.

Raspberry PI. С чего начать?

noreply@blogger.com (id) — Tue, 29 Apr 2014 20:28:00 +0000

Феномен Raspberry Pi трудно отрицать. Тем круче было мое удивление, когда коллеги проявили о нем практически нулевую осведомленность. На мой невинный вопрос "а не пора ли открывать ветку совместимости с Debian 7, а то на ней даже Raspberry Pi бегает" получил в ответ "а что это за разберри такой?".

Честно говоря, стало немного досадно. Я бегло просмотрел поисковый вывод и понял, что сейчас материалов на русском по Raspberry Pi на порядок меньше, чем про тот же Arduino. Традиционно, впереди всех выступает LinuxFormat, подписка платная (доступна и электронная версия, но все равно - она стоит денег), материалы выкладываются у них на wiki, с задержкой на один год.

И тогда я подумал, что стоит сделать пару статей - тем более, что последнее время мне крайне интересна связка Arduino+RaspberryPi.

Немного истории

Однажды, в далеком 2006 Эбен Аптон, тогдашний руководитель компьютерной лаборатории Кэмбриджского Университета, бился над идеей создания дешевого учебного микрокомпьютера, который бы мог использоваться в равной степени и компьютерными энтузиастами, и студентами, и даже детьми. В конечном итоге он надеялся достичь такого же образовательного эффекта, что сыграли домашние компьютеры 80-х в бурном развитии компьютерных технологий 90-х годов.

Однако, задача оказалась непростой. За пару лет сменилось несколько концепций, это первый прототип:

О да, зрение вас не обманывает - он собран на ATmega644, у которого 19 из 32 пинов использовано для подключения микросхемы SDRAM размером 512K, хранящей буфер экрана и данные. Собственно вывод на экран происходил путем последовательного выставления на адресной шине адресов ячеек памяти, содержимое которых через микросхему логики серии 74HC и DAC формировало композитный видеосигнал 320x400. Какой-то другой работой, кроме формирования видеосигнала, разогнанный до 22,1 МГц MCU мог заниматься в межстрочных и межкадровых паузах.

Как уже можно догадаться, этот ~~хардкор~~ прототип в серию запущен не был, хотя схема и печатные платы были опубликованы. К 2008 году стало понятно, что бурный рост числа мобильных телефонов с мультимедийными возможностями в недалеком будущем сделает доступным и переносной компьютер аналогичного размера. Заметим, что к этому моменту более 96% мобильников имели внутри ARM, что и заставило в конечном итоге остановиться на этой технологии (в Raspberry Pi работает ядро ARM1176JZF-S).

Наконец, в августе 2011 разработка добралась до альфа-прототипов, и желающие получили возможность оценить будущее устройство. Были представлены LXDE на Debian, Quake III Arena и проигрывание FullHD видео 1080p. Одновременно стало понятно с ценой - на выбор было предложено два варианта:

А за $25 - 1 x USB, 256 RAM;
B за $35 - 2 x USB, 1 x Ethernet 10/100, 256 RAM (полгода спустя - уже 512MB).

Соотношение цены и возможностей произвело неизгладимое впечатление на общественность и 200 000 желающих "построились в очередь" на получение первых Raspberry Pi варианта B. Но количество устройств в первой партии все равно осталось 10 000 штук, и лишь 10 из них были реализованы раньше срока: азартные покупатели на e-bay выложили за них в сумме £16000. Дальше - больше, за первые 6 месяцев было продано полмиллиона штук.

В тот момент запросто можно было встать перед дилеммой: "на что лучше потратить 32 USD - на оригинальную Arduino Mega или на Raspberry Pi?". С одной стороны, за Arduino стояло весьма внушительное коммьюнити, готовые библиотеки, масса шилд-плат и простота программирования, с другой - за Raspberry Pi - Linux и возможности ARM, низкая цена.

Сам Линус Торвальдсон, кстати, высказывался на эту тему тоже двояко (из интервью в октябрьском номере LinuxFormat): "Она (Raspberry Pi - прим. автора блога) слишком медлительна для того, что мне надо делать. Она на самом деле может выводить что-то на настоящий монитор, а потом вдруг не воспроизводит YouTube, а если она не может нормально делать такие вещи, значит, она слишком медлительна ... мне очень нравится идея такого дешевого оборудования, что его можно дать детям ... подозреваю, что следующее поколение будет значительно лучше...". Не осталась без внимания и "устаревшая, а потому и такая дешевая SoC", на которой построено устройство. Впрочем, всё это не остановило энтузиастов, пожелавших собственноручно испытать Raspberry Pi в действии.

Что придется добавить

Итак, мы встали в очередь и приобрели себе "малинки". Что потребуется добавить для получения некоторого полезного устройства (ну или чтобы просто "побаловаться" на досуге)? Ниже перечень, необходимый минимум состоит из первых двух пунктов:

1. Блок питания 5VDC с кабелем microUSB.

Для устойчивой работы Raspberry Pi достаточно иметь источник 700 мА. Потребности нашей "малинки" напрямую зависят от двух факторов: количества питаемых через USB устройств и степени разгона системы (да-да, его можно разгонять!). Если ничего не подключать, то уложитесь и в 500..600 мА. Но если, например, подключить WiFi-донгл и флешку - уже нет. Кстати, в качестве источника вполне подойдет зарядное устройство от современного смартфона, выдающего на microUSB ток 1.5...2А.

2. SD-карточка

Начальная загрузка происходит с SD-карты, но в комплекте она, как правило, не идет. Нужна любая полноразмерная SD, емкостью от 2 Гб. Для комфортной работы практически всех дистрибутивов рекомендуется емкость 4 Гб и скорость class 6 (нередко встречаются рекомендации "от 8Гб и class 10").

Есть особенность установки полноразмерной карты в Raspberry Pi - она наполовину выступает за край:

Избежать такого позволяет специальный переходник и microSD:

Разумеется, потребуется устройство, которое запишет скачанный из интернета образ на эту SD-карту. Подойдет любой компьютер с кард-ридером и операционной системой Windows/Linux/MacOS.

В зависимости от того, что предполагается сотворить в итоге, могут также пригодиться:

3. Монитор и кабель к нему

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

Монитор с DVI-входом тоже подойдет, только купите переходник HDMI-DVI:

4. Клавиатура и мышь

Да, без них тоже сложно. Поскольку на Raspberry нет PS/2 - разъемов, подойдут только USB-устройства.

5. USB-хаб

Поскольку USB-портов на Raspberry Pi всего два (на модели А и того меньше), может оказаться нелишним. Обратите внимание на энергопотребление подключаемых устройств: чем их больше, тем мощнее должен быть блок питания у Raspberry. В противном случае, можно выбрать USB-хаб с собственным источником питания.

Я практически сразу стал использовать хаб - мой экземпляр Raspberry перезагружался каждый раз, когда в USB вообще что-то вставляли. Вот он:

6. Internet-подключение

Для проводного потребуется сетевой Ethernet-кабель и свободный порт на коммутаторе, для беспроводного - USB-донгл. При установке дистрибутива довольно часто приходится наблюдать, как что-то докачивается или обновляется. С другой стороны, после завершения установки на устройство можно "заходить" удаленно (и, таким образом, монитор, клавиатура и мышь оказываются ненужными - при условии, что вы знаете ip-адрес, который получило устройство).

7. Кабель для вывода звука.

На Raspberry Pi есть стерео-гнездо 3,5 мм. Если вы подключили монитор при помощи RCA-кабеля, для вывода звука может потребоваться аудио-кабель со стерео-джеком 3,5 мм с одной стороны и с другой - как у вас на звуковой системе или TV (наушники тоже заработают).

В случае подключения по HDMI голову особо ломать не надо - звук пойдет там.

А вот микрофонного гнезда, к сожалению, нет. Придется прикупить USB-гарнитуру или USB-микрофон.

Медиацентр на Raspberry Pi

Часто люди задаются вопросом, насколько высок "порог входа" в мир RaspberryPi: что надо знать, чтобы там работать~~, там же ужасный и непонятный Linux~~? Всё зависит от дистрибутива, который будет выбран. Для тех, кто не хочет лишний раз пошевелить пальцем, предлагается Raspbmc, который основан на XBMC и прост в установке до предела. Ошибиться сложно, и если проделаете все правильно - получите на выходе готовый медиацентр.

Необходимое условие - наличие сетевого подключения у Raspberry (с сервером dhcp в придачу, от него Raspberry Pi получит сетевой адрес автоматически, вместе с выходом в Internet). Тогда клавиатура и мышь для установки вообще не нужны. Правда, для последующего управления медиацентром мышь все-таки потребуется.

Итак, отправляемся на http://www.raspbmc.com/download и получаем инсталятор для своей ОС вместе с подробными инструкциями по установке.

Windows

Вставляем SD-карточку, распаковываем raspbmc-win32.zip и запускаем setup.exe (сопровождается запросом UAC, если установлена Vista и выше):

Все данные на карточке погибнут, поэтому будьте внимательны! Выбирайте из списка именно ту карточку, на которую собираетесь использовать для установки Raspbian.

Linux

Вставьте SD-карточку в ридер, затем скачайте и запустите скрипт:

wget http://svn.stmlabs.com/svn/raspbmc/release/installers/python/install.py
chmod +x install.py
sudo python install.py

Появится "дружественный интерфейс":

Тут тоже важно не промахнуться мимо целевого диска (и не отформатировать случайно свой основной).

Всё, образ готов, теперь вставляем SD-карту в Raspberry Pi, подключаем его к монитору и к LAN, затем подаем питание и наслаждаемся радугой (заранее прошу прощения за муар - делал фото с экрана телевизора):

После Linux-оводы наслаждаются логами загрузки ядра:

Далее стартует интерфейс в стиле ncurses и сообщает, что он коннектится куда надо:

Если соединение прошло успешно, скачивается самый свежий образ:

(про кофе - истинная правда, а в действительности можно еще и супчик успеть навернуть...)

И вот, наконец-то видим, что устройство пошло перезагружаться с таким лого:

Ну, значит всё в порядке - через некоторое время попадаем в основной интерфейс Raspbmc:

Описание GUI выходит за пределы нашей статьи - единственное, что отмечу - в настройках можно переключиться на русский язык.

Виртуальный Raspberry Pi

Чтобы экспериментировать с программным обеспечением Raspberry Pi, покупать его не обязательно. Можно воспользоваться QEMU, и хоть это и не будет стопроцентным аналогом (чип BCM2835 не эмулируется), но довольно хорошим приближением к устройству с точки зрения архитектуры ARM. Для установки в Linux надо выполнить (в зависимости от типа дистрибутива):

yum install qemu

или

apt-get install qemu-system-arm

Создайте рабочий каталог и скачайте туда два файла: http://xecdesign.com/downloads/linux-qemu/kernel-qemu и какой-нибудь образ ОС для Raspberry Pi отсюда (я взял тот, что на основе Fedora, с интригующим названием "PiDora") - распакуйте его, если он был запакован.

Есть вероятность, что для запуска в qemu этот имидж требуется немного подправить, для этого выясните параметры самого имиджа при помощи file:

$ file Pidora-2014-R1.img

Pidora-2014-R1.img: x86 boot sector; partition 1: ID=0xc, active, starthead 32, startsector 2048, 102400 sectors; partition 2: ID=0x83, starthead 127, startsector 104448, 4355793 sectors, code offset 0xb8

Умножьте число в startsrector для partition 2 на 512 (выделено жирным выше, в вашем варианте может отличаться) и полученный результат подставьте в параметре offset при монтировании:

$ mkdir pidora
$ sudo mount Pidora-2014-R1.img -o offset=53477376 ./pidora

Открываем в любом текстовом редакторе файл ./pidora/etc/ld.so.preload и комментируем единственную строку, добавляя впереди символ #. Может статься, что такого файла не существует - в этом случае вообще ничего делать не нужно.

После этого надо отмонтировать образ:

$ sudo umount ./pidora

И запустить QEMU следующей строкой:

$ qemu-system-arm -kernel kernel-qemu -cpu arm1176 -m 256 -M versatilepb -serial stdio -append "root=/dev/sda2 panic=1" -hda Pidora-2014-R1.img

Если все сделано правильно, увидим процесс загрузки и выйдем на начало графической установки:

В следующей серии попробуем все-таки собраться с силами и что-то сделать своими руками, а пока можете исследовать дистрибутивы для RaspberryPi ;)

А все-таки она вертится!

noreply@blogger.com (id) — Sun, 30 Mar 2014 14:48:00 +0000

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

Прежде всего, надо осознать, что перед нами плата с Linux внутри, при этом ее программирование осуществляется самым привычным способом, через ArduinoIDE 1.5.3. Можно сказать, что мы получили продвинутый Arduino UNO R3 - на плате расположены колодки в формате Arduino pinout 1.0, к ней можно подключать стандартные шилды.

* * *

Приехавшая коробка интриговала - Галилея на ней можно признать с трудом, но зато мы видим отражение далеких звезд в стеклах очков незнакомца. Наверное, это современный ученый, который делает нечто космического масштаба (быть может, он и сам еще пока не знает что именно, не даром ниже мы читаем вопрос "Что вы собираетесь сделать?") .

Сбоку, однако, мы видим, что внутри продукт Galileo1, сделан в Китае:

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

Устав вертеть коробочку в руках, разрезаем две прозрачные пломбы-липучки и снимаем крышку:

Сама плата хоть и ненамного, но превышает размеры Arduino Uno - получается где-то 7 на 10 см. Это навязчивое "What will you make?" уже наводит на мысль, что с этим надо было давным-давно определиться, ещё до вскрытия коробки. На внутренней стороне крышки опять схема:

Стало быть, без блока питания она не заведется...

Ах, какой приятный сюрприз: блок питания в комплекте! Наверное, стоило бы и шнурок microUSB вложить... Ну или хотя бы кабель microUSB OTG. Из всех насадок выбираем европейскую, зачитываем Safety Instruction на русском:

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

Теперь самое время присмотреться к компонентам:

1. Эта зелененькая BGA-микруха и есть ЦП, Intel® Quark SoC X1000, работающая на тактовой частоте 400 МГц. Мы получили почти Pentium ;) (строго говоря - Intel Pentium Instruction set Architecture):

32-битный;
L1 кэш 16 Кбайт;
внутренняя память 512 Кбайт;
одно ядро, один тред, постоянная скорость выполнения;
поддержка ACPI-состояний для засыпания;
часы RTC, сохраняют данные при питании от внешней литиевой батарейки 3В.

Стоит он 13..16 USD, но приобретать его вам навряд ли придется - BGA-корпус не располагает к DIY-творчеству.

2. Внешняя память, в сумме имеем 256 Мбайт DDR3. В нем хранятся и данные, и программы - после выключения питания они, разумеется, теряются.

3. Флешка. Загрузка Linux идет прямо оттуда, остальная память может быть использована для хранения каких-то данных, суммарный объем 8 Мегабайт.

4. Это не звук! Это разъем последовательного порта RS232 (микросхема MAX3232 находится справа). Через этот порт можно получить доступ к консоли Linux, параметры 115200-8-N-1

5. Сетевой порт Ethernet 10/100. Можно использовать в скетчах.

6. Разъем USB device. Сюда подключается компьютер, через этот порт загружаются скетчи. Разработчики почему-то советуют сначала подключить к плате источник питания, а уже потом этот порт - к компьютеру.

7. Разъем USB host. К нему можно подключать разнообразную периферию - флешки, камеры, аудио-карты и тому подобное.

8. microSD, поддерживаются SDHC до 32 Гиговые. С карточки придется загрузиться, если требуется работа с WiFi - драйвера не смогли уместиться 8 Мб флешки (3). С другой стороны, она тоже доступна для скетчей.

9. Внешнее питание +5VDC. Разъем такой же в точности, как на платах Arduino. Блок питания в комплекте на 2А, в документации нашел упоминания и про 3А. Конечно, для шилд-плат +5В не может быть полноценным VIN-ом, и Galileo позволяет соединять их по желанию.

10. Розетки для подключения шилд-плат, всё как на UNO R3. Есть пара моментов, о которых стоит помнить:

цифровой пин в режиме выхода способен на ток до 10 мА, в режиме входа - принять ток до 25 мА. Не вздумайте подключать обычный светодиод напрямую, без токоограничительного резистора 330 Ом;
суммарный ток, который могут отдать цифровые пины не должен превышать 80 мА;
пин AREF на Galileo - декоративный, изменить опорное напряжение АЦП нельзя - не только с помощью этого входа, но и с помощью analogReference();
аналоговые пины можно при желании переключить на разрешающую способность 12 бит (0..4095), измерение по умолчанию идет в диапазоне 0..+5В и по стандартной 10-битной шкале;
питающий пин +3,3V способен на ток до 800 мА;
значение напряжения на пине VIN зависит от установленного рядом джампера.

11. Гребенка ICSP. Загружать через нее бутлоадер не придется, скорее подключаться к шилд-платам с поддержкой аппаратного SPI.

12. Кнопка сброса скетча. Скетч сбрасывается, остальная система продолжает работать.

13. Кнопка сброса SoC. По ее нажатию происходит перезагрузка всей системы, и скетча за компанию.

14. Вилочка для подключения внешней батарейки RTC. Полезно, если Galileo должен вспоминать время при включении питания.

Кроме всего прочего, есть несколько джамперов, довольно важных:

IOREF: выбирает напряжение логической единицы - +5В или +3,3В. Переключением напряжений сейчас никого не удивишь, хотя для клонов классических плат Arduino существует извечная проблема - ATmega упорно запитывают от +3,3В, но в даташите тактовая частота 16 МГц на таком питании внятно не гарантируется. Здесь, конечно же, с напряжением питания SoC это никак не связано ;)

VIN: этот джампер соединяет пин VIN с питанием +5В. Если шилд такое питание не устраивает, можно разомкнуть этот джампер и подать на шилд +9В. Только будьте аккуратней - не замкните этот джампер при поданном напряжении >5В, иначе с вашим Galileo произойдет то, что в свое время грозила с ним сделать святая католическая церковь.

I2C: Служит для изменения адресов устройств I2C на плате. Поскольку на двухпроводной шине I2C все устройства обязаны иметь собственный адрес, то теоретически имеется ситуация, когда адреса двух устройств, оказавшихся волей судеб на одной шине, совпадут. На Galileo таковыми являются флешка 8 Мб и расширитель GPIO (именно через него реализован PWM для пинов Arduino). По умолчанию это адреса 0100000 и 1010000, но если переставить этот джампер на первый пин (помечен белым треугольничком), то к адресам добавится единица - будет 0100001 и 1010001.

Наконец, с обратной стороны платы есть разъем Full PCI Express, который поддерживает PCIe 2.0. Можно подключать платы половинного размера через специальный переходник, а на коннекторе есть USB 2.0 хост.

Подводя итог по поводу начинки, полезно закрепить, помедитировав на блок-схему (кликабельно):

На плате есть светодиоды "USB", "SD", "ON" и "GP". Последний соответствует светодиоду L, подключенному к D13 на платах Arduino. Чтобы исполнить Blink (убедиться, что плата работает), идем на страничку Galileo и качаем оттуда версию ArduinoIDE 1.5.3. Файл находится в разделе загрузок и начинается с "Intel_Galileo_Arduino_SW_on". После распаковки и запуска выберите порт подключения (в Windows подключенная плата представится как "Gadget Serial V2.4", для нее потребуется "обновить драйвера"; в Linux - как /dev/ttyACMXXX и никаких драйверов не понадобится), выберите из примеров Blink, нажмите Ctrl-U и подождите, пока закончится загрузка.

Полюбовавшись на мигающий огонек, можно попробовать проделать с этой платой манипуляции, выходящие за возможности Arduino UNO. Например, достучаться до внутреннего Linux-а, с помощью такого скетча:

void setup() { 
  system("telnetd -l /bin/sh");
}
void loop() {
  system ( "ifconfig eth0 > /dev/ttyGS0" ); // 
  delay ( 5000 ); 
}

Никаких хитростей - system делает тоже самое, что и команда с тем же названием на UNIX-подобных системах: запускает какую-либо команду во внешнем shell. В данном случае она в setup запускает сервер Telnet, а далее в цикле выводит текущую информацию о сетевом интерфейсе в порт Serial Monitor. Если адрес выдан, мы должны увидеть что-то типа:

eth0 Link encap:Ethernet HWaddr 00:23:14:09:15:24
inet addr:192.168.100.20 Bcast:192.168.100.255 Mask:255.255.255.0
inet6 addr: fe80::223:14ff:fe09:1524/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:31852 errors:0 dropped:0 overruns:0 frame:0
TX packets:23743 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:28794897 (28.7 MB) TX bytes:4941927 (4.9 MB)

Берем из второй строки ip-адрес, запускаем telnet, передавая его в качестве аргумента, получаем приглашение от рута:

Poky 9.0.2 (Yocto Project 1.4 Reference Distro) 1.4.2 clanton

sh-4.2#

Если по каким-то причинам плата не получает адрес (например, просто нет сервера dhcp), можно изменить setup таким образом, чтобы перед запуском telnet нужный адрес присваивался вручную:

void setup() { 
  system("ifconfig eth0 192.168.100.101");
  system("telnetd -l /bin/sh");
}

Что можно делать в командной строке? Да всё, что угодно - с рутовыми-то привилегиями ;) Однако будьте предельно осторожны, доступ к файловой системе идет в режиме rw и необдуманные действия могут повлечь необходимость ее восстановления.

В качестве примера, обратимся к портам ввода-вывода, для этого:

/ # login root
root@clanton:~# cd /sys/class/gpio/
root@clanton:/sys/class/gpio# ls
export gpio20 gpio29 gpio4 gpio48 gpiochip16
gpio0 gpio21 gpio3 gpio40 gpio49 gpiochip2
gpio1 gpio22 gpio30 gpio41 gpio50 gpiochip8
gpio14 gpio23 gpio31 gpio42 gpio51 unexport
gpio15 gpio24 gpio32 gpio43 gpio52
gpio16 gpio25 gpio36 gpio44 gpio53
gpio17 gpio26 gpio37 gpio45 gpio54
gpio18 gpio27 gpio38 gpio46 gpio55
gpio19 gpio28 gpio39 gpio47 gpiochip0

Первый строкой мы логинимся (правильно устанавливаются переменные окружения, тот же prompt), второй переходим в каталог в sysfs, где представлены все GPIO нашей платы - в виде набора каталогов с управляющими файлами.

Как связаны номера GPIO и пинов Arduino в Galileo? А вот так:

Пин Arduino	GPIO Linux
0	50
1	51
2	14
3	15
4	28
5	17
6	24
7	27
8	26
9	19
10	16
11	25
12	38
13	39
14	44
15	45
16	46
17	47
18	48
19	49

Таким образом, например, чтобы изменить состояние пина D13, мы должны манипулировать файлами в каталоге gpio39. Но допустим, нам надо просто поморгать светодиодом GP. Он подключен к аппаратно независимому пину gpio3 (звучит странно, но это правда - для скетча это один пин, аппаратно - два). Проделаем следующее:

root@clanton:/sys/class/gpio# cd gpio3
root@clanton:/sys/devices/pci0000:00/0000:00:1f.0/sch_gpio.2398/gpio/gpio3# ls

active_low device direction drive power subsystem uevent value

Первой командой мы переходим в каталог с управляюще-информационными файлами для пина, второй - распечатываем их список. Файл direction отвечает за направление пина - ввод или вывод. А файл value - за значение. Такая последовательность команд включает светодиод:

# echo out > direction

# echo 1 > value

А такая - гасит:

# echo 0 > value

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

На плате есть некоторое количество периферии, которое доступно скетчам Arduino в режиме совместимости. Это, например, означает, что у вас есть виртуальный Ethernet Shield, для использования которого надо всего-то подключить стандартную библиотеку Ethernet.

Таким же образом можно получить и виртуальный WiFi Shield, но для этого надо не только подключить стандартную библиотеку WiFi, но и установить сам модуль WiFi в разъем Mini PCIe, загрузиться с SD-карточки и убедиться, что драйвер распознал карточку.

И к самой SD-карточке тоже можно получить доступ через стандартную библиотеку SD.

Во всех перечисленных случаях явное преимущество состоит в возможности использования ранее написанных скетчей - с минимальными модификациями.

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

я долго не мог понять, как сбрасывать скетч - нажатие на кнопку reset, казалось, не давало эффекта. Это оказалось наполовину правдой - сброс производится по отпусканию кнопки, а до этого момента скетч продолжал работать (на обычном Arduino он на время нажатия останавливается).
сетевой карте не выдавался ip-адрес через dhcp. Пришлось обновить firmware - ура, помогло! Но при этом перестала нормально работать кнопка reboot :(
при загрузке с SD-карты, старая карточка WiFi, оставшаяся на память от погибшего лаптопа, работать не захотела. То ли драйвера в сборке нет, то ли она тоже приказала долго жить, надо разбираться :(

Поскольку ядро Arduino эмулируется аппаратно, то новые косяки должны всплывать постоянно, и вопрос только в том, насколько оперативно их будут фиксить. И тут есть некоторые сомнения - хотя разработка Intel действительно полностью открыта (как всегда - схемы, чертежи и софт с исходниками доступны для изучения), сколько еще она будет уделять ей времени? Год или два, а потом что-то новенькое выпустят, например Edison? Очень похоже, это devboard для Intel Quark X1000, который раскручивают при помощи Arduino.

С другой стороны, за 80 USD вы получаете аналоги Arduino UNO R3 и Ethernet Shield, оригиналы которых стоят 30 и 40 USD соответственно, но с более широкими возможностями внутреннего Linux. Правда, однажды такое уже cделали - выпустив Arduino Yún.

Так или иначе, Galileo с нами. Будет время - попробую покопаться в его внутреннем устройстве чуть глубже.

Freeduino 32u4 R6

noreply@blogger.com (id) — Thu, 30 Jan 2014 14:38:00 +0000

Вышла очередная ревизия нашей платы на ATmega32u4, уже шестая по счету.

(слева направо - Freeduino 32u4 R4, Freeduino 324u4 R6, Freeduino Nano)

Основная борьба шла за уменьшение размеров, поскольку плата в первую очередь предназначена для беспаечной макетки. Ура, теперь будет закрыт на один ряд отверстий меньше (и по вертикали, и по горизонтали). Разъем USB тоже уменьшился (mini -> micro).

К сожалению, продолжать уменьшать размеры мешает осознанная необходимость размещать удобочитаемую шелкографию с названиями пинов (без нее придется подглядывать в картинку с обозначениями). Не исключаю, что в будущем перейдем на QFN-корпус и получится что-то наподобие Arduino Micro. Напоминаю, что сейчас на плате отсутствует вход VIN, и питать её можно только от USB или источника +5В.

Немного модифицирован бутлоадер. Нам пришлась по душе идея SparkFun: одиночное нажатие на сброс теперь перезапускает скетч, а вот для активизации бутлоадера надо нажать на сброс дважды:

Это удобно, если надо быстро перезапустить скетч, не теряя 8 секунд на ожидание завершения бутлоадера.

Для владельцев предыдущих ревизий платы, желающих прошить новый бутлоадер Freeduino32u4: это можно сделать через ArduinoIDE или через avrdude:

avrdude -c stk500v2 -P avrdoper -B 3 -p atmega32u4 -F -e -u -U lock:w:0x3f:m -U efuse:w:0xcb:m -U hfuse:w:0xd8:m -U lfuse:w:0xff:m

avrdude -c stk500v2 -P avrdoper -B 3 -B 1.1 -p atmega32u4 -F -U flash:w:file.hex -U lock:w:0x2f:m

Конечно, для этого потребуется программатор (строки программирования приведены для AVRDoper).

Freeduino wireless (2)

noreply@blogger.com (id) — Mon, 30 Dec 2013 08:00:00 +0000

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

Довольно давно на рынке существует микросхема nRF24L01+, выпускаемая фирмой Nordic Semiconductors. Она обеспечивает возможность приема или передачи информации на несущей 2,4 ГГц (полоса ISM), методом частотной манипуляции GFSK. Для Arduino это решение удобно не только в силу низкой стоимости чипа, но и по причине подключения через SPI.

Для экспериментов нам понадобится какой-либо беспроводной модуль на основе nRF24L01+, например такой:

Его можно купить практически где угодно, стоить больше 160 рублей он не должен. Следует заметить, что 90% таких модулей ничем друг от друга не отличаются - схема скопирована из реф-дизайна evolution-кита к nRF24L01+, опубликованному производителем. Антенна расположена прямо на печатной плате, что при такой длине волны вполне допустимо и обещает максимальное расстояние до 100 метров (разумеется, с оговоркой про "идеальные условия", в реальности оно будет меньше - сколько именно, придется проверять экспериментально). К слову, существует две версии чипа - nRF24L01 и nRF24L01+, отличающиеся совсем ненамного и совместимые друг с другом (просто имейте ввиду, что если ваш модуль с nRF24L01 - к нему эта статья применима в полном объеме).

Назначение контактов на вилке должно быть следующим (вид сверху):

У модулей с вилкой 2x4 есть одно существенное неудобство - невозможно воткнуть в беспаечную макетку: расположенные в два ряда контакты, увы, будут закорочены попарно. Остается только позавидовать счастливым обладателям модуля от SparkFun, не поскупившимся отдать за это чудо 19.95 USD:

Посмотрим, какие выводы и куда подключать:

GND - земля, соединяем с одним из пинов GND на Arduino;
VCC - питание модуля, внимательно - соединяем с пином 3.3В - модуль питается от напряжений 1,9..3,6В, хотя при этом отлично умеет работать с логическими уровнями +5В;
CE - расшифровывается как Chip Enable, но речь не про работу всего чипа, а лишь про его радиоинтерфейс - в режиме приема заставляет модуль "прослушивать" эфир в поисках предназначенного ему пакета, в режиме передачи кратковременный импульс CE передает в эфир содержимое буфера FIFO. Подключим его к пину D8;
CSN - SPI: Chip select not, выбор Slave-устройства на шине SPI низким уровнем, подключаем к пину D7;
SCK - SPI: Clock, подключаем к пину D13;
MOSI - SPI: Master Out, Slave In - подключаем к пину D11;
MISO - SPI: Master In, Slave Out - подключаем к пину D12;
IRQ - прерывание, пока никуда не подключаем :(

Пины с аппаратной поддержкой SPI (SCK, MOSI, MISO) гарантированно можно найти на шестиконтактной ISP-вилке Arduino:

Если же будете подключаться к боковым гребенкам, учитывайте, что аппаратная поддержка SPI у Mega находится на пинах 50 (MISO), 51 (MOSI), 52 (SCK) и 53 (SS).

Переходник для установки в беспаечную макетку можно соорудить из разъемов PBD08 и PLS8, на кусочке обрезка обычной макетной платы (под пайку):

Итак, паяльник можно откладывать в сторону. Однако прежде чем приступать к написанию скетчей, познакомимся с документацией на чип и поподробней разберемся в том, что он умеет (и что не умеет - разумеется, тоже).

nRF24L01+ способен работать приемником или передатчиком на частотах 2400..2525 МГц, конкретная частота определяется номером частотного канала от 1 до 126, задаваемым через регистр RF_CH. Чтобы приемник и передатчик смогли обмениваться между собой, они обязательно должны быть сконфигурированы для одного и того же канала. Скорость обмена по умолчанию - 2 Мбит/с, но при необходимости ее можно снизить до 1 Мбит/с - в основном это делается для совместимости с ранними версиями чипов Nordec (вот одно из отличий nRF24L01 от nRF24L01+: последний умеет работать еще и на пониженной скорости 250 Кбит/с).

Данные передаются пакетами. Пользовательская часть (в документации называется "Payload") может занимать до 32 байт, остальные поля - служебные:

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

В какой-то конкретный момент времени чип может быть либо передатчиком, либо приемником - либо передавать, либо принимать: по-очереди, но не одновременно. Для контроля можно организовать смену режимов - одной стороне даете команду передать сообщение и перейти в режим приема, другой - принять сообщение, проверить его корректность с помощью поля CRC, затем перейти в режим передачи и "отстучать" передавшему подтверждение.

Но, к счастью, существует специальный встроенный протокол Enhanced Shockburst (tm), который берет на себя все заботы о гарантированной доставке сообщения между двумя nRF24L01+. Это включает в себя не только прием, проверку правильности и отсылку подтверждающего пакета приемником, но и повторную перепосылку пакета передатчиком. Не правда ли, инженеры Nordic Semiconductors поработали на славу? ;) Для работы протокол использует поле управления пакетом.

В довершение существует специальный режим Multiceiver, в котором приемник может быть настроен на получение данных от шести передатчиков, и опять же, с возможностью работы по Enhanced Shockburst. Иными словами - один приемник может "тянуть" данные из шести передатчиков с аппаратным подтверждением и перепосылкой. Правда, есть некоторые ограничения - все устройства надо сконфигурировать на работу в одном частотном канале, с одинаковой скоростью, длиной адреса и способом формирования CRC. Один адрес передатчика можно выбрать произвольно, а вот остальные пять должны совпадать во всех байтах адреса, кроме последнего (например, 0x1234567801, 0x12345678D5, 0x12345678AA, 0x1234567855, и так далее).

Адрес задает пользователь, и, строго говоря, он может быть произвольным. Но располагается он в самом начале пакета, сразу после преамбулы, которая выглядит в двоичном представлении как 01010101 или 10101010 - такая комбинация не случайна и нужна для правильного пробуждения приемника и его подстройки к частоте передатчика. Чтобы было меньше ложных "отбраковываний" пакетов приемной частью, надо стараться избегать как адресов, похожих на преамбулу (например - 0xAAAAAA или 0x555555), так и адресов, состоящих из вообще одних нулей и единиц (еще два плохих примера - 0xFFFFFF или 0x000000).

Пример схемы (допустим, Freeduino Nano):

Какие библиотеки для Arduino существуют для работы с nRF24L01+?

Самый простой вариант - библиотека Mirf, которая предоставляет минимальную обвязку (её даже адаптировали для ATtiny). Скачайте последнюю версию библиотеки:

на странице Arduino playground, посвященной nRF24L01+;
непосредственно из gitHub.

Перед началом работы надо задать пины, к которым подключены CE и CSN, собственный адрес как приемника, длину пользовательской части (payload) и вызывать пару функций. По умолчанию предполагается, что CE подключен к D8, CSN - к D7 (ровно так мы уже и сделали), работа будет идти по каналу 1, длина пакета - 16 байт. Если что-то из перечисленного не совпадает с вашими потребностями, необходимо установить соответствующие значения полей до вызова init() и config(), например: Mirf.cePIN = 10; в случае, если CE подключен к D10.

В основном, последовательность инициализации выглядит так:

Mirf.spi = &MirfHardwareSpi;
Mirf.init();
Mirf.setRADDR((byte *)"12345");
Mirf.payload = 4;
Mirf.config();

Первая строчка - установление "правильного" алгоритма работы с SPI, носит скорее исторический характер. Сейчас всё равно вся работа осуществляется через встроенную в ArduinoIDE библиотку SPI, но ведь не всегда было так ;) Второй строчкой происходит инициализация пинов и SPI, в третьей мы устанавливаем собственный адрес приемника, длиной 5 байт (символьная строка "12345" дана исключительно для наглядности, на самом деле это 0x3132333435 ;) В четвертой - мы устанавливаем длину пакета 4 байта, и, наконец-то, в пятой конфигурируем чип NRF24L01 и переводим его в режим приема.

Дальше можно принимать и передавать данные.

Прием:


 if(Mirf.dataReady()){

  Mirf.getData((byte *) &packet); 

 }

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

Передача:


Mirf.setTADDR((byte *)"12345");

Mirf.send((byte *)&packet);

while(Mirf.isSending()){

}

Устанавливаем адрес получателя, затем отсылаем packet и при помощи isSending дожидаемся завершения отправки.

К библиотеке прилагаются примеры ping_client и ping_server, которые обмениваются пакетами друг с другом. Чуть интереснее изучить пример ping_server_interrupt, демонстрирующий работу по прерыванию в режиме энергосбережения: пока нет данных, Arduino пребывает в режиме сна. Однако, как только фиксируется прием нового пакета, он просыпается, принимает пакет из nRF24L01+, отсылает ответный пакет и снова "засыпает". Для корректной работы потребуется подключить ранее неиспользованный пин IRQ на плате радиомодуля - к пину D2 Arduino.

В каких случаях генерируется прерывание от nRF24L01+?

Это происходит в трех ситуациях и отображается в регистре STATUS при помощи соответствующих битовых полей:

TX_DS - передающая сторона получила от встречной стороны информацию (ACK-пакет), подтверждающую успешный прием;
RX_DR - приемная сторона получила новый пакет данных (и с правильным CRC, и не дубль уже полученного ранее пакета);
MAX_RT - передающая сторона попыталась передать пакет максимально разрешенное количество раз, но так и не получила подтверждения о приеме.

И, самое важное - после того, как любой из перечисленных битов был установлен, для дальнейшей работы его необходимо сбросить - записать единицу. Обычно, об этом заботится библиотека ;)

Функция Mirf.isSending() как раз и проверяет факт завершения передачи по установке TX_DS или MAX_RT. Но имейте ввиду, что она не отвечает на вопрос о том, был ли пакет благополучно принят на противоположной стороне. После того, как Mirf.isSending() вернет true, чтение регистра STATUS становится бессмысленным - перед выходом функция сбрасывает биты TX_DS и MAX_RT. К счастью, при каждом возникновении MAX_RT увеличивается счетчик PLOS_CNT в специальном регистре OBSERVE_TX, поэтому проверку благополучной доставки можно организовать так:

int readPLOS_CNT() {
  byte reg;
  Mirf.readRegister(OBSERVE_TX,&reg,1);
  return (reg >> PLOS_CNT) & B1111;
}

void loop() {
  
  int prev_plos_cnt = readPLOS_CNT();

  /* ... */
  Mirf.send((byte *)&packet);
  while(Mirf.isSending()){
  }

  if (readPLOS_CNT() != prev_plos_cnt) {
   /* failed :( */
  } else {
   /* success! */
  }
}

Еще можно вообще отказаться от использования Mirf.isSending(), и проверять биты TX_DS и MSX_RT непосредственно чтением регистра STATUS. Но тогда не забывайте сбрасывать их после установки, иначе процесс передачи встанет после первого же пакета.

Как я уже упоминал в самом начале - библиотека реализует действительно минимально необходимый набор функционала. За это приходится расплатиться следующим:

длина адресного поля - всегда 5 байт;
CRC всегда однобайтовый;
длина payload всегда фиксирована;
нет поддержки режима multiceiver (прием данных от шести передатчиков).

Что-то решается простейшим исправлением кода библиотеки, что-то можно сделать через запись и чтение управляющих регистров nRF24L01+, что-то (multiceiver или динамическая длина payload) добавить уже и вовсе непросто.

Однако, если у вас возникает слишком много претензий к функционалу Mirf, можно попробовать альтернативу - RF24. В ней конфигурируется буквально всё, в том числе автоматически учитываются различия между nRF24L01 и nRF24L01+. Идеологически библиотека ближе к стандартам Arduino и интуитивно понятнее, особенно начинающим. Например, по аналогии с Mirf есть функция RF24::startWrite, а в дополнение к ней - RF24::send, которая блокирует ход скетча до завершения процесса передачи, чтобы стало понятно - передан пакет успешно или нет, что и сообщается в возвращаемом значении типа bool (прямая замена вышеприведенному коду, который пришлось добавлять для аналогичного контроля в Mirf).

В комплекте с библиотекой RF24 много полезных примеров, которые демонстрируют использование irq, отправку пользовательских данных в ACK-пакете и прочее. Есть даже примитивный сканер эфира ;)

Куда двигаться дальше?

Например, по каким-то причинам не устраивает дальность приема: то ли расстояние велико, то ли стен многовато. В этом случае надо брать модуль nRF24L01+ с PA/LNA (Power Amplifier и Low Noise Amplifier):

Этот модуль будет стоить чуть дороже, около 10 USD. В его основе nRF24L01+ с точно такой же вилкой, но у него непосредственно к выходным каскадам вместо антенны подключен усилитель, повышающий мощность передатчика и чувствительность приемника. К SMA-коннектору необходимо подключить стандартную антенну для диапазона 2,4 ГГц (можно скрутить с нерабочего WiFi роутера) и правильно сориентировать - получите диапазон до 1000 метров. Правда, сразу вырастут запросы по питанию: модулю потребуются не десятки, а сотни mA, напряжение питания должно быть в диапазоне 3,0..3,6В. В этом случае может уже не получиться питать его от Arduino - если не помогает конденсатор 10 мкФ между 3,3В и землей, просто подключите модуль к отдельному источнику питания.

Да, и еще одно: не исключено пересечение по частотным каналам с другими беспроводными устройствами. Если у вас есть беспроводная клавиатура или мышь на 2,4 ГГц, с очень большой долей вероятности есть шанс разобрав ее увидеть нашего старого знакомого ;)

Ссылки по теме:

ARCAdaptor или Игра в Продукт

noreply@blogger.com (znoxx) — Sun, 24 Nov 2013 08:51:00 +0000

Сегодня будет не совсем обычная статья - уважаемый znoxx поделится опытом о том, как проделать путь от макета железки до полноценного коммерческого продукта. Быть может, он найдет единомышленников, или, что будет еще круче, вдохновит кого-то по его примеру поделиться с общественностью своей разработкой. Приятного чтения! -- ведущий блога MK90 - id.

Наверное, каждый, кто увлекается разработкой различных железок на микроконтроллерах, задавался подобными вопросами:

А что дальше?
Как сделать из прототипа законченный продукт?
Смогут ли им пользоваться другие люди?
Зачем мне вообще всё это?

Будем считать, что вы уже вышли из стадии "because we can" ("потому что можем") и вам хочется немного большего. В этой статье я хочу рассказать о проекте ARCAdaptor и поделиться опытом выпуска "почти-продукта". Что это такое и почему продукт все-таки "почти" — читайте ниже.

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

Устройство

Сейчас уже тяжело вспомнить, с чего все началось. Но будем считать, что очень хотелось сделать адаптер для подключения панели MAME — Multy Machine Arcade Emulator. В один из праздничных "зимних" дней я наткнулся проект V-USB MAME Panel. Возможность использования ATmega8 в качестве "сердца" устройства грело душу.

И вот, нулевой прототип:

Breadboard, кусок USB-провода, в общем, всё как всегда.

Как многие могли догадаться, проект базируется на библиотеке V-USB — программной реализации протокола USB для микроконтроллеров AVR. Набор поддерживаемых микросхем очень широкий, есть даже микроконтроллеры семейства ATtiny.

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

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

Что дальше ? Чего, так сказать, не хватает ?

Для этого рассмотрим принцип действия чуть подробнее:

К пинам ATmega8 подключены размыкаемые контакты - наши "кнопки" и "джойстики" (на самом деле - обычные 4-х контактные манипуляторы, хорошо знакомые всем по ZX-Spectrum, Atari и прочим MSX);
Контроллер считывает состояние пинов и формирует пакет для USB, который симулирует нажатие клавиатуры и/или джойстика;
Компьютер-хост (планшет, телефон или Raspberry Pi :-)) честно считает это сооружение клавиатурой-джойстиком-HID-устройством и реагирует соответственно.

Однако, чтобы поменять назначение кнопок ("маппинг"), требуется правка исходных текстов, перекомпиляция прошивки и перепрограммирование микроконтроллера.

С другой стороны, ATmega8 имеет специальную энергонезависимую область данных EEPROM, которая может быть прочитана и записана независимо от основной программы. Почему бы нам не использовать ее ? Всего-то требуется — жалких 17 байт или около того.

Решительно меняем алгоритм работы! Было так:

В RAM формируется табличка в виде массива, куда прописаны коды клавиш и управляющие последовательности джойстика;
Каждая ячейка соответствует либо кнопке, либо позиции джойстика (или кнопки).

Заменяем на такое:

Копия массива хранится в EEPROM;
Последовательность копируется в RAM при инициализации устройства;
Заставим компилятор генерировать отдельный .eep-файл с содержимым EEPROM для загрузки в устройство.

Чтобы сделать совсем хорошо — ещё и разнесем код, формирующий и обрабатывающий содержимое EEPROM в отдельные файлы, дабы было удобно править.

Пробуем, учим теорию, опять пробуем… Наконец-то видим желаемый результат.

Маленькая победа. Функциональность значительно расширилась. Воодушевленные результатом движемся дальше. Пора освободить bredboard для других амбициозных целей, да и место на столе не резиновое.

Прототип 1

Про ЛУТ написано много статей, хороших, подробных и разных. Останавливаться на этом не буду, отмечу лишь, что травилось всё в "экологически безопасном" растворе, на основе перекиси водорода, лимонной кислоты и соли. Причем перекись была в таблетках. Подробнее можно посмотреть тут, правда речь о другой плате, ну суть от этого не меняется.

Итак, вот что на выходе:

Плата разводилась в черновом варианте, лишь бы влезло на один слой. Коннекторы с другой стороны, кварц там же. Кстати, для разводки лично я использую FreeRouting. Писан на java, работает с Eagle через скрипт-костыль, но работает. И результаты лучше, чем в Eagle, на мой неискушенный взгляд.

Итак, наш прототип уже не развалится при переносе со стола на стол. Однако на плате есть разъем USB, а для обновления EEPROM по-прежнему требуется программатор. Вот ведь незадача.

Bootloader

Bootloader - это микропрограмма, работающая в строго отведенной области и защищенная от перезаписи. В нашем случае она позволит загружать содержимое Flash и EEPROM без выделенного программатора, прямо как в Arduino.

К сожалению, наличие бутлоадера сокращает доступный размер памяти для основной программы, и в ATmega8 остается 8192-2048 = 6144 байт. Но поверьте, 6 Килобайт — вполне достаточная емкость для написания огромного числа программ. Например, наш проект занимает значительно меньше

Из всех готовых бутлоадеров мне приглянулся тот, который позволял записывать EEPROM отдельно - им оказался USBAspLoader. После входа в бутлоадер (в исходном тексте настраивается условие - определенный пин замкнут на землю), программа avrdude "понимает" его, как программатор usbasp и ключи для записи EERPOM в командной строке прекрасно работают.

Мало того, мы получили возможность обновлять не только конфигурацию в EEPROM, но и саму прошивку.

Можно даже сказать, что мы получили Arduino-совместимую плату, по примеру проекта Metaboard. Правда, пара пинов недоступна (на них работает USB), а один из пинов нужно использовать с осторожностью, ибо он работает как триггер для бутлоадера (просто об этом нужно помнить).

Знаю, что можно было бы клонировать Metaboard, но хотелось осилить "свой путь", не замыкаться на Arduino, как конечном изделии. У нас будет своя плата - "с шахматами и поэтессами".

Схема и прошивка

(кликабельно для увеличения)

Основные отличия от оригинального проекта V-USB MamePanel:

схема работает от +5В — убран преобразователь в +3.3В;
в связи с этим установлено 2 стабилитрона на D+ и D- согласно рекомендациям/требованием авторов V-USB;
резистор-подтяжка для D- заменен на 1.5 кОм, опять-таки согласно референсной схеме V-USB. Кстати, резистор-подтяжка нужен для определения устройства, как low speed usb device. Если повесить на D+ — Windows, в частности, может пожаловаться, что это устройство "может работать быстрее", но стабильности это не добавляет.
разъем X3 имеет 8 контактов. Во-первых оттуда можно брать или подавать питание, во-вторых туда вынесены служебные контакты;
наименование контактов осталось прежним и соответствует "дефолтному" маппингу кнопок.

Архив с исходным кодом содержит как бутлоадер, так и непосредственно дефолтную прошивку. Почему она "дефолтная", а также значения lock и fuse битов можно посмотреть в "Руководстве по эксплуатации ARCAdaptor".

Схема в формате EagleCAD входит в состав документации на ARCAdaptor (ссылка в конце страницы проекта). Плату придется развести самому или изготовить на макетке. Если нет возможности заниматься травлением, готовую плату, набор для сборки или пустую плату можно купить здесь.

Подведем промежуточный итог: мы получили устройство, которое совмещает в себе следующие возможности:

Адаптер для создания "кастомных" клавиатур и джойстиков для компьютера;
Отладочная плата на ATmega8;
Arduino-совместимая плата;
Радиоконструктор :-)

Что же, будем считать, что с прототипом мы закончили. Ничто не мешает собрать такое устройство самому в домашних условиях — хоть на макетной плате. Однако, чтобы довести ее до продукта, надо пройти еще несколько шагов ;-)

Путь к Продукту

Что нам мешает поделиться работающей "железкой" с единомышленниками?

Не все умеют/желают копаться в исходных текстах. Перекомпиляция проекта — несложный процесс, но все равно требует определенных навыков;
Далеко не все имеют возможность вытравить плату дома. И пусть этот процесс описан в тысячах источников, повторяю, такая возможность есть не у всех.
Человек хочет получить готовый к употреблению продукт, а не нечто из мира Open Hardware, требующее доработки напильником и сборки по кусочкам.

Какие есть пути решения?

Изначально ARCAdaptor позиционируется, как устройство, позволяющее подключить самодельный джойстик или клавиатуру к компьютеру - обычному ПК или планшету с USB портом. Возможность конфигурировать прошивки есть - можете назначать контакты на конкретные действия — кнопка X будет вызывать нажатие "пробела", а кнопка Y будет, например, изображать движение джойстика "вверх". Однако надо составить правильный образ EEPROM, и для этого мы создадим удобный и наглядный редактор, разместив его прямо на сайте, чтобы пользователь мог самостоятельно составить и скачать образ, не покидая любимого браузера;
Сделаем симпатичные платы на заводе;
Документация решает всё. Распишем доступным русским языком и опубликуем на веб-сайте.

Онлайн-редактор

Появление HTML5 и продвинутых средств разработки, таких как jquery привело к тому, что наша жизнь потихоньку переползает в онлайн. Смартфоны сразу загружают фотки в "облако" — ни тебе проводов, подключений и поиска по устройству. Эта статья пишется в Google Docs.

Так почему бы нам не сделать редактор конфигурации прямо в браузере? От него потребуется:

Назначать клавиши, а также кнопки и контакты джойстика на конкретные контакты ARCAdaptor;
Сохранять свое состояние;
Выдавать пользователю образ EEPROM прямо в .hex файле, который готов к употреблению — заливке в устройство.

Рабочая область редактора состоит из схематичного шаблонного изображения клавиатуры, двух джойстиков и набора контактов ARCAdaptor (X1, X2 X3).

Взаимодействие протекает предельно просто: цепляете кнопку с экранной клавиатуры или джойстика и тащите на желаемый контакт, который принимает новое значение и подсвечивается. Как только всё переназначено, можно кликнуть по ссылке Get EEPROM Image, чтобы скачать файл конфигурации.

Интересно, что механизм Drag'n'Drop в HTML5 был полностью перенесен из модели, используемой в Internet Explorer. Но, по иронии судьбы — Internet Explorer как раз и не работает с редактором. Ну или редактор с IE, как кому удобнее думать :-).

При нажатии на ссылку "Get EERPOM Image" назначение контактов отсылается на сервер, который в ответ формирует .hex файл. К сожалению, все тонкости реализации, слова "json" и "ajax" лежат совсем за рамками данной статьи. Но если у кому-то интересно — в конце есть способы связи со мной. Попробовать редактор в деле можно незамедлительно.

Заводские платы

Так уж вышло, что я по образованию больше программист, чем разработчик железа. Хотя в жизни удалось поучаствовать во многих проектах, но вот как схема превращается в плату — узнал не так давно. То, что я "ваяю" в Eagle, далеко от совершенства: оно одностороннее, не имеет эстетической ценности и, наконец, делается для себя. Тут нужна была консультация специалиста.

Опытным путем выяснилось, что китайские изготовители делают относительно дешево, но на "вход" принимают в основном Gerber-файлы. Их генерация из Eagle предусмотрена, но я, честно говоря, страшился этого шага, так как не знаю, как и что должно там быть. А чувствовать себя неподготовленным студентом в общении с изготовителем не очень хотелось.

Короче, схема была отдана сведущему коллеге, который развел ее в PCAD за пару часов. Была заказана опытная партия, найдена ошибка (не моя :-)), исправлена, и вот заветная партия в руках.

Изготовитель — отечественный, поэтому не пришлось ждать милости у почты РФ. Из плюсов — принимают документацию в формате этого самого PCAD.

Часто спрашивают: сколько это стоит. Первоначальный заказ обошелся в сумму около 80 долларов США. Когда фотошаблон готов — стоимость изготовления ниже стоимости доставки. А сколько времени и нервов экономится при "неиспользовании" утюга — и не сосчитаешь.

Документация

При написании документации важно понимать три момента: для кого, как и сколько.

Для кого:

Помните, что вы пишите для людей, поэтому пишите так, чтобы мог понять ваш близкий друг, далекий от электроники. Совсем опускаться до людей с "гуманитарным складом ума" не стоит, но и заумствовать/нагонять тоску противопоказано. Помните, ваша задача — сделать так, чтобы человек дочитал до конца. Желательно по доброй воле, а не от безысходности.

Как:

Вдумчиво. Представьте, что вы открыли коробку со сложным прибором. И не получится им воспользоваться без прочтения фолианта, именуемого "руководство по эксплуатации". Всегда помните о Вашем пользователе. Расшифровывайте термины, сделайте оглавление, сохраняйте логику повествования. Вначале базовые вещи, потом уровень advanced.

Обязательно найдите "жертву" — пусть это будет Ваш товарищ, друг, коллега, которому интересно то, что вы делаете. Дайте ему на "вычитку" документ. Если хотите максимально использовать "эффект первого прочтения" — пользуйтесь онлайн средствами для совместной работы. Google Docs позволяет оставлять комментарии, не требуют гонять версии по почте или на "флешке".

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

Не стесняйтесь использовать ссылки — например "подробнее о том, что такое ATmega8 можно почитать тут или тут".

На самом деле, эффект "первого прочтения" очень важен. Вам сообщат о массе недочетов. Постарайтесь использовать это преимущество. К сожалению, повторить этот эффект можно не раньше, чем через 3 месяца — это свойство человеческой памяти и восприятия.

Сколько:

Столько, сколько нужно. Ориентир один — все связанные с продуктом, устройством или "сервисом" вопросы должны решаться с помощью документации. Вы сэкономите свое время и время Ваших пользователей.

Из личного опыта — мне задавали совершенно разные вопросы по проекту. На 95% из них я отвечал, просто отсылая к нужному разделу документации.

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

И напоследок — помните, что в русском языке букву "Ё" никто не отменял. А также, "-" — это "минус", а "—" — это тире. И это хорошие привычки.

Продвижение

Вебсайт, онлайновый магазин, you name it… Здесь потребуются навыки и дизайнера, и SEO, и разработчика, но не электроники, а www. Говорить об этом можно бесконечно, и для этого есть более другие ресурсы. Главное здесь — не умножать сущности без необходимости. Помните о том, что Ваше время есть главная ценность. Не стоит его тратить на то, что не принесёт никакого эффекта.

Стоит завести wiki, наполнять faq, узнавать впечатления от использования. Вобщем, поддержать Вашего клиента информационно. Что НЕ стоит делать — Вы поймете сами. Например, участвовать в перепалках на форумах, если речь идет о Вашем продукте. Хейтеры и тролли будут всегда, особенно если продукт хоть чего-то стоит.

Ну и название. ARCAdaptor. Arcade Adaptor. А домен — adapto.rs. Вдруг будут ещё какие-нибудь адаптОры :-)

Оргвыводы и планы

Итак, ARCAdaptor оформился от "просто платы" до практически готового продукта. Это был долгий путь. В какой-то момент хотелось бросить всё, а когда-то сидеть всю ночь и думать над очередной формулировкой.

Вот некоторые выводы, которые я лично сделал в процессе работы:

Создание конечного продукта — трудный и довольно ресурсоёмкий процесс;
"Железо" и "Софт" — это всего лишь 20% от усилий. Остальные 80% — это документация;
Для себя вы делаете прототип. Продукт вы делаете для людей;
Найдите хотя бы одного из Ваших знакомых, которому интересно то же, что и Вам. Взгляд со стороны — бесценен;
Сделайте людям удобно. Это самое главное. По крайней мере, сейчас.

В ближайших планах — перевод всего, чего можно на GitHub. Это просто нужно сделать :-).

Далее, сделать поддержку V-USB из среды Arduino (ну не всё же лампочками моргать), тем более это уже частично реализовано с помощью проекта ArduinoUSB. Есть библиотека, позволяющая полноценно работать из Arduino IDE с устройствами libusb, а также включает в себя пример реализации USB-клавиатуры, как HID устройства. Сайт проекта не обновлялся довольно давно, но библиотека вполне работающая, хоть и требует некоторого "вмешательства".

Задача - сделать так, чтобы библиотека работала в актуальных версиях Arduino IDE, не требовала усилий по установке (сейчас документация говорит о том, что часть проекта нужно предварительно скомпилировать в объектные файлы - согласитесь, задача не совсем тривиальная, тем более для совсем юных падаванов), ну и конечно же, работала c ARCAdaptor.

Что сделано для этого проекта сейчас:

Немного подправлен код;
Произведено обновление до последней версии V-USB;
Установка может быть выполнена без специальных средств - как для обычной библиотеки (хотя это заслуга нового Arduino IDE, если честно - сборка работает более гуманно);
Работают все тестовые примеры (проверялось на Mac/Linux).

Что будет сделано (когда будет свободная минута):

Будет написано краткое руководство по установке;
Примеры на Python будут хотя бы задокументированы;
Всё это будет опубликовано.

Ну и, конечно, нужно продолжать наполнять базу существующих проектов.

Ниже по ссылкам отзывы пользователей (точнее одного, который был достаточно смел, чтобы рассказать о своем опыте :-) :

http://a320.emulate.su/2013/07/20/arcadaptor-pervye-testy-i-vpechatleniya/

http://a320.emulate.su/2013/07/21/arcadaptor-prakticheskoe-primenenie-v-windows-i-android/

Связь

По всем вопросам по поводу проекта ARCAdaptor можно писать в почту contact@adapto.rs

Совсем персональный сайт: http://znoxx.me.

Связаться по другим вопросам можно по почте me@znoxx.me.

Спасибо, что дочитали до конца!

Freeduino One c microUSB

noreply@blogger.com (id) — Thu, 25 Jul 2013 10:53:00 +0000

Однажды, в комментах мне попеняли на "любовь к большим разъемам USB". В другой раз услышал в личной беседе пожелание использовать microUSB, потому что "к нему проще найти кабель".

"Ну что же..." - подумал я, и:

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

Но если серьезно, меня сильно порадовало высвободившееся на плате место, это дает определенный простор для творчества (в прямом и переносном смысле).

TV-out для Arduino

noreply@blogger.com (id) — Fri, 07 Jun 2013 11:56:00 +0000

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

При определенном везении можно заполучить весьма внушительных размеров дисплей (если телевизор имеет прилично дюймов в диагонали), работающий в режиме телетайпа 38 x 25 знакомест. Впрочем, бросив первый взгляд на схему, ловишь себя на мысли о розыгрыше. В самом деле:

Обычный ATmega8 на тактовой частоте 16 МГц формирует два компонента видеосигнала, которые смешиваются нехитрой схемой из двух резисторов и двух диодов. Группой переключателей S1 устанавливаются режимы работы; согласующий резистор 75 Ом подключается через перемычку и добавлен, скорее, для универсальности (думаю, в большинстве случаев не понадобится).

Arduino выводит информацию для отображения через последовательный порт - пины RX/TX. Если вас смущает, что по ним же происходит загузка скетча и во время этого процесса на экране появляется некая "ерунда", можно уйти на любой пин с помощью библиотеки SoftwareSerial. Поддерживаются разные скорости, а также есть возможность автоопределения. Простейший скетч выглядит так:

        Serial.begin(57600); //57k6 baud
        Serial.println("Hello, world!");

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

Вы, наверное, заметили, что для вывода видео использован аудио-разъем 3,5мм. На самом деле, это не казус, а вполне осознанный выбор, ограничивающий высоту элементов и делающий возможным стекирование шилдов:

Кроме вывода обычных символов, поддерживаются так называемые ESCAPE-последовательности, которые управляют курсором, удваивавают высоту и/или ширину символов и даже переключают банки шрифтов и переопределяют символы (что, впрочем, возможно только на ATmega328P, где памяти гораздо больше, чем у ATmega8). Таким же образом можно получить версию прошивки и прочую диагностическую информацию.

Чем-то все это напоминает LoL-Shield, особенно приложениями - взгляните на список доступных .ino. Здесь найдется не только классика Life и Snake, но и более изощренные - Maze и даже простейший "графический редактор"!

Поскольку все материалы доступны и открыты для доработки, мы решили немного поэкспериментировать и создать на базе этого шилда русифицированный вариант. Имя "TellyMate", подобно Arduino, является торговой маркой - поэтому пришлось назвать наш вариант Freeduino Teleсhat:

Все детали - PTH, поскольку шилд задумывался изначально в формате кита для самостоятельной сборки - и что может быть лучше, чем собрать всё самостоятельно? ;) Пины RX/TX имеют перемычки под пайку с обратной стороны платы, так что при желании их можно перерезать и подпаять к любым другим пинам. Аналогичным способом отключается и кнопка сброса - если не хотите, чтобы МК шилда сбрасывался синхронно со скетчем Arduino.

Краткое руководство по сборке шилда:

Шутка, конечно ;) просто там действительно все элементарно. На howtomakekit.blogspot.ru, как всегда, выложена подробная пошаговая инструкция.

Русифицированный шрифт мы разместили точно таким же способом, что и автор - в виде ссылки на документ в GDocs, копию которого при необходимости можно сохранить у себя. В открытом документе надо зайти на последнюю закладку, генерирующую hex, и скопировать ее содержимое в файл fontbank0.c, подменив его в исходниках (можно скачать со страницы проекта). После компиляции получите прошивку c поддержкой кодовой страницы 866. Именно она и зашивается в ATmega8, входящие в комплект наборов Freeduino TeleChat.

Для вывода русского текста потребуется еще кое-что сделать. Как известно, ArduinoIDE хранит все символы в кодировке UTF-8, и для нормальной работы потребуется их транслировать в кодировку 866. Делать это в оригинальной прошивке нам показалось святотатством - авторы очень скрупулезно рассчитали все задержки в коде. Предлагаем самый простой вариант перекодирующей функции:

byte c1 = 0;

void tele_print_char(char cd) {
  byte c = cd;
  if (  c >= 0x80) { // UTF-8 handling
    if (!c1) {
      c1 = c;
    } else {
      if (c1 == 0xd0) { 
       if (c == 0x81) Serial.print(char(0xf0)); // Ё
        else Serial.print( (char) (c - 0x10));
      }
      if (c1 == 0xd1) {
       if (c == 0x91) Serial.print(char(0xf1)); // ё
        else Serial.print( (char) (c + 0x60));
      }
      c1 = 0;
    }
  } else Serial.print(cd);
} 

void tele_print_str(char *s) {
  for(int i=0;i<strlen(s);i++) tele_print_char(s[i]);
}

void setup()
{
  char letter[]="АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ";
  Serial.begin( 57600 ) ;
  Serial.println( "Hello World!" ) ;
  tele_print_str( "Привет, мир!\n\r" ) ;
  tele_print_str( letter );
}

void loop()
{
    // do nothing!
}

Купить шилд в собранном виде или в виде комплекта деталей можно здесь.

Для тех, кто любит почитать оффлайн - про TellyMate упоминается в книге У. Соммера "Программирование микроконтроллерных плат Arduino/Freeduino".

Web-термометр

noreply@blogger.com (id) — Tue, 07 May 2013 13:36:00 +0000

"Погодная станция своими руками" - вот как можно было бы назвать статью, но я решил пока просто рассказать о том, как соорудить web-термометр, подключить его к домашней LAN и наблюдать показания через браузер ;)

Для этого нам потребуется Arduino-совместимая плата, поддержка Ethernet и несколько температурных датчиков.

По традиции, я использовал то, что оказалось под руками:

Arduino-совместимая плата: Angelino с ATmega328P. Конечно, начать отлаживаться можно на любой Arduino-совместимой плате, с USB. Но в конечном итоге устройство будет жить где-то в кладовке, где ему уже не потребуется USB. Тоже самое относится и к схеме автоматического выбора питания, и к красивым перемигивающимся светодиодам на пинах RX/TX (их тоже никто не увидит). Памяти процессора ATmega328P как раз хватит и для управления Ethernet, и для считывания информации с датчиков;
В качестве Ethernet-контроллера - Freeduino EtherCard R1. Если нет необходимости в SD и скорости в 100Мб, вполне подойдет. Стоит он дешевле классического Ethernet+SD шилда, а поддержку SD-карт при необходимости можно добавить с помощью microSD shield;
Датчики температуры - цифровые DS18B20. Работать с ними удобно, все датчики имеют уникальный идентификатор. Могут висеть на одном проводке, поэтому сколько их там будет - один, два или десять, можно практически не задумываться.

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

Как выглядит процесс прототипизации на базе Arduino? Примерно так:

Сначала набросаем схему.

Пока всё просто - Arduino соединен с Ethernet-шилдом, обмен идет по шине SPI. Выбор устройства (он же - сигнал SS) для EtherCard находится на пине D10. Для коммуникации с сетью датчиков DS18B20 используется свободный пин D9, который в соответствии с требованиями однопроводной шины подтянут к VCC через резистор 4K7. Для питания датчиков отказываемся он паразитного режима, чтобы не усложнять себе отладку.

Настало время набросать первый скетч, в основном для проверки работы нашей схемы. Берем библиотеки EtherCard, OneWire - распаковываем их в sketchook/libraries. Если у нас изначально Angelino, на время экспериментов потребуется USB-TTL переходник (для заливки скетчей и получения отладочной информации через Serial Monitor).

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

Далее, нам потребуется IP-адрес: на случай, если в сети не окажется сервера DHCP, прописываем статический адрес прямо в скетче. Следите, чтобы он тоже был уникальным и желательно в одной подсети с целевым компьютером (например, если у компьютера, с которого вы будете подключаться к Arduino, IP = 192.168.0.2 с маской 255.255.255.0, можно выбрать для Arduino 192.168.0.3 или 192.168.0.222). Если же Arduino получит динамический IP-адрес, потребуется каким-то образом его узнать - по логам DHCP-сервера или, что гораздо проще, через Serial Monitor.

Второй момент - это опрос температурного датчика и вывод результатов. По счастью, Dallas Semiconductors (ныне является подразделением Maxim Integrated Products) снабжает все датчики уникальным ROM-кодом, нам остается только последовательно получить все их адреса на шине, а затем вывести полученные значения в тексте HTML-странички, которую будет генерировать на лету, при каждом обращении к web-серверу Arduino.

Тестовый скетч выглядит так:

#include <OneWire.h>
#include <EtherCard.h>

// настройки Ethernet

#define BUF_SIZE 512

byte mac[] = { 0x00, 0x04, 0xA3, 0x21, 0xCA, 0x38 }; // MAC-адрес

byte fixed = false; // =false: пробовать получить адрес по DHCP, 
                    //         в случае неудачи использовать статический; 
                    // =true:  сразу использовать статический

uint8_t ip[] = { 169, 254, 8, 200 };     // Статический IP-адрес
uint8_t subnet[] = { 255, 255, 0, 0 };   // Маска подсети
uint8_t gateway[] = { 192, 168, 1, 20 }; // Адрес шлюза 
uint8_t dns[] = { 192, 168, 1, 20 };     // Адрес DNS-сервера (необязателен)

byte Ethernet::buffer[BUF_SIZE];
static BufferFiller bfill; 

// настройки OneWire

#define DS18B20PIN  9
OneWire ds(DS18B20PIN);

void setup(void)
{
    Serial.begin(57600);
    delay(2000);

    // Проверяем, что контроллер Ethernet доступен для работы
    Serial.println("Initialising the Ethernet controller");
    if (ether.begin(sizeof Ethernet::buffer, mac, 10) == 0) {
        Serial.println( "Ethernet controller NOT initialised");
        while (true);
    }

    // Пытаемся получить адрес динамически 
    Serial.println("Attempting to get an IP address using DHCP");
    if (ether.dhcpSetup()) {
        ether.printIp("Got an IP address using DHCP: ", ether.myip);
    } else {
        // Если DHCP не доступен, используем статический ip-адрес
        ether.staticSetup(ip, gateway, dns);
        ether.printIp("DHCP FAILED, using fixed address: ", ether.myip);
        fixed = true;
    }
}

char okHeader[] PROGMEM =
  "HTTP/1.0 200 OK\r\n"
  "Content-Type: text/html\r\n"
  "Pragma: no-cache\r\n"
;

char authorLink[] PROGMEM =
  "</pre><hr>Read about me <a href=\"http://mk90.blogspot.com\" target=\"_blank\">here</a>"
;

static void homePage (BufferFiller& buf) {
  
  buf.emit_p(PSTR("$F\r\n"
    "<title>Arduino web-thermometr</title>"
    "<h2>DS18B20 Network:</h2>"
    "<pre>"), okHeader);
  
  byte counter = 0; 
  byte addr[8]; 
  ds.reset_search();
  delay(250);
  while (ds.search(addr)) {
    buf.emit_p(PSTR("$D: "),++counter);
    for (byte i=0; i<8; i++) {  // считываем и выводим 9-байтный код
      buf.emit_p(PSTR("$H "), addr[i]);
    }
    if ( OneWire::crc8(addr, 7) != addr[7]) {
      buf.emit_p(PSTR("- CRC is not valid!"));
    } else if (addr[0] != 0x28) {
      buf.emit_p(PSTR("- is not a DS18B20 family device!"));
    }
    buf.emit_p(PSTR("\n"));
  }
  buf.emit_p(PSTR("\nTotal: $D devices."), counter);
  buf.emit_p(authorLink);
}


void loop(void)
{
  word len = ether.packetReceive();
  word pos = ether.packetLoop(len);
  if (pos) { 
    bfill = ether.tcpOffset();
    char* data = (char *) Ethernet::buffer + pos;
    Serial.println(data); // распечатываем запрос для отладки
    
    if (strncmp("GET / ", data, 6) == 0) 
      homePage(bfill);
    else
      bfill.emit_p(PSTR(
        "HTTP/1.0 401 Unauthorized\r\n"
        "Content-Type: text/html\r\n"
        "\r\n"
        "<h1>401 Unauthorized</h1>"));
        
    // отправить ответ клиенту
    ether.httpServerReply(bfill.position());
  }
}

Скачать скетч ecard_webthermo_1

После направления браузера на http://ip-адрес-arduino, мы должны увидеть ROM-номера всех найденных датчиков, например:

Возможны следующие варианты ошибок:

Браузер "долго думает" и в итоге ничего не показывает. Загляните в вывод Serial Monitor-а, еще раз уточнив правильность набираемого в строке браузера адреса. Проверьте правильность подключения Ethernet Card R1 к сети. Из командной строки это можно сделать командой ping <адрес Arduino>, визуально - по наличию зеленого и помигиванию желтого светодиода на разъеме Ethernet Card R1;
В окне браузера мы видим, что датчиков не обнаружено. Увы, "наука о контактах" весьма часто сопровождает инженеров-практиков ;) Проверьте еще раз, что датчик правильно питается (верный признак ошибки - если вы обжигаетесь, прикасаясь к корпусу датчика), его DATA-пин подключен именно к тому пину, который указан в скетче (ну и ничего другого, разумеется, не подключено) и он не соединен по чистой случайности с GND или VCC;
В окне браузера напротив идентификатора датчика отображается ошибка CRC. Это разновидность предыдущей ошибки подключения датчика - только ошибка может быть не только в неустойчивом контакте, но и в наводках на кабель. Еще раз проверьте контакты, в крайнем случае замените кабель небольшим кусочком провода - после завершения отладки можете экспериментировать с его длиной сколько угодно, а лучше загляните в эту статью.

Разобравшись со всеми ошибками, можно продолжить совершенствовать скетч.

Первым делом, надо добавить считывание и вывод значений температуры, путем нехитрых манипуляций, благо они подробно расписаны в документации на DS18B20.

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

Для удобства добавим функции setConversionTime и startConversionAll, а затем перепишем homePage - вместо вывода адреса, пустим его "в дело" - то есть в вычисление температуры.

// команды DS18B20

void setConversionTime(byte conf) {
  ds.reset();
  ds.skip(); // skip ROM
  ds.write(0x4E); // write scratchpad
  ds.write(0); // Th
  ds.write(0); // Tl
  ds.write(conf); // configuration
}

void startConversionAll() {
  ds.reset();
  ds.skip(); // skip ROM
  ds.write(0x44,0); // start conversion
  delay(10);
}

static void homePage (BufferFiller& buf) {
  
  buf.emit_p(PSTR("$F\r\n"
    "<title>Arduino web-thermometr</title>"
    "<h2>DS18B20 Network:</h2>"
    "<pre>"), okHeader);
  
  byte counter = 0; 
  byte addr[8]; 
  byte data[12];
  
  setConversionTime(0x7F); // установить 9-битное разрешение 
  startConversionAll(); // запустить конвертацию температуры
  delay(100); // на конвертацию 9-битного значения требуется 93,75 мс
  
  // ищем устройства и выводим результаты
  ds.reset_search();
  delay(250);
  while (ds.search(addr)) {
    buf.emit_p(PSTR("$D: "),++counter);
    if ( OneWire::crc8(addr, 7) != addr[7]) {
      buf.emit_p(PSTR("- address CRC is not valid!\n"));
      continue;
    } else if (addr[0] != 0x28) {
      buf.emit_p(PSTR("- is not a DS18B20 family device!\n"));
      continue;
    }
    ds.reset();
    ds.select(addr);
    ds.write(0xBE); // читать scratchpad
    for (byte k=0; k<9; k++) {  // нам потребуется 9 байт
      data[k] = ds.read();
    }     
    if ( OneWire::crc8( data, 8) != data[8]) {
      buf.emit_p(PSTR("- value CRC is not valid!\n"));
      continue;
    }
    buf.emit_p(PSTR(" $D.$D °C\n"), *(int *)data/16, (int) (abs(*(int *)data % 16) * 0.625));
  }
  buf.emit_p(PSTR("\nTotal: $D devices."), counter);
  buf.emit_p(authorLink);
}

Скачать скетч ecard_webthermo_2

Ну вот, теперь наш скетч стал вполне рабочим:

(полные тексты всех скетчей можно скачать по ссылке в конце статьи)

Отлично, но что делать, если хочется вместо порядкового номера видеть осмысленные местоположения проведения измерений? Допустим, "гостиная" или "балкон"?..

Тут, наверное, будет уместным заметить, что из алгоритма поиска на однопроводной шине однозначно вытекает гарантия, что для одного и того же набора датчиков последовательность их нахождения будет всегда одной и той же. Иными словами - если уж вы развесили конкретные датчики по конкретным помещениям, то - при условии, что они все работают - в процессе поиска первым всегда будет найдено одно помещение, вторым - другое, и т.д. Остается жестко прописать названия в скетче, и потом выводить их вместо номера. Например, через объявляемый в памяти программ массив locations:

// локации

prog_char string_0[] PROGMEM = "Комната";   
prog_char string_1[] PROGMEM = "Кухня";
prog_char string_2[] PROGMEM = "Балкон";

PROGMEM const char *locations[] = 
{   
  string_0,
  string_1,
  string_2
};

Директива PROGMEM предписывает компилятору размещать строковые константы в памяти программ, что одновременно обязывает использовать для обращения к ним специальные процедуры. Вот как это выглядит в замененном в homePage фрагменте, где выводится строка с названием локации:

  while (ds.search(addr)) {
    //buf.emit_p(PSTR("$D: "),++counter);
    buf.emit_p( (char*)pgm_read_word(&(locations[counter++])) );
    buf.emit_p(PSTR(": "));

Результат в окне браузера:

Кстати - русский язык существует в ArduinoIDE в виде UTF-8, поэтому для корректного отображения на платформах, для которых эта кодировка не является системной (например, Windows XP), требуется уточнить ее в HTTP-ответе OK, изменив строки в массиве okHeader следующим образом:

char okHeader[] PROGMEM =
  "HTTP/1.0 200 OK\r\n"
  "Content-Type: text/html; charset=utf-8\r\n"
  "Pragma: no-cache\r\n"
;

Скачать скетч ecard_webthermo_3

Сокрушительно слабое место такого подхода - изъятие, замена или добавление датчика в сеть. Тут же изменяется порядок поиска и надо заново выяснять, как последовательность поиска сопоставлена с названиями локаций. Для этого, а также для изменения имени локации надо перекомпилировать скетч и залить его в Arduino, что не всегда возможно/удобно.

Следовательно, наиболее надежно - запоминать соответствия индентификаторов датчиков и локаций. Хотя можно возложить это на специальную программу и пользоваться ей вместо браузера, но выглядит это как-то неуклюже. Гораздо проще все поручить Arduino, задействовав EEPROM - энергонезависимую память нашего MCU, которую можно перезаписывать прямо из скетча. Снабдив нашу HTML-страничку ссылками, можно по клику предлагать форму ввода нового имени, которое будет запоминаться в EEPROM. Быть может, на первый взгляд это кажется сложным, но не забывайте - у нас в распоряжении остаются еще свыше 10К свободной памяти программ!

Для начала определим формат хранения в EEPROM - в нулевой ячейке будем хранить размер списка, а дальше - записи, состоящие из адреса (8 байт) и собственно названия (17 байт). Для удобства доступа определим макросы через #define:

// константы для EEPROM

#define EEFIRSTENTRY  1
#define EEADDRLEN  8
#define EENAMELEN  17

// макросы для доступа в EEPROM

#define LOCADDR(n) (EEFIRSTENTRY+((n)*(EEADDRLEN+EENAMELEN)))
#define LOCNAME(n) (EEFIRSTENTRY+EEADDRLEN+((n)*(EEADDRLEN+EENAMELEN)))

В самом начале EEPROM вообще ничего не хранит, и скорее всего из нулевого байта мы прочтем первый раз 0xff. Это как минимум наводит на мысль, что в setup нелишне было бы проверить, что этот байт хранит какое-то реальное значение, не "убегающее" за пределы доступного EEPROM, размер которого у ATmega328P равняется 1024 байтам:

    // считываем и анализируем EEPROM
    if ( ((EEPROM.read(0)+1)*(EEADDRLEN+EENAMELEN)+EEFIRSTENTRY) > E2END) {
      EEPROM.write(0,0); // инициализируем число записей
    }

Теперь надо добавить новую функцию searchLocationByAddress, которая будет 1) по ROM-идентификатору датчика возвращать порядковый номер найденной записи и 2) если записи не найдено, создавать такую запись и присваивать локации стандартное имя "?".

byte searchLocationByAddr(byte *addr) {
  byte total = EEPROM.read(0);
  for (byte i=0;i<total;i++) {
    byte equial = 0;
    for (byte k=0;k<EEADDRLEN;k++) {
      if (addr[k] == EEPROM.read(LOCADDR(i)+k)) equial++;
    }
    if (equial == EEADDRLEN) return i;
  }
  
  // записи не найдено, создаем еще одну - в конце
  for (byte k=0;k<EEADDRLEN;k++) {
    EEPROM.write(LOCADDR(total)+k,addr[k]);
  }
  
  EEPROM.write(LOCNAME(total),'?');
  EEPROM.write(LOCNAME(total)+1,0);
  
  EEPROM.write(0,total+1);
  return total;
}

Теперь настало время подумать о дополнительном CGI-скрипте для редактирования названия локации. Пусть он будет называться "e" - для краткости. Добавим в loop лишний оператор if, проверяющий URL в запросе:

    if (strncmp("GET / ", data, 6) == 0) 
      homePage(bfill);
    else if (strncmp("GET /e", data, 6) == 0)
      editPage(data, bfill);
    else
      bfill.emit_p(PSTR(
        "HTTP/1.0 401 Unauthorized\r\n"
        "Content-Type: text/html\r\n"
        "\r\n"
        "<h1>401 Unauthorized</h1>"));

Теперь добавим ссылку в вывод на основной странице - в функции homePage:

    counter++;
    byte idx = searchLocationByAddr(addr); // возвращает номер локации в eeprom
    buf.emit_p(PSTR("<a href=\"/e?n=$D\">$E</a>: "), 
      idx, LOCNAME(idx));

Тут надо немного пояснить аргументы buf.emit_p: подобно функциям семейства printf, она формирует строку по шаблону (первый параметр), подставляя в него все последующие (второй параметр и далее). В шаблоне можно указывать следующие типы данных:

$D - числовая константа;
$S - строковая константа;
$F - строковая константа, расположенная в PROGMEM (т.е в памяти программ);
$E - строковая константа, расположенная в EEPROM (что мы и использовали).

Наконец, сама функция редактирования. Манера ее написания покажется до боли знакома web-программистам: генерация формы или запоминание значения, переданного через GET:

static void editPage (const char* data, BufferFiller& buf) {
  if (data[6] == '?') {
    char buf2[96];
    if (EtherCard::findKeyVal(data+6, buf2, sizeof(buf2)-1, "n")) {
      byte n = atoi(buf2);
      if (!EtherCard::findKeyVal(data+6, buf2, sizeof(buf2)-1, "s")) {
        // генерировать форму
        buf.emit_p(PSTR("$F\r\n"
        "<h3>Edit location name</h3>"
        "<form>"
         "<p>"
         "Change name: <input type=text name=b value='$E' size=8>"
         "<input type=hidden name=n value=$D>"         
         "<input type=submit name=s value=set>"
         "</p>"
        "</form>"), okHeader, LOCNAME(n), n); 
        return;
      } else {
        // cохранить новое название локации
        byte len = EtherCard::findKeyVal(data+6, buf2, sizeof(buf2)-1, "b");
        if (len) { 
          EtherCard::urlDecode(buf2);
          for (byte i=0;i<(strlen(buf2)+1);i++) 
            EEPROM.write(LOCNAME(n)+i,buf2[i]);
        }
      }
    }
  }  
  buf.emit_p(PSTR(
        "HTTP/1.0 302 found\r\n"
        "Location: /\r\n"
        "\r\n"));  
}

Другая вспомогательная функция EtherCard::findKeyVal служит для поиска параметра в строке GET. Она анализирует цепочку символов запроса в поисках названия параметра, а затем копирует в буфер значение после знака равенства. Функция EtherCard::urlDecode приводит кодированные для передачи через URL символы типа %20 к нормальному виду.

Скачать скетч ecard_webthermo_4

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

Внимательнее манипулировать EEPROM - например, добавить проверки при исчерпании свободного места и подумать о возможности удаления из таблицы названий локаций неиспользуемых записей;
Возможно, стоит отказаться от хранения числа записей в нулевой ячейке EEPROM - производитель предупреждает, что в случае сбоев она пострадает первой;
Для любителей русских названий может вызвать, например, удивление тот факт, что при максимальной длине в 17 символов, ввести можно только 8. Повторно обращаю внимание на использование UTF-8 - каждая русская буква в этом наборе занимает 2 байта, поэтому либо пишите по-английски, либо рассмотрите переход на однобайтовое кодирование - например, с помощью KOI8-R или CP1251;
Ограничением библиотеки EtherCard является необходимость умещать страничку в одном пакете tcp. Если размер html-кода будет расти, это может вызвать проблемы. Поэтому, старайтесь соблюдать минимализм в записи HTML - даже если это не соответствует стандартам. Разумеется, можно доработать код библиотеки ;)

Что можно было бы еще сделать? Можно добавить новые типы датчиков. Можно добавить внешнюю flash-память (например, подключаемую по i2c) и читать оттуда предварительно записанные favicon или css-стили, чтобы украсить страничку. Можно добавить базовую авторизацию, чтобы кто попало не имел доступ к информации или не мог редактировать названия локаций.

Будем считать это домашним заданием для тех, кто хочет довести свою конструкцию до совершенства - которое, конечно же, недостижимо ;)

Кстати, уже почти после написания статьи наткнулся на замечательный блог lucadentella.it, который ведет Luca Dentella, разбирая разные приемы работы с EtherCard под тегом ENC28J60.

ArduinoIDE 1.0.4

noreply@blogger.com (id) — Wed, 17 Apr 2013 13:06:00 +0000

Новая ArduinoIDE 1.0.4 вышла 11.03.2013, и почти весь ее смысл - исправление ошибок.

Лично мне видится три главных момента:

Добавлена новая библиотека GSM, для работы с Arduino GSM Shield. С ее помощью можно не только передавать данные с использованием конструкции Client/Server по аналогии с Ethernet, но и отправлять/получать SMS-сообщения, а также голосовые вызовы;
Все драйверы собраны в один пакет, с цифровой подписью для Windows 8. По идее, это упрощает процесс установки, избавляя вас от лишних вопросов и подозрений со стороны операционной системы;
Официально исправлены накопившиеся (видимо, за все время) ошибки в бутлоадере Mega2560. Ошибки это были знаменитые, ко многим давно существовали патчи - взять, например, ошибку с незагрузкой скетча, в котором встречается комбинация "!!!". Разумеется, аналогичные изменения войдут и в бутлоадер, прошитый во Freeduino Mega2560.

Впереди - слияние ветки 1.5.x и 1.0.x, но когда именно оно произойдет, пока сказать трудно...

Температура и влажность (2)

noreply@blogger.com (id) — Wed, 03 Apr 2013 17:40:00 +0000

У датчика измерения температуры и влажности DHT-11 (о его возможностях и стыковке с Arduino я подробно писал в предыдущей статье) есть "старший брат", сенсор DHT-22 (часто под этим названием фигурирует AM2302, производимый фирмой AOSONG):

Несколько проигрывая DHT11 по габаритам, этот датчик имеет более широкий диапазон измеряемых величин и обладает большей точностью. Ранние версии даташитов объясняют, что измерением температуры занимается встроенный DS18B20, однако в последних вариантах его заменили на термистор.

Сравнительная таблица из предыдущей статьи должна быть дополнена так:

Показатель	DS18B20	DHT11	DHT22
Допустимый диапазон t,°C	-55..+125	0..+50	-40..+80
Погрешность измерения t, min	±0.5°C@-10..+85°C	±2°C@0..+50°C	±0.5°C@+15..+55°C
Погрешность измерения t, max	±2°C	±2°C	±1°C
Разрешение шкалы t,°C	0.5/0.25/0.125,/0.0625	1	0.1
Допустимый диапазон RH, %	-	20..95	0..99.9
Погрешность измерения RH, min	-	±4% +25°C	±2% +25°C
Погрешность измерения RH, max	-	±5%	±4%
Разрешение шкалы RH, %	-	1	0.1

Точность измерения относительной влажности возрастает для значений меньших 12% и больших 90%, а также имеет некоторый гистерезис. Считывание очередного значения возможно не чаще, чем один раз в 2 секунды. Более подробно можно прочесть в документации: AM2302.pdf.

Подключение DHT22 к Arduino выглядит аналогично DHT11. Пины имеют идентичное назначение, схема подключения не отличается, да и протокол общения с датчиком, по сути, тот же.

Отличия начинаются в трактовке считываемых значений. Мы по-прежнему получаем от сенсора по 40 бит:

Старшая часть значения влажности;
Младшая часть значения влажности;
Старшая часть значения температуры;
Младшая часть значения температуры;
Контрольная сумма.

Значение относительной влажности и температуры выдаются в десятых долях, например: если прочитано 010Dh, то эту цифру надо перевести в десятичный формат (269), а затем разделить на 10 - получится 26,9. И, кстати, отрицательные значения температуры кодируются единицей в старшем разряде считываемого 16-битного значения: 1000 0000 0110 0101 означает -10,1 °C.

Существует несколько вариантов библиотек для Arduino (и вы можете написать свой собственный!), вот наиболее известные:

https://github.com/ringerc/Arduino-DHT22
https://github.com/adafruit/DHT-sensor-library (работает на Arduino с тактовой частотой, отличной от 16 МГц)
http://playground.arduino.cc/Main/DHTLib.

В примере ниже я использую именно последний вариант, он простой и универсальный (работает не только с DHT22, но и с DHT11). Архив с библиотекой надо распаковать в каталог sketchbook/libraries и перед загрузкой скетча в Arduino не забыть исправить значение константы DHT22_PIN на номер пина, к которому подключен вывод DATA датчика:

#include <dht.h>

dht DHT;

#define DHT22_PIN 6

void setup()
{
  Serial.begin(115200);
  Serial.println("DHT TEST PROGRAM ");
  Serial.print("LIBRARY VERSION: ");
  Serial.println(DHT_LIB_VERSION);
  Serial.println();
  Serial.println("Type,\tstatus,\tHumidity (%),\tTemperature (C)");
}

void loop()
{
  // READ DATA
  Serial.print("DHT22, \t");
  int chk = DHT.read22(DHT22_PIN);
  switch (chk)
  {
    case DHTLIB_OK:  
                Serial.print("OK,\t"); 
                break;
    case DHTLIB_ERROR_CHECKSUM: 
                Serial.print("Checksum error,\t"); 
                break;
    case DHTLIB_ERROR_TIMEOUT: 
                Serial.print("Time out error,\t"); 
                break;
    default: 
                Serial.print("Unknown error,\t"); 
                break;
  }
  // DISPLAY DATA
  Serial.print(DHT.humidity, 1);
  Serial.print(",\t\t");
  Serial.println(DHT.temperature, 1);

  delay(2000);
}

После старта программы надо вызвать окно Serial Monitor-а (Ctrl+Shift+M):

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

Диапазон питания датчика составляет +3.3...+5.5В, поэтому его можно с успехом использовать с трехвольтовыми Arduino и конструировать довольно компактные и малопотребляющие конструкции - например, при помощи Freeduino Pro Mini. Рекомендуемая длина кабеля, соединяющего DHT22 с MCU при питании от 3.3В не должна превышать 100 см.

Ссылки по теме:

Ethernet Shield своими руками

noreply@blogger.com (id) — Fri, 01 Feb 2013 16:27:00 +0000

Классический Ethernet Shield от Arduino на микросхеме Wiznet W5100 появился одним из первых, перенес уже как минимум три существенных ревизии, а также интегрирован в плату Arduino Ethernet.

Тем не менее, использование W5100 - вовсе не единственный способ добавить немного LAN в ваше устройство на основе Arduino. Давным-давно фирма Microchip выпустила Ethernet-контроллер ENC28J60, который изготавливается не только в SMD-исполнении, но и в DIP-корпусе, что сделало его незаменимым для DIY-любителей. От себя замечу, что это единственный Ethernet-контроллер в DIP-е, который вообще попадал мне в руки.

Если сравнивать W5100 и ENC28J60, сразу же выяснится, что их основная общая черта - способность работать по шине SPI и тем самым экономить пины микроконтроллера для других задач. Но по техническим характеристикам ENC28J60 уступает - он не может пощеголять ни аппаратной поддержкой TCP, ни скоростью 100 Мбит.

Но, быть может, вашему проекту оно и не надо?

Когда говорят о скорости 100 Мбит/с, подразумевают скорость работы физического интерфейса (а не скорость поступления полезных данных, которая всегда меньше). К сожалению, Arduino UNO/Mega работает на тактовой частоте 16 МГц и способен выполнять только 16 000 000 операций в секунду (одна инструкция за такт - на то он и RISC ;). Вероятно, он не справится со сложным потоком медиаданных, зато на обмен небольшими порциями управляющей информации - вполне способен. Скорее всего, вы не почувствуете разницу между 10 и 100 Мбит/с, если будете считывать состояние датчиков или давать управляющие команды. Сетевые интерфейсы, способные работать на 100 Мбит/с, как правило, поддерживают и 10 Мбит/с - если только эта скорость не будет запрещена в конфигурации сетевого устройства принудительно ~~каким-то злым маньяком~~ системным администратором.

Что касается аппаратной поддержки TCP, который обеспечивает гарантированную доставку данных для многих протоколов, включая http, то здесь тоже все относительно просто: микросхема W5100 работает с четырьмя соединениями одновременно, обрабатывая перезапросы; в микросхеме ENC28J60 такой возможности нет (хотя она и поддерживает подсчет контрольной суммы, а также имеет буфер на 8 килобайт). То, что не делается аппаратно - приходится реализовывать программно, хоть и нагружая МК Arduino. Для программиста прикладного уровня (читаем - для рядового Arduino-пользователя типа нас с вами) это решается использованием соответствующей библиотеки, с оглядкой на свободную память микроконтроллера. Опытным путем я установил, что разница по объему скетчей хоть и есть, но не такая драматически большая, как мне показалось с первого взгляда.

Что нужно для того, чтобы состыковать ENC28J60 с Arduino? Да практически тоже самое, что и W5100:

схема тактирования (кварц 25 МГц + емкости);
питание +3,3В;
шина SPI c согласованием уровней логических сигналов (+5В у Arduino и +3,3В у контроллера Ethernet);
развязка с линией (трансформатор, разрядник и резисторы - желательно 1%-ые);
внешний "точный" (1%-ый) резистор для работы опорного источника напряжения.

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

Автономные модули и шилд-платы с ENC28J60 в SMD-исполнении давно доступны на EBay и у прочих интернет-магазинов (в особенности, конечно же, в китайских) - но это всего лишь железо, реализация одной и той же, по сути, схемы. Программная часть наиболее грамотно разрабатывается JeeLabs, можно даже найти инструкции по миграции с EthernetShield на EtherCard (так называется их вариант кита для самостоятельной сборки). Идея же представить набор для самостоятельной сборки по праву принадлежит Open Electronics, а библиотеку можно скачать на GitHub.

Основываясь на этой разработке, свет увидела Freeduino EtherCard R1:

Схема оставлена практически без изменений. Вот несколько моментов, которые их отличают:

Шилд подключается по SPI, но через проходную вилку - таким образом, к нему можно подключить еще один SPI-шилд, например MicroSD shield;
Все резисторы, которые требуют повышенной точности, взяты действительно 1%-ые;
Шилд стыкуется с платой максимально компактно - обратите внимание, что в отличие от оригинала, он полностью "сел" на плату (обратите внимание на разъем USB и край печатной платы шилда, чтобы понять, о чем я говорю);
Бочкообразные электролиты несоразмерной емкости 470 мкФ заменены на низкопрофильные.

Купить шилд в собранном виде или в виде kit-а можно здесь, пошаговая инструкция по сборке доступна здесь.

При использовании библиотеки, не забывайте в инициализации ether.begin дописывать третий параметр - номер пина, к которому подключено разрешение работы. Библиотека по умолчанию предполагает D8, но в этом шилде - D10.

Возьмите прилагающийся к библиотеке пример testDHCP и найдите строчки:

  if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) 
    Serial.println( "Failed to access Ethernet controller");

Впишите номер пина в конце следующим образом:

  if (ether.begin(sizeof Ethernet::buffer, mymac, 10) == 0) 
    Serial.println( "Failed to access Ethernet controller");

И все тут же заработает (при наличии подключенной сетки с DHCP-сервером, конечно же ;)

Используем HNYDuino R2

noreply@blogger.com (id) — Mon, 21 Jan 2013 11:48:00 +0000

Новогодние праздники давно окончились, а после крещения многие уже избавились от своих новогодних деревьев. Конечно, если только это не HNYDuino R2 - с ней можно развлекаться хоть круглый год. Рассмотрим более подробно, как именно это делается ;)

Первым делом, подключим HNYDuino R2 к компьютеру через прилагающийся к ней mini-USB кабель. Следите, чтобы движок переключателя питания (слева) был установлен в нижнее положение (USB). В ArduinoIDE надо выбрать плату Arduino Leonardo:

Если все ОК, в системе появится новое устройство на шине USB, а после нажатия на сброс центральный светодиод начнет плавно переливаться красным. Установите драйверы - бутлоадера (отсюда) и Leonardo (из папки ArduinoIDE). Откройте скетч-пример Blink (Примеры -> 01. Basics -> Blink) и загрузите его в по Ctrl-U в устройство. После загрузки центральный светодиод начнет мигать красным (уже без плавного переливания).

Все получилось? Тогда двигаемся дальше!

Елка снабжена шестнадцатью одноцветными светодиодами и одним - трехцветным, а также датчиком звука:

Расположенный в центре трехцветный светодиод подключен к пинам с аппаратной поддержкой ШИМ, поэтому есть возможность плавно мигать и переливаться каждым из трех цветов через analogWrite():

красный - пин D13
зеленый - пин D10
синий - пин D5

Через гребенку на подставку дополнительно выведены:

VCC - напряжение питания MCU, в нашем случае +5В. Переключатель питания коммутирует туда напряжение питания с USB или выход микросхемы-стабилизатора 7805;
VIN - входное напряжение от разъема питания на подставке (плюс в центре). Рекомендуется подавать +7..+12В, от переполюсовки спасет расположенный на той же подставке диод 1N4007;
A4 - аналоговый вход, и он же - цифровой пин D22;
A5 - аналоговый вход, и он же - цифровой пин D23;
D17 - цифровой пин, аппаратно это PB0 - сигнал SS или PCINT0;
D7 - цифровой пин, аппаратно это PE6 - сигнал INT6/AIN0.

Светодиоды R1..R8 и G1..G8 подключены к двум закаскадированным микросхемам 74HC595, принцип работы с которыми я уже подробно разбирал в статье Удвоение пинов Arduino, а также в аналогичной статье про HNYDuino R1 (только подключены они к другим пинам). В общем случае всё сводится к выполнению двух последовательных команд shiftOut с использованием известных пинов (LATCH = 12, CLK = 8 и DATA = 16).

Вывод осуществляется при помощи функции setState(byte greenDataOut, byte redDataOut), где надо указать два байта, для G1..G8 и R1..R8 соответственно. Если мысленно выстроить образуемый ими контур в линию, могло бы получиться следующее:

Чтобы отобразить произвольный орнамент, надо сформировать два байта в двоичном виде и передать их функции setState. Например, чтобы зажечь линейку из четырех самых нижних светодиодов (G1, R1, G8 и R8), подставим на их места единицы, получится:

1 0 0 0 0 0 0 1

Теперь можно отдавать команду setState(B10000001,B10000001) - префикс 'B' предваряет число в двоичной записи. Если кому-то по душе шестнадцатеричная запись, тоже самое будет по setState(0x81,0x81).

Если и после этого останутся вопросы, загрузите пример, который прилагается к библиотеке - зацикленное случайное переключение простейших эффектов (обычно прошито в елку по умолчанию).

Датчик звука собран в виде узла с электретным микрофоном (такие обычно можно встретить в телефонных аппаратах) и операционного усилителя LM386, выход которого подключен к аналоговому пину A0:

Усиленное звуковое колебание с выхода усилителя попадает на RC-цепочку C10 и R25, причем резистор - переменный, что дает возможность регулировки чувствительности (резистор расположен с противоположной стороны):

Таким образом, регулировать можно и аппаратно, и программно. Вот примерный скетч, демонстрирующий работу датчика:

#define BLUE   5

const int thresholdvalue=400;//The threshold to turn the led on

void setup() {
  pinMode(BLUE,OUTPUT);
}
 
void loop() {
  int sensorValue = analogRead(A0);//use A0 to read the electrical signal
  if(sensorValue>thresholdvalue) {
    digitalWrite(BLUE,HIGH);//if the value read from A0 is larger than 400,then light the LED
    delay(200);
    digitalWrite(BLUE,LOW);
  }
}

В цикле постоянно проверяется значение, считываемое с A0, и если оно превысило константу thresholdvalue, трехцветный светодиод вспыхивает на 0,2 секунды синим цветом. Если после загрузки вы уже отбили себе хлопками все руки, а реакции все нет - не забудьте покрутить переменный резистор.

Более подробную информацию можно найти в нашем wiki.

RelayShield HighPower

noreply@blogger.com (id) — Fri, 11 Jan 2013 16:08:00 +0000

С момента выпуска RelayShield прошло около года. По традиции, мы проанализировали отзывы пользователей и создали новую версию:

Основная идея - реализовать возможность переключения больших токов. Соответственно, место шести реле заняли четыре, зато более мощных (10А, 250VAC или 30VDC). Как и предыдущий вариант, этот тоже никак не соприкасается с Arduino-совместимой платой при стыковке:

Для тех, кто хочет пользоваться модулем отдельно от Arduino-совместимой платы, пригодится опция "Вилки отсутствуют" - в этом варианте вилки для стыковки не напаиваются. Кроме того, если требуется освободить или переместить управление на другие выходы Arduino, это можно сделать перерезав соответствующую дорожку на solder-джампере с обратной стороны платы:

Управляющие выходы реле находятся на пинах D7, D6, D3 и D4 соответственно. Контактные группы каждого реле обозначены как:

NOx - Normal Open, разомкнутый в исходном состоянии контакт;
NCx - Normal Close, замкнутый в исходном состоянии контакт;
COMx - Common, общий.

Управление несложное - надо перевести пин в режим цифрового выхода при помощи pinMode(N, OUTPUT), затем записать в него соответствующее значение (HIGH или LOW) через digitalWrite:

LOW (исходное состояние): замкнуты NCx и COMx, NO ни с чем не соединен;
HIGH: замкнуты NOx и COMx, NC ни с чем не соединен.

Купить RelayShield HighPower можно здесь.

Как подключить шилд к Nano

noreply@blogger.com (id) — Tue, 08 Jan 2013 15:52:00 +0000

Все, кто потратил на сравнение Arduino-совместимых плат хотя бы минут десять, успели усвоить простые истины:

Полноразмерные платы типа Arduino UNO удобны для пристыковывания шилдов;
Миниатюрные платы типа Arduino Nano чудо как хороши в комплекте с беспаечной макеткой.

Но что, если требуется ровно наоборот?...

Существуют полноразмерные Arduino-совместимые платы, на которые не напаяны колодки - вместо них можно впаять штыри и воткнуть таким образом в макетку (как правило, на них даже два ряда отверстий - одно для стандартного arduino pinout, второе - на сетке 2,54 мм), хотя по смыслу такое подходит скорее для обычной макетной платы - к которой без паяльника лучше не подходить.

Nano-совместимые платы можно соединить с шилдом либо проводами на той же беспаечной макетке, либо непосредственно (без участия макетки), но, в любом случае, получится не самого приятного вида колтун.

Так или иначе, отныне у нас есть вариант шилда-переходника, который быстро и непринужденно ~~превращаются брюки~~ позволяет состыковать Nano с шилд-платами для полноразмерных старших братьев:

Вот что она умеет:

изображать arduino pinout 1.0, включая ICSP-вилку для стыковки с последними Ethernet-платами (и прочими вариантами, которые используют для коммуникаций пины с аппаратной поддержкой SPI);
разъем питания с защитным диодом и опциональной возможностью запитывания от стабилизированного источника +5В;
посадочные места для пинов A6 и A7 - если они все-таки используются в конструируемом вами устройстве;
посадочные места для резисторов-подтяжек I2C, если вдруг понадобится;
кнопку сброса (хотя она и кажется бесполезной на первый взгляд).

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

И хотя вопрос решался увеличением высоты колодок, я решил отказаться от этой затратной со всех точек зрения идеи (стоимость этих экзотических высоких колодок и результирующая высота и прочность конструкции) и поместил Nano с противоположной стороны ;) Иными словами - колодки для шилдов и для Nano смотрят в разные стороны:

Я, конечно, понимаю - истинный фанат платформы Arduino просто обязан иметь в своем арсенале как минимум Nano, UNO, и Mega, а следовательно - в таком переходнике не нуждается. Тем не менее, по себе знаю, что прототипизация происходит очень спонтанно и результат качественно зависит от того, что оказалось под руками в конкретный момент времени. В результате это может выглядеть так:

Что до меня лично - я, наконец, получил возможность питать и Nano, и UNO от одного блока питания - быть может, эта идея еще кому-то понравится ;)

Купить кит или собранную плату можно здесь. А руководство по сборе кита (поясняющее отдельные моменты конструкции) - прочитать здесь.

IR-приемник на Arduino

noreply@blogger.com (id) — Tue, 25 Dec 2012 15:06:00 +0000

Когда ваше устройство на основе Arduino переходит из фазы прототипизации в реальную жизнь, часто возникают вопросы типа "надо делать корпус" - и все из-за того, что отлично работающие под уютной настольной лампой, от лабораторного источника питания устройства могут не пережить и одной попытки использования в руках ребенка или "отчаянной" домохозяйки. Да я уж и не говорю о рассеянных авторах! ;)

Один из таких аспектов - дистанционный пульт для исполнительного устройства на основе Arduino. Изготавливать его самостоятельно может оказаться довольно муторным делом - во времена первых советских бытовых компьютеров, например, можно было изготовить самостоятельно пленочную клавиатуру или разобрать калькулятор с шикарными герконовыми клавишами. Но теперь, стоит нам оглянуться по сторонам - и на глаза обязательно должен попасться ИК-пульт от какой-то бытовой техники (телевизора, музыкального центра, кондиционера). Если управляемое устройство находится в прямой видимости управляющего - это определенно ~~возможность схалявить~~ наш вариант:

Как грамотно построить схему ИК-приемника? Начнем с краткой справки по структуре сигнала: обычно, это серия световых импульсов определенной частоты - что-то около 38 кГц. Импульсы по специальным правилам образуют посылки, в которых кодируются команды (проще говоря - каждой кнопке соответствует свой код). Для передачи используется инфракрасный светодиод, для получения - инфракрасный приемник.

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

Стоит запомнить, пожалуй, единственный принципиальный момент - от того, насколько соответствуют частоты пульта и приемника, зависит дальность приема. Иными словами, если излучение модулировано частотой 38 кГц, а фотоприемник по спецификации рассчитан на 36 кГц - все равно будет работать, только придется ближе подходить ;) Выглядят подобные устройства, например, так:

Подключить фотоприемник к Arduino можно с минимальным комплектом деталей:

Резистор R1 и емкость C1 нужны для стабилизации питания, подтягивающий резистор опционален (хотя, как вы понимаете, подтягивающий резистор уже есть в Arduino и использовать можно его).

В качестве библиотеки можно взять вариант от Ken Shirriff, который не только поддерживает форматы NEC, SIRC, RC5, RC6, но и может принимать вообще "сырые" посылки, ни к одному известному коду не относящиеся (и умеет еще много другого, конечно же ;)

Первым делом надо загрузить в Arduino тестовый скетч IRecvDemo и решительно испытать на нем все необходимые кнопки вашего ИК-пульта, просматривая результат в окне Serial Monitor-а:

/*
 * IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv
 * An IR detector/demodulator must be connected to the input RECV_PIN.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
  }
}

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

И, кстати, вызов decode неблокирующийся. После его вызова управление сразу же возвращается и, таким образом, скетч может работать и "заниматься своими делами", принимая команды от пульта в фоновом режиме.

Не забудьте также посмотреть самое лучшее в инете описание IR-кодов на страницах SB Projects.

ArduinoIDE 1.0.3

noreply@blogger.com (id) — Fri, 21 Dec 2012 16:44:00 +0000

Вышла очередная версия ArduinoIDE 1.0.3. Самым значимым в списке изменений идет новая плата - Arduino Esplora (Leonardo-совместимая, на основе ATmega32u4):

В отличие от предыдущих плат, на этой есть сенсоры: фоторезистор, акселерометр, датчик температуры. Также есть четыре кнопки, аналоговый джойстик, пьезоизлучатель, трехцветный светодиод и линейный потенциометр. Разъемы для стыковки с LCD и несколько входов / выходов тоже присутствуют:

Рулить всем этим многообразием помогает Esplora Library. Вообще, конечно же - это просто мечта для гаджетоманов-ардуинокопателей, которым не жалко потратить 65 USD. Но перед покупкой все-таки рекомендую пробежаться по Getting Started With Esplora.

Но вернемся к новой версии ArduinoIDE: нас ожидает пара незначительных фиксов, связанных с Leonardo-совместимыми платами. Один касается бутлоадера, другой - массива digital_pin_to_timer_PGM, описанного в variant-файле.

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

Исправления хоть и мелкие, но вполне разумные, поэтому рекомендую владельцам Freeduino 32u4 а) провести обновление поддержки своей платы в ArduinoIDE с помощью нового variant-файла и б) при наличии программатора, прошить новый бутлоадер. Со старым бутлоадером Caterina, естественно, тоже будет работать, но начиная с этого момента во все Leonardo-совместимые контроллеры в нашем магазине по умолчанию будет прошит новый вариант. Так что смело качайте и распаковывайте этот файл в каталог с установленной ArduinoIDE 1.0.3 (не забудьте ее перезапустить, чтобы изменения актуализировались).

В новостях также сообщается и про обновление кода для бутлоадера ATmega8, а также про поддержку скорости 600 бод библиотекой SoftwareSerial.

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

И, судя по всему, число клонов Leonardo будет расти. Взять, например, новую "женскую" плату от Seeedstudio:

Если присмотреться, то видно несколько моментов:

есть колодки пинов и вилка программирования, так что скорее всего предполагается стыковка с шилд-платами;
присутствует холдер с батарейкой и переключателем питания - следовательно, возможна автономная работа и трехвольтовое питание платы/схемы;
на плате - ATmega328P и FT232RL (авторы утверждают, что в продажу пойдет плата именно с ATmega32u4);
присутствует пара SMD-светодиодов ;)

Плата все еще не имеет названия, и если на языке вертится что-то подходящее - напишите им немедленно! ;)

Температура и Влажность

noreply@blogger.com (id) — Sat, 15 Dec 2012 11:32:00 +0000

Из серии статей про измерения температуры незаслуженно выпал сенсор DHT11, представляющий собой недорогой цифровой датчик температуры и влажности в одном корпусе:

В принципе - одновременно измерять температуру и относительную влажность выглядит логично, поскольку второе напрямую зависит от первого. Стоит только начать работать батареям центрального отопления, как температура в квартире повышается, а вот количество влаги в воздухе - нет, оттого и говорят, что, мол, "батареи сушат воздух". Правильнее - "нагревают" и, таким образом, понижают относительную влажность.

Насколько важна влажность в помещении? Считается, что оптимум лежит около 50% - именно при такой влажности растения, люди и животные будут чувствовать себя комфортно. В частности - люди меньше болеют вирусными заболеваниями, а растения не рискуют превратиться в экибану.

Вот так устроен этот датчик внутри (а ведь он заменяет собой целый психрометр):

С одной стороны микроплатки - аналоговый сенсор, с другой - микросхема, оцифровывающая измерения и реализующая интерфейс с MCU.

Протокол обмена - однопроводный, по структуре сильно похож на DS18B20, но с важными оговорками:

DHT11 не умеет работать в "паразитном" режиме (питание по линии данных);
каждый DS18B20 имеет персональный идентификатор, что дает возможность подключения нескольких таких датчиков к одному пину Arduino - у DHT11 такой возможности нет - один датчик будет использовать строго один цифровой пин.

DHT11 медленнее конвертирует измеренные значения - считывать их можно не чаще, чем раз в секунду. Погрешность у него тоже больше:

Показатель	DS18B20	DHT11
Допустимый диапазон t,°C	-55..+125	0..+50
Погрешность измерения t, min	±0.5°C@-10..+85°C	±2°C@0..+50°C
Погрешность измерения t, max	±2°C	±2°C
Разрешение шкалы t,°C	0.5/0.25/0.125,/0.0625	1
Допустимый диапазон RH, %	-	20..95
Погрешность измерения RH, min	-	±4% +25°C
Погрешность измерения RH, max	-	±5%
Разрешение шкалы RH, %	-	1

(для тех, кто склонен путать разрешающую способность и точность: хотя DS18B20 можно настроить таким образом, чтобы он отдавал 12-битные значения с разрешением 0,0625 градуса, его точность не станет лучше 0.5С. Но можно сделать "более живой" дисплей с отображением двух знаков после запятой ;)

Из характеристик видно невооруженным глазом, что DHT11 практически идеально подходит для жилых помещений и комнатных температур. Если датчик попадает в условия, выходящие за допустимые пределы, он начинает врать (попутно ускорится процесс старения аналогового сенсора), после чего требуется несложный процесс восстановления. Более подробно про это можно прочесть в описании: DHT11.pdf.

Как подключить DHT11 к Arduino? Начнем с расположения его пинов:

(третий пин не надо никуда подключать)

Рекомендуемая схема подключения содержит обязательный для однопроводных линий резистор-подтяжку к VCC и, в качестве опции, рекомендуется конденсатор (фильтр по питанию между VCC и GND):

На макетке это выглядит так (сенсор подключен к цифровому пину D8 платы Freeduino Nano):

Кстати, если вам в руки попал DHT11 на небольшой платке, можно подключать его напрямую к Arduino - скорее всего, резистор и конденсатор там уже и так есть:

Разберемся, как происходит обмен DHT11 с Arduino. Логически, это представляется такой последовательностью:

Arduino запускает считывание показаний, переводя свой пин в режим выхода - как минимум на 18 миллисекунд переводит его в LOW, затем на 40 мкс в HIGH - и, после этого, переключает его в режим входа;
Через 20..40 мкс DHT11 отвечает подтверждением, также сначала переводя шину в LOW на 80 мкс, а затем в HIGH на 80 мкс;
DHT11 начинает побитную передачу информации, каждый бит начинается с уровня LOW в течение 50 мкс, и затем HIGH разной продолжительности: если 26-28 мкс, то это ноль, если же 70 мкс - единица;
По окончании передачи 40 бит информации DHT11 "на прощание" еще раз переводит шину в LOW на 50 мкс и освобождает ее.

Полученная от DHT11 пачка из 40 бит представляется в виде последовательности из 5 байт следующего содержания:

Целая часть значения влажности;
Дробная часть значения влажности;
Целая часть значения температуры;
Дробная часть значения температуры;
Контрольная сумма.

Как всегда, можно воспользоваться готовой библиотекой, которая считывает показания и вычисляет контрольную сумму для проверки. Что характерно, байты с дробной частью приходят всегда нулевые - пусть вас это не смущает, так и задумано ;)

Примеры использования DHT11 с Arduino: во-первых, данные можно выводить в последовательный порт и наблюдать на Serial Monitor:

#include <dht11.h>

dht11 sensor;

#define DHT11PIN 8

void setup()
{
  Serial.begin(115200);
  Serial.println("DHT11 TEST PROGRAM ");
  Serial.print("LIBRARY VERSION: ");
  Serial.println(DHT11LIB_VERSION);
  Serial.println();
}

void loop()
{
  Serial.println("\n");

  int chk = sensor.read(DHT11PIN);

  Serial.print("Read sensor: ");
  switch (chk)
  {
    case DHTLIB_OK: 
         Serial.println("OK"); 
         break;
    case DHTLIB_ERROR_CHECKSUM: 
         Serial.println("Checksum error"); 
         break;
    case DHTLIB_ERROR_TIMEOUT: 
         Serial.println("Time out error"); 
         break;
    default: 
         Serial.println("Unknown error"); 
         break;
  }

  Serial.print("Humidity (%): ");
  Serial.println(sensor.humidity);

  Serial.print("Temperature (oC): ");
  Serial.println(sensor.temperature);
  
  delay(2000);
}

Во-вторых, немного усложнив схему, можно выводить данные на LCD-дисплей:

#include <LiquidCrystalRus.h>
#include <dht11.h>

LiquidCrystalRus lcd(12, 11, 5, 4, 3, 2);
dht11 sensor;

#define DHT11PIN 8

void setup() {
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  switch (sensor.read(DHT11PIN)) {
    case DHTLIB_OK: 
                break;
    case DHTLIB_ERROR_CHECKSUM: 
                lcd.print("Checksum error");
                delay(2000);
                return;
    case DHTLIB_ERROR_TIMEOUT: 
                lcd.print("Time out error"); 
                delay(2000);
                return;
    default: 
                lcd.print("Unknown error"); 
                delay(2000);
                return;
  }
  lcd.setCursor(0, 0);
  lcd.print("Влажность,%:");
  lcd.print(sensor.humidity);
  lcd.setCursor(0, 1);
  lcd.print("Температура,C:");
  lcd.print(sensor.temperature);
  delay(2000);
  
}

Куда двигаться дальше?

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

Купить DHT11 можно, например, здесь.

Ссылки по теме:

UPD: Статья про DHT22

Ёлкадуино R2

noreply@blogger.com (id) — Tue, 11 Dec 2012 20:35:00 +0000

Опять наступает декабрь, и снова хочется чего-то новогоднего. Если уважаемый читатель еще не забыл - в прошлом году был представлен проект новогоднего Arduino-совместимого дерева HNYduino. Практически сразу появились замечания и дополнения, и через год родилась версия R2:

Из предыдущей версии были унаследованы две 74HC595, к которым подключены по 8 зеленых и красных светодиодов (более подробно об увеличении числа пинов Arduino этим способом я уже писал).

Но кое-что, конечно же, было изменено.

Первым делом ATmega328P была заменена на ATmega32u4, так что можно было бы сразу гордо писать Leonardo-compatible. Это сразу же добавило возможность и питать, и программировать ёлку напрямую от miniUSB (никаких дополнительных переходников USB-TTL не требуется). Возможность батарейного питания по-прежнему сохранена, переключение выполняется при помощи механического переключателя.

Расположенные в прежней версии по центру светодиоды убраны, а их место занял трехцветный пятимиллиметровый светодиод, подключенный к выводам, поддерживающим аппаратный ШИМ - таким образом можно подбирать практически любое сочетание цветов, плавно управляя яркостью через analogWrite().

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

Выход датчика, кстати, подключен к аналоговому входу A0.

Количество выводов, которые выведены на подставку сокращено до четырех - оставлены два аналоговых и два цифровых. Кроме них в вашем распоряжении вилка программирования ISP6 и отдельно выведенный UART.

Ну что, скажете "опять ерунда какая-то"? ;)

Возможно, да. Но при помощи смекалки и навыков программирования Arduino с ее помощью можно сделать что-то забавное, красивое и даже полезное. Важно, в чьих руках она окажется ;)

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

ArduinoIDE 1.0.2

noreply@blogger.com (id) — Sat, 01 Dec 2012 08:15:00 +0000

В конце октября - начале ноября произошло сразу несколько событий: была официально выпущена в продажу и почти сразу же распродана Arduino Due, вышла ArduinoIDE 1.5 специально для поддержки этой самой Due, затем вышла ArduinoIDE 1.0.2 - не поддерживающая Due, но содержащая много полезных фиксов для платы Leonardo.

В октябре David Mellis (один из членов команды Arduino) заявил, что уходит с позиции лидера, уступая ее Cristian Maglie из Торино. Причина банальна - Дэвид хочет сосредоточиться на аспирантуре в MIT Tech Labs, потому что, дескать, четвертый курс уже заканчивается ;) Тем не менее, он продолжает оставаться членом команды и будет принимать участие в подготовке выпуска ArduinoIDE 1.0.2, а вот управлять миграцией на новую 1.5 уже предстоит Кристиану (тем более, что он и так уже довольно много труда положил на поддержку Due).

Про версию 1.5 было отдельно написано в блоге Arduino, и если кратко, то нас ждет:

Поддержка любых микроконтроллеров и тулчейнов. Сейчас есть только Due - Atmel SAM3X, однако в скором времени туда будут добавлены все существующие AVR-платы, а на перспективу - можно будет добавлять вообще любые платы;
Автоматизация установки библиотек - их по-прежнему можно добавлять вручную, но теперь можно просто указать zip-файл, который ArduinoIDE послушно распакует и запихнет в то место, которое ему и предназначается (sketchbook/libraries), а затем добавит в список поддерживаемых библиотек;
Пересмотрено распухшее меню выбора платы, в итоге оно будет двухуровневым. Первый уровень - тип платы, второй - установленный на ней микроконтроллер.

Скачать и попробовать в действии новую версию (на момент написания статьи она уже добралась до 1.5.1) можно здесь - arduino.cc/en/Main/SoftwareDue.

Релиз ArduinoIDE 1.0.2 получился в каком-то смысле эпохальным - завершена работа над добавлением Leonardo, все недочеты поддержки ATmega32u4 в ядре наконец-то вылечены:

теперь функция tone() работает (а не вешает MCU, как это было раньше);
заработали прерывания;
исправлена работа входящего буфера данных, получаемых от USB (через CDC);
вылечено некорректное поведение функции write();
починен неработающий обмен с SD-картой во встроенной библиотеке SD.

Поэтому, рекомендую всем владельцам Freeduino 32u4 обновить ArduinoIDE до 1.0.2 в обязательном порядке.

Кстати, вышла новая официальная плата на ATmega32u4, разработанная совместно с ladyada - Arduino Micro:

Кроме нее, в списке можно обнаружить LilyPad с USB, но это не новая плата ;) а лишь обозначение для LilyPad, к которому подключили USB-TTL конвертер.

Об остальных изменениях можно прочитать здесь. Есть такие нововведения как, например, автоматическое обнаружение и вывод в print() ситуаций переполнения (ovf), бесконечности (inf) и неопределенности (nan). Но, к счастью, нет ничего такого, что заставило бы править существующие скетчи, поэтому можно пока перевести дух ;)

Апгрейдим Netduino

noreply@blogger.com (id) — Mon, 12 Nov 2012 07:27:00 +0000

Перед тем, как пройти процедуру апгрейда прошивки в Netduino, несколько слов о структуре firmware, надо которым мы собираемся надругаться.

Оно состоит из двух фрагментов:

TinyBooter - бутлоадер;
TinyCLR - .NET Micro Framework runtime.

Бутлоадер запускается сразу после включения питания, грузит TinyCLR, который, в свою очередь - запускает ваше приложение из flash-памяти.

Итак, сначала надо найти интересующую прошивку, например в wiki. Важно скачать именно тот вариант, который относится к вашему типу платы (т.е. прошивки для Netduino и Netduino Plus отличаются).

Если требуется апдейтить только TinyCLR (еще это называют minor-апдейтом, то есть незначительными исправлениями), используют утилиту MFDeploy (ее можно найти через меню "Пуск": .Net Micro Framework SDK | Tools). После запуска установите в боке Device USB и Netduino_netduino и нажмите Ping:

Как видите, если устройство подключено, оно должно откликнуться и хоть что-то сообщить. Чтобы получить более подробную информацию о выбранном устройстве, используйте команду Device Capabilities (Ctrl+Shift+C), там можно разглядеть текущую прошитую версию TinyCLR:

Если Netduino все-таки не отзывается, нажмите расположенную на нем кнопку сброса, и, не отпуская, переподключите плату к шине (отключите, а потом снова воткните в USB - после 20 секунд плата войдет в специальный failsafe-режим), при этом на Ping она будет отвечать "TinyBoot".

Теперь в боксе Image File надо выбрать файлы для прошивания. Обычно их два - ER_CONFIG и ER_FLASH. Можете добавить сразу оба, после этого можно нажать Deploy.

Дождитесь завершения процесса и еще раз нажмите Ctrl+Shift+C - информация с номерами прошивок должна измениться.

Для более значимых апгрейдов (например, с 4.1 до 4.2) требуется замена TinyBooter. В этом случае надо прибегнуть к фирменной атмеловской утилите "SAM-BA CDC" (можно скачать бесплатно с сайта ATMEL, правда придется заполнить несложную регистрационную форму), но для начала надо полностью похерить содержимое флеш-памяти:

Подключите Netduino к источнику питания, затем соедините Erase Pad (небольшая токопроводящая площадочка рядом с пином D0) с питанием +3.3В на более чем полсекунды. Готово! Если и было там какое-то firmware, то теперь оно стерто.

Переподключите плату - теперь вы увидите в списке устройств неизвестное устройство c VID=03EB и PID=6124. Если указать мастеру установки поискать драйвера в папке инсталлированной атмеловской утилиты, должен установиться виртуальный последовательный порт (запомните его номер!):

Самое время запустить SAM-BA-CDC Tool, выбрать номер свежеустановленного последовательного порта, тип платы "at91sam7x512-ek" и нажать Connect:

Теперь последовательно проделаем следующие действия:

Выберите в выпадающем списке Scripts "Boot from Flash (GPNVM2)", затем нажмите кнопку Execute;
Выберите там же "Enable Flash Access", затем опять нажмите Execute;
Выберите файл для зашивания (кнопка рядом с полем Send File Name), выберите файл TinyBooterDecompressor.bin;
Нажмите Send File и подождите завершения (всего пара секунд);
В окне с вопросом о залочивании областей (lock regions) откажитесь - ответьте No;
По желанию, можно проверить записанный файл - поправьте размер файла в поле size (receivedfile) путем добавления 2-3 нулей в конце и нажмите "Compare sent file with memory". Должно появиться "match".

После этого можно закрыть SAM-BA-CDC Tool и переподключить Netduino к источнику питания - новый TinyBooter будет ожидать загрузки нового TinyCLR, как это делать - см. выше.

От себя добавлю - после обновления до .Net Micro Framework 4.2 все мои нарекания по работе с Visual Studio исчезли. Только не забудьте после апгрейда выбрать в свойствах проекта .Net целевую версию 4.2, иначе Deploy вашего приложения из студии будет завершаться неуспехом:

Ну и вот ради чего все это было проделано ;) Пошаговая отладка великолепно работает в виртуальной машине:

Скоро Due!

noreply@blogger.com (id) — Fri, 05 Oct 2012 11:18:00 +0000

Вот и прошел очередной Maker Faire в Нью-Йорке, и появились первые слухи по поводу даты входа Arduino Due. Вот что пишет Engadget:

The Due is roughly the size of the Mega 2560, but swaps the 16MHz, 8-bit processor found in your standard issue Arduino for a 96MHz Cortex-M3. Predictably, the Due is a much more capable development platform, and could easily replace multiple AVR-based Arduinos in products like DIY Drones' UAVs. The Due isn't expected ship till at least November in large quantities, but preview boards are currently being handed out to select developers.

То есть, в народ она пойдет где-то после ноября, есть и спецификации (взято отсюда):

TinyDuino

noreply@blogger.com (id) — Mon, 24 Sep 2012 08:52:00 +0000

Казалось бы, куда еще развивать тему с LilyPad, но попытки улучшить идею продолжаются. На этот раз - в сторону еще большей миниатюризации в проекте TinyDuino.

Название: TinyDuino
Процессор: ATmega328P-MU
Тактовая частота: 8 МГц
Совместимость с ArduinoIDE: да, требуется USB-TTL
Совместимость с Shield-платами: собственный стандарт шилдов
Авторы: TinyCircuits
Страница проекта: http://tiny-circuits.com/products/tinyduino/
Дата первого упоминания: 22.08.2012

На фото - основная плата TinyDuino Processor Board. Из интересных особенностей я бы отметил возможность питания от литиевой батареи, с автовыбором источника (можно припаять на тыльную сторону разъем-холдер):

Если на плату подано внешнее напряжение питания +5В, питание будет осуществляться от него, и только при его пропадании - от батарейки.

Другая особенность - все пины ATmega выведены на миниатюрную двурядную колодку:

Что характерно, есть и три неиспользуемых контакта (для организации схем между шилдами - RSV0..2).

И, конечно же, для TinyDuino есть свои TinyShield-ы. Например, для подключения USB и программирования есть TinyShield USB & ICP:

Идея LoL-shield, реализованная для полноразмерных Arduino, существует и здесь, в виде TinyShield 16 Edge LEDs (с помощью пяти пинов управляем 16-ю светодиодами):

Если размер 20x20 мм все-таки великоват, есть и TinyLily - совсем миниатюрная LilyPad:

Ее диаметр - всего 14 мм, и именно поэтому наружу по краю выведено только по четыре цифровых и аналоговых пина (зато уже не так страшно стирать! Все-таки она в 12 раз меньше оригинального LilyPad ;) В спецификациях процессорной платы указано, что она по умолчанию сконфигурирована на 8 МГц, однако внешнего резонатора ни на фото, ни по схеме не видно. Следовательно, используется внутренняя RC-цепочка, которая хоть и доступна для калибровки, однако сильно зависит от напряжения питания и температуры окружающей среды (не очень удачное решение для носимых на одежде устройств).

Проект TinyDuino чем-то напомнил мне советские микромодули - в те времена уже начали задумываться о миниатюризации схемы и была предпринята попытка делать их на типовых элементах в виде модулей на пластинке размером примерно 10x10 мм. Это позволяло достигнуть плотности монтажа аж до 20 элементов в 1 см3, но как таковое не прижилось - к концу 60-х годов их вытеснили более надежные и технологичные интегральные схемы, а затем добили микросхемы ;)

Тем не менее, радиолюбители со стажем могут гордо продемонстрировать внукам эдакую диковину - усилитель или триггер по размеру и форме напоминающий палец ;) Станет ли такой же диковиной TinyDuino через несколько лет? Время покажет, а пока ребята собирают через kickstarter деньги на начало массового производства. Если идея нравится - помогите им осуществить задуманное материально, они в долгу не останутся ;)

Пин Arduino	GPIO Linux
0	50
1	51
2	14
3	15
4	28
5	17
6	24
7	27
8	26
9	19
10	16
11	25
12	38
13	39
14	44
15	45
16	46
17	47
18	48
19	49

Пин Arduino	GPIO Linux
0	50
1	51
2	14
3	15
4	28
5	17
6	24
7	27
8	26
9	19
10	16
11	25
12	38
13	39
14	44
15	45
16	46
17	47
18	48
19	49

Пин Arduino	GPIO Linux
0	50
1	51
2	14
3	15
4	28
5	17
6	24
7	27
8	26
9	19
10	16
11	25
12	38
13	39
14	44
15	45
16	46
17	47
18	48
19	49