Módulo gsm que interactúa con el microcontrolador pic

Los módulos GSM son fascinantes de usar, especialmente cuando nuestro proyecto requiere acceso remoto. Estos módulos podrían realizar todas las acciones que podría realizar nuestro teléfono móvil normal, como hacer / recibir una llamada, enviar / recibir un SMS, conectarse a Internet mediante GPRS, etc. También puede conectar un micrófono y un altavoz normales a este módulo y conversar en su llamadas móviles. Esto abrirá las puertas a muchos proyectos creativos si se pudiera conectar con un microcontrolador. Por lo tanto, en este tutorial aprenderemos cómo podemos conectar el módulo GSM (SIM900A) con nuestro microcontrolador PIC y lo demostraremos haciendo y recibiendo llamadas usando el módulo GSM. Lo hemos interconectado previamente con Arduino y Raspberry Pi para llamadas y mensajería:

Llamada y mensaje usando Arduino y módulo GSM
Llamar y enviar mensajes de texto usando Raspberry Pi y módulo GSM

Materiales necesarios:

Microcontrolador PIC (PIC16F877A)
Módulo GSM (SIM900 o cualquier otro)
Cables de conexión
Adaptador 12V
PicKit 3

Módulo GSM:

El módulo GSM se puede utilizar incluso sin ningún microcontrolador utilizando el modo de comando AT. Como se muestra arriba, el módulo GSM viene con un adaptador USART que se puede conectar directamente a la computadora usando un módulo MAX232 o los pines Tx y Rx se pueden usar para conectarlo a un microcontrolador. También puede notar los otros pines como MIC +, MIC-, SP +, SP- etc.donde se puede conectar un micrófono o un altavoz. El módulo se puede alimentar con un adaptador de 12 V a través de un conector de barril CC normal.

Inserte su tarjeta SIM en la ranura del módulo y enciéndalo, debería notar que un LED de encendido se enciende. Ahora espere un minuto más o menos, y debería ver un LED rojo (o de cualquier otro color) parpadeando una vez cada 3 segundos. Esto significa que su Módulo pudo establecer conexión con su tarjeta SIM. Ahora puede proceder a conectar su módulo con el teléfono o cualquier microcontrolador.

Comunicarse con el módulo GSM mediante comandos AT:

Como habrás adivinado, el módulo GSM puede comunicarse a través de la comunicación en serie y puede entender solo un idioma y son los " comandos AT ". Sea lo que sea lo que quiera decirle o preguntarle al módulo GSM, solo debe ser a través de comandos AT. Por ejemplo, si desea saber si su módulo está activo. Debe pedir (enviar) un comando como "AT" y su módulo responderá "OK".

Estos comandos AT están bien explicados en su hoja de datos y se pueden encontrar aquí en su hoja de datos oficial. ¡Bueno! ¡Bueno! Es una hoja de datos de 271 páginas y es posible que tarde días en leerla. Así que le he dado algunos de los comandos AT más importantes a continuación para que pueda ponerlo en funcionamiento pronto.

A	Responde con OK para reconocimiento
AT + CPIN?	Verificar la calidad de la señal
AT + COPS?	Buscar el nombre del proveedor de servicios
ATD96XXXXXXXX;	Llamar al número específico, termina con punto y coma
AT + CNUM	Encuentra el número de tarjeta SIM (puede que no funcione para algunas SIM)
ATA	Responder la llamada entrante
ATH	Cuelgue la llamada entrante actual
EN + COLP	Mostrar número de llamada entrante
AT + VTS = (número)	Envíe el número DTMF. Puede utilizar cualquier número en el teclado de su móvil para (número)
AT + CMGR	AT + CMGR = 1 lee el mensaje en la primera posición
AT + CMGD = 1	Eliminar mensaje en la primera posición
AT + CMGDA = "BORRAR TODO"	Eliminar todos los mensajes de la SIM
AT + CMGL = "TODOS"	Leer todos los mensajes de SIM
AT + CMGF = 1	Establecer la configuración de SMS. "1" es para el modo de solo texto
AT + CMGS = "+91 968837XXXX" > Texto de resumen de circuito	Envía SMS a un número particular aquí 968837XXXX. Cuando vea “>” comience a ingresar el texto. Presione Ctrl + Z para enviar el texto.
AT + CGATT?	Para comprobar la conexión a Internet en la tarjeta SIM
AT + CIPSHUT	Para cerrar la conexión TCP, es decir, desconectarse de Internet
AT + CSTT = "APN", "nombre de usuario", "Pass"	Conéctese a GPRS con su APN y contraseña. Puede obtenerse del proveedor de la red.
AT + CIICR	Verifique si la tarjeta SIM tiene paquete de datos
AT + CIFSR	Obtener IP de la red SIM
AT + CIPSTART = "TCP", "IP DEL SERVIDOR", "PUERTO"	Se usa para establecer una conexión TCP IP
EN + CIPSEND	Este comando se usa para enviar datos al servidor

Diagrama de circuito:

El diagrama de conexión para el módulo GSM de interfaz con el microcontrolador PIC se muestra a continuación.

Simplemente hemos interconectado los pines Tx y Rx del módulo GSM con los pines Rx y Tx del PIC MCU PIC16F877A respectivamente. Esto establecerá una conexión serial entre ambos. Además, no se olvide de poner a tierra en común tanto el módulo GSM como el PIC. También hemos utilizado una pantalla LCD para conocer el estado de nuestro módulo GSM. Una vez que se realizan las conexiones, su hardware se verá como algo a continuación.

La placa PIC Perf se hizo para nuestra serie de tutoriales PIC, en la que aprendimos cómo usar el microcontrolador PIC. Es posible que desee volver a esos tutoriales de microcontroladores PIC usando MPLABX y XC8 si no sabe cómo grabar un programa usando Pickit 3, ya que me saltaré toda esa información básica.

Programando su microcontrolador PIC:

El programa completo para este proyecto se puede encontrar al final de este tutorial. Aquí explicaré algunas funciones y piezas de código importantes. Este programa también tiene códigos de LCD que fueron de Interfaz LCD con microcontrolador PIC, puede visitar ese tutorial si tiene curiosidad por saber cómo se puede usar LCD con microcontrolador PIC.

Como se dijo anteriormente, vamos a comunicarnos entre PIC y GSM usando comandos AT a través del modo de comunicación Serial. Entonces, primero tenemos que inicializar el módulo de comunicación USART en nuestro microcontrolador PIC usando Initialize _SIM900 (); función. Dentro de esta función declaramos los pines Tx y RX e inicializamos la recepción y transmisión asíncronas a 9600 baudios y modo de 8 bits.

// *** Inicializar UART para SIM900 ** // void Initialize_SIM900 (void) {// **** Configuración de pines de E / S para UART **** // TRISC6 = 0; // Pin TX configurado como salida TRISC7 = 1; // Pin RX configurado como entrada // ________ Pines de E / S establecidos __________ // / ** Inicializar el registro SPBRG para la velocidad en baudios requerida y configurar BRGH para velocidad en baudios rápida ** / SPBRG = 129; // SIM900 funciona a una velocidad de 9600 baudios, por lo que 129 BRGH = 1; // para alta velocidad en baudios // _________ Fin de la configuración de velocidad en baudios _________ // // **** Habilitar puerto serie asíncrono ******* // SYNC = 0; // SPEN asincrónico = 1; // Habilitar los pines del puerto serie // _____ Puerto serie asíncrono habilitado _______ // // ** Vamos a prepararnos para la transmisión y recepción ** // TXEN = 1; // habilita la transmisión CREN = 1; // habilita la recepción // __ módulo UART arriba y listo para transmisión y recepción __ // // ** Seleccionar modo de 8 bits ** // TX9 = 0; // Recepción de 8 bits seleccionada RX9 = 0;// Modo de recepción de 8 bits seleccionado // __ Modo de 8 bits seleccionado __ //} // ________ Módulo UART Inicializado __________ //

Ahora necesitamos leer y escribir información desde / hacia nuestro módulo GSM. Para ello utilizamos las funciones _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Estas funciones utilizan el registro de búfer de transmisión y recepción, como TXREG y RCREG, para leer o escribir datos en serie.

// ** Función para enviar un byte de fecha a UART ** // void _SIM900_putch (char bt) {while (! TXIF); // mantenga el programa hasta que el búfer de TX esté libre TXREG = bt; // Cargar el búfer del transmisor con el valor recibido} // _____________ Fin de la función ________________ // // ** Función para obtener un byte de fecha de UART ** // char _SIM900_getch () {if (OERR) // buscar Error { CREN = 0; // Si hay error -> Reset CREN = 1; // Si hay error -> Reset} while (! RCIF); // mantener el programa hasta que el búfer RX esté libre return RCREG; // recibe el valor y lo envía a la función principal} // _____________ Fin de la función ________________ // // ** Función para convertir la cadena en byte ** // void SIM900_send_string (char * st_pt) {while (* st_pt) // si hay es un char _SIM900_putch (* st_pt ++);// procesarlo como un byte de datos} // ___________ Fin de la función ______________ // // ** Fin de los códigos modificados ** // void _SIM900_print (unsigned const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

Las funciones anteriores son universales y no es necesario cambiarlas para ninguna aplicación. Se explicaron solo para dar una introducción aproximada. Puede sumergirse profundamente en ellos si lo desea mediante la comprensión.

Ahora, dentro de nuestra función principal, inicializamos la conexión USART y verificamos si podemos recibir un "OK" cuando enviamos "AT" usando la siguiente línea de código

hacer {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Módulo no encontrado"); } while (! SIM900_isStarted ()); // espera hasta que el GSM envíe "OK" Lcd_Set_Cursor (2,1); Lcd_Print_String ("Módulo detectado"); __delay_ms (1500);

La función SIM900_isStarted (); enviará "AT" al GSM y espera la respuesta "OK" de este. Si es así, devolverá 1 más 0;

Si no se detecta el módulo o si hay algún problema de conexión, entonces la pantalla LCD mostrará "Módulo no encontrado", de lo contrario, mostrará el módulo se detectó y procedemos al siguiente paso donde, verificamos si la tarjeta SIM puede ser detectada por el siguiente línea de código.

/ * Verifique si se detecta la tarjeta SIM * / do {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM no encontrada"); } while (! SIM900_isReady ()); // esperar hasta que el GSM envíe de vuelta "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM detectada"); __delay_ms (1500);

La función SIM900_isReady () enviará "AT + CPIN?" al GSM y espera la respuesta "+ CPIN: LISTO". Si es así, devolverá 1 más 0;

Si se encuentra una tarjeta SIM, se mostrará la SIM detectada en la pantalla LCD. Luego, podemos intentar hacer una llamada usando el comando “ ATD mobilenumber ; ”. Aquí, como ejemplo, he usado mi número como ATD93643159XX;. Tienes que reemplazar tu número de móvil respectivo allí.

/ * Realizar una llamada telefónica * / do {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Aquí estamos haciendo una llamada al número 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Realizando llamada…."); } while (_SIM900_waitResponse ()! = SIM900_OK); // esperar hasta que el ESP envíe "OK" Lcd_Set_Cursor (1,1); Lcd_Print_String ("Llamada realizada…."); __delay_ms (1500);

Una vez que se realiza la llamada, la pantalla LCD mostrará Llamada realizada y debería recibir una llamada entrante a ese número especificado.

También puede llamar al número de teléfono móvil conectado al módulo GSM y recibir una notificación al respecto en su pantalla LCD y utilizando el siguiente código

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Verifica si hay una llamada entrante {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Llamada entrante !!."); }}

Cuando el módulo GSM detecta una llamada entrante, mostrará Llamada entrante en la segunda línea del módulo LCD. La función _SIM900_waitResponse () comprobará si hay datos entrantes del módulo GSM. Cuando recibe SIM900_RING, que equivale a “RING” debido a waitResponce () , mostraremos el estado “Llamada entrante”.

Puede crear sus propias funciones como esta para realizar casi todo tipo de activaciones usando el módulo GSM. Si desea tener las cosas codificadas, simplemente puede usar la función __SIM900_print () para enviar cualquier comando AT como este a continuación.

_SIM900_print ("AT + CPIN? \ R \ n");

Recuerde que todos sus comandos deben ir seguidos de "\ r \ n" para indicar que el comando está terminando.

Simulación:

Una vez que haya entendido cómo funciona el programa, puede intentar simular y realizar cambios para satisfacer sus necesidades. La simulación le permitirá ahorrar mucho tiempo. La simulación se realiza usando Proteus y se ve a continuación.

Como puede ver, hemos utilizado la opción de terminal virtual en Proteus para verificar si el Programa responde como se esperaba. Podemos introducir los valores a través del cuadro de diálogo emergente. Por ejemplo, tan pronto como presionemos ejecutar, aparecerá un cuadro de diálogo negro como el anterior y mostrará AT, esto significa que ha enviado el módulo GSM AT, ahora podemos responder a PIC escribiendo en el cuadro como "OK" y presionar enter y el PIC responderá. Del mismo modo, podemos probar con todos los comandos AT.

Realizar y recibir llamadas usando GSM y PIC:

Una vez que comprenda cómo funcionan el código y el hardware, simplemente cargue el programa a continuación en PIC y encienda el módulo. Su pantalla LCD debe mostrar "Módulo detectado", "SIM detectada" y "llamada colocada" si todo está funcionando bien. Una vez que vea "Llamada realizada", recibirá una llamada entrante al número especificado en el programa.

También puede intentar llamar al número presente en el módulo GSM y su pantalla LCD mostrará "Llamada entrante" para indicar que se está llamando a la SIM.

El funcionamiento completo del proyecto se muestra en el video a continuación. Espero que haya entendido el proyecto y haya disfrutado haciéndolo. Si tiene algún problema para que las cosas funcionen, publique su pregunta en la sección de comentarios o en nuestros foros y estaré encantado de ayudarle.