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

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

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

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

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

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

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

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

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

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

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

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

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

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

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

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

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

ArduinoIDE 1.0.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <dht11.h>

dht11 sensor;

#define DHT11PIN 8

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

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

  int chk = sensor.read(DHT11PIN);

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

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

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

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

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

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

#define DHT11PIN 8

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

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

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

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

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

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

• библиотека для Arduino на playground;
• альтернативная библиотека от ladyada;
• погодная станция на ATmega8+DHT11;
• библиотека+примеры из статьи.

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

Ёлкадуино R2

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

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

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

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

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

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

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

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

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

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

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

ArduinoIDE 1.0.2

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

Апгрейдим Netduino

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Скоро Due!

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

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

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

TinyDuino

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

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

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

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

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

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

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

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

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

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

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

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

Netduino

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

Я уже рассказывал о Leaf Maple от leaflabs.com, и проект, кстати, успешно существует до сих пор. На фоне массы преимуществ остаются недостатки, связанные с совместимостью шилдов и библиотек. Работа продвигается неспешно, но зато это первая в истории Arduino-совместимая плата на ARM.

В этом году Google выпустил ARM-плату ADK 2012 - она может быть задействована с помощью одноименного приложения ADK 2012 для Android. Доступны как исходники самого Android-приложения, так и того, что находится внутри платы, а также схема, разводка и тулчейн. Поддержка в ArduinoIDE ожидается этой осенью, вместе с выходом Arduino Due - однако все мы помним, как итальянцы умеют выдерживать драматическую паузу ;)

Существует и еще одна популярная ARM-плата - Netduino. Повторяя  форм-фактор Arduino, тем не менее программируется она на Microsoft C#, на базе специального .NET Micro Framework. Исходные тексты и CAD-файлы - открыты (в том числе и для улучшений). И поскольку экземпляр такой платы недавно попал ко мне в руки, хочу воспользоваться случаем и поделиться опытом.

Внешне это выглядит так:

Как видите - всё честно, можно стыковать с шилдами для Arduino, и даже вилку программирования, столь важную для совместимости SPI-ориентированными шилдами не забыли. На негодование по поводу отсутствия поддержки в ArduinoIDE могу только развести руками и напомнить о паре положительных моментов:

1. По отношению к новичку .NET выглядит более-менее дружественно (оценим это ниже, в примерах кода);
2. Micro Framework хоть и урезана, но все-таки поддерживает многопоточность, события и пошаговую отладку.

Первым делом надо установить программное окружение, способное компилировать код на языке Microsoft C#, начнем с платформы Windows (для Linux и Mac OS X есть возможность использовать Mono, про это в следующий раз):

1. Установите бесплатный Microsoft Visual C# Express 2010 
http://www.microsoft.com/express/downloads/
2. Скачайте и установите Microsoft .NET Micro Framework v4.1 SDK 
http://www.netduino.com/downloads/MicroFrameworkSDK.msi
(в инсталляторе можно выбрать вариант "Typical")  
3. Скачайте и установите Netduino SDK v4.1 
http://www.netduino.com/downloads/netduinosdk_32bit.exe (для 32-bit Windows)  http://www.netduino.com/downloads/netduinosdk_64bit.exe (для 64-bit Windows) 

Установка протекает скучно и, как правило, вопросов не вызывает. Конечно, Express нужен только если не установлена платная версия студии. Можно использовать и версию SDK 4.2, но потребуется 1) дополнительно повозиться с перепрошивкой платы, 2) использовать версию студии не ниже 2010.

После запуска MSVC выбираем в меню File | New Project, и далее в появившемся окне - Micro Framework, затем Netduino Application.

В окне Solution Explorer-а справа дважды щелкам на созданной из дефолтового темплейта Program.cs, это будет приблизительно так:

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

namespace NetduinoApplication1
{
    public class Program
    {
        public static void Main()
        {
            // write your code here
        }
    }
}

Теперь вместо строчки "write your code here" вписываем:

OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);

while (true) {
  led.Write(true);
  Thread.Sleep(500);
  led.Write(false);
  Thread.Sleep(500);
}

Самое время опробовать этот "Blink" в работе, однако по умолчанию среда компилирует и загружает результат в эмулятор от Microsoft. Вещь это красивая, но для нас бесполезная - специального эмулятора для Netduino вместе с SDK не устанавливается (хотя, существует как минимум одна попытка его создания, здесь можно ознакомиться подробнее).

Поэтому, самое время подключить Netduino к компьютеру и установить драйвера из папки Netduino SDK (по умолчанию это Program Files/Secret Labs/Netduino SDK/Drivers). После этого в студии щелкаем правой кнопкой по имени проекта (имя проекта располагается сразу под именем солюшена, т.е. второй строкой), в появившемся окне меняем Transport с "Emulator" на "USB", и, если плата подключена, в строке Device увидим "Netduino_netduino".

Теперь можно вернуться на закладку с программой и проверить, успешно ли она компилируется (F6), после чего загрузить ее в плату (F5). При этом произойдет тоже самое, что обычно происходит в ArduinoIDE - скомпилированная программа будет записана во флеш. Если же надо начать пошаговую отладку - нажимайте F11.

После успешного запуска Blink-а можно взглянуть на плату поподробнее:

• "сердцем" является AT91SAM7X512 - ARM7TDMI с 512К FLASH, 128К RAM, аппаратной поддержкой USB 2.0, Ethernet MAC 10/100 base-T, CAN, I2C, I2S, SPI, USART, JTAG. Все пины 5В-совместимые, в том числе четыре - с повышенной нагрузочной способностью (до 16мА). МК работает на частоте 48 МГц и питается от +3.3В;
• для пользовательских программ доступно 128К FLASH и 60K RAM;
• аналоговых пинов - 6 (как и в Arduino, они могут быть переведены в цифровой режим);
• цифровых пинов -  14;
• кнопка сброса, которая может быть использована и в качестве генератора внешнего события в  программе (то есть, не обязательно строго сбрасывает устройство);
• светодиод, индицирующий подачу питания (кстати, белый) и еще один - доступный пользователю (так же, как светодиод L в Arduino);
• разъем внешнего питания 2.1/5.5, плюс в центре, защитный диод от переполюсовки;
• microUSB с предохранителем 0.5 мА;
• специальный erase pad для обновления прошивки. 

Разъем Ethernet присутствует только на плате Netduino Plus, и на ней же есть слот microSD, с которого можно грузиться. И, напротив - существует модификация Netduino Mini, которая по  аналогии с Freeduino Pro Mini - хорошо подходит для беспаечной макетки, но не содержит даже порта USB. 

Несколько слов о нагрузочной способности портов. Привычные для Arduino и ATMEL/AVR 40 мА на пин здесь оказыаются недостижимой роскошью - большинство пинов выдерживают максимум 8 мА, так что возьмите на заметку значение токоограничительного резистора для светодиода с падением напряжения 2.1В - около 150 Ом. Более подробно про назначения пинов можно прочесть здесь.

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

InputPort button = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);

Обычная кнопка инициализируется аналогичным способом:

InputPort button = new InputPort(Pins.GPIO_PIN_D1, false, Port.ResistorMode.PullUp);

(обратите внимание на последний параметр - это управление встроенными подтягивающими резисторами). Далее чтение состояния производится простым button.Read(), которое возвращает true или false.

Аналоговые входы, позволяющие оцифровывать величину приложенного к ним напряжения, работают в диапазоне 0..+3.3В в дестиразрядном режиме (т.е. возвращают значения от 0 до 1023) :

AnalogInput pot = new AnalogInput(Pins.GPIO_PIN_A0);

и далее, для считывания - pot.Read(). Если диапазон значений 0..1023 не выглядит удобно, можно его масштабировать таким способом: pot.SetRange(0, 100).

Возможность аппаратного ШИМ-а есть на пинах 5, 6, 9, 10, инициализировать его можно так:

PWM led = new PWM(Pins.GPIO_PIN_D5);

Затем передаем potValue - число от 0 до 100 в качестве аргумента, меняя скважность импульсов (или яркость свечения светодиода, соответственно): led.SetDutyCycle((uint) potValue). Или, прямо указываем длительность всего импульса и его  - led.SetPulse(duration * 2, duration).

Кстати, с помощью Thread.Sleep можно приостановить выполнение "навсегда": Thread.Sleep(Timeout.Infinite);

Подводя краткие итоги по использованию моего Netduino c Windows XP (запущенном в Oracle VirtualBox, совместимость с которым прямо декларирована в спецификациях платы), отмечу явное подтормаживание во взаимодействии студии с платой. Программы исправно компилировались, но процесс загрузки был инфинитным - такое впечатление, что программа загружалась, но не запускалась (приходится жать на сброс). Также мне не удалось войти в режим пошаговой отладки :( Возможно, это какая-то особенность работы в виртуальной машине или сочетание версий софта и firmware - надеюсь ее победить в ближайшее время.

Для кого Netduino будет полезен? В первую очередь, для приверженцев C# от M$. В основном, конечно, эффектно будет смотреться перенос существующих исходников, работающих с сетевым интерфейсом (насколько я могу судить - изменения там минимальные). Но, с другой стороны, не стоит забывать о том, что Netduino Plus со встроенной сетевой поддержкой дает пользователю еще меньше свободы -  64К FLASH и 42K RAM.

Для начинающих может пригодиться Getting Started with Netduino, написанная Крисом Уолкером (Chris Walker) - собственно автором железки и главой сообщества Netduino.