Mcufriend_kbv_2.5.zip

Использованы:

1. Копия Arduino NANO на базе микроконтроллера ATmega328p
2. Ethernet shield на базе чипа ENC28J60
3. Датчик влажности AM2302, известный в народе как DHT22
4. Барометр/Термометр GY-68 на базе сенсора фирмы BOSH - BMP180

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

Также Вас может заинтересовать вариант метеостанции на ESP8266

ВАЖНО!

Я использовал в скетче сторожевой таймер (Watchdog timer). Для этого необходимо перепрошить загрузчик Arduino NANO (ATmega328p) со стандартного на Оptiboot (как это сделать описано тут). Если залить выложенный ниже скетч в неподготовленный контроллер, получите "кирпич".

Если Вы читаете эту часть уже после того как залили скетч, то необходимо перезапустить микроконтроллер по питанию (и только по питанию) и у Вас будет 8 сек. на перепрошивку его другой программой. Иначе "селяви", что в переводе с древнегреческого - НЕ ПОВЕЗЛО! Процедуру можно повторять сколько угодно раз, пока не восстановите беднягу.

Вступительная часть окончена, переходим к делу

Станция разделена на две части

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

Скрытый текст

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

Скрытый текст

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

Схема этого безобразия, за исключением Ethernet модуля (это просо "бутерброд"), выглядит так.

На схеме использовал датчик BMP085 т.к другого я не нашел в Fritzing. На практике стоит BMP180 и подключен по 5V а не по 3.3V Т.к изучение китайской платы показало, что на борту имеется преобразователь.

Скрытый текст

Датчик DHT22 имеет обвязку в виде SMD резистора 0805 на 10kOm между двумя ногами - питание и 1-Wire. Но братья Китайцы могут продать датчик уже в обвязке по значительно завышенной ценой.

Скрытый текст

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

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

Если следовать ГОСТу, то сенсоры должны быть размещены в тени в течение всего дня.

Скрытый текст

Скрытый текст

Переходим к самому вкусному

Необходимо зарегистрироваться на http://narodmon.ru/ и добавить Ваше устройство. В качестве идентификатора, чтобы не запутать себя, Вы можете использовать MAC адрес Ethernet модуля. В данном случае мы будем передавать данные по TCP на 8283 порт сервера. Телеграмма будет состоять из:

1. Идентификатора устройства (MAC адрес)
2. Названия устройства
3. GPS координаты для позиционирования на карте проекта (т.к станция стационарна, координаты указаны в скетче без использования GPS модуля)
4. Показания со всех датчиков

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

Понадобятся библиотеки:

1. BMP180 (использует библиотеку BMP085) bmp085.zip
2. DHT22 https://github.com/adafruit/DHT-sensor-library
3. UIPEthernet https://github.com/ntruchsess/arduino_uip
4. 1-Wire http://playground.arduino.cc/Learning/OneWire

Скетч

Скрытый текст

#include <avr/wdt.h>
#include <Wire.h>
#include <BMP085.h>
#include "DHT.h"
#include <UIPEthernet.h>

#define DHTTYPE DHT22
#define DHTPIN 5

DHT dht(DHTPIN, DHTTYPE);

byte mac[] = {0x54, 0x34, 0x31, 0x31, 0x31, 0x31};
char server[] = "narodmon.ru";
int port = 8283;

IPAddress ip(192,168,0,201);
EthernetClient client;

BMP085 dps = BMP085();
long Temperature = 0, Pressure = 0;

bool interval = true;

void setup() {
  // Инициализация сторожевого таймера (Watchdog timer)
  wdt_disable();
  delay(8000);
  wdt_enable(WDTO_8S);
  // Инициализация консоли
  Serial.begin(9600);
  // Инициализация датчика DHT
  dht.begin();
  // Стартуем сеть, если не дождались данных с DHCP сервера то
  // присваеваем себе адрес самостоятельно
  if (Ethernet.begin(mac) == 0) Ethernet.begin(mac, ip);
  // Инициализация 1-Wire
  Wire.begin();
  delay(200);
  
  // Инициализация BMP180 с корректировкой высоты
  // dps.init(MODE_STANDARD, 3200, true);
  
  // Инициализация BMP180
  dps.init();

  // Отправляем первые данные сразу после включения устройства
  send_info();
}
// dewPoint function NOAA
// reference (1) : http://wahiduddin.net/calc/density_algorithms.htm
// reference (2) : http://www.colorado.edu/geography/weather_station/Geog_site/about.htm
double dewPoint(double celsius, double humidity)
{
  // (1) Saturation Vapor Pressure = ESGG(T)
  double RATIO = 373.15 / (273.15 + celsius);
  double RHS = -7.90298 * (RATIO - 1);
  RHS += 5.02808 * log10(RATIO);
  RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RATIO ))) - 1) ;
  RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RATIO - 1))) - 1) ;
  RHS += log10(1013.246);
  // factor -3 is to adjust units - Vapor Pressure SVP * humidity
  double VP = pow(10, RHS - 3) * humidity;
  // (2) DEWPOINT = F(Vapor Pressure)
  double T = log(VP/0.61078);   // temp var
  return (241.88 * T) / (17.558 - T);
}
// delta max = 0.6544 wrt dewPoint()
// 6.9 x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
  double a = 17.271;
  double b = 237.7;
  double temp = (a * celsius) / (b + celsius) + log(humidity*0.01);
  double Td = (b * temp) / (a - temp);
  return Td;
}

void send_info() {
  float H, dP, dPt;
  bool fail = true;

  while(fail) {
    // Пытаемся считать данные с датчика влажности DHT до тех пор, пока не получим 
    // результат. В 90% случаев все работает нормально, но нам нужны 100%
    if((H = dht.readHumidity()) >= 0) {
      // Получение влажности и температуры с датчика BMP180
      dps.getPressure(&Pressure);
      dps.getTemperature(&Temperature);
      // Подсчитываем точку росы, если температура на улице выше 0 градусов Цельсия
      // и ожидаем результат выше 0, в противном случае выводим 0. Это необходимо
      // чтобы не вводить в заблуждения в зимее время года.
      dP = Temperature>0?((dPt=dewPoint(Temperature*0.1, H))<0?0:dPt):0;
      // Подключаемся к серверу "Народный мониторинг"
      if(client.connect(server, port)) {
        // Начинаем передачу данных
        // адрес_устройства_в_проекте, имя_устройства, GPS широта, GPS долгота
        client.print(F("#fe-31-31-0e-5a-3b#Arduino Nano#71.344699#27.200014\n"));
        // температура
        client.print(F("#T0#"));
        client.print(Temperature*0.1);        
        client.print(F("#Температура\n"));
        // Давление
        client.print("#P1#");
        client.print(Pressure/133.3);
        client.print(F("#Давление\n"));
        // Влажность
        client.print("#H1#");
        client.print(H);
        client.print(F("#Влажность\n"));
        // Точка росы
        client.print("#T1#");
        client.print(dP);
        client.print(F("#Точка росы\n"));
        // Отправляем конец телеграммы
        client.print("##");

        // Даем время отработать Ethernet модулю и разрываем соединение
        delay(200);
        client.stop();
        // Останавливаем цикл, если передача завершена
        fail = !fail;
        break;
      }
      delay(250);
    }
    delay(250);
  }
}

void loop()
{
  // Каждые 3 секунды сбрасываем сторожевой таймер микроконтроллера
  // Каждые 6 минут отправляем данные на "Народный мониторинг"
  if(!(millis()/1000%30)) wdt_reset();
  if(!(millis()/1000%360)) {
    if(interval) {
      send_info();
      interval = false;
    }
  }
  else interval = true; 
}

 

Данные о температуре снимаются с датчика BOSH, они более точны.

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

1. dewPoint
2. dewPointFast

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

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

dP = Temperature>0?((dPt=dewPoint(Temperature*0.1, H))<0?0:dPt):0;

на

dP = dewPoint(Temperature*0.1, H);

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

Скрытый текст

В дальнейшем планирую:

1. Увеличить разнообразие датчиков
2. Объединить обе части метеостанции и вынести все на улицу
3. Уйти от ENC28J60 в пользу W5100 или W5500
4. Использовать POE для питания всей кухни

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

bmp085.zip

Обновление по просьбе Alex13 находится тут

1. Открытие/Закрытие разнесены на разные пины микроконтроллера (для управление соленоидом)

Обновление по просьбе Alex13 находится тут

1. Добавлен выбор режима закрытия замка (автоматический или по карте)
2. Добавлена сигнализация оповещающая о попытках подбора ключа

Обновление по просьбе svchekalin находится тут

1. Добавлен Ethernet Shield на чипе W5100
2. Ключи теперь хранятся не в EEPROM контроллера, а в MySQL базе на удаленном сервере
3. ...

Внимание: Очень много фотографий в статье!

Начнем с предыстории.

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

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

Задача поставлена, приступаем к реализации!

Техническое задание

1. Замок должен аутентифицировать хозяев без физического контакта пользователя с устройством
2. Память должна вмещать не менее двух десятков ключей
3. Устройство должно иметь возможность добавлять в память новые ключи
4. Добавлять новые ключи можно только, используя специальный, мастер ключ
5. Мастер ключ должен также иметь возможность открывать замок
6. Должна быть реализована возможность обнуления списка используемых ключей, в том числе и удаление мастер ключа
7. Замок должен иметь возможность открываться изнутри по нажатию на кнопку (как в домофоне)
8. Все описанные пункты должны быть просты в использовании и не требовать знания программирования

Реализация

За основу было решено взять клон Arduino UNO с ATmega328p на борту в паре с RFID (NRF) сканером RC522. Сам сканер является очень удачным выбором т.к работает на частоте 13.56 МГц и поддерживает чипы:

1. MIFARE S50
2. MIFARE S70
3. MIFARE UltraLight
4. MIFARE Pro
5. MIFARE DESfire
6. ...

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

Прокручиваем решение в голове

Хранить все ключи будем в энергонезависимой памяти микроконтроллера (EEPROM). Хорошее и как мне кажется единственное решение. ATmega328p имеет 1kB памяти, RFID (NRF) ключи содержат уникальный номер размером от 4 до N байт. Если уровнять все типы ключей, то читать мы будем только первый четыре байта любого ключа. Делаем вывод, что 1024/4=256 ключей.

Но необходимо знать точное их количество чтобы не читать пустую память, иначе можно взломать замок так, как это делается с некоторыми домофонами, а именно - передать ключ, состоящий из одних 0 или 255 и Вуаля!

Выделим один и по совместительству первый байт в EEPROM под число с количеством ключей и получаем (1024-1)/4=255,75, а это 255 полноценных четырехбайтных ключей! Это более чем достаточно, хоть домофон делай.

Добавлять ключи будем путем записи его первых четырех байт, в свободную память микроконтроллера, начиная с N+1 занятого байта памяти Arduino. Но делать это необходимо только с использованием мастер ключа. И тут встают два вопроса, какой из ключей должен быть мастером и как его найти среди кучи всех остальных? 

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

Открытие дверей. Как понять, что поднесенный к сканеру ключ является тем самым или наоборот. Давайте опять отталкиваться от идеи четырехбайтного ключа. Пройдя все предыдущие этапы записи памяти микроконтроллера, мы с 100% точностью можем сказать, сколько ключей и как они расположены в памяти Arduino. Следовательно, для быстрого сравнения логичнее искать совпадение по первому байту каждого ключа в памяти, и только если оно найдено переходить к сравнению следующего байта. Если какой либо из 4 байт не совпал, то останавливаем проверку и переходить к следующему ключу в памяти микроконтроллера. Если найдено совпадение всех четырех байт ключа, то прекращаем проверку и устанавливаем замок в состояние открыто, иначе оставляем замок запертым.

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

Чтобы добавить новый ключ в память замка необходимо поднести и удерживать у RFID (NRF) сканера мастер ключ. Для начала будет открыта дверь, чтобы впустить владыку в обитель. Но если мастер ключ удерживается в течение 5 секунд (по умолчанию), то замок переводится в постоянно открытое состояние и система распознавания ключей, описанная ранее, начинает работать как проверка наличия ключа в памяти. Ключа нет, тогда записываем его. Ключ найден, значит, ругаемся, плюемся и топаем ногами.

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

Для очистки памяти решено ввести красную кнопку с защитой от ложного нажатия. Если удерживать её в течение 5 секунд, то контроллер начинает перезапись EEPROM одними нулями. По окончанию операции производится перезапуск программы микроконтроллера. Но теперь нет ни единого ключа, следовательно, и мастера тоже. Непорядок! В этом безмятежном состоянии замок стоит держать постоянно открытым иначе "Се Ля Ви", что в переводе с древнегреческого "не повезло"!

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

Открытие двери изнутри по нажатию на волшебную кнопку поначалу показалось мне тривиальной задачей, и я добавил этот механизм простым способом (как и кнопку очистки памяти) - ногу микроконтроллера посадил через резистор на землю, а сама кнопка коммутировала на эту же ногу +5V. Все дешево и сердито, но вся соль кроется в деталях! Кнопок открытия двери будет несколько. Все они должны сидеть параллельно и самая дальняя будет расположена как минимум в 15, а то и больше, метрах от контроллера (если мерить длинной кабеля)! Это расстояние смело можно умножать на 2 и получить нереальную для +5V цифру. Необходимо пересадить ногу Arduino с GND на +5V (через резистор 10k), предварительно задействовать встроенный подтягивающий резистор микроконтроллера, а сама кнопка станет прижимать ногу к земле. Резистор между ногой и питанием необходим для избегания короткого замыкания при использовании самой кнопки.

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

Схема подключения

 - РАСПИНОВКА ----------------------------------------------------------------------------
             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
             Reader/PCD   Uno           Mega      Nano v3    Leonardo/Micro   Pro Micro
 Signal      Pin          Pin           Pin       Pin        Pin              Pin
 -----------------------------------------------------------------------------------------
 RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 SPI SS      SDA(SS)      10            53        D10        10               10
 SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 -----------------------------------------------------------------------------------------

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

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

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

Сам сканер был помещен в крышку от металлической коробки и закрыт стеклотекстолитом, естественно НЕ фольгированным!

Полученный результат показался мне довольно сносным и был передан заказчику для установки. Для питания был задействован компьютерный блок питания, с которого, через стабилизатор напряжения 12v в 8v для запитки Arduino UNO через стандартный 5,5мм разъем.

Фото монтажа

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

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

Вам понадобятся следующие библиотеки:

1. RFID-RC522 (NRF)
2. Bounce2 (избавляет от дребезга контактов при нажатии кнопок)

Хотите помочь проект?

• Yandex.Money
• PayPal.me

Сам скетч

/*
 * Программа управления нагрузкой с помощью RFID-RC522 13.56 мГц
 *  
 * - РАСПИНОВКА ----------------------------------------------------------------------------
 *             MFRC522      Arduino       Arduino   Arduino    Arduino          Arduino
 *             Reader/PCD   Uno           Mega      Nano v3    Leonardo/Micro   Pro Micro
 * Signal      Pin          Pin           Pin       Pin        Pin              Pin
 * -----------------------------------------------------------------------------------------
 * RST/Reset   RST          9             5         D9         RESET/ICSP-5     RST
 * SPI SS      SDA(SS)      10            53        D10        10               10
 * SPI MOSI    MOSI         11 / ICSP-4   51        D11        ICSP-4           16
 * SPI MISO    MISO         12 / ICSP-1   50        D12        ICSP-1           14
 * SPI SCK     SCK          13 / ICSP-3   52        D13        ICSP-3           15
 * -----------------------------------------------------------------------------------------
 *
 */

// Необходимые библиотеки
#include <avr/wdt.h>
#include <EEPROM.h>
#include <SPI.h>
#include <MFRC522.h>
#include <Bounce2.h>

// Необходимые пины
#define PIN_RESET         4        // RESER MEMORY
#define PIN_OPEN          2        // OPEN

#define PIN_RELAY         7        // RELAY
#define PIN_TONE          3        // TONE

#define PIN_RST	          9        // RFID
#define PIN_SS	          10       // RFID

// Инициализация RFID ридера
MFRC522 mfrc522(PIN_SS, PIN_RST);

// Переменные необходимые для работы со списком ключей
byte **keys;
byte keys_count = EEPROM.read(0);

// Переменные необходимые для режима программирования
byte modeProgTime         = 5;       // Количество секунд удержания мастер ключа для входа\выхода в\из режим\а программирования
bool mode                 = false;   // НЕ МЕНЯТЬ!
byte modeClean            = 0;       // НЕ МЕНЯТЬ!
unsigned long modeTimer   = 0;       // НЕ МЕНЯТЬ!
unsigned long resetTimer  = 0;       // НЕ МЕНЯТЬ!

// Управление замком
unsigned long openTimer = 0;

// Защита кнопок от дребезга
Bounce key_reset = Bounce();
Bounce key_open  = Bounce();
/*
  Якобы программный reset, но мы с Вами знаем, что это не так ;)
*/
void(* resetFunc) (void) = 0;
/*
  Функция звукового оповещения.
  Принимает параметры: количество звуковых сигналов, частота в герцах, продолжительность звука, пауза в милесекундах (не обязательно)
*/
void squeaker(byte count, unsigned int Hz, unsigned int duration, unsigned int sleep = 0) 
{
  for(int i=0; i<count; i++) {
    tone(PIN_TONE, Hz, duration);
    if(sleep > 0) delay(sleep);
  }
}
/*
  Функция читает EEPROM и составляет список активных ключей
  Первый байт в памяти содержит количество ключей
  UID ключа содержит 4 байта
  Общая память 1 + количество ключей * 4
  Максимум можно записать 255 ключей
*/
void keysRead() {
  // Выводим количество ключей
  Serial.print(F("KEYS COUNT: "));
  Serial.println(keys_count);
  int eb = 0;
  keys = (byte**)malloc(sizeof(byte*)*keys_count);
  // Читаем список ключей из EPROM
  Serial.println(F("------------------------------"));
  for(byte i=0; i<keys_count; i++) {
    Serial.print(F("KEY: "));Serial.print(i);Serial.print(" | ");
    keys[i] = (byte*)malloc(sizeof(byte)*4);
    for(byte b=0; b<4; b++) {
      keys[i][b] = EEPROM.read(++eb);
      Serial.print(keys[i][b]);
      if(b < 3) Serial.print(F(" "));
    }
    Serial.println();
  }
  Serial.println(F("------------------------------"));
  Serial.println();
}
/*
  Функция выводит UID ключа и, при необходимости, сопроводительное сообщение
*/
void uidPrint(String text = "") {
  Serial.print(F("UID: "));
  for(byte i=0; i<mfrc522.uid.size; i++) {
    Serial.print(mfrc522.uid.uidByte[i]);
    if(i < mfrc522.uid.size - 1) Serial.print(F(" "));
  }
  Serial.println();
  if(text.length() != 0) Serial.println(text + "\r\n");
}
/*
  Инициализация программы
*/
void setup() {
  // Настраиваем сторожевой таймер
  wdt_disable();
  delay(8000); // <- ЗАКОМЕНТИРУЙТЕ ЭТУ СТРОКУ, ЕСЛИ ЗНАЕТЕ, ЧТО ТАКОЕ wdt_enable(WDTO_8S);
  wdt_enable(WDTO_8S);
    
  // Инициализация используемых пинов
  // Реле
  pinMode(PIN_RELAY, OUTPUT);
  digitalWrite(PIN_RELAY, HIGH);
  
  // Кнопка сброса памяти
  pinMode(PIN_RESET,INPUT_PULLUP);
  key_reset.attach(PIN_RESET);
  key_reset.interval(5);
  
  // Кнопка открытия двери
  pinMode(PIN_OPEN,INPUT_PULLUP);
  key_open.attach(PIN_OPEN);
  key_open.interval(5);   
  
  // Инициализация консоли
  Serial.begin(9600);
  while (!Serial);
  // Приглашаем в гости
  Serial.println(F("iT4iT CLUB (C) 2015\r\nhttps://it4it.club\r\n"));
  
  // Инициализация ридера
  SPI.begin();
  mfrc522.PCD_Init();

  // Читаем количество ключей
  // Значение должно быть равным или больше 1 т.к первый ключ это мастер
  // В случае утери мастер ключа, мы можем сбросить EEPROM и прикрутить новый мастер ключ
  if(keys_count > 0 and keys_count < 255) {
    keysRead();
  }
  else {
    keys_count = 0;
    Serial.println(F("The master key is not in memory. The first presentation to the key will be the master!\r\n"));
    digitalWrite(PIN_RELAY, LOW);
  }
}
/*
  Лупаем, что происходит
*/
void loop() {
  // Сбрасываем сторожевой таймер микроконтроллера
  wdt_reset();

  if(resetTimer > millis()+10000) resetTimer = 0;
  if(openTimer > millis()+10000) openTimer = 0;
  
  // Очистка памяти
  key_reset.update();
  if(key_reset.read() == HIGH) {
    if(resetTimer == 0) resetTimer = millis();
    else {
      if((millis()-resetTimer)/1000 > 5) {
        Serial.println(F("Launched memory cleaning"));
        squeaker(4, 1600, 300, 200);
        wdt_disable();
        for(int i=1; i<=EEPROM.length(); i++) {
          EEPROM.write(i, 0);
          if(!(i%50)) Serial.println(F("#")); else Serial.print(F("#"));
        }
        Serial.println(F("\r\nMemory cleaning is completed\r\n"));
        delay(1000);
        resetFunc();
      }
    }
  }
  else if(resetTimer != 0) resetTimer = 0;
  // Открытие двери с кнопки
  key_open.update();
  //Serial.println(key_open.read());
  if(key_open.read() == LOW and openTimer == 0) {
    if(keys_count > 0) {
      openTimer = millis()/1000;
      digitalWrite(PIN_RELAY, LOW);
      Serial.println(F("The door opened from the inside"));
      squeaker(5, 3200, 100, 300);
    }
    else Serial.println(F("\nAttempting to open the lock from the inside.\nAccess denied. The master key is unknown. The castle is always open.\n"));
    delay(2000);
  }  
  // Автоматическое закрытие двери
  if(openTimer != 0) {
    if(millis()/1000 - openTimer > 5) {
      openTimer = 0;
      digitalWrite(PIN_RELAY, HIGH);
      Serial.println("* closed lock\r\n");
    }
  }
  // Если ключ отсутствует или не читается, не выполняем дальнейший код
  if(!mfrc522.PICC_IsNewCardPresent()) {
    // Очистка таймера входа в режим программирования, в случае если ридер свободен
    if(modeTimer != 0) {
      if(++modeClean > 5) modeTimer = modeClean = 0;
    }
    return;
  }
  if(!mfrc522.PICC_ReadCardSerial()) return;
  // Останавливаем режим очистки
  modeClean = 0;
  
  // Кривое создание мастер ключа
  if(keys_count == 0) {
    for(byte i=0; i<4; i++) EEPROM.write(i+1, mfrc522.uid.uidByte[i]);
    EEPROM.write(0, keys_count = 1);
    uidPrint(F("master key is created"));
    digitalWrite(PIN_RELAY, HIGH);
    keysRead();
    squeaker(8, 1200, 100, 100);
    delay(2000);
    return;
  }
  
  // Проверка ключа на соответствие
  bool access = false;
  bool master = false;
  for(byte i=0; i<keys_count; i++) {
    for(byte b=0; b<4; b++) {
      if(keys[i][b] != mfrc522.uid.uidByte[b]) break;
      if(b == 3) {
        access = true;
        if(i == 0) master = true;
        // Останавливаем проверку костылем т.к "break 2;" не работает
        i = keys_count;
      }
    }
  }
  // ========================================================================================
  // Следующая секция имеет двойное назначение:
  //  1. В обычном режиме - контроль доступа
  //  2. В режиме программирования - запись ключа при его отсутствие в EEPROM
  // ========================================================================================
  // ОБЫЧНЫЙ РЕЖИМ
  // ========================================================================================
  if(access and !mode and !master) {
    // Доступ разрешен
    openTimer = millis()/1000;
    digitalWrite(PIN_RELAY, LOW);
    uidPrint(F("access allow"));
    squeaker(2, 2200, 200, 200);
	delay(2000);
  }
  else if(!access and !mode and !master) {
    // Доступ запрещен
    uidPrint(F("access dany"));
    squeaker(1, 500, 1000);
    delay(2000);
  }
  // ========================================================================================
  // РЕЖИМ ПРОГРАММИРОВАНИЯ
  // ========================================================================================
  else if(access and mode and !master) {
    // Попытка записи существующего ключа
    uidPrint(F("error: key elrady exists in eeprom"));
    squeaker(2, 500, 300);
    delay(2000);
  }
  else if(!access and mode and !master) {
    // Записываем новый ключ
    // Максимум 255 ключей (с учетом первого байта) для 328 камня
    if(keys_count < 255) {
      for(byte i=0; i<4; i++) EEPROM.write(1 + keys_count*4 + i, mfrc522.uid.uidByte[i]);
      EEPROM.write(0, ++keys_count);
      uidPrint(F("add key in eeprom"));
      keysRead();
      squeaker(2, 2200, 200, 200);      
    }
    else {
      uidPrint(F("error: not enough memory for recording key!"));
      squeaker(2, 500, 300);
    }
    delay(2000);
  }
  // ========================================================================================
  // РАБОТА С МАСТЕР КЛЮЧОМ
  // ========================================================================================
  else if(access and master) {
    // Мастер ключ в обычном режиме
    if(modeTimer == 0) {
      modeTimer = millis()/1000;
      if(!mode) {
        openTimer = millis()/1000;
        digitalWrite(PIN_RELAY, LOW);
        // Сигнал о наличии мастер ключа в обычном режиме
        uidPrint(F("MASTER KEY"));
        squeaker(2, 2200, 200, 200);
      }
    }
    else {
      if(millis()/1000 - modeTimer > modeProgTime and modeTimer != 0) {
        modeTimer = 0;
        if((mode = !mode) == true) {
          // Вход в режим программирования
          digitalWrite(PIN_RELAY, LOW);
          uidPrint(F("MASTER PROGRAMMING MODE ON"));
          squeaker(4, 1200, 200, 200);
        }
        else {
          // Выход из режима программирования
          digitalWrite(PIN_RELAY, HIGH);
          uidPrint(F("MASTER PROGRAMMING MODE OFF"));
          squeaker(4, 2200, 200, 200);
        }
      }
      delay(2000);
      // Дополнительные действия по таймеру modeProgTime
    }
    // Мастер ключ удерживается у ридера
  }
}

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

PS: Желаю Вам приятного и надеюсь полезного использования.

Сегодня мы будем собирать бесконтактный замок с использованием NFC контроллера PN532. Опираясь на опыт прошлого варианта (на контроллере MFRC522) и на отзывы тех, кто пытался повторить схему, были сделаны определенные выводы. Постараемся избавиться от старых подводных камней и поищем новые 

И так, что мы знаем о PN532:

• Очень компактный размер 42.7 x 40.4 мм
• Поддерживает работу по SPI, i2C и HSU (высокоскоростной UART)
• Читение/Запись RFID меток, может общаться с другими контроллерами PN532, и вроде как общаться с Android телефонами
• Рабочая дистанция 5-7 см

Поддерживаемые чипы

• ISO 14443 Type A  - NXP Mifare 1k, 4k, Ultralight, Desfire
• ISO 14443 Type B
• ISO/IEC 14443-4-совместимые чипы
• FeliCa
• Jewel
• TopaZ

Чтение / Запись RFID меток

Обмен данными P2P

Передача данных смартфону

Кстати, вроде как начиная с Androik 4.4 KitKat операционная система умеет эмулировать NFC метки программным способом. Это подразумевает, что мы можем на телефоне сделать копию проездного билета (БСК, Тройка) или просто обычной метки, и использовать смартфон в качестве ключа для замка. К сожалению, у меня пока нет под рукой аппарата с поддержкой NFC, а значит и проверить это мне не под силам. Оставляю эту задачу Вам! 

Для сборки замка нам понадобятся:

1. Arduino UNO или любой аналог с контроллером ATmega328
2. Сам модуль сканера с контроллером PN532
3. Китайский модуль реле с опторазвязкой (в программе предусмотрена инверсия управляющего сигнала на случай управления реле напрямую или замены его на транзисторный ключ / мосфет)
4. Две кнопки для, одна для разблокировки замка изнутри помещения, а другая для сброса памяти микроконтроллера
5. Два резистора 10kOm и 4.7kOm
6. Танталовый конденсатор на 1uF
7. Светодиод для индикации о попытках взлома замка с помощью брутфорса ключа
8. Транзистор KT315 или его аналог для управления питанием PN532. Говорят, что война между Десептиконами и Автоботами началась именно из-за этих Советских транзисторов!

Зачем нужен транзистор? Он используется для управления питанием сканера, если по какой-либо причине Arduino пойдет на перезагрузку, то она потянет за собой и сканер. Таким образом мы лишний раз подстрахуем себя. Конденсатор в обвязке транзистора необходим для сглаживания пульсаций, у меня они были явно заметны при питании от USB. Конечно это все можно выкинуть из схемы и пустить на ножку VCC контроллера PN532 питание напрямую с 5V платы Arduino. Это уже на Ваш страх и риск.

Критически важно обратить внимание на питание! Не поленитесь и возьмите отдельный блок питания, USB используйте только в качестве Serial монитора. На реле желательно подавать отдельное питание, на Китайских модулях для этого есть соответствующие пины (GND, VCC, JD-VCC). На схеме я это не отражено т.к каждый волен самостоятельно выбирать как управлять силовой частью замка. Может вы замените реле мосфетом.

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

Так показано на схеме и так делает большинство. Все будет работать. 

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

Выбор за Вами.

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

Мы будем использовать i2C интерфейс. Возможно стоило бы SPI?

Все подключения можно свести к одной таблицы

Как все устроено

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

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

Первые 8 байт используются для хранения системной информации. Пока заняты только первые 2 байта, а остальные 6 зарезервированы под будущие улучшения. Возможно Вы что-то захотите добавить свое. Начиная с 9 байта идут ключи. Ключи бывают разного размера, но мы будем использовать только первые его 4 байта. Первый ключ всегда идет мастер, все последующие обычные. Всего можно иметь 1 мастер и 253 обычных ключа. То есть мы израсходуем весь объем EEPROM контроллера ATmega328. Вы конечно можете воспользоваться другим контроллером, с большим количеством памяти, но программа не даст Вам создать более 254 ключей. Оставшаяся память останется свободной.

И так после создания мастер ключа замок перейдет в дежурный режим, разблокировать его можно кратковременным нажатием на кнопку OPEN или самим мастер ключом. Для добавления новых ключей необходимо поднести мастер ключ к сканеру и удерживать более 5 секунд. Замок перейдет в режим программирования оповестив Вас об этом звуковым сигналом. В этом состоянии замок будет в разблокированном состоянии и все поднесенные новые ключи будет записаны в память. Для выхода из режима программирования необходимо опять поднести мастер ключ к сканеру и удерживать более 5 секунд. Звуковой сигнал оповестит об этом и замок вернется в дежурный режим.

После открытия двери ключом или кнопкой запускается таймер, который закроет замок через 5 секунд. Можно удерживать замок в открытом состоянии при удержании кнопки OPEN, но при её отпускании замок сразу закроется.

Теперь немного про защиту

В программе имеется счетчик ложных срабатываний. Если в течении минуты будут зарегистрированы 5 попыток подбора ключа, замок будет заблокирован на 1 минуту. Открыть дверь можно будет только с кнопки OPEN. Поднесения действующего ключа, даже мастера, будет проигнорировано замком. По истечению минуты доступ будет открыт, но на этом еще не конец. Счетчик даст только одну попытку разблокировать замок, если она потерпит неудачу, блокировка повторится. Замок будет давать по одной дополнительной попытки за каждую минуту ожидания, но не более 5 попыток. Таким образом скорость подбора ключа сводится к 1 ключу в минуту, а учитывая длину ключа даже в 4 байта, тот кто захочет этим заняться должен быть бессмертным. Проще ключ украсть или сделать копию, но от этого не застрахованы даже обычные замки, но в следующем варианте программы мы позаботимся и об этом.

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

• 1 раз в секунду если была выявлена хотя бы одна блокировка
• 2 раза в секунду если было выявлено более 5 блокировок
• 3 раза в секунду если более 10 блокировок
• 4 раза в секунду если выявлено более 20 попыток
• Горит постоянно при более 50 попытках

Есть два способа сбросить счетчик. Воспользоваться мастер ключом и перевести замок в режим программирования, после вернуть обратно в дежурный режим. Или удерживая активный ключ у сканера PN532 зажать кнопку OPEN на 5 секунд.

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

1. Bounce2 для программной защиты от дребезга
2. Timer1 для удобной реализации прерываний
3. Adafruit PN532 для связи с самим сканером

Хотите помочь проект?

• Yandex.Money
• PayPal.me

Сама программа замка: PN532_lock_iT4iT.CLUB.7z

Необходимо контролировать наличие магнита и передавать информацию на сервер по mqtt-протоколу

При инициализации устройства магниты УЖЕ поднесены к датчику Холла. 

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

Если изначально при старте магниты не поднесены, всё прекрасно работает.

Код (часть связанную с сетью и передачей по mqtt-протоколу на брокер исключил):

01  #include <SPI.h>
02	#include <Wire.h>
03	#include <PCF8575.h>
04	
05	#define PUB_DELAY 3000 // Частота передачи данных ото всех ключей
06	#define CHK_DELAY 500 // Частота проверки ключей
07	#define KEYS 3 // Кол-во ключей
08	#define ACT LOW // Состояние входа при активации
09	#define DIS !ACT
10	
11	PCF8575 ex1;
12	  
13	long previousMillis, checkMillis;
14	boolean kst[KEYS] = {0};
15	  
16	void setup () {
17	  // setup serial communication
18	  Serial.begin(9600);
19	  
20	  
21	  // Адрес i2c расширителя pcf8575
22	  ex1.begin(0x20);
23	   
24	  for (int i = 0; i < 3; i++) ex1.pinMode(i, INPUT);
25	  for (int i = 0; i < KEYS; i++) kst = DIS; // состояние датчика задается константой 
26   
27   delay(1500); // Allow hardware to stabilize
28   
29   previousMillis = millis();
30   checkMillis = millis();
31    
32 }
33   
34 void loop () {
35   if (millis() - checkMillis > CHK_DELAY) { // проверка ключей
36     for (int i = 0; i < 3; i++) kst = ex1.digitalRead(i);
37     for (int i = 0; i < 3; i++){
38       if (kst[i] == ACT) { // если хотя бы 1 ключ активен
39         String state = "Active";
40         Serial.println (state);
41       }
42     }
43     checkMillis = millis();
44   }
45   if (millis() - previousMillis > PUB_DELAY) { // передача данных о ключах
46     String request;
47     for (int i = 0; i < 3; i++) {
48        Serial.println (request);
49     }
50     previousMillis = millis();
51   }
52     // mqttClient.loop();
53 }

Детали: Nodemcu v3, два датчика BME280, подключенные на один I2C.

Для первого датчика с адресом 0х76 использовалась библиотека https://github.com/Seeed-Studio/Grove_BME280  и эта же библиотека отредактирована для второго датчика с адресом 0х77 (в прикрепленном файле). Как поменять адрес второго датчика например тут - http://arduino.ru/forum/apparatnye-voprosy/pomenyat-adres-i2c-na-bme280  Установить обе библиотеки.

Метеостанция умеет выводить данные в UART. Также создает WEB-сервер, по WIFI соединяется с домашней сетью, данные с метеостанции можно посмотреть в браузере, перейдя по адресу, который дал роутер. В скетч вставить имя/пароль своей сети, а также указать к каким пинам подключены датчики. В моем случае это D1 и D2.

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

Ну и скетч:

#include "Seeed_BME280.h"
#include "Seeed_BME280_77.h"
#include <Wire.h>
#include <ESP8266WiFi.h>

BME280 bme280;
BME280_77 bme280_77;

#define pin_sda 5 // default sda pin //вставить свое значение
#define pin_scl 4 // default scl pin //вставить свое значение

const char* ssid = "ssid"; //вставить свое значение
const char* password = "password"; //вставить свое значение


WiFiServer server(80);

void setup()
{
  Serial.begin(115200);
  if(!bme280.init()){
    Serial.println("Device error!");
  }
    if(!bme280_77.init()){
    Serial.println("Device error!");
  }
    delay(10);
      // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  

  server.begin();
  Serial.println("Server started");

  
  Serial.println(WiFi.localIP());
    
}

void loop()
{

  float t = (bme280.getTemperature());
  float p = (bme280.getPressure()*0.00750063);
  float h = (bme280.getHumidity());


  float t_77 = (bme280_77.getTemperature());
  float p_77 = (bme280_77.getPressure()*0.00750063);
  float h_77 = (bme280_77.getHumidity());
  
    //get and print temperatures
  Serial.print("Temp: ");
  Serial.print(t);
  Serial.println(" C");//The unit for  Celsius because original arduino don't support speical symbols

    //get and print temperatures_77
  Serial.print("Temp_77: ");
  Serial.print(t_77);
  Serial.println(" C");//The unit for  Celsius because original arduino don't support speical symbols
  
  //get and print atmospheric pressure data
  Serial.print("Pressure: ");
  Serial.print(p);
  Serial.println(" mm.Hg");

    //get and print atmospheric pressure data_77
  Serial.print("Pressure_77: ");
  Serial.print(p_77);
  Serial.println(" mm.Hg");

  //get and print humidity data
  Serial.print("Humidity: ");
  Serial.print(h);
  Serial.println(" %");

    //get and print humidity data_77
  Serial.print("Humidity_77: ");
  Serial.print(h_77);
  Serial.println(" %");

  delay(1000);

WiFiClient client = server.available();
if (!client) {
return;
}
while(!client.available()){
delay(1);
}

String req = client.readStringUntil('\r');
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("");
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head></head><body>");
client.print("Temperatures_in: ");
client.print(t);
client.print(" &#8451");
client.print("<br>");
client.print("Pressure_in: ");
client.print(p);
client.print(" mm.Hg.");
client.print("<br>");
client.print("Humidity_in: ");
client.print(h);
client.print(" %");
client.print("<br><br>");
client.print("Temperatures_out: ");
client.print(t_77);
client.print(" &#8451");
client.print("<br>");
client.print("Pressure_out: ");
client.print(p_77);
client.print(" mm.Hg.");
client.print("<br>");
client.print("Humidity_out: ");
client.print(h_77);
client.print(" %");
client.println("</body></html>");
delay(1);
client.stop();
  
}

Grove_BME280_77-master.zip

В данной теме пойдет речь о конфигурации микроконтроллера через UART (Universal Asynchronous Receiver-Transmitter) интерфейс. А рассмотрим мы это на примере MQTT логгера. В данном случае, это будет логгер температуры. Мне это устройство потребовалось на работе, даже не мне, а моим коллегам, и оно действительно работает и приносит огромную пользу т.к контроль температуры производится совместно с отличной, на мой взгляд, системой мониторинга Zabbix с оперативными оповещениями, построением графиков, блэк-джеком и... Подробнее о дружбе Arduino и Zabbix можно почитать тут

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

И тут на помощь приходит UART

Микросхема UART to USB имеется в большинстве плат семейства Arduino, а там, где её нет, обычно выведены соответствующие "пины". И все это очень облегчает жизнь т.к позволяет общаться с контроллером, просто подключив его к компьютеру напрямую или через переходник, благо их везде навалом, да и стоят они как пачка семечек. Остается только запустить любой терминал, который умеет доставлять в конец строки символ "перевод строки", что известен в народе как "\n", а в ASCII таблице имеет номер 0A.

Кстати, в Serial мониторе Arduino IDE выставить символ конца строки можно так

Ну а дальше только, что и остается, как общаться с устройством на той стороне. И тут мы переходим к основному алгоритму программы. Но перед этим хочу отметить, и это ВАЖНО, что за любое упрощение жизни, всякие красивости и прочее, приходиться платить, и цена довольно высока! В данном случае, это ОЗУ микроконтроллера. Поэтому не раскатываем губы, а если очень хочется, то берем следующий по характеристикам микроконтроллер. А начинать мы будем с ATmega328P, что известен в народе как Arduino UNO, Arduino Nano, IBoard v1.1 и т.д по списку. Заканчивать Вы можете чем угодно, хоть ATmega2560, ESP8266 или ESP32. В противном случае, производим оптимизацию кода, отказываемся от громоздких библиотек, или вообще, от Arduino IDE.

Что мы хотим получить

1. Вся конфигурация микроконтроллера должна храниться в энергонезависимой памяти (ПЗУ) известной нам как EEPROMM.
2. Если в ПЗУ конфигурация отсутствует, необходимо иметь резервный план. И им станет сброс конфигурации на настройки по умолчанию. Это поведение знакомо всем, особенно по домашним дешевым маршрутизаторам, а значит, интуитивно понятно.
3. Выводить справку при начале общения пользователя и устройства, на мой взгляд, как манеры высшего общества. Контроллер должен представляться и сообщать всю необходимую информацию о себе и о том, как с ним вести диалог.
4. Все команды должны быть просты и иметь не двусмысленное значение.
5. И конечно, мы должны иметь возможность просмотра текущего состояния датчиков или процессов, которыми занимается устройство в свободное от общения с нами время.

Как сохранять конфигурацию в EEPROM

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

#include <EEPROM.h>

На данный момент нас интересуют две функции, это чтение и запись

EEPROM.get(address, variable);
EEPROM.put(address, variable);

Обе принимают два параметра:

1. Адрес, начиная с которого будет произведено чтение или запись данных в память
2. Переменная чье содержимое надо сохранить или в которую нужно из памяти прочитать

Особенность работы этих функция заключается в том, что в зависимости от типа переданной им переменной во втором параметре, будет произведено чтение или запись ровно того количества данных которое соответствует размеру типа этой самой переменной. На простом языке это означает, что если переменная variable будет иметь типа byte, то и работать мы будем с объемом памяти в 1 байт. И тоже самое произойдет с абсолютно любым типом данных пока мы не упремся в размеры самого EEPROM или ОЗУ микроконтролера. Из этого всего следует, что мы можем создать свой собственный тип данных, разместить в нем необходимую нам информацию и всего лишь двумя функциями помещать его в память и извлекать обратно.

И в этом нам поможет пользовательский составной тип - структура (struct). Данный тип позволяет объединить в себе различные типы данных, упорядочить их и присвоить им понятные имена.

// Описываем структуру
struct user {
  char name[40];
  byte age;
};
// Объявляем новую переменную с нашим типом и помещаем в неё нужные нам значения
user anna;
anna.name = "Smirnova Anna";
anna.age  = 15;
// Записываем данные в EEPROM
EEPROM.put(0, anna);
// Объявляем еще одну переменную с нашим типом
user human;
// Читаем данные из EEPROM
EEPROM.get(0, human);
// Выводим содержимое
Serial.println(human.name); // Smirnova Anna 
Serial.println(human.age);  // 15

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

Наша структура будет немного сложнее, но суть остается той же самой.

// Дополнительная структура описывающая IPv4 адреса
struct addres {
  byte a;
  byte b;
  byte c;
  byte d;
};

// Структура объекта конфига для хранения в EEPROM
struct configObj {
  addres ip;
  addres subnet;
  addres gateway;
  addres dns;
  byte mac[6];
  byte hex;
  char server[40];
  char topic[40];
} config;

Данная структура хранит сетевые настройки для работы с Ethernet модулем (w5100 и выше) Arduino, базовые настройки для связи с MQTT брокером. Сразу при описании структуры мы объявили новую переменную с именем config с типом нашей структуры.

ВАЖНО: кроме наших данных в структуре имеется дополнительная переменная с именем hex. Её задача, это контроль наличия наших данных в EEPROM. Она всегда должна содержать одно и тоже значение. Представьте ситуацию, что вы взяли контроллер в EEPROM которого находится какая-либо информация (может там чисто, но мы этого не знаем наверняка) и мы прочитаем данные и поместим их в нашу переменную. В итоге мы получим данные которым нельзя доверять, а что еще хуже, это если эти самые данные нарушат работу внешнего оборудования.

Более правильным, на мой взгляд, будет проверка значений по конкретно определенным адресам. Например, мы знаем, что в 16 байте должно быть значение 0xAA и если оно действительно там, то мы убеждаемся, что это наша информация. Естественно, что контрольных точек может быть несколько и разумеется с разными значениями, это увеличит гарантию того, что данные являются нашими, но 100% гарантии не даст. Для более серьезных проектов есть более серьезные методы, например, подсчет контрольной суммы всего набора данных.

Также структура может иметь вложенные структуры, у нас ими являются: ip, subnet, gateway, dns. Вы можете отказаться от такого варианта и записывать данные просто в массив байт, как это было сделано с MAC адресом. Естественно, что обращаться к этим полям нужно по-разному.

Запись данных в поле subnet

config.subnet = {255, 255, 255, 0};

Запись данных в поле mac

byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02};
memcpy(config.mac, mac, 6);

С записью данных в поле server все еще проще

config.server = "mqtt.it4it.club";

Функция, которая возвращает нашу структуру данных с полностью заполненными полями.

// Начальный конфиг
configObj defaultConfig() {
  configObj config = {
    {192, 168, 0, 200},
    {255, 255, 255, 0},
    {192, 168, 0, 1},
    {192, 168, 0, 1},
    {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02},
    0xAA, // Не трогать! Используется для проверки конфигурации в EEPROM
    F("mqtt.it4it.club"),
    F("arduino/serial/config")
  };
  return config;
}

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

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

const byte startingAddress = 9;
bool configured = false;

void loadConfig() {
  EEPROM.get(startingAddress, config);
  if (config.hex == 170) configured = true;
  else config = defaultConfig();
  configEthernet(); // Функция производящая настройку сети
}

Как контроллеру начать понимать, что от него хотят

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

void serialEvent() {
    // Вызывается каждый раз, когда что-то прилетает по UART
    // Данные передаются посимвольно. Если в строке 100 символов, то функция будет вызвана 100 раз
}

И в контексте обсуждаемой нами программы, мы можем представить ее в следующем виде

void serialEvent() {
  serialEventTime = millis();
  if (console.available()) {
    char c = (char)console.read();
    if (inputCommands.length() < inputCommandsLength) {
      if (c != '\n') inputCommands += c;
      else if (inputCommands.length()) inputCommandsComplete = true;
    }
  }
}

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

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

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

Переменная отвечающая за размер принимаемого буфера

const byte inputCommandsLength = 60;

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

void serialEventHandler() {
    // вызывается в loop и проверяет взведена ли переменная inputCommandsComplete
    // в полученных данных пытается распознать команды
}

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

Разбор serialEventHandler

Полученные данные будут переданы нам в переменной inputCommands с типом String

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

inputCommands.trim();

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

if (inputCommands == F("help")) {
    consoleHelp();
} else if (inputCommands == F("restart")) {
    resetFunc();
} else {
    // Все сложные команды обрабатываются в этом блоке
}

Как Вы видите, все очень просто и скучно. Но не в том случае если команда динамическая, то есть содержит не только саму команду (заголовок) но и полезную нагрузку (параметр) которая может меняться раз от раза. Простой пример это команда изменения ip адреса и её варианты:

• ip 37.140.198.90
• ip 192.168.0.244
• ip 10.10.10.88

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

if (inputCommands.startsWith(F("ip"))) {
    // Строка inputCommands начинается с пары символов "ip"
}

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

inputCommands.substring(4)

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

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

1. Указатель на переменную с типом char, для этого нам потребуется преобразовать наш тип String
2. Символ разделителя, что для IPv4 является точка "."
3. Указатель на массив типа byte, которому будет присвоен результат разбора
4. Количество искомых элементов в строке
5. И система счисления, подразумеваемая в качестве исходной для записи элементов подстроки

/*
    Парсинг
    https://stackoverflow.com/questions/35227449/convert-ip-or-mac-address-from-string-to-byte-array-arduino-or-c
*/
void parseBytes(const char* str, char sep, byte* bytes, int maxBytes, int base) {
    for (int i = 0; i < maxBytes; i++) {
        bytes[i] = strtoul(str, NULL, base);
        str = strchr(str, sep);
        if (str == NULL || *str == '\0') break;
        str++;
    }
}

В нашем случае выглядеть это будет следующим образом

byte ip[4];
parseBytes(inputCommands.substring(4).c_str(), '.', ip, 4, 10);

А дале все становится еще проще, попросту проверить попадает ли наш ip адрес, в список правильных адресов. И самой простой проверкой послужит проверка первого байта адреса на несоответствие не угодным нам сетям (0, 127, 255)

if (ip[0] != 127 and ip[0] != 255 and ip[0] != 0) {
    // Производим необходимые нам действия с ip адресом, например, запись в конфиг
    config.ip = {ip[0], ip[1], ip[2], ip[3]};
}

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

Также хотелось бы отметить, что обрабатывать некоторые параметры проще и быстрее через их короткие записи. К таким можно отнести маску подсети устройства. Например, привычный дня нас адрес 192.168.0.1 с маской подсети 255.255.255.0 можно записать в виде 192.168.0.1/24, где цифра 24 указывает нашу подсеть в краткой форме. А, следовательно, мы можем записать несколько кратких форм масок подсети в следующем виде:

1. subnet 255.255.255.0 или subnet 24
2. subnet 255.255.0.0 или subnet 16
3. subnet 255.0.0.0 или subnet 8

Это основные маски, и я не описывал все существующие т.к в этом нет нужды, но если Вам интересно, то почитать про них можно в wikipedia.

if (inputCommands.startsWith(F("subnet"))) {
    String input = inputCommands.substring(8);
    if (input == F("24"))      config.subnet = {255, 255, 255,   0};
    else if (input == F("16")) config.subnet = {255, 255,   0,   0};
    else if (input == F("8"))  config.subnet = {255,   0,   0,   0};
    else {
        // Все остальные маски попадают в этот блок
        byte subnet[4];
        parseBytes(input.c_str(), '.', subnet, 4, 10);
        config.subnet = {subnet[0], subnet[1], subnet[2], subnet[3]};
    }
}

MAC адрес хранится у нас в виде массива байт. Его перезапись другим массивом производится с помощью функции memcpy

if (inputCommands.startsWith(F("mac"))) {
    byte mac[6];
    parseBytes(inputCommands.substring(4).c_str(), ':', mac, 6, 16);
    memcpy(config.mac, mac, 6);
}

Изменение адреса MQTT сервера

if (inputCommands.startsWith(F("server"))) {
    String server = inputCommands.substring(8);
    server.trim();
    if (server.length() < 40) server.toCharArray(config.server, 40);
}

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

Как это выглядит на практике

Заливаем программу в микроконтроллер и подключаемся к Arduino по usb или через переходник. Открываем терминал и нас приветствуют краткой справкой с описанием доступных команд.

- ---------------------------------------------------------------------------------------
# Sensor with data sending to mqtt server (c) it4it.club
# Use the "config" command to view the current configuration
# To change the configuration, specify the parameter name and its new value with a space,
# for example "ip 192.168.0.200", "subnet 255.255.255.0" or "mac AA:BB:CC:DD:EE:FF"
# You can also specify a subnet using the mask 24, 16 or 8
# Additional commands:
# sensors - view current data from sensors
# config - view current configuration
# save - saves the current configuration
# reset - resets all settings
# restart - restarts the device
# eeprom clear - removes all contents of eeprom
# help - view this help
- ---------------------------------------------------------------------------------------

Т.к. в EEPROM микроконтроллера не была обнаружена конфигурация (волшебный hex байт нам подсказал), то были задействованы стандартные настройки. Просмотреть текущую конфигурацию можно командой config

config
# ip: 192.168.0.200
# subnet: 255.255.255.0
# gateway: 192.168.0.1
# dns: 192.168.0.1
# mac: 00:AA:BB:CC:DE:02
# server: mqtt.it4it.club
# topic: arduino/serial/config

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

ip 10.10.10.99
# ok
gateway 10.10.10.1
# ok
dns 10.10.10.1
# ok

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

save
# ok
restart
# ok
# restarting device...

Если параметр был успешно принят, то контроллер ответит нам "ok", а в противном случае ругнется.

ip 127.0.0.1
# bad ip

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

qwerqwer1243
# bad command

С остальными командами Вы разберетесь самостоятельно.

Исходник: MQTT_CLIENT_328_SERIAL_CONFIG.zip

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

ридер имеет размер .

Поддержка I2C , SPI и HSU (High Speed UART )

прошу прощения за кривой гугл перевод данных производителя

чтения и запись , P2P общение с коллегами, NFC с Android телефон RFID- устройство считывания / записи поддерживает следующие функции: Mifare 1k , 4k , Ultralight , и DESFire карт ISO / IEC 14443-4 карты, такие как CD97BX , CD свет, DESFire , P5CN072 ( SMX ) Innovision Jewel карты, такие как карты IRT5001 FeliCa карты, такие как RCS_860 и RCS_854 До 5 см - 7см расстояние чтения На борту сдвига уровня , Стандартный 5V TTL для I2C и UART , SPI 3.3V TTL

В качестве основной функции , этот модуль может считывать и записывать RFID- карты . Различные карты могут быть поддержаны .

Два модуля PN532 могли бы общаться друг с другом .

в качестве ключа можно использовать телефон с NFC и если допустим в базе пользователь не зарегистрирован то телефон автоматически переходит на страничку с инструкцией по получению ключа а в случае авторизированного пользователя можно получить страничку с кнопками для дальнейших действий и все это использует в качестве связи технологию NFC никаких WIFi или GSM

ссылка на английский мануал от производителя http://www.elechouse.com/elechouse/images/product/PN532_module_V3/PN532_%20Manual_V3.pdf 

библеотечка nfc-pn532-master.zip PN532-PN532_HSU.zip

На данный момент занят собственными изысканиями на эту тему буду рад любой информации и идеям.

скетч.7z

Хочу поделиться опытом автоматизации изобретения Джона Уэбстера - Жалюзи, что в переводе с Французского звучит как Ревность! Скажу честно, что мой опыт обуздать это не хитрое устройство имеет как положительный, так и отрицательный результат. И я буду очень рад поделиться им с Вами, дабы Вы не совершали моих ошибок, и результат Вашей работы вызывал настоящую Ревность у всех, кто её видит!

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

Второе, и самое главное (на чем я прокололся), это выбор привода для управления механизмом. Я правильно подумал, что для поворота всех секций необходимо довольно большой крутящий момент и дать его мне может сервопривод. Решено было взять серву MG995 с металлическими шестернями, крутящим моментом 13 кг. на сантиметр и переделать её в сервопривод постоянного вращения.

Сама процедура модернизация "мускул" проекта очень проста.

1. Аккуратно разбираем привод (внутри много смазки) и запоминаем его устройство.
2. На основной шестерни расположен ограничитель хода (простой цилиндр из другого метала, отличается цветом от шестерней), удаляем его (без усилия вытягивается плоскогубцами).
3. Вынимаем всю электронику и запоминаем расположения контактов переменного резистора необходимого для позиционирования устройства.
4. Удаляем переменный резистор и заменяем его двумя обычными и равными половине номинала удаленного органа (в моем случае это два резистора по 2.5 кОм). Полагаю, что можно воспользоваться любыми резисторами одинакового номинала до 10 кОм. Но это стоит перепроверить!
5. Собираем все обратно.

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

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

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

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

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

Причина крылась в неидеальности нашего мира. Создать идеальный резистор не подверженный окружающей среде способна только задача из учебника по физике. А в результате, как только в комнате изменялась температура, даже на короткий миг, один из резисторов менял свои свойства. Вот тут и проявлялись те самые 1%, 5%, 10% погрешностей которые обещал производитель. Мириться с этим я не мог!

Решений было два:

1. Разобраться в устройстве мозгов сервопривода и заложить эту погрешность в программу микроконтроллера сервы.
2. Купить заводскую серву постоянного вращения.

И как Вы угадали, я сделал единственно верный выбор! Заказал новую серву и ею стало произведения Китайского искуства - модель DS04-NFC. Пластиковые шестерни, крутящий момент 5,5 кг. на сантиметр. Взяв её в руки, и сравнив с предшественницей, я отчетливо испытал чувство со столь красивым названием Жалюзи! Да это была Ревность! Как можно променять MG995 на DS04-NFC, каааакккк! Каарррлл скажииии, каааааккк!

Ладно, боль стихла, выбор сделан. Необходимо проверить её в деле. И забегая вперед, я обязан сказать, что новая серва была подвержена той же болезни, что и переделанная MG995. Фокус не удался, но исправить проблему получилось программно в самом скетче!

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

Для исправления данного недостатка я посадил параллельно нестабилизированного входа Arduino преобразователь AMS-1117-5.0 (Китайский клон LM-1117-5.0). Таким образом, я могу подавать питание (рекомендую 7-9V) на вход платы c контроллером и иметь раздельное стабилизированное питание, как самого контроллера, так и сервопривода. Фокус удался...

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

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

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

Согласен, не очень красиво но, что я могу поделать. Исправлю в следующей версии.

Переходим к программной части

По началу стоит определиться с командами, на которые будет реагировать контроллер. Это зависит только от используемого Вами пульта дистанционного управления. За основу я взял библиотеку Arduino-IRremote-master.zip В комплекте куча примеров чтобы научиться с ней дружить.

Ну а итоговый скетч будет выглядеть следующим образом

#include <IRremote.h>
#include <Servo.h> 

byte PIN_IR     = 8;
byte PIN_SERVO  = 9;

IRrecv irrecv(PIN_IR);
decode_results ir;

Servo myservo;

unsigned long timer = 0;

unsigned long lSpeed = 0;
unsigned long rSpeed = 0;

byte Speed;
int  fullSpeedTime = 3000;  // Время в миллисекундах, за которое серва выходит на полную скорость

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

void loop() {
  if (irrecv.decode(&ir)) {   
    //Serial.println(ir.value);
    
    // Поворот направо
    if(ir.value == 117192113) {
      timer = millis();

      if(rSpeed == 0) rSpeed = millis();
      Speed = map(millis()-rSpeed<fullSpeedTime?millis()-rSpeed:fullSpeedTime, 0, fullSpeedTime, 100, 180);
      Serial.println("Servo turns to the right. Speed " + String(Speed));
      
      myservo.attach(PIN_SERVO);
      myservo.write(Speed);
    }
    // Поворот налево
    else if(ir.value == 1819890863) {
      timer = millis();

      if(lSpeed == 0) lSpeed = millis();
      Speed = map(millis()-lSpeed<fullSpeedTime?millis()-lSpeed:fullSpeedTime, 0, fullSpeedTime, 100, 0);
      Serial.println("Servo turns to the left. Speed " + String(Speed));
      
      myservo.attach(PIN_SERVO);
      myservo.write(Speed);
    }

    irrecv.resume();
  }
  else {
    // Обнуляем все задействованные таймеры и отключаем серву
    if(timer != 0 and millis() - timer > 200) {
      rSpeed = lSpeed = timer = 0;
      myservo.detach(); // <- Именно этот костыль заставляет серву молчать
      Serial.println(F("Servo stop\n"));
    }
  }
}

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

Углы поворота влияют на скорость:

1. от 0 до 100
2. от 100 до 180

Это те значения, что получились у меня на двух сервах, и которые я использовал в скетче.

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

myservo.detach();

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

Привожу еще немного снимков всей получившейся конструкции

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

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

Идея есть, приступаем к реализации. 

Т.к работа с моими игрушками происходит через Web браузер, то логично воспользоваться стандартными средствами авторизации заложенными в большинство браузеров. Забегая вперед скажу, что у меня все заработало в браузерах: chrome, firefox и opera. Через ишака не завелось, но он живет своей жизнью и меня не интересует (даже разбираться не стал). В остальных не проверял, но думаю, что все будет работать.

Механизм выглядит следующим образом

При запросе страницы, браузер (например Opera) отправляет множество различной информации на Web сервер. 

GET / HTTP/1.1
User-Agent: Opera/9.80 (Windows NT 6.1; U; ru) Presto/2.10.229 Version/11.60
Host: 10.10.10.2
Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1
Accept-Language: ru-RU,ru;q=0.9,en;q=0.8
Accept-Encoding: gzip, deflate
Connection: keep-alive

В свою очередь мы ожидаем во всем этом шлаке увидеть заголовок Authorization: Basic <encoded-key> и естественно его не видим. Делаем правильный вывод - клиент не авторизован. Отправляем пользователю заголовок который заставит его браузер отобразить форму авторизации.

HTTP/1.0 401 Unauthorized
WWW-Authenticate: Basic realm="Arduino - iT4iT.CLUB"

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

GET / HTTP/1.1
User-Agent: Opera/9.80 (Windows NT 6.1; U; ru) Presto/2.10.229 Version/11.60
Host: 10.10.10.2
Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1
Accept-Language: ru-RU,ru;q=0.9,en;q=0.8
Accept-Encoding: gzip, deflate
Authorization: Basic bG9naW46cGFzc3dvcmQ=
Connection: keep-alive

При дальнейшем изучении вопроса, выясняется, что уникальный ключ bG9naW46cGFzc3dvcmQ= является ничем иным как строкой закодированной в Base64. И при её преобразовании в читаемый вид получаем login:password. Это и есть наши данные разделенные спец. символом ":".

Для работы с Base64, для Arduino имеется сторонняя библиотека с одноименным названием и забрать ей можно тут: https://github.com/adamvr/arduino-base64

У меня в наличие имеются Ethernet модули на чипах W5100 и ENC28J60 для Arduino Uno и Nano соответственно. Они имеют серьезные отличия и требуют для работы различные библиотеки. К примеру W5100 , в отличие от ENC28J60, имеет аппаратную поддержку TCP/IP: TCP, UDP, IPv4, ICMP, ARP, IGMP, MAC. Следовательно в ENC28J60 вся эта кухня должна быть реализована программно, что отразится на свободной памяти микроконтроллера.

W5100

Для работы требуются библиотеки Ethernet.h и SPI.h. Поставляется совместно со средой разработки Arduino. Скетч для микроконтроллера будет выглядеть следующим образом:

/*
  sign in (authentication) to the Web server Arduino
  (с) http://it4it.club
*/
#include <SPI.h>
#include <Ethernet.h> // Used for Ethernet
#include <Base64.h>
/*
  Настройки сети
*/
byte mac[] = { 0x54, 0x34, 0x41, 0x30, 0x30, 0x32 };
IPAddress ip(10, 10, 10, 11);                        

EthernetServer server(80);
/*
  Переменные для авторизации через web
*/
String readString;                // Буфер для данных от пользователя Web сервера
String auth_hash;                 // Тут храним полноценную строку авторизации, которую ожидаем от браузера в таком виде "Authorization: Basic bG9naW46cGFzc3dvcmQ="
char login[] = "login";           // Логин по дефолту. В дальнейшем необходимо измененные данные авторизации в Web морде хранить в EPROM
char password[] = "password";     // Пароль по умолчанию. -/-
/*
  SETUP
*/
void setup() {
  Serial.begin(9600);
  // Подготавливаем строку авторизации
  auth_hash = auth_update(login, password);
  // Поднимаем сеть  
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.println(Ethernet.localIP());
}
/*
  LOOP
*/
void loop() {
  EthernetClient client = server.available();
  if (client) {  
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        readString += c;
        if (c == '\n' && currentLineIsBlank) {
          if (readString.lastIndexOf(auth_hash)>-1) {
            if (readString.lastIndexOf("GET /favicon.ico")>-1) {
              client.println(F("HTTP/1.0 404 Not Found"));
            }
            else {
              client.println(F("HTTP/1.0 200 OK"));
              client.println(F("Content-Type: text/html"));
              client.println(F("Pragma: no-cache\r\nRefresh: 30\r\n"));
              client.println(F("<html><head><meta charset=UTF-8\"><title>Arduino - iT4iT.CLUB</title>"));
              client.println(F("<style>body,table,tr,td{font-style:normal;font-family:verdana;font-size:11px;}body{background-color:#FFEBD5;}</style></head><body>"));
              client.print(F("Arduino on <a href=\"https://it4it.club\">iT4iT.CLUB</a>"));
              client.println(F("</body></html>"));
            }
          }
          else {
            client.println(F("HTTP/1.0 401 Unauthorized"));
            client.println(F("WWW-Authenticate: Basic realm=\"Arduino - iT4iT.CLUB\""));
          }
          break;
        }

        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      } 
    }
    delay(30);

    readString = "";
    client.stop();
  }
}
/*
  Функция подготавливает строку авторизации с хэшем учетных данных, для сравнения её с данными в HEADER браузера которые мы получим
*/
String auth_update(char login[], char password[]) {
  // Строка для будущего хэша
  String hash = strcat(strcat(login, ":"),password);
  int buf_size = hash.length()+1;
  char buf_char[buf_size];
  // Переводим строку в char для дальнейшей обработки base64
  hash.toCharArray(buf_char, buf_size);
  char encoded[base64_enc_len(buf_size-1)];
  // Получаем хэш для авторизации
  base64_encode(encoded, buf_char, buf_size-1);
  // Формируем полную строку поиска "Authorization: Basic <BASE64-HASH>" чтобы не могли подсунуть хэш в GET или POST
  return "Authorization: Basic " + String(encoded);
}

 

ENC28J60

Для данного чипа требуется сторонняя библиотека. Я выбрал UIPEthernet.h, забрать можно тут: https://github.com/ntruchsess/arduino_uip 

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

/*
  sign in (authentication) to the Web server Arduino
  (с) http://it4it.club
*/
#include <UIPEthernet.h> // Used for Ethernet
#include <Base64.h>

На этом пока все, всем удачи с экспериментами!

PS: Не забывайте изменить IP в скетче.

• Статья переработана и перепроверена
• Актуально для Optiboot 6.2 и Arduino IDE 1.6.6 или выше.

Рано или поздно приходится столкнуться с необходимостью замены bootloader (загрузчика) микроконтроллера. В моём случае остро потребовался функционал загрузчика Optiboot, из-за реализованного в нем сторожевого таймера (watchdog). Плюс ко всему, он весит в четыре раза меньше стандартного и освобождает дополнительно 1.5kb памяти для скетча!

Сразу хочу отметить, что Optiboot залит по умолчанию на Arduino UNO и Mega 2560.

У меня в наличии имелись: Arduino Nano и Arduino Pro Mini на чипах ATmega328P-AU, и просто пачка "голых" ATmega328P-PU. Есть несколько простых способов перезаписать загрузчик которыми я воспользовался (это далеко не все возможные варианты).

Использование программатора USBasp

Как по мне, это самый простой способ не требующий никакой магии. Сам программатор можно приобрести у братьев Китайцев за $2. Он представляет из себя плату с ATmega8 или ATmega128, USB на входе и 10Pin ICSP интерфейс на выходе. От стандартного 6Pin интерфейса он отличается лишь тремя дополнительными пинами GND и одним не использующимся NC. Чтобы упростить себе жизнь, советую сразу брать переходник с USBasp 10pin to 6pin за $0.5

Выглядит это следующим образом

Сама распиновка программатора и разъемов (позаимствована у братьев наших)

Если на плате Arduino распаян 6pin разъем ICSP, то подключение до безобразия простое. Совмещаем одноименные контакты программатора с платой Arduino. Если готового разъема нет, то используем соответствующие ноги на плате Arduino или на самом микроконтроллере.

Необходимые ноги:

1. GND
2. VCC
3. MOSI
4. MISO
5. RST

Распиновка некоторых плат Arduino и микроконтроллеров находится в соседней теме

Пример подключения USBasp к Arduino Pro Mini и к ATmega328P-PU. В случае с последним, конденсаторы можно выкинуть из схемы.

Теперь самое интересное

1. Переходим на GitHub проекта Optiboot (ссылка имеется в начале поста) и скачиваем архив со всем необходимым.
2. Переходим в каталог где хранятся созданные вами скетчи (в Windows это "\Мои документы\Arduino\") и создаем в нем ветку каталогов \hardware\optiboot\avr\
3. В скачанном архиве находим каталог optiboot и переносим все его содержимое в каталог созданный в предыдущем пункте.
4. Среди всех перенесенных файлов находим boards.txt удаляем его. Он является устаревшим и более нас не интересует!
5. Находим файл boards-1.6.txt и переименовываем в boards.txt, в итоге должно получится как на изображении ниже
   Скрытый текст

   

    

6. Перезапускаем срезу Arduino IDE
7. Проверяем список плат во вкладке "Инструменты" и наслаждаемся результатом

При хранении всех необходимых файлов вне среды разработки Arduino IDE последующее обновление самой среды не позволит Вам потерять настройки и файлы загрузчика Optiboot в отличие от прямого вмешательства в оригинальный boards.txt

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

Выбираем программатор USBasp

И жмем "Записать загрузчик".

ВАЖНО: Если желаете залить скетч через USBasp, то необходимо нажимать "Записать\Вгрузить" при зажатой клавиши SHIFT. Только в этом случае будет выбран программатор для заливки, а соответствующая подсказка изменится за "Загрузить через программатор".

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

Цитата

avrdude: warning: cannot set sck period. please check for usbasp firmware update.

Попросту игнорируем их!

Использование Arduino в качестве программатора

Нам понадобится вторая плата Arduino. Прошиваем её скетчем ArduinoISP, идущим по умолчанию со средой разработки. После этого Arduino становится полноценным программатором.

// pin name:    not-mega:         mega(1280 and 2560)
// slave reset: 10:               53
// MOSI:        11:               51
// MISO:        12:               50
// SCK:         13:               52

В скетче имеется подсказка с способом подключения.

Изменяем в Arduino IDE программатор на  Arduino as ISP, выбираем необходимую плату, к которой подключен наш вновь испеченный программатор и "прожигаем" загрузчик.

Если необходимо записать какой либо скетч, то делаем это также при зажатой клавиши SHIFT (как и в первом варианте).

PS: По умолчанию в среде разработки имеются файлы загрузчика optiboot и скачивать ничего не нужно. Достаточно выбрать плату Arduino UNO и перезаписать загрузчик. Но в этом случае Ваше детище станет определяться именно как UNO, даже если на самом деле это NANO, Pro Mini или еще что-то.

hardware.zip

Микроконтроллеры

ATmega328p-pu

Скрытый текст

ATmega328p-au

Скрытый текст

ATmega2560

Скрытый текст

ATmega32u4-au

Attiny

Платы

Arduino UNO

Скрытый текст

Arduino NANO

Скрытый текст

Arduino PRO-MINI

Скрытый текст

Arduino MICRO

Скрытый текст

Arduino MEGA

Скрытый текст

Arduino LEONARDO

Скрытый текст

 

Arduino Yun

Arduino Esplora

Arduino Fio