Сигнализация / удаленный мониторинг за датчиками по GSM/GPRS

Введение:

В этом уроке мы создадим систему удаленного мониторинга и охраны дома, используя GSM/GPRS Shield.

При выполнении одного из заданных сценариев модуль будет отправлять СМС или звонить Вам на телефон, а в режиме ожидания по запросу сможет отправлять СМС с текущим состоянием системы.

Видео:

Нам понадобится:

1х Arduino / Piranha UNO;
1х GSM/GPRS Shield;
1х Battery Shield;
1х Trema Shield;
1х Trema-модуль Цифровой термометр;
1х Цифровой термометр (герметичный);
1х Trema-модуль Датчик газа MQ-2 (широкого спектра);
1х ИК-датчик движения HC-SR501;
1х Магнитный извещатель (геркон);
1х Гарнитура;

Для реализации проекта нам необходимо установить библиотеки:

iarduino_GSM — для работы с GSM/GPRS Shield;
OneWhire — для работы с датчиками фирмы Dallas;
DallasTemperature — для работы с цифровыми термометрами DS18B20;
SoftwareSerial — библиотека входит в базовый набор Arduino IDE и не требует установки;

О том, как устанавливать библиотеки, Вы можете ознакомиться на странице Wiki - Установка библиотек в Arduino IDE.

Описание работы системы удалённого управления:

После подачи питания дождитесь получения смс с уведомлением о том, что инициализация прошла успешно и модем GSM зарегистрировался в сети. После этого устройство готово к работе.
Устройство может принимать сообщения с командой "ОТЧЁТ";
После правильно написанной и отправленной СМС дождитесь обратного сообщения с данными об актуальном состоянии системы;
Так же, в устройстве есть несколько сценариев работы с датчиками:
- При сработке любого из датчиков на телефон абонента отправляется СМС с уведомлением и актуальным значением датчика;
- При сработке некоторых особо важных датчиков устройство отправляет СМС с уведомлением, а затем совершает звонок на указанный в коде номер, благодаря чему абонент может услышать, что происходит вокруг устройства.

Схема сборки:

Arduino / Piranha UNO:

Batery Shield:

Установите Battery Shield на Arduino / Piranha UNO:
Во время установки Battery Shield должен быть в выключенном состоянии.

GSM/GPRS Shield:

На Battery Shield установите GSM/GPRS Shield:

На плате GSM/GPRS Shield имеется слот для SIM-карт и переключатель UART. Установите SIM-карту в слот, выберите положение переключателя RX-7/TX-8.

Trema Shield:

На GSM/GPRS Shield установите Trema Shield:

Гарнитура:

Установите гарнитуру в GSM/GPRS Shield.

Обратите внимание, что между информационным проводом (жёлтый) и проводом питания 5В (красный) установлен резистор 10кОм.

ИК-датчик движения HC-SR501

Подключите ИК-датчик движения HC-SR501 к Trema Shield.

Магнитный извещатель (геркон):

Подключите магнитный извещатель (геркон) к Trema Shield.

Обратите внимание, что от информационного провода (жёлтый) через резистор 10кОм подключается провод GND (чёрный).

Код программы (скетч):

                                                            // БИБЛИОТЕКИ
#include        "SoftwareSerial.h"                                                                                          // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
#include        "iarduino_GSM.h"                                                                                            // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
#include        "OneWire.h"                                                                                                 // Подключаем библиотеку OneWire для работы с оборудованием фирмы Dallas
#include        "DallasTemperature.h"                                                                                       // Подключаем библиотеку DallasTemperature для работы с цифровым термометром DS18B20
#define pinPWR  7                                                                                                           // Вывод PWR GSM шилда
#define pinRX   8                                                                                                           // Вывод RX для работы с GSM шилдом (TX на шилде)
#define pinTX   9                                                                                                           // Вывод TX для работы с GSM шилдом (RX на шилде)            
                                            // ОБЪЕКТЫ ДЛЯ РАБОТЫ С ДАТЧИКАМИ ТЕМПЕРАТУРЫ
OneWire         oneWire_in(2);                                                                                              // Указываем вывод, к которому подключен термометр внутри помещения
OneWire         oneWire_out(3);                                                                                             // Указываем вывод, к которому подключен термометр снаружи помещения
DallasTemperature sensor_inhouse(&oneWire_in);                                                                              // Создаём объект sensor_inhouse для работы с термометром внутри помещения
DallasTemperature sensor_outhouse(&oneWire_out);                                                                            // Создаём объект sensor_outhouse для работы с термометром снаружи помещения
                                              // ОБЪЕКТЫ ДЛЯ РАБОТЫ С GSM/GPRS МОДУЛЕМ
iarduino_GSM    gsm(pinPWR);                                                                                                // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
SoftwareSerial  softSerial(pinRX, pinTX);                                                                                   // Создаём объект softSerial для работы по программной шине UATR, указывая выводы RX и TX платы Arduino
                                                            // ПЕРЕМЕННЫЕ
String          TEXT;                                                                                                       // Переменная типа String для хранения текстовой информации и отправки её абоненту
String          strSMStxt;                                                                                                  // Переменная типа String для работы с поиском символа в строке
char            SMStxt[161];                                                                                                // Объявляем строку для хранения текста принятых SMS сообщений.
char            SMSnum[13];                                                                                                 // Объявляем строку для хранения номера отправителя SMS сообщений.
char            NUMBER[13]                            = "7_ВАШ_НОМЕР_ТЕЛЕФОНА";                                             // Зададим номер, с которым будет работать модуль
char*           REPORT_COMMAND                        = "ОТЧЁТ";                                                            // Объявляем массив для хранения указателя на строку
char            PINS[]                                = {A0, 4, 5};                                                         // Массив с номерами выводов устройств
uint8_t         MIN_TEMP_IN                           = 15;                                                                 // Минимальная температура срабатывания для термометра внутри помещения
uint8_t         MAX_TEMP_IN                           = 28;                                                                 // Максимальная температура срабатывания для термометра внутри помещения
uint8_t         MIN_TEMP_OUT                          = 10;                                                                 // Минимальная температура срабатывания для термометра снаружи помещения
uint8_t         MAX_TEMP_OUT                          = 35;                                                                 // Максимальная температура срабатывания для термометра снаружи помещения
uint16_t        MAX_GAS_VALUE                         = 450;                                                                // Максимальное значение концентрации газа
uint32_t        SMS_RESEND_TIME                       = 100000;                                                             // Время, по истечении которого производится повторная отправка СМС
uint32_t        WAITING_TIME_AFTER_SMS_FOR_TAKE_CALL  = 10000;                                                              // Время между отправкой СМС и совершением тревожного звонка
uint32_t        EMERGENCY_CALL_TALKING_TIME           = 30000;                                                              // Время разговора при тревожном звонке
uint32_t        TEMP_SENSOR_1_TIMER                   = 0;                                                                  // Таймер для датчика температуры внутри помещения на повторную отправку СМС
uint32_t        TEMP_SENSOR_2_TIMER                   = 0;                                                                  // Таймер для датчика температуры снаружи помещения на повторную отправку СМС
uint32_t        GAS_SENSOR_TIMER                      = 0;                                                                  // Таймер для датчика газа на повторную отправку СМС
uint32_t        MOTION_SENSOR_TIMER                   = 0;                                                                  // Таймер для датчика движения на повторную отправку СМС
uint32_t        GERKON_SENSOR_TIMER                   = 0;                                                                  // Таймер для датчика состояния на повторную отправку СМС
uint32_t        EMERGENCY_CALL_TIMER                  = 0;                                                                  // Таймер для совершения тревожного звонка
uint32_t        PHONE_TALKING_TIMER                   = 0;                                                                  // Таймер для времени дозванивания до абонента

void setup() {
  //Serial.begin(57600);
  sensor_inhouse.begin();                                                                                                   // Инициируем работу с термометром внутри помещения
  sensor_outhouse.begin();                                                                                                  // Инициируем работу с термометром снаружи помещения
  pinMode(PINS[0], INPUT);                                                                                                  // Настройка вывода на работу в режиме ВХОД
  pinMode(PINS[1], INPUT);                                                                                                  // Настройка вывода на работу в режиме ВХОД
  //Serial.print( F("Initialization, please wait ... ") );
  gsm.begin(softSerial);                                                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
  while (gsm.status() != GSM_OK) {                                                                                          // Ждём завершения регистрации модема в сети оператора связи.
    //Serial.print(".");
    delay(1000);
  }
  //Serial.println(" OK!");
  // Установка кодировки для символов Кириллицы:
  gsm.TXTsendCodingDetect("п");                                                                                             // Выполняем автоопределение кодировки скетча для отправки текста на Русском языке.
  // Отправка сообщения об удачном запуске:
  gsm.SMSsend( F("Инициализация прошла успешно."), NUMBER);                                                                 // Данная строка будет отвечать отправителю указанным SMS сообщением.
  delay(3000);                                                                                                              // задержка
  //Serial.println(F("================AFTER SETUP================="));
}

void loop () {

  TEXT = "";                                                                                                                // Очищаем строку
  //========================================================================================================================//
                                                    // ДАТЧИК ГАЗА

  if (analogRead(PINS[0]) >= MAX_GAS_VALUE) {                                                                               // Проверяем, не превышена ли концентрация газа и
    //Serial.println(F("gas inside VALUE"));
    if ((GAS_SENSOR_TIMER + SMS_RESEND_TIME) < millis() || GAS_SENSOR_TIMER == 0) {                                         // если превышена, то проверяем, чтобы сообщения отправлялись не чаще, чем 1 раз в SMS_RESEND_TIME
      //Serial.println(F("gas inside TIMER"));
      GAS_SENSOR_TIMER = millis();                                                                                          // Обновляем счётчик
      TEXT = "Превышена концентрация газа.\r\nЗначение = " + analogRead(PINS[0]);                                           // Формируем текст сообщения
      gsm.SMSsend(TEXT, NUMBER);                                                                                            // Отправляем СМС с текстом
      delay(1000);                                                                                                          // задержка
    }
  }
  TEXT = TEXT + "Газ: " + analogRead(PINS[0]) + "ppm";                                                                      // добавляем в строку текст, значение уровня концентрации газа и
  delay(5);                                                                                                                 // ждём 5мс
  //Serial.println(F("===============AFTER GAS SENSOR=============="));
  //========================================================================================================================//
                                            // ДАТЧИК ТЕМПЕРАТУРЫ ВНУТРЕННИЙ

  sensor_inhouse.requestTemperatures();                                                                                     // Запрос значения термометра внутри помещения
  if (sensor_inhouse.getTempCByIndex(0) <= MIN_TEMP_IN || sensor_inhouse.getTempCByIndex(0) >= MAX_TEMP_IN) {               // Проверяем, не выходит ли полученное значение за установленные границы и
    //Serial.println(F("temp 1 inside VALUE"));
    if ((TEMP_SENSOR_1_TIMER + SMS_RESEND_TIME) < millis() || TEMP_SENSOR_1_TIMER == 0) {                                   // если выходит, то проверяем, чтобы сообщения отправлялись не чаще, чем 1 раз в SMS_RESEND_TIME
      //Serial.println(F("temp 1 inside TIMER"));
      TEMP_SENSOR_1_TIMER = millis();                                                                                       // Обновляем счётчик
      TEXT = "Пороговое изменение температуры внутри.\r\nЗначение = " + String (sensor_inhouse.getTempCByIndex(0));         // Формируем текст сообщения
      gsm.SMSsend(TEXT, NUMBER);                                                                                            // Отправляем СМС с текстом
      delay(1000);                                                                                                          // задержка
    }
  }
  TEXT = TEXT + "\r\nТвнут: " + sensor_inhouse.getTempCByIndex(0);                                                          // добавляем в строку текст, значение термометра и
  delay(5);                                                                                                                 // ждём 5мс
  //Serial.println(F("=============AFTER TEMP 1 SENSOR=================="));
  //========================================================================================================================//
                                               // ДАТЧИК ТЕМПЕРАТУРЫ ВНЕШНИЙ
  sensor_outhouse.requestTemperatures();                                                                                    // Запрос значения термометра снаружи помещения
  if (sensor_outhouse.getTempCByIndex(0) <= MIN_TEMP_OUT || sensor_outhouse.getTempCByIndex(0) >= MAX_TEMP_OUT) {           // Проверяем, не выходит ли полученное значение за установленные границы и
    //Serial.println(F("temp 2 inside VALUE"));
    if ((TEMP_SENSOR_2_TIMER + SMS_RESEND_TIME) < millis() || TEMP_SENSOR_2_TIMER == 0) {                                   // если выходит, то проверяем, чтобы сообщения отправлялись не чаще, чем 1 раз в SMS_RESEND_TIME
      //Serial.println(F("temp 2 inside TIMER"));
      TEMP_SENSOR_2_TIMER = millis();                                                                                       // Обновляем счётчик
      TEXT = "Пороговое изменение температуры снаружи.\r\nЗначение = " + String (sensor_outhouse.getTempCByIndex(0));       // Формируем текст сообщения
      gsm.SMSsend(TEXT, NUMBER);                                                                                            // Отправляем СМС с текстом
      delay(1000);                                                                                                          // задержка
    }
  }
  TEXT = TEXT + "\r\nТвнеш: " + sensor_outhouse.getTempCByIndex(0);                                                         // добавляем в строку текст, значение термометра и
  delay(5);                                                                                                                 // ждём 5мс
  //Serial.println(F("=================AFTER TEMP 2 SENSOR===================="));
  //========================================================================================================================//
                                                    // ДАТЧИК ДВИЖЕНИЯ

  if (digitalRead(PINS[1])) {                                                                                               // Проверяем, не было ли сработки датчика движения и
    //Serial.println(F("motion inside DIGITAL READ"));
    if ((MOTION_SENSOR_TIMER + SMS_RESEND_TIME) < millis() || MOTION_SENSOR_TIMER == 0) {                                   // если было, то проверяем, чтобы сообщения отправлялись не чаще, чем 1 раз в SMS_RESEND_TIME
      //Serial.println(F("motion inside TIMER"));
      MOTION_SENSOR_TIMER = millis();                                                                                       // Обновляем счётчик
      gsm.SMSsend(F("Замечено движение!"), NUMBER);                                                                         // Отправляем СМС с текстом
      if ((EMERGENCY_CALL_TIMER + WAITING_TIME_AFTER_SMS_FOR_TAKE_CALL) < millis() || EMERGENCY_CALL_TIMER == 0 ) {         // Ждём, пока не пройдёт время WAITING_TIME_AFTER_SMS_FOR_TAKE_CALL, прежде чем совершим тревожный звонок
        //Serial.println(F("motion inside EMERGENCY CALL TIMER"));
        EMERGENCY_CALL_TIMER = millis();
        gsm.SOUNDdevice(GSM_HEADSET);                                                                                       // Укажем использование модулем гарнитуры
        // Закомментируйте строки 125-149 и раскомментируйте строку 150, если вам не требуется ограничение тревожного звонка по времени
        if (gsm.CALLdial(NUMBER)) {                                                                                         // Если исходящий вызов на номер NUMBER инициирован, то...
          //Serial.println(F("motion inside CALL DIAL"));
          //Serial.println(F("motion BEFORE OUT DIAL"));
          while (gsm.CALLstatus() == GSM_CALL_OUT_DIAL) {                                                                   // Цикл выполняется пока набирается номер ...
            // Можно добавить код который будет выполняться в процессе набора номера
            //Serial.println(F("dial-ing..."));
          }
          delay(500);                                                                                                       // Даём немного времени для установки состояния - "дозвон" или "соединён".
          //Serial.println(F("motion BEFORE OUT BEEP"));
          if (gsm.CALLstatus() == GSM_CALL_OUT_BEEP) {                                                                      // Если начались гудки дозвона, то ...
            //Serial.println(F("motion inside CALL OUT BEEP"));
            while (gsm.CALLstatus() == GSM_CALL_OUT_BEEP) {                                                                 // Цикл выполняется пока идут гудки дозвона ...
              // Можно добавить код который будет выполняться в процессе ожидания ответа
              //Serial.println(F("beep-ing..."));
            }
            delay(500);                                                                                                     // Даём немного времени для установки состояния - "соединён".
          }
          //Serial.println(F("motion BEFORE ACTIVE"));
          if (gsm.CALLstatus() == GSM_CALL_ACTIVE) {                                                                        // Если соединение установлено (абонент ответил), то ...
            //Serial.println(F("motion inside CALL ACTIVE"));
            PHONE_TALKING_TIMER = millis();
            while (gsm.CALLstatus() == GSM_CALL_ACTIVE && (PHONE_TALKING_TIMER + EMERGENCY_CALL_TALKING_TIME) > millis()) { // Цикл выполняется пока установлено активное голосовое соединение и не закончилось время тревожного звонка
              // Можно добавить код который будет выполняться в процессе разговора
              //Serial.println(F("talk-ing..."));
            }
            gsm.CALLend();                                                                                                  // После окончания указанного времени разрываем соединение
          }
        }
        //gsm.CALLdial(NUMBER);                                                                                             // Выполняем набор номера
      }
    }
  }
  TEXT = TEXT + "\r\nДвижение: -";                                                                                          // добавляем в строку текст, значение датчика движения и
  delay(5);                                                                                                                 // ждём 5мс
  //Serial.println(F("===============AFTER MOTION SENSOR=================="));
  //========================================================================================================================//
                                                // ДАТЧИК СОСТОЯНИЯ (ГЕРКОН)

  if (!digitalRead(PINS[2])) {                                                                                              // Проверяем, не было ли сработки датчика состояния и
    //Serial.println(F("gerkon inside DIGITAL READ"));
    if ((GERKON_SENSOR_TIMER + SMS_RESEND_TIME) < millis() || GERKON_SENSOR_TIMER == 0) {                                   // если было, то проверяем, чтобы сообщения отправлялись не чаще, чем 1 раз в SMS_RESEND_TIME
      //Serial.println(F("gerkon inside TIMER"));
      GERKON_SENSOR_TIMER = millis();                                                                                       // Обновляем счётчик
      gsm.SMSsend(F("Окно открыто!"), NUMBER);                                                                              // Отправляем СМС с текстом
      if ((EMERGENCY_CALL_TIMER + WAITING_TIME_AFTER_SMS_FOR_TAKE_CALL) < millis() || EMERGENCY_CALL_TIMER == 0 ) {         // Ждём, пока не пройдёт время WAITING_TIME_AFTER_SMS_FOR_TAKE_CALL, прежде чем совершим тревожный звонок
        //Serial.println(F("gerkon inside EMERGENCY CALL TIMER"));
        EMERGENCY_CALL_TIMER = millis();
        gsm.SOUNDdevice(GSM_HEADSET);                                                                                       // Укажем использование модулем гарнитуры
        // Закомментируйте строки 174-201 и раскомментируйте строку 202, если вам не требуется ограничение тревожного звонка по времени
        if (gsm.CALLdial(NUMBER)) {                                                                                         // Если исходящий вызов на номер NUMBER инициирован, то...
          //Serial.println(F("gerkon inside CALL DIAL"));
          //Serial.println(F("gerkon BEFORE OUT DIAL"));
          while (gsm.CALLstatus() == GSM_CALL_OUT_DIAL) {                                                                   // Цикл выполняется пока набирается номер ...
            // Можно добавить код который будет выполняться в процессе набора номера
            //Serial.println(F("dial-ing..."));
          }
          delay(500);                                                                                                       // Даём немного времени для установки состояния - "дозвон" или "соединён".
          //Serial.println(F("gerkon BEFORE OUT BEEP"));
          if (gsm.CALLstatus() == GSM_CALL_OUT_BEEP) {                                                                      // Если начались гудки дозвона, то ...
            //Serial.println(F("gerkon inside CALL OUT BEEP"));
            while (gsm.CALLstatus() == GSM_CALL_OUT_BEEP) {                                                                 // Цикл выполняется пока идут гудки дозвона ...
              // Можно добавить код который будет выполняться в процессе ожидания ответа
              //Serial.println(F("beep-ing..."));
            }
            delay(500);                                                                                                     // Даём немного времени для установки состояния - "соединён".
          }
          //Serial.println(F("gerkon BEFORE ACTIVE"));
          if (gsm.CALLstatus() == GSM_CALL_ACTIVE) {                                                                        // Если соединение установлено (абонент ответил), то ...
            //Serial.println(F("gerkon inside CALL ACTIVE"));
            PHONE_TALKING_TIMER = millis();
            while (gsm.CALLstatus() == GSM_CALL_ACTIVE && (PHONE_TALKING_TIMER + EMERGENCY_CALL_TALKING_TIME) > millis()) { // Цикл выполняется пока установлено активное голосовое соединение и не закончилось время тревожного звонка
              // Можно добавить код который будет выполняться в процессе разговора
              //Serial.println(F("talk-ing..."));
            }
            gsm.CALLend();                                                                                                  // После окончания указанного времени разрываем соединение
          }
        }
        //gsm.CALLdial(NUMBER);                                                                                             // Выполняем набор номера
      }
    }
  }
  TEXT = TEXT + "\r\nОкно: +";                                                                                              // добавляем в строку текст и
  delay(5);                                                                                                                 // ждём 5мс
  //Serial.println(F("=============AFTER GERKON================="));
  //========================================================================================================================//
                                                  // ЗАПРОС ОТЧЁТА

  if (gsm.SMSavailable()) {                                                                                                 // Функция SMSavailable() возвращает количество входящих непрочитанных SMS сообщений.
    //Serial.println(F("sms inside if AVAILABLE"));
    gsm.SMSread(SMStxt, SMSnum);                                                                                            // Читаем SMS сообщение в ранее объявленные переменные (текст SMS сообщения, номер SMS).
    if (!strcmp(NUMBER, SMSnum)) {                                                                                          // Проверим, что все указанный в условии номер и номер, с которого пришло СМС совпадают
      //Serial.println(F("sms inside if right NUMBER"));
      strSMStxt = SMStxt;                                                                                                   // Присваиваем массиву strSMStxt значение массива SMStxt для дальнейшей проверки на совпадения
      if (strSMStxt.indexOf(REPORT_COMMAND) != -1 ) {                                                                       // Если совпадение текста из массива с командой в условии найдено, то
        //Serial.println(F("sms inside if RIGHT COMMAND"));
        gsm.SMSsend(TEXT, NUMBER);                                                                                          // отправляем сообщение с отчётом
        delay(1000);                                                                                                        // задержка
      } else {                                                                                                              // Если текст пришёл не верный, то
        //Serial.println(F("sms inside if WRONG COMMAND"));
        gsm.SMSsend(F("Ошибка в тексте!"), NUMBER);                                                                         // отправляем об этом сообщение
        delay(1000);                                                                                                        // задержка
      }
    }
  }
  //Serial.println(F("===============AFTER REPORT COMMAND==================="));
  //========================================================================================================================//
                                             // ОТВЕТ НА ВХОДЯЩИЙ ЗВОНОК
                                                  
  if (gsm.CALLavailable(SMSnum)) {                                                                                          // Функция CALLavailable() возвращает true если есть входящий дозванивающийся вызов. В качестве аргумента функции можно указать строку в которую будет записан адрес (номер) вызывающего абонента.
    //Serial.println(F("call inside if available"));
    if (!strcmp(NUMBER, SMSnum)) {                                                                                          // Проверим, что все символы в двух строках совпадают (при совпадении функция strcmp возвращает 0)
      //Serial.println(F("call inside if right NUMBER"));
      gsm.SOUNDdevice(GSM_HEADSET);                                                                                         // Использовать гарнитуру для ввода/вывода звука.
      gsm.CALLup();                                                                                                         // Отвечаем на вызов. Если нужно сбросить вызов, то обращаемся к функции CALLend().
      while (gsm.CALLavailable()) {}                                                                                        // Цикл выполняется пока входящий дозванивающийся вызов не сменит статус на "активный голосовой вызов" или любой другой.
    }
  }
  //Serial.println(F("==========AFTER INCOMING CALL=================="));
}

Алгоритм работы скетча:

Обратите внимание на то, что при многократной отправке СМС с одинаковым текстом, возможно блокирование сообщений вашим оператором и внесение номера в "спам".

До кода void setup() определяются номера выводов, объявляются переменные и функции, подключаются библиотеки, и создаются объекты для работы с ними.

Перед загрузкой скетча не забудьте задать в переменной number[] номер телефона, куда будет приходить смс-уведомление о пройденной идентификации!

В коде void setup() конфигурируются выбранные выводы, инициируется работа GSM/GPRS Shield, выполняется цикл ожидания готовности GSM/GPRS Shield к работе (регистрация в сети оператора). И, после выполнения всех указанных действий, выполняется оповещение о готовности к работе, путем отправки смс на указанный номер.

Код void loop() выполняется в цикле. При получении СМС или при наступлении события, указанного в сценарии кода, устройство отправляет сообщение абоненту или совершает тревожный звонок. Чтобы после наступления события модуль не начал непрерывно отправлять сообщения или совершать звонки, в код была добавлена временная задержка delta_time, в течении которой модуль игнорирует повторные сработки. По истечении этого времени, если ничего не изменилось, модуль повторно отправит СМС или совершит тревожный звонок.

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

Сам код можно разделить на блоки:

Датчик газа:

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

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

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

Датчик температуры внутренний:

Указав в переменных MIN_TEMP_IN и MAX_TEMP_IN границы допустимых температур, настроим модуль на работу с цифровым термометром, расположенным внутри помещения.

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

Если температура внутри помещения в норме, то данные будут внесены в строку Text, которая при запросе пользователя будет выслана ему по СМС вместе с показателями других модулей.

Датчик температуры внешний:

Указав в переменных MIN_TEMP_OUT и MAX_TEMP_OUT границы допустимых температур, настроим модуль на работу с цифровым термометром, расположенным снаружи помещения.

Если температура снаружи помещения в норме, то данные будут внесены в строку Text, которая при запросе пользователя будет выслана ему по СМС вместе с показателями других модулей.

Датчик движения:

Проверяем, нет ли движения в радиусе действия датчика:

Если движение замечено, то модуль отправляет СМС абоненту на номер, указанный в переменной number, далее ждёт время waiting_timeи после этого совершает тревожный звонок на тот же номер.
В переменной gsm.SOUNDdevice указан параметр GSM_HEADSET, что означает, что на стороне модуля установлена гарнитура.
Тревожный звонок можно настроить:
- Модуль совершает тревожный звонок "до победного", пока абонент не снимет трубку или не начнёт работать автоответчик;
- Модуль совершает тревожный звонок, а после того, как трубка будет снята, ограничит разговор на время, указанное в переменной diall_waiting;
Если движение не замечено, то данные будут внесены в строку Text, которая при запросе пользователя будет выслана ему по СМС вместе с показателями других модулей.

Датчик состояния(геркон):

Проверяем, нет ли размыкания датчика:

Если датчик разомкнут, то модуль отправляет СМС абоненту на номер, указанный в переменной number, далее ждёт время waiting_timeи после этого совершает тревожный звонок на тот же номер.
В переменной gsm.SOUNDdevice указан параметр GSM_HEADSET, что означает, что на стороне модуля установлена гарнитура.
Тревожный звонок можно настроить:
- Модуль совершает тревожный звонок "до победного", пока абонент не снимет трубку или не начнёт работать автоответчик;
- Модуль совершает тревожный звонок, а после того, как трубка будет снята, ограничит разговор на время, указанное в переменной diall_waiting;
Если датчик замкнут, то данные будут внесены в строку Text, которая при запросе пользователя будет выслана ему по СМС вместе с показателями других модулей.

Запрос отчёта:

Модуль проверяет раз в секунду, нет ли входящего сообщения. Если сообщение есть, то модуль проверяет, совпадает ли номер, с которого пришло сообщение, с номером, указанным ранее в переменной number:

Если номер совпадает, то модуль проверяет текст сообщения:
- Если в тексте сообщения указана команда из переменной Func, то модуль отправляет ответное СМС с полным отчётом по всем датчикам;
- Если в тексте СМС ошибка, то модуль в ответном СМС уведомит об этом;
Если номер не совпадает, то модуль будет игнорировать текст СМС;

Ответ на входящий звонок:

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

В переменной gsm.SOUNDdevice указан параметр GSM_HEADSET, что означает, что на стороне модуля установлена гарнитура.

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

Ссылки:

Библиотека iarduino_GSM;
Библиотека OneWhire;
Библиотека DallasTemperature;
Arduino / Piranha UNO;
GSM/GPRS Shield;
Battery Shield;
Trema Shield;
Trema-модуль Цифровой термометр;
Цифровой термометр (герметичный);
Trema-модуль Датчик газа MQ-2 (широкого спектра);
ИК-датчик движения HC-SR501;
Магнитный извещатель (геркон);