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

Для всех, кто хочет использовать облако для машинного обучения или глубокого обучения нейросетей, у нас есть хорошая новость – облако Microsoft Azure прекрасно вам подойдёт! И вот почему:

• В Azure есть готовый образ Data Science Virtual Machine, как под управлением Windows, так и под Linux, на которых уже установлено всё необходимое вам программное обеспечение!
• В нашем облаке вам доступны компьютеры с графическими процессорами NVidia (т.н. N-Series VMs), что сильно ускоряет процесс обучения нейросетей.

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

Data Science Virtual Machine

Для задач обработки данных хорошо подходит специализированная виртуальная машина Data Science Virtual Machine. На ней изначально уже установлены:

• Visual Studio и Visual Studio Code, с поддержкой R и Python
• Anaconda – самая популярная cреда для поддержки различных окружений на Python и не только
• Все необходимые фреймворки для обучения нейросетей: Microsoft Cognitive Toolkit (CNTK), Tensorflow, MXNet и др. Причем если вы используете виртуалку с GPU – все утилиты и библиотеки для работы с GPU (драйвера NVidia, CUDA, cuDNN и др.) будут уже настроены.
• Jupyter Notebooks
• Microsoft R
• Все необходимые библиотеки и утилиты для доступа к Azure
• Много полезных утилит (github, AzCopy, …) и прочих вкусностей

Виртуальные машины доступны как для Windows, так и для Linux:

При этом есть тонкости:

• Data Science Virtual Machine for Windows 2016 – это самый лучший вариант! Может ставится как на GPU (причем как NC, так и NV – подробнее об этом ниже), так и на обычную VM.
• Deep Learning Toolkit for DSVM – это более старая версия виртуальной машины для глубокого обучения на базе Windows Server, которая ставится только на виртуалки типа NC (которых иногда может не хватать).
• Из Linux-вариантов поддержка GPU есть только в Ubuntu, но зато и выбор фреймворков там чуть шире.

Виртуалки с GPU

В Azure есть 2 типа виртуалок с GPU (т.н. N-Series VMs):

• NC (Compute) – предназначены для вычислений и глубокого обучения. Поскольку такие виртуалки пользуются значительной популярностью, их может иногда не хватать в тех или иных регионах.
• NV (Visualisation) – предназначены для запуска приложений графической визуализации. Тем не менее, на этих виртуалках теоретически можно считать нейросети, хотя делать это не рекомендуется. И стоят они чуть дороже.

Виртуальные машины с GPU доступны лишь в некоторых регионах, поэтому если вам не предлагают NC или NV в качестве опции при выборе типа виртуалки – попробуйте выбрать другой регион. Начинать стоит с США (South-Central US, East US) или Европы (North Europe). Вот на этой странице можно посмотреть доступность в разных регионах, выбирая их из drop-down вверху страницы.

Процесс создания VM

Ниже описывается процесс создания и настройки Data Science VM на GPU.

1. Заходим на Azure Portal и выбираем вверху пункт “создать”:

2. В строке поиска пишем Data Science и получаем на выбор несколько вариантов, приведенных на рисунке выше.

3. Выбираем нужны вариант и нажимаем “Создать”. После этого переходим вот к такому экрану конфигурации:

4. При установке машины с GPU в качестве диска обязательно выбрать HDD, поскольку N-Series VM не бывают с SSD, и если выбрать SSD-потом не будет доступна опция выбора N-Series.

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

6. В качестве региона выбираем подходящий регион по принципу, описанному выше. Если в выбранном регионе не окажется доступных VM с GPU – потом можно будет вернуться и сменить его.

7. Следующим пунктом выбираем размер и тип виртуалки. NC6 – это самая простая виртуалка с графическим процессором, и как видим на текущий момент она стоит около 60000 руб. в месяц.

8. В разделе “дополнительные параметры” в принципе можно ничего не настраивать, если вы просто создаете одну вирталку. Если же у вас уже есть какая-то виртуальная подсеть, или вы настраивали ранее сетевой доступ для другой VM – здесь есть некоторый простор для оптимизации.

9. На последнем экране читаем ещё раз выбранную конфигурацию и нажимаем “Купить”.

10. После этого машина долго и мучительно (более 10 минут) создается.

Процесс настройки VM

На этом этапе вы уже можете зайти в свою виртуалку, нажав кнопку “Connect” на страничке настроек (выделено красным):

Однако для комфортной работы с виртуальной машиной нужно сделать ещё несколько настроек:

1. Присвоить машине удобное DNS-имя, чтобы обращаться к ней по имени. Для этого надо нажать на IP-адрес на страничке выше (выделено синим), на открывшейся странице ввести DNS-имя и нажать “Сохранить”:

Также запомните окончание адреса, который зависит от региона. Для данной машины полный DNS-адрес будет smart8.southcentralus.cloudapp.azure.com. Теперь вы сможете просто подключаться к машине с помощью удалённого рабочего стола, используя DNS-адрес и введя указанные ранее данные о пользователе и пароль:

2. Очень удобно проводить обучение нейросетей не через удалённый терминал, а через браузер, используя Jupyter Notebook. Для этого рекомендуется настроить автоматический запуск Jupyter на виртуалке, а также пароль для доступа. Для этого войдите на машину через удалённый рабочий стол и запустите ярлык, показанный ниже:

После этого в появившемся текстовом окне необходимо дважды ввести пароль и нажать ENTER.

После этого необходимо немного подождать, и можно попробовать войти в Jupyter из локального браузера по адресу https://localhost:9999. При этом игнорируйте сообщения о том, что https-сертификат неверный – смело переходите на страницу, вводите установленный ранее пароль и начинайте работать!

3. Для того, чтобы Jupyter Notebook был доступен извне по порту 9999, необходимо добавить запись в Network Security Group для нашей машины (если это не было сделано по умолчанию). В панели управления Azure переходим в группу ресурсов нашей виртуалки и выбираем нечто, заканчивающееся на –nsg:

В открывшемся окне мы должны увидеть примерно такие правила:

Если правила Jupyter с портом 9999 нет, то его необходимо добавить вручную, указав протокол TCP и порт 9999.

После этого вы должны быть в состоянии зайти на Jupyter Notebook вашей машины, просто указав в браузере адрес https://smart8.southcentralus.cloudapp.azure.com:9999 и введя пароль, установленный на предыдущем шаге.

Простой запуск и остановка VM

Поскольку машины с GPU дорогие, то рекомендуется останавливать виртуалки, когда вы их не используете. Так вы сможете снизить расходы с $1000 в месяц, до $70-150 (таков на данный момент мой типовой счет за облако, если я не делаю чего-то экстраординарного). Чтобы каждый раз не заходить на Azure Portal, очень удобно настроить специального Azure Bot в скайпе, который позволит вам запускать и останавливать машины простыми командами.

Процесс настройки бота такой:

1. Заходите на http://botframework.com в раздел Bot Directory.

2. Как правило, Azure Bot будет доступен на первой странице. Если нет – найдите его!

3. Нажимаете на бота и устанавливаете его себе в Skype.

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

5. Для остановки и запуска виртуальных машин используйте команды start vm <имя>, stop vm <имя>

Обратите внимание, что только такое выключение машины (DEALLOCATION) ведет к тому, что с вас перестают списывать деньги за её использование. Если вы просто в удалённом терминале скажете Shutdown – машина будет остановлена, но не деаллоцирована, и деньги продолжат списываться. При деаллокации машины освобождаются лишние ресурсы, включая IP-адреса и временные диски.

Хранение данных

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

• Диск C: – системный. На нем хранятся все программы и системные файлы, и даже есть немного места. Содержимое этого диска сохраняется при деаллокации машины. Однако захламлять его вашими данными – не слишком хорошая идея.
• Диск D: – это быстрый диск для временных данных, его содержимое между запусками машины будет теряться.

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

• Создать файловое хранилище внутри Azure Storage и затем подключить его к своей машине командой net use. Такой подход имеет тот плюс, что вы сможете также подключить то же хранилище к своей основной машине, и тем самым получите простой способ обмениваться данными. Однако файловое хранилище относительно медленное, а если оно вдруг расположено в другом регионе – то совсем медленное. Кроме того, за пересылку данных между регионами взимается какая-то плата.
• Создать виртуальный диск (Managed Disk) и подключить его к виртуальной машине. Виртуальные диски быстрее, чем файловые хранилища, но их сложнее подключить к внешним компьютерам.

Best Practice

В последнее время я делаю несколько проектов по анализу данных и обучению нейросетей, поэтому хочу поделиться с вами полезным приёмом использования виртуальных машин с GPU. Как известно, 80% времени обычно тратится на подготовку данных, и лишь 20% – на собственно запуск алгоритмов обучения. Поэтому я обычно имею в своём арсенале две виртуальные машины, подключенные к общему файловому хранилищу:

• Виртуальная машина для подготовки данных – это обычная виртуалка, без GPU, достаточно мощная, чтобы с ней было комфортно работать по удалённому доступу. Обычно я использую что-то типа DS2.
• Виртуальная машина для обучения – это NC6.

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

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

Заключение

Data Science Virtual Machine – это очень простой и быстрый способ начать использовать инструменты анализа данных и глубокого обучения. Я надеюсь, что мой опыт поможет вам использовать эти виртуальные машины в своей работе или исследованиях. Если у вас есть свой опыт использования виртуальных машин с GPU для анализа данных – делитесь опытом в комментариях!]]> https://docs.microsoft.com/archive/blogs/sos/%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D0%B5%D1%82%D1%81%D1%8F-%D0%B2%D1%82%D0%BE%D1%80%D0%BE%D0%B9-%D1%8D%D1%82%D0%B0%D0%BF-imagine-cup-2017 Sat, 18 Mar 2017 13:52:49 GMT https://blogs.msdn.microsoft.com/sos/?p=825 Друзья!

Закончился приём заявок на конкурс Imagine Cup этого года. Мне приятно сообщить, что несмотря на несколько снизившуюся нашу активность в регионах в этом году, заявок на конкурс пришло очень много. В этом году по количеству заявок лидирует Москва, затем Санкт-Петербург, Пермь, Волгоград, Екатеринбург; много заявок из Казани, Кемерово, Нижнего Новгорода, Ульяновска и Челябинска.

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

Как участвовать в онлайн-отборе

Для участия в онлайн-отборе вам необходимо подготовить видео-ролик, рассказывающий о проекте, продолжительностью не более 7 минут. Отправить нам все материалы необходимо не позднее 26 марта 2017 г., заполнив онлайн-форму.

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

• Актуальность проблемы и постановку задачи [15%]. Расскажите про целевую аудиторию, с какими проблемами она сталкивается, и как вы решаете эти проблемы
• Инновационность решения [20%] – что же нового вы предлагаете. Здесь помогает сравнить ваше решение с другими существующими (конкурентами)
• Технологии [50%] – самый главный пункт в этом году! Будут учитываться, используются ли современные и инновационные технологии (когнитивные сервисы, искусственный интеллект, чат-боты и т.д.), насколько интересна архитектура решения, как используется облако Microsoft Azure, а также насколько привлекательно и профессионально выглядит проект в целом.
• Для того, чтобы оценить этот пункт, ролик обязательно должен содержать живую демонстрацию продукта.
• Обратите внимание, что использование Microsoft Azure в том или ином виде является обязательным требованием конкурса, не забудьте рассказать, как вы используете облако!
• Бизнес-часть и команда [15%] – ваша задача показать, что проект будет развиваться дальше. Для этого полезно понимать, как вы сможете привлечь средства для развития проекта, и как предполагается его монетизировать.

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

Как записать видео-ролик

Для записи видео-ролика мы рекомендуем использовать плагин к Powerpoint под названием Office MIX. Он позволяет записывать и монтировать видеоролик прямо из слайдов Powerpoint, умеет осуществлять захват экрана (это нужно для живой демонстрации продукта), а также записывать и внедрять в слайды видео-поток с веб-камеры, чтобы было видно говорящего. При этом у вас будет возможность переписать каждый слайд до достижения требуемого результата, а потом экспортировать всё ваше выступление как единый видеоролик.

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

На что обратить внимание

Игровые проекты. После мировых побед российских команд в категории игры, традиционно на Imagine Cup подаётся много игровых проектов. Этот год – не исключение, было очень много красивых игр. Но ВАЖНО ПОНЯТЬ, что в этом году игровые проекты оцениваются наряду с остальными проектами по единым критериям, куда не входят такие критерии, как fun, gameplay и другие. Как и другие проекты, игры будут в первую очередь оцениваться по технологиям, поэтому не очень красивая игра, использующая Azure и когнитивные сервисы имеет больше шансов, чем прекрасная и инновационная по геймплею игра, не использующая облака (она скорее всего не пройдет по формальным признакам). Поэтому если ваша игра не победила – не расстраивайтесь, а обязательно участвуйте в других игровых конкурсах, например, GamesJam. Подать туда проект можно до 17 апреля. А подавая ролик к нам, не забудьте сделать акцент на технических аспектах проекта.

Нужна демонстрация и прототип. Imagine Cup – это конкурс проектов, поэтому в видео необходимо показать работающих прототип. Бизнес-проектам, в которых приводится только идея, но нет реализации – рекомендуем подаваться на другие конкурсы.

Технологии важнее всего. Поэтому из отведенных 7 минут говорите 50% о технологиях. Нас интересуют подробности, какие алгоритмы машинного обучения и какие архитектуры нейросетей вы использовали, какова архитектура решения, какие облачные технологии и сервисы. Распределите время презентации в соответствии с важностью критериев оценки, не забыв оставить время на демонстрацию.

Что будет дальше

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

Удачи в подготовке ролика, и мы с нетерпением ждем более подробную информацию о ваших проектах!

Алгоритм построения треугольника таков:

• Задаем координаты трех вершин – аттракторов (x1,y1), (x2,y2) и (x3,y3)
• Выбираем некоторую точку (x,y) внутри треугольника
• Повторяем много раз:
  • Ставим точку с координатами (x,y)
  • Выбираем случайным образом одну из вершин (xi,yi)
  • Вычисляем координаты новой точки по формуле ((x+xi)/2,(y+yi)/2)

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

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

let sierpinski (p1,p2,p3) =
   let rec sierpinski' pt =
      seq {
        let p = pick [p1;p2;p3]
        let pt' = mid pt p
        yield pt'
        yield! sierpinski' pt'
      }
   sierpinski' (mid3 p1 p2 p3)

В этом определении мы используем вспомогательную вложенную рекурсивную функцию sierpinski’, которая в качестве аргумента передает координаты текущей точки pt. Координаты вершин p1,p2,p3 в данном случае являются внешними по отношению к этой функции. Далее мы выбираем одну из вершин случайным образом, вычисляем координаты очередной точки, “возвращаем” (с помощью yield) эти координаты, и затем рекурсивно возвращаем бесконечный остаток списка, который получается из рекурсивного вызова. Затем чтобы сформировать результат мы вызываем sierpinsky’, передавая ему в качестве начальной точки среднюю точку, вычисленную из координат вершин.

Для вычисления средних точек мы определим следующие вспомогательные функции:

let mid (x1,y1) (x2,y2) = (x1+x2)/2,(y1+y2)/2 
let mid3 (x1,y1) (x2,y2) (x3,y3) = (x1+x2+x3)/3,(y1+y2+y3)/2

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

let Rnd = new Random()
let pick (L:'t list) = L.[Rnd.Next(0,Seq.length L)]

В завершение остаётся лишь построить полученный треугольник. Для этого можем использовать стандартную библиотеку FSharp.Charting:

sierpinski ((0,0),(300,600),(600,0)) 
   |> Seq.take 5000 
   |> Chart.FastPoint

Вот какой получился результат:

Весь исходный код можно найти тут: http://fssnip.net/ta

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

Что такое Windows Remote Arduino

Windows Remote Arduino – это библиотека WinRT, которая позволяет управлять цифровыми и аналоговыми каналами платы Arduino из Windows/Windows Phone приложения, с помощью привычных команд типа digitalRead/Write и analogRead/Write. При этом сама плата может быть подключена к компьютеру по USB или Bluetooth – важно, чтобы обеспечивался последовательный канал передачи данных. Помимо простых команд включения/выключения входов/выходов, в том или ином виде предусмотрена работа с шиной I2C и (в перспективе) сервоприводами.

Для работы необходимо, чтобы на плате Arduino была запущена специальная программа, поддерживающая выполнение команд по протоколу Firmata, а библиотека Windows Remote Arduino обменивается командами с платой, предоставляя программисту высокоуровневые функции управления.

Библиотеки Windows Remote Arduino доступны для Windows 8.1/Windows Phone 8.1 и для универсальных приложений Windows 10. Чтобы использовать их в своем проекте, в настоящее время проще всего клонировать Git-репозиторий проекта и добавить необходимые проекты в своё решение (пример я опишу ниже).

Пример – включатель лампочки

В моём примере я буду разрабатывать интеллектуальное приложение, включающее настольную лампу. Для этой цели я использую плату Arduino Uno и реле, способное коммутировать 220В. Реле подключается к какому-нибудь цифровому выходу (например, 7). Также для обнаружения присутствия человека будем использовать инфракрасный датчик присутствия, который включим в аналоговый вход A0. Для удобства коммутации мы используем Troyka Shiled от Амперки.

На приведенном ниже видео смотрите подробнее про hardware setup, а также весь проект в действиии.

Устанавливаем скетч Firmata на плату Arduino

Первым делом необходимо установить на плату Arduino стандартный скетч для выполнения команд Firmata. Такой скетч уже включен в стандартную поставку Arduino IDE – достаточно выбрать в меню File –> Examples –> Firmata –> Standard Firmata. Открывшийся при этом скетч необходимо загрузить в плату обычным образом.

На этом этапе полезно будет убедиться, что все аппаратное обеспечение настроено правильно. Для этого можно использовать специальную программу firmata_test.exe (или любую из программ, описанных здесь) – вы должны быть в состоянии управлять лампочкой, переключая состояние цифрового выхода 7, а также на входе A0 вы должны получать значение 0, если движения вокруг сенсора нет, и большое положительное значение (около 600 и более) в противном случае.

Готовим проект с Windows Remote Ardunio

Чтобы использовать Windows Remote Arduino в своём проекте, необходимо подключить соответствующие библиотеки. На текущий момент технология достаточно молодая, и библиотеки существуют в виде исходных текстов. Мы надеемся, что со временем появятся пакеты NuGet, сейчас же процесс включения библиотек выглядит следующим образом:

1. Создадим новый проект – в нашем случае это будет универсальное приложение Windows 10

2. Клонируйте GitHub-репозиторий проекта Windows Remote Arduino в какую-нибудь локальную папку:

git clone https://github.com/ms-iot/remote-wiring/

ВАЖНО: в репозитории имеются несколько версий библиотеки. На момент написания статьи последняя ветка master содержала много ошибок при работе с аналоговыми и цифровыми входами, поэтому я использовать наиболее стабильную ветку revert-18-develop. Очень надеюсь, что в скором времени выйдет еще более стабильная версия, и клонировать можно будет как показано выше, без указания ветки.

3. В получившемся дереве проектов есть папки Microsoft.Maker.Win10 и Microsoft.Maker.Win8_1. Мы будем использовать вариант для Windows 10, но проект поддерживает и универсальные приложения Windows 8.1

4. В папке Microsoft.Maker.Win10 есть три проекта: Microsoft.Maker.Firmata, Microsoft.Maker.Serial и Microsoft.Maker.RemoteWiring. Эти три проекта нужно добавить в созданный нами проект (Add Existing Project)

5. В результате получится следующее дерево проектов:

6. Чтобы проекты компилировались в правильном порядке, необходимо установить правильные зависимости проектов. Нажмите правой кнопкой на наш проект, выберите “Зависимости сборки –> Зависимости проектов”, и установите галочки напротив всех трех добавленных проектов. Остальные зависимости должны быть уже установлены, но вы можете их проверить: проект Firmata зависит от проекта Serial, проект RemoteWiring – от проектов Firmata и Serial. Соответственно, на вкладке “Порядок сборки” проекты должны собираться в таком порядке: Serial, Firmata, RemoteWiring и наше приложение.

7. В нашем основном проекте правой кнопкой нажмите на References и добавьте расширение Microsoft Visual C++ AppLocal Runtime Package for Windows UAP. Там же в пункте “Общие проекты” выберите все три добавленных проекта Windows Remote Arduino.

8. ВАЖНО: Чтобы наше приложение могло использовать возможности работы с последовательным портом, необходимо в манифест приложения (файл Package.appxmanifest) в раздел <Capabilities> добавить следующий код:

<DeviceCapability Name="serialcommunication">
   <Device Id="any">
      <Function Type="name:serialPort"/>
   </Device>
</DeviceCapability>

9. Мы готовы к созданию нашего приложения, которое будет использовать библиотеки Windows Remote Arduino! Чтобы убедиться, что всё работает правильно, попробуйте выполнить сборку получившегося приложения.

Создаем приложение с Windows Remote Arduino

Наше приложение будет иметь три кнопки: для включения лампочки, для выключения, и для авто-режима, в котором лампочка будет управляться датчиком присутствия. Для начала добавим на главную страницу приложения MainPage.xaml эти три кнопки, установив их в неактивное состояние:

<StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Center">

    <Button x:Name="on" IsEnabled="False" Content="ON" FontSize="30" Width="150" Height="150" Click="on_Click"></Button>

    <Button x:Name="off" IsEnabled="False" Content="OFF" FontSize="30" Width="150" Height="150" Click="off_Click"></Button>

    <Button x:Name="auto" IsEnabled="False" Content="AUTO" FontSize="30" Width="150" Height="150" Click="auto_Click" ></Button>

</StackPanel>

Этот код добавляется внутрь того контейнера Grid, который уже по умолчанию есть у страницы. Также для каждой кнопки создадим функцию-обработчик на C# (кликнув дважды на каждую кнопку, или через окно свойств Visual Studio).

Для начала инициализируем объект Remote Arduino. Для этого в классе окна в файле MainPage.xaml.cs опишем две переменные

UsbSerial usbcomm;

RemoteDevice arduino;

Для подключение к Arduino опишем функцию connect(), которую затем вызовем из конструктора MainPage():

private async void connect()

{

    var dev = await UsbSerial.listAvailableDevicesAsync();

    usbcomm = new UsbSerial(dev[0]);

    arduino = new RemoteDevice(usbcomm);

    usbcomm.ConnectionEstablished += Comm_ConnectionEstablished;

    usbcomm.begin(57600, SerialConfig.SERIAL_8N1);

}

Здесь мы сначала определяем список доступных портов, куда может быть подключен Arduino, затем создаем последовательное соединение UsbSerial с этим портом, а затем поверх этого – объект RemoteDevice, который будет представлять собой виртуальный Arduino. После этого мы вызываем функцию begin, передавая параметры последовательного соединения.

ВАЖНО: Скорость последовательного канала, используемая протоколом Firmatа, задается в скетче StandardFirmata. По умолчанию она равна 57600, поэтому мы выбираем именно эту скорость в нашем приложении. Если скорости не будут совпадать, то соединение не будет работать.

При установлении соединения с платой, будет вызвана функция Comm_ConnectionEstablished, которую мы опишем следующим образом:

private void Comm_ConnectionEstablished()

{

    Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,new Windows.UI.Core.DispatchedHandler(() =>

    {

        arduino.pinMode(14, PinMode.ANALOG);

        arduino.pinMode(relay_pin, PinMode.OUTPUT);

        dt = new DispatcherTimer() { Interval = new TimeSpan(500) };

        dt.Tick += loop;

        dt.Start();

        on.IsEnabled = true;

        off.IsEnabled = true;

        auto.IsEnabled = true;

    }));

}

Основной код функции обернут в вызов диспетчера, который запускает его в потоке UI – это важно. Далее мы устанавливаем режимы основных используемых пинов Arduino, создаем таймер, который будет вызывать каждые пол-секунды функцию loop(), а также делаем кнопки видимыми.

Интересный момент – установка порта 14 в аналоговый режим. Дело в том, что аналоговые входы в Arduino нумеруются после цифровых, и входу A0 соответствует номер 14. Режим необходимо установить именно ANALOG, а не INPUT, который означает цифровой ввод.

Теперь для включения/выключения лампочки достаточно описать функции-обработчики событий кнопок следующим образом:

private void on_Click(object sender, RoutedEventArgs e)

{

    auto_mode = false;

    arduino.digitalWrite(relay_pin, PinState.HIGH);

}

Функция off_Click делается по аналогии. Обратите внимание, что для работы с пинами удалённой платы Arduino используются привычные команды типа digitalRead/digitalWrite.

Переменная auto_mode – это переменная типа bool, которую нужно описать в нашем классе. Она нужна для того, чтобы обрабатывать автоматический режим. Кнопка AUTO будет устанавливать эту переменную в true:

private void auto_Click(object sender, RoutedEventArgs e)

{

    auto_mode = true;

}

Теперь дело осталось за малым – реализовать функцию loop, которая будет переключать лампу в зависимости от наличия сигнала с датчика присутствия. Делать это надо только в том случае, если auto_mode установлен:

private void loop(object sender, object e)

{

    if (auto_mode)

    {

        arduino.pinMode(14, PinMode.ANALOG);

        var on = arduino.analogRead(0) > 512;

        arduino.digitalWrite(relay_pin, on ? PinState.HIGH : PinState.LOW);

    }

}

ВАЖНО

: Для более надежной работы прямо перед чтением порта лучше еще раз установить его режим в аналоговый. Так быть не должно, но на практике это улучшает стабильность. Также обратите внимание, что мы используем analogRead(0), хотя строчкой ранее указывали номер порта 14. В analogRead передается номер порта от 0 до 5, при установке режима порта надо прибавить к этим номерам 14.

Как подключить Arduino по Bluetooth и управлять со смартфона

В нашем случае мы написали универсальное приложение, которое можем разместить на Windows Phone 10. Однако это бесполезно, поскольку подключить плату Arduino по USB к смартфону невозможно. Однако если мы будем использовать Bluetooth вместо USB-соединения, подключив к Arduino bluetooth-плату, то мы сможем этим же приложением управлять нашей конструкцией со смартфона. В этом случае в манифест приложения необходимо добавить следующие строчки для разрешения коммуникации по Bluetooth:

<DeviceCapability Name="bluetooth.rfcomm">
  <Device Id="any">
    <Function Type="name:serialPort"/>
  </Device>
</DeviceCapability>

Мы не будем сейчас рассматривать использование bluetooth – это тема для отдельной статьи. Однако заметим, что с точки зрения программирования разницы почти нет – надо использовать объект BluetoothSerial вместо UsbSerial, а все остальные конструкции остаются без изменений.

Где взять исходный код

Исходный код моего проекта по традиции доступен на GitHub:

https://github.com/evangelism/RemoteArduinoLamp/tree/v1.0-serial

Пожалуйста, берите его, экспериментируйте, если найдете ошибки – делайте pull requests.

Выводы

Windows Remote Arduino – достаточно молодая и сырая технология, но уже сейчас она может упростить решения ряда задач, в которых необходимо напрямую управлять входами/выходами платы Arduino, подключенной к компьютеру. Конечно, всё тоже самое можно запрограммировать вручную, написав свой скетч и используя последовательный канал для взаимодействия с ним, но почему бы не использовать уже готовые наработки и сложившиеся стандарты (Firmata), чтобы не изобретать велосипеды.

Я надеюсь, вы будете использовать Windows Remote Arduino в своих проектах, и если вы сделаете что-то интересное – мне будет приятно об этом узнать! Пишите в комментариях, в твиттере или вконтакте!

Самое главное, что следует из этого объявления – Microsoft понимает важность платформы Arduino и будет предпринимать усилия, чтобы соответствующие устройства хорошо взаимодействовали с устройствами на Windows 10. Представьте себе мир, в котором внешние электронные устройства на базе Arduino являются продолжением аппаратного обеспечения компьютера, работающего под управлением Windows 10, и доступны из стандартных универсальных приложений с помощью соответствующих расширений. Это позволит оптимальным образом сочетать вычислительную мощность традиционных компьютеров и облака с потенциалом микроконтроллеров по управлению устройствами, создавая целостные решения в области интернета вещей.

В рамках текущих анонсов было объявлено о доступности двух технологий:

• Windows Remote Arduino – это технология, которая позволяет управлять платой Arduino, подключенной по USB или Bluetooth, из универсального приложения, как если бы её порты ввода-вывода были доступны локально. Разработчику универсального приложения становятся доступны основные команды по работе с аналоговыми и цифровыми портами, что позволяет напрямую работать с рядом датчиков. Для взаимодействия Arduino с компьютером используется протокол Firmata, а на плате запускается специальный Firmata Sketch, выполняющий приходящие от удаленного компьютера команды. Проект доступен для Windows 8.1 и Windows 10 в виде исходных текстов на GitHub.
• Windows Virtual Shield for Arduino позволяет использовать смартфон под управлением Windows Phone 10 в качестве виртуальной платы расширения для Arduino. При этом смартфон может использоваться как текстовый экран, как гироскоп/акселерометр/GPS, в качестве распознавателя речи и т.д. Вы получаете простой доступ ко всем этим возможностям прямо из своего Arduino Sketch. В качестве примера можно посмотреть на проект Picture the Weather.

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

В новом мире многие инновации делаются энтузиастами, которые любят собирать что-то своими руками – в английском языке для этого есть прекрасное слово maker. Понимая важность такого сообщества для будущих инноваций в IoT, Microsoft также объявила о партнерстве с популярным порталом Hackster.IO, на котором теперь будут представлены многие официальные примеры разработок для Windows IoT.

Если же говорить про промышленный интернет вещей, то здесь важной задачей является построение инфраструктуры для взаимодействия сети устройств между собой и с клиентами. Одной из таких платформ межмашинного взаимодействия является DeviceHive от компании DataArt. В результате партнерства компании с Microsoft теперь можно легко разворачивать DeviceHive в облаке прямо из магазина Azure Marketplace, что существенно упрощает создания облачных решений для интернета вещей.

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

Для соединения Arduino с Raspberry Pi существует несколько сценариев подключения:

• Использование явного последовательного канала передачи данных. При этом возникают сложности, связанные с разностью уровней питания: Raspberry Pi работает на напряжении 3.3В, в то время как Arduino использует 5 вольт. При этом для обеспечения безопасного соединения рекомендуется использовать специальные преобразователи уровня.
• Использование последовательной шины I2C, что позволяет подключать к одной Raspberry Pi до 128 устройств Arduino в режиме slave, при этом такое подключение также не требует преобразователей уровня.
• Подключение по USB является пожалуй самым простым способом, поскольку для этого достаточно всего лишь воткнуть Arduino через стандартный кабель в USB-разъем Raspberry Pi. Именно этот способ мы и рассмотрим.

В качестве примера рассмотрим простейший датчик температуры и давления BMP-180, подключенный к Arduino Uno по стандартной схеме. После этого контроллер Arduino включается в USB-разъем Raspberry Pi, а сам Raspberry Pi затем подключается обычным образом к питанию, монитору и т.д.

При таком подключении общение Arduino и Raspberry происходит по последовательному порту. Предварительно (до подключения) на Arduino необходимо залить требуемый скетч – в нашем случае это простая программа, считывающая значение давления и температуры с датчика и печатающая их в виде текста в последовательный канал (температура предваряется символом Т, а давление – P):

#include <Wire.h>
#include <BMP180.h>

BMP180 barometer;

void setup()
{
  Serial.begin(9600);
  Wire.begin();
  barometer = BMP180();
  if(barometer.EnsureConnected())
  {
    barometer.SoftReset();
    barometer.Initialize();
  }
  else
  { 
    Serial.println("E");
  }
}

void loop()
{
  if(barometer.IsConnected)
  {
    long pres = barometer.GetPressure();
    float temp = barometer.GetTemperature();
    Serial.print("P"); Serial.println(pres);
    Serial.print("T"); Serial.println(temp);
    delay(1000);
  }
}

Проверим работоспособность скетча в Arduino IDE, открыв монитор последовательного порта – мы должны увидеть появляющиеся значения температуры и давления. Обратите внимание на скорость – в программе задана скорость в 9600 бод, такие же установки должны быть и у монитора последовательного порта.

Теперь загрузим Raspberry Pi – в моем примере я использую Pidora в качестве базовой операционной системы и классическую модель Rapsberry Pi, хотя с таким же успехом можно использовать Raspberry Pi 2 и Windows 10.

Первым делом нужно определить, какой последовательный порт будет отвечать за общение с Arduino-контроллером. Проще всего это сделать следующим образом: при выключенной плате Arduino смотрим все доступные последовательные терминалы (ls /dev/tty*), после чего включаем плату в USB-порт, и через некоторое время снова смотрим список терминалов. То устройство, которое появилось в списке, и будет требуемым портом. В моём случае это был /dev/ttyUSB0, но в зависимости от номера порта, используемого дистрибутива системы и других факторов это имя может сильно отличаться.

Теперь мы можем использовать любые средства общения с последовательным портом для того, чтобы принять значения от датчика, передаваемые Arduino. Чаще всего удобным оказывается использовать Python и библиотеку serial. Например, следующий простой скрипт, набранный прямо в REPL, будет отображать на экране все данные, приходящие в последовательный порт:

import serial
ser = serial.Serial("/dev/ttyUSB0",9600)
while 1:
   ser.readline()

Ниже показано, как этот скрипт выполняется в окне терминала на Raspberry Pi:

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

Использованию информационных технологиях применительно к развитию детей посвящен мой новый курс на Microsoft Virtual Academy, под кодовым названием “Как научить ребенка программировать”. На самом деле речь пойдет не только о программировании – в этом курсе я постарался описать известные мне технологии Майкрософт, которые могут вдохновить ребенка на творчество.

Этот курс предназначен для родителей, которые ищут различные способы занять своих детей творчеством. Мы видим, что дети с удовольствием берут в руки компьютер, и важно дать им правильные творческие инструменты, чтобы они воспринимали компьютер не как поставщика развлекательного контента (наравне с телевизором), а как инструмент для творчества. На самом деле детям нравится творить (этим в основном объясняется популярность Minecraft), и важно направить их в правильное русло.

Среди технологий, о которых рассказывается в курсе – технологии для исследования мира (Bing Maps, Worldwide Telescope), для коллективного творчества (Photosynth, Image Composite Editor и др.). Я также уделяю особое внимание вопросу мотивации детей, и рассказываю о своем опыте работы с детскими коллективами как преподавателя детского лагеря ЮНИО-Р, одного из идеологов часа кода в России и детского трека Microsoft AppDay, лектора и ведущего мастер-классов в Компьютерии.

Особое внимание конечно уделяется именно обучению программированию. На мой взгляд, важнее всего увлечь ребенка на первых этапах процесса, поэтому предлагается использовать инструменты быстрого создания игровых миров Kodu Game Lab и Project Spark. Ну а потом уже подключаются различные “традиционные” инструменты – от увлекательного введения в C#, до возможного пути Small Basic –> Visual Basic и функционального программирования на F#.

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

Надеюсь, этот курс будет полезен и интересен – по крайней мере об интересе к этой теме говорят полные залы на моих докладах на конференциях DevCon и ряде других. Приятного просмотра!

Завтра в подмосковном курорте Яхонты начнется крупнейшая в России конференция для разработчиков по технологиям Майкрософт – Microsoft DevCon. Но наша команда евангелистов уже сегодня присутствует на мероприятии и активно готовиться поразить всех слушателей завтра самыми искрометными и интересными докладами. А для тех, кто не сможет присутствовать лично – смотрите онлайн-трансляцию на сайте конференции.

• Используется достаточно редкий контроллер NetDuino 2 Plus – было бы здорово перейти с него на более классический и недорогой Arduino
• Передача данных в сеть идет по незащищенному каналу связи HTTP – в реальных задачах разумнее использовать HTTPS, чтобы а значит для отправки данных необходим более мощный процессор, чем в Arduino
• Предложенный подход с веб-сервисом не всегда способен принять большой поток данных, поэтому если мы хотим поддерживать множество аналогичных погодных станций – необходимо использовать специальные облачные механизмы для интернета вещей, такие как концентраторы событий (Event Hub).

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

Аппаратная сторона

Итак, для отправки HTTPS-запросов и для работы с продвинутыми сервисами Azure нам необходим более мощный процессор, чем в Arduino – при этом Arduino по-прежнему остаётся стандартом де-факто для подключения различных датчиков. Поэтому обычно используют в том или ином виде комбинацию Arduino с более мощным микрокомпьютером, обычно работающим под управлением какой-то операционной системы:

• Связка Raspberry Pi + Arduino. Raspberry Pi представляет собой недорогой одноплатный контроллер стоимостью около $35, на котором могут работать как разные версии UNIX, так и Windows 10. В случае простых датчиков – их можно подключить прямо к Raspberry Pi, но обычно используют Arduino, которое может быть связано с Raspberry Pi по последовательному каналу либо через USB (самый простой способ), либо напрямую или по интерфейсу I2C. Преимуществом Raspberry Pi является то, что можно использовать достаточно мощную операционную систему и производить на плате не только передачу данных, но и осмысленную пред-обработку и принятие решений.
• Arduino Yun представляет собой одну плату, на которой по сути совмещена функциональность классического Arduino Uno и микрокомпьютера под управлением специальной версии Linux – OpenWrt. С точки зрения программирования такая связка очень похожа на рассмотренный выше вариант с Raspberry Pi, но при этом мы имеем одну плату (правда, с чуть менее функциональной ОС).
• Intel Gallileo или Edison – это компактные платы на основе процессоров x86, которые аппаратно совместимы с Arduino, при этом работают под управлением полноценной ОС типа Unix (или даже Windows). Можно работать со всеми аппаратными возможностями этих плат непосредственно из уровня ОС (например, используя Python и библиотеку Wiring x86 – пример такого скрипта смотрите тут, при этом такой же скрипт может отправлять данные в облако), либо с помощью эмулятора Arduino – в этом случае аппаратная часть программируется стандартным способом как Arduino Sketch в Arduino IDE, и затем связывается с базовой ОС через вызов system для отправки данных (пример смотрите тут).
• Конечно, можно еще использовать полноценный персональный компьютер с подключенным Arduino, но такой способ мы не будем рассматривать ввиду его простоты и экономической неэффективности.

Программная часть

Для отправки потоковых данных с датчиков в облако рекомендуется использовать технологию концентраторов событий. Если вы используете в качестве базового микрокомпьютера Raspberry Pi, Arduino Yun или Intel Galileo, то удобнее всего будет разрабатывать на Python. Для этого установите свежую версию Azure SDK for Python, в котором есть API для работы с Event Hub. Более подробный пример работы (с использованием более старого API) приведен тут, документация по функциям работы с Event Hub – тут, а я постараюсь в ближайшее время также описать этот процесс на русском языке.

Проект Connect-the-Dots

Проект Connect-the-Dots – это проект Microsoft Open Technologies с открытым исходным кодом, который показывает разные сценарии использования сенсоров для сбора данных в облаке с использованием Event Hub. Он по сути дела представляет собой реализацию тех принципов, о которых я написал выше – использование достаточно производительных контроллеров для отправки потоковых данных в Azure Event Hub.

В качестве сценариев поддерживается прямая отсылка данных в облако (с Intel Galileo или плат на основе .NET MicroFramework), или же использование шлюза на базе Raspberry Pi и конечных устройств на Arduino Uno, а также возможность использовать Windows Phone как прямой источник данных (освещенность, акселерометр и т.д.).

Проект Connect-the-Dots хорошо использовать как отправную точку для своих масштабных проектов, связанных с интернетом вещей. Более скромные проекты, возможно, имеет смысл делать с меньшим размахом – про это я буду писать в своих следующих заметках.

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

Две составляющие интернета вещей

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

• Компактные клиентские устройства, подключенные к сети. С этой стороны процесс бурно развивается благодаря наличию недорогих микроконтроллеров, начиная от Arduino (который можно легко программировать на Visual Studio), и заканчивая экзотическими контроллерами, программируемыми на JavaScript.
• Развитие облачных технологий, которые позволяют накапливать в облаке большие объемы данных и производить их анализ и обработку. С этой точки зрения очень интересно использование AzureML.

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

Архитектура облачной погодной станции

В соответствии с таким пониманием интернета вещей мы и спроектируем нашу погодную станцию. Роль конечного устройства будет выполнять датчик температуры и освещенности (зачем нужно мерить освещенность – я расскажу в отдельном посте), подключенный к интернет с помощью замечательного контроллера NetDuino Plus 2, а облачный сервис будет реализован на Microsoft Azure. Также мы будем получать сведения о текущей температуре из погодного сервиса OpenWeatherMap, чтобы сравнивать наши измерения с данным прогноза погоды.

Архитектура облачного сервиса

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

• Хранилище данных. Нам важно сразу выбрать правильную архитектуру для хранения данных: полноценная база данных SQL, полуструктурированные Azure Storage или же решение типа NoSQL. В нашем случае проще всего было бы использовать SQL Azure, поскольку объем данных не очень велик – но мы предпочтем в образовательных целях использовать Azure Table Storage, истинное облачное хранилище, которое может потенциально сильно масштабироваться. Ценой такого решения будет то, что мы не сможем использовать достаточно богатые конструкции запросов к данным, что немного усложнит реализацию.
• Веб-интерфейс, который будет отображать пользователю графики температуры, давления, освещенности и т.д. Я буду использовать ASP.NET Web Forms как самую простую технологию, однако на практике для повышения производительности конечно стоит рассмотреть ASP.NET MVC.
• Веб-сервис для регистрации температуры, а также для передачи данных мобильному приложению. Используем замечательную технологию Web API, которую можно развернуть параллельно с веб-интерфейсом на ASP.NET (ниже расскажем, как).
• Постоянно работающий процесс Worker Role, которые будет периодически собирать данные из сервиса OpenWeatherMap и сохранять в нашем хранилище.

Создание проекта в Visual Studio

Для начала создадим проект в Visual Studio (я буду использовать Visual Studio 2015). Если вы не хотите создавать проект сами, а лишь поэкспериментировать, то используйте готовый код проекта, доступный на GitHub: версию, описанную в статье, или последнюю версию.

Начнем с создания облачного сервиса, которые будет содержать в себе Web Role и Worker Role. Для работы с облачными проектами и инструментами вам потребуется установить Windows Azure SDK.

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

При создании веб-составляющей WeatherMonitorWeb нас попросят выбрать стек технологий ASP.NET – в нашем случае я использовал ASP.NET Web Forms. Если кто-то поможет переписать этот проект на ASP.NET MVC – я буду признателен! Используйте pull request для исходного кода проекта на GitHub.

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

Организация доступа к данным

Данные о погоде будут хранится в табличном хранилище Microsoft Azure. Мы можем использовать встроенное хранилище, создаваемое в рамках облачной службы, или настроить отдельное хранилище, доступ к которому будет осуществляться из разных служб. Создадим отдельное хранилище – для этого в портале Microsoft Azure выберем следующий пункт:

При создании хранилища стоит использовать разумные опции (в зависимости от требований к надежности – выбирать реплицированное или локальное хранилище). После создания службы данных (мы назовём её weathermon) в меню “управление ключами” (внизу страницы) будут доступны ключи, которые потребуются нам позднее для доступа к данным.

Табличное хранилище позволяет хранить множество пар атрибут-значение на множестве распределенных серверов. Для удобства мы будем использовать Azure Storage SDK, который входит в состав Azure SDK. Необходимо добавить в проект ссылку (Reference) на WindowsAzure.Storage, либо использовать NuGet (install-package WindowsAzure.Storage).

Storage SDK позволит нам автоматически помещать в хранилище объекты, унаследованные от TableEntity – при этом сам SDK позаботится о том, как они будут преобразованы к атрибутам. Запрашивать данные из хранилища мы сможем с помощью простых и привычных LINQ-запросов, получая в результате коллекции объектов.

Для начала опишем класс для хранения одного измерения:

public enum WeatherInfoSource { WeatherService, Device };
public enum ReadingType { Temperature, Humidity, Pressure, Luminocity };

public class WeatherRecord : TableEntity
{

    public WeatherRecord(DateTime When, double Reading, WeatherInfoSource src, ReadingType type)
    {
        this.Reading = Reading;
        this.WeatherInfoSource = src;
        this.When = When;
        this.ReadingType = type;
        PartitionKey = string.Format("{0}.{1}", When.Year, When.Month);
        RowKey = string.Format("{0}-{1}:{2}.{3}.{4},{5}:{6}", src, type, When.Year, When.Month, When.Day, When.Hour, When.Minute);
    }

    public WeatherRecord() { }

    public DateTime When { get; set; }

    public int iWeatherInfoSource
    {
        get; set;
    }
    public WeatherInfoSource WeatherInfoSource
    {
        get { return (WeatherInfoSource)iWeatherInfoSource; }
        set { iWeatherInfoSource = (int)value; }
    }

    public int iReadingType { get; set; }

    public ReadingType ReadingType
    {
        get { return (ReadingType)iReadingType; }
        set { iReadingType = (int)value; }
    }
    public double Reading { get; set; } 

}

Основные поля в этом классе:

• WeatherInfoSource - показывает, взято ли измерение из погодного сервиса или из погодной станции
• ReadingType - описывает тип измерения: температура, давление, влажность, освещенность
• Reading – само значение измерения
• When – время проведения измерения

В этом классе есть две важные тонкости:

• Мы не можем хранить в TableEntity данные не-примитивных типов. Поэтому вместо публично доступных свойств WeatherInfoSource и ReadingType перечислимого типа, мы описываем поля iReadingType и iWeatherInfoSource типа int, а WeatherInfoSource/ReadingType делаем свойствами, которые скрывают в себе операции преобразования типов
• Поля PartitionKey и RowKey определяют, как данные будут распределяться по серверам в случае значительных объемов. Все объекты с одним PartitionKey хранятся вместе. В нашем случае мы будем хранить вместе все данные за одни месяц, т.к. нам их в дальнейшем может понадобится агрегировать. Правильный выбор PartitionKey/RowKey определяет архитектуру распределенного хранения данных, и может сильно влиять на производительность.

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

static CloudStorageAccount CloudStore;
static CloudTableClient CloudTable;
public static CloudTable Table;

static WeatherDB()
{
    string str = "DefaultEndpointsProtocol=http;AccountName=weathermon;AccountKey=...";
    CloudStore = CloudStorageAccount.Parse(str);
    CloudTable = CloudStore.CreateCloudTableClient();
    Table = CloudTable.GetTableReference("WeatherRecord");
    Table.CreateIfNotExists();
}

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

Для помещения объекта в таблицу используем следующий метод:

public static async void Record(ReadingType t, WeatherInfoSource src, double x)
{
    var rd = new WeatherRecord(CurrentDateTime, x, src, t);
    await Table.ExecuteAsync(TableOperation.Insert(rd));
}

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

public static IEnumerable<WeatherRecord> GetData()
{
    var q = new TableQuery<WeatherRecord>();
    return WeatherDB.Table.ExecuteQuery(q);
}

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

public static WeatherRecord[] GetCurrentReading(ReadingType type)
{
    var data = (from z in WeatherDB.Table.CreateQuery<WeatherRecord>()
               where z.When > DateTime.Now.AddMinutes(-10)
               // where z.ReadingType == type
               select z).ToList();
    var res = from z in data
              where z.ReadingType == type
              group z by z.WeatherInfoSource into g
              select g.OrderByDescending(x => x.When).First();
    return res.ToArray();
}

Этот метод устроен достаточно хитро. Проблема в том, что мы не можем использовать функции сортировки данных на сервере, поскольку данные возможно распределены по серверам. В первом LINQ-запросе, который выполняется на сервере, нам доступны только очень простые операции. Поэтому вначале мы выбираем из таблицы в память все данные за последние 10 минут – чтобы уменьшить размер обрабатываемых данных. При этом мы даже не может отфильтровать их по ReadingType – соответствующая строчка закомментарена.

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

Worker Role для доступа к погодному сервису

Теперь запрограммируем Worker Role, который будет обращаться к погодному сервису и раз в 10 минут считывать значение погодных параметров. Для этого нам нужно будет зарегистрироваться в сервисе OpenWeatherMap и получить оттуда API Key для нашего приложения. Для доступа к OpenWeatherMap из нашего сервиса будем использовать библиотеку OpenWeatherMapClient.

Worker Role – это процесс, который запускается в облаке и всё время работает. Основной его функционал описывается одним классом, а главная функция – это асинхронная функция RunAsync:

private async Task RunAsync(CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        var Weather = await WeatherClient.CurrentWeather.GetByName(TargetCity,MetricSystem.Metric);
        WeatherDB.Record(ReadingType.Temperature, WeatherInfoSource.WeatherService, Weather.Temperature.Value);
        WeatherDB.Record(ReadingType.Pressure, WeatherInfoSource.WeatherService, Weather.Pressure.Value);
        WeatherDB.Record(ReadingType.Humidity, WeatherInfoSource.WeatherService, Weather.Humidity.Value);
        await Task.Delay(1000*60*NumMinutes);
    }
}

В ней всё очень просто: считываем текущую погоду через OpenWeatherMapClient, а потом вызываем описанные ранее функции для записи данных в хранилище. Обратите внимание, что поскольку функция асинхронная – она может спокойно “засыпать” на длительное время с помощью Task.Delay, освобождая процессорное время для других задач. Кроме того, в асинхронной функции можно удобно вызывать другие асинхронные методы – как это мы делаем с вызовом API OpenWeatherMap. Пока производится удалённый вызов, наш сервис также находится в состоянии спокойного ожидания.

Нам осталось в методе OnStart() инициализировать все необходимые переменные, в т.ч. параметры: название города и периодичность выполнения в минутах:

TargetCity = CloudConfigurationManager.GetSetting("City");
WeatherClient = new OpenWeatherMapClient("...OpenWeatherMapAPIKey...");
NumMinutes = int.Parse(CloudConfigurationManager.GetSetting("NumMinutes"));

Чтобы мы могли использовать CloudConfigurationManager.GetSetting, нам надо прописать соответствующие параметры в конфигурации нашего облачного сервиса. Идем в основной раздел решения в Visual Studio, отвечающий за облачный сервис (WeatherMonitor), выбираем WeatherMonitorWorker, и в разделе “параметры” добавляем два параметра NumMinutes и City типа string.

Всегда когда возможно стоит использовать такой способ конфигурации сервисов, поскольку соответствующие значения можно будет менять как из интерфейса Visual Studio, так и из портала Windows Azure. Это очень удобно!

Теперь уже можно запустить наше приложение и проверить его в работе! Убедится, что данные записываются в хранилище, можно с использованием очень удобного инструмента Azure Storage Explorer.

Отображение данных на веб-портале

У нашего приложения также есть веб-составляющая WeatherMonitorWeb. Это приложение ASP.NET Web Forms, в которое на главную страницу мы добавим элемент управления Chart Control для отображения графика измерений, и пару элементов управления для выбора параметров:

    <asp:Chart ID="MainChart" runat="server" Height="600" Width="800">
        <series>
            <asp:Series Name="MainSeries" ChartArea="MainChartArea" ChartType="Line" Color="Black"/>
            <asp:Series Name="RealSeries" ChartArea="MainChartArea" ChartType="Point" Color="Red" />
        </series>
        <chartareas>
            <asp:ChartArea Name="MainChartArea" />
        </chartareas>
    </asp:Chart>
<br /><br />
<asp:DropDownList runat="server" AutoPostBack="True" ID="ddDispType">
    <asp:ListItem Value="Temperature" />
    <asp:ListItem Value="Pressure" />
    <asp:ListItem Value="Humidity" />
    <asp:ListItem Value="Luminocity" />
</asp:DropDownList>
<asp:DropDownList runat="server" AutoPostBack="True" ID="ddTimePeriod">
    <asp:ListItem Value="Day" />
    <asp:ListItem Value="Week" />
    <asp:ListItem Value="Month" />
    <asp:ListItem Value="Year" />
</asp:DropDownList>

Здесь в Chart Control мы накладываем друг на друга два графика: реальные результаты измерений (которые мы научимся измерять чуть позже), и сохраненные нами значения из погодного сервиса.

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

ReadingType t = ReadingType.Temperature;
DateTime fr = DateTime.Now.AddYears(-1);
switch (ddTimePeriod.SelectedValue)
{
    case "Day":
        fr = DateTime.Now.AddDays(-1); break;
    case "Month":
        fr = DateTime.Now.AddMonths(-1); break;
    case "Year":
        fr = DateTime.Now.AddYears(-1); break;
    case "Week":
        fr = DateTime.Now.AddDays(-7); break;
}
switch(ddDispType.SelectedValue)
{
    case "Temperature":
        t = ReadingType.Temperature; break;
    case "Pressure":
        t = ReadingType.Pressure; break;
    case "Humidity":
        t = ReadingType.Humidity; break;
    case "Luminocity":
        t = ReadingType.Luminocity; break;
}

Далее собственно переходим к получению данных и их отображению с помощью DataBinding:

var db = WeatherDB.GetData();
var data = from z in db
            where z.WeatherInfoSource == WeatherInfoSource.WeatherService
            where z.ReadingType == t
            where z.When > fr
            orderby z.When descending
            select new { When = z.When, Data = z.Reading };
MainChart.Series[0].Points.DataBind(data,"When", "Data", "");
var rdata = from z in db
               where z.WeatherInfoSource == WeatherInfoSource.Device
               where z.ReadingType == t
               where z.When > fr
               orderby z.When descending
               select new { When = z.When, Data = z.Reading };
MainChart.Series[1].Points.DataBind(rdata, "When", "Data", "");

Здесь мы используем не очень хороший подход – сначала запрашиваем все данные в память с помощью описанного ранее метода GetData(), а уже потом осуществляем их выборку и сортировку. Оставляю читателю оптимизацию этого кода в качестве самостоятельного упражнения (Pull Requests приветствуются) – это можно сделать, ограничив объем передаваемых данных нужным периодом, как это сделано в функции GetCurrentReading выше.

На этом этапе вы должны быть в состоянии запустить сервис на своём компьютере, дать ему поработать некоторое время, и увидеть график температуры, собранной с OpenWeatherMap. Теперь самое время разместить проект в реальном облаке – для этого выберем облачный сервис WeatherMonitor правой кнопкой и используем “Опубликовать”.

При этом скорее всего у вас возникнут проблемы, связанные с особенностью реализации Chart Control. Дело в том, что этот элемент использует временные файлы в системной директории, которая при облачном развертывании оказывается защищена от записи. Для борьбы с этой проблемой, надо добавить в Web.Config следующие строчки конфигурации:

<configuration>
  <appSettings>
    <add key="ChartImageHandler" value="storage=session;timeout=20;" />

Создаем сервис WebAPI

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

Первым делом, в файл Global.asax.cs необходимо добавить следующий код настройки маршрутизации, выполняемый при запуске приложения:

void Application_Start(object sender, EventArgs e)
{
    RouteTable.Routes.MapHttpRoute(
        name: "DefaultApi",
        routeTemplate: "api/{controller}/{id}",
        defaults: new { id = System.Web.Http.RouteParameter.Optional });
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
}

Теперь для того чтобы создать API по записи температуры, нам надо создать класс контроллера TemperatureController.cs – проще всего это сделать через добавление в проект класса Web API:

Контроллер позволяет определять методы, которые будут вызываться при получении GET или POST-запросов по адресам типа /api/temperature или /api/temperature/13. Например, для записи температуры в базу по GET-запросу, переопределим следующий метод:

// GET api/<controller>/5
public async Task<string> Get(int id)
{
    await WeatherDB.RecordSuccess(ReadingType.Temperature, WeatherInfoSource.Device, id / 100.0);
    return DateTime.Now.ToString();
}

Все преобразование входных и выходных параметров будут проведены автоматически инфраструктурой Web API. В нашем случае мы принимаем на вход температуру (умноженную на 100, чтобы использовать целый тип), а возвращаем текущую дату и время – это будет полезно, если мы захотим использовать контроллер Arduino без часов реального времени.

Аналогичным образом мы опишем метод, который по обычному запросу по адресу /api/temperature без параметров вернет последние измерения температуры. Все измерения возвращаются в формате JSON:

public WeatherRecord[] Get()
{
    return WeatherDB.GetCurrentReading(ReadingType.Temperature);
}

Аналогично создаются контроллеры для давления, влажности, освещенности.

Теперь мы можем, сделав запрос по адресу http://weathermon.cloudapp.net/temperature/-13, записать в таблицу любое измерение. Это измерение можно будет сразу посмотреть на графике.

Проектируем аппаратное устройство

Для реализации устройства, которое будет измерять температуру, давление и освещенность за окном, используем замечательный микроконтроллер NetDuino Plus 2. Его основной плюс состоит в том, что он имеет встроенный контроллер Ethernet, а также является совместимым в Arduino по форм-фактору.

Для измерения давления и температуры будем использовать замечательный датчик BMP-180, а для измерения освещенности – классическую схему с фоторезистором. Принципиальная схема устройства приведена ниже:

Для сборки устройства я использовал обычный тонкий провод и паяльник, собрав схему прямо “на проводах” без использование макетной платы (конструкция видна на фото вверху статьи). Провод Ethernet втыкался прямо из марштуризатора (важно, чтобы на маршрутизаторе был включен DHCP), питание – от стандартного блока питания на 9 вольт.

В полученном дизайне значение освещенности мы будем снимать в аналогового входа 0, а сенсором давления/температуры будем управлять через последовательную шину I2C.

Пишем программу для NetDuino

Я был искренне и приятно удивлен, но программа для NetDuino пишется на слегка урезанном .NET – .NET Micro Framework (русскоязычный сайт). В отличие от Arduino, где работа с Ethernet Shield происходит достаточно сложно, здесь нам сразу становятся доступны все функции .NET по работе с сетью.

Для работы с сенсором я использовал библиотеку SensorLib. Поскольку программирование в .NET требует Visual Studio 2013 (вот тут рассказывается про работу .NET MF с VS2013), я создал отдельный проект (код на GitHub).

Вся функциональность программируется в одном главном файле в функции Main. Вначале мы инициализируем порты и создаем объект для работы с сенсором:

AnalogInput photo_in = new AnalogInput(Pins.GPIO_PIN_A0);
OutputPort pin = new OutputPort(Pins.GPIO_PIN_SDA, true);
Thread.Sleep(200);
pin.Write(false); pin.Dispose();

Debug.Print("Initializing sensor library...");
SensorLibrary.BMP180 sensor = new SensorLibrary.BMP180();
sensor.Init(SensorLibrary.BMP180.Mode.BMP085_MODE_STANDARD);

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

while (true)
{
    double pressure = sensor.GetPressure() / 100.0F;
    double pressuremm = pressure * 0.75006375541921;
    Debug.Print("Pressure:    " + pressuremm.ToString() + " mmHg");
    double temperature = sensor.GetTemperature();
    Debug.Print("Temperature: " + temperature.ToString() + " C");
    int lum = photo_in.Read();
    Debug.Print("Luminocity: " + lum.ToString());
    record("Temperature", (int)(temperature * 100));
    record("Pressure", (int)(pressuremm * 10));
    record("Luminocity", lum);
    Thread.Sleep(1000 * 60 * 10);
}

Для отправки в интернет служит функция record – она инициирует запрос в интернет по соответствующей URL и игнорирует результат:

private static void record(string measurement, int value)
{
    TouchUrl("http://weathermon.cloudapp.net/api/" + 
	  measurement + "/" + value.ToString());
}

private static string TouchUrl(string url)
{
    using (var req = (HttpWebRequest)WebRequest.Create(url))
    {
        req.Method = "GET";
        using (var resp = req.GetResponse())
        {
		  // Если нужно - тут можем прочесть результат
        }
    }
}

На всякий случай мы также предусмотрели промежуточную печать с помощью Debug.Print – это очень удобно, поскольку когда плата подключена к компьютеру по USB, мы можем сразу видеть соответствующие строки прямо в Visual Studio. Также .NET MicroFramework поддерживает удобную отладку прямо из Visual Studio.

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

Если вы посмотрите внимательнее на историю данных – в некоторых местах реальные измерения отсутствуют. Это происходит потому, что мы не предусмотрели обработку исключений нашим контроллером. Если вдруг доступ в интернет временно теряется, приложение генерирут исключение, и бесконечный цикл останавливается. Для более устойчивой работы контроллера требуется более аккуратно подходить к вопросам исключительных ситуаций (Pull Request Welcome)!

Реализуем приложение для Windows Phone

Заключительным аккордом нашего упражнения станет реализация приложения для Windows Phone, которое позволит отображать текущую температуру. Будем использовать созданное нами WebAPI, которое возвращает необходимые данные в формате JSON. Для работы с такими данными нам потребуется подключить к вновь созданному проекту Windows Phone библиотеку JSON.NET (через NuGet – install-package Newtonsoft.Json).

Чтобы десериализовывать данные, нам потребуется класс, аналогичный созданному ранее WeatherRecord. Однако подключить WeatherLib напрямую к нашему проекту мы не можем, поскольку она не поддерживает платформу Windows Runtime, да и тащить за собой в приложения для смартфона всю облачную функциональность не очень правильно. Поэтому мы можем воспользоваться Cut-And-Paste, либо создать упрощенный вариант класса WeatherRecord – SimpleWeatherRecord.

Для получения результата вызова JSON-метода создадим функцию GetReading, которая будет вызывать нужные метод API и возвращать массив последних измерений типа SimpleWeatherRecord:

public async Task<SimpleWeatherRecord[]> GetReading(string rtype)
{
    var cli = new HttpClient();
    var str = string.Format("http://weathermon.cloudapp.net/api/{0}", rtype);
    var s = await cli.GetStringAsync(new Uri(str));
    return Newtonsoft.Json.JsonConvert.DeserializeObject<SimpleWeatherRecord[]>(s);
}

Обратите внимание на естественную асинхронность метода, и на простоту преобразования из формата JSON в строго типизированный массив объектов – одной строчкой!

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

private async void Page_Loaded(object sender, RoutedEventArgs e)
{
    var ind = StatusBar.GetForCurrentView().ProgressIndicator;
    await ind.ShowAsync();
    ind.Text = "Getting temperature...";
    TempService.Text = "--"; TempOut.Text = "--";
    var temp = await GetReading("temperature");
    foreach(var x in temp)
    {
        if (x.iWeatherInfoSource == 0) // данные из сервиса
            TempService.Text = x.Reading.ToString();
        else // данные с термометра
            TempOut.Text = x.Reading.ToString();
    }
    await ind.HideAsync();
}

Полученные с сервиса данные обычно содержат массив из двух измерений – последнее измерение температуры на улице и из OpenWeatherMap. Пройдясь по массиву циклом, мы помещаем каждое из измерений в соответствующий ему TextBlock. Если вдруг за последние 10 минут не было сделано измерения (это возможно, если например наше устройство NetDuino перестало передавать данные в облако), то соответствующей записи не будет в массиве, и текстовое поле будет отображать значение “—“.

Конечно, было бы правильнее сразу сделать это приложение универсальным приложением Windows. Но я оставлю это в качеству упражнения читателям, и буду ждать ваших Pull Requests.

Заключение

Статья получилась достаточно длинной, но, надеюсь, полезной! Она показывает, как на одном языке программирования C# и в одной среде (Visual Studio) вы можете создавать совершенно разное программное обеспечение – облачные сервисы, приложения для смартфонов, программы для микроконтроллеров. Программист все время использует (почти) одну и ту же библиотеку базовых функций, удобную среду программирования и отладки. Всё это делает платформу Майкрософт приятной в использовании, настолько, что я решил потратить часть новогодних каникул на проектирование этой погодной станции.

В статье содержится ряд пожеланий по улучшению. Мне будет очень любопытно, если кто-то подключится и в режиме pull request улучшит или дополнит мои примеры. Давайте вместе улучшать примеры в лучших традициях Open Source!

Эта статья - по всей видимости не последняя про погодную станцию, я расскажу вам про обработку получаемых данных на F#, а также возможно про создание аналогичной погодной станции на Arduino, как на более распространенном контроллере. Если у вас есть пожелания или идеи, о чем лучше рассказать – пишите мне! В любом случае, мне будет очень интересно узнать (в комментариях или вконтакте), сколько человек дочитало статью до конца, что показалось полезным, а что – нет.

Счастливого кодирования!