Interface do módulo Gsm com microcontrolador pic

Os módulos GSM são fascinantes de usar, especialmente quando nosso projeto requer acesso remoto. Esses módulos podem realizar todas as ações que nosso telefone celular normal pode realizar, como fazer / receber uma chamada, enviar / receber um SMS, conectar-se à Internet usando GPRS etc. Você também pode conectar um microfone e alto-falante normais a este módulo e conversar no seu chamadas móveis. Isso abrirá portas para muitos projetos criativos se puder ser conectado a um microcontrolador. Portanto, neste tutorial, aprenderemos como podemos fazer a interface do módulo GSM (SIM900A) com nosso microcontrolador PIC e demonstraremos fazendo e recebendo chamadas usando o módulo GSM. Anteriormente, fizemos a interface com Arduino e Raspberry Pi para chamadas e mensagens:

Chamada e mensagem usando Arduino e módulo GSM
Ligar e enviar mensagens de texto usando Raspberry Pi e módulo GSM

Materiais requisitados:

Microcontrolador PIC (PIC16F877A)
Módulo GSM (SIM900 ou qualquer outro)
Fios de conexão
Adaptador 12V
PicKit 3

Módulo GSM:

O módulo GSM pode ser usado mesmo sem qualquer microcontrolador, usando o modo de comando AT. Conforme mostrado acima, o módulo GSM vem com um adaptador USART que pode ser conectado diretamente ao computador usando um módulo MAX232 ou os pinos Tx e Rx podem ser usados para conectá-lo a um microcontrolador. Você também pode notar os outros pinos como MIC +, MIC-, SP +, SP- etc, onde um microfone ou alto-falante pode ser conectado. O módulo pode ser alimentado por um adaptador de 12 V por meio de um conector de barril CC normal.

Insira seu cartão SIM no slot do módulo e ligue-o, você deve notar um LED de energia acendendo. Agora espere por um minuto ou mais, e você verá um LED vermelho (ou qualquer outra cor) piscando uma vez a cada 3 segundos. Isso significa que seu Módulo foi capaz de estabelecer conexão com seu cartão SIM. Agora você pode prosseguir com a conexão do seu módulo com o telefone ou qualquer microcontrolador.

Comunicação com o módulo GSM usando comandos AT:

Como você já deve ter adivinhado, o módulo GSM pode se comunicar por meio de comunicação serial e só pode entender um idioma: os “ comandos AT ”. O que quer que você queira dizer ou perguntar ao módulo GSM, deve ser apenas por meio de comandos AT. Por exemplo, se você deseja saber se o seu módulo está ativo. Você deve pedir (enviar) um comando como “AT” e seu módulo responderá “OK”.

Esses comandos AT são bem explicados em sua folha de dados e podem ser encontrados aqui em sua folha de dados oficial. OK! OK! É uma folha de dados de 271 páginas e você pode levar dias para lê-la. Então, eu dei alguns comandos AT mais importantes abaixo para que você possa colocá-los em funcionamento em breve.

AT	Respostas com OK para reconhecimento
AT + CPIN?	Verifique a qualidade do sinal
AT + COPS?	Encontre o nome do provedor de serviços
ATD96XXXXXXXX;	Ligue para o número específico, termina com ponto e vírgula
AT + CNUM	Encontre o número do cartão SIM (pode não funcionar para alguns SIM)
ATA	Atenda a chamada
ATH	Desligue a chamada de entrada atual
AT + COLP	Mostrar número de chamada recebida
AT + VTS = (número)	Envie o número DTMF. Você pode usar qualquer número no teclado do seu celular para (número)
AT + CMGR	AT + CMGR = 1 lê a mensagem na primeira posição
AT + CMGD = 1	Excluir mensagem na primeira posição
AT + CMGDA = ”DEL ALL”	Excluir todas as mensagens do SIM
AT + CMGL = ”TODOS”	Leia todas as mensagens do SIM
AT + CMGF = 1	Defina a configuração de SMS. “1” é para modo somente texto
AT + CMGS = “+91 968837XXXX” > Texto CircuitDigest	Envia SMS para um número específico aqui 968837XXXX. Quando você vir “>”, comece a inserir o texto. Pressione Ctrl + Z para enviar o texto.
AT + CGATT?	Para verificar a conexão à Internet no cartão SIM
AT + CIPSHUT	Fechar a conexão TCP, ou seja, desconectar-se da internet
AT + CSTT = "APN", "nome de usuário", "Aprovado"	Conecte-se ao GPRS com seu APN e chave de acesso. Pode ser obtido no provedor de rede.
AT + CIICR	Verifique se o cartão SIM possui pacote de dados
AT + CIFSR	Obter IP da rede SIM
AT + CIPSTART = “TCP”, ”IP DO SERVIDOR”, ”PORTA”	Usado para definir uma conexão TCP IP
AT + CIPSEND	Este comando é usado para enviar dados para o servidor

Diagrama de circuito:

O diagrama de conexão para o módulo GSM de interface com o microcontrolador PIC é mostrado abaixo.

Simplesmente conectamos os pinos Tx e Rx do módulo GSM aos pinos Rx e Tx do PIC MCU PIC16F877A, respectivamente. Isso estabelecerá uma conexão serial entre os dois. Além disso, não se esqueça de estabelecer uma ligação comum entre os módulos GSM e PIC. Também usamos um display LCD para saber o status do nosso módulo GSM. Assim que as conexões forem feitas, seu hardware se parecerá com o seguinte.

A placa PIC Perf foi feita para nossa série de tutoriais PIC, na qual aprendemos como usar o microcontrolador PIC. Você pode querer voltar para aqueles tutoriais de Microcontrolador PIC usando MPLABX e XC8 se você não souber como gravar um programa usando Pickit 3, já que estarei pulando todas essas informações básicas.

Programando seu microcontrolador PIC:

O programa completo para este projeto pode ser encontrado na parte inferior deste tutorial. Aqui explicarei algumas funções e partes importantes do código. Este programa também possui códigos de LCD que foram da interface de LCD com microcontrolador PIC, você pode visitar esse tutorial se estiver curioso para saber como LCD pode ser usado com microcontrolador PIC.

Como dito anteriormente, vamos nos comunicar entre PIC e GSM usando comandos AT através do modo Serial de comunicação. Portanto, primeiro temos que inicializar o módulo de comunicação USART em nosso microcontrolador PIC usando o Initialize _SIM900 (); função. Dentro desta função, declaramos os pinos Tx e RX e inicializamos a recepção e transmissão assíncrona na taxa de transmissão de 9600 e no modo de 8 bits.

// *** Inicializar UART para SIM900 ** // void Initialize_SIM900 (void) {// **** Definindo pinos de E / S para UART **** // TRISC6 = 0; // Pino TX definido como saída TRISC7 = 1; // Pino RX definido como entrada // ________ Pinos de E / S definidos __________ // / ** Inicializar o registro SPBRG para a taxa de transmissão necessária e definir BRGH para taxa de transmissão rápida ** / SPBRG = 129; // SIM900 opera a uma taxa de 9600 Baud, então 129 BRGH = 1; // para baud_rate alto // _________ Fim da configuração de baud_rate _________ // // **** Habilitar porta serial assíncrona ******* // SYNC = 0; // SPEN assíncrono = 1; // Habilita os pinos da porta serial // _____ Porta serial assíncrona habilitada _______ // // ** Vamos nos preparar para a transmissão e recepção ** // TXEN = 1; // habilita a transmissão CREN = 1; // habilita a recepção // __ módulo UART ativo e pronto para transmissão e recepção __ // // ** Selecione o modo de 8 bits ** // TX9 = 0; // Recepção de 8 bits selecionada RX9 = 0;// modo de recepção de 8 bits selecionado // __ modo de 8 bits selecionado __ //} // ________ módulo UART inicializado __________ //

Agora precisamos ler e gravar informações de / para nosso módulo GSM. Para isso usamos as funções _SIM900_putch (), _SIM900_getch (), _SIM900_send_string (), _SIM900_print (). Essas funções usam o registro de buffer de transmissão e recepção, como TXREG e RCREG, para ler ou gravar dados em série.

// ** Função para enviar um byte de data para UART ** // void _SIM900_putch (char bt) {while (! TXIF); // mantenha o programa até que o buffer TX esteja livre TXREG = bt; // Carregar o buffer do transmissor com o valor recebido} // _____________ Fim da função ________________ // // ** Função para obter um byte de data do UART ** // char _SIM900_getch () {if (OERR) // verificar o erro { CREN = 0; // Se houver erro -> Redefinir CREN = 1; // Se houver erro -> Reiniciar} while (! RCIF); // mantenha o programa até que o buffer RX esteja livre return RCREG; // recebe o valor e envia para a função principal} // _____________ Fim da função ________________ // // ** Função para converter string em byte ** // void SIM900_send_string (char * st_pt) {while (* st_pt) // se houver é um char _SIM900_putch (* st_pt ++);// processá-lo como um dado de byte} // ___________ Fim da função ______________ // // ** Fim dos códigos modificados ** // void _SIM900_print (unsigned const char * ptr) {while (* ptr! = 0) {_SIM900_putch (* ptr ++); }

As funções acima são universais e não precisam ser alteradas para nenhum aplicativo. Eles foram explicados apenas para dar uma introdução aproximada. Você pode mergulhar fundo neles se quiser através da compreensão.

Agora dentro de nossa função principal, inicializamos a conexão USART e verificamos se podemos receber um “OK” quando enviamos “AT” usando a linha de código abaixo

faça {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Módulo não encontrado"); } enquanto (! SIM900_isStarted ()); // espere até que o GSM envie de volta "OK" Lcd_Set_Cursor (2,1); Lcd_Print_String ("Módulo detectado"); __delay_ms (1500);

A função SIM900_isStarted (); irá enviar “AT” para o GSM e aguarda a resposta “OK” dele. Se sim, ele retornará 1 else 0;

Se o módulo não for detectado ou se houver algum problema de conexão, o LCD mostrará "Módulo não encontrado", caso contrário, mostrará Módulo detectado e prosseguiremos para a próxima etapa, onde verificamos se o cartão SIM pode ser detectado pelo seguinte linha de código.

/ * Verifique se o cartão SIM foi detectado * / do {Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM não encontrado"); } enquanto (! SIM900_isReady ()); // espera até que o GSM envie de volta "+ CPIN: READY" Lcd_Set_Cursor (2,1); Lcd_Print_String ("SIM detectado"); __delay_ms (1500);

A função SIM900_isReady () enviará “AT + CPIN?” para o GSM e aguarda a resposta “+ CPIN: PRONTO” dele. Se sim, ele retornará 1 else 0;

Se um cartão SIM for encontrado, teremos o SIM detectado exibido no LCD. Então, podemos tentar fazer uma chamada usando o comando “ ATD mobilenumber ; ”. Aqui, como exemplo, usei meu número como ATD93643159XX;. Você deve substituir seu respectivo número de celular lá.

/ * Fazer uma ligação * / do {_SIM900_print ("ATD93643XXXXX; \ r \ n"); // Aqui estamos fazendo uma chamada para o número 93643XXXXX Lcd_Set_Cursor (1,1); Lcd_Print_String ("Colocando Chamada…."); } enquanto (_SIM900_waitResponse ()! = SIM900_OK); // espere até que o ESP envie "OK" de volta Lcd_Set_Cursor (1,1); Lcd_Print_String ("Chamada feita…."); __delay_ms (1500);

Assim que a chamada for feita, o LCD exibirá Chamada efetuada e você deverá receber uma chamada para esse número especificado.

Você também pode ligar para o número do celular conectado ao módulo GSM e ser notificado sobre isso na tela LCD usando o código abaixo

while (1) {if (_SIM900_waitResponse () == SIM900_RING) // Verificar se há uma chamada de entrada {Lcd_Set_Cursor (2,1); Lcd_Print_String ("Chamada de entrada !!."); }}

Quando o módulo GSM detecta uma chamada recebida, ele exibe Chamada recebida na segunda linha do módulo LCD. A função _SIM900_waitResponse () verificará os dados de entrada do módulo GSM. Ao receber SIM900_RING, que equivale a “RING” devido ao waitResponce () , exibiremos o status “Chamada entrante”.

Você pode criar suas próprias funções como esta para realizar quase todos os tipos de ativações usando o módulo GSM. Se você quiser que as coisas sejam codificadas, você pode simplesmente usar a função __SIM900_print () para enviar qualquer comando AT como este abaixo.

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

Lembre-se de que todos os seus comandos devem ser seguidos de “\ r \ n” para indicar que o comando está terminando.

Simulação:

Depois de entender como o programa funciona, você pode tentar simular e fazer alterações para atender às suas necessidades. A simulação vai economizar muito tempo. A simulação é feita usando Proteus e tem a aparência abaixo.

Como você pode ver, usamos a opção de terminal virtual no Proteus para verificar se o Programa está respondendo conforme o esperado. Podemos alimentar os valores por meio da caixa de diálogo pop-up. Por exemplo, assim que clicarmos em executar, uma caixa de diálogo preta como a acima aparecerá e exibirá AT, isso significa que ele enviou o módulo GSM AT, agora podemos responder ao PIC digitando na caixa como “OK” e apertando enter e o PIC responderá a ele. Da mesma forma, podemos tentar todos os comandos AT.

Fazendo e recebendo chamadas usando GSM e PIC:

Depois de entender como o código e o hardware funcionam, simplesmente carregue o programa abaixo no PIC e ligue o módulo. Seu LCD deve exibir “Módulo detectado”, “SIM detectado” e “Chamada realizada” se tudo estiver funcionando bem. Depois de ver "Chamada realizada", você receberá uma chamada para o número especificado no programa.

Você também pode tentar ligar para o número presente no módulo GSM e seu LCD exibirá “Chamada de entrada” para indicar que o SIM está sendo chamado.

O funcionamento completo do projeto é mostrado no vídeo abaixo. Espero que você tenha entendido o projeto e gostado de executá-lo. Se você tiver qualquer problema em fazer as coisas funcionarem, poste sua pergunta na seção de comentários ou em nossos Fóruns e ficarei feliz em ajudá-lo.