GSM/GPRS Shield, A6

Исходники изображение:
Библиотеки:

GSM/GPRS Shield, A6 - позволяет работать в сетях сотовой связи по технологиям GSM/GPRS для приёма/передачи данных, отправки/получения SMS (Short Message Service) и осуществления телефонной голосовой связи.

GSM/GPRS Shield, A6 подключается по шине UART, а управление осуществляется AT-командами по стандарту GSM07.07,07.05 + команды TCP/IP. Для более удобной работы с GSM/GPRS Shield, A6 нами разработана библиотека iarduino_GSM.

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

Видео:

Общие сведения:

Есть несколько поколений сетей сотовой связи 1G, 2G, 3G, 4G ..., где G означает Generation - поколение, так вот 2G это и есть GSM (Global System for Mobile communications) - глобальная система мобильной связи. Это стандарт цифровой мобильной сотовой связи, с Гауссовской частотной модуляцией (GMSK), разделением каналов по времени (TDMA) и частоте (FDMA).

Значит GSM/GPRS Shield, A6 может работать только с SIM (Subscriber Identification Module) картами тех сотовых операторов, которые поддерживают стандарт сотовой связи 2G (GSM). К таким операторам относится тройка: MTS, Megafon и Beeline, о поддержке стандарта GSM другими операторами сотовой связи, уточняйте у их представителей.

GPRS (General Packet Radio Service) - пакетная радиосвязь общего пользования, это дополнение (или надстройка) к GSM позволяющая осуществлять обмен данными с другими устройствами и внешними сетями, в т.ч. интернет.

GSM/GPRS Shield, A6 построен на базе PCB модуля A6 производства компании Ai-Thinker, который отличается от своих конкурентов меньшим энергопотреблением. Не смотря на заявленное производителем пиковое (кратковременное) потребление тока до 2А, в процессе тестирования (в течении месяца) максимальное потребление тока не превышало 500 мА. Такое низкое энергопотребление (по сравнению с другими GSM модулями) позволяет работать от USB порта компьютера (ноутбука, планшета), а при питании от аккумуляторных батарей или Battery Shield, значительно увеличивает срок автономной работы. Для питания модуля на плате установлен импульсный DC-DC преобразователь, так же имеется преобразователь уровней для согласования выводов шины UART с 5В логикой. Встроенная PCB антенна позволяет работать без подключения внешней. Назначение переключателя шин UART и перемычек будут подробно рассмотрены ниже.

На плате имеются разъемы: 3,5 jack - для подключения гарнитуры (с микрофоном), PLS-2 - для подключения динамика и микрофона громкой связи, IPX U.FL - для подключения внешней антенны, SIM LG P970 - для установки SIM карты размера 2FF, а так же разъёмы для установки платы на Arduino/Piranha UNO/MEGA/Leonardo.

Спецификация:

  • Напряжение питания: 5 В (постоянного тока).
  • Потребляемый ток: до 3 мА (в спящем режиме).
  • Потребляемый ток: до 100 мА (в режиме ожидания).
  • Потребляемый ток: до 500 мА (в режиме соединения и разговора).
  • Потребляемый ток: до 2 А (пиковый) заявлен производителем модуля A6.
  • Поддерживаются: голосовая связь, SMS-сообщения, передача данных.
  • Стандарт сотовой связи: GSM/GPRS.
  • Чувствительность приёмника: -105 дБм.
  • Частотные диапазоны: 850, 900, 1800, 1900 МГц.
  • Класс GPRS: 10.
  • Максимальная скорость GPRS: 85,6 Кбит/сек (загрузка), 42,8 Кбит/сек (передача).
  • Форматы кодировки речи: HR, FR, EFR, AMR.
  • Используемая шина данных: UART.
  • Логические уровни шины UART: 5 В.
  • Тип передачи данных: AT-команды (стандарт GSM07.07,07.05 + команды TCP/IP).
  • Рабочая температура: -30 ... 80 °С.
  • Габариты: Shield.

Подключение:

GSM/GPRS Shield, A6 подключается по шине UART используя выводы D0 и D1, или D7, и D8 (зависит от положения переключателя на плате: "RX-0/TX-1" или "RX-7/TX-8"). Для выключения и перезагрузки модуля используется вывод D9 (модуль выключается подачей логической «1», а включается при наличии логического «0» или отсутствии логических уровней). Из выводов питания используются 5V, 3V3 и GND. Остальные выводы платы не задействованы.

Для удобства на плате указаны названия выводов к которым их требуется подключить (вывод D0 или D7 подключается к выводу RX шины UART Arduino/Piranha, а вывод D1 или D8 подключается к выводу TX шины UART Arduino/Piranha). Что удобно и при создании объекта программной шины UART: SoftwareSerial объект(RX,TX); значит для работы с выводами D7 и D8 нужно написать SoftwareSerial softSerial(7,8);.

Arduino/Piranha UNO:

Для подключения GSM/GPRS Shield, A6 к плате Arduino/Piranha UNO, достаточно установить Shield поверх платы, после чего выбрать переключателем требуемую шину UART:

Arduino/Piranha UNO
Для плат Arduino/Piranha UNO рекомендуем использовать программную шину UART на выводах D7 и D8, так как аппаратная шина UART на выводах D0 и D1 задействована USB-UART преобразователем. Значит переключатель нужно установить в положение "RX-7/TX-8".

Для реализации программной шины UART необходимо указать в скетче номера выводов, которые требуется использовать как RX и TX шины UART. При использовании библиотеки iarduino_GSM для работы с GSM/GPRS Shield, код создания и указания программной шины UART будет выглядеть следующим образом:
#include <iarduino_GSM.h> // подключаем библиотеку iarduino_GSM.
#include <softwareserial.h> // подключаем библиотеку SoftwareSerial.
iarduino_GSM gsm; // объект gsm для работы с GSM/GPRS Shield.
SoftwareSerial sfs(7,8); // объект для работы с шиной UART (выводы RX, TX).
... //
gsm.begin(softSerial); // указываем объект для работы с шиной UART.

Для подключения к платам Arduino/Piranha Mini или Nano можно воспользоваться Trema Shield NANO или проводами соединить выводы D7, D8, D9, 5V, 3V3 и GND платы GSM/GPRS Shield, A6 с одноимёнными выводами платы Arduino/Piranha Mini или Nano. Далее использовать скетч как для Arduino/Piranha UNO.

Arduino/Piranha Leonardo:

Для подключения GSM/GPRS Shield, A6 к плате Arduino/Piranha Leonardo, достаточно установить Shield поверх платы, после чего выбрать переключателем требуемую шину UART:

Arduino/Piranha Leonardo
Для плат Arduino/Piranha Leonardo рекомендуем использовать аппаратную шину UART1 (она использует выводы D0 и D1). Значит переключатель нужно установить в положение "RX-0/TX-1".

При использовании библиотеки iarduino_GSM для работы с GSM/GPRS Shield, код подготовки и указания аппаратной шины UART1 будет выглядеть следующим образом:

#include <iarduino_GSM.h> // подключаем библиотеку iarduino_GSM.
iarduino_GSM gsm; // объект gsm для работы с GSM/GPRS Shield.
... //
gsm.begin(Serial1); // указываем класс Serial1 для работы с шиной UART1.

Arduino/Piranha MEGA:

Для подключения GSM/GPRS Shield, A6 к плате Arduino/Piranha MEGA, нужно установить Shield на плату, как показано на рисунке:

Arduino/Piranha MEGA
Так как на платах Arduino/Piranha MEGA действуют ограничения на работу с программным UART (вывод RX можно назначить только на выводах: D10, D11, D12, D13, D14, D15, D50, D51, D52, D53, A8, A9, A10, A11, A12, A13, A14 и A15), то рекомендуем использовать аппаратную шину UART3. Значит переключатель нужно установить в положение "RX-7/TX-8", вывод 7 (RX) соединить с выводом RX3, а вывод 8 (ТХ) соединить с выводом TX3, как показано на рисунке. При этом выводы D7 и D8 нельзя задействовать для других целей.
(для работы с UART1 выводы нужно соединять не с RX3,TX3, а с RX1,TX1).
(для работы с UART2 выводы нужно соединять не с RX3,TX3, а с RX2,TX2).

При использовании библиотеки iarduino_GSM для работы с GSM/GPRS Shield, код подготовки и указания аппаратной шины UART3 будет выглядеть следующим образом:
#include <iarduino_GSM.h> // подключаем библиотеку iarduino_GSM.
iarduino_GSM gsm; // объект gsm для работы с GSM/GPRS Shield.
... //
pinMode(7,INPUT); // переводим вывод D7 в режим входа.
pinMode(8,INPUT); // переводим вывод D8 в режим входа.
gsm.begin(Serial3); // указываем класс Serial3 для работы с шиной UART3.

Звук:

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

Для громкой связи используется динамик и микрофон подключенные к разъемам PLS-2 с соответствующими значками.
Для включения громкой связи в библиотеке iarduino_GSM необходимо вызвать функцию SOUNDdevice(GSM_SPEAKER);(используется по умолчанию).
Для включения только микрофона громкой связи в библиотеке iarduino_GSM необходимо вызвать функцию SOUNDdevice(GSM_MICROPHONE);.
Для перевода звука на гарнитуру в библиотеке iarduino_GSM необходимо вызвать функцию SOUNDdevice(GSM_HEADSET);.

При работе с модулем через AT-команды, перевод звука между громкой связью и гарнитурой осуществляет команда AT+SNFS.

Антенна:

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

Внешняя GSM антенна подключается к разъему IPX UFL. При этом отключение встроенной GSM антенны не является обязательным.
Встроенная GSM антенна отключается путем разрыва контакта перемычки «JP ANT».

Вывод D9:

Вывод D9 используется для отключения и перезагрузки модуля. Модуль выключается подачей логической «1», а включается при наличии логического «0» или отсутствии логических уровней.

Если Вы НЕ ИСПОЛЬЗУЕТЕ библиотеку iarduino_GSM и в Вашем проекте нет необходимости отключать или перезагружать модуль, то вывод D9 можно освободить для других целей, разорвав контакт перемычки «JP OFF».

Работа с модулем:

Для работы с GSM/GPRS Shield предлагаем воспользоваться библиотекой iarduino_GSM, позволяющей устанавливать голосовые соединения и обмениваться SMS (в т.ч. на Русском языке) используя несколько простых и понятных функций.

Примеры:

Отправка короткого SMS сообщения:

//  Данный пример демонстрирует отправку SMS сообщений:                                       //
//  ========================================================================================= //
                                                                                              //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
void setup(){                                                                                 //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Установка кодировки для символов Кириллицы:                                               //
    gsm.TXTsendCodingDetect("п");                                                             // Выполняем автоопределение кодировки скетча для отправки текста на Русском языке.
                                                                                              //
//  Отправка SMS сообщения:                                                                   //
    if( gsm.SMSsend("Это короткое SMS сообщение", "70123456789") )                            // Отправляем короткое SMS сообщение на номер +7(012)345-67-89
    { Serial.println("Sent!"); }else{ Serial.println( "Error!" ); }                           // Выводим результат отправки SMS сообщения
                                                                                              //
}                                                                                             //
                                                                                              //
void loop (){                                                                                 //
}                                                                                             //

В данном примере используется программная шина UART для работы с GSM/GPRS Shield. Отправка SMS сообщения осуществляется функцией SMSsend() с двумя параметрами: строка с отправляемым текстом и строка с номером телефона (перед телефоном можно указывать символ +). Функция SMSsend() возвращает флаг результата отправки сообщения (true или false), что используется в примере для вывода сообщений "Sent!" или "Error!".

Важно: Измените номер получателя SMS перед загрузкой данного скетча!

Текст сообщения не должен превышать 70 символов, если в нём есть хотя бы 1 символ Кириллицы. Текст без символов Кириллицы не должен превышать 160 символов.

Отправка большого (составного) SMS сообщения:

​​//  Данный пример демонстрирует отправку SMS сообщений:                                       //
//  ========================================================================================= //
                                                                                              //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
void setup(){                                                                                 //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Установка кодировки для символов Кириллицы:                                               //
    gsm.TXTsendCodingDetect("п");                                                             // Выполняем автоопределение кодировки скетча для отправки текста на Русском языке.
                                                                                              //
//  Отправка SMS сообщения:                                                                   //
    if(gsm.SMSsend("Это длинное SMS сообщение состоящее из двух", "70123456789", 0x1234,2,1)) // Отправляем 1 часть составного (длинного) SMS сообщения на номер +7(012)345-67-89
    { Serial.println("1 Sent!"); }else{ Serial.println( "1 Error!" ); }                       //
                                                                                              //
    if(gsm.SMSsend(" SMS, которые придут получателю как 1 часть", "70123456789", 0x1234,2,2)) // Отправляем 2 часть составного (длинного) SMS сообщения на номер +7(012)345-67-89
    { Serial.println("2 Sent!"); }else{ Serial.println( "2 Error!" ); }                       //
                                                                                              //
}                                                                                             //
                                                                                              //
void loop (){                                                                                 //
}                                                                                             //

Данный пример похож на предыдущий, но одно сообщение отправляется двумя SMS, которые на телефоне получателя будут отображаться как одно длинное сообщение. Обратите внимание на то, что функция SMSsend() теперь принимает не два, а пять параметров: строка с текстом, строка с телефоном, идентификатор всего сообщения (число от 1 до 65535 одинаковое для всех SMS в составе одного сообщения), количество SMS в сообщении (число от 2 до 255 одинаковое для всех SMS в составе одного сообщения) и номер данной SMS в сообщении (число определяющее порядок "склейки" сообщений на принимающей стороне).

Важно: Измените номер получателя SMS перед загрузкой данного скетча!

Текст одной SMS не должен превышать 66 символов, если в тексте этой SMS есть хотя бы 1 символ Кириллицы (не во всём сообщении, а именно в тексте этой SMS). Текст SMS без символов Кириллицы не должен превышать 152 символа.

Получение коротких SMS сообщений:

//  Данный пример демонстрирует получение коротких SMS сообщений:                             //
//  ========================================================================================= //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
    char SMStxt[161];                                                                         // Объявляем строку для хранения текста принятых SMS сообщений.
    char SMSnum[ 13];                                                                         // Объявляем строку для хранения номера отправителя SMS сообщений.
    char SMStim[ 18];                                                                         // Объявляем строку для хранения даты и времени отправки SMS сообщений.
                                                                                              //
void setup(){                                                                                 //
//  Выводим текст в монитор последовательного порта:                                          //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Установка кодировки для символов Кириллицы:                                               //
//  gsm.TXTreadCoding(GSM_TXT_CP866);                                                         // Если символы Кириллицы входящих SMS сообщений некорректно отображаются в мониторе, выберите одну из кодировок: GSM_TXT_CP866 / GSM_TXT_UTF8 / GSM_TXT_WIN1251.
}                                                                                             // По умолчанию для входящих и исходящих SMS сообщений установлена кодировка GSM_TXT_UTF8.
                                                                                              //
void loop (){                                                                                 //
    if(gsm.SMSavailable()){                                                                   // Функция SMSavailable() возвращает количество входящих непрочитанных SMS сообщений.
//  Если есть входящие непрочитанные SMS сообщения:                                           //
        Serial.println( "SMS came, I read ..." );                                             // Выводим текст "Пришла SMS, читаю ... ".
        gsm.SMSread(SMStxt, SMSnum, SMStim);                                                  // Читаем SMS сообщение в ранее объявленные переменные (текст SMS сообщения, адрес отправителя, дата отправки).
        Serial.print  ( "SMS sent on "    ); Serial.print  ( SMStim );                        // Выводим дату отправки.
        Serial.print  ( " from number "   ); Serial.print  ( SMSnum );                        // Выводим номер отправителя.
        Serial.println( ", message text:" ); Serial.println( SMStxt );                        // Выводим текст сообщения.
    }                                                                                         //
}                                                                                             //

При получении SMS в мониторе последовательного порта появится сообщение "SMS came, I read ...", после чего появится информация принятого SMS сообщения:
"SMS sent on ДД.ММ.ГГ ЧЧ:ММ:СС from number 70123456789, message text: ТЕКСТ SMS".

Функция SMSread() имеет только один обязательный параметр - строка для получения текста SMS сообщения, а строки для получения номера отправителя и даты отправки можно не указывать. Так же функция SMSread() возвращает флаг результата чтения сообщения (true или false), по этому её можно взять в условие оператора if() для оповещения об успехе чтения, как это сделано с функцией SMSsend() в предыдущем скетче.

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

Получение коротких и больших (составных) SMS сообщений:

//  Данный пример демонстрирует получение коротких и составных SMS сообщений:                 //
//  ========================================================================================= //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
    char SMStxt[161];                                                                         // Объявляем строку для хранения текста принятых SMS сообщений.
    char SMSnum[ 13];                                                                         // Объявляем строку для хранения номера отправителя SMS сообщений.
    char SMStim[ 18];                                                                         // Объявляем строку для хранения даты и времени отправки SMS сообщений.
    uint16_t SMSlongID;                                                                       // Объявляем переменную для хранения идентификатора составного SMS сообщения.
    uint8_t  SMSlongSUM;                                                                      // Объявляем переменную для хранения количества SMS в составном сообщении.
    uint8_t  SMSlongNUM;                                                                      // Объявляем переменную для хранения номера SMS в составном сообщении.
                                                                                              //
void setup(){                                                                                 //
//  Выводим текст в монитор последовательного порта:                                          //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Установка кодировки для символов Кириллицы:                                               //
//  gsm.TXTreadCoding(GSM_TXT_CP866);                                                         // Если символы Кириллицы входящих SMS сообщений некорректно отображаются в мониторе, выберите одну из кодировок: GSM_TXT_CP866 / GSM_TXT_UTF8 / GSM_TXT_WIN1251.
}                                                                                             // По умолчанию для входящих и исходящих SMS сообщений установлена кодировка GSM_TXT_UTF8.
                                                                                              //
void loop (){                                                                                 //
    if(gsm.SMSavailable()){                                                                   // Функция SMSavailable() возвращает количество входящих непрочитанных SMS сообщений.
//  Если есть входящие непрочитанные SMS сообщения:                                           //
        Serial.println( "SMS came, I read ..." );                                             // Выводим текст "Пришла SMS, читаю ... ".
        gsm.SMSread(SMStxt, SMSnum, SMStim, SMSlongID, SMSlongSUM, SMSlongNUM);               // Читаем SMS сообщение в ранее объявленные переменные (текст SMS сообщения, адрес отправителя, дата отправки, идентификатор SMS, количество SMS, номер SMS).
        Serial.print  ( "SMS "            ); Serial.print  ( SMSlongNUM );                    // Выводи номер SMS.
        Serial.print  ( " in "            ); Serial.print  ( SMSlongSUM );                    // Выводим количество SMS.
        Serial.print  ( ", ID="           ); Serial.print  ( SMSlongID  );                    // Выводим идентификатор сообщения.
        Serial.print  ( ", sent on "      ); Serial.print  ( SMStim     );                    // Выводим дату отправки.
        Serial.print  ( " from number "   ); Serial.print  ( SMSnum     );                    // Выводим номер отправителя.
        Serial.println( ", message text:" ); Serial.println( SMStxt     );                    // Выводим текст сообщения.
    }                                                                                         //
}                                                                                             //

Данный скетч отличается от предыдущего только тем, что в нём объявлены три дополнительные переменные: SMSlongID, SMSlongSUM и SMSlongNUM. Эти переменные указаны как дополнительные параметры функции SMSread() для получения идентификатора сообщения, количестве и номере SMS в составе большого сообщения. После чего указанные значения, вместе со значениями предыдущего скетча, выводятся в монитор порта:
"SMS 3 in 5, ID=65535, sent on ДД.ММ.ГГ ЧЧ:ММ:СС from number 70123456789, message text: ТЕКСТ SMS".

При получении короткого SMS сообщения, в мониторе порта будет указано, что идентификатор равен 0, количество SMS в сообщении равно 1 и номер данной SMS равен 1.

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

Запрос баланса:

//  Данный пример демонстрирует отправку USSD запроса *100# с получением ответа:              //
//  ========================================================================================= //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
void setup(){                                                                                 //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Установка кодировки для символов Кириллицы:                                               //
//  gsm.TXTreadCoding(GSM_TXT_CP866);                                                         // Если символы Кириллицы входящих SMS сообщений некорректно отображаются в мониторе, выберите одну из кодировок: GSM_TXT_CP866 / GSM_TXT_UTF8 / GSM_TXT_WIN1251.
                                                                                              // По умолчанию установлена кодировка GSM_TXT_UTF8.
//  Отправка USSD запроса *100# с выводом ответа в монитор последовательного порта:           //
    Serial.println( "Sending USSD request \"*100#\" ..." );                                   // Выводим текст: Отправка USSD запроса "*100#" ...
    Serial.print  ( "Answer: " );                                                             // Выводим текст: Ответ
    Serial.println( gsm.runUSSD("*100#") );                                                   // Отравляем USSD запрос "*100#" возвращая ответ в монитор последовательного порта.
}                                                                                             //
                                                                                              //
void loop (){                                                                                 //
}                                                                                             //

Функция runUSSD() принимает строку c текстом USSD команды и возвращает текст ответа на указанную команду. В данном примере функция runUSSD() вызвана с параметром "*100#", а её ответ (текст) будет выведен в монитор.

У большинства Российских операторов связи, команда *100# означает запрос баланса.

На заметку: Вы можете выполнять любые USSD запросы поддерживаемые Вашим оператором связи (не только *100#).

Многие Российские операторы связи придерживаются правила, что ответ на команду начинающуюся с символа '*' возвращается на Русском, а при замене данного символа на символ '#' ответ возвращается на Латинице. Например, команда #100# вернёт баланс на Латинице (для большинства операторов связи).

Совершение исходящего голосового вызова:

//  Данный пример демонстрирует совершение исходящего голосового вызова:                      //
//  ========================================================================================= //
                                                                                              //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
void setup(){                                                                                 //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
                                                                                              //
//  Инициируем исходящий вызов на указанный ниже номер:                                       // Номер можно указывать со знаком плюс ("+70123456789") или указывать короткие номера (например, "0525" - голосовая почта beeline).
    if(gsm.CALLdial( "70123456789" )){                                                        // Если исходящий вызов на номер +7(012)345-67-89 инициирован, то...
        Serial.println( "Dialing ..." );                                                      //
    }else{                                                                                    //
        Serial.println( "Error!" );                                                           //
    }                                                                                         //
}                                                                                             //
                                                                                              //
void loop (){                                                                                 // В данном скетче вызов не осуществляется в цикле loop, для экономии Ваших средств на счёте.
}                                                                                             //

При старте скетча будет осуществлён исходящий голосовой вызов на номер +7(012)345-67-89. Этот скетч уже может претендовать на готовый проект. Подключите к GSM/GPRS Shield динамик и микрофон, и оставьте его подключённым к USB порту компьютера (или 5В шине питания внутри корпуса системного блока). Теперь при кадом включении компьютера будет осуществляться звонок на указанный в скетче номер телефона. Вам останется лишь поднять трубку и сказать "А ну быстро выключи мой компьютер! )))".

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

Ответ на входящий голосовой вызов:

//  Данный пример демонстрирует ответ на входящий голосовой вызов:                            //
//  ========================================================================================= //
                                                                                              //
    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
                                                                                              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
                                                                                              //
void setup(){                                                                                 //
    Serial.begin(9600);                                                                       // Инициируем передачу данных по аппаратной шине UART для вывода результата в монитор последовательного порта.
    Serial.print( "Initialization, please wait ... " );                                       // Выводим текст.
                                                                                              //
    gsm.begin(softSerial);                                                                    // Инициируем работу GSM/GPRS Shield, указывая объект шины UART.
                                                                                              //
//  Ждём готовность GSM/GPRS Shield к работе:                                                 //
    while(gsm.status()!=GSM_OK){Serial.print("."); delay(1000);} Serial.println(" OK!");      // Ждём завершения регистрации модема в сети оператора связи.
}                                                                                             //
                                                                                              //
void loop (){                                                                                 //
//  Если есть входящий вызов:                                                                 //  
    if(gsm.CALLavailable()){                                                                  // Функция CALLavailable() возвращает true если есть входящий дозванивающийся вызов. В качестве аргумента функции можно указать строку в которую будет записан адрес (номер) вызывающего абонента.
        Serial.println( "Incoming call" );                                                    // Входящий вызов.
        gsm.CALLup();                                                                         // Отвечаем на вызов. Если нужно сбросить вызов, то обращаемся к функции CALLend().
        while(gsm.CALLavailable()){}                                                          // Цикл выполняется пока входящий дозванивающийся вызов не сменит статус на "активный голосовой вызов" или любой другой.
    }                                                                                         //
    delay(1000);                                                                              // Проверяем наличие входящих звонков один раз в секунду.
}                                                                                             //

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

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

Описание функций библиотеки:

Библиотека iarduino_GSM позволяет устанавливать голосовые соединения и обмениваться SMS (в т.ч. на Русском языке) используя несколько простых и понятных функций:

Подключение библиотеки:

    #include <iarduino_GSM.h>                                                                 // Подключаем библиотеку iarduino_GSM для работы с GSM/GPRS Shield.
    iarduino_GSM gsm;                                                                         // Создаём объект gsm для работы с функциями и методами библиотеки iarduino_GSM.
//  Следующие 2 строки нужны для работы по программной шине UATR (выводы 7 и 8):              //
    #include <softwareserial.h>                                                               // Подключаем библиотеку SoftwareSerial для программной реализации шины UART.
    SoftwareSerial softSerial(7,8);                                                           // Создаём объект softSerial указывая выводы RX и TX платы Arduino.
//  Если Вы работаете c GSM/GPRS Shield по аппаратной шине UATR, удалите 2 предыдущие строки, //
//  а в функции gsm.begin(), вместо softSerial укажите Serial или Serial1, Serial2 ...        // Зависит от номера используемой аппаратной шины UART.

Функция begin();

  • Назначение: инициализация работы с GSM/GPRS Shield.
  • Синтаксис: begin( UART );
  • Параметры:
    • UART - объект или класс используемые для работы с шиной UART.
  • Возвращаемое значение: (bool) результат инициализации true/false.
  • Примечание:
    • Если используется программная реализация шины UART на выводах D7 и D8, то в качестве параметра функции указывается объект библиотеки softwareserial. Рекомендуем использовать программную реализацию шины UART при работе с платами UNO, Nano, Mini.
    • Если используется аппаратная реализация шины UART то в качестве параметра функции указывается класс Serial или Serial1, Serial2, Serial3 и т.д. Рекомендуем использовать аппаратную реализацию шины UART с платами Leonardo и Mega.
    • Если модуль был выключен функцией pwr(), то он будет включён.
    • Функцию begin() достаточно вызвать один раз в коде setup().
    • Данную функцию нужно вызвать до обращения к остальным функциям библиотеки.
  • Пример:
gsm.begin(softSerial); // Инициализация с указанием объекта softSerial для работы по программной шине UART.
gsm.begin(Serial1);    // Инициализация с указанием класса Serail1 для работы по аппаратной шине UART1.

Функция status();

  • Назначение: получение состояния GSM/GPRS Shield.
  • Синтаксис: status();
  • Параметры: нет.
  • Возвращаемое значение: соответствует одной из констант:
    • GSM_OK - модуль готов к работе.
    • GSM_SPEED_ERR - не удалось согласовать скорость UART.
    • GSM_UNAVAILABLE - модуль недоступен (AT-команды не выполняются).
    • GSM_UNKNOWN - статус неизвестен (AT-команды могут не выполнятся).
    • GSM_SLEEP - модуль режиме ограниченной функциональности.
    • GSM_SIM_PIN - требуется ввод PIN1 (CHV1).
    • GSM_SIM_PUK - требуется ввод PUK1 и новый PIN1.
    • GSM_SIM_PIN2 - требуется ввод PIN2 (CHV2).
    • GSM_SIM_PUK2 - требуется ввод PUK2 и новый PIN2.
    • GSM_SIM_NO - нет SIM-карты.
    • GSM_SIM_FAULT - SIM-карта неисправна.
    • GSM_SIM_ERR - неопределённое состояние SIM-карты.
    • GSM_REG_NO - модем не зарегистрирован в сети оператора.
    • GSM_REG_FAULT - регистрация модема в сети оператора отклонена.
    • GSM_REG_ERR - статус регистрации модема в сети оператора не читается.
  • Примечание:
    • Функцию status() удобно использовать сразу после функции begin() для ожидания регистрации модема в сети оператора связи, определения необходимости ввода pin-кода, информирования об отсутствии SIM-карты и т.д.
    • Так же функцию удобно использовать в коде loop() для отслеживания разрыва регистрации с сетью оператора связи.
  • Пример:
if( gsm.status()==GSM_SIM_PIN   ){ gsm.pin("1234"); } // Вводим pin-код "1234" если он нужен.
while( gsm.status()==GSM_REG_NO ){ delay(1000); }     // Ждём завершения регистрации модема в сети оператора связи.
while( gsm.status()!=GSM_OK     ){ delay(1000); }     // Ждём полной готовности модуля к работе (включая регистрацию модема в сети оператора связи).

Функция pin();

  • Назначение: ввод PIN-кода (CHV1).
  • Синтаксис: pin( "PIN" );
  • Параметры:
    • "PIN" - строка с PIN-кодом (CHV1).
  • Возвращаемое значение: (bool) флаг корректности введённого PIN-кода true/false.
  • Примечание:
    • PIN-код вводится только после того, как функция status() вернула GSM_SIM_PIN.
    • Некорректный ввод PIN-кода 3 раза подряд, приведёт к необходимости смены PIN-кода с вводом PUK1.
  • Пример:
if( gsm.status()==GSM_SIM_PIN ){ gsm.pin("1234"); } // Вводим pin-код "1234" если он нужен.

Функция puk();

  • Назначение: ввод PUK-кода (PUK1) и нового PIN-кода (CHV1).
  • Синтаксис: puk( "PUK", "PIN" );
  • Параметры:
    • "PUK" - строка с PUK-кодом (PUK1).
    • "PIN" - строка с новым PIN-кодом (CHV1).
  • Возвращаемое значение: (bool) флаг корректности введённого PUK-кода true/false.
  • Примечание:
    • PUK-код вводится только после того, как функция status() вернула GSM_SIM_PUK.
    • Некорректный ввод PUK-кода 10 раз подряд, приведёт к порче SIM-карты.
    • Если в качестве нового значения PIN-кода указать "0000", то его ввод более не потребуется.
  • Пример:
if( gsm.status()==GSM_SIM_PUK ){ gsm.puk("12345678","0000"); } // Вводим puk-код "123456789" и новый pin-код "0000".

Функция pwr();

  • Назначение: включение/выключение модуля.
  • Синтаксис: pwr( ФЛАГ );
  • Параметры:
    • ФЛАГ - значение (bool) true- включить / false- выключить модуль.
  • Возвращаемое значение: нет.
  • Примечание:
    • По умолчанию модуль включён.
    • Функция использует вывод D9.
    • При включении модуля функцией pwr() его инициализация происходит автоматически, но на это требуется время, как при обращении к функции begin().
    • Для перезагрузки модуля воспользуйтесь функцией reset().
  • Пример:
gsm.pwr(false); // Отключить модуль.
gsm.pwr(true);  // Включить модуль.

Функция reset();

  • Назначение: перезагрузка модуля.
  • Синтаксис: reset();
  • Параметры:
  • Возвращаемое значение: нет.
  • Примечание:
    • Функция выключает модуль, ждёт 2 секунды (согласно рекомендациям разработчика) и включает модуль выполняя код: pwr(false); delay(2000); pwr(true);.
    • Следовательно, к данной функции применимы и все примечания функции pwr().
  • Пример:
if(gsm.runAT("AT").indexOf( "OK" ) < 0){ // Если модуль не ответил OK на команду AT, то
    gsm.reset();                         // Перезагружаем модуль ...
}                                        //

Функция runAT();

  • Назначение: выполнение AT-команды.
  • Синтаксис: runAT( "КОМАНДА" [,ТАЙМАУТ [,ФЛАГ]] );
  • Параметры:
    • "КОМАНДА" - строка с AT-командой которую требуется выполнить.
    • ТАЙМАУТ - число (uint32_t), необязательный параметр, время в мс отводимое на выполнение AT-команды. По умолчанию 200 мс.
    • ФЛАГ - (bool), необязательный параметр, true- разрешить /false- запретить, досрочный выход из функции при наличии в ответе комбинации символов "OK" или "ERROR". По умолчанию true.
  • Возвращаемое значение: (String) строка с ответом на команду.
  • Примечание:
    • Текст AT-команды должен заканчиваться символом \r или символами \r\n .
    • Текст ответа на AT-команды так же содержит символы \r\n.
  • Пример:
Serial.println( gsm.runAT("AT+CSQ\r\n", 1000, false) ); // Вывести результат AT-команды "AT+CSQ" (запрос уровня сигнала), выделить на выполнение команды 1000 мс, запретить досрочный выход - ждать указанное время вне зависимости от ответа.
Serial.println( gsm.runAT("AT+CSQ\r\n", 1000       ) ); // Вывести результат AT-команды "AT+CSQ" (запрос уровня сигнала), выделить на выполнение команды 1000 мс, разрешить досрочный выход при получении "ОК" или "ERROR" (по умолчанию).
Serial.println( gsm.runAT("AT+CSQ\r\n"             ) ); // Вывести результат AT-команды "AT+CSQ" (запрос уровня сигнала), выделить на выполнение команды 200 мс (по умолчанию), разрешить досрочный выход при получении "ОК" или "ERROR" (по умолчанию).

Функция runUSSD();

  • Назначение: выполнение USSD запроса.
  • Синтаксис: runUSSD( "КОМАНДА" );
  • Параметры:
    • "КОМАНДА" - строка с командой USSD запроса.
  • Возвращаемое значение: (String) строка с ответом на USSD запрос.
  • Примечание:
    • Ответы могут содержать символы Кириллицы, если ответ на Русском языке отображается некорректно, см. функцию TXTreadCoding().
    • Многие Российские операторы связи придерживаются правила, что ответ на команду начинающуюся с символа '*' возвращается на Русском, а при замене данного символа на символ '#' ответ возвращается на Латинице.
  • Пример:
Serial.println( gsm.runUSSD("*100#") ); // Вывести баланс (ответ на команду *100# ).

Функция signal();

  • Назначение: запрос уровня принимаемого сигнала.
  • Синтаксис: signal();
  • Параметры: нет.
  • Возвращаемое значение: число (uint8_t) от 0 до 31.
  • Примечание:
    • 0 - уровень сигнала -113 дБм и ниже,
    • 1 ... 30 уровень сигнала от -111 дБм ... -53 дБм (шаг 2 дБм).
    • 31 - уровень принимаемого сигнала -51 дБм и выше.
  • Пример:
uint8_t i = gsm.signal();                // Получаем уровень приёма сигнала
if( i==0 ){Serial.println("    ");}else  // При уровне приёма ниже -113дБм или равном.
if( i<8  ){Serial.println("█   ");}else  // При уровне приёма ниже -97дБм.
if( i<16 ){Serial.println("██  ");}else  // При уровне приёма ниже -81дБм.
if( i<24 ){Serial.println("███ ");}else  // При уровне приёма ниже -65дБм.
          {Serial.println("████");}      // При уровне приёма выше -65дБм или равном.

Функция SMSavailable();

  • Назначение: запрос количества принятых непрочитанных SMS сообщений.
  • Синтаксис: SMSavailable();
  • Параметры: нет.
  • Возвращаемое значение: число (uint8_t) количество принятых непрочитанных SMS.
  • Примечание:
    • Принятые SMS сообщения хранятся на SIM-карте, пока они не будут прочитаны.
    • Если память SIM-карты заполнена, то модуль не будет принимать новые входящие сообщения, пока не будут прочитаны старые (хранящиеся на SIM-карте).
    • Сообщения удаляются с SIM-карты сразу после их чтения функцией SMSread().
    • Общий объем памяти SIM-карты для SMS можно узнать функцией SMSmax().
  • Пример:
if( gsm.SMSavailable() ){                     // Функция SMSavailable() возвращает количество входящих непрочитанных SMS сообщений.
    Serial.println( "I have incoming SMS!" ); // Выводим текст "Имеются входящие SMS".
}                                             //

Функция SMSmax();

  • Назначение: запрос объема памяти SMS на SIM карте.
  • Синтаксис: SMSmax();
  • Параметры: нет.
  • Возвращаемое значение: число (uint8_t) максимальное количество хранимых SMS.
  • Примечание:
    • Принятые SMS сообщения хранятся на SIM-карте, пока они не будут прочитаны.
    • Если память SIM-карты заполнена, то модуль не будет принимать новые входящие сообщения, пока не будут прочитаны старые (хранящиеся на SIM-карте).
    • Сообщения удаляются с SIM-карты сразу после их чтения функцией SMSread().
  • Пример:
Serial.println( "You can store "    );  // Вы можете хранить
Serial.println( gsm.SMSmax()        );  // Количество
Serial.println( "SMS on a SIM card" );  // SMS на SIM-карте

Функция SMSread();

  • Назначение: чтение одного входящего не прочитанного SMS сообщения.
  • Синтаксис: SMSread( ТЕКСТ [,АДРЕС [,ДАТА [,ID,КОЛИЧЕСТВО,НОМЕР]]] );
  • Параметры:
    • ТЕКСТ - строка (char[161]) в которую требуется сохранить текст SMS сообщения. Текст сообщение может достигать 160 символов + символ конца строки.
    • АДРЕС - строка (char[13]) в которую требуется сохранить адрес (номер) отправителя SMS. Адрес отправителя может достигать 12 символов + символ конца строки.
    • ДАТА - строка (char[18]) в которую требуется сохранить дату отправки SMS. Дата отправки сообщения содержит 17 символов "ДД.ММ.ГГ ЧЧ:ММ:СС" + символ конца строки.
    • ID - переменная (uint16_t) в которую требуется сохранить идентификатор. Если сообщение состоит из нескольких SMS (составное сообщение), то у каждой SMS данного сообщения будет один и тот же идентификатор. Если сообщение состоит из 1 SMS, то идентификатор будет равен 0.
    • КОЛИЧЕСТВО - переменная (uint8_t) в которую требуется сохранить количество SMS в составном сообщении. Если сообщение состоит из 1 SMS, то количество будет равно 1.
    • НОМЕР - переменная (uint8_t) в которую требуется сохранить номер данной SMS в составном сообщении. Если сообщение состоит из 1 SMS, то номер будет равен 1.
  • Возвращаемое значение: (bool) флаг корректности чтения true/false.
  • Примечание:
    • Если предполагается принимать только короткие SMS сообщения (сообщения состоящие из одной SMS), то параметры ID, КОЛИЧЕСТВО и НОМЕР можно не указывать.
    • Параметры АДРЕС и ДАТА так же являются необязательными.
    • ТЕКСТ короткого SMS сообщения может достигать 160 символов (без Кириллицы) или 70 символов (если в тексте есть хотя бы один символ Кириллицы).
    • ТЕКСТ одной SMS в составе составного сообщения может достигать 152 символов (без Кириллицы) или 66 символов (если в тексте данной SMS есть хотя бы один символ Кириллицы).
    • Данная функция удаляет SMS сообщение из памяти SIM-карты, сразу после его чтения.
    • SMS сообщения читаются в порядке их поступления.
    • символы Кириллицы отображаются некорректно, см. функцию TXTreadCoding().
  • Пример:
char SMStxt[161];                 // Объявляем строку (массив) для получения текста SMS.
char SMSadr[13];                  // Объявляем строку (массив) для получения адреса отправителя SMS.
if(gsm.SMSavailable()){           // Если есть SMS сообщения, то ...
    gsm.SMSread(SMStxt, SMSadr);  // Читаем SMS сообщение (только текст и адрес отправителя).
    Serial.println(SMSadr);       // Выводим адрес (номер) отправителя SMS.
    Serial.println(SMStxt);       // Выводим текст SMS сообщения.
}                                 //

Функция SMSsend();

  • Назначение: отправка одного SMS сообщения.
  • Синтаксис: SMSsend( "ТЕКСТ" ,"АДРЕС" [,ID,КОЛИЧЕСТВО,НОМЕР] );
  • Параметры:
    • "ТЕКСТ" - текст отправляемого SMS сообщения, может содержать символы Кириллицы.
    • "АДРЕС" - текст с номером получателя SMS сообщения. Можно указывать короткие номера, ведущий символ '+' в номере телефона можно не указывать.
    • ID - идентификатор, случайное число (uint16_t), указывается только для SMS составного сообщения. Составное сообщение это длинное сообщение состоящее из нескольких SMS с одним и тем же идентификатором, такое сообщение отображается на телефоне получателя как одно большое сообщение.
    • КОЛИЧЕСТВО - число (uint8_t) указывается только для SMS составного сообщения. Определяет количество SMS в составе составного сообщения.
    • НОМЕР - число (uint8_t) указывается только для SMS составного сообщения. Определяет порядковый номер данной SMS в составе составного сообщения.
  • Возвращаемое значение: (bool) флаг корректности отправкиtrue/false.
  • Примечание:
    • Если отправляется обычное (короткое) SMS сообщение, то параметры ID, КОЛИЧЕСТВО и НОМЕР не указываются.
    • ТЕКСТ короткого SMS сообщения не может превышать 160 символов (без Кириллицы) или 70 символов (если в тексте есть хотя бы один символ Кириллицы).
    • ТЕКСТ одной SMS в составе составного сообщения не может превышать 152 символа (без Кириллицы) или 66 символов (если в тексте данной SMS есть хотя бы один символ Кириллицы).
    • Отправленные SMS сообщения не сохраняются в памяти.
    • Если на телефоне принимающей стороны некорректно отображаются символы Кириллицы, см. функции TXTsendCoding()и TXTsendCodingDetect().
    • Если принимающей стороне одновременно поступят несколько (больше одного) составных сообщений с одинаковым ИДЕНТИФИКАТОРОМ и одинаковым КОЛИЧЕСТВОМ SMS в составе составных сообщений, то существует вероятность неправильной склейки ТЕКСТА этих сообщений (часть текста будет от одного сообщения, а часть от другого). По этому значение ИДЕНТИФИКАТОРА должно генерироваться как случайное число от 1 до 65535.
  • Пример:
gsm.SMSread("Привет", "+70123456789");  // Отправка SMS с текстом "Привет" на номер +7(012)345-67-89.
gsm.SMSsend(F("Данное SMS сообщение является составным, так как содержит более 70"), "70123456789", 0x1234, 3, 1); // Отправка 1 из 3 SMS в составе составного сообщения с идентификатором 0x1234, на номер получателя +7(012)345-67-89.
gsm.SMSsend(F(" символов. По этому это сообщение будет отправлено как 3 SMS сообщ"), "70123456789", 0x1234, 3, 2); // Отправка 2 из 3 SMS в составе составного сообщения с идентификатором 0x1234, на номер получателя +7(012)345-67-89.
gsm.SMSsend(F("ения.\nНо получатель увидит его как один большой целый текст."     ), "70123456789", 0x1234, 3, 3); // Отправка 3 из 3 SMS в составе составного сообщения с идентификатором 0x1234, на номер получателя +7(012)345-67-89.

Функция SMSsendClass();

  • Назначение: указание класса для всех отправляемых SMS сообщений.
  • Синтаксис: SMSsendClass( КЛАСС );
  • Параметры:
    • КЛАСС - значение соответствующее одной из констант:
      • GSM_SMS_CLASS_NO - отправлять SMS сообщения без класса (по умолчанию).
      • GSM_SMS_CLASS_0 - отправлять SMS сообщения с указанием 0 класса.
      • GSM_SMS_CLASS_1 - отправлять SMS сообщения с указанием 1 класса.
      • GSM_SMS_CLASS_2 - отправлять SMS сообщения с указанием 2 класса.
      • GSM_SMS_CLASS_3 - отправлять SMS сообщения с указанием 3 класса.
  • Возвращаемое значение: нет.
  • Примечание:
    • Сообщения без класса это обычные SMS сообщения отправляемые с телефона на телефон.
    • Входящие сообщения 0 класса (ими информируют о ЧС и называют Flash SMS) выводятся напрямую на дисплей телефона. Такие сообщения либо не сохраняются вообще, либо телефон запрашивает разрешение на сохранение сообщения в памяти входящих SMS.
    • Входящие сообщения 1 класса (ими оператор отправляет настройки телефона) сохраняются в памяти телефона.
    • Входящие сообщения 2 класса сохраняются в памяти SIM-карты.
    • Входящие сообщения 3 класса передаются терминальному оборудованию или приложению.
    • Выбранный класс будет применяться ко всем SMS сообщениям отправляемым функцией SMSsend().
  • Пример:
gsm.SMSsendClass(GSM_SMS_CLASS_0);      // Отправлять все последующие SMS с указанием класса 0 (отображая их сразу на экране телефона).
gsm.SMSread("Привет", "+70123456789");  // Данное сообщение будет отправлено как SMS класса 0.
gsm.SMSsendClass(GSM_SMS_CLASS_NO);     // Отправлять все последующие SMS без класса (как обычные SMS сообщения).

Функция TXTreadCoding();

  • Назначение: указание кодировки для получаемого (выводимого) текста.
  • Синтаксис: TXTreadCoding( КОДИРОВКА );
  • Параметры:
    • КОДИРОВКА - значение соответствующее одной из констант:
      • GSM_TXT_UTF8 - использовать кодировку UTF88.
      • GSM_TXT_WIN1251 - использовать кодировку Windows-1251.
      • GSM_TXT_CP866 - использовать кодировку CP-866.
  • Возвращаемое значение: нет.
  • Примечание:
    • Если функция получения SMS сообщений SMSread() или функция выполнения USSD запросов runUSSD() некорректно возвращают символы Кириллицы в принятом тексте, то до их выполнения нужно вызвать функцию TXTreadCoding() указав одну из предложенных кодировок.
    • По умолчанию используется кодировка UTF-8.
  • Пример:
gsm.begin(Serial1);                  // Инициализация с указанием объекта или класса шины UART.
gsm.TXTreadCoding(GSM_TXT_WIN1251);  // Указываем выводить весь текст (входящих SMS и ответов на запросы USSD) в кодировке Windows-1251.

Функция TXTsendCoding();

  • Назначение: указание кодировки отправляемого (вводимого) текста.
  • Синтаксис: TXTsendCoding( КОДИРОВКА );
  • Параметры:
    • КОДИРОВКА - значение соответствующее одной из констант:
      • GSM_TXT_UTF8 - использовать кодировку UTF88.
      • GSM_TXT_WIN1251 - использовать кодировку Windows-1251.
      • GSM_TXT_CP866 - использовать кодировку CP-866.
  • Возвращаемое значение: нет.
  • Примечание:
    • Данная функция указывает в какой кодировке написан текст SMS сообщения отправляемого функцией SMSsend().
    • Если на телефоне получателя SMS сообщений некорректно отображаются символы Кириллицы, то до обращения к функции SMSsend() нужно вызвать функцию TXTsendCoding() указав одну из предложенных кодировок.
    • По умолчанию используется кодировка UTF-8.
    • Так как в большинстве случаев отправляемый текст SMS сообщений хранится в скетче, то вместо функции TXTsendCoding() можно использовать функцию автоопределения кодировки отправляемого текста TXTsendCodingDetect().
  • Пример:
gsm.begin(Serial1);                  // Инициализация с указанием объекта или класса шины UART.
gsm.TXTsendCoding(GSM_TXT_WIN1251);  // Указываем что текст отправляемых SMS сообщений передан функции SMSsend в кодировке Windows-1251.

Функция TXTsendCodingDetect();

  • Назначение: автоопределение кодировки отправляемого текста.
  • Синтаксис: TXTsendCodingDetect( 'п' );
  • Параметры: символ 'п' (строчная буква 'п').
  • Возвращаемое значение: нет.
  • Примечание:
    • Данная функция определяет кодировку скетча и сообщает функции SMSsend() что именно в этой кодировке написан текст отправляемого SMS сообщения.
    • В качестве параметра допускается указывать только символ 'п', так как кодировка определяется по коду указанного символа.
  • Пример:
gsm.begin(Serial1);            // Инициализация с указанием объекта или класса шины UART.
gsm.TXTsendCodingDetect('п');  // Указываем отправлять текст SMS из кодировки скетча.

Функция CALLavailable();

  • Назначение: проверка наличия входящего (звонящего) голосового вызова.
  • Синтаксис: CALLavailable( [ АДРЕС ] );
  • Параметры:
    • АДРЕС - необязательный параметр, строка (массив char) в которую требуется сохранить адрес (номер) вызывающего абонента. Обычно номер содержит до 12 символов + символ конца строки.
  • Возвращаемое значение: флаг (bool) true/falseуказывает на наличие входящего голосового вызова в режиме дозвона.
  • Примечание:
    • Данную функцию удобно использовать перед ответом на входящий голосовой вызов функцией поднятия трубки CALLup().
  • Пример:
if( gsm.CALLavailable() ){                       // Функция CALLavailable() возвращает флаг наличия входящего голосового вызова в режиме дозвона.
    Serial.println( "I have incoming call!" );   // Выводим текст "Имеется входящий звонок".
}                                                //
char SMSadr[13];                                  // Объявляем строку (массив) для получения адреса (номера) вызывающего абонента.
if( gsm.CALLavailable(SMSadr) ){                  // Функция CALLavailable() возвращает флаг наличия входящего голосового вызова в режиме дозвона.
    Serial.print( "I have incoming call from " ); // Выводим текст "Имеется входящий звонок от ".
    Serial.println( SMSadr );                     // Выводим адрес (номер) вызывающего абонента.
}                                                 //

Функция CALLup();

  • Назначение: ответ на входящий голосовой вызов (поднятие трубки).
  • Синтаксис: CALLup();
  • Параметры: нет.
  • Возвращаемое значение: нет.
  • Примечание:
    • Перед данной функцией удобно использовать функцию проверки наличия входящего голосового вызова в режиме дозвона CALLavailable().
    • При установке активного голосового соединения, используется громкая связь, если иное не выбрано функцией SOUNDdevice().
  • Пример:
if( gsm.CALLavailable() ){  // Если есть входящий вызов, то ...
    gsm.CALLup()            // Поднимаем трубку.
}                           //

Функция CALLend();

  • Назначение: завершение голосовых вызовов (опускание трубки).
  • Синтаксис: CALLend();
  • Параметры: нет.
  • Возвращаемое значение: нет.
  • Примечание:
    • Функция завершает все вызовы (входящие, исходящие, активные, удерживаемые и ожидающие).
  • Пример:
if( gsm.CALLavailable() ){  // Если есть входящий вызов, то ...
    gsm.CALLend()           // Бросаем трубку.
}                           //

Функция CALLdial();

  • Назначение: инициализация исходящего голосового вызова (набор номера).
  • Синтаксис: CALLdial( "АДРЕС" );
  • Параметры:
    • "АДРЕС" - текст адреса (номера) вызываемого абонента. Можно указывать короткие номера, ведущий символ '+' в номере телефона можно не указывать.
  • Возвращаемое значение: флаг (bool) true/falseуказывает на успешную инициализацию исходящего голосового вызова.
  • Примечание:
    • После успешной инициализации установится статус вызова «исходящий набираемый».
    • После успешного набора номера установится статус вызова «исходящий в режиме дозвона» (ожидание ответа с вызываемой стороны).
    • После ответа вызываемой стороной установится статус вызова «активный голосовой».
    • После сброса установится статус вызова «разъединение».
    • После разъединения установится статус «свободен для звонков».
    • Статус голосового вызова можно отследить функцией CALLstatus().
    • При установке активного голосового соединения, используется громкая связь, если иное не выбрано функциейSOUNDdevice().
  • Пример:
gsm.CALLdial( "+70123456789" ); // Набрать номер +7(012)345-67-89.

Функция CALLstatus();

  • Назначение: получение состояния голосового вызова.
  • Синтаксис: CALLstatus();
  • Параметры: нет.
  • Возвращаемое значение: соответствует одной из констант:
    • GSM_OK - свободен для звонков.
    • GSM_CALL_ACTIVE - активное голосовое соединение.
    • GSM_CALL_OUT_DIAL - исходящий вызов в режиме набора адреса (номера).
    • GSM_CALL_OUT_BEEP - исходящий вызов в режиме дозвона (ждём поднятия трубки).
    • GSM_CALL_IN_BEEP - входящий вызов в режиме дозвона (ждёт поднятия трубки).
    • GSM_CALL_IN_WAIT - входящий вызов в режиме ожидания.
    • GSM_CALL_HELD - вызов в режиме удержания.
    • GSM_CALL_END - вызов разъединяется (кратковременный статус).
    • GSM_CALL_ERR - состояние вызова не определено.
  • Примечание:
    • Данную функцию удобно использовать для распределения функционала на разных стадиях голосового вызова.
  • Пример:
if(gsm.CALLdial( "70123456789" )){                           // Если исходящий вызов инициирован, то...
    Serial.println( "Dialing ..." );                         // "Набираю ..."
    while(gsm.CALLstatus()==GSM_CALL_OUT_DIAL){              // Ждём завершения набора номера.
//      Код будет выполняться в процессе набора номера.      //
    }   delay(500);                                          // Даём немного времени для установки состояния - "дозвон" или "соединён".
    if(gsm.CALLstatus()==GSM_CALL_OUT_BEEP){                 // Если начались гудки дозвона, то ...
        Serial.println( "Waiting for an answer ... " );      // "Ждём ответа ...".
        while(gsm.CALLstatus()==GSM_CALL_OUT_BEEP){          // Ждём поднятия трубки на вызываемой стороне.
//          Код будет выполняться в процессе ожидания ответа //
        }   delay(500);                                      // Даём немного времени для установки состояния - "соединён".
    }                                                        //
    if(gsm.CALLstatus()==GSM_CALL_ACTIVE){                   // Если соединение установлено (абонент ответил), то ...
        Serial.println( "Voice connection established!" );   // "Установлено голосовое соединение!"
        while(gsm.CALLstatus()==GSM_CALL_ACTIVE){            // Ждём завершения активного голосового соединения.
//          Код будет выполняться в процессе разговора       //
        }                                                    //
        Serial.println( "Call ended" );                      // "Вызов завершён".
    }else{                                                   // Иначе, если активное голосовое соединение не было установлено, то ...
        Serial.println( "No answer!" );                      // "Абонент не ответил".
    }                                                        //
}                                                            //

Функция SOUNDdevice();

  • Назначение: выбор устройства ввода/вывода звука.
  • Синтаксис: SOUNDdevice( [ УСТРОЙСТВО ] );
  • Параметры:
    • УСТРОЙСТВО - необязательное значение указывающее какое устройство требуется использовать для ввода/вывода звука, соответствует одной из констант:
      • GSM_HEADSET- использовать гарнитуру.
      • GSM_SPEAKER- использовать громкую связь.
      • GSM_MICROPHONE - использовать только микрофон громкой связи.
  • Возвращаемое значение:
    • УСТРОЙСТВО - значение указывающее какое устройство сейчас используется, соответствует одной из констант:
      • GSM_HEADSET- используется гарнитура.
      • GSM_SPEAKER- используется громкая связь.
      • GSM_MICROPHONE - используется только микрофон громкой связи.
  • Примечание:
    • Если функцию вызвать без параметра, то она вернёт значение соответствующее используемому устройству, не меняя его.
    • Если функцию вызвать с параметром, то она переключит звук на указанное устройство и вернёт значение соответствующее используемому устройству.
    • По умолчанию, после подачи питания, используется громкая связь.
  • Пример:
gsm.SOUNDdevice(GSM_HEADSET); // Использовать гарнитуру для ввода/вывода звука.

Функция SOUNDvolume();

  • Назначение: указание громкости звука.
  • Синтаксис: SOUNDvolume( [ ГРОМКОСТЬ ] );
  • Параметры:
    • ГРОМКОСТЬ - необязательное значение (uint8_t) от 0 до 7 определяющее уровень звука:
      • 7 - максимальная громкость.
      • 1 - минимальная громкость.
      • 0 - без звука.
      • Значения отличные от 0...7 игнорируются.
  • Возвращаемое значение:
    • ГРОМКОСТЬ - значение (uint8_t) указывающее на установленный уровень звука:
      • 7 - максимальная громкость.
      • 1 - минимальная громкость.
      • 0 - без звука.
  • Примечание:
    • Если функцию вызвать без параметра, то она вернёт значение соответствующее установленной громкости, не меняя её.
    • Если функцию вызвать с параметром, то она установит указанный уровень звука и вернёт значение соответствующее установленному уровню звука.
  • Пример:
gsm.SOUNDvolume(4);                   // Установить средний уровень громкости.
gsm.SOUNDvolume(gsm.SOUNDvolume()+1); // Увеличить громкость на 1 пункт.
gsm.SOUNDvolume(gsm.SOUNDvolume()-1); // Уменьшить громкость на 1 пункт.

Функция SOUNDmute();

  • Назначение: включение немого режима (режим без микрофона).
  • Синтаксис: SOUNDmute( [ ФЛАГ ] );
  • Параметры:
    • ФЛАГ - необязательный параметр, флаг включения немого режима (bool) true / false.
  • Возвращаемое значение:
    • ФЛАГ - (bool) указывающий включён ли немой режим.
  • Примечание:
    • Если функцию вызвать без параметра, то она вернёт флаг указывающий включён ли немой режим, без включения/отключения немого режима.
    • Если функцию вызвать с параметром, то она включит/отключит немой режим (в соответствии с указанным флагом) и вернёт флаг указывающий включён ли немой режим.
    • В немом режиме отключается микрофон устройства выбранного для ввода/вывода звука функцией SOUNDdevice().
  • Пример:
gsm.SOUNDmute(true);             // Включить немой режим.
gsm.SOUNDmute(!gsm.SOUNDmute()); // Переключить немой режим (данную строку удобно "вешать" на одну кнопку).

Применение:

  • Управление устройствами по SMS или через интернет.
  • Осуществление SMS уведомлений систем охраны или оповещения о событиях.
  • Выполнение SMS рассылки.
  • Отправка статистических данных на интернет ресурсы.
  • Осуществление голосовой связи, и многое многое другое...

Ссылки:

Обсуждение