Enviar SMS con Arduino y módulo GSM

SIM800L
by Admin | Jul 15, 2018 | Tutoriales Arduino | 3 comments
Los celulares y la telefonía móvil son tendencia en la actualidad, por eso
en esta página vamos a enseñarte como utilizar el módulo GSM SIM800L
de SIMCOM para enviar SMS con Arduino. Los mensajes de texto pueden
ser de gran utilidad en diversos proyectos, por ejemplo: para alertarnos de
situaciones de alarma en equipos remotos, para alertarnos de intrusiones en un
sistema de seguridad casero, enviar datos de telemetría, crear un localizador
GPS que se comunique mediante mensajes de texto SMS, creación de alarmas
vecinales, etc.
El módulo SIM800L es el componente principal de las tarjetas FONA 800 de
Adafruit, por lo que podemos utilizar la librería realizada para estas
tarjetas con los módulos económicos que montan el SIM800L, como el que
tenemos a la venta en nuestra tienda virtual. En este tutorial nos enfocamos en
el uso de la librería de Adafruit, pero también mostramos como puede
realizarse el envío de mensajes de texto enviando comandos AT directamente
al módulo GSM, esto ultimo es principalmente con fines didácticos, ya que el
método preferido será el uso de una librería.
En la foto principal de este artículo vemos el circuito que hemos armado
para las pruebas de envío de SMS con arduino. También se observan los
equipos que alimentan el experimento.

Materiales necesarios para las prácticas

Para esta experiencia requerimos los siguientes materiales:
 Módulo GSM / GPRS SIM800L
 Arduino UNO R3
 Cables dupont macho-macho
 Protoboard 800 puntos
 Módulo Convertidor DC-DC buck ajustable
 Fuente de alimentación de 9 volts DC (preferentemente de laboratorio)
De manera alternativa, podemos utilizar los shield de Adafruit:
 Adafruit FONA Shield 800
 Adafruit FONA Shield 808

Conexiones para Enviar SMS con Arduino y

SIM800L
Para usar el SIM800 es necesario contar con una fuente de alimentación
de 4.0 volts (el SIM800 acepta voltajes en el rango de 3.4 a 4.4 volts). Muchas
personas utilizan baterías de polímero de litio para alimentarlo, aunque si no se
desea estar cargando constantemente las baterías recomendamos usar una
fuente de alimentación ajustable como las que encontramos en nuestra tienda
virtual, mismas que estaremos utilizando en nuestras pruebas y que
ajustaremos para una salida de 4 volts a partir de los 9 con los que
alimentaremos todo el equipo (incluyendo el arduino).
En este punto hay que hacer énfasis en el hecho de que no vale utilizar
directamente las salidas de 3.3 volts ni 5 volts de arduino, debido a que 5
volts es demasiado para el SIM800 y 3.3 volts esta por abajo del rango
permitido. Además, el puerto USB de la computadora y el arduino en si mismo
no es capaz de suministrar la corriente necesaria para el funcionamiento del
módulo SIM800L. Para que el experimento tenga éxito, una alimentación
impecable para el SIM800L es necesaria.
Nuestra conexión de la energía quedó de la siguiente manera:
Las conexiones de datos con el módulo GSM SIM800L se realizan mediante la
UART. Debemos conectar el TX de Arduino al RX del SIM800L y el RX del
Arduino al TX del SIM800L (cruzadas). Debemos respetar los niveles de
entrada del SIM800L el cual es de 2.8 volts. Para esto podemos usar un simple
divisor resistivo en el lado TX del arduino o un adaptador de niveles lógicos,
nosotros optamos por un divisor resistivo formado por dos resistencias de 330
ohms: Hemos destacado nuestro convertidor de niveles para la comunicación
en dirección al SIM800L, ya que los 5 volts de salida del Arduino pueden dañar
el SIM800L.
De manera alternativa a la fuente de alimentación, podemos utilizar una batería
de polímero de litio para alimentar el SIM800L, tal como se muestra a
continuación.

Programación para envío de mensaje SMS con

Arduino y SIM800L
En este caso, vamos a simular que queremos desarrollar una alarma que nos
alerte mediante un mensaje de texto a nuestro celular cuando alguien abre una
puerta, para simular el sensor de la puerta, podemos utilizar un switch común
insertado en el protoboard. Con la librería FONA, el programa queda de la
siguiente manera:

1
/**
2
GeekFactory - "INNOVATING TOGETHER"
3
Distribucion de materiales para el desarrollo e innovacion tecnologica
4
www.geekfactory.mx
5
6
SKETCH PARA ENVIAR SMS CON ARDUINO UTILIZANDO LA LIBRERIA DE ADAFRUIT
7
FONA.
8
ESTE SKETCH SIMULA UNA ALARMA EN LA CUAL AL OPRIMIR UN BOTON SE ENVIA UN
9
MENSAJE SMS
10
ALERTANDO DE UNA INTRUSION. PODEMOS SUSTITUIR EL BOTON POR UN SENSOR
11
MAGNETICO PARA
12
PUERTAS Y VENTANAS, DE FORMA QUE ESTE EJEMPLO PUEDE VOLVERSE UNA
13
ALARMA FUNCIONAL.
14
*/
15
#include <SoftwareSerial.h>
16
#include "Adafruit_FONA.h"
17
18
// CONFIGURACION DE UART GSM
19
#define CONFIG_GSM_RXPIN 4
20
#define CONFIG_GSM_TXPIN 3
21
#define CONFIG_GSM_BAUDRATE 9600
22
23
// CONFIGURACION DEL NUMERO DESTINO DEL MENSAJE SMS
24
#define CONFIG_GSM_SMS_DESTINATION "+52155XXXXXXXX"
25
26
// PIN UTILIZADO COMO ENTRADA PARA DESENCADENAR EL ENVIO DE UN MENSAJE
27
#define CONFIG_ALARM_PIN 5
28
29
// PUERTO SERIE EMULADO: EL ARDUINO UNO TIENE SOLO 1 UART
30
// EN EL CONSTRUCTOR DE SOFTWARESERIAL SE ESPECIFICAN LOS PINES PARA RX Y TX
31
SoftwareSerial swseri = SoftwareSerial(CONFIG_GSM_RXPIN, CONFIG_GSM_TXPIN);
32
33
// OBJETO ADAFRUIT_FONA USADO PARA COMUNICARSE CON EL SIM800L
34
Adafruit_FONA fona = Adafruit_FONA(10);
35
36
void setup() {
37
// PREPARAR PINES IO
38
pinMode(CONFIG_ALARM_PIN, INPUT_PULLUP);
39
40
// PREPARAR LOS PUERTOS SERIALES A LA VELOCIDAD CONFIGURADA
41
swseri.begin(CONFIG_GSM_BAUDRATE);
42
Serial.begin(CONFIG_GSM_BAUDRATE);
43
44
// IMPRIMIR EL ENCABEZADO INCIAL
45
Serial.println(F("----------------------------------------------------"));
46
Serial.println(F(" EJEMPLO ALARMA CONTRA INTRUSOS CON ALERTA SMS "));
47
Serial.println(F(" http://www.geekfactory.mx "));
48
Serial.println(F("----------------------------------------------------"));
49
50
// INICIAR LA COMUNICACION CON EL MODULO GSM
51
 52 // PASAMOS REFERENCIA AL PUERTO SERIE USADO PARA LA COMUNICACION CON EL
53 MODEM
54 if (fona.begin(swseri))
55 Serial.println(F("MODULO GSM OK"));
56 else
57 {
58 // BLOQUEAR LA EJECUCIÓN EN ESTE PUNTO SI NO SE ENCUENTRA MODULO GSM O
59 FALLA LA COMUNICACIÓN CON ESTE
60 Serial.println(F("NO SE ENCUENTRA MODULO GSM"));
61 while (1);
62 }
63
64 // AQUI SE REALIZA EL ENVIO DEL MENSAJE SMS
65 // INDICAMOS EL NUMERO DESTINO Y EL CUERPO DEL MENSAJE
66 if (!fona.sendSMS(CONFIG_GSM_SMS_DESTINATION, "Alarma SMS encendiendo!!!")) {
67 Serial.println(F("ERROR"));
68 } else {
69 Serial.println(F("ENVIADO"));
70 }
71 }
72
73 void loop() {
74 // ESPERAR CAMBIO DE ESTADO EN EL PIN
75 if (!digitalRead(CONFIG_ALARM_PIN))
76 {
77 // RETARDO PARA LIDIAR CON REBOTES Y RUIDO
78 delay(100);
79 // VOLVEMOS A REVISAR EL ESTADO DEL PIN
80 if (!digitalRead(CONFIG_ALARM_PIN))
81 {
82 if (!fona.sendSMS(CONFIG_GSM_SMS_DESTINATION, "MENSAJE DE ALERTA DEL
83 SISTEMA DE ALARMA DOMESTICA!!!")) {
84 Serial.println(F("ERROR AL ENVIAR MENSAJE DE ALARMA"));
} else {
Serial.println(F("MENSAJE DE ALARMA ENVIADO"));
}
// PARA NO ENVIAR DEMASIADOS MENSAJES SEGUIDOS
delay(5000);
}
}
}

Código para envío de SMS con Arduino y

SIM800L sin librería (solo comandos AT).
En caso de que deseemos prescindir de la librería, el programa puede quedar
como se muestra más abajo. La verdad, estamos simplificando al extremo las
cosas aquí y solamente es para ilustrar lo sencillo que es controlar el módulo
GSM / GPRS SIM800L mediante los comandos AT. El método más robusto
para enviar SMS con arduino es el que se indica más arriba, mediante la
librería de Adafruit.

1 /**
2 GeekFactory - "INNOVATING TOGETHER"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5
6 SKETCH PARA ENVIAR SMS CON ARDUINO TRAVÉS DE MODEM GSM SIM800L. AL
7 MOMENTO
8 DE ARRANCAR EL SKETCH SE ENVÍA EL MENSAJE DE TEXTO, LUEGO EL ARDUINO
9 QUEDA EN MODO DE
10 PUENTE USB-UART PARA PODER SEGUIR ENVIANDO COMANDOS AT AL MODULO GSM.
11
12 ESTE SKETCH CREA UN UART EMULADO POR SOFTWARE EN LOS PINES INDICADOS Y
13 REDIRIGE
14 LOS DATOS DESDE Y HACIA EL UART POR HARDWARE EN LOS PINES 0 Y 1 DEL
15 ARDUINO UNO.
16 ESTA DISEÑADO PENSANDO EN LA TARJETA UNO, YA QUE EL MEGA SI DISPONE DE
17 VARIOS
18 UART POR HARDWARE Y PODRIA REALIZARSE SIN RECURRIR A SOFTWARESERIAL.
19
20 */
21 #include <SoftwareSerial.h>
22
23 // CONFIGURACION DE UART GSM
24 #define CONFIG_GSM_RXPIN 4
25 #define CONFIG_GSM_TXPIN 3
26 #define CONFIG_GSM_BAUDRATE 9600
27
28 // PUERTO SERIE EMULADO: EL ARDUINO UNO TIENE SOLO 1 UART
29 // EN EL CONSTRUCTOR DE SOFTWARESERIAL SE ESPECIFICAN LOS PINES PARA RX Y TX
30 SoftwareSerial swseri = SoftwareSerial(CONFIG_GSM_RXPIN, CONFIG_GSM_TXPIN);
31
32 void setup()
33 {
34 // PREPARAR LOS PUERTOS SERIALES A LA VELOCIDAD CONFIGURADA
35 swseri.begin(CONFIG_GSM_BAUDRATE);
36 Serial.begin(CONFIG_GSM_BAUDRATE);
37
38 // IMPRIMIR EL ENCABEZADO INCIAL
39 Serial.println(F("----------------------------------------------------"));
40 Serial.println(F(" EJEMPLO PARA ENVIAR SMS CON ARDUINO Y MODULO GSM "));
41 Serial.println(F(" http://www.geekfactory.mx "));
42 Serial.println(F("----------------------------------------------------"));
43
44 // ENVIAR LOS COMANDOS AT AL MODEM PARA EL ENVIO DEL MENSAJE SMS
45 // CONFIGURAR EL MODULO PARA ENVIO DE MENSAJES EN MODO TEXTO (OTRA
46 OPCION ES EL MODO PDU)
47 swseri.println("AT+CMGF=1");
48 delay(100);
49
50 // ENVIAR EL COMANDO DE ENVIO DE SMS INCLUYENDO EL DESTINATARIO DEL
51 MENSAJE
52 swseri.println("AT+CMGS=\"+521XXXXXXXXX\"");
53 delay(100);
54
55 // ENVIAR EL CUERPO DEL MENSAJE
56 swseri.print("HOLA MUNDO SMS DESDE ARDUINO!");
57 delay(500);
58
59 // ENVIAR EL CARACTER DE CONTROL ASCII 26 (SUB) 0X1A INDICANDO EL FINAL DEL
60 CUERPO DEL MENSAJE
61 swseri.print(char(0x1A));
62 delay(2000);
63 }
64
65 void loop()
66 {
 67 // SI HAY DATOS EN LA INTERFAZ SERIAL POR SOFTWARE, ESCRIBIRLOS EN EL UART
68 FISICO
69 if (swseri.available())
70 {
Serial.write(swseri.read());
}

// SI HAY DATOS EN LA INTERFAZ SERIAL POR HARDWARE, ESCRIBIRLOS EN EL UART

EMULADO
if (Serial.available())
{
swseri.write(Serial.read());
}
}

En este programa no hacemos caso a las respuestas del módulo GSM, por lo
tanto, no hay una manera sencilla de determinar si algo salio mal al momento
de enviar el mensaje, sin embargo, este programa se deja a disposición de los
lectores para fines didácticos.

Conclusión y repaso
 En este tutorial aprendimos como dar alimentación al módulo SIM800L y las
conexiones básicas entre este y el arduino.
 Aprendimos a utilizar la librería FONA de Adafruit para controlar el SIM800L y
mandar mensajes SMS.
 Aprendimos a realizar el envío de mensajes SMS utilizando comandos AT
desde arduino en caso de no querer utilizar una librería externa.
 Este tutorial funciona como introducción a los módulos SIM800 y shields FONA
de Adafruit que funcionan gracias al SIM800L.
 Aprendimos que este programa puede funcionar con otros módulos GSM, ya
que los comandos para enviar mensajes de texto son estándar entre los
fabricantes.
3 Comments

1.
claudio on 23 noviembre, 2018 at 17:16

Hola muy bueno comento que he logrado comunicacion con el modulo he

conseguido mandarle msg y que el arduino responda pero no logro que el
modulo me envie el msg en el monitor serie me marca como ok y se
incrementa el nro de msg enviados pero el msg nunca llega a destino void
EnviarMensage(){
SIM800L.println(“AT+CMGF=1”);
 delay(100);
SIM800L.println(“AT+CMGS=\”+0341xxxxxxx\””);
delay(100);
SIM800L.println(“Enviado”);
delay(500);
SIM800L.println(char(0x1A)); // REMPLASE POR CHAR 26
delay(2000);
SIM800L.println(” “);}
Reply

2.
Herminio on 21 agosto, 2018 at 10:39

Hola, buenos dias… Escribo porque tengo una duda, como haria con
comandos AT para Reenviar un sms? Ya tengo el numero de mensaje
almacenado en un String, pero no se como hacer para usar esa variable dentro
del swseri.println(“AT+CMGS=\”+521XXXXXXXXX\””);… Me explico?
Reply


Admin on 2 septiembre, 2018 at 20:01

Hola buena tarde.

Investiga sobre la concatenación de cadenas y la clase String de
Arduino. También te puede servir leer a cerca de la función
sprintf() de C.
Espero que te sirva la orientación.
Saludos cordiales.