No tutorial anterior, abordamos os comandos AT suportados por um modem SIM900 GSM-GPRS. Já discutimos como fazer a interface de um modem SIM900A GSM-GPRS com Raspberry Pi, Arduino, bem como outros microcontroladores e computadores desktop. Agora é hora de usar este modem para fazer e receber chamadas e enviar e receber SMS.
Neste tutorial, demonstraremos chamadas de voz e mensagens SMS usando um SIM900A com Raspberry Pi (RPi) e um computador desktop.
Comunicando-se com um modem GSM-GPRS usando Python
Aprendemos anteriormente sobre a comunicação receptor/transmissor assíncrono universal serial (UART) usando a porta serial TTL do RPi.
Basta conectar o modem GSM à porta serial TTL do RPi e abrir uma porta de comunicação serial com o modem usando o método serial.Serial . A seguir, você pode enviar os comandos AT para o modem usando o método serial.write e receber uma resposta dos comandos AT usando o método serial.read .
A resposta do modem pode ser armazenada em uma variável e impressa no console usando o método print . Também é possível projetar um Aplicativo GUI usando a biblioteca TTK e um editor de texto para que os dados sejam enviados e recebidos por uma porta serial — e mostrados em um aplicativo Python.
Na verdade, Python é independente de plataforma e pode ser usado para configurar comunicação serial em qualquer dispositivo e qualquer outra plataforma (ou seja, não apenas a plataforma Linux do RPi, mas também outras como Win32 e macOS).
Em um sistema desktop, a interface do modem pode ser feita usando uma placa serial USB. Para isso, primeiro descubra o nome da porta onde o modem GSM faz interface com o desktop, através da interface USB. Nós cobrimos como encontre um nome de porta serial em um desktop aqui.
Normalmente, o modem se comunica a uma taxa de transmissão de 9.600 bps e codificação de dados 8N1 UART. Os modems são projetados para detectar automaticamente a taxa de transmissão. Embora o esquema de codificação de dados permaneça 8N1, a taxa de transmissão máxima de 115.200 bps pode ser usada para comunicação com o modem.
Inicializando o modem SIM900A GSM-GPRS
Para começar, devemos preparar o modem GSM para comunicação celular. Insira um cartão SIM no suporte do cartão SIM do modem SIM900A. O modem é semelhante a um telefone celular e requer um cartão SIM para se conectar a uma rede celular.
A maioria dos modems possui suportes de cartão SIM para Mini SIM (fator de forma 2FF). No entanto, Micro SIM (fator de forma 3FF) e Nano SIM (fator de forma 4FF) também podem ser conectados, desde que os contatos do SIM toquem corretamente nos pinos do porta-cartão.
Em seguida, ligue o modem GSM conectando-o a um adaptador de energia (5V-12V, 2A). O LED de status do modem ou LED de rede começará a piscar. Normalmente pisca mais rapidamente enquanto o modem se conecta à rede móvel. Depois que o modem estiver conectado ao provedor de serviços de comunicação assinado (CSP), ele piscará a cada três segundos. Pode levar até um minuto para o modem inicializar (assim como a inicialização de um telefone celular) e se conectar a uma rede móvel assinada.
Se você ligar para o SIM conectado, o modem começará a tocar através da campainha e piscará o LED indicador de toque nele. Isso confirma que o modem está funcionando. Na verdade, quando você liga para o número SIM, a chamada é automaticamente atendida pelo modem após alguns toques. E se você conectar um alto-falante e um microfone ao modem, poderá falar e receber chamadas no SIM conectado. Portanto, a entrada do microfone e do alto-falante está, na verdade, no modem.
Interface do SIM900A com RPi
O modem SIM900A é um dispositivo de 5V e o Raspberry Pi é um computador de placa única de 3,3V. Não podemos conectar diretamente a porta serial TTL do modem SIM900 com a porta serial TTL do RPi.
Se você conectar diretamente as portas seriais do modem e do RPi, ele transmitirá os dados seriais para o modem porque o modem de 5V pode tolerar tensões UART de 3,3V. Mas quando você tenta receber dados do modem no RPi, os sinais UART de 5V do modem podem danificar ou destruir o pino do receptor serial do RPi.
Por segurança, vamos usar um Shifter lógico TTL de 5V a 3,3V. Um deslocador lógico simples de 5V para 3V3 pode ser projetado usando o diodo 1N4148, conforme mostrado neste diagrama de circuito:
Como alternativa, você pode usar um módulo de E/S de comutação de nível de 2, 4 ou 8 canais. Este é um módulo de E/S bidirecional de comutação de nível de 8 canais:
Em seguida, conecte os pinos Rxd, Txd e terra do modem aos do RPi por meio do circuito de comutação de nível ou módulo de E/S. Agora você está pronto para se comunicar com o modem pela porta serial.
Fazendo uma chamada do Raspberry Pi
Para habilitar a comunicação serial com o modem no RPi, você deve importar as bibliotecas serial, RPi.GPIO, os e time. As bibliotecas os e time são necessárias para usar a função sleep , que garante que o RPi aguarde respostas do modem.
Comece configurando o sistema de numeração de pinos para os números da placa e acesse a porta serial TTL do RPi usando o método serial.Serial . O nome da porta no Raspberry Pi é /dev/serial0. Alternativamente, o nome da porta pode ser /dev/ttyS0 ou /dev/ttyAMA0 — use qualquer um que seja o UART primário no respectivo Raspberry Pi.
Envie o comando AT “AT” ao modem usando o método serial.write para verificar a comunicação com ele. Leia a resposta do modem usando o método serial.read e imprima-a no console usando o método print ou em uma interface GUI. O modem responderá “OK” se estiver funcionando corretamente e conectado ao Raspberry Pi.
- Para fazer uma chamada, envie um comando “ATD
” para o modem - Para encerrar a chamada, envie um comando “ATH” ao modem
O script Python mostrado abaixo faz uma chamada para um número com êxito e encerra a chamada após 30 segundos. Os comandos AT são passados como bytes para o modem e a sequência de escape '\r' é usada para passar a entrada da linha de comando. Você também pode conectar um microfone e um alto-falante ao modem. Anteriormente, hackeamos um fone de ouvido para que chamadas de voz pudessem ser recebidas no modem GSM-GPRS.
importar série
importar sistema operacional, hora
importar RPi.GPIO como GPIO
GPIO.setmode(GPIO.BOARD)
porta = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b'ATD9166873301;\r')
print(“Chamando…”)
hora.sono(30)
porta.write(b'ATH\r')
print(“Desligar chamada…”)
Recebendo uma chamada no RPi
Quando o SIM conectado no modem é chamado de um telefone ou de qualquer dispositivo móvel, o modem atende automaticamente a chamada após alguns toques. O modem transmite “RING” de seu pino Txd quando há uma chamada recebida. O número que liga para o SIM pode ser extraído usando o comando “AT+CLIP”.
Esta chamada é automaticamente atendida pelo modem, a menos que seja rejeitada, o que pode ser feito usando o comando AT “ATH”. Para atender manualmente a chamada, pode-se utilizar o comando “ATA”.
Configurando o SIM900 para mensagens SMS
O modem primeiro precisa ser configurado para mensagens SMS do SIM900. Comece verificando se o modem está funcionando enviando o comando “AT”. A seguir, desligue o eco enviando o comando “ATE0”. Defina indicadores para recebimento de SMS usando o comando “AT+CNMI”.
Este é um comando do tipo set e tem o seguinte formato:
AT+CNMI =
O
0: Uma mensagem recém-recebida com códigos de resultado não solicitados é armazenada em buffer no modem. Se o buffer do modem estiver cheio, os códigos de resultado poderão ser armazenados em outro lugar ou as indicações mais antigas poderão ser substituídas por novas.
1: Os códigos de resultado das mensagens recebidas são descartados e rejeitados quando o modem está online (ou seja, há um link serial ativo entre o modem e o dispositivo de controle). Caso contrário, os códigos de resultado serão transferidos diretamente para o dispositivo de controle.
2: Os códigos de resultado das mensagens recebidas são armazenados em buffer no modem quando o modem está on-line (ou seja, há um link serial ativo entre o modem e o dispositivo de controle). Caso contrário, os códigos de resultado serão transferidos diretamente para o dispositivo de controle.
3: Neste modo, os códigos de resultado das mensagens recebidas são transferidos diretamente para o dispositivo de controle.
O
0: As indicações dobSMS-DELIVER não são roteadas para o dispositivo de controle.
1: Se o SMS-DELIVER estiver armazenado no modem, uma indicação de sua localização na memória é roteada para o dispositivo de controle usando os códigos de resultado (uma resposta aos comandos AT) para o comando “+CMTI:
2: Os códigos de resultado SMS-DELIVER são roteados diretamente para o dispositivo de controle.
3: Os SMS-DELIVERs de classe 3 são roteados para o dispositivo de controle usando os códigos de resultados não solicitados.
O
0: As indicações do CBM não são roteadas para o dispositivo de controle.
2: Quaisquer novos CBMs são roteados diretamente para o dispositivo de controle usando os códigos de resultado não solicitados (uma resposta ao comando AT) — “+CMB:
O
0: Os SMS-STATUS-REPORTs são não roteado para o dispositivo de controle.
1: Os SMS-STATUS-REPORTs são roteados para o dispositivo de controle usando o código de resultado não solicitado (uma resposta ao comando AT) usando “+CDS:
O
0: O buffer do modem é liberado para o dispositivo de controle quando o dispositivo de controle entra no modo 1 a 3.
1: O buffer do modem é limpo para o dispositivo de controle quando o dispositivo de controle entra no modo 1 a 3.
Lembre-se de que o dispositivo de controle é o Raspberry Pi, o Arduino, o microcontrolador ou o computador que controla o modem GSM. Na referência de comando AT do SIM900A, o modem é referido como adaptador de terminal (TA) e o dispositivo de controle é referido como equipamento terminal (TE).
Neste caso, definimos as indicações do SMS para “AT+CNMI=1, 1, 0, 0, 0”.
Em seguida, verifique o local preferido de armazenamento de SMS usando “AT+CPMS=?” comando. O local de armazenamento pode ser definido como cartão SIM (
Existem três memórias, onde:
1. As mensagens são lidas e excluídas
2. A escrita e o envio das mensagens estão concluídos
3. As mensagens recebidas são armazenadas
Definimos todas as três memórias no cartão SIM usando o comando AT: AT+CPMS=”SM”,”SM”,”SM.” Em resposta, o modem envia de volta a memória usada e total para todas as três operações (leitura, gravação e armazenamento de SMS recebidos).
Estas configurações de SMS serão perdidas se não forem salvas no modem. Para salvar essas configurações, o comando “AT+CSAS” é passado ao modem.
Excluímos todas as mensagens SMS atuais armazenadas no cartão SIM usando o comando AT+ CMGDA=”DEL ALL”. Por fim, verificamos novamente o espaço de memória utilizado para as mensagens SMS com o comando AT+CPMS=”SM”,”SM”,”SM”. Desta vez, os locais de memória usados são 0.
importar série
importar sistema operacional, hora
importar RPi.GPIO como GPIO
GPIO.setmode(GPIO.BOARD)
porta = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”ATE0\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CNMI=1,1,0,0,0\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CSAS\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sono(10)
porta.write(b'AT+CMGDA=”DEL ALL”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
Enviando o SMS do RPi
Para enviar o SMS, primeiro configure a mensagem para o modo texto usando o comando “AT+CMGF=1″. Em seguida, selecione um número para enviar o SMS usando o comando AT+CMGS=”XXXXXXXXXX”, onde XXXXXXXXXX é um número de celular.
A mensagem a ser enviada é armazenada em uma variável. O buffer de saída é limpo usando o método reset_output_buffer ou flushoutput , mas somente se a versão serialpy instalada no RPI for inferior a 2,5.
A mensagem é concatenada com CTRL+Z ou um caractere substituto usando o método char(26). A mensagem junto com o caractere substituto é codificada usando o método str.encode e enviada ao modem usando o método serial.write .
importar série
importar sistema operacional, hora
importar RPi.GPIO como GPIO
GPIO.setmode(GPIO.BOARD)
porta = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”AT+CMGF=1\r”)
print(“Modo Texto Habilitado…”)
hora.sono(3)
porta.write(b'AT+CMGS=”9166873301″\r')
msg = “mensagem de teste do SIM900A…”
print(“enviando mensagem….”)
hora.sono(3)
porta.reset_output_buffer
hora.sleep(1)
porta.write(str.encode(msg+chr(26)))
hora.sono(3)
imprimir(“mensagem enviada…”)
Recebendo o SMS no RPi
As mensagens recebidas são armazenadas no cartão SIM ou no telefone/modem. A mensagem SMS recebida em um índice específico pode ser lida passando o comando AT+CMGR=
O modem responderá com as indicações do SMS e um corpo do SMS recebido.
importar série
importar sistema operacional, hora
importar RPi.GPIO como GPIO
GPIO.setmode(GPIO.BOARD)
porta = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”ATE0\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”AT+CMGF=1\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
print(“Modo Texto Habilitado…”)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CMGR=1\r')
rcv = porta.read(100)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CMGL=”ALL”\r')
rcv = porta.read(300)
imprimir (rcv)
hora.sleep(1)
Interface do SIM900A com um computador desktop
Ao usar um computador desktop, o modem GSM-GPRS pode ser conectado a uma placa USB para serial. O modem via placa USB para serial é identificado como escravo USB no desktop.
Depois de descobrir o nome da porta serial no sistema desktop (macOS, Linux ou Windows), só é necessário alterar o nome da porta serial nos scripts acima.
O modem tem interface com a área de trabalho da seguinte forma:
Aqui conectamos o modem GSM-GPRS a um computador Windows. Em nossa área de trabalho do Windows, o modem através da placa serial USB é identificado como COM22.
Fazendo uma chamada de um computador desktop
Conforme mencionado anteriormente no script Python, para fazer uma chamada do Raspberry Pi, primeiro comente ou remova as seguintes linhas específicas do RPi:
importar RPi.GPIO como GPIO
GPIO.setmode(GPIO.BOARD)
porta = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
Abra uma comunicação serial com a porta COM, onde o modem GSM está conectado através da placa serial USB. Aqui, ele está usando COM22.
Adicione esta linha:
porta = serial.Serial (“COM22”, taxa de transmissão = 9600, tempo limite = 1)
Agora podemos fazer uma chamada do desktop usando o modem SIM900.
importar série
importar sistema operacional, hora
#importar RPi.GPIO como GPIO
#GPIO.setmode(GPIO.BOARD)
#port = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta = serial.Serial (“COM22”, taxa de transmissão = 9600, tempo limite = 1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b'ATD9166873301;\r')
print(“Chamando…”)
hora.sono(30)
porta.write(b'ATH\r')
print(“Desligar chamada…”)
O resultado:
Recebendo uma chamada em um computador desktop
Para receber uma chamada em um computador desktop, o processo é praticamente o mesmo do Raspberry Pi. Podemos passar os comandos para encerrar uma chamada recebida ou atendê-la manualmente usando um aplicativo serial (como Termite ou Putty) em uma área de trabalho do Windows.
Configurando o SIM900 para mensagens SMS em uma área de trabalho
Aqui, também precisamos comentar ou remover linhas específicas do RPi e adicionar o código adequado para abrir a porta serial COM de um desktop Windows no script Python – que deve ser escrito para definir as configurações de SMS no Raspberry Pi.
importar série
importar sistema operacional, hora
#importar RPi.GPIO como GPIO
#GPIO.setmode(GPIO.BOARD)
#port = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta = serial.Serial (“COM22”, taxa de transmissão = 9600, tempo limite = 1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”ATE0\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CNMI=1,1,0,0,0\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CSAS\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sono(10)
porta.write(b'AT+CMGDA=”DEL ALL”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
O resultado:
Dos códigos de resultado recebidos do modem, no máximo 25 mensagens podem ser armazenadas no cartão SIM. Neste caso, já havia duas mensagens armazenadas nele.
Depois de excluir todas as mensagens atuais durante a configuração, 0 é usado nos locais de memória SMS.
Enviando o SMS de um computador desktop
Mais uma vez, comente ou remova as linhas específicas do RPi. Adicione o código adequado para abrir a porta serial COM da área de trabalho do Windows no script Python, que é escrito para enviar mensagens SMS do Raspberry Pi.
importar série
importar sistema operacional, hora
#importar RPi.GPIO como GPIO
#GPIO.setmode(GPIO.BOARD)
#port = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta = serial.Serial (“COM22”, taxa de transmissão = 9600, tempo limite = 1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”AT+CMGF=1\r”)
print(“Modo Texto Habilitado…”)
hora.sono(3)
porta.write(b'AT+CMGS=”9166873301″\r')
msg = “mensagem de teste do SIM900A…”
print(“enviando mensagem….”)
hora.sono(3)
porta.reset_output_buffer
hora.sleep(1)
porta.write(str.encode(msg+chr(26)))
hora.sono(3)
imprimir(“mensagem enviada…”)
O resultado:
Recebendo o SMS em um computador desktop
Também é necessário comentar ou remover linhas específicas do RPi aqui. Adicione o código para abrir a porta serial COM da área de trabalho do Windows no script Python, que é escrito para receber SMS no Raspberry Pi.
importar série
importar sistema operacional, hora
#importar RPi.GPIO como GPIO
#GPIO.setmode(GPIO.BOARD)
#port = serial.Serial(“/dev/ttyS0”, taxa de transmissão=9600, tempo limite=1)
porta = serial.Serial (“COM22”, taxa de transmissão = 9600, tempo limite = 1)
porta.write(b'AT\r')
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”ATE0\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
porta.write(b”AT+CMGF=1\r”)
rcv = porta.read(10)
imprimir (rcv)
hora.sleep(1)
print(“Modo Texto Habilitado…”)
hora.sleep(1)
porta.write(b'AT+CPMS=”SM”,”SM”,”SM”\r')
rcv = porta.read(30)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CMGR=1\r')
rcv = porta.read(100)
imprimir (rcv)
hora.sleep(1)
porta.write(b'AT+CMGL=”ALL”\r')
rcv = porta.read(300)
imprimir (rcv)
hora.sleep(1)
O resultado:
Nota: as mensagens SMS recebidas são armazenadas no cartão SIM, por isso estamos passando comandos para ler essas mensagens dos locais de memória do cartão SIM.
Agora você pode conectar um modem SIM900 GSM-GPRS com Raspberry Pi e qualquer sistema desktop. Isso inclui fazer e receber chamadas e enviar e receber mensagens SMS.
No próximo tutorial, aprenderemos como fazer a interface de um modem GPS com Raspberry Pi e um computador desktop.
