Платы Intel® Edison оборудованы встроенным модулем Bluetooth*. В этом документе показано включение Bluetooth* и связывание устройства.

Для включения Bluetooth* выполните следующие команды.

     rfkill unblock bluetooth
     bluetoothctl

bluetoothctlзапуск программы командной строки BlueZ. В этой программе вы увидите [bluetooth]#в начале каждой строки.

Зарегистрируйте агента и настройте его использование по умолчанию.

     agent KeyboardDisplay
     default-agent

Для сканирования устройств Bluetooth* выполните scan on. Будут показаны доступные устройства Bluetooth.

     scan on

Для связывания с устройством Bluetooth* требуется знать идентификатор устройства: он используется в следующей команде.

     pair <Device ID>

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

     connect <Device ID>

Чтобы отобразить список других команд, введите help. Для выхода из BlueZ введите exit. Снимок экрана см. на рис.1.

Рисунок 1. Снимок экрана настройки Bluetooth*

Ресурсы

Intel® Intel® Edison. Руководство пользователя по использованию Bluetooth

Intel® Intel® Edison. Ресурсы для разработчиков

В рамках программы Intel® IoT Developer Program вы получите инструменты, шаблоны, библиотеки и другие ресурсы для ускорения разработки решений Интернета вещей: от замысла — к прототипу, от прототипа — к производству. Мы поддерживаем ваши разработки в течение всего жизненного цикла продуктов, предлагаем решения для безопасности и управляемости, необходимые при крупномасштабном развертывании.

Быстрое создание прототипов

Мы понимаем, что вам необходимо работать быстро и не тратить время на «изобретение велосипеда». Используя наш набор разработчика с открытым исходным кодом, вы получаете богатый набор кода и библиотек, поэтому вам не придется начинать работу с нуля.

• В шаблонах проектов реализована основная функциональность, например, управление передачей аналоговых и цифровых данных между датчиками и контактами на платах Intel® Galileo и Intel® Edison.
• Инструменты помогут вам избавиться от выполнения повторяющихся рутинных задач.
• Набор сред разработки и языков программирования для написания кода на привычном языке, с которым вам удобно работать (от JavaScript* и Python* до C/C++).

Библиотеки датчиков и ввода-вывода

Заранее написанные оптимизированные драйверы, функции и алгоритмы для различных датчиков — от акселерометров до датчиков температуры и влажности — и многое другое. 

• Низкоуровневые протоколы ввода-вывода — с помощью языков высокого уровня и конструкций библиотеки C/C++  libmraa
• Библиотека UPM с более чем сотней драйверов для датчиков и приводов.
• Привязки для JavaScript* и Python*.
• Обнаружение платы выполняется во время выполнения.

Просмотрите нашу библиотеку датчиков

Интегрированные среды разработки

Intel® XDK IoT Edition
Создание, развертывание, запуск и отладка приложений на базе Node.js* непосредственно на устройствах Интернета вещей.

Интеграция с Eclipse*
При использовании C или C++ вы получите в Eclipse полный контроль над интеграцией системных компонентов и оптимизацией производительности. Наш экземпляр поставляется с уже скомпилированными шаблонами для использования различных датчиков, Intel® IoT Cloud Analytics и пр.

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

Загрузите среду разработки по вкусу

Целенаправленные платформы разработки

К вашим услугам — широкий набор плат и комплектов для разработки, включая платы Intel® Edison, Intel® Galileoи MinnowBoard MAX*. Все эти платформы удобны для быстрой и простой разработки, они поставляются в уже настроенном виде, с мощным набором программных компонентов на основе Linux. Можно удобно подключать десятки сторонних плат расширения и датчиков, если нужно быстро проверить какую-либо идею.

Гибкие возможности подключения к облачной среде

Решения поддерживают взаимодействие с различными общедоступными облачными службами, такими как Amazon* Web Services (AWS), Microsoft* Azure*, IBM* Bluemix* и т. д. Вы получаете гибкие возможности для реализации обмена данными, их хранения и анализа.

Intel® IoT Hub for Instructables*

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

Посетите

Концепция проверена, что дальше?

После проработки концепции естественный дальнейший шаг — создание действующего прототипа. Для этого можно использовать комплект Intel® IoT Commercial Developer Kit. В состав комплекта входит плата Intel® Galileo, набор датчиков и программное обеспечение Wind River. Это полнофункциональное решение для использования API, безопасности, подключения к облачной среде и интегрированных сред разработки. Это означает, что можно перенести концепцию на платформу, средства которой позволяют наращивать функциональность, безопасность и управляемость. После успешной проверки функциональности с помощью этого комплекта можно продолжить разработку средствами Wind River, а затем перенести код в IoT Gateway для добавления датчиков и приложений промышленного уровня. Для получения уведомлений о доступности комплекта Intel IoT Commercial Developer Kit посетите Intel Embedded Design Center. 

Надежное и безопасное подключение для готового продукта: Intel® IoT Gateway
 

На этапе перехода от прототипа к полностью проработанным продуктам используйте Intel® IoT Gateway для реализации подключений. Этот интегрированный набор аппаратных и программных компонентов включает механизмы для управления данными датчиков, средства взаимного подключения датчиков и устройств и подключения их к облаку.

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

Найдите свое решение Intel® IoT Gateway

«Системы на кристалле» Intel® Quark™

• Недорогие интеллектуальные системы для периметра сети.
• Безопасное управление.
• Широкие возможности, низкое потребление электроэнергии, одноядерный чип в виде квадрата со стороной 15 мм.
• Транспорт, энергетика, производство.

Процессоры Intel® Atom™

• Исключительное соотношение производительности и потребляемой мощности.
• Отличная графика, встроенные компоненты ввода-вывода.
• Дискретный процессор и набор микросхем либо «система на кристалле».
• Транспорт, сетевое оборудование, сегменты энергетического рынка.

Intel IoT Gateway включает Wind River* Intelligent Device Platform* XT — настраиваемую среду для разработки, интеграции и развертывания шлюзов Интернета вещей. Можно получить такие модули у партнеров по альянсу решений для Интернета вещей Intel®.

Безопасность

• Дискретный доверенный платформенный модуль* (TPM).
• Безопасная загрузка*.
• Mcafee ePolicy Orchestrator*.

Управляемость

• Wind River Helix* — облако устройств.
• Wind River Helix* — облако приложений.
• Решения для управления API Intel® Mashery.

Подключения

• Проводной и беспроводной Ethernet.
• Мобильные сети.
• Виртуальные частные сети.
• Bluetooth*.

Симуляторы, средства анализа и отладки

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

Wind River Simics*
Создание моделируемой среды для имитации работы вашего решения в реальном мире. 

Технология Intel® CoFluent™
Мощные средства моделирования и анализа, позволяющие разрабатывать и проверять технические требования к системам.

Intel® System Studio
Включает компилятор с возможностями оптимизации, библиотеки функций, анализаторы, отладчик и средства трассировки.

Собираем все вместе

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

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

Intel SoC Watch– это инструмент командной строки, который позволяет анализировать энергопотребление систем, основанных на платформах от Intel. Nexus Player – одна из таких систем. Для того чтобы узнать с помощью SoCWatch о том, что творится «под капотом» Nexus Player, устройство нужно особым образом подготовить.

Общие сведения о SoCWatch

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

После сбора информации SoCWatch, по умолчанию, генерирует файлы, содержащие необработанные данные и отчёт с общими сведениями по целевой системе. Необработанные данные (они хранятся в файле формата .SW1) можно импортировать в Intel Energy Profiler. Это средство имеет такой же интерфейс, как VTune Amplifier. Здесь можно сопоставлять и визуализировать данные о поведении системы, развёрнутые во времени. Файл отчёта (в формате .CSV) можно открыть, например, в Microsoft Excel и, на основе содержащихся в нём данных, построить графики, которые позволят облегчить анализ.
 

Получение root-прав на Nexus player

Nexus Player уже появился в продаже. Подробности о работе с ним, освещённые на Intel Developer Forum 2015, вы можете найти в материале IDF2015 Lab Notes: Getting your Nexus Player from shrink-wrap to Performance and Energy Analysis.

Для того чтобы Nexus Player можно было анализировать с помощью SoCWatch, потребуются дополнительные усилия. Так, аналитической системе нужны root-права для сбора данных о производительности с помощью драйвера уровня ядра. Для того чтобы получить такие права, вы можете воспользоваться видео-руководством Nexus Player – How to Root Android TV. После того, как root-права получены, устройство сможет воспринимать команду su в оболочке ADB.
 

Построение ядра с новой конфигурацией для Nexus Player

Google отключила функцию загрузки модулей в конфигурации ядра ОС устройства. Поэтому, для подготовки Nexus Player к работе с SoCWatch, нам необходимо загрузить исходный код ядра с официального сайта Google и, модифицировав его конфигурацию, пересобрать. Для того чтобы это сделать, нужно выполнить следующие шаги.

1.Загрузим исходный код ядра с официального сайта Google.

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

export ARCH=x86make fugu_defconfigmake menuconfig

CONFIG_MODULES=yCONFIG_MODULE_UNLOAD=yCONFIG_TRACEPOINTS=yCONFIG_FRAME_POINTER=yCONFIG_COMPAT=yCONFIG_TIMER_STATS=yCONFIG_X86_ACPI_CPUFREQ=m (or CONFIG_X86_ACPI_CPUFREQ=y)CONFIG_INTEL_IDLE=y

3.Убедимся, что перестроенное ядро можно найти по адресу < INSTALLATION_DIR_PATH >\x86_64\arch\x86\boot\bzImage
 

make–j4

4.Создадим загрузочный образ с предварительно собранным ядром. В случае с устройствами, построенными на платформе Intel, иногда, если перепрошивать только раздел ядра, можно потерпеть неудачу. Поэтому мы создадим загрузочный образ с только что построенным ядром, настроенным так, как нам нужно. Для этой цели мы можем поместить ядро внутрь дерева исходного кода Android и построить только загрузочный образ.

Для того чтобы собрать загрузочный образ, мы пользуемся средством для работы с образами Android Image Kitchen. Оно, в частности, позволяет распаковывать и упаковывать образы. Для начала загрузим заводской образ с портала Google Developers. После этого воспользуемся файлом unpackimg.bat для распаковки образа и заменим файл < INSTALLATION_DIR_PATH >\split_img\boot.img-zImage на файл bzImage, который мы создали на предыдущем шаге. В завершение данного шага воспользуемся пакетным файлом repacking.bat для создания нового boot.img

Обратите внимание на то, что если устройство не может перезагрузиться после неудачной перепрошивки, оживить его можно следующим образом. Отключите кабель питания, немного подождите, подключите кабель, после чего нажмите и удерживайте аппаратную кнопку, которая расположена на нижней грани устройства. Nexus Player войдёт в режим fastboot. После этого воспользуйтесь скриптом flash-all.bat, который можно найти среди файлов, загруженных вместе с заводским образом с сайта Google Developers. Он перепрошьёт устройство и вернёт ему работоспособность.

5.Прошьём новый boot.img на устройство с помощью следующих команд:
 

adb reboot bootloaderfastboot flash boot boot.imgfastboot reboot

Теперь можно проверить версию ядра для того, чтобы понять, удалась ли перепрошивка. Если удалась, то можно собирать драйвер SoCWatch.
 

Сборка драйвера SoCWatch

Исходный код драйвера входит в состав пакета SocWatch, который можно загрузить вместе с Intel System Studio. SoCWatch – это один из компонентов Intel System Studio. Для сборки драйвера воспользуемся такой последовательностью действий:

1.Выполним сборку socperf1_2.ko с помощью скрипта для сборки драйвера в < INSTALLATION_DIR_PATH >\soc_perf_driver\src\
 

sh ./build-driver

2.Выполним сборку SOCWATCH1_5.ko с помощью скрипта для сборки драйвера в < INSTALLATION_DIR_PATH >\socwatch_driver\lxkernel\
 

sh ./build-driver –k <KERNEl_BUILD_DIR> -s <KERNEl_BUILD_DIR>

Настройка окружения SoCWatch

Можно запустить установочный файл (socwatch_android_install.bat) с помощью команды adb root после того, как на устройстве получены root-права. Однако, для того, чтобы эта команда успешно сработала, могут понадобиться некоторые дополнительные настройки. Поэтому мы рассмотрим здесь универсальную процедуру подготовки окружения SoCWatch, основанную на использовании команды su.

Для начала нужно перейти в папку SoCWatch и скопировать необходимые файлы на устройство. В нашем случае мы можем отправить эти файлы на SD-карту, а затем скопировать их в директорию /data/socwatch. Делается это так:
 

tools\os2unix.exe setup_socwatch_env.sh
tools\dos2unix.exe SOCWatchConfig.txt
adb push socwatch /sdcard/socwatch/
adb push setup_socwatch_env.sh /sdcard/socwatch/
adb push libs /sdcard/socwatch/libs/
adb push valleyview_soc /sdcard/socwatch/valleyview_soc/
adb push tangier_soc /sdcard/socwatch/tangier_soc/
adb push anniedale_soc /sdcard/socwatch/anniedale_soc/
adb push socperf1_2.ko /sdcard/socwatch/
adb push SOCWATCH1_5.ko /sdcard/socwatch/
adb shell
su
cp –r /sdcard/socwatch /data/
cd /data/socwatch
chmod 766 socwatch

Теперь вы можете, воспользовавшись Руководством пользователя по SoCWatch, приступить к сбору данных. Собрав данные, остаётся лишь загрузить полученные файлы с устройства на главный компьютер и приступить к анализу сведений о производительности и энергопотреблении Nexus Player.

Итоги

Если вы разрабатываете приложения, ориентированные на Nexus Player, то сейчас вы знаете, как сделать мир лучше. Достаточно проанализировать энергопотребление своих разработок с помощью Intel SoC Watch и исправить то, что «ест» неоправданно много электричества.

Эта статья объяснит, как создать сеть передачи данных с использованием протокола PPP, подключив GPRS-модульк плате Intel Edison.

Установка пакетов и включение PPP в ядре

Загрузим файлы с исходниками:
http://downloadmirror.intel.com/24698/eng/edison-src-ww05-15.tgz
Перед компиляцией исходных файлов, желательно увеличить root-раздел файловой системы. (Инструкция по увеличению).
В зависимости от конфигурации системы, постройка займет от 2 до 6 часов. Я использовал операционную систему Ubuntu 12.04.

Ошибки во время компиляции:

Install libtool using sudo apt-get install libtool.1. ERROR: Task 535 (/home/inteldell/edison-src/device-software/meta-edison-distro/recipes-connectivity/libwebsockets/libwebsockets_1.23.bb, do_compile) failed with exit code '1'2. NOTE: Tasks Summary: Attempted 1855 tasks of which18 didn't need to be rerun and 1 failed.

Решение: замените строку 22 в recept файле:

edison-src/device-software/meta-edison-distro/recipes-connectivity/libwebsockets/libwebsockets_1.23.bb

Оригинал:

export OPENSSL_CONF=${TMPDIR}/sysroots/x86_64-linux/usr/lib/ssl/openssl.cnf

Заменить на:

export OPENSSL_CONF=${TMPDIR}/sysroots/i686-linux/usr/lib/ssl/openssl.cnf

Конфигурирование PPP в ядре.

# bitbake virtual/kernel –c menuconfig

Сначала, я включил только поддержку PPP для асинхронного последовательного порта, но в результате появилась другая ошибка – включил PPP фильтрацию. В конце концов, я включил всё.
Теперь устанавливаем пакеты PPP из http://repo.opkg.net/edison/repo/core2-32/
Демон pppd используется для соединения GPRS-модуля.
После удачной установки вы должны увидеть следующую файловую структуру.

Чтобы работать с модемом, аппаратный последовательный порт должен быть подключен к GPIO 0 и 1.
 

Включение последовательного порта

Включите последовательный порт на пинах 0 и 1, выполнив следующие команды в терминале:

echo 214 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio214/direction
echo low > /sys/class/gpio/gpio214/direction
echo 131 > /sys/class/gpio/export 2>&1
echo mode1 > /sys/kernel/debug/gpio_debug/gpio131/current_pinmux
echo 249 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio249/direction
echo 1 > /sys/class/gpio/gpio249/value
echo 217 > /sys/class/gpio/export 2>&1
echo high > /sys/class/gpio/gpio217/direction
echo 1 > /sys/class/gpio/gpio217/value
echo out > /sys/class/gpio/gpio131/direction
echo 0 > /sys/class/gpio/gpio131/value
echo 130 > /sys/class/gpio/export 2>&1
echo mode1 > /sys/kernel/debug/gpio_debug/gpio130/current_pinmux
echo 248 > /sys/class/gpio/export 2>&1
echo low > /sys/class/gpio/gpio248/direction
echo 0 > /sys/class/gpio/gpio248/value
echo 216 > /sys/class/gpio/export 2>&1
echo in > /sys/class/gpio/gpio216/direction
echo in > /sys/class/gpio/gpio130/direction
echo high > /sys/class/gpio/gpio214/direction

Тестирование GPRS-модуля

Использовалась рабочая SIM-карта от оператора T-Mobile. Проверим состояние GPRS-модема, посылая AT-команды через программу microcom:

# microcom /dev/ttyMFD1 –s 115200
AT
OK
AT+CMGF=1                      Set SMS text format
OK
AT+CMGS="+1503*****79"       Send SMS message> Hello World
+CMGS: 14
OK

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

AT+CGATT=1                                     attach to GPRS network (normally includes in atd*99#)
AT+CGATT?                                      should return +CGATT: 1
AT+CGDCONT=1,"IP","isp.singular"               context definition
AT+CGACT=1                                     PDP context activation
AT+CGDATA="PPP",1                     	       enter data mode

Подключение к интернету с использованием GPRS

Создайте скрипт, который определяет контекст PDP (Packet Data Protocol) и сообщает о соединении. Необходимые скрипты есть в файле ppp.zip, ссылка на который приведена в конце статьи.
Теперь создайте соединение, использую команду:

# pppd call gprs &

Вы можете проверить лог-файл следующей командой:

#cat /var/log/ppp/log

Press CTRL-C to close the connection at any stage!
defining PDP context...
AT
OK
ATH
OK
ATE1
OK
AT+CGDCONT=1,"IP","isp.singular","",0,0
OK
waiting for connect...

ATD*99#
CONNECT
Connected.

Serial connection established.
Using interface ppp0
Connect: ppp0 <--> /dev/ttyMFD1
not replacing default route to wlan0 [192.168.1.1]
local  IP address 100.198.64.64
remote IP address 192.200.1.21
primary   DNS address 10.177.0.34
secondary DNS address 10.168.185.116

Ссылки:

https://communities.intel.com/docs/DOC-23449

http://repo.opkg.net/edison/repo/core2-32/

https://communities.intel.com/thread/54236

https://communities.intel.com/thread/55790

http://downloadmirror.intel.com/24698/eng/edison-src-ww05-15.tgz

http://www.att.com/esupport/article.jsp?sid=36059&cv=820#fbid=AcRge45P9Za

http://www.tldp.org/HOWTO/PPP-HOWTO/

1. Обзор MRAA

MRAA (произносится «эм-ра») это низкоуровневая библиотека, написанная на языке C. Она предназначена для абстрагирования от деталей, связанных с доступом и управлением вводом-выводом на платформе, такой как Intel Galileo или Intel Edison, при помощи введения одного небольшого API.
 

• MRAA работает как переходный слой для базовых возможностей по работе с портами ввода/вывода (GPIO) в Linux. Несмотря на то, что Linux предлагает довольно богатую инфраструктуру для управления GPIO, и типичные команды для работы с GPIO стандартны, всё же, может быть сложно их использовать.
   
• Все платформы различны. Каждая имеет различные возможности, чисто пинов и типов GPIO. Например, пин может не поддерживать одинаковые возможности для двух разных платформ. Пин может не существовать на данной платформе. Ещё и способ, которым он настраивается, может зависеть от множества факторов. Например, использование пина в одном режиме, может препятствовать работе другого пина в другом режиме или вообще запретить его использование. А так как библиотека MRAA позволяет создавать платформонезависимый код, то она делает разработку менее сложной.
   
• Надо помнить, что хотя MRAA может быть использована для написания платформонезависимого кода, разработчик всё ещё отвечает за то, чтобы код был устойчивым к ограничениям всех платформ, на которых он может быть запущен.

1.1 Загрузка библиотеки MRAA и документации по API

1.2 Имена GPIO пинов

1.3 Линковка библиотеки

gcc -g blink.c -o blink -lmraa

1.4 Использование MRAA

 mraa_result_t rv;
rv = mraa_init();
if (rv != MRAA_SUCCESS)сообщение об ошибке
	. . .

1.5 Подключение заголовочных файлов MRAA

#include <mraa.h>
#include <mraa/aio.h>

Код для цифрового устройства должен подключать:
 

#include <mraa.h>
#include <mraa/gpio.h>

2. Использование MRAA с аналоговыми устройствами

2.1 Опорное напряжение

2.2 Разрядность АЦП

2.3 Интерпретирование данных

2.4 Аналоговый пример

int main()
{
	/* initialize MRAA */
	mraa_init();
	/* create an MRAA analog context */
	mraa_aio_context m_aio;
	/* initialize A0 for use as an analog input */
	m_aio = mraa_aio_init(0);

	/* read the value, an integer */
	int value;
	value = mraa_aio_read(m_aio);

	/* print the value */
	printf(“The value returned was: %dn”, value);

	/* now release (close) the pin and exit */
	mraa_aio_close(m_aio);
	return(0)	;
}

С АЦП разрядностью 10 бит, возвращаемое значение будет от 0 до 1023. Как интерпретировать значение, зависит от устройства сенсора. Для сенсора Grove и разрядностью АЦП 10 бит, документация даёт следующие диапазоны для состояния сухо, влажно и сыро.

• 0-299= сухо
• 300-699 = влажно
• 700-1023 = сыро

3. Использование MRAA с цифровыми устройствами

#include <mraa/gpio.h>

3.1 Пример использования цифрового входа

int main()
{
	/* initialize MRAA */
	mraa_init();

	/* create an MRAA digital context */
	mraa_ai	o_context m_aio;

	/* initialize D2 for use as a digital pin */
	m_gpio = mraa_gpio_init(2);

	/* configure the digital pin as an input */
	mraa_gpio_dir(m_gpio, MRAA_GPIO_IN);

	/* read the value into an integer */
	int value = mraa_gpio_read(m_gpio);

	/* print the value */
	if (value != 0)
		printf(“The button is being pushedn”);
	else
		printf(“The button is not being pushedn”);

	/* now release (close) the pin and exit */
	mraa_gpio_close(m_gpio);
	return(0);
}

Как вы можете видеть, всё достаточно просто. Обратите внимание как мы указываем MRAA настроить пин на ввод с использованием функции mraa_gpio_dir(). Цифровые пины могут быть использованы и на ввод и на выход, в отличие от аналоговых, которые могут работать только на ввод.

3.2. Обработчики прерываний

/* first, create our counting variable */
volatile int counter = 0;

/* Now our simple counting function. */
/* This will be our interrupt handler. */
void intrHandler(void *arg)
{
	counter++;
}

/* now in our main() function */

int main()
{

	/* initialize MRAA */
	mraa_init();

	/* create an MRAA digital context */
	mraa_aio_context m_aio;

	/* initialize D2 for use as digital pin */
	m_gpio = mraa_gpio_init(2);

	/* configure the digital pin as an input */
	mraa_gpio_dir(m_gpio, MRAA_GPIO_IN);

	/* now, setup an interrupt handler. */
	/* Our function (intrHandler()) above will */
	/* be called whenever the pin goes from */
	/* HIGH to LOW */
	 */
	mraa_gpio_isr(m_gpio, MRAA_GPIO_EDGE_FALLING, intrHandler, NULL);

	/* sleep for 5 seconds, and then print out the current */
	/* value of counter */
	sleep(5);

	printf(“Counter = %dn”, counter);

	/* now, stop the interrupt handler and cleanup */
	mraa_gpio_isr_exit(m_gpio);

	/* now release (close) the pin and exit */
	mraa_gpio_close(m_gpio);
	return(0);
}

Обратите внимание на следующее в этом примере:
 

• Переменная-счетчик определена с ключевым словом volatile. Это очень важно. Ключевое слово volatile говорит компилятору C, что переменная может быть изменена без его ведома и запрещает ему делать с ней какие-либо оптимизации. Без volatile компилятор может решить, что переменная совсем не изменяется, и будет всегда выводить «0». Любая переменная, с которой работают внутри обработчика прерывания и одновременно вне его, должна быть помечена как volatile.
   
• В дополнение к MRAA_GPIO_EDGE_FALLING, функция mraa_gpio_isr() также поддерживает MRAA_GPIO_EDGE_RISING (для определения перехода с LOW на HIGH), и MRAA_GPIO_EDGE_BOTH (для определения обоих переходов). Обратите внимание, что не все типы переходов поддерживаются всеми платформами. Наиболее простой способ определить, что поддерживается, это проверить код ошибки, возвращаемый функцией mraa_gpio_isr().
   
• Последний аргумент, передаваемый в mraa_gpio_isr() это указатель. Этот аргумент будет передан в обработчик прерывания intrHandler(). Он не обязательный и может быть использован для передачи дополнительных параметров в функцию-обработчик. В нашем примере нам не нужны такие возможности, и мы просто передадим NULL.
   
• Вызов mraa_gpio_isr_exit() отключает обработчик прерываний, и его обязательно рекомендуется вызывать, чтобы исключить всякие неожиданные сюрпризы.
   
• Только один обработчик прерываний может быть подключен к конкретному пину. Полное число пинов, которые могут управлять прерываниями в одно время, зависит от платформы, как и тип прерываний, который может быть использован (MRAA_GPIO_EDGE_RISING, MRAA_GPIO_EDGE_FALLING или MRAA_GPIO_EDGE_BOTH). Это ещё одна причина, чтобы проверять код ошибки при вызове функций MRAA.

3.3 Пример цифрового вывода

int main()
{
	/* initialize MRAA */
	mraa_init();

	/* create an MRAA digital context */
	mraa_aio_context m_aio;

	/* initialize D13 for use as a digital pin */
	m_gpio = mraa_gpio_init(13);

	/* configure the digital pin as an output */
	mraa_gpio_dir(m_gpio, MRAA_GPIO_OUT);

	/* now run in a loop 10 times, blinking the output each second */
	int i;
	for (i=0; i<10; i++)
	{
		/* turn output on (HIGH) */
		mraa_gpio_write(m_gpio, 1);
		sleep(1);
		/* turn output off (LOW) */
		mraa_gpio_write(m_gpio, 0);
		sleep(1);
	}


	/* now release (close) the pin and exit */
	mraa_gpio_close(m_gpio);
	return(0);
}

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

4. Использование MRAA для широтно-импульсной модуляции (ШИМ)

Широтно-импульсная модуляция (ШИМ, PWM — Pulse-width modulation) это тип цифрового вывода. ШИМ задается двумя параметрами, периодом и коэффициентом заполнения:

• период задает, как часто надо генерировать импульс;
• коэффициент заполнения показывает, какая часть от периода должна находиться в высоком состоянии.

4.1 Основные правила использования

• MRAA предлагает возможность сконфигурировать цифровой выход для использования в ШИМ режиме. Важно проверить вашу платформу, чтобы выяснить какой пин может работать в таком режиме. Это может отличаться на разных платформах.
   
• Платформы могут отличаться по продолжительности периода, который доступен. Поэтому важно проверять ошибки вызова функций MRAA.
   
• У некоторых устройств есть требования на длину периода, который может быть использован. Например, сервомотор обычно работает с периодом 20 мс.
   
• Заголовочный файл, который надо подключить для работы с ШИМ:

#include <mraa/pwm.h>

4.2. Пример работы с ШИМ

int main()
{
	/* initialize MRAA */
	mraa_init();

	/* create an MRAA PWM context */
	mraa_pwm_context m_pwm;

	/* initialize D3 for use as a digital pin */
	m_pwm = mraa_gpio_init(3);

	/* set the period to 10ms */
	mraa_pwm_period_ms(m_pwm, 10);

	/* set the initial duty cycle to 0 */
	mraa_pwm_write(m_pwm, 0.0);

	/* enable PWM output */
	mraa_pwm_enable(m_pwm, 1);
/* now run in a loop 10 times, dimming or brightening /*
	/* the LED every 100ms */
	int i;
	float duty = 0.0;
	for (i=0; i<10; i++)
	{
		/* first, start at 0% duty cycle and increase to 100% */
		for (duty= 0.0; duty < 1.0; duty+=0.1)
		{
			mraa_pwm_write(m_pwm, duty);
			usleep(100000);
		}
		sleep(1);
		/* now decrease it to 0% */
		for (duty= 1.0; duty > 0.0; duty-=0.1)
		{
			mraa_pwm_write(m_pwm, duty);
			usleep(100000);
		}
		sleep(1);
	}

	/* disable PWM output and clean up */
	mraa_pwm_enable(m_pwm, 0);

	mraa_pwm_close(m_pwm);
	return(0);
}

Обратите внимание на следующее в этом примере:

• Мы использовали функцию mraa_pwm_write() которая принимает значение в формате плавающей точки со значением 0.0 (выключено, или коэффициент заполнения 0%) и 1.0 (включено, или коэффициент заполнения 100%).
   
• MRAA также предоставляет набор функций, которые позволяют непосредственно задавать длительность коэффициента заполнения, а не как проценты. Это может быть полезно для устройств, которые имеют специфические требования на период и величину времени, когда сигнал находится в состоянии HIGH, например, сервомотор.
   
• В MRAA есть функции для задания периода в секундах, миллисекундах (как в примере ранее) и микросекундах. В MRAA также есть функция, которая позволяет задавать одним вызовом период и коэффициент заполнения.
   
• Основная проблема в том, чтобы узнать поддерживает ли ваша платформа требуемый период. MRAA возвратит соответствующую ошибку если данный период не поддерживается.

5. Использование MRAA с Inter-Integrated Circuits (I2C)

• I2C это двухпроводная двунаправленна шина. Она может работать с частотой 100 кГц, 400 кГц, 3.4 МГц.
   
• I2C состоит из двух сигнальных линий – SCL (тактирование) и SDA (данные).
   
• Устройства I2C имеют адрес, который должен быть уникальным на шине I2C. Несколько устройств может быть подключено к одной шине, но каждое должно иметь уникальный адрес, и только с одним из них можно соединяться в один момент времени.
   
• В дополнение к адресу, I2C устройства могут иметь набор регистров (иногда называемые командами) в которые можно писать или читать. Запись и чтение этих регистров дает возможность коммуникации и управления.
   
• Заголовочный файл для работы с I2C

#include <mraa/i2c.h>

5.1 Пример работы с I2C

int main()
{
	/* initialize MRAA */
	mraa_init();

	/* create an MRAA I2C context */
	mraa_i2c_context m_i2c;

	/* initialize I2C on bus 0 */
	m_i2c = mraa_i2c_init(0);

	/* now run in a loop 10 times, reading the seconds */
	/* register and printing it.*/
	int i;
	for (i=0; i<10; i++)
	{
		char buf;

		/* always specify the address */
		mraa_i2c_address(m_i2c, 0x68);
		/* read in 1 byte.  mraa_i2c_read() always reads */
		/* starting at register 0x00 */
		mraa_i2c_read(m_i2c, &buf, 1);

		printf(“The seconds returned was: %dn”, buf);
		sleep(1);
	}
	mraa_i2c_stop(m_pwm);
	return(0);
 }

Посмотрите пример выше:
 

• Мы использовали функцию mraa_i2c_read(), которая начинает чтение из регистра 0x00. Для более гибкого использования, MRAA предлагает ещё несколько функций для чтения и записи в регистры. Также есть возможность писать и читать данные шириной 16 бит. Метод, который следует использовать, зависит от вашего устройства и программных требований.
   
• Когда вы читаете слово шириной 16 бит, возможно, вам придется поменять порядок байтов, если такое требование есть у устройства.
   
• Некоторые способы доступа работают лучше на некоторых устройствах. Например, на одном из нами проверенных устройств неправильно работала функция mraa_i2c_read(), и потребовалось использовать mraa_i2c_read_byte_data(). Поэтому, при разработке могут потребоваться дополнительные эксперименты.

6. Использование MRAA с Universal Asynchronous Receivers/Transmitters (UART)

• Устройство на основе UART это, по существу, обычное устройство с последовательным портом. Как те устройства, которые мы подключали к COM-порту в прошлом. Обычно это дуплексное соединение (full duplex), которое работает на определенной скорости, измеряемой в бодах. Стандартная скорость для многих сенсоров 9600 бод (или 9600 бит в секунду).
   
• Фактически у вас есть два провода. TX для передачи и RX для приема. Надо учитывать, что в случае большинства сенсоров, вы будете использовать другие уровни напряжения, чем те, которые используются на традиционном COM порту, который совместим со стандартом RS232. Обычно эти напряжения 5 В или 3.3 В, тогда как RS232 COM порт использует -15В…15В. Не присоединяйте такое устройство с низким напряжением непосредственно к COM-порту, если оно специально не поддерживается производителем сенсора. Так как вы можете испортить ваше устройство.
   
• MRAA предлагает механизм, когда два пина D0 и D1 (Intel Galileo и Intel Edison) могут реализовывать аппаратный UART, позволяющий программе просто читать и писать данные на устройство с UART доступом. Когда MRAA настроен на правильные пины, вы можете общаться с устройством через /dev/ttyX, используя стандартные функции read() и write() из ОС Linux. Учтите, что MRAA только настраивает правильный роутинг пинов для подключения UART, и ваша программа сама должна открыть и правильно настроить TTY устройство и начать работать с ним.
   
• Заголовочный файл для использования UART:

#include <mraa/uart.h>

6.1 Пример использования UART

int setupTTY(int fd, speed_t baud)
{
  if (fd < 0)
	return 0;

  struct termios termio;

  /* get current modes */
  tcgetattr(fd, &termio);

 /* setup for a 'raw' mode.  8bit, 1 stop bit, no parity, */
 /* no echo or special character handling, */
 /* no flow control or line editing semantics. */

  cfmakeraw(&termio);

  // set our baud rates
  cfsetispeed(&termio, baud);
  cfsetospeed(&termio, baud);

  // make it so
  if (tcsetattr(fd, TCSAFLUSH, &termio) < 0)
	{
	  fprintf(stderr, “%sn”, “tcsetattr failed”);
	  return 0;
	}

  return 1;
}

/* now our main function */
int main()
{
	/* initialize MRAA */
	mraa_init();

	/* create an MRAA UART context */
	mraa_uart_context m_uart;

	/* initialize UART 0 (pins D0 and D1 used for TX and RX) */
	m_uart = mraa_uart_init(0);

	/* now that we have our context, query MRAA */
	/* to get the file name of the TTY device we need to open. */

	char *devPath = mraa_uart_get_dev_path(m_uart);

	/* if this fails, we can go no further */
	if (!devPath)
	{
		fprintf(stderr, “%sn”, “Could not get device path”);
		return 0;
	}

	/* now that we have a device path, open it and set it up */
	int fd;
	if ((fd = open(devPath, O_RDWR)) == -1)
	{
		fprintf(stderr, “%sn”, “Could not open device path”);
		return 0;
	}

	/* now we are almost ready, call setupTTY() and from then on */
	/* we can read/write to the device normally. */
	/* We assume a baud rate of 9600/ */
if (!setupTTY(fd, B9600))
	{
		fprintf(stderr, “%sn”, “Could not setup TTY port”);
		return 0;
	}

	/* now we can use standard read and write calls */
	/* read(fd, ...) or write(fd, …) */

	/* when we are done, close the device and exit */
	close(fd);

	return(0);
}

Посмотрите предыдущий пример:
 

• Используя UART-устройство, важно правильно настроить пины, запросить у MRAA путь к устройству, открыть и инициализировать устройство и затем использовать стандартные Unix функции, такие как read() и write().
   
• Функции read() и write() блокируются, если нечего читать. Для того, чтобы исключить такое поведение, в большинстве случаев можно создать функцию, которая проверяет если ли доступные для чтения данные. Этого можно сделать с использованием системного вызова select(). Посмотрите драйвер UPM wt5001 для примера. Эта возможность реализована в функции dataAvailable().
   
• В нашем примере мы предполагали, что скорость 9600 бод. Константа B9600 определена в заголовочном файле Linux’а. Конечно доступны и другие скорости. Вам надо выбрать правильную скорость в зависимости от устройства, которое вы используете.
   
• Функция setupTTY(), используемая в примере, предполагает обычные установки. Если у вас будет устройство с другими требованиями, то возможно вам придётся её изменить.

7. Заключение

Intel Edison способен стать мозгом любого устройства из армии интернета вещей. Мозг умеет обрабатывать информацию, но для того, чтобы её получать, ему нужны органы чувств. Например, как Edison может узнать, жарко или холодно сейчас в помещении? Ответ прост – с помощью температурного сенсора.

Из этого материала вы узнаете о том, как использовать профиль общих атрибутов (Generic Attribute Profile, GATT) при организации взаимодействия Intel Edison с Texas Instruments SensorTag по протоколу Bluetooth Low Energy.

Перед тем, как мы начнём

Для того чтобы вы смогли воспользоваться этим руководством на практике, вам понадобится собранная плата Intel Edison, прошивка которой обновлена до самой свежей версии. Между платой и компьютером должно быть установлено соединение, эмулирующее подключение по последовательному (serial) порту, кроме того, устройство должно иметь доступ в Интернет по Wi-Fi. Если вам, для подготовки платы, нужна помощь, обратитесь к руководствам по началу работы с Intel Edison.
 

Установка Gatttool

Texas Instruments SensorTag, как и многие другие Bluetooth-устройства, поддерживает GATT для связи с компьютерами, смартфонами, планшетами. Gatttool – это стандартный набор программных инструментов, который входит в состав пакета BlueZ. Он, однако, по умолчанию на Intel Edison не установлен. Для того чтобы это исправить, нужно подключиться к Intel Edison через эмулятор терминала, после чего – загрузить и скомпилировать BlueZ с использованием следующих команд:
 

root@edison: cd ~
root@edison: wget
https://www.kernel.org/pub/linux/bluetooth/bluez-5.24.tar.xz –no-check-certificate
root@edison: tar -xf bluez-5.24.tar.xz
root@edison: cd bluez-5.24
root@edison: ./configure --disable-systemd –disable-udev
root@edison: make
root@edison: make install

Для того чтобы gatttool можно было запускать отовсюду, модифицируем переменную PATH:
 

root@edison: export PATH=$PATH:~/bluez-5.24/attrib/

Сканирование эфира и обнаружение BLE-устройств с помощью bluetoothctl

1. Включим Bluetooth на Intel Edison.
 

root@edison: rfkill unblock bluetooth

2. Запустим bluetoothctl
 

root@edison: bluetoothctl

3. Зарегистрируем агента и установим его в состояние по умолчанию.
 

[bluetooth]# agent KeyboardDisplay[bluetooth]# default-agent[bluetooth]# scan on

4. Если SensorTag найти не получается, нажмём на нём кнопку сопряжения с другими устройствами. После того, как удалось выяснить MAC-адрес SensorTag, режим сканирования можно выключить и выйти из сеанса работы с bluetoothctl.
 

[bluetooth]# scan off[bluetooth]# quit

Выделенный MAC-адрес SensorTag, обнаруженный в ходе поиска Bluetooth-устройств.

Использование gatttool для чтения показаний датчика

Теперь мы можем воспользоваться gatttool для того, чтобы прочесть показания датчика с SensorTag.

1. Запустим gatttool в интерактивном режиме, используя MAC-адрес, выясненный на предыдущем шаге.
 

root@edison: gatttool -b 34:B1:F7:D5:15:38–I

2. Подключимся к устройству и включим температурный датчик, записав 01 в идентификатор настроек (configure handle) 0x29. После этого прочтём показатели температуры из идентификатора 0x25.
 

[34:B1:F7:D5:15:38][LE]> connect
[34:B1:F7:D5:15:38][LE]> char-write-cmd 0x29 01
[34:B1:F7:D5:15:38][LE]> char-read-hnd 0x25

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

Показания с температурного датчика, полученные с SensorTag

оказания температурного датчика выглядят как два 16-битных числа без знака. Для того чтобы преобразовать эти данные к привычному виду, их надо обработать с помощью скрипта, который реализует алгоритм конверсии, описанный в базе знаний по SensorTag.
 

Использование Python для интерпретации показаний датчика

1. Для того чтобы интерпретировать показания датчиков, можно воспользоваться скриптом, написанным на языке программирования Python и использующим модуль pexpect. В качестве примера возьмём этот скрипти применим его для чтения температурных показаний с SensorTag.
 

root@edison: wget https://github.com/msaunby/ble-sensor-
pi/archive/master.zip -–no-check-certificate
root@edison: unzip master.zip
root@edison: cd /ble-sensor-pi-master/sensortag

2. Откроем скрипт sensortag_test.py с помощью vi.
 

root@edison: vi ./sensortag_test.py

3. Внесём изменения в строку 62. А именно, этот код:
 

tool.expect('\[CON\].*>')

заменим на этот:
 

tool.expect('Connection successful')

4. После внесения правок сохраним их и выйдем, нажав Escape и введя следующую команду:
 

:wq

Установка pip и необходимых модулей Python

Для запуска Python-скрипта с использованием pexpect, последний нужно установить. Легче всего это сделать с помощью Pip. Pip не установлен на Intel Edison по умолчанию, его нет в официальном репозитории opkg. Однако Pip можно найти в неофициальном репозитории Intel Edison, который собрал Michael Hirsch. Следующие инструкции составлены на основе его руководствапо использованию неофициального репозитория.

1. Отредактируем файл base-feeds.conf с помощью vi.
 

root@edison: vi /etc/opkg/base-feeds.conf

2. Введём следующее:
 

src/gz all http://repo.opkg.net/edison/repo/all
src/gz edison http://repo.opkg.net/edison/repo/edison
src/gz core2-32 http://repo.opkg.net/edison/repo/core2-32<source>3. Нажмём Escape и введем:

<source>:wq

4. Обновим opkg и установим Python.
 

root@edison: opkg updateroot@edison: opkg install python-pip

Установим средства настройки (setup tools) Pip:
 

root@edison: wgethttps://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py
-–no-check-certificate -O - | python>

Запуск Python-скрипта и чтение показаний температуры

Теперь всё готово для того, чтобы запустить скрипт, который читает показания температурного датчика. Для этого нужно перейти в директорию /ble-sensor-pi-master/sensortag и выполнить следующую команду:
 

root@edison: ./sensortag_test.py 34:B1:F7:D5:15:38

Intel Edison это новый удивительный одноплатный компьютер. С двухъядерным процессором, портами ввода-вывода и другими внешними интерфейсами, плата Intel Edison имеет большой потенциал для Physical computing (Physical computing — физические вычисления. Соединение аппаратного и программного обеспечения в устройстве, позволяющее ему получать аналоговую информацию из окружающего мира и реагировать на неё). Вот почему мы добавили полную поддержку для платы Intel Edison в Cylon.js, наш JavaScript-фреймворк для приложений, разрабатываемых для роботов и Интернета вещей (IoT).
Эта статья расскажет новичкам с чего начать и как получить доступ к полному набору всех возможностей. Мы покажем вам, как использовать Cylon.js почти для всех устройств, которые входит в набор Intel IoT Developer Kit. Заметьте, мы сказали «почти для всех», мы не стали рассматривать реле, т.к. это может быть небезопасно. А использование устройств, работающих от переменного напряжения с платой Intel Edison, это вообще тема отдельной статьи.

Плата Intel Edison, к которой присоединено почти всё, что есть в наборе:

Используя Cylon.js мы соединим все устройства из набора, чтобы создать одно интегрированное решение — умную входную дверь. Дверная система будет включать в себя освещение, пищалку, LCD экран, звуковой и световой датчики и свой собственный API. Это будет законченное IoT-решение, хотя и небольшого размера.

Используйте внешний источник питания, который обеспечивает достаточный ток для питания одновременно всех устройств, подключенных к плате Intel Edison. Подойдет любой блок питания, с напряжением 7-15 В и током 1 А.
 

Часть 1. Свет

Используем светодиод. Мы начнем с включения освещения, используя светодиод из набора. Включение светодиода, это что-то типа программы «Hello, World» для IoT, которая служит хорошим стартом. Мы собираемся использовать плату-соединитель для светодиода. Вам потребуется выбрать один из цветных светодиодов и подключить его к маленькой Grove плате. Помните, что длинная ножка у светодиода это «+» (анод), и она должна быть подключена к «+» на плате Grove.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне редактирования Intel® XDK IoT Edition, сохраните его и выгрузите на плату.

Запустите программу и вы должны увидеть мигающий светодиод.

Часть 2. Выключатель света

Добавляем кнопку. Сейчас мы добавим кнопку, и пользователь сможет сам включать и выключать светодиод. В коде видно как Cylon.js может отвечать на действие из реального мира. Если вы когда-нибудь использовали jQuery, то вы знаете основную идиому событий, таких как «MouseOver». Cylon.js широко использует события, которые соответствуют действиям от аппаратных устройств. В нашем случае, драйвер кнопки поддерживает два события «push» и «release» («нажать» и «отпустить»). Мы соединим эти события со светодиодом таким образом, что он будет включаться и выключаться, когда кнопка будет нажата или отпущена.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу и помигайте светодиодом, нажимая кнопку.

Часть 3. Дисплей

Добавляем ЖК-экран. Сейчас мы собираемся подключить дисплей, который позволит нам видеть, что происходит на плате, пока мы добавляем новую функциональность в нашу системы. Это ЖК-дисплей с RGB-подсветкой фона. Он позволит нам одновременно показывать текст и менять цвет фоновой подсветки.

ЖК-экран из набора, это устройство, подключаемое по последовательной шине I2C. I2C-интерфейс это стандарт для многих типов высокоуровневых сенсоров и устройств. Нам надо подключить его к разъему «i2c» на Grove-шилде.

Сначала мы добавим код для ЖК-экрана. Затем мы добавим код для вывода сообщения при запуске нашей программы. В завершении мы добавим код для события button.on(“release”) и (“push”) для обновления экрана с текущим состоянием освещения.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу, понажимайте кнопку и посмотрите на сообщения на ЖК-экране.

Часть 4 — Web API

Мы собираемся добавить Cylon.js HTTP API, который позволит нам увидеть пользовательский веб-интерфейс и управлять системой с использованием REST. Cylon.js API имеет модульную структуру и реализован в виде нескольких плагинов. Поэтому вы можете подключать его различные части в зависимости от потребностей. Сейчас у нас есть плагины «http», «socketio», и «mqtt». Вскоре мы добавим ещё.

Плагин HTTP API также включает Robeaux (http://robeaux.io), который является простым, одностраничным веб-приложением, основанном на React. Это приложение показывает панель управления с текущим состоянием вашего робота и дает возможность менять его параметры.

В различных API-плагинах Cylon.js существует единый способ определить с каким роботом или устройством вы хотите работать. Этот способ задания пути как в файловой системе описан в форме спецификаций и называется Common Protocol for Programming Physical Input/Output или кратко «cppp.io».

Например, в нашем текущем проекте «Doorbot», путь к светодиоду будет «/api/robots/doorbot/devices/led». Используя шаблон «/api/robots/<robot name>/devices/<device name>» мы сможем использовать Cylon.js API чтобы разрешить другим программам управлять нашим устройством или посылать команды нашему роботу.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу и зайдите браузером по IP-адресу вашей платы, указав порт 3000 (это порт по умолчанию для Robeaux). Вы должны увидеть следующую страницу:

Нажмите «doorbot». Вы должны увидеть список устройств. Нажмите устройство «button». Будет показана информация по этой кнопке.

В блоке «Device Events» введите в поле ввода строку «push», затем нажмите кнопку «Listen». Теперь нажмите реальную подключенную кнопку. Благодаря событиям на стороне сервера, вы должны увидеть появившееся событие на веб-странице. Это отличный способ проверить, что ваше устройство подключено правильно.

Часть 5. Дверной звонок

Добавляем датчик касания и пищалку. Сейчас мы добавим пищалку и дадим посетителю возможность звонить в неё. С точки зрения Cylon.js датчик касания это просто разновидность кнопки. А пищалка действует подобно светодиоду, то есть может быть только включена и выключена.

Прикосновение к датчику касания включает событие touch.on(“push”). Мы включим пищалку и покажем сообщение на ЖК экране.

Подключите датчик касания и пищалку.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу, прикоснитесь к датчику касания и послушайте, что пищалка подает сигнал.

Часть 6. Открыватель двери

Добавляем датчик поворота (потенциометр) и сервомотор. Сейчас мы добавим возможность поворачивать сервомотор, управляя им при помощи потенциометра. Нечто подобное можно использовать для открывания замка или поворота камеры наблюдения. Но ради простоты мы просто собираемся использовать ещё пару деталей из набора.

Потенциометр это вид переменного резистора. Основываясь на том, как вы его поворачиваете, он выдает большее или меньшее напряжение, подобно ручке управления громкостью. Фактически, большинство регуляторов громкости это и есть потенциометры.

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

Подключите сервомотор и потенциометр:

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу, поверните ручку и посмотрите на сервомотор

Часть 7. Пожарная тревога

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

Датчик температуры использует библиотеку UMP, которая встроена в Cylon.js. UPM это библиотека Intel, которая поддерживает множество различных датчиков. Один из них это как раз наш датчик температуры «Grove — Temperature Sensor».

Подключите датчик температуры.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите код и проверьте показания температуры на экране.
 

Часть 8. Охранная сигнализация

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

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

Подключите звуковой датчик.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу, пошумите и посмотрите, что светодиод включится.

Часть 9. Охранная сигнализация (продолжение)

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

Датчик освещения из набора это ещё одно аналоговое устройство, поэтому его код аналогичен коду звукового сенсора.

Подключите датчик освещения.

Также код доступен по ссылке. Скопируйте или введите этот код в файл «main.js» в окне Intel® XDK IoT Edition, замените весь предыдущий код, сохраните и выгрузите его на плату.

Запустите программу, осветите датчик и посмотрите, что светодиод включится.

Заключение

В этой статье мы показали, как использовать Cylon.js с платой Intel Edison и подключить все детали из набора Intel® IoT Developer Kit, кроме реле. Также мы создали законченную, миниатюрную версию умной дверной системы.

Плата Intel Edison это очень мощное устройство при очень небольшом размере. И мы всего лишь посмотрели на верхушку её возможностей. Благодаря Cylon.js очень просто использовать эти возможности для создания умных устройств следующего поколения. А что вы придумаете сами?

Сейчас, в мире приходящим на смену эре мобильных телефонов, мы видим появление умных устройств соединенных с вещами, которые мы не могли и представить. Строится мир, названный «Интернет вещей», или кратко IoT (Internet of Things). Устройства IoT находятся всё ещё в младенческом состоянии, начиная с часов с шагомером и заканчивая автомобилем, который включается с телефона. Интересная особенность IoT-устройств заключается в том, что они могут быть оборудованы разнообразными дешёвыми сенсорами, которые могут считывать температуру, влажность, пульс и так далее. Таких сенсоров не было в вашем телефоне и компьютере, поэтому сейчас эти данные становится такими доступной первый раз за всё время.

А с платформой Intel Edison и процессором Intel Quark можно легко построить прототип устройства, которое собирает информацию с сенсоров, и в итоге создать инновационный продукт.

Другая инновация от Intel это технология Intel RealSense. С помощью камеры RealSense 3D и SDK, приложения могут выполнять распознавание жестов, анализ лиц, отделение фона, распознавание голоса, синтез голоса и многое другое. Это как будто у нас есть некий супер сенсор, который может получать много разных данных. Используя эту технологию вместе с платой Intel Edison, мы можем построить много креативных приложений, которые одновременно и полезные и интересные.

Необходимое оборудование:
 

• Модуль Intel Edison с Arduino-адаптером
• Набор Seeed Grove* – Starter Kit Plus — Intel IoT Edition
• Компьютер с процессором 4-го поколения (Haswell или старше) Intel Core
• Microsoft Windows 8.1 (64-bit)
• 8 Гб свободно места на диске
• Разъем USB 3.0
• Камера Intel RealSense 3D F200 (встроенная или внешняя)
• (Опционально) мини-компьютер Intel NUC (Next Unit Computing) с процессором Intel Core 4-го поколения

Программное обеспечение:
 

• Среда разработки Arduino IDE для Intel IoT
• Среда разработки Microsoft Visual Studio 2010-2013 с пакетом обновления SP1 или новее
• Intel RealSense SDK

Что такое Intel RealSense SDK?

Intel RealSense SDK предлагает анализ лица, отслеживание рук и пальцев, распознавание голоса, синтезирование голоса, отслеживание объектов для дополненной реальности, сегментацию фона, дополненную реальность и много другой функциональности за счет сочетания аппаратного обеспечения, программного обеспечения и 3D камеры. Текущая версия SDK поддерживает Microsoft .NET framework, Unity Pro 4.1.0 и выше, Processing 2.2.1 или выше и JDK 1.7.0_11 или выше. В нашем примере мы будем использовать .NET и C#.

Обычное приложение, которое может быть разработано с помощью RealSense, включает общение с эффектом присутствия, игры, естественное взаимодействие, интерактивный сюжет, и технологию Intel Capture and Share, но это всего лишь небольшая часть всех возможностей.
Больше информации по технологии Intel RealSense можно получить на сайте Intel в обзоре технологии.

И скачать бесплатный SDK.
 

Внимательный взгляд на аппаратную часть

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

Плата Intel Edison построена на базе двухядерного чипа Intel Atom SoC, изготовленного по технологии 22 нм и работающего на частоте 500 МГц. Она поддерживает 40 GPIO (входы-выходы общего назначения) и включает 1 Гб LPDDR3 ОЗУ, 4 Гб EMMC флеш-памяти, двухдиапазонный Wi-Fi, Bluetooth и всё это при небольшом размере.

Она работает под управление полного ядра Linux. И если вам надо достичь большей производительности, то вы можете писать на аппаратном уровне Linux.

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

Узнать больше по плате Intel Edison можно здесь.
 

Arduino-адаптер

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

Набор Grove Starter Kit Plus

Полное название набора «Grove Starter Kit Plus – Intel IoT Edition». Изначально он был разработан для платы Intel Galileo gen 2. К счастью, он полностью совместим и с платой Intel Edison через Arduino-адаптер.

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

Вот более подробное описаниенабора.

У компании Seeed Studios, которая создала набор «Grove Kit» есть много полезной документации. Я рекомендую скачать «Sketchbook Starter». Можете также добавить себе в закладки Wiki-страницу:

Камера Intel RealSense 3D F200

Камера Intel RealSense 3D бывает внешней или встроенной, и обе эти модификации созданы для игрового взаимодействия, развлечения, фотографии и создания контента. 3D камера это сложный сенсор, который фактически является частью IoT (не зря в его названии есть слово Sense). Для своей работы камера требует USB 3.0 и процессор Intel Core 4-го поколения (Haswell) и 8 Гб свободного места на диске.

Камера имеет цветной HD сенсор разрешением 1080p и сенсор глубины, который дает компьютеру 3D зрение и многостороннее восприятие. Вы также можете купить набор разработчика.

Мини ПК – Intel NUC на основе процессора Intel Core 4-го поколения

Миникомпьютер Intel NUC (Next Unit Computing) это опциональное устройство, которое может быть использовано как центральный управляющий блок для камеры RealSense 3D и модуля Intel Edison. Он может выполнять дополнительные функции, такие как получение и хранение данных из облака с их последующим анализом. Конечно, он не является необходимым для разработки, так как обычную камеру (не Intel RealSense 3D) можно подключить непосредственно к плате Intel Edison по USB кабелю. Тем не менее, если вы его используете, то информация, которую вы получаете с камеры, может быть обработана и послана на плату Intel Edison, чтобы воспроизвести сигнал, включить светодиоды, моторы и так далее. Информация, которая получена с сенсоров платой Intel Edison, может быть послана на мини ПК Intel NUC, чтобы, например, включить синтезирование голоса с использованием RealSense SDK.

Так как для работы RealSense камеры необходим USB 3.0, 8 Гб памяти и процессор Intel Core 4-го поколения, то выбор Intel NUC является наиболее простым решением. Дополнительным преимуществом является его пользовательский интерфейс, так как наличие HDMI порта позволяет использовать его как обычный компьютер. Если у вас нет компьютера с нужным программным обеспечением, то Intel NUC может быть доступной возможностью его иметь.

Больше информации о Intel NUC можно найти в его обзоре.

Установка программного обеспечения и подготовка к кодированию

Мы будем работать с двумя примерами:
 

1. Захват жестов с камеры Intel RealSense 3D для управления светодиодами на плате Intel Edison.
2. Использование данных полученных с температурного сенсора, подключенного к плате Intel Edison для включения синтеза голоса с использованием Intel RealSense SDK.

Среда разработки Arduino IDE для платформы Intel IoT

Вам надо скачать специальную версию Arduino IDE, чтобы загружать скетчи на вашу плату. Текущая версия 1.6.0 доступна по ссылке.
 

Драйверы для платы Intel Edison

Еще надо скачатьи установить драйверы для платы Intel Edison. Это должна быть последняя ссылка на странице под заголовком «Driver Software» (текущая версия 1.2.1). Для дополнительных инструкций используйте руководство «Getting Started Guide»:
 

Visual Studio

Visual Studio это замечательная коллекция инструментов и сервисов для разработчика, которые помогают создавать приложения для многих платформ. Минимально для работы Intel RealSense SDK нужен Visual Studio и Windows 8.1. Visual Studio поддерживает C, C++, VB.NET, C#, F#, M, Python*, Ruby, JavaScript* и многие другие языки. Мы будем использовать С#.

Вы можете бесплатно скачать Visual Studio Express Edition или Visual Studio Community. Коммерческая версия Visual Studio может быть получена бесплатно по программе DreamSparkдля студентов и BizSparkдля стартапов.

Вы можете найти больше информации про Visual Studio по ссылке. А по C# тут.
 

Intel RealSense SDK

Intel RealSense SDK позволяет разработчикам использовать возможности 3D с ранее описанной функциональностью. Текущая версия 4.0.0.112526 (или Gold R2 release) доступна по ссылке.
 

Тестирование платы Intel Edison

Перед тем, как приступить к тому, что описано ниже, давайте убедимся, что мы сможем запустить пример скетча Blink. Он находится в скачанном Arduino IDE, в папке examples -> 01.Basics -> Blink.
 

Установка Visual Studio и Intel RealSense SDK

Установка Visual Studio должна быть достаточно проста. А вот для установки Intel RealSense SDK потребуется подключенная 3D-камера к USB 3.0. Если у вас всё правильно установилось, то вы увидите примеры в Intel RealSense SDK Sample Browser на вашем рабочем столе, в котором вы сможете посмотреть примеры на C++ и C#. Также доступны примеры с камерой. Мы будем использовать пример «Hand Viewer».
После установки SDK, должен быть загружен «F200 Depth Camera Manager». Он находится здесь. При отсутствии менеджера камеры, примеры программы не будут правильно инициализироваться.

Пример 1. Посылка сигналов с камеры RealSense 3D на плату Intel Edison

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

Код для платы Intel Edison

Сначала мы создадим конечную часть программы. Мы присоединим набор Grove к Arduino-адаптеру, возьмем светодиод (LED socket kit v1.3) и присоединим его к разъёму D2.

Соедините USB-кабелем плату Intel Edison с компьютером или мини-КП Intel NUC. Используйте диспетчер устройств Windows Device Manager, чтобы найти какой последовательный порт использует плата Intel Edison. На следующей картинке вы можете видеть, что в нашем случае это «COM16». Windows автоматически определит плату и назначит порт, когда мы подключим плату к компьютеру.

В среде разработке Arduino IDE, в меню Tools->Board мы выберем плату «Intel Edison».

А в Tools -> Port выберем «COM16».

И, наконец, немного попрограммируем. Так как наша плата используется как устройство вывода, то следующие несколько строк кода будут работать с последовательным портом, где 1 – включает светодиод, а 0 – выключает.
 

constint ledPin = 2;     // the number of the pushbutton pin

const int ledPin = 2;     // the number of the pushbutton pin
void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  if (Serial.available()>0)
  /* read the most recent byte */
  {
    int tmp = Serial.parseInt();
    if(tmp == 0)
    {
      // turn LED off:
      digitalWrite(ledPin, LOW);
    }
    else if (tmp == 1)
    {
        // turn LED on:
        digitalWrite(ledPin, HIGH);
    }
  }
}

На этом мы закончили с примером кода для платы Intel Edison.

Код приложения для Intel RealSense

В примерах C# F200, есть приложение «Hand Viewer». Выберете исходный код справа и откройте папку RSSDK/FF_HandsViewer.cs. Скопируйте всю папку на рабочий стол, чтобы можно было вносить изменения в проект.

В качестве специального жеста мы будем использовать растопыренные пальцы (spreadfingers). Если захотите, вы всегда сможете переключиться на другой жест.

В файле MainForm.cs измените и добавьте следующий код. Программа относительно простая, мы просто объявляем последовательный порт и отслеживаем последний жест. Если жест изменился, то мы изменяем флаг для светодиода. В функции UpdateInfo находится пример кода, обновляющего жест пользователя. Мы можем использовать переменную status, чтобы отслеживать, когда появится жест “spreadfingers”. Когда это происходит, мы передаем на последовательный порт 1 и включаем светодиод. Когда жест закончится, мы пошлем 0, чтобы выключить светодиод.

using System.IO.Ports;
…
public partial class MainForm : Form
{
	private SerialPort _serialPort;
private int _lastGesture;
	…
public MainForm(PXCMSession session)
{
	…
	_serialPort = new SerialPort();
_serialPort.PortName = "COM16"; //Serial port Edison is connected to
            _serialPort.BaudRate = 9600;
            _serialPort.ReadTimeout = 500;
            _serialPort.WriteTimeout = 500;
}

private void WriteToSerialPort(int value)
{
            if (_lastGesture != write)
            {
                Console.WriteLine(write.ToString());
                _serialPort.Write(write.ToString());
            }
            _lastGesture = write;
}

public void UpdateInfo(string status,Color color)
{
…

            if (status.Contains("spreadfingers") || status.Contains("spreadfingers"))
            {
                WriteToSerialPort(1);
            }
            else
            {
                WriteToSerialPort(0);
            }
 }

        private void Start_Click(object sender, EventArgs e)
        {
            …
            _serialPort.Open();
        }

       private void Stop_Click(object sender, EventArgs e)
        {
            …
            _serialPort.Close();
        }

Если всё работает правильно, нажмите кнопку запуска и поместите ладонь перед камерой. Когда пальцы будут раскрыты, светодиод должен загореться.

Пример 2. Чтение данных с платы Intel Edison и использование Intel RealSense для вывода

В этом примере мы используем датчик температуры, присоединённый к плате Intel Edison для ввода данных, и синтез голоса из Intel RealSense, чтобы данные сенсора было легче воспринимать.
 

Код для платы Intel Edison

Температурный датчик Temperature sensor v1.1 из набора Grove это аналоговый датчик, который мы можем подключить к разъему A0 на плате. Следующий Arduino код считывает температуру в градусах Цельсия. В программе есть задержка на 15 секунд, поэтому у модуля воспроизведения голоса есть время произнести весь необходимый текст. Вы можете изменить длительность этой задержки, если вам надо. Вы можете написать дополнительную логику, чтобы выводить предупреждения, если температура слишком высокая или слишком низкая.

#include <math.h>
int a;
float temperature;
int B=3975;                  //B value of the thermistor
float resistance;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  a=analogRead(0);
  resistance=(float)(1023-a)*10000/a; //get the resistance of the sensor;
  temperature=1/(log(resistance/10000)/B+1/298.15)-273.15;//convert to temperature via datasheet ;
  Serial.print("Current temperature is ");
  Serial.print(temperature);
  Serial.println(" celcius");

  delay(15000);
}

Приложение Intel RealSense

В блоке «Common Samples» вы увидите пример синтезирования голоса «Speech Synthesis». Скопируйте папку с исходниками, так же как мы сделали в предыдущем примере «Hand Viewer». Интерфейс не поменяется, но теперь наша цель использовать синтезирование голоса, чтобы проговорить данные сенсора. И мы всё еще используем «COM16».
Измените файл MainForm.cs следующим образом.

using System.IO.Ports;
…
public partial class MainForm : Form
{
        private SerialPort _serialPort;
        private static bool _continue;
        protected static string curr_module_name;
        protected static uint curr_language;
        protected static int curr_volume;
        protected static int curr_pitch;
        protected static int curr_speech_rate;

        Thread readThread = new Thread(Read);

        static public void Read()
        {
            while (_continue)
            {
                try
                {
                    string message = _serialPort.ReadLine();
                    Console.WriteLine(message);
                    VoiceSynthesis.Speak(curr_module_name, (int)curr_language, message, curr_volume, curr_pitch, curr_speech_rate);
                }
                catch (TimeoutException) { }
            }
        }

        public MainForm(PXCMSession session)
        {
            …
            _serialPort = new SerialPort();
            _serialPort.PortName = "COM16"; //Serial port Edison is connected to
            _serialPort.BaudRate = 9600;
            _serialPort.ReadTimeout = 500;
            _serialPort.WriteTimeout = 500;

            _serialPort.Open();
            _continue = true;
            readThread.Start();
        }
        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            _continue = false;
            readThread.Join();
            _serialPort.Close();
        }
        …
}

Если всё работает правильно, программа будет проговаривать данные с температурного сенсора каждые 15 секунд. Не бойтесь изменять программу в соответствии с вашими требованиями, например, изменяя интерфейс. Или можете просто скопировать файлы VoiceSynthesis.cs и VoiceOut.cs в свой проект.
 

Идём дальше

Я надеюсь, что это два примера помогут разработчикам и новичкам расширить их кругозор и получить больше идей для использования этих двух технологий. Один прототип, который я придумал это AntiSnoozer (АнтиДрёма). В нем камера Intel RealSense 3D определяет, когда водитель становится сонными и посылает команду на плату Intel Edison, чтобы воспроизвести дополнительные сигналы, которые разбудят водителя. Возможны тысячи комбинаций использования мощи этих двух технологий. Итак, что вы сделаете?

Взаимосвязанные физические устройства представляют совершенно новые возможности бизнесу и частным лицам, чтобы они получили больше контроля над своим окружением. Сейчас мы можем удаленно управлять своими домами, транспортными средствами и рабочими пространствами с помощью всего лишь наладонного смартфона. С этим большим уровнем связности стало возможным собирать огромное количества данных с этих устройств, а точнее информацию, которые дают встроенные в них сенсоры. Эти сенсоры, такие как датчики температуры, ускорения и положения могут выдавать непрерывный поток данных, но эти данные имеют ограниченное применение без хороших методов их анализа. Эта статья описывает панель управления с сайта Intel Internet of Things (IoT) Analytics enableiot.comи показывает, как вы можете использовать этот сайт, чтобы агрегировать, организовывать и облегчать крупномасштабный анализ данных, полученных от географически распределенных датчиков.

Введение

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

Одно растущее направление в IoT разработке, это сбор и анализ данных с географически распределенных сенсоров. Рассмотрим, например, множество температурных датчиков встроенных в дорогу. Все эти датчики подключены проводным или беспроводным способом к точке сбора информации, где потоки данных собираются, предобрабатываются и агрегируются. Этот единый поток информации передается человеку, ответственному за дорогу, который решает, куда послать уборочные машины, когда чинить дорогу, перекрыть её или сделать временный объезд. А если рассмотреть эти данные вместе с данными собранными за предыдущие года, то можно создать модель предсказания, которая показывает, как будет изменяться температура дороги в результате локальных условий. Возможно, некий мост имеет большую тенденцию к обледенению, чем другие, и предупреждение об этом позволит сделать ремонт, уменьшающий риск несчастного случая на мосту.

Платы Intel Galileo и Edison были разработаны и построены для того, что предоставить данные с сенсоров для широкой публики. Большое разнообразие датчиков может передавать информацию на объединяющую IoT плату, где данные временно собираются и предобрабатываются перед тем, как будут отправлены на дополнительный анализ. Компания Интел создала сайт Internet of Things Analytics (IoT Analytics) для связи сенсоров, которые подключаются к Intel Galileo и Edison. Сайт может агрегировать большbе временные серии данных для последующего анализа.
 

Типы датчиков и приложений

Сегодня большое разнообразие маленьких и недорогих, но мощных датчиков можно присоединить практически к любому устройству (см. Таблицу 1). Эти сенсоры передают данные с заданной частотой (например, раз в секунду) и некоторой точностью. Результатом этой генерации данных является серия равномерных по времени точек со значениями для каждой из них. Рассмотрим, например, чип RFID встроенный в бэйджик шахтёра. Чип передает непрерывный поток данных о времени и положении рабочего, позволяя управляющему по безопасности точно знать, где находится рабочий в каждый момент времени. Такая информация имеет решающее значение при возникновении аварии, когда быстрое реагирование может спасти жизни.

Типы датчиков и примеры

Сенсоры могут быть спроектированы для передачи своих измерений через различные физические соединения. Это может быть последовательный интерфейс, как RS232 или беспроводной, как Bluetooth. Необходимо, чтобы сенсор был спроектирован для физической среды — температуры, удара, давления и так далее. И надо, чтобы соединение было достаточно безопасным.
 

Сбор и передача данных

Данные с сенсоров имеют небольшую ценность, если они не собираются и не передаются в место, где просматриваются и анализируются. Для этой цели и предназначены платы Intel Galileo, Intel Edison и сайт IoT Analytics. Эти платы для разработки могут быть подключены (через Arduino-адаптер или через Bluetooth) к различным входным сигналам, число которых ограничено только количеством физических портов. Несколько плат могут быть соединены вместе для объединения данных с распределенной сети датчиков.

Поток данных с сенсора может быть направлен сразу на сайт IoT Analytics или предварительно обработан на плате, чтобы удалить ошибки или пробелы в измерениях, и уже потом передан дальше на сайт IoT Analytics. Для получения большей информации посмотрите статью «Intel Edison Development Board Summary». Ссылка в конце этой статьи.

Обработка и хранение

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

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

Качество временных серий

Как было сказано ранее, все данные сенсоров состоят из набора измерений, полученных в определенный момент времени. Эти временные ряды имеют некоторые свойства, которые делают анализ этих данных уникальным по сравнению с другими типами анализа, такими как финансовый или маркетинговый:
 

• Одинаковый интервал сбора. Значения собираются в определённые, регулярные промежутки времени, такие как секунды, минуты, дни.
   
• Последовательность значений (измерений). Значения собираются последовательным способом, одно за другим, число измерений в определённом наборе временных рядов определяет «размерность» потока данных.
   
• Верность (точность). Данные сенсора выдаются с определённой точностью (так называемая инструментальная ошибка). Обратите внимание, что точность анализируемых значений не может превышать точность исходного измерения, например, если измеренное значение составляет 0,35, то анализируемые значения не могут иметь более двух знаков после запятой.
   
• Диапазон (амплитуда). Значения датчиков будут находиться в ожидаемом диапазоне, который определяется ограничениями самого физического сенсора (например, для температурного датчика значение может быть от -30 до 50 градусов).

Каждый элемент временной серии данных состоит из пары время-значение, например, (t)ime = 0.55 sec и (v)alue = 40.5º C. Если периодичность потока данных с сенсора составляет 0.05 с, то следующее измерение будет при t = 0.60 с, затем при t = 0.65 с и так далее. Этот набор может быть показан на двумерном графике, со временем по оси x, и значениям по оси y. Вот пример графика с сайта IoT Analytics.

Как вы можете видеть на рисунке, сайт IoT Analytics может нарисовать серию временных данных в различных форматах, включая объединение по временному периоду (минута, час, день, неделя, месяц, год), как линию или область графика, с возможностью масштабирования определенных наборов для более детального просмотра исходных данных.

Анализ и моделирование

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

Исходные сырые данные имеют ограниченное использование, например, только визуальный просмотр, без дальнейшего анализа или моделирования. Хотя, возможно установить предупреждения при превышении максимального значения (основанном, скажем, на правиле изменения одной сигмы), но более сложный подход анализирует данные на предмет предсказаний. Представьте, что на предыдущем рисунке автомобильный датчик выхлопа CO2 сообщает об измеренных уровнях определённой частотой выходного сигнала. Если это часть большого набора данных, собранного от разных датчиков (таких как температура двигателя и расход топлива), то можно поискать закономерности, сравнивая изменения на одном графике с другим, чтобы предсказать предстоящее техническое обслуживание автомобиля.

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

Модель предсказания, которая основана на нормальном поведении системы, обычно нужна, чтобы обнаружить аномальное поведение. Есть несколько способов для создания такой модели: использование известного измеренного состояния (под контролем), применяя математические или инженерные предсказания ожидаемого поведения системы (полуконтроль) или просто сравнивая точки данных сенсора с ими самими, но в другие моменты времени (без контроля). В конечном случае, выбранный временной период сравнивается с другим, возможно используя скользящее окно, для проверки неожидаемых значений (см. «Дополнительная информация»).

Для создания этих моделей, вы применяете алгоритм или подход к потокам данных, собранных с сенсора. Общие методы включают преобразование Фурье (преобразование значений временных рядов к частоте появления), динамическое изменение времени (выравнивание временных рядов независимо от времени измерения), вейвлет преобразование (сегментирование данных временных рядов в более мелкие сегменты). Относительно новый метод, называемый Symbolic ApproXimation (SAX), использует современный метод преобразования данных временных рядов в определённый символический набор, такой как буквы алфавита, который позволяет использовать различные алгоритмы поиска по шаблону, включая те, которые разработаны для биологического анализа ДНК, РНК и белка (например, в биоинформатике).

После того, как вы выбрали аналитический подход, следующее решение состоит в том, как обнаружить аномалии. Традиционно это достигается либо определением выбросов (статистическое обнаружение) или вычислением разности между номинальной кривой данных и измеренной серией. Это известно как мера расстояния и часто вычисляется, используя Евклидово расстояние или квадрат разности между последовательными точками данных. Совокупность этих значений дает качественный индикатор разности между двумя кривыми. Если номинальный и измеренный временной ряд отличается больше чем на данное значение, то временной ряд помечается для дальнейшего исследования. Кроме того, алгоритм поиска по образцу разработан для исследования в биоинформатике и может быть использован для количественного сравнения двух и более временных рядов.
 

Представление

В заключительном разделе этой статьи обсуждается способы уведомления заинтересованных сторон, когда будет обнаружена аномалия в записанном временном ряде. Сайт IoT Analytics предлагает простой, но мощный механизм для оповещения, основанного на наборе правил. Как видно на картинке, вы можете определить группу определённых правил для датчика связанного с коллекцией устройств. Условия для выполнения правил могут быть определены для нескольких распространенных ситуаций:
 

• Простое условие. Значение с сенсора становится выше или ниже заданной границы.
• Временное условие. Значение сенсора становится выше или ниже заданной границы в течение заданного периода времени.
• Условие на дисперсию. Дисперсия значения (сигма) превышает 2 или 3.
• Определение изменения датчика (одиночное или множественное). Один или несколько датчиков определили изменение условий (например, как событие активации/деактивации).

Зарегистрированный пользователь может быть уведомлен о срабатывании правил по почте (используя адрес, заданный при создании аккаунта) или при помощи посылки HTTP сообщения на специальный адрес.

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

Заключение

Распространение недорогих, но чувствительных датчиков и повсеместное сетевая доступность создали основу для нового способа оценки и управления устройствами, которые окружают нас каждый день. Объединяя измерения от этих сенсоров и применяя набор простых правил анализа, можно действовать упреждающе в случае возможного отказа устройства или более быстро реагировать на изменение условий окружающей среды. Кроме того, используя центральный сайт агрегации, такой как Intel IoT Analytics, эти данные с сенсоров могут быть объектом более сложных методов анализа данных, которые позволят создать и использовать модели предсказания поведения.
 

Дополнительная информация

• Intel Edison Development Board Summary
• Intel Internet of Things (IoT) Analytics Installation Instructions
• Intel Internet of Things (IoT) Analytics Guide

Intel Edison – это самая маленькая в мире вычислительная платформа с самым низким энергопотреблением, которая была разработана для создания носимых устройств, таких, как те, из которых строится интернет вещей. Это – плата для разработки и прототипирования, сертифицированная Arduino. Программы на С++, которые можно писать для Intel Edison – это то же самое, что скетчи (sketch) в мире Arduino. Благодаря соответствующему окружению, Intel Edison способен взаимодействовать с различными датчиками. С их помощью можно в реальном времени измерять различные характеристики окружающей среды с высоким уровнем точности и стабильности. Intel Edison можно использовать для чтения и обработки данных самых разных датчиков, что позволяет строить на основе этой платы устройства, рассчитанные на работу в помещениях и на улице.

Сервис Twilio позволяет разработчикам программным путём получать SMS и MMS-сообщения на свои телефонные номера Twilio, и, соответственно, отправлять сообщения в ответ. Отправлять SMS и MMS-сообщения можно, используя REST API Twilio, можно организовывать SMS-переписку и отправлять SMS-сообщения в ходе телефонных звонков. Здесь мы рассмотрим отправку SMS-сообщений на обычный телефон с номеров Twilio.

Из этого материала вы узнаете о том, как считывать показания температурного датчика и отправлять SMS-сообщения на мобильный телефон, используя учётную запись Twilio.
 

Аппаратные компоненты

В этом проекте, посвященном работе с SMS-сообщениями, использованы следующие аппаратные компоненты:
 

• Вычислительный модуль Intel Edison
• Плата расширения Arduino
• Набор Grove – Starter Kit Plus
• Два Micro USB-кабеля для подключения платы к ПК
• Источник постоянного тока

Подробная инструкция, посвящённая сборке и обеспечению питанием платы Intel Edison, находится здесь.

Аппаратные компоненты в сборе

 

Загрузка программного обеспечения

Воспользуйтесь ресурсом Intel Edison Board Software Downloadsдля того, чтобы загрузить свежие драйверы, вспомогательные приложения, образы прошивок и IDE Arduino.
 

Загрузка и установка библиотеки Twilio

Загрузите библиотеку Twilio C++и распакуйте в папку с библиотеками Arduino IDE, которая обычно расположена по адресу C:\Arduino\arduino-1.5.3-Intel.1.0.4\libraries. Arduino не позволяет, чтобы в именах библиотек содержался символ «–», поэтому переименуйте twilio-cplusplus в Twilio.

Библиотека Twilio

Перейдите в папку Twilio и переименуйте файл Example.cpp в Example.cpp.org, в результате Example.cpp не будет вызываться каждый раз, когда мы пользуемся библиотекой Twilio. Внесите в файл Utils.h следующие изменения:

#include <string.h>
#include <vector>

using namespace std;

Доступ к разделу устройства USB Mass Storage с Intel Edison

Multifunction Composite Gadget (g_multi) – это составной гаджет, который интенсивно использует composite framework и реализует широкую функциональность. В частности, он предоставляет USB-конфигурацию с поддержкой USB Mass Storage, а так же – интерфейсов Ethernet (RNDIS и (или) CDC Ethernet) и последовательного порта (ACM).

Для того чтобы вручную загружать или выгружать модули ядра, мы используем команду modprobe. Мы удаляем модуль g_multi для того, чтобы отключить устройство USB Mass Storage на Intel Edison.

Использование команды modprobe, Edison

Создадим директорию для монтирования:

Создание директории для монтирования, Edison

Воспользуемся командой losetup для того, чтобы назначить соответствие метки раздела «update» устройству loopback (/dev/loop0) со смещением 8192. В примере, показанном ниже, устройство loopback монтируется как /mnt/transfer.

Монтирование устройства на Edison

Доступ к устройству USB Mass Storage с главного компьютера

Нажмите кнопку перезагрузки, устройство USB Mass Storage появится в Проводнике Windows.

Устройство USB Mass Storage

Размонтируем раздел и вернём модуль g_multi.

Размонтирование устройства

Установка Curl и криптографических библиотек

Обратитесь к разделу «Доступ к разделу устройства USB Mass Storage с Intel Edison» для того, чтобы скопировать libcurl с зависимостями из папки /usr/lib на Edison в корневую директорию установки Arduino IDE, в папку hardware\tools\edison\sysroots\core2-32-poky-linux\usr\lib:

• libcurl.so
• libtasn1.so.6
• libgcrypt.so.11
• libgnutls.so.26
• libgpg-error.so.0

Копирование Curl и других библиотек с Edison

Curl и другие библиотеки в Windows

Аналогично, воспользуйтесь рекомендациями раздела «Доступ к разделу устройства USB Mass Storage с Intel Edison» для того, чтобы скопировать нижеперечисленные библиотеки из папки /lib в Edison в корневую директорию установки Arduino IDE, в папку hardware\tools\edison\sysroots\core2-32-poky-linux\lib:

• libz.so.1
• libcap.so.2
• libcrypto.so

Копирование криптографических и других библиотек с Edison

Криптографические и другие библиотеки в Windows

Установка заголовочных файлов Curl

Заголовочные файлы Curl нужно поместить в корневую директорию установки Arduino IDE по адресу hardware\tools\edison\sysroots\core2-32-poky-linux\usr\include:

Заголовочные файлы Curl

Заголовочные файлы OpenSSL нужно поместить в корневую директорию установки Arduino IDE по адресу hardware\tools\edison\sysroots\core2-32-poky-linux\usr\include:

Заголовочные файлы OpenSSL

Модификация шаблонов компиляции

В папке установки Arduino IDE, по адресу hardware\arduino\edison, имеются файлы platform.*.txt. Отредактируйте тот файл, имя которого соответствует платформе, на которой выполняется сборка. Если вы работаете с Arduino IDE в Microsoft Windows, отредактируйте файл platform.win.txt.

Файл platform.win.txt для Windows

Для того чтобы сообщить компоновщику о том, что ему нужно добавить libcurl и libcrypto к списку библиотек при компоновке исполняемых файлов, добавьте –lcurl и –lcrypto в конец строки «recipe.c.combine.pattern». Эту строку не должны разрывать символы перевода строки.

Динамическая компоновка – файл platform.win.txt.

recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} -march={build.mcu} -o "{build.path}/{build.project_name}.elf" {object_files} "{build.path}/{archive_file}""-L{build.path}" -lm -lpthread -lcurl –lcrypto

Создание аккаунта Twilio

Для того чтобы принимать SMS и MMS-сообщения вам нужен телефонный номер Twilio, который поддерживает работу с SMS. Для того чтобы получить собственный выделенный номер, зарегистрируйте пробную учётную запись Twilio. Как только вы получите такой номер, перейдите в раздел Hide API Credentials на сайте Twilio и найдите там Account SID и Auth Token:

Телефонный номер из сервиса Twilio и данные для программного доступа к сервису

// Twilio REST API version
const char API_VERSION[] = "2010-04-01";

// SMS-enabled Twilio phone number
const char CALLER_ID[] = "1480405xxxx";

// Twilio Account SID and Auth token
const char ACCOUNT_SID[] = "AC9c55339a5a070ae81e782117xxxxxxxx";
const char ACCOUNT_TOKEN[] = "59e8819f3f5b530b97b84baexxxxxxxx";

Code Example 2: Twilio Phone Number, Account SID and Auth Token Example

POST-вызовы Twilio

Для того чтобы отправить SMS-сообщение, мы совершаем POST-запрос к Twilio, используя URL «/SMS/Messages». При этом нужно передать поля «To», «From» и «Body». «To» — это ваш телефонный номер, тот, на который должно прийти SMS. «From» — это телефонный номер Twilio, а «Body» — это текст SMS-сообщения.

Пример отправки SMS с помощью сервиса Twilio

    // URL path = /API_VERSION/Accounts/ACCOUNT_SID/SMS/Messages
    char postReqStr[150];
    strcpy(postReqStr, twilioAcc);
    strcat(postReqStr, "/SMS/Messages");
    Serial.println(postReqStr);

    // Send SMS
    vars.clear();
    vars.push_back(Var("To", "480-xxx-xxxx"));
    vars.push_back(Var("From", "480-405-xxxx"));
    vars.push_back(Var("Body", smsStr));
    string response = twilioRest.request(postReqStr, "POST", vars);

Code Example 3: Send “/SMS/Messages” Example

Датчик температуры

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

Работа с датчиком температуры

// Connect temperature sensor to Analog pin 1
const int tempSensorPin = 1;

// Temperatuere in Fahrenheit
float degF = 0;

// This function reads the analog pin value, converts to Fahrenheit, then
// returns current temperature in Fahrenheit.
float getTemperature()
{
    int analogValue = analogRead(tempSensorPin);

    //Get the resistance of the sensor;
    float resistance = (float)(1023 - analogValue) * 10000/analogValue;

    //Convert to temperature via datasheet;
    float degKelvin = 1/(log(resistance/10000)/B_THERMISTOR + 1/298.15);

    // Convert Kelvin to Celcius
    float degC = degKelvin - 273.15;

    // Celcius to Fahrenheit
    degF = (degC * 9.0) / 5.0 + 32.0;

    return degF;
}

Пример готовой программы

Вот пример готовой программы для отправки SMS-сообщения на обычный мобильный телефон в тех случаях, когда температура достигает заданного предела в 100 градусов по Фаренгейту. Отладочный вывод выполняется в эмулятор консоли Galileo в Arduino IDE.

Отправка SMS с помощью учётной записи Twilio при достижении температурой заданного порогового значения

#include "WString.h"
#include <Utils.h>
#include <Rest.h>
#include <TwiML.h>
#include <vector>
#include <math.h>

using namespace twilio;

vector<Var> vars;

// Версия Twilio REST API
const char API_VERSION[] = "2010-04-01";

// Телефонный номер Twilio с поддержкой SMS
const char CALLER_ID[] = "1480405xxxx";

// Account SID и Auth token для программного доступа к Twilio
const char ACCOUNT_SID[] = " AC9c55339a5a070ae81e782117xxxxxxxx ";
const char ACCOUNT_TOKEN[] = "59e8819f3f5b530b97b84baexxxxxxxx ";

// Ответ от Twilio
const char* responseStr;

// Порог температуры, в Фаренгейтах
const int THRESHOLD_TEMP = 100;
const int WAIT = 1000000;

// B-значение термистора
const int B_THERMISTOR = 3975;                  

int analogValue = 0;
float degKelvin = 0;
float degC = 0;
float degF = 0;
float resistance = 0;

// Датчик температуры подключён к аналоговому входу 1
const int tempSensorPin = 1;

// Эта функция инициализирует последовательный отладочный интерфейс
void setup() {
    Serial.begin(9600);  
}

// Эта функция делает следующее:
//     - Создаёт SMS-сообщение для отправки
//     - Использует URL-путь
//     - Отправляет SMS-сообщение на мобильный телефон с Twilio-номера
// Вход: float tempF – текущая температура в градусах Фаренгейта
void sendSMS( float tempF ) {
 
    // Конверсия tempF в строку
    char degFstr[20];
    sprintf(degFstr, "%2f", degF);
    
    // Конверсия THRESHOLD_TEMP в строку
    char thresholdStr[20];
    sprintf(thresholdStr, "%d", THRESHOLD_TEMP);
    
    // Создание SMS-сообщения
    char smsStr[100] = "Current temperature is ";
    strcat(smsStr, degFstr);
    strcat(smsStr, " F greater than threshold temp ");
    strcat(smsStr, thresholdStr);
    strcat(smsStr, " F.");
        
    // Twilio Account = /API_VERSION/Accounts/ACCOUNT_SID
    char twilioAcc[70] = "/";
    strcat(twilioAcc, API_VERSION);
    strcat(twilioAcc, "/Accounts/");
    strcat(twilioAcc, ACCOUNT_SID);
    
    // URL path = /API_VERSION/Accounts/ACCOUNT_SID//SMS/Messages
    char postReqStr[150];
    strcpy(postReqStr, twilioAcc);
    strcat(postReqStr, "/SMS/Messages");
    Serial.println(postReqStr);
   
    // Twilio REST
    Rest rest(ACCOUNT_SID, ACCOUNT_TOKEN);
    
    // Отправка SMS
    vars.clear();
    vars.push_back(Var("To", "480-xxx-xxxx"));
    vars.push_back(Var("From", "480-405-xxxx"));
    vars.push_back(Var("Body", smsStr));
    string response = twilioRest.request(postReqStr, "POST", vars);
}

// Эта функция считывает данные с аналогового входа, конвертирует их
// в градусы Фаренгейта и возвращает полученную текущую температуру.
float getTemperature()
{
    analogValue = analogRead(tempSensorPin);
 
    // Получим сопротивление сенсора;
    resistance = (float)(1023 - analogValue) * 10000/analogValue;
 
    // Сконвертируем температурные данные в соответствии с документацией
    degKelvin = 1/(log(resistance/10000)/B_THERMISTOR + 1/298.15);
 
    // Конверсия из градусов Кельвина в градусы Цельсия
    degC = degKelvin - 273.15;
 
    // Конверсия градусов Цельсия в градусы по Фаренгейту
    degF = (degC * 9.0) / 5.0 + 32.0;
        
    return degF;
}

// Главный цикл, в котором производится считывание текущей температуры с
// датчика. Если температура больше, чем заданное пороговое значение,
// выполняется отправка SMS-сообщения.
void loop() {
    degF = getTemperature();
    if(degF > THRESHOLD_TEMP)
    {
        sendSMS(degF);
        delay(WAIT);
    }
}

Итоги

В этом материале мы поэкспериментировали с датчиком температуры и отправкой SMS-сообщений с помощью сервиса Twilio. Схожим образом можно работать и с другими датчиками из комплекта Grove Starter Kit Plus – испытайте их, а если вам хочется большего – взгляните на эти датчики. Надеемся, наш рассказ вдохновит вас на интересные опыты с Intel Edison.
 

Полезные ссылки

software.intel.com/en-us/iot/hardware/edison/downloads
www-ssl.intel.com/content/www/us/en/do-it-yourself/edison.html
software.intel.com/en-us/iot/hardware/edison
software.intel.com/en-us/iot/library/edison-getting-started
software.intel.com/en-us/iot/hardware/devkit
www.seeedstudio.com/wiki/images/a/a1/NCP18WF104F03RC.pdf

Введение

Когда я впервые услышал о системе, которая способна определить частоту сердечных сокращений человека бесконтактным способом, я отнёсся к этому скептически, решил, что то, о чём шла речь, находится где-то между откровенным шарлатанством и магией Вуду. Много позже мне понадобилось больше узнать о технологиях, нужных для такого «волшебства». К моему удивлению, подобное оказалось не просто «возможным», но и уже существующим. Более того, это реализовано в последней версии Intel Real Sense SDK.

Я провёл следующий эксперимент. Для начала – нашёл и запустил подходящий пример из SDK и дождался появления результатов измерений. Тут же, в течение 15 секунд, посчитал собственный пульс на сонной артерии и умножил то, что получилось, на четыре. После того, как я сравнил то, что насчитал я, с тем, что выдала программа, я окончательно уверился в том, что это действительно работает! Эксперименты я продолжил: попрыгал немного для того, чтобы слегка «разогнать» сердце и снова позволил компьютеру посчитать пульс. Через несколько секунд он зафиксировал рост частоты сердечных сокращений. Тогда я был в таком восторге от открытия, был так взволнован перспективой использования компьютеров, которые знают, спокоен пользователь или возбуждён, что просто не смог дождаться, когда моё сердцебиение дойдёт до нормальных для меня 76 ударов в минуту и протестировать систему на предмет правильности определения понижения частоты пульса.

Почему это важно

Начав исследовать удивительный мир передовых технологий бесконтактного управления, 3D-сканирования и распознавания движений, вы, через некоторое время, зададитесь вопросом: «А что ещё можно сделать с помощью камеры Intel RealSense?». Когда же вы перейдёте от хорошо изученных, чётко определённых систем, вроде распознавания движений, к более тонким материям, вы попадёте в область, в которой компьютеры способны на невероятные доселе вещи.

Определение частоты пульса, вместе с другими функциями Intel RealSense SDK, это возможности, основанные на работе с едва уловимыми характеристиками физических объектов, которые однажды могут стать такими же важными в повседневной жизни, как мышь и клавиатура сегодня. Например, клавиатура и мышь не очень подходят тому, кто страдает от RSI-синдрома (Repetitive Stain Injury, хроническая травма от повторяющегося напряжения). А если человек расстроен, взволнован, хочет спать, или у него просто плохое настроение, то будь у него самые современные и удобные средства управления ПК, особого толку от них не добиться. Если же компьютеры смогут определять физическое, и, возможно, эмоциональное состояние людей, это позволит машинам помогать пользователям на совершенно новом уровне.

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

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

А вот ещё один пример, который напрямую не связан с определением частоты пульса. Представьте, что компьютер способен измерять температуру и сопоставлять её с данными об эффективности вашей работы. В ходе наблюдений оказывается, что когда вам жарко, скорость работы падает. Например – снижается скорость набора, вы чаще отвлекаетесь. Когда же температура снижается, это хорошо сказывается на производительности труда. Теперь представьте себе, что сведения с датчиков регулярно записываются. Однажды утром, а оно выдалось особенно жарким, машина показывает вам уведомление о том, что пару дней назад вам тоже было жарко, вы отошли на 20 секунд, а через две минуты стало прохладнее (и эффективность вашей работы вслед за этим в тот день выросла). Подобное уведомление может помочь вспомнить, что тогда вы открыли несколько окон или включили кондиционер в соседней комнате. Вспомнив, вы сделали то же самое, и, как результат, подобный совет, поступивший от компьютера, улучшил вашу жизнь. Позволяя компьютеру собирать данные подобного рода и экспериментируя с тем, как эти данные способны улучшить качество вашей собственной жизни, вы, в итоге, станете частью движения, которое приведет к инновациям, улучшающим качество жизни всего человечества.

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

Как это вообще возможно?

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

Для того чтобы обнаружить микродвижения головы, нужно нечто более точное, чем рулетка.

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

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

Еще один подход, который ближе к методике, используемой в Intel RealSense SDK, заключается в обнаружении изменения цвета в потоке видео реального времени. Изменения цвета используются для подсчёта частоты пульса. Частота кадров, необходимая для работы этого метода, не должна быть особенно высокой, камера не должна быть полностью неподвижной. Однако этот метод даёт наилучшие результаты только в идеальных условиях освещения. У данного подхода есть разновидности, каждая из них показывает разные уровни успешного определения частоты пульса. Сейчас мы кратко рассмотрим два варианта «цветовой» методики.

Знаете ли вы, что глаза могут рассказать о том, как быстро бьётся сердце?

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

Длительность процедуры может меняться в зависимости от времени, которое понадобится для того, чтобы получить подходящий материал для анализа. Кроме того, если при съёмке в кадрах окажется слишком много шума, их придётся отбросить и повторить процедуру. Но, даже если выполнять съёмку на умеренных 30 кадрах в секунду, для того, чтобы зафиксировать одно биение пульса, понадобится 20-30 кадров (это, если предположить, что частота сердцебиения испытуемого составляет 30 – 90 ударов в минуту).

Если вы столкнётесь с ситуацией, когда цветовой информации, полученной при съёмке глаз, недостаточно, а такое может произойти, например, если испытуемый находится довольно далеко от компьютера, или носит очки, или попросту медитирует, вам понадобится другой подход для подсчёта пульса. Один из вариантов анализа изменения цвета тканей тела заключается в использовании потока в инфракрасной части спектра (IR, InfraRed). Такой поток можно получить с камеры Intel RealSense. В отличие от потоков, предоставляющих сведения о цвете и глубине пространства, инфракрасный поток может поставлять данные для последующей обработки с частотой около 300 кадров в секунду. Это довольно высокая скорость. Как было отмечено выше, нам, для подсчёта пульса, достаточно получить хорошие материалы с частотой около 30 кадров в секунду. При обработке инфракрасного изображения, которое можно получить с камеры, используется особый подход.

Обратите внимание на то, что вены на запястье хорошо видны на инфракрасном видеопотоке.

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

Один из побочных эффектов, возникающих при захвате инфракрасных лучей, отражающихся от тела человека, заключается в том, что на полученном изображении можно обнаружить сосуды, расположенные близко к поверхности кожи. В ИК-диапазоне можно разглядеть и следы машинного масла на футболке, которая при обычном освещении выглядит идеально. Учитывая, что поток крови очень точно отражает то, что мы хотим измерить, вы можете решить, что рассматриваемый метод идеально подходит для определения частоты пульса. Если вы немного углубитесь в этот вопрос, то обнаружите, что ИК-сканирование человеческого тела действительно используется в медицинских исследованиях для изучения циркуляции крови по кровеносной системе. Однако делается это под строгим врачебным контролем. Минус использования ИК-лучей заключается в том, что мы, фактически, ограничиваем объём информации, получаемый с камеры, не используя данные о цвете из видимого спектра, которые можно извлечь из обычного цветного видеоканала.

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

Как Intel RealSense определяет частоту пульса

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

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

Для начала нам нужно создать PXC-сессию и указатель SenseManager. Так же нам понадобится указатель faceModule, так как мы будем пользоваться системой Face для того, чтобы подсчитывать частоту пульса. Полная версия этого кода лучше всего представлена в образце Face Tracking, его вы можете найти и скомпилировать. В нём, помимо кода, который показан здесь, есть и поддержка дополнительных возможностей – таких, как определение позы.

PXCSession* session = PXCSession_Create();
PXCSenseManager* senseManager = session->CreateSenseManager();
senseManager->EnableFace();
PXCFaceModule* faceModule = senseManager->QueryFace();

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

PXCFaceConfiguration* config=faceModule->CreateActiveConfiguration();
config->QueryPulse()->Enable();
config->ApplyChanges();

Объект ActiveConfiguration включает в себя все настройки, необходимые для работы системы Face, однако одна строка кода, QueryPulse()->Enable(), имеет непосредственное отношение к подсчёту пульса. Она включает нужную нам часть системы и поддерживает её работу.

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

PXCFaceData* faceOutput = faceModule->CreateOutput();
const int numFaces = faceOutput->QueryNumberOfDetectedFaces();
for (int i = 0; i < numFaces; ++i)
{
	PXCFaceData::Face* trackedFace = faceOutput->QueryFaceByIndex(i);
	const PXCFaceData::PulseData* pulse = trackedFace->QueryPulse();
	if (pulse != NULL)
	{
		pxcF32 hr = pulse->QueryHeartRate();
	}
}

Разбирая этот код, вы можете не обращать особого внимания на всё, кроме вызова trackedFace->QueryPulse(), который запрашивает у системы частоту пульса, полученную на основе ранее собранных данных. Если данные о пульсе имеются, применяется вызов pulse->QueryHeartRate() для того, чтобы извлечь нужную нам информацию и возвратить её в формате частоты сердечных сокращений в минуту.

Вот как я удивился, когда понял, что машина верно определила пульс.

Для того чтобы измерить собственный пульс, запустите пример Face Tracking, который поставляется вместе с RealSense SDK. В правой части окна программы оставьте выбранными пункты Detection (Обнаружение) и Pulse (Пульс), нажмите на кнопку Start (Пуск) и секунд 10 спокойно посидите.

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

Секреты и советы

Это стоит попробовать:
 

• Для того, чтобы получить наилучшие результаты, причём – это касается любой работы с видеопотоками, а не только определения пульса, пользуйтесь камерой в хороших условиях освещённости (не при солнечном свете) и старайтесь оставаться неподвижным в фазе захвата изображения до тех пор, пока не получите точные результаты.
   
• Так как в текущей версии SDK имеется лишь одна функция для определения частоты пульса, перед вами – широко распахнутая дверь для новаторов, которые, на основе необработанных данных, смогут получить более точные сведения о частоте сердцебиения или ускорить этот процесс. Сейчас для определения частоты пульса требуется около 10 секунд. Сможете написать программу, которая делает это быстрее?
   
• Если вы собираетесь определять частоту сердечных сокращений на улице и хотите написать собственный алгоритм анализа данных, рекомендуется использовать только цветовой видеопоток для определения изменения цвета кожи.

Этого лучше не делать:
 

• Используя пример Face Tracking, не пытайтесь определять частоту сердечных сокращений, включив все его возможности. Это ухудшит качество результатов, а, возможно, вы их и вовсе не получите. Для того чтобы модуль Face мог точно определить частоту сердечных сокращений, ему требуется достаточная вычислительная мощность.
   
• Не пользуйтесь технологией определения пульса, которая основана на анализе данных в инфракрасном диапазоне, на улице. Дело в том, что любое количество прямого солнечного света полностью испортит данные в инфракрасной части спектра, воспринятые системой. Как результат, любой анализ этих данных потеряет смысл.

Итоги

Как было сказано в самом начале этого материала, от использования технологий определения частоты пульса не стоит ждать мгновенной выгоды, как от технологий бесконтактного управления или трёхмерного сканирования. Однако, сведения о пульсе, скомбинированные с другой информацией, полученной с различных датчиков, способны привести к созданию систем, которые смогут оказать пользователю неоценимую помощь, причём, делать это тогда, когда пользователь в этой помощи больше всего нуждается. Мы пока не на том уровне развития технологий, когда компьютер сможет выяснить частоту сердцебиения человека, просто проходящего мимо кабинета врача. Однако, мы буквально на полпути к этому. И вопрос о том, когда всё это займёт прочное место в современном мире – это лишь вопрос времени, дальнейших инноваций и поисков вариантов применения технологий дистанционного подсчёта частоты пульса.

Если говорить лично обо мне, то я веду жизнь перегруженного работой программиста старой школы, перемалывающего тонны кода. Сегодня собственное здоровье и экология моего рабочего места значат для меня гораздо больше, чем в юности. Поэтому я с радостью приму любую помощь. И если эта помощь обретёт вид компьютера, который будет одолевать меня сообщениями вроде: «просыпайся; выпей кофе; подними голову; не забудь; открой окно; сделай паузу; поешь чего-нибудь; прогуляйся на свежем воздухе; поиграй в какую-нибудь игру; сходи к доктору, похоже, у тебя пульс пропал; послушай Моцарта; отправляйся спать», в особенности, если эти напоминания будут делаться приятным компьютерным голосом, тогда – да будет так.

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

Android – одна из самых популярных мобильных операционных систем в мире. Ей пользуются около полутора миллиардов человек. Но, несмотря на подобную распространённость, до некоторых пор в корпоративной среде эту ОС старательно избегали, опасаясь угроз безопасности.

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

Ещё одно важное улучшение в данной области представлено новой инициативой Google для организаций – Android for Work. В рамках Android for Work предлагается, во-первых – безопасность корпоративного уровня, во-вторых – возможность контейнеризации рабочих пространств, разделения рабочих и личных данных пользователей.

Эти улучшения серьёзно меняют дело, позволяя смело использовать Android-устройства в бизнес-среде. Естественно, при условии, что организации будут прилагать усилия к устранению проблем с безопасностью, присущих, в силу её особенностей, платформе Android. В этом материале мы рассмотрим четыре рекомендации по управлению Android-устройствами. А именно:
 

• Предотвращение получения пользователями повышенных привилегий на устройствах.
• Защита от мобильных вредоносных программ.
• Обязательное применение надёжных методов защиты информации.
• Реализация политик управления устройствами.
•  

• Предотвращение получения повышенных привилегий

  В Android-среде взлом устройств с целью получения повышенных привилегий называют «рутованием». Это жаргонное, но весьма распространённое слово – русский вариант английского «rooting». Означает оно «получение прав суперпользователя», который в среде Unix-подобных ОС называется «root». Фактически это – снятие ограничений, накладываемых производителем на устройство, и получение полного доступа к нему. Пользователи взламывают телефоны и планшеты самостоятельно. Всё дело в том, что на рутованное Android-устройство можно устанавливать любые приложения, в том числе – потенциально опасные. Можно настраивать, на любом уровне, операционную систему, менять прошивку аппарата.

Приложение для получения прав суперпользователя на Lenovo Yoga Tablet

Рутованные устройства представляют серьёзную проблему безопасности для организаций. Эти устройства находятся в группе повышенного риска заражения вредоносным ПО. Работая в корпоративной сети, они могут быть причиной «утечек данных», могут сделать сеть уязвимой к хакерским атакам.

Проблема, связанная с получением пользователем повышенных привилегий, характерна не только для платформы Android. Так, например, в среде мобильных устройств от Apple существует термин «джейлбрейкинг». Он произошёл от англоязычного «jailbreak», что в дословном переводе означает «побег из тюрьмы». Джейлбрейкинг – это снятие стандартных ограничений на устройствах от Apple, работающих на iOS. В частности, таких, как iPhone, iPod touch, iPad, второе поколение Apple TV. Снятие ограничений заключается в программной или аппаратной модификации устройств, благодаря которому пользователь получает полный доступ к файловой системе iOS. Ему открываются новые возможности по настройке устройства, по установке приложений, расширений и тем, которые недоступны в Apple App Store. Однако в результате страдает безопасность и теряется гарантия на аппарат.

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

Защита от мобильных вредоносных программ

Пользователи Android-устройств могут устанавливать приложения не только из Google Play, но и из других источников. Среди программ, установленных из ненадёжных источников, немало таких, которые несут в себе вредоносную составляющую. Риск установки вредоносного приложения, хотя и очень небольшой, благодаря политике безопасности Google, существует и при работе исключительно с Google Play. Это способно повлиять на организации, в которых работают пользователи, так как вредоносные программы могут красть логины и пароли для доступа к критически важным ресурсам, открывать доступ в корпоративные сети посторонним лицам, могут быть причиной потери важных данных.

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

• Dr.Web Antivirus
• Antivirus and Mobile Security (Avast)
• Mobile Security and Antivirus by ESET
• Armor for Android
• AntiVirus Security Free by AVG
• Mobile Security and AntiVirus by Avast
• Zoner AntiVirus Free
• BitDefender AntiVirus Free
• Hornet AntiVirus Free
• Norton Security Antivirus

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

Применение надёжных методов защиты информации

Если к корпоративной сети могут подключаться мобильные устройства – для защиты информации нужны надёжные меры безопасности. Конкретные подходы к обеспечению безопасности в разных организациях могут различаться, они зависят от специфики деятельности. Мы хотим предложить набор базовых рекомендаций, которые стоит включить в корпоративную политику управления мобильными устройствами.
 

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

Обзор возможностей Google for Work

В дополнение к вышесказанному, здесь мы хотели бы сделать обзор возможностей Google for Work, которые основаны на передовых подходах к организации удобной и безопасной работы мобильных корпоративных пользователей.

Безопасность и разделение данных. При развёртывании Android for Work используется аппаратное шифрование и политики безопасности, управляемые администратором. Это позволяет разделить бизнес-данные и данные пользователя. Данные организации оказываются в безопасности, они защищены от вредоносного ПО. Информация пользователя при этом недоступна никому, кроме него.

Поддержка корпоративных устройств и личных устройств сотрудников. Пользователи Android for Work могут безопасно применять одно и то же устройство и для рабочих, и для личных целей. Компании могут предоставлять предварительно подготовленные корпоративные устройства работникам, а так же – настраивать рабочие профили на устройствах, которые принадлежат сотрудникам.

Удалённое управление. Администраторы могут удалённо управлять политиками безопасности, связанными с работой организации, приложениями и данными. Критически важные данные можно удалить с устройства дистанционно, при этом не затронув личных данных пользователя.

Удобная работа с личными и корпоративными приложениями. Android for Work позволяет создать однородную рабочую среду на всех устройствах. Личные и рабочие приложения находятся в одних и тех же списках установленных и недавно использованных приложений. Переключаться между разными видами приложений очень просто. К тому же, иконки для запуска рабочих приложений выделены особыми значками, которые чётко отличают их от личных приложений.

Упрощённая установка приложений.Администраторы могут использовать Google Play для поиска разрешённых в организации приложений, добавления их в белый список и для установки бизнес-приложений на устройства, работающие в системе Android for Work. Кроме того, Google Play можно использовать и для развёртывания собственных приложений компаний, предназначенных только для внутреннего использования. Подробнее об этом можно узнать в справочном центре Google Play for Work.

Отдельный набор приложений для работы. Пользователи, у которых нет Google Apps for Work, могут пользоваться полным набором безопасных рабочих приложений, специально созданных для применения в рамках Android for Work, но работающих и самостоятельно. В набор входят почтовая программа, календарь, записная книжка, список задач и менеджер загрузок.

Google предлагает систему Android for Work вместе с набором приложений Google Apps for Work. Всё это подходит для немедленного развёртывания. Система позволяет администраторам приложений пакета Google Apps for Work пользоваться функционалом корпоративного управления мобильными устройствами с помощью административной консоли. Это расширяет возможности по управлению устройствами.
 

Реализация политик управления устройствами

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

О безопасности в экосистеме Android

Google, работая над ОС Android и площадкой Google Play, стремится сделать экосистему Android безопаснее. Этой целью руководствуется команда Android Security, которая делает всё возможное для того, чтобы Android-устройства были как можно меньше подвержены угрозам.
Google применяет многоуровневый подход к безопасности. Первый уровень – это предотвращения самой возможности возникновения угрозы. Далее – это выявление вредоносных приложений и быстрая реакция при возникновении каких-либо проблем. А именно, вот что в Google делается ради повышения безопасности:
 

• Компания стремится предотвратить возникновение проблем с безопасностью. Делается это с помощью анализа архитектуры решений, тестирования систем на проникновение, аудита кода.
• До выпуска новых версий Android и Google Play проводится анализ безопасности.
• Исходный код Android открыт, доступен всем желающим. Как результат, его может анализировать большое сообщество разработчиков, выявляя проблемы и помогая сделать Android самой безопасной мобильной платформой в мире.
• Делается всё возможное для того, чтобы свести к минимуму последствия проблем с безопасностью. В частности, с помощью таких решений, как изолированная среда исполнения приложений.
• Приложения в Google Play проходят регулярную проверку на уязвимости и проблемы с безопасностью. Если приложение может представлять угрозу для устройств или данных, его удаляют с площадки.
• Ведётся плотная работа с партнёрами, направленная на как можно более быстрое устранение обнаруженных проблем с безопасностью и выпуск обновлений.

Команда разработки Android тесно сотрудничает с сообществом экспертов в области безопасности, обсуждая идеи, применяя в работе передовые решения, совершенствуя систему. Android является частью Google Patch Reward Program. Программа предусматривает вознаграждение для разработчиков, которые вносят вклад в повышение безопасности популярных проектов с открытым исходным кодом, многие из которых являются основой для Android Open Source Project (AOSP). Кроме того, Google является членом Forum of Incident Response and Security Teams (FIRST).
 

Заключение

Усилия Google сделали Android безопаснее, Android for Work позволяет взять под контроль мобильные устройства, которыми сотрудники пользуются для решения бизнес-задач. Однако не стоит забывать о том, что не существует абсолютно защищённых компьютерных систем.
На базе решений Google можно наладить безопасную работу Android-устройств в организации, но только в том случае, если будут учтены особенности такой работы, в том числе – человеческий фактор. Надеемся, этот материал поможет вам в построении безопасной мобильной рабочей среды.

Загрузить PDF

Носимые устройства – это передний край сегодняшних информационных технологий. Это – мощный тренд. Самые популярные «носимые компьютеры» работают под управлением ОС Android Wear от Google. Она не так уж сильно отличается от того Android’а, который знаком огромному количеству разработчиков. Как результат, любой из этих разработчиков может без особых сложностей начать создавать приложения для Android Wear и претендовать на свою долю внимания от весьма перспективного рынка «носимых приложений».

В этой статье мы поговорим об ОС Android Wear, обратив особое внимание на устройства, работающие под её управлением, на типы приложений, на их разработку и отладку. В частности, рассмотрим два способа отладки с использованием ADB.

Устройства

Понятие «носимый компьютер» подходит для широкого спектра «вычислительных машин». Среди них – гарнитуры для телефонов, медицинские и спортивные устройства, «цифровые украшения» и даже компьютеры для животных. Однако сегодня наибольшее распространение получили так называемые «умные часы».

Крупнейшие производители оборудования выпускают собственные серии наручных часов, которые несут на борту Android Wear. Среди устройств этого типа можно отметить ASUS ZenWatch 2, Motorola 360, LG Watch Urbane, Samsung Gear S, Sony SmartWatch 3. Выглядят эти часы по-разному, но в их функциональности, благодаря одной и той же программной платформе, много общего. Это приложение Google Now, возможность отслеживания физической активности пользователя, средства для управления воспроизведением музыки, поддержка голосовых команд.

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

Что разрабатывать для умных часов?

Хотя Android Wear – проект сравнительно новый, Android Wear Center, площадка, аналогичная Google Play, предлагает множество приложений, созданных специально для носимых устройств.

Здесь есть программы на любой вкус. Каждый день в Android Wear Center публикуются новые приложения для персонализации часов, для работы с музыкой, приложения для организации работы с функциями связи, разработки для здоровья, спорта и другие. Несмотря на небольшой размер экранов часов, есть и игры для них. Например – аркады и пазлы, хотя «носимых игр» пока не так много.

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

Как разрабатывать?

С одной стороны, написание приложений для умных часов очень похоже на создание программ для планшетов и смартфонов. В дело идут знакомые Android-разработчикам инструменты, такие, как JDK, Android SDK (платформа Android Wear поддерживает большую часть API Android), Eclipse, Android Studio или другие интегрированные среды разработки. Здесьможно найти список классов из библиотеки поддержки носимых устройств (Wearable Support Library).

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

Как отлаживать?

Отладка – это то, без чего не обходится процесс создания любого программного кода. Разработка для Android Wear – не исключение. В этом разделе мы рассмотрим отладку «носимых» приложений на примере часов LG G Watch R, подключённых к Nexus 4.

Android Wear поддерживает два способа отладки: с использованием проводного интерфейса USB и по беспроводному Bluetooth.

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

• Установка ADB на компьютер разработчика.
  
  Отладочный мост Android (Android Debub Bridge, ADB) – это инструмент командной строки, который обеспечивает взаимодействие компьютера с устройствами, работающими под управлением ОС Android или с соответствующими эмуляторами.
   
• Подготовка устройства.
  
  Для того чтобы отлаживать приложения для Android Wear, нужно включить на устройствах работу в режиме отладки. Сделать это необходимо и на умных часах, и на смартфоне, к которому они подключены. Если устройство впервые используется для отладки, нужно открыть его Настройки (Settings), войти в раздел Об устройстве (About) и семь раз коснуться элемента Номер сборки (Build number). После этого в списке настроек устройства появится новая строка – Параметры разработчика (Developer Options). На устройствах различных производителей названия пунктов могут выглядеть иначе.

•  

• Переход в раздел настроек разработчика и включение возможности отладки с использованием ADB.

После этого, если планируется использовать USB-отладку, выполняются следующие действия.

Подключение носимого устройства к ПК с помощью USB-кабеля.

• Разрешение отладки приложений на часах.

  Для этого нужно нажать ОК во всплывающем окне с соответствующим вопросом. Оно появится на смартфоне или планшете, с которым связаны часы.

Для того, чтобы проверить, распознал ли ADB умные часы, подключённые к компьютеру, можно воспользоваться командой adb devicesв командной строке.

После этого всё готово к отладке «носимых» приложений по USB. А вот если вы решили воспользоваться Bluetooth-отладкой, то подготовка к ней будет немного сложнее. Для этого надо выполнить следующие действия.

Включение возможности отладки по Bluetooth (Debug over Bluetooth) на часах.

• Включение отладки по Bluetooth (Debug over Bluetooth) в приложении, благодаря которому смартфон или планшет взаимодействуют с часами. На рисунке выделена область, в которой отображается состояние устройств.

• Подключение смартфона или планшета, соединённых с часами, к компьютеру по USB и разрешение отладки по USB.

• Выполнение следующих команд ADB в командной строке:

  adb forward tcp:4444 localabstract:/adb-hubadb connect localhost:4444

• 
  Включение на смартфоне или планшете возможности отладки носимого устройства, подключённого к нему.

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

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

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

Как делать скриншоты на часах?

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

adb shell screencap -p /sdcard/screenshot.pngadb pull /sdcard/screenshot.png

Обратите внимание на то, что экран у часов круглый, а скриншот – квадратный. Это следует учитывать при разработке приложений и работе над удобством их использования. Если элемент интерфейса приложения виден на копии экрана, он не обязательно целиком появится на экране часов.

Выводы

Союз современных технологий, таких, как процессор Intel Quark и операционная система Android Wear, открывает новые возможности не только для разработчиков устройств, но и для создателей приложений.

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

Загрузить Документ

Из этого практического руководства вы узнаете о библиотеках FMOD, Cocos2D-x, OpenAL и OpenSSL для Android-устройств, построенных на платформе x86. Они, в особенности – первые три, пригодятся тем, кто разрабатывает игры и мультимедийные приложения. А именно, мы поговорим об их настройке, компиляции и использовании в Android-приложениях.

Предварительная подготовка

Прежде, чем мы начнём, нужно кое-что подготовить. Если вы уже разрабатываете приложения для Android, вполне вероятно, что большая часть того, о чём идёт речь, у вас уже есть. Однако и в этом случае полезным будет просмотреть предложенный список.

А именно, вам понадобятся следующие программные инструменты.

1. Среда разработки Android-приложений.  С этой страницы нужно загрузить Android SDK. Мы, приводя практические примеры, используем IDE Eclipse.
2. Android NDK.
3. Cygwin. В ходе установки, на этапе настройки состава пакетов, нужно выбрать следующие: Autoconf, Automake, binutils, gcc-core, gcc-g++, gcc4-core, gcc4-g++, gdb, pcre, pcre-devel, gawk, make, python. Не забудьте выбрать GNU-версию make, иначе вы не сможете выполнять построение проектов с использованием NDK.
4. JDK.
5. Apache Ant.

После того, как всё это у вас есть, нужно отредактировать переменные среды.

1. Запишите в переменную среды JAVA_HOMEпуть, который ведет к установленному Java JDK. В нашем случае это – C:\Program Files\Java\jdk1.7.0_45
2. Запишите в переменную ANDROID_SDK_ROOTполный путь к папке Android SDK. Например, в нашем случае пакет разработчика Android был распакован в папку D:\android\, в результате в эту переменную был записан путь D:\android\adt-bundle-windows-x86-20131030\sdk
3. В переменную NDK_ROOTнужно записать полный путь к папке, в которой располагаются файлы NDK. В нашем случае – это папка D:\android\android-ndk-r9b.
4. Переменную Pathнужно привести к состоянию, в котором она содержит следующие пути:
   1. путь к папке JDK;
   2.  путь к папке bin JDK;
   3. путь к папке NDK;
   4.  путь к папке bin Cygwin;
   5. путь к папке bin ANT;
   6. путь к папке tools Android SDK;
   7. путь к папке platform-tools Android SDK.

Эти пути должны быть разделены знаком точки с запятой (;). В нашем случае содержимое этой переменной выглядит так:

D:\cygwin64\bin;C:\Program Files\Java\jdk1.7.0_40\bin;D:\android\adt-bundle-windows-x86_64-20131030\sdk\tools;D:\android\adt-bundle-windows-x86_64-20131030\sdk\platform-tools;%JAVA_HOME%\bin;%ANT_HOME%\bin

Обратите внимание на то, что в конце пути к нужной папке не должно быть специальных символов, вроде «/» или «’».

FMOD

FMOD – это коммерческая библиотека для работы со звуком. Это – набор инструментов, который работает в разных ОС и позволяет воспроизводить звуковые файлы различных форматов. Его используют при реализации звуковой составляющей игр и мультимедийных приложений.

Ниже приведено пошаговое руководство по интеграции библиотеки FMOD в Android-приложение, рассчитанное на платформу x86 с использованием IDE Eclipse.

Для начала нужно загрузить FMOD. В частности, нас интересует Android-версия FMOD Ex Programmer’s API.

Установка FMOD заключается в распаковке загруженного архива в локальную папку компьютера разработчика.

Сборка с помощью средств Android NDK

Для того чтобы работать со звуком посредством API FMOD Ex, нужно включить соответствующую C/C++ библиотеку в приложение и обратиться к ней с использованием механизма jni.

Функциональность FMOD реализована в виде C/C++ библиотек, к которым можно обращаться через jni, с ними можно работать и из C/C++ компонентов разрабатываемого приложения.

• Библиотека libfmodex.soиспользуется в готовых к выпуску приложениях.
• Библиотека libfmodexL.so– это та же библиотека с включённым отладочным выводом. Её можно использовать в ходе разработки приложения, при его отладке, для выявления и устранения ошибок.

Библиотеки FMOD Ex поставляются в виде armeabi и armeabi-v7a сборок для android-3 и в виде x86-сборки для android-9. Найти эти сборки можно по такому пути:

• {$FMOD INSTALLED PATH}\api\lib\$(ABI)

«Родной» аудио-интерфейс Android OpenSL используется по умолчанию для воспроизведения аудио на устройствах, которые его поддерживают (android-9). На таких устройствах дополнительные файлы для работы не требуются. Для тех устройств, которые OpenSL не поддерживают, понадобится применять режим вывода звука Audio Track. Для этого понадобится jar-файл FMOD. Этот файл нужно добавить в Java-приложение для выполнения инициализации и вывода звука через FMOD.

• fmodex.jar

Ниже мы это обсудим.

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

Инициализация Java-драйвера

Для того чтобы выводить звук с использованием метода Audio Track, в проект приложения нужно включить аудио-драйвер FMOD (реализованный на Java) и инициализировать его. Если используется режим вывода OpenSL, этого делать не нужно.

Для подключения драйвера нужно добавить файл fmodex.jar в проект и импортировать пакет org.fmod.FMODAudioDevice. Для работы Java-драйвера нужно, чтобы приложение загружало библиотеку fmodex.

В классе FMODAudioDevice есть две функции, start () и stop (), которые нужно вызывать для инициализации системы проигрывания звука и её отключения. Их можно вызывать в любое время и в любом месте, но мы рекомендуем поместить вызовы функций start () и stop () в переопределённые в вашем проекте методы жизненного цикла объекта класса Activity onStart() и onStop().

Приложение-пример для Android-устройства, основанного на платформе x86

Создание данного приложения – это то же самое, что сборка NDK-приложения для Android. Взглянем на пример, для которого мы будем использовать демонстрационное приложение, расположенное по следующему адресу:

• {$FMOD INSTALLED PATH}\examples\playsound

Мы будем упоминать эту папку как {$PROJECT DIRECTORY}. Однако прежде чем мы займёмся сборкой, нам нужно выполнить некоторые изменения в демонстрационном приложении.

1. Перейдём в папку {$PROJECT DIRECTORY}/jni и откроем файл Application.mk
2. Изменим этот код:

APP_ABI := armeabi armeabi-v7a

На этот:

APP_ABI := x86

Теперь откроем Cygwin и выполним следующие задачи для построения приложения:

1. Обновим переменную PATH в Cygwin:

export PATH=.:/cygdrive/{$PATH TO NDK}:$PATH

1. Перейдём в папку проекта:

cd /cygdrive/{$PROJECT DIRECTORY}

1. Выполним команду для построения приложения:

ndk-build

Проект будет собран и готов для развёртывания.

Обратите внимание на то, что здесь символы «\», которые используются в Windows при указании путей к папкам, заменены на символы «/», которые используются в путях формата GNU.

После успешной сборки проекта в окне Cygwin вы увидите следующие сообщения:

[x86] Prebuilt  : libfmodex.so <= jni/../../../api/lib/x86/

[x86] Install   : libfmodex.so => libs/x86/libfmodex.so

[x86] Cygwin    : Generating dependency file converter script

[x86] Compile   : main <= main.c

[x86] SharedLibrary  : libmain.so

[x86] Install   : libmain.so => libs/x86/libmain.so

Теперь, после успешного построения проекта, его можно импортировать в Eclipse и подготовить к запуску на Android-устройстве.

Подготовка и запуск приложения в IDE Eclipse

Для того чтобы подготовить приложение к запуску с использованием IDE Eclipse, нужно выполнить следующие шаги.

1. Запустите Eclipse и выполните команду File > Import

2. Выберите параметр Existing Android… и нажмите кнопку Next.
4. Перейдите в корневую папку проекта (то есть, в ту папку, что мы называем {$PROJECT DIRECTORY}), затем проверьте, чтобы флаг Copy projects… был снят и нажмите Finish.
6. На данном этапе вы заметите на импортированном проекте, в обозревателе проектов, красный восклицательный знак.
8. Для того чтобы решить проблему, на которую этот знак указывает, выполните команду Window > Preferences, вызвав окно настроек. В окне перейдите к набору настроек Classpath Variables.
10. Щёлкните на странице Classpath Variables кнопку New… , появится окно для настройки новой переменной. Его нужно привести к виду, показанному на рисунке.
12. В поле Name введите
13.  
14. Для заполнения поля Path нажмите на кнопку File и найдите следующий файл:

15. {$FMOD INSTALLED PATH}/api/lib/fmodex.jar

16. Нажмите ОК.
17. Затем снова нажмите ОК, появится окно, показанное ниже. Нажмите в нём кнопку Yes.
19. Теперь красный восклицательный знак исчезнет, проблема будет решена.
20. Выполните команду Project > Properties.
22. В появившемся окне, в разделе C/C++ Build > Environment, нажмите на кнопку Add.
24. В появившемся окне, в поле Name, введите ANDROID_NDK_ROOT, в поле Value – полный путь к установленному на компьютере NDK и нажмите ОК.
26. Теперь нажмите на кнопку Apply, после чего – на кнопку OK.

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

{$FMOD INSTALLED PATH}\examples\media\*

{$FMOD INSTALLED PATH}\fmoddesignerapi\examples\media\*

Обратите внимание на то, что на Android-эмуляторе это приложение может не запуститься.

Настройки, специфические для платформы x86

При сборке приложения, рассчитанного на платформу x86, очень важно внести в проект следующее изменение. Обратите внимание на то, что это делается до начала построения библиотеки.

1. Нужно перейти в директорию {$PROJECT DIRECTORY}\jni и открыть файл Application.mk (или создать такой файл, если его в этой директории нет).
2. В указанном файле нужно заменить код

APP_ABI := armeabi armeabi-v7a

•  
• _ABI := x86

Материалы, которые получаются после построения

Материалы, получаемые при сборке, размещаются в папке {$PROJECT DIRECTORY}\ . А именно, библиотеки libmain.so и libfmodex.so окажутся в папке{$PROJECT DIRECTORY}\libs\x86. Сгенерированные объектные файлы попадают в папку {$PROJECT DIRECTORY}\obj.

Известные ошибки и проблемы

Если в ходе построения проекта с использованием NDK появляются сообщения об ошибках, нужно настроить разрешение доступа к файлам. А именно, изменить разрешение на «Полный доступ» («Full Control») для группы «Все» («Everyone»).

Кроме того, обратите внимание на то, что приложение, которое использует рассматриваемые библиотеки, может не запуститься в эмуляторе. Учтите и то, что для его нормальной работы на физическом устройстве нужно скопировать файлы из папок {$FMOD INSTALLED PATH}\examples\media\* и {$FMOD INSTALLED PATH}\fmoddesignerapi\examples\media\ в папку fmod, которая должна быть расположена в корневой директории SD-карты устройства.

Fmod Studio API, работа в Android Studio

Fmod, помимо библиотеки Fmod Ex, предлагает продукт Fmod Studio, предназначенный для подготовки звука для компьютерных игр, и соответствующую библиотеку для различных платформ, которая позволяет работать с проектами Fmod Studio. Всё это можно загрузить отсюда.

Для того чтобы быстро получить работающий пример использования Fmod Studio API на Android, вы можете воспользоваться проектом с GitHub Fmod Sample 3D. В частности, в проекте присутствует библиотека, рассчитанная на архитектуру x86. Его можно импортировать в вашу IDE, например - в Android Studio. Если при импорте возникнет ошибка NDK integration is deprecated…, для её исправления в корневой папке проекта нужно создать файл gradle.properties и записать в него строку android.useDeprecatedNdk=true.

Запуск демонстрационного приложения на Asus FonePad 8

Многие примеры использования сторонних библиотек в Android-проектах, которые, в частности, можно обнаружить на GitHub, созданы с использованием IDE Eclipse. Их можно импортировать и в Android Studio, однако, в ходе импорта могут возникнуть ошибки.

Например, если системе не удаётся обнаружить NDK – вероятнее всего, неверно указан путь к нему в настройках проекта. Проверить это можно в файле local.properties, в корневой директории проекта. Исправить – записав верный путь в переменную ndk.dir.

Если Eclipse-проект содержит ссылки на внешние файлы, которые в вашей копии импортированного проекта неактуальны, Android Studio может отказаться импортировать проект до исправления таких ссылок. Для успешного импорта проекта нужно найти файлы (например – project.properties), содержащие такие ссылки (например, вида «android.library.reference.1=») и исправить их на те, которые актуальны для вашего окружения.

Cocos2d-x

Рассмотрим теперь процесс создания кросс-платформенного Android-приложения с использованием игрового движка Cocos2d-x для целевой платформы x86.

Приложение-пример, которое используется в этом руководстве, является частью материалов, доступных при загрузке Cocos2d-x. Приложение можно найти в папке \samples\Cpp\, которая расположена, в нашем случае, в директории cocos2d-x-2.1.1.

Cocos2d-x– это библиотека, написанная на C++ и портированная на множество платформ. Среди них – iOS, Android, Windows, Marmalade, Linux, Bada и Blackberry 10. В качестве скриптовых языков при работе с игровым движком используются Lua и JavaScript. Подробности о движке можно найти в документациик нему.

Прежде чем приступать к работе с Cocos2D-x, вам нужно подготовить всё необходимое – так, как описано в начале этого материала.

Загрузка Cocos2d-x

Загрузите свежую версию Cocos2d-x. Обратите внимание на то, что нам нужна обычная, а не html-5 версия движка.

Установка и настройка Cocos2d-x

1. Распакуйте архив, загруженный на предыдущем шаге, на диск. В нашем случае архив извлечён в папку D:\Cocos2d-x.
2. После распаковки архива, для описываемой версии движка, в целевой папке будут находиться директории D:\Cocos2d-x\__MACOSX и D:\Cocos2d-x\cocos2d-x-2.2.1.
3. Настройте переменную среды для Cocos2d-x следующим образом:
4. 2DX_ROOT = полный путь к папке cocos2d-x-2.2.1, в нашем случае это: D:\Cocos2d-x\cocos2d-x-2.2.1.

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

• {$ADT PATH} = полный путь к Android ADT, в нашем случае это: D:\android\adt-bundle-windows-x86_64-20131030.
• {$ECLIPSE PATH} = полный путь к Eclipse. В нашем случае, так как Eclipse входит в состав ADT, путь будет выглядеть как: {$ADT PATH}\eclipse
• {$COCOS2D-X PATH} = полный путь к папке cocos2d-x-2.2.1, в нашем случае это: D:\Cocos2d-x\cocos2d-x-2.2.1.
• {$WORKSPACE PATH} = полный путь к папке рабочего пространства Android-проекта Eclipse. У нас это: D:\and_proj_coco.

Настройка проекта Cocos2d-x в IDE Eclipse

1. Запустите Eclipse, воспользовавшись исполняемым файлом {$ECLIPSE PATH}\eclipse.exe.
2. Создайте рабочее пространство. Мы создали его по адресу {$WORKSPACE PATH}, как показано на рисунке.

2. Выполните команду File > Import.

3. Появится окно, похожее на то, что приведено на рисунке.
5. Разверните раздел Android, выберите пункт Existing Android Code Into Workspace и нажмите кнопку Next.
6. В следующем окне нажмите на кнопку Browse, как показано ниже.
8. Найдите папку {$COCOS2D-X PATH}\samples\Cpp\HelloCpp\proj.android, как показано на рисунке, и нажмите OK.
10. Для этого демонстрационного примера, прежде чем нажимать на кнопку Finish, проверьте, чтобы флаг Copy projects into workspace не был установлен.
12. После импорта в Eclipse могут появиться сообщения об ошибках. Пока на них можно не обращать внимания и переходить к следующим шагам.

13. Обратите внимание на то, что если в будущем вы решите оставить исходный код проекта в неприкосновенности и будете при этом уверены, что импорт кода проекта в рабочее пространство не повлияет на его исполнение, вышеописанный флаг Copy projects into workspace можно установить.

14. Теперь повторите шаги 3 – 8, с той разницей, что вместо импорта {$COCOS2D-X PATH}\samples\Cpp\HelloCpp\proj.android, нужно выполнить импорт {$COCOS2D-X PATH}\cocos2dx\platform\android как показано ниже. Если хотите, установите флаг Copy project into workspace.
16. Если сообщения об ошибках, которые возникли на шаге 8, не исчезли, выполните следующие шаги для решения проблем.
17. На закладке Package Explorer, слева, щёлкните правой кнопкой мыши libcocos2dx и в появившемся меню выберите пункт Properties.
19. В появившемся окне выберите, в левой колонке, пункт Android и проверьте, установлен ли флаг Is Library, как показано на рисунке ниже. Если это не так, установите флаг, нажмите Apply и OK.
21. Так же, как было описано выше, откройте свойства проекта HelloCpp, добравшись до окна, показанного на рисунке.
23. Уберите из раздела Library всё, что отмечено красным крестиком и нажмите кнопку Add.
24. Выберите libcocos2dx и нажмите OK.
26. Теперь вы увидите, что в разделе Library появилось название проекта с зелёной галочкой. После этого можно нажать кнопку Apply, и затем – OK.
28. На данном этапе Eclipse выполнит перестроение проекта. Если сообщений об ошибках не появилось, пропустите этот шаг. Если нет – удалите проект HelloCpp из панели Package Explorer. При этом обратите внимание на то, чтобы флаг Delete project contents on disk… не был установлен. Если он будет установлен, данное действие нельзя будет отменить. Теперь снова выполните шаги 3 – 8 и 13 – 16.
30. Теперь ваш проект должен выглядеть примерно так, как показано на рисунке.

Если вы успешно добрались до этого места – примите поздравления! Проект успешно открыт в IDE Eclipse, всё готово к его сборке.

Построение проекта Cocos2d-x в IDE Eclipse

1. На закладке Package Explorer найдите файл HelloCpp > jni > Application.mk

2. Для того чтобы осуществить сборку для платформы x86, добавьте туда следующее:

3. APP_ABI := x86

4. Теперь, в главном меню Project, сначала выполните команду Clean…, потом – Build Project.

Открытие и построение проекта Cocos2d-x средствами Cygwin

1. Запустите Cygwin и перейдите к папке демонстрационного проекта HelloCpp, используя следующую команду:

cd /cygdrive/d/Cocos2d-x/cocos2d-x-2.2.1/samples/Cpp/HelloCpp/proj.android

Учитывайте, что путь к папке проекта зависит от {$COCOS2D-X PATH}.

1. Откройте файл /jni/Application.mk. Он должен содержать следующую строку:

APP_ABI := x86

1. Для построения проекта, находясь в папке /proj.android, выполните следующую команду:
2.  

Если вы столкнётесь с сообщениями об ошибках, проверьте следующее:

• Убедитесь в том, что загружены все необходимые пакеты для Cygwin.
• Переменная PATH Cygwin содержит пути к Android NDK, SDK, JDK и к папкам COCOS2D-X, как было описано в разделе, посвящённом предварительной подготовке.

После успешного завершения сборки двоичные файлы окажутся в папке proj.android\obj\local\x86.

В частности, это следующие файлы:

proj.android\obj\local\x86\libhellocpp.so

proj.android\obj\local\x86\libcocos2d.a

OpenAL (Open Audio Library)

OpenAL (Open Audio Library) – это кросс-платформенный API для работы со звуком. Данная библиотека разработана для эффективного вывода многоканального объёмного звука. Стиль API и соглашения, принятые в нём, намеренно сделаны похожими на OpenGL. Начиная с версии 1.1., компания Creative закрыла код своей реализации. Однако, OpenAL Soft– это широко используемая альтернатива с открытым кодом. Мы будем пользоваться версией OpenAL Soft, адаптированной для Android.

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

Загрузка исправленного кода OpenAL

Для того чтобы работать с OpenAL, нам понадобится исправленный исходный код, который специально адаптирован для Android. Соответствующая версия OpenAL увидела свет благодаря стараниями Мартинса Мозейко (Martins Mozeiko) и Криса Робинсона (Chris Robinson). Спасибо им за это! Для продолжения наших экспериментов загрузите свежую версию кода.

Загрузить всё необходимое можно и другим путём, пользуясь терминалом Cygwin.

1. Запустите Cygwin и введите следующую команду:

git clone http://repo.or.cz/r/openal-soft/android.git OpenAL

1. После успешного выполнения этой команды, нужный нам репозиторий будет клонирован в локальную папку OpenAL. В нашем случае это папка /home/user001 или ~.

Обратите внимание на то, что в случае с Windows-версией Cygwin, директорию /home можно найти в той папке, куда установлен Cygwin. В нашем случае это – D:\cygwin64.

Настройка OpenAL для платформы x86

Прежде чем приступать к сборке, создадим обычный Android-проект Hello OpenAL. Будем считать, что путь к папке этого проекта – {$PROJECT_DIR}, например, он может быть таким: D:\openal_proj\HelloOpenAL.

Для сборки проекта с использованием OpenAL для Android, нужно выполнить следующие шаги.

1. Для сборки OpenAL понадобится файл config.h. Его надо скопировать из этой папки:
2.  
3. эту:
4.  

Здесь {$OPENAL_DIR} – это полный путь к папке, в которую на предыдущем этапе были загружены файлы OpenAL. В нашем случае это ~/openal.

1. Теперь, когда файл скопирован, скопируйте данную папку OpenAL в папку проекта {$PROJECT_DIR}.
2. Добавьте в следующих шагах native-интерфейс к проекту.
3. Мы пользовались файлом org_pielot_helloopenal_HelloOpenAL.c для реализации методов воспроизведения аудио из «родного» интерфейса.
4. Нужно создать два make-файла. Это – Android.mk и Application.mk и поместить их в папку jni вместе с файлом .c и его файлом заголовков .h.

Для того чтобы настроить проект для платформы x86, проверьте, чтобы в файле Application.mk содержалось следующее:

APP_OPTIM := release

APP_ABI := x86

Сборка проекта

1. Запустите Cygwin и перейдите к папке {$PROJECT_DIR}:
2. /cygdrive/{$PROJECT_DIR}

Здесь {$PROJECT_DIR} представляет собой полный путь к папке проекта. В нашем случае команда выглядит так:

1. /cygdrive/d/openal_proj

1. Теперь, для того, чтобы включить путь к NDK в переменную среды PATH Cygwin, выполните команду такого вида:

export PATH=.:/cygdrive/{$PATH TO NDK}:$PATH

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

export PATH=.:/cygdrive/d/android/android-ndk-r9b:$PATH

1. Выполните команду для сборки проекта:
2.  

После её успешного выполнения проект OpenAL будет собран для целевой архитектуры x86.

Файлы, полученные при сборке проекта

Файлы, являющиеся результатами сборки, расположены в папке {$PROJECT_DIR}. А именно, сгенерированные библиотеки libopenal.so и libopenaltest.so будут находиться в папке {$PROJECT_DIR}\libs\x86.

Объектные файлы – в папке {$PROJECT_DIR}\obj.

Библиотеки OpenSSL

Рассмотрим сборку библиотек OpenSSLдля Android-устройств, построенных на базе архитектуры x86.

Предварительная подготовка

Для дальнейшей работы нам понадобится следующее.

1. Главный компьютер, работающий под управлением ОС Windows 7 или более поздней.
2. Так как библиотеки OpenSSL написаны на чистом C, для сборки будет достаточно Android NDK, в который встроена поддержка для кросс-компиляции библиотек для заданных платформ (ARM, x86 и других).

Исходный код библиотек OpenSSL для Android можно загрузить из репозиториев eighthaveили guardianproject.

Сборка для платформы x86

Выбрать целевую платформу сборки можно так же, как и для любого другого Android-приложения, используя установки Application Binary Interface (ABI).

В нашем случае в файле jni/Application.mk должно присутствовать следующее:

APP_ABI := x86

Итак, после того, как NDK загружен и установлен, исходный код Android OpenSSL так же загружен и размещён в локальной папке (например, в C:\openssl-android-master), для сборки библиотек нужно будет сделать следующее.

1. Откройте окно командной строки (cmd.exe).
2. Перейдите в папку, где расположены файлы OpenSSL для Android. Например, такой командой:

cd C:\openssl-android-master

1. Не забудьте указать для сборки целевую платформу x86:

APP_ABI := x86

1. Выполните команду NDK для запуска сборки:

C:\openssl-android-master > ndk-build

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

Выводы

Мы рассмотрели вопросы подготовки различных библиотек для использования в приложениях, рассчитанных на Android-устройства, построенные на платформе x86. Это – библиотеки для работы со звуком FMOD и OpenAL, игровой движок Cocos2d-x, криптографическая библиотека OpenSSL. Да, кстати, если вам нужно подготовить для использования в проектах, рассчитанных на архитектуру x86, библиотеку FFMPEG, можете заглянуть сюда.

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

На момент написания этого текста текущей версией Android Studio была версия 1.0.1. Компилятор Intel C++ Compiler for Android, будучи частью Intel Integrated Native Developer Experience (Intel INDE), поддерживает Android Studio 1.0.1 в Intel INDE 2015 Update 1. Поскольку Android Studio 1.0.1 не поддерживает Android NDK, в этой статье описаны шаги для создания нативного Android-приложения с использованием Android NDK r10d и компилятора Intel C++ Compiler for Android. Поехали!

Android Studio в качестве системы сборки использует Gradle. На момент написания статьи Gradle в процессе сборки вызывала систему NDK. В Android NDK r10 и более поздней версии после инсталляции Intel INDE компилятор Intel C++ Compiler for Android (ICC) не является более используемым по умолчанию компилятором в системе сборки NDK.

Представленные ниже шаги дают общее описание подготовки, сборки и выполнения нативного приложения в Android Studio 1.0.1.

Если вы используете Android Studio 0.8.6, почитайте статью «Сборка нативных Android-приложений с использованием компилятора Intel C++ Compiler в Android Studio», где рассказывается о применении Intel C++ Compiler.
 

Требуемые программные инструменты

Успешная инсталляция INDE 2015 Update 1 с Android Studio Integration гарантирует, что вы располагаете всем необходимым программным обеспечением. Детальные требования к программному обеспечению и системе описаны в документе Intel C++ Compiler Release Notes for Intel Integrated Native Developer Experience 2015.

Приведенные в данной статье инструкции предполагают использование следующего ПО для архитектуры IA-32 и Intel-64:
 

• Oracle JDK 7 (нативный Intel-64 JDK для систем Windows x64)
• Android SDK 20 или старше
• NDK r10d (предполагается инсталляция в [ndk-dir] )
• Android Studio 1.0.1

Убедитесь, что в переменную среды PATH добавлены следующие директории Android NDK (если они отсутствуют, добавьте):
 

• C:\Intel\INDE\IDEintegration\NDK\build\tools
• C:\Intel\INDE\IDEintegration\NDK

Использование компилятора Intel C++ Compiler в Android Studio 1.0.1

После инсталляции Intel C++ Compiler 15.0 for Android в папку «[ndk-dir]\toolchains» (директория по умолчанию – «C:\Intel\INDE\IDEintegration\android-ndk-r10d\toolchains») устанавливаются следующие элементы:
 

• x86-icc
• x86-icc15.0.X.YYY
• x86_64-icc (если NDK поддерживает 64-разрядные цели)
• x86_64-icc15.0.X.YYY (если NDK поддерживает 64-разрядные цели)

Для NDK до r9d:после инсталляции нативным компилятором C/C++ будет Intel C++ Compiler. Дополнительных шагов для использования Intel C++ Compiler с Android Studio не требуется. Ели вы хотите для построения нативного кода использовать GNU gc, следуйте инструкциям в «Замена компилятора по умолчанию с Intel C++ Compiler на GCC для целевых приложений x86».

Для NDK r10 — r10d:компилятор Intel C++ после инсталляции не является компилятором по умолчанию. Чтобы использовать Intel C++ Compiler из Android Studio, следуйте шагам 3, 4, 5 ниже.

Если у вас установлено несколько Android NDK, следуйте инструкциям в статье «Интеграция Intel C++ Compiler for Android с несколькими Android NDK».

Теперь создадим новый проект Android для Intel-64 с нативным вызовом функции, продемонстрировав тем самым использование компилятора Intel C++ Compiler:
 

1. Создание нового проекта Android с нативным интерфейсом:

1. 1. 1.Откройте Android Studio, создайте новый Android-проект «nativeDemo» с параметрами по умолчанию, например:

   2. Откройте «app\src\main\java\MainActivity.java» и добавьте в конец класса «MainActivity» нативную функцию как показано ниже:
       

      publicnative String getStringFromNative();

      
      Должно получиться примерно так:

   3. Чтобы создать проект «nativeDemo», выберите: «Build > Make Project», после чего можно будет использовать «javah».
      4.В «View > Tools Windows > Terminal» откройте терминальное окно и выполните указанные ниже шаги для запуска «javah» и создания заголовка jni:
      a)В терминальном окне перейдите в подпапку «src\main»:
       

      cd src\main

      
      b)Чтобы создать «com_example_nativedemo_app_MainActivit.h» в папке src\main\jni, выполните следующую команду «javah» cmd:
       

      javah -d .\jni -classpath C:\Intel\INDE\IDEintegration\android-sdk-windows\platforms\android-21\android.jar;..\..\build\intermediates\classes\debug com.example.mydemo.nativedemo.MainActivity

      
      Пример:

      e.g.

   4. 5.В окне Project измените вид на Project, щелкните правой кнопкой мыши на папке «src» и выберите «Synchronize 'src». Теперь в папке «src\main\jni» можно видеть файл заголовка «com_example_mydemo_nativedemo_MainActivity.h».
       

      2. Добавление нативного исходного кода: main.c

      1.Создайте «main.c»: выделите файл «com_example_mydemo_nativedemo_MainActivity.h», используйте волшебные клавиши copy/paste для создания нового «main.c» со следующим кодом:
       

      #include "com_example_mydemo_nativedemo_MainActivity.h"
      
      JNIEXPORT jstring JNICALL
      Java_com_example_mydemo_nativedemo_MainActivity_getStringFromNative
        (JNIEnv * env, jobject obj)
      {
          #ifdef __INTEL_COMPILER_UPDATE
              return (*env)->NewStringUTF(env, "Hello from Intel C++ !");
          #else
              return (*env)->NewStringUTF(env, "Hello from default C++ !");
          #endif
      }

   5. Сохраните изменения
      3.Теперь в папке «jni» у вас два файла: com_example_mydemo_nativedemo_MainActivity.h и main.c

2. Добавление make-файла: Android.mk

   1.Щелкните правой кнопкой на папке «jni», выберите «New > File»
   2.Наберите «Android.mk» и щёлкните на «OK»
   3.Добавьте в этот файл следующие строки (обратите внимание, что строка LOCAL_SRC_FILES должна содержать исходные файлы, которые находятся в папке «jni»):
    

   LOCAL_PATH := $(call my-dir)
   include $(CLEAR_VARS)
   
   LOCAL_MODULE    := nativeDemo
   LOCAL_SRC_FILES := main.c
   
   include $(BUILD_SHARED_LIBRARY)

    

   4. Добавление make-файла: Application.mk

   1.Щелкните правой кнопкой на папке «jni», выберите «New > File»
   2.Наберите «Application.mk» и щёлкните на «OK»
   3.Добавьте в этот файл следующие строки:
    

   # For IA-32
   #APP_ABI:=x86
   #NDK_TOOLCHAIN:=x86-icc
   #include $(BUILD_SHARED_LIBRARY)
   
   # For Intel-64
   APP_ABI:=x86_64
   NDK_TOOLCHAIN:=x86_64-icc
   include $(BUILD_SHARED_LIBRARY)

   
   4. [Опционально] Для изменения параметров компилятора используйте следующее:
    

   APP_CFLAGS := -O3

    

   5. Сконфигурируйте свое приложение для выполнения ndk-build с помощью make-файлов

   1.Откройте файл «app\build.gradle»
   2.Добавьте в начало файла следующий импорт:
    

   import com.android.build.gradle.tasks.NdkCompile
   import org.apache.tools.ant.taskdefs.condition.Os

   
   3.И эти строки после секции «defaultConfig»:
    

   sourceSets.main {
       jniLibs.srcDir 'src/main/libs' //set .so files location to libs
   }
   
   tasks.withType(NdkCompile) { // disable automatic ndk-build call
       compileTask -> compileTask.enabled = false
   }
   
   task ndkBuild(type: Exec) { // call ndk-build(.cmd) script
       if (Os.isFamily(Os.FAMILY_WINDOWS)) {
           commandLine 'cmd', '/c', 'ndk-build.cmd', '-C', file('src/main').absolutePath
       } else {
           commandLine 'ndk-build', '-C', file('src/main').absolutePath
       }
   }
   
   tasks.withType(JavaCompile) {
       compileTask -> compileTask.dependsOn ndkBuild
   }

   
   4.А следующие строки – в конец файла:
    

   dependencies {
       compile fileTree(dir: 'libs', include: ['*.jar'])
   }

   
   5.Сохраните изменения
   6.Теперь создадим проект: выберите [Build > Make Project]. Вы увидите все выходные папки и файлы «libmain.so» в папках «main\libs» и «main\obj\local».
    

   6. Добавьте ID «hello_textview» в виджет textview

   Откройте «res\layout\activity_main.xml» и измените виджет «textview» как показано ниже:
    

   <TextView
       android:text="@string/hello_world"
   	android:layout_width="wrap_content"
   	android:layout_height="wrap_content"
   	android:id="@+id/hello_textview" />

    

   7. Обновите «MainActivity.java», чтобы UI textview вызов нативной библиотеки:

   public class MainActivity extends Activity { static { // load the native library "nativeDemo" System.loadLibrary("nativeDemo"); } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // get the text string from native API, and display on the UI TextView tv = (TextView)findViewById(R.id.hello_textview); tv.setText(this.getStringFromNative()); }

   
   Для импорта виджета TextView и сохранения изменений нажмите ALT+Enter.
    

   8. Запустите виртуальную машину Android Virtual Machine «Intel-Nexus 7 x64» и выполните приложение, щёлкнув кнопку «Run».

   Это означает, что был использован компилятор Intel C++ Compiler for Android.
    

   The end

Теперь вы знаете, как с помощью Intel C++ Compiler в Android Studio создать нативное Android-приложение. Попробуйте запустить его и сообщите нам, что оно делает.

Многие Android-устройства используют процессоры с несколькими вычислительными ядрами, поэтому в отрасли разработки мобильных приложений всё более важным становится умение создавать многопоточные программы. Компания Intel предлагает ценный инструментарий для разработки «параллельных» приложений – он называется Intel Threading Building Blocks (Intel TBB). По существу, Intel TBB представляет собой кросс-платформенную библиотеку шаблонов для создания параллельных программ. Она позволяет создавать и синхронизировать потоки данных, оставляя за кадром детали архитектуры и позволяя вам работать на высоком уровне абстрагирования. Intel TBB поддерживает все архитектуры. Что касается ОС Android, то следует использовать версию 4.3 и выше.

Создание Intel TBB

1. Скачайте Intel TBB, найти можно здесь: www.threadingbuildingblocks.org.
    
2. Добавьте NDK в PATH.
3. 
   Для Windows:
   Для Linux:
   • $ SET PATH=%PATH%;
   • $ export PATH=$PATH:
4. Распакуйте TBB и перейдите в директорию с исходным кодом и в папку src. $ cd /src/
5. Запустите TBB для Android: $ /ndk-build –C /src/ arch=intel64 compiler=gcc target=android clean tbb tbbmalloc –j
6. Эта команда создает TBB для 64-разрядной версии Android 64. Чтобы сформировать TBB для 32-разрядной версии Android, замените arch=intel64 на arch=ia32.
    
7. Библиотека создана. В соответствующей директории (/build/) вы найдете поддиректории с библиотеками: libgnustl_shared.so, libtbbmalloc_proxy.so, libtbbmalloc.so and libtbb.so. libtbb.so и libgnustl_shared. Теперь их можно использовать в нашем приложении.

Вычисление числа Пи

Для вычисления Пи можно выбрать в Wikipedia любую формулу с определенным интегралом. Я выбрал следующую формулу:

Для данной программы я модифицировал эту формулу:

Для вычисления интеграла я использовал метод прямоугольников. Интегрируемая функция разбивается на N = 10⁷равных подинтервалов длиной h = 2·10^-7. Затем вычисляется аппроксимация интеграла – сложением площадей (основание х высоту) N прямоугольников по формуле:

Создание приложения

Создадим новое Android-приложение:

Создадим «основную активность» (Main Activity).

Копируем следующий код в res/layout/activity_main.xml:

In the res/layout/activity_main.xml paste the following code:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="intel.example.pitbbcalc.MainActivity"><LinearLayout
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical"><TextView
            android:id="@+id/title"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/title"
            android:textAppearance="?android:attr/textAppearanceLarge" /><Button
            android:id="@+id/startButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/start" /><LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"><TextView
                android:id="@+id/pi_equally"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/pi_equally"
                android:textAppearance="?android:attr/textAppearanceLarge" /><TextView
                android:id="@+id/pi_val"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:textAppearance="?android:attr/textAppearanceLarge" /></LinearLayout></LinearLayout></RelativeLayout>

А в res/values/strings.xml такой код:

<?xml version="1.0" encoding="utf-8"?><resources><string name="app_name">PiTBBCalc</string><string name="action_settings">Settings</string><string name="start">Start</string><string name="title">Calculation of π</string><string name="pi_equally">π = </string></resources>

Теперь Main Activity выглядит примерно так:

В Project Explorer -> Android Tools -> Add Native Support можно задать нативную поддержку нажатия правой кнопкой на нашем проекте. В следующем окне вводим имя библиотеки нашего проекта и щёлкаем мышью на Finish.

package intel.example.pitbbcalc;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {

	private native double onClickCalc();
	private TextView piEqually;
	private TextView piVal;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		Button startButton = (Button) findViewById(R.id.startButton);
		piEqually = (TextView) findViewById(R.id.pi_equally);
		piVal = (TextView) findViewById(R.id.pi_val);
		piEqually.setVisibility(View.INVISIBLE);
		piVal.setVisibility(View.INVISIBLE);

		startButton.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				double val = onClickCalc();
				piVal.setText(String.valueOf(val));
				piEqually.setVisibility(View.VISIBLE);
				piVal.setVisibility(View.VISIBLE);
			}
		});

		System.loadLibrary("PiTBBCalc");
		System.loadLibrary("tbb");
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle action bar item clicks here. The action bar will
		// automatically handle clicks on the Home/Up button, so long
		// as you specify a parent activity in AndroidManifest.xml.
		int id = item.getItemId();
		if (id == R.id.action_settings) {
			return true;
		}
		return super.onOptionsItemSelected(item);
	}
}

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

Чтобы с помощью Intel TBB добавить в проект параллельные вычисления, нужно отредактировать jni/Android.mk. Android.mk – это Makefile для нашего проекта, и нужно добавить в него библиотеки Intel TBB:

#include <jni.h>
#include <math.h>

double piIntFunc (const double x)
{
	return sqrt(1 - pow(x, 2.0));
}

double calcPi()
{
	const unsigned int n = pow(10.0, 7);
	double a(-1), b(1);
	double h = (b - a) / n;
	double x (a);

	for (unsigned int i (0); i < n; ++i)
	{
		sum += piIntFunc(x);
		x += h;
	}

	sum *= h;

	return 2 * sum;
}

extern "C"
JNIEXPORT jdouble JNICALL Java_intel_example_pitbbcalc_MainActivity_onClickCalc(JNIEnv *env,
		jobject obj)
{
	return calcPi();
}

В директории jni/ создадим файл Application.mk и добавим в него следующие строки:

Чтобы с помощью Intel TBB добавить в проект параллельные вычисления, нужно отредактировать jni/Android.mk. Android.mk – это Makefile для нашего проекта, и нужно добавить в него библиотеки Intel TBB:

LOCAL_PATH := $(call my-dir)
TBB_PATH := <tbb_sources>
TBB_BUILD_PATH := /build/linux_intel64_gcc_android_cc4.9_NDKr10b_version_android-L_release

include $(CLEAR_VARS)

LOCAL_MODULE    := PiTBBCalc
LOCAL_SRC_FILES := PiTBBCalc.cpp
LOCAL_CFLAGS += -DTBB_USE_GCC_BUILTINS -std=c++11 -fexceptions -Wdeprecated-declarations -I$(TBB_PATH)/include -I$(TBB_PATH)$(TBB_BUILD_PATH)
LOCAL_LDLIBS := -llog -ltbb -L./ -L$(TBB_PATH)$(TBB_BUILD_PATH)
LOCAL_SHARED_LIBRARIES += libtbb

include $(BUILD_SHARED_LIBRARY)

include $(CLEAR_VARS)
LOCAL_MODULE    := libtbb
LOCAL_SRC_FILES := $(TBB_PATH)$(TBB_BUILD_PATH)/libtbb.so
include $(PREBUILT_SHARED_LIBRARY)

В директории jni/ создадим файл Application.mk и добавим в него следующие строки:

APP_ABI := x86_64 APP_GNUSTL_FORCE_CPP_FEATURES := exceptions rtti APP_STL := gnustl_shared

Здесь назначение Application.mk состоит в описании необходимых нашему приложению нативных модулей (то есть статический/общих библиотек). В строке APP_ABI := x86_64 зададим нашу целевую архитектуру.

Теперь попробуем запустить приложение. Если вы увидите основной экран приложения, значит библиотеки Intel TBB слинковались успешно, и мы можем начинать разработку нашего приложения.

Для добавления параллелизма нам следует включить заголовок Intel TBB: #include «tbb/tbb.h», удалить цикл и добавить следующий код:

double sum = tbb::parallel_reduce(
		tbb::blocked_range<unsigned int>(0,n),
		double(0), // identity element for summation
		[&](const tbb::blocked_range<unsigned int>& r, double sum)->double {
			for( int i=r.begin(); i!=r.end(); ++i )
			{
				sum += piIntFunc(x);
				x += h;
			}
			return sum; // body returns updated value of accumulator
		},
		[]( double x, double y )->double {
			return x+y; // joins two accumulated values
		}
	);

И теперь, если запустить приложение, оно будет работать в многопоточном режиме.
 

The end

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

Хозяйке на заметку:

»Threading Building Blocks – базовые элементы многопоточности
» Создание параллельных Android-приложений для 64-разрядной архитектуры с использованием Intel TBB
» Руководство по Android: написание многопоточных приложений с помощью Intel Threading Building Blocks

Вам понадобятся

• Звуковое Bluetooth устройство, например, наушники или колонки.
• Подключенная к WiFi сети плата Intel Edison. (Смотрите Step 3: Get your Board Online).
• Компьютер с музыкальными wav файлами, расположенный в нашей сетке.
• Установленное терминальное соединение с платой через последовательный порт (Смотрите Set Up WiFi – Intel Edison) или SSH.

Настройка

Включите ваше Bluetooth устройство и сделайте его видимым. Введите следующие команды в терминале:

rfkill unblock bluetooth
bluetoothctl

Просканируйте доступные Bluetooth устройства:

scan on

Найдите ваше устройство и присоединитесь к нему (подставив его MAC адрес):

pair 00:25:DB:05:72:F2

Установите соединение, если необходимо:

connect 00:25:DB:05:72:F2

Закройте программу bluetoothctl:

quit

Проверьте, что ваше A2DP устройство (в нашем случае наушники LG) распознались в pulseaudio как sink-устройство и его имя начинается с bluez_sink

pactl list sinks

Сконфигурируйте дефолтный sink для использования в pulseaudio следующими командами, подставив параметры вашего устройства:

pactl set-default-sink bluez_sink.00_25_DB_05_72_F2 

Скопируйте аудио файл в формате wav на плату Intel Edison, используя scp (Linux) или pscp.exe (Windows) и проиграйте его через mplayer:

gst-launch-1.0 filesrc location= /home/root/music.wav ! wavparse ! pulsesink

Используйте wav файлы, так как могут быть некоторые сложности при проигрывании mp3 файлов.
 

Устранение проблем

Если вы получили:

Failed to pair: org.bluez.Error.AlreadyExists

Проверьте, какое устройство у вас подключено:

paired-devices

Удалите устройство, к которому вы подключены (подставьте MAC-адрес вашего устройства):

remove 78:24:AF:13:58:B9

-----

Другие полезные команды bluetoothctl можно получить так:

help

Дополнительная информация

Потоковое вещание по сети или через конвейер

От переводчика

При проверке этой статьи у меня возникли некоторые проблемы. Устройство не получалось подсоединить командой connect, не было команды pactl. Плата Edison была прямо из коробки, поэтому всё это решилось перепрошивкой новой версией образа Yocto.

Чтобы перепрошить плату, можно воспользоваться следующей рекомендацией. Я сделал немного по-другому в Windows.

В папке с распакованным архивом Yocto на Windows компьютере запускаем flashall.bat. Возможно, еще понадобится программа dfu-util.exe, которую надо поместить в эту же распакованную папку. Сама программа доступна по ссылке.

Обсуждение dfu-util под Windows и перепрошивку Edison можно найти тути тут.

Подготовка образа (старый образ)

Приготовьте стандартный (или специальный с дополнительными пакетами) образ Edison’а используя Board Support Packageи Startup Guide. Можете использовать оригинальный образ или настроить свой с дополнительными пакетами.
 

Включение UVC (USB Video device Class) в ядре Linux (старый образ)

Если вы хотите использовать обычную USB камеру, тогда понадобится включить UVC в ядре Linux’а. Если вы закончили построение своего собственного образа (сделали 'bitbake edison-image'), то теперь вы готовы настроить Linux ядро. Введите на хост машине:

   ~/edison-src> bitbake virtual/kernel -c menuconfig

Затем найдите и активируйте Device Drivers -> Multimedia support -> Media USB Adapters. Когда настройка будет закончена, замените defconfig содержимым .config, который вы только что изменили. Введите:

  ~/edison-src> cp /build/tmp/work/edison-poky-linux/linuxyocto/3.10.17+gitAUTOINC+6ad20f049a_c03195ed6e-r0/linux-edison-standardbuild/.config build/tmp/work/edison-poky-linux/linuxyocto/3.10.17+gitAUTOINC+6ad20f049a_c03195ed6er0/defconfig

Напоследок выполним bitbake ещё раз:

  ~/edison-src> bitbake virtual/kernel -c configure -f -v


  ~/edison-src> bitbake edison-image

Изменение разделов (старый образ)

Если у вас старый образ, рекомендуем изменить стандартное разбиение разделов, потому что размер корневой файловой системы всего 512 Мб, большая часть которой будет занята сразу же. '/home'– занимает всё, что осталось после присоединения заданных разделов, и обычно это более 2 Гб. Поэтому создание обоих разделов по 1.3 Гб будет более разумно.

Посмотрите в файл 'edison-src/device-software/meta-edison-distro/recipes-bsp/u-boot/files/edison.env' (для нового релиза исходников это файл 'edison-src/device-software/meta-edison/recipes-bsp/u-boot/files/edison.env') измените размер Rootfs с 512 Мб до 1312 Мб. В результате размер /home будет сокращен автоматически. Ещё одно изменение надо будет сделать перед повторной записью образа. Это размер rootfs, который устанавливается в 'edison-src/device-software/meta-edison-distro/recipes-core/images/edison-image.bb'и также равен 512 Мб. Измените размер rootfs снова и перестройте образ, выполнив 'bitbake edison-image'. Когда bitbake завершится, выполните:

 ~/edison-src> /device-software/utils/flash/postBuild.sh

Проверьте, есть ли у вас 'dfu-util'. Если нет, установите:

 ~/edison-src> sudo apt-get install dfu-util

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

 ~/edison-src> /build/toFlash/flashall.sh --recovery

И затем выполните запись без '--recovery'

 ~/edison-src> /build/toFlash/flashall.sh

После удачного запуска Edison’а, присоедините USB кабель к последовательному порту. Проверьте, какой номер USB устройства получил ваш Edison при соединении с Linux компьютером. Затем подключитесь через ‘screen’ (введите соответствующий номер вместо ‘X’, например, ttyUSBX -> ttyUSB0)

> sudo screen /dev/ttyUSBX 115200

Если вы видите, что Edison удачно загрузился, войдите как ‘root’ и проверьте доступное место, выполнив:

 root@edison:~# df -h

Настройка WiFi, пароля для ssh и FTP

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

 root@edison:~# configure_edison --setup

 Следуйте инструкциям и настройте пароли и WiFi. Если у вас не будет задан пароль, тогда доступ по ssh будет запрещен. Подключите хост компьютер и Edison к одной точке доступа. Для передачи файлов можете использовать любой способ подключения по FTP или SCP.

Убедитесь, что у платы Edison есть доступ в интернет, так как он понадобится при автоматической установке IPP.
 

Установка CMake (старый образ)

Старый образ Edison’а не поставляется вместе с 'cmake', но он нам потребуется, чтобы собрать OpenCV. Придётся вручную установить его. Один из способов, использовать ‘opkg’. Пользователь AlexT с форума Intel создал репозиторий, описанный в ветке.

AlexT рассказывает как присоединить репозиторий через ‘opkg’. Чтобы Edison’а получал пакеты из репозитория, замените всё, что у вас есть в /etc/opkg/base-feeds.conf следующим (другие конфигурационные файлы opkg изменять не надо):

===/etc/opkg/base-feeds.conf contents below===
src/gz all http://repo.opkg.net/edison/repo/all
src/gz edison http://repo.opkg.net/edison/repo/edison
src/gz core2-32 http://repo.opkg.net/edison/repo/core2-32

===end of /etc/opkg/base-feeds.conf contents===

Now type 'opkg update' and

Введите ‘opkg update’. Вы должны увидеть следующие строки, означающие, что вы успешно подсоединились к репозиторию:

root@edison:~# opkg update
Downloading http://repo.opkg.net/edison/repo/all/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/all/Packages.gz.
Updated list of available packages in /var/lib/opkg/all.
Downloading http://repo.opkg.net/edison/repo/edison/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/edison/Packages.gz.
Updated list of available packages in /var/lib/opkg/edison.
Downloading http://repo.opkg.net/edison/repo/core2-32/Packages.gz.
Inflating http://repo.opkg.net/edison/repo/core2-32/Packages.gz.
Updated list of available packages in /var/lib/opkg/core2-32.

Теперь вы готовы установить CMake. Введите:

root@edison:~# opkg install cmake-dev

Введите 'cmake'и вы должны увидеть страницу помощи.
 

OpenCV 3.0.0

Перед тем, как мы перейдем к самому OpenCV, нам потребуется много свободного места для его построения на Edison. Поэтому нам нужна дополнительная внешняя память, минимум 2 Гб. Мы отформатируем micro SD карточку и подмонтируем ее к Edison’у. Карточку можно отформатировать как сразу на плате, так и на Linux хост машине. Для форматирования карточки на Linux компьютере введите (block_device замените на ваше устройство, например, /dev/mmcblk1 )

 > mkfs.ext4 block_device

Или:

  > mke4fs -t ext4 block_device

Пометим раздел:

  > e4label <block_device> new_label

Вставьте SD карту в Edison и подмонтируйте её:

 root@edison:~# mkdir <Desired DIR>

 root@edison:~# mount block_device <Desired DIR > 

Проверьте, что она подмонтировалась без проблем, используя 'df -h'. Для удобства, можно настроить автомонтирование ‘auto mount’. Добавьте /dev/block_device <ваша папка> 'в /etc/fstab.

 root@edison:~# vi /etc/fstab

И добавьте '/dev/mmcblk1 /home/ext'

  Скачайте OpenCV for Linux 3.0 c официальной страницы OpenCV. Скопируйте полученный zip-файл на Edison через FTP или SCP. Лучше сразу копировать на внешнюю SD карту, так как, когда OpenCV будет построен, он займет более 1 Гб. Распакуйте скачанный файл командой 'unzip opencv-3.0.0-rc1.zip'и проверьте, что папка opencv-3.0.0-rc1 была создана. Перейдите в папку <OpenCV_DIR>, введите 'cmake .'и посмотрите какие опции есть.

Мы включим IPP и TBB для лучшей производительности. Библиотека IPP будет загружена автоматически, когда флаг WITH_IPP будет включен. Этого нельзя сказать о библиотеке TBB. Её надо будет установить вручную. Поэтому, установите пакет TBB на ваш хост компьютер и скопируйте соответствующие файлы на Edison. Если на вашем хост компьютере Linux 64 разрядный, нужно указать i386 когда будете скачивать через apt-get. На вашем хост компьютере введите:

> sudo apt-get install libtbb-dev:i386

 И скопируйте файлы в папку /usr/include/tbb на Edison с таким же именем. Также надо скопировать на Edison следующие файлы:

На этой странице, можно посмотреть полный список файлов библиотеки tbb.
Теперь на Edison в <OpenCV_DIR> напечатайте (не забыв ‘.’ точку в конце командной строки)

 root@edison:<OpenCV DIR># cmake -D WITH_IPP=ON -D WITH_TBB=ON -D WITH_CUDA=OFF -D WITH_OPENCL=OFF -D BUILD_SHARED_LIBS=OFF -D BUILD_PERF_TESTS=OFF -D BUILD_TESTS=OFF .

Эта команда включает IPP и TBB и выключает всё ненужное. С опцией 'BUILD_SHARED_LIBS=OFF'вы сможете создавать исполняемые программы для запуска без установленного OpenCV. Это может пригодиться, например, при распространении приложений. (Если вам не нужны IPP и TBB используйте WITH_TBB=OFF и WITH_IPP=OFF). В результате конфигурирования вы должны увидеть, что IPP и TBB включены.

Если проблем нет, введите:

 root@edison:<OpenCV DIR># make -j2

Полная сборка займет от 30 минут до одного часа. Если вы получили ошибку

при создании OpenCV или примеров OpenCV, тогда надо добавить ‘-lv4l2’ после ‘-lv4l1’ в соответствующие конфигурационные файлы. Подобная ошибка может появиться в более чем 50 файлах, поэтому будет лучше сделать эту замену следующей командой:

root@edison:<OpenCV DIR># grep -rl -- -lv4l1 samples/* modules/* | xargs sed -i ‘s/-lv4l1/-lv4l1 -lv4l2/g’

Когда сборка закончится, установите то, что построили:

 root@edison:<OpenCV DIR># make install

Установки TBB без компьютера с Linux

У вас может не быть в наличии машины с Linux. Здесь описан вариант такой установки TBB.
Скачайте TBB с сайта www.threadingbuildingblocks.org, это tgz архив. Распакуйте. Нам понадобится две папки, которые надо будет скопировать на Edison.

 root@edison:<OpenCV DIR>/samples# cmake .

Всё её содержимое надо будет скопировать на плату Edison в /usr/include/tbb

root@edison:<OpenCV DIR>/samples# make example_facedetect

 then it will automatically get the building done and output file will be placed in 'samples/cpp'

И её содержимое надо будет скопировать на плату Edison в /usr/lib настроив правильно линки на библиотечные so-файлы.
 

Создание приложений с использованием OpenCV 3.0.0-rc1

Самый лёгкий способ создать простое OpenCV приложение это использовать примеры, которые идут вместе с библиотекой.
Перейдите в папку '/samples'и введите:

root@edison:<OpenCV DIR># grep -rl -- -lv4l1 samples/* modules/* | xargs sed -i ‘s/-lv4l1/-lv4l1 -lv4l2/g’

всё будет сконфигурировано и готово для компиляции примеров. Теперь вы можете заменить один из файлов с примерами в 'samples/cpp'и построить его через cmake. Например, вы можете заменить 'image.cpp'вашим собственным кодом. Сначала сделайте резервную копию оригинального файла:

root@edison:<OpenCV DIR>/samples/cpp# cp image.cpp image_orig.cpp

В этом примере считывается картинка из файла ‘lena.jpg’, переводится в режим градаций серого и записывается в файл ‘test_gray_Image.jpg’. Поднимемся на один уровень выше и скомпилируем пример:
 

root@edison:<OpenCV DIR>/samples/cpp# cd ..
root@edison:<OpenCV DIR>/samples# make example_image

Если вы получите ошибку:
 

'undefined reference to symbol 'v4l2_munmap' ... libv4l2.so.0 : error adding symbols: DSO missing from command line'

пока строите OpenCV или примеры OpenCV, надо будет добавить ‘-lv4l2’ после ‘-lv4l1’ в соответствующие конфигурационные файлы. Подобная ошибка может появиться в более чем 50 файлах, поэтому будет лучше сделать эту замену следующей командой:
 

root@edison:<OpenCV_DIR># grep -rl -- -lv4l1 samples/* modules/* | xargs sed -i ‘s/-lv4l1/-lv4l1 -lv4l2/g’

Запустим:
 

root@edison:<OpenCV DIR>/samples# cd cpp
root@edison:<OpenCV DIR>/samples/cpp#./cpp-example-image

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

Write image ok

И в папке:
 

<OPENCV_DIR>/samples/data

Должен появиться файл:
 

test_gray_Image.jpg

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

И ещё, так как Edison не имеет видеовыхода, будет ошибка, если в коде будет вывод на графический экран. Например, не получится использовать 'imshow', который создает и показывает изображение или видео.
 

Взглянем на мир

Проверим работу OpenCV с камерой. Проще всего использовать камеру, которая работает в Linux и совместима с UVC.
Для подключения камеры по USB надо передвинуть на плате переключатель SW1, чтобы он находился в стороне полноразмерного USB порта, куда будет подключена камера.

Подключив камеру, можно вывести информацию обо всех USB устройствах:
 

root@Edison:/# lsusb
Bus 001 Device 002: ID 1a40:0101 Terminus Technology Inc. 4-Port HUB
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 005: ID 1871:0141 Aveo Technology Corp.

Последняя строка это как раз наша камера. Проверим, что она может работать по UVC:
 

root@Edison:/# lsusb -d 1871:0141 -v | grep "14 Video"
      bFunctionClass         14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video
      bInterfaceClass        14 Video

Если такие строки найдены, то камера поддерживает UVC и её можно использовать в OpenCV. Введите следующий код:
 

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

Дополнительные ссылки:

facedetect.zip (13.81 MB)
mjpg-streamer-for-Edison.zip (957.36 KB)
VTune-Result-Edison.zip (1.07 MB)
 

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

Вот скажите, всегда ли вы чистите зубы положенные 2 минуты?

В этом DIY-проекте мы переделаем обычную, купленную в магазине подставку для зубных щёток в современную бытовую технику интернета вещей.

Плата Intel Edison обладает небольшим размером и необходимой вычислительной мощностью, чтобы приучать к здоровым привычкам – правильному использованию зубной щётки и пасты.

Уверен, у вас уже есть знания, необходимые для разработки под Intel Edison. Так как эта плата содержит встроенный Wi-Fi и использует node.js для работы со своей аппаратной частью, то вы можете программировать на JavaScript. Это значит, что большинство веб-разработчиков может использовать плату Intel Edison, чтобы быстро начать программировать для интернета вещей.

Шаги, описанные ниже, показывают, как добавить выключатели, экран и сенсоры, чтобы переделать любую подставку для зубных щёток в T.E.E.T.H. (Timer Encouraging Everyone To Health – Таймер, побуждающий каждого к здоровому образу жизни). В исходниках видно, как достаточно простой node.js-проект управляет этими компонентами и подключается к интернету, чтобы использовать облачную аналитику и отправлять почту.
 

Использование T.E.E.T.H. — умного таймера для зубной щётки

Для начала выньте вашу щётку из держателя. Это подготовит таймер, который будет ожидать, когда вы начнёте чистить зубы. Затем начнётся двухминутный отсчет, и ЖК-экран будет показывать вам слова одобрения. Две минуты – это время чистки зубов, рекомендованное Американской Ассоциацией Дантистов. Экран будет менять цвета и надписи, пока вы не закончите. Не беспокойтесь, если вы чистите зубы с закрытыми глазами, звуковой сигнал прозвучит в начале и в конце процедуры. Таймер остановится, когда вы поставите щётку обратно или когда вы выключите свет, выходя из ванной. После этого подставка сохранит данные вашего таймера в облаке. Если вы достигните цели, она пошлёт email с поздравлением. Потом вы можете зайти в облако и увидеть прогресс для каждой щётки в подставке. Вы можете отслеживать эти IoT-данные, чтобы поощрять здоровые привычки всех домочадцев.
 

Покупки и планирование

Приблизительное время исполнения проекта: 2-3 часа.
Цена: 75-100 долларов.
 

Детали, использованные в проекте

Материалы:

• Подставка для зубных щёток.
• Процессорный модуль Intel Edison.
• Плата подключения для Intel Edison.
• Кнопки-переключатели, по одному на каждую щётку.
• Пластиковая платформа (по одной для каждой щётки).
• Резисторы 10к (по одному на каждую щётку, и ещё один для фоторезистора).
• ЖК-экран с RGB-подсветкой. (http://www.seeedstudio.com/depot/Grove-LCD-RGB-Backlight-p-1643.html?cPath=34_36).
• Датчик освещения (фоторезистор).
• Пьезоэлектрический динамик.
• Аккумулятор с USB-разъёмом.
• Силиконовый клей или герметик.
• Исходный код проекта.
• Монтажные провода.

Инструменты:

• Компьютер с установленным Intel® XDK IoT Edition и USB кабели.
• Паяльник и припой.
• Режущие инструменты в зависимости от материала вашей подставки.

Шаги

1. Подготовка подставки

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

Установка ЖК-экрана на переднюю стенку

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

Кроме того, вы можете просто прикрутить все компоненты снаружи. Это зависит от вашего чувства прекрасного. Но неважно, как вы это сделаете, главное помнить, чтобы провода от вашего экрана смогли достать до платы Intel Edison, которая будет прикреплена сзади.
 

Добавим кнопку на дно подставки

Подойдет любой датчик, который сможет определить наличие щётки. Я выбрал кнопку с рычажком, вместо какого-нибудь ИК-сенсора, чтобы минимизировать потребление. Однако, зубная щётка весит всего 15 граммов, поэтому понадобится достаточно чувствительный датчик.

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

Из-за того, что нажатие на заднюю часть кнопки не приводит к срабатыванию, я установил кнопку так, чтобы её задняя часть фактически была внутри стенки подставки. Также как и с ЖК-экраном, убедитесь, что провода достанут до основной платы. Я просверлил дырки сзади подставки, поэтому провода в основном не видны.
 

Добавление датчика освещения спереди и пищалки сзади

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

Защита чувствительной электроники от воды

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

Подсоединение компонентов к основной плате

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

Используйте следующую схему соединения компонентов к пинам на монтажной плате.

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

Добавим процессорный модуль Intel Edison к основной печатной плате. Железная часть вашего проекта почти закончена. Вскоре мы добавим батарейку. На данный момент ваш проект должен выглядеть как-то так.

2. Подготовка платы Intel Edison и Облачного сервиса

Запуск платы Intel Edison описан на сайте Intel IoT. Чтобы подсоединить компьютер к плате, следуйте инструкциям http://intel.com/Edison/getstarted
 

Настройка Wi-Fi

Так как наш проект использует Wi-Fi для соединения с облаком и отсылки почты, надо будет соединить плату с Wi-Fi-роутером. Это достаточно просто сделать, используя утилиту configure_edison, которая уже есть на плате Intel Edison. Больше информации можно получить из intel.com/Edison/getstarted
 

Настройка аккаунта IoT Analytics

Этот проект использует Intel® IoT Developer Kit Cloud-based Analytics, чтобы хранить данные в облаке. Вы можете настроить аккаунт по ссылке https://dashboard.us.enableiot.com/v1/ui/auth#/login
 

Добавление компонентов к облаку

После того как вы зарегистрируете вашу плату Intel Edison на IoT Analytics, вы должны приготовить облако для ваших данных, создав специальные компоненты. Создайте по одному компоненту для каждой зубной щётки. Имена, которые вы дадите компонентам, будут именами, которые показываются в отчёте. Следуйте инструкциям по созданию компонентов https:///software.intel.com/ru-ru/intel-iot-developer-kit-cloud-based-analytics-user-guide
 

Регистрирование компонентов на плате Intel Edison

Когда компоненты созданы в панели управления IoT Analytics, вам надо зарегистрировать их на плате. Имена, которые вы используете на этом шаге, будут использоваться в исходном коде, который посылает данные в облако. Вот ссылка на подобные инструкции по регистрации компонентов на плате https:///software.intel.com/ru-ru/intel-iot-developer-kit-cloud-based-analytics-user-guide
 

Запуск Intel агента на плате Intel Edison

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

3. Программирование платы Intel Edison

Ну, раз аппаратная часть и сервисы готовы, время загрузить на плату исходный код T.E.E.T.H.
 

Подключение к плате из Intel® XDK IoT Edition

Среда разработки Intel XDK IoT Edition позволяет строить Node.js проекты на плате. Она поставляется с кучей проектов-примеров. Документация доступна здесь https:///software.intel.com/ru-ru/html5/documentation/getting-started-with-intel-xdk-iot-edition
 

Загрузка программы

Загрузите или клонируйте исходники с GitHub. Файлы имеют структуру небольшого node.js-проекта https://github.com/ncarver/TEETH
 

• readme.md – документация и лицензия;
• package.json – описатель проекта и зависимых библиотек;
• main.js – основной код, необходимый для запуска T.E.E.T.H.;
• node_modules – директория с зависимыми библиотеками, созданная, когда вы первый раз построите проект.

Настройка службы SMTP

В начале файла main.js определяется несколько констант. Вы можете изменить их, чтобы они соответствовали параметрам вашего домашнего окружения и вашим предпочтениям. Как минимум, вам надо изменить значения для MAIL.user, MAIL.pass, and MAIL.brushTo. Эти свойства определяют, как почтовый сервер SMTP соединяется с интернетом и куда должен слать письма T.E.E.T.H.

Использование имен зарегистрированных аналитических компонент

Используйте имена, которые вы зарегистрировали в панели управления IoT Analytics в секции констант, METRICS.brushComponent. Это массив всех компонент, использованных в вашем проекте. У меня он состоит из двух элементов.

Больше, ещё больше зубных щеток

Если вы построили подставку более чем для двух щёток, вам надо будет изменить секцию констант, чтобы код соответствовал этому. Код использует массив структур со значениями специфичными для щёток. Добавьте дополнительные элементы массива для каждой щётки, такие константы как: METRICS.brushComponent, MAIL. brushTo.PINS.brushSwitch, SCREEN_MSG.brushName, TIME.brushPreptime, and TIME.brushGoaltime.
 

4. Разбор исходного кода

Хотя было возможно разбить проект на несколько файлов по модулям, мне кажется, будет проще, если всё будет находиться в одном файле main.js. Этот проект не требует много кода, поэтому дополнительные файлы могут только усложнить понимание.
 

Требуемые библиотеки

Так как у нас node.js-проект, то используются дополнительные модули для взаимодействия с железом, демоном аналитики и почтой.

constants

Эта единственная секция, в которой надо что-то редактировать. Измените эти константные значения для изменения цвета сообщений на экране, текста писем и временных интервалов.
 

timers

Для простоты все таймеры хранятся как глобальные объекты. Это позволяет при вызове методов из setTimeout и setInterval всегда иметь доступ к таймерам.
 

Logger

Класс Logger выводит сообщения на консоль, используя традиционный подход для уменьшения вывода ошибок, предупреждений и информации.
 

Sensors

Используя класс Sensors, вы увидите, как просто работать с пинами ввода/вывода. Состояние выключателей под зубными щётками и значение фоторезистора считываются в этом классе.
 

Buzzer

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

Screen

Класс Screen отвечает за все команды к ЖК-экрану. У него две обязанности — показывать текстовые сообщения и изменять цвет фоновой подсветки.
 

Mailer

Класс Mailer использует nodemailer для отправки почты, используя SMTP. Он содержит проверку ошибок, если невозможно послать письмо.
 

Metrics

Класс Metrics использует локальный сокет на плате, чтобы послать аналитические данные демону iotkit-agent. Если возникает ошибка соединения, на консоль посылается сообщение об ошибке.
 

Teeth

Это главный класс, содержащий всю логику проекта. Teeth вызывает класс Sensors для мониторинга кнопок и света, класс Buzzer для воспроизведения звука, класс Screen для показа сообщений, класс Mailer для посылки почты, класс Metrics для обновления IoT Dashboard. Если вы хотите изменить возможности вашего устройства, надо обновить этот код.
 

5. Протестируем

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

Проверка сенсоров и дисплея

Используйте кнопку Install/Build в Intel XDK IoT Edition для того, чтобы загрузить исходный код на плату и запустить NPM для постройки node-проекта. Нажмите кнопку Run для запуска T.E.E.T.H.

Протестируйте подставку, используя зубную щётку для каждой кнопки на подставке. Вы должны увидеть, что ЖК-экран включается, и вы можете следить за консольным выводом. Также пищалка должна бибикнуть и таймер должен выключиться, если вы закроете датчик освещения.
 

Проверка почты

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

Просмотр аналитики

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

6. Добавим питание

Наконец-то вы готовы отсоединить плату Intel Edison от вашего компьютера и поместить подставку для щёток на раковину в ванную комнату как автономное IoT устройство.
 

Присоединение аккумулятора

Используйте аккумулятор с USB-разъемом, чтобы запитать плату. Мне такой подарили на конференции. Он предназначен для заряда сотового телефона, но замечательно работает и в этом проекте. Я оставил его USB-порт доступным для зарядки.

Финальный шаг

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

Двигаемся дальше

В этом проекте мы только начали получать преимущества от использования беспроводного интернета и облачных данных на платформе Intel Edison. Исходный код может быть легко модифицирован для использования других технологий. Может быть, вы захотите послать твит вместо письма. Или вы захотите использовать другой облачный сервис вместо IoT Analytics, например, Xively. Даже звук запуска и остановки таймера может быть заменён на ваш любимый mp3-файл, который будет послан на динамик. Вы можете быстро внести эти изменения, просто заменяя одни модули другими, которые вы хотите использовать.

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

Об авторе

Натан Карвер пришёл в область IoT извилистой дорогой. Начиная клоуном в Ringling Brothers, сейчас он вице-президент по инженерии в Crisp Media – мобильной рекламной компании, где он работает с веб-технологиями и технологиями больших данных. Предыдущая работа включала запуск отдела профессионального сервиса, основание софтверной компании, исполнение музыки на пиле («Singer and Saw») и хождение под парусом по реке Гудзон. Он живет в Нью-Йорке. Его другие проекты доступны на Github.