ARTHUR MUNIZ
BRUNO BRAZ
ELAINE LOPES
MILTHOR FERNANDES
SO MATEUS
2015
VIA
II
ARTHUR MUNIZ
BRUNO BRAZ
ELAINE LOPES
MILTHOR FERNADES
Samatec,
como
requisito
SO MATEUS
2015
III
ARTHUR MUNIZ
BRUNO BRAZ
ELAINE LOPES
MILTHOR FERNADES
ACIONAMENTO REMOTO DE PORTO ELTRICO VIA
CELULAR ATRAVS DE MICROCONTROLADOR
COMISSO EXAMINADORA
Prof. - Convidado
IV
AGRADECIMENTOS
RESUMO
Este projeto apresenta um dispositivo de acionamento remoto de portes
eltricos via celular utilizando micro controlador. O projeto integra a placa
Arduino UNO, cujo micro controlador ATmega328, uma placa com mdulo
GSM SIM900 e uma placa com mdulos rels num nico prottipo. O prottipo
realiza cadastro de usurios, adicionando novos ou removendo cadastros j
existentes, atravs de mensagem de texto enviada por um administrador do
sistema o primeiro usurio a mandar um SMS ao prottipo. O prottipo, ao
receber a mensagem, faz a identificao e a compara aos telefones cadastrados
em seu SIM Card; e envia um pulso eltrico ao mdulo rel acionando o porto
eltrico caso o usurio seja cadastrado. A linguagem de programao utilizada
para o desenvolvimento foi a Arduino que implementa as linguagens Processing
e C.
VI
SUMRIO
VII
5.1 Modelagem do sistema .............................................................. 30
5.2 Elaborao do cdigo fonte ...................................................... 31
5.2.1 Escrita do cdigo fonte .................................................... 31
5.3 Montagem do prottipo .............................................................. 34
VIII
LISTA DE FIGURAS
Figura 2.1 Dispositivo (2), TiDiGino............................................................17
Figura 2.2 Ilustrao do funcionamento do dispositivo (1)......................18
Figura 3.1 Placa Arduino UNO.....................................................................20
Figura 3.2 Logo GSM desde 2000................................................................20
Figura 3.3 SIM Card usado no projeto........................................................22
Figura 4.1 Modelo Arduino UNO..................................................................23
Figura 4.2 Interface do Arduino IDE verso 0022 (AUTOR)......................26
Figura 4.3 Circuito esquemtico da placa com modulo GSM SIM900.....27
Figura 4.4 Mdulo GSM SIM900...................................................................28
Figura 4.5 Placa do porto ( esquerda) e botoeira em destaque (
direita)...............................................................................................................31
Figura 4.6 Tenso em volts ( esquerda) e a corrente em A ( direita)
do porto eltrico utilizado no projeto..........................................................31
Figura 4.7 Placa com 8 mdulos rels........................................................32
Figura 4.8 Circuito do modulo rel..............................................................32
Figura 5.1 Fluxograma geral........................................................................34
Figura 5.2 Fluxograma Trata SMS.............................................................34
Figura 5.3 Cdigo fonte: Diretivas e Variveis...........................................36
Figura 5.4 Cdigo fonte: Funo setup......................................................37
Figura 6.0 Placa Aruino UNO em funcionamento......................................46
IX
LISTA DE TABELAS
Tabela 4.1 Principais caractersticas da placa Arduino UNO...................24
Tabela 4.2 Pinagem da placa Arduino UNO utilizada neste projeto........25
Tabela 4.3 Descrio da interface do Arduino IDE....................................26
Tabela 4.4 Sintaxe dos comandos AT.........................................................29
Tabela 4.5 Comandos AT utilizados............................................................30
Tabela 5.1 Comandos da funo setup......................................................38
Hayes AT Commands
Centmetros
EEPROM
FTDI
GSM
IDE
KB
Kilo Bytes
Micro Ampere
MHz
Mega Hertz
PWM
SRAM
USB
Volts
11
CAPTULO 1 INTRODUO
1.1 Apresentao do Problema
Nos ltimos anos, tem sido uma tendncia a utilizao da tecnologia no dia a dia
do ser humano, em diversos setores de sua vida. No que diz respeito ao controle
e automao residencial, h diversas ofertas de produtos para um mercado
crescente, que pode pagar por mais comodidade e segurana.
Dentre as diversas tecnologias que tm sido trazidas s residncias, portes
eltricos acionados por controle remoto uma destas tecnologias mais simples
e presentes em casas e condomnios. Essa tecnologia permite um acesso mais
gil, seja residncia, ao condomnio, etc., tornando esse acesso mais seguro,
evitando que o usurio tenha que sair do veculo para abrir o porto. No entanto,
o controle remoto responsvel pelo acionamento do porto eltrico no faz
distino de quem o aciona, tornando possvel o acesso de qualquer indivduo
que tenha este controle em mos.
Outro problema gerado pelo acionamento remoto o fato do usurio ter
que carregar consigo at mais de um controle, como no caso de condomnios em
que necessrio um controle para o acesso ao condomnio e outro para a prpria
residncia. Como solucionar ou evitar estes problemas?
12
cadastra o cliente que a enviou como administrador do sistema o nico capaz
de cadastrar e remover usurios. Aps a definio do administrador, possvel
realizar o cadastro de novos usurios atravs do envio de um SMS com o nmero
de telefone do cliente. Caso seja necessria a remoo de um usurio, basta que
o administrador envie outro SMS com o nmero deste cliente para que o sistema
o apague da memria. Assim, ao receber um SMS, o prottipo verifica o cadastro
e aciona o porto eltrico para os usurios registrados.
1.3 Metodologias
Para o desenvolvimento deste projeto foram realizadas pesquisas bibliogrficas
como ponto de partida para o desenvolvimento da idia do prottipo. Diversas
pesquisas foram feitas no site oficial do microcontrolador escolhido para a
determinao dos componentes de hardware como a placa Arduino UNO e o
mdulo GSM SIM900 e software o ambiente de desenvolvimento Arduino
(IDE) que foram utilizados ao longo do desenvolvimento do projeto.
Foram realizados estudos sobre a tecnologia da telefonia mvel, como a rede
GSM e o envio de mensagens de texto, e tambm sobre as caractersticas fsicas
dos componentes utilizados no projeto. Todos os componentes eletrnicos foram
estudados atravs de manuais e sites oficiais para o desenvolvimento do
prottipo. Estes componentes foram testados atravs de medies com
multmetro, bem como suas ligaes.
O desenvolvimento do sistema teve como incio a elaborao de um fluxograma
geral do programa que serviu como base para a escrita do cdigo fonte. Foi
desenvolvido um fluxograma, para o tratamento de SMS , para auxiliar tanto na
compreenso quanto na elaborao do destas das funes. Aps a escrita do
cdigo fonte, este foi compilado e carregado no microcontrolador para que ento
fosse realizada a montagem do prottipo. O dispositivo teve como base um
quadrado de madeira onde foram fixados os componentes eletrnicos e, depois,
colocados dentro de uma caixa de papelo adaptada.
Os testes realizados foram executados atravs de celular comum com chip da
operadora Vivo. Estes testes tm como objetivo avaliar o desempenho do
13
sistema nas seguintes tarefas: definio do administrador, cadastro de novos
usurios, remoo de usurios e acionamento remoto do porto eltrico.
14
2.2 Comodidade
O avano tecnolgico contnuo observado nas mais diversas reas, como na
medicina, construo civil, engenharia da computao e, com isso, tem
adentrado hospitais, escritrios e residncias.
A tecnologia surge tambm como uma fonte geradora de conforto. Desde um
simples controle remoto da televiso at geladeiras que informam quando os
alimentos esto acabando so possibilidades.
15
O prottipo resultante deste projeto tem como objetivo trazer mais comodidade
ao usurio, tendo o controle de acionamento remoto do porto eltrico ao alcance
de um SMS.
16
Figura 2.2 Ilustrao do funcionamento do dispositivo (1). Fonte: GSM REMOTE CONTROL
17
3.1 Microcontroladores
Segundo Gimenez (2005), o microcontrolador um dispositivo semicondutor
em forma de circuito integrado, que integra as partes bsicas de um
microcomputador microprocessador, memrias no-volteis e volteis e portas
de entrada e sada.
Microcontroladores so usados com frequncia em tarefas especficas que no
exijam grandes quantidades de dados, como em automao residencial mais
especificamente, placas de portes eltricos , pois geralmente possuem pouca
memria de armazenamento.
3.1.1 Arduino
O Arduino uma plataforma de computao fsica de fonte aberta, com base em
uma placa simples de entrada/sada (input/output, ou I/O), assim como em um
ambiente de desenvolvimento que implementa a linguagem Processing 1 . O
Arduino pode ser utilizado para desenvolver objetos interativos independentes,
ou conectado a softwares de seu computador (BANZI, 2011).
Processing uma linguagem de programao de cdigo aberto que foi inicialmente desenvolvida
para ensinar fundamentos da programao computacional num contexto visual.
18
Criada em 1982, a rede GSM uma tecnologia digital para celulares usada para
transmisso mvel de voz e dados. A rede GSM permite que indivduos sejam
19
contatados atravs do mesmo nmero de celular em at 219 pases. As redes
GSM terrestres cobrem mais de 90% da populao mundial e a tecnologia
roaming 2 GSM de satlites estende essa cobertura para reas que a rede
terrestre no alcana. Hoje, as conexes mveis globais superam 6 bilhes
(GSM,2012).
3.3 SMS
De acordo com Hillebrand (2010), o conceito do Servio de Mensagens Curtas
(do ingls, Short Message Service) foi desenvolvido em 1984 numa cooperao
franco-germnica. A idia seria aproveitar o sistema telefnico da poca, que
mandava mensagens de sinalizao atravs de canais telefnicos para controle
de trfego durante certos perodos do dia, para enviar mensagens de texto a um
baixo custo quando este sistema estivesse ocioso. No entanto, essas
mensagens seriam limitadas a 128 bytes (futuramente aumentadas para 140
bytes ou 160 dgitos de 7 bits), o tamanho padro das mensagens de sinalizao
utilizadas.
Atualmente, as mensagens de texto esto presentes no cotidiano dos usurios
de telefones celulares como uma forma barata e rpida de se comunicar.
Segundo o site de estudos estatsticos, Statista3 (2012), durante o ano de 2010
mais de 192 mil mensagens de textos foram enviadas a cada segundo em todo
o globo.
20
chip que utilizado para identificar um usurio na rede GSM e tambm para
controlar e armazenar dados de telefones celulares.
Na Figura 3.3 ilustrado o SIM Card utilizado neste projeto. Este possui 128 KB
de memria e dimenses padres de 25 milmetros comprimento e 15 milmetros
de largura.
O SIM Card possui uma memria do tipo EEPROM, uma memria no voltil,
que armazena, no s os nmeros de telefones e o cdigo de identificao do
chip, mas as configuraes e dados das outras funcionalidades. Algumas dessas
funcionalidades so:
Autenticao do usurio
21
4.1.1 Especificaes
A placa Arduino UNO baseada no microcontrolador ATmega328, produzido
pela Atmel. A figura 4.1 ilustra o modelo da placa utilizada neste projeto.
22
Descrio
Microcontrolador
ATmega328
Voltagem de operao
5V
Alimentao (Recomendada)
7 12 V
Alimentao (Limite)
6 20 V
14 (de 0 at 13, dos quais 6 podem prover
sadas PWM)
6 (de A0 at A5)
40 mA
50 mA
Memria Flash
32 KB (ATmega328)
SRAM
2 KB (ATmega328)
EEPROM
1 KB (ATmega328)
Frequncia de clock2
16 MHz
Fonte: AUTOR
Esta placa possui 3 pinos GND (do ingls Ground, ou Terra), dois pinos que
fornecem uma voltagem regulada de 3,3 V e 5 V cada, um pino Vin que fornece
a voltagem advinda diretamente da alimentao seja por USB ou por fonte
externa e um pino de entrada para referncia analgica (AREF).
Utilizao
23
Vin
5V
GND
4
5
GSM
Porta TX Virtual para controle do Mdulo GSM
Acionamento de um dos rels da placa de
Rels
Fonte: AUTOR
24
Nome
Descrio
Item composto do nome da
Ttulo | Verso
sketch e da verso do
Arduino IDE
Verify
Stop
Para a execuo ou
compilao do programa
New
Open
Save
Upload
Efetua a compilao do
1
2
placa
7
Fonte: AUTOR
Serial Monitor
25
Shield do ingls, escudo. Utilizada neste contexto como placa empilhvel em formato compatvel
com a placa Arduino UNO.
26
4.4 Comandos AT
Os comandos AT so linhas de cdigo com solicitaes de servios
reconhecidas pelo mdulo GSM SIM900. Esses comandos so fornecidos pelo
fabricante e seguem um padro de sintaxe descrito brevemente a seguir na
tabela 4.4.
Tabela 4.4 Sintaxe dos comandos AT
Nome
Sintaxe
Descrio
Comando de Teste
AT+<comando>=?
Comando de Leitura
AT+<comando>?
Comando de Escrita
AT+<comando>=<...>
27
Executa parmetros no
Comando de Execuo
AT+<comando>
Apesar do mdulo GSM SIM900 reconhecer uma vasta lista de comandos AT,
apenas
alguns
desses
foram
utilizados
direta
ou
indiretamente
no
Descrio
AT
AT+IPR=9600
(bauds)
AT&F
AT+CLIP=1
AT+CMEE=0
AT+CMGF=1
AT+CPBS=SM
ATE0
AT+CPBR=i
no mdulo
Retorna o registro na posio i do SIM Card
Escreve o nmero de telefone 06199998888
AT+CPBW=i,06199998888
AT+CPAS
AT+CLCC
AT+CMGL=ALL
AT+CMGR=i
28
Apaga todas mensagens de texto do local de
AT+CMGD=1,4
ATH
armazenamento atual
Desliga quaisquer chamadas e/ou ligaes
Figura 4.5 Placa do porto ( esquerda) e botoeira em destaque ( direita). Fonte: AUTOR
29
Como o prottipo visa abranger um grande nmero de portes eltricos e suas
botoeiras o rel escolhido foi o comum SRD-05VDC-SL-C da SONGLE que
requer a alimentao de 5 V que a placa Arduino UNO pode fornecer.
A placa com mdulos rels utilizada neste projeto se caracteriza pela associao
de um opto-acoplador (U1) utilizado para proteo das placas Arduino UNO e
shield GSM , um transistor (Q1) que controla o fluxo da corrente no rel, um
diodo (D1) e um rel, para cada de mdulo rel. Apesar da placa utilizada possuir
8 mdulos rels, apenas um utilizado para o acionamento do porto eltrico.
30
CAPTULO 5 IMPLEMENTAO
Neste captulo so descritos, detalhadamente, os procedimentos necessrios
para o desenvolvimento deste projeto. Esses procedimentos foram divididos da
seguinte forma:
Modelagem do sistema;
Montagem do prottipo;
31
Comunicao serial:
O
cdigo fonte de teste faz com que o prottipo envie ao monitor serial
Relatrio peridico:
O
32
5.1 Modelagem do sistema e a pinagem utilizada definida na tabela 4.2
Pinagem da placa Arduino UNO utilizada neste projeto possvel definir as
diretivas de pr-compilao e as variveis.
Aps definir as diretivas de pr-compilao e as variveis, necessrio definir
que parte do cdigo fonte deve executar apenas uma nica vez. Na linguagem
de programao Arduino, utiliza-se a funo setup para o que se executar
apenas na inicializao do sistema.
Essa funo de inicializao basicamente define qual pino ser utilizado para
enviar o pulso eltrico (pinoRele), inicia a comunicao serial para o envio de
informaes ao monitor serial, liga e configura o mdulo GSM de acordo com a
necessidade do prottipo. A tabela 5.1 mostra cada funo utilizada e uma breve
descrio dessas.
Tabela 5.1 Comandos da funo setup
Nome
Descrio
pinMode(i,OUTPUT)
Serial.begin(9600)
gsm.TurnOn(9600)
gsm.InitParam(1)
- AT+CLIP=1
- AT+CMEE=0
- AT+CMGF=1
- AT+CPBS=SM
Desabilita eco das informaes no mdulo
gsm.Echo(0)
Serial.println(texto) ou Serial.print(texto)
33
Verifica se existe algum nmero de telefone
na posio i e carrega este nmero em
gsm.GetPhoneNumber(i,telefone)
Fonte: AUTOR
34
6. Apaga SMS recebido para economizar espao de memria.
35
6.1 Simulaes
Nessa seo, so testadas todas as funcionalidades propostas ao sistema, no
intuito de simular um ambiente real. As funcionalidades simuladas tiveram como
objetivo atingir as seguintes metas:
36
37
4. Confirmar cadastro do administrador e do nmero enviado por SMS
atravs de relatrio peridico do sistema.
Os resultados obtidos nessas simulaes do sistema demonstraram
funcionamento do prottipo da forma esperada. Em todos os testes o sistema
no demonstrou falhas na fase de inicializao do prottipo at a execuo da
etapa 1. Em todos os testes realizados, na etapa 2, o sistema funcionou como
esperado, no autorizando o usurio no cadastrado. Na etapa 3, o tempo para
o recebimento da mensagem de texto pelo prottipo oscilou entre 10 e 30
segundos para 27 das 30 simulaes.
38
Os
resultados
obtidos
nessas
simulaes
do
sistema
demonstraram
39
1. Enviar um SMS de um usurio cadastrado e confirmar o acionamento
do porto eltrico atravs de mensagem mostrada no monitor serial.
2. Enviar SMS de um usurio no cadastrado e confirmar o NO
acionamento do porto eltrico atravs de mensagem mostrada no
monitor serial.
Os
resultados
obtidos
nessas
simulaes
do
sistema
demonstraram
40
as mensagens de texto enviadas durante o desenvolvimento e simulao do
prottipo foram recebidas, existe a possibilidade que tanto o cadastro quanto a
remoo de usurios no ocorra, se fazendo necessria uma verificao
adicional, como a tentativa de um novo usurio acionar o porto eltrico para
garantir seu cadastro.
41
42
43
REFERNCIAS BIBLIOGRFICAS
WIKIPEDIA,
enciclopdia
livre.
Wikipdia.
Disponvel
em:
44
45
46
}
if((*p_char1)=='4') {
digitalWrite(GSM_ON, HIGH);
delay(1200);
digitalWrite(GSM_ON, LOW);
delay(10000);
ret_val=2;
}
return ret_val;
}
int SIMCOM900::configandwait(char* pin)
{
int connCode;
//_tf.setTimeout(_GSM_CONNECTION_TOUT_);
if(pin) setPIN(pin); //syv
// Try 10 times to register in the network. Note this can take some time!
for(int i=0; i<10; i++) {
//Ask for register status to GPRS network.
SimpleWriteln(F("AT+CGREG?"));
//Se espera la unsolicited response de registered to network.
while(gsm.WaitResp(5000, 50, "+CGREG: 0,")!=RX_FINISHED_STR_RECV)
//while (_tf.find("+CGREG: 0,")) // CHANGE!!!!
{
//connCode=_tf.getValue();
connCode=_cell.read();
if((connCode==1)||(connCode==5)) {
setStatus(READY);
SimpleWriteln(F("AT+CMGF=1")); //SMS text mode.
delay(200);
// Buah, we should take this to readCall()
SimpleWriteln(F("AT+CLIP=1")); //SMS text mode.
delay(200);
//_cell << "AT+QIDEACT" << _DEC(cr) << endl; //To make sure not pending
connection.
//delay(1000);
return 1;
}
}
}
return 0;
}
/**
47
* SIMCOM900::read(char* buffer, int buffersize)
*
* Waits for data to be readable from the gsm module, reads data until
* no more is available or the buffer has been filled
*
* returns number of bytes read
*
*/
int SIMCOM900::read(char* result, int resultlength)
{
char temp;
int i=0;
#ifdef DEBUG_ON
Serial.print(F("Starting read..\nWaiting for Data.."));
#endif
// Wait until we start receiving data
while(gsm.available()<1) {
delay(100);
#ifdef DEBUG_ON
Serial.print(F("."));
#endif
}
while(gsm.available()>0 && i<(resultlength-1)) {
temp=_cell.read();
if(temp>0) {
#ifdef DEBUG_ON
Serial.print(temp);
#endif
result[i]=temp;
i++;
}
delay(1);
}
// Terminate the string
result[resultlength-1]='\0';
#ifdef DEBUG_ON
Serial.println(F("\nDone.."));
#endif
return i;
}
int SIMCOM900::readCellData(int &mcc, int &mnc, long &lac, long &cellid)
{
if (getStatus()==IDLE)
return 0;
//_tf.setTimeout(_GSM_DATA_TOUT_);
48
//_cell.flush();
SimpleWriteln(F("AT+QENG=1,0"));
SimpleWriteln(F("AT+QENG?"));
if(gsm.WaitResp(5000, 50, "+QENG")!=RX_FINISHED_STR_NOT_RECV)
return 0;
//mcc=_tf.getValue(); // The first one is 0
mcc=_cell.read();
//mcc=_tf.getValue();
mcc=_cell.read();
//mnc=_tf.getValue();
mnc=_cell.read();
//lac=_tf.getValue();
lac=_cell.read();
//cellid=_tf.getValue();
cellid=_cell.read();
gsm.WaitResp(5000, 50, "+OK");
SimpleWriteln(F("AT+QENG=1,0"));
gsm.WaitResp(5000, 50, "+OK");
return 1;
}
boolean SIMCOM900::readSMS(char* msg, int msglength, char* number, int nlength)
{
Serial.println(F("This method is deprecated! Please use GetSMS in the SMS class."));
long index;
char *p_char;
char *p_char1;
/*
if (getStatus()==IDLE)
return false;
*/
#ifdef UNO
_tf.setTimeout(_GSM_DATA_TOUT_);
#endif
//_cell.flush();
WaitResp(500, 500);
SimpleWriteln(F("AT+CMGL=\"REC UNREAD\",1"));
WaitResp(5000, 500);
if(gsm.IsStringReceived("+CMGL")) {
//index
p_char = strchr((char *)(gsm.comm_buf),'+CMGL');
p_char1 = p_char+3; //we are on the first char of string
p_char = p_char1+1;
*p_char = 0;
index=atoi(p_char1);
49
p_char1 = p_char+1;
p_char = strstr((char *)(p_char1), "\",\"");
p_char1 = p_char+3;
p_char = strstr((char *)(p_char1), "\",\"");
if (p_char != NULL) {
*p_char = 0;
}
strcpy(number, (char *)(p_char1));
//////
p_char1 = p_char+3;
p_char = strstr((char *)(p_char1), "\",\"");
p_char1 = p_char+3;
p_char = strstr((char *)(p_char1), "\n");
p_char1 = p_char+1;
p_char = strstr((char *)(p_char1), "\n");
if (p_char != NULL) {
*p_char = 0;
}
strcpy(msg, (char *)(p_char1));
// #ifdef UNO
// index=_tf.getValue();
// #endif
// #ifdef MEGA
//index=_cell.read();
// #endif
// Serial.println("DEBUG");
// #ifdef UNO
// _tf.getString("\",\"", "\"", number, nlength);
// #endif
// Serial.println("PRIMA");
// #ifdef MEGA
// _cell.getString("\",\"", "\"", number, nlength);
// #endif
// Serial.println("DEBUG");
// #ifdef UNO
// _tf.getString("\n", "\nOK", msg, msglength);
// #endif
// #ifdef MEGA
// _cell.getString("\n", "\nOK", msg, msglength);
// #endif
SimpleWrite(F("AT+CMGD="));
SimpleWriteln(index);
// Serial.print("VAL= ");
// Serial.println(index);
gsm.WaitResp(5000, 50, str_ok);
return true;
};
50
return false;
};
boolean SIMCOM900::readCall(char* number, int nlength)
{
int index;
if (getStatus()==IDLE)
return false;
//_tf.setTimeout(_GSM_DATA_TOUT_);
if(gsm.WaitResp(5000, 50, "+CLIP: \"")!=RX_FINISHED_STR_RECV)
//if(_tf.find("+CLIP: \""))
{
#ifdef UNO
_tf.getString("", "\"", number, nlength);
#endif
#ifdef MEGA
_cell.getString("", "\"", number, nlength);
#endif
SimpleWriteln(F("ATH"));
delay(1000);
//_cell.flush();
return true;
};
return false;
};
boolean SIMCOM900::call(char* number, unsigned int milliseconds)
{
if (getStatus()==IDLE)
return false;
//_tf.setTimeout(_GSM_DATA_TOUT_);
SimpleWrite(F("ATD"));
SimpleWrite(number);
SimpleWriteln(F(";"));
delay(milliseconds);
SimpleWriteln(F("ATH"));
return true;
}
int SIMCOM900::setPIN(char *pin)
{
//Status = READY or ATTACHED.
if((getStatus() != IDLE))
return 2;
51
//_tf.setTimeout(_GSM_DATA_TOUT_); //Timeout for expecting modem responses.
//_cell.flush();
//AT command to set PIN.
SimpleWrite(F("AT+CPIN="));
SimpleWriteln(pin);
//Expect str_ok.
if(gsm.WaitResp(5000, 50, str_ok)!=RX_FINISHED_STR_NOT_RECV)
return 0;
else
return 1;
}
int SIMCOM900::changeNSIPmode(char mode)
{
//_tf.setTimeout(_TCP_CONNECTION_TOUT_);
//if (getStatus()!=ATTACHED)
// return 0;
//_cell.flush();
SimpleWrite(F("AT+QIDNSIP="));
SimpleWriteln(mode);
if(gsm.WaitResp(5000, 50, str_ok)!=RX_FINISHED_STR_NOT_RECV) return 0;
//if(!_tf.find(str_ok)) return 0;
return 1;
}
int SIMCOM900::getCCI(char *cci)
{
//Status must be READY
if((getStatus() != READY))
return 2;
//_tf.setTimeout(_GSM_DATA_TOUT_); //Timeout for expecting modem responses.
//_cell.flush();
//AT command to get CCID.
SimpleWriteln(F("AT+QCCID"));
//Read response from modem
#ifdef UNO
_tf.getString("AT+QCCID\r\r\r\n","\r\n",cci, 21);
#endif
#ifdef MEGA
52
_cell.getString("AT+QCCID\r\r\r\n","\r\n",cci, 21);
#endif
//Expect str_ok.
if(gsm.WaitResp(5000, 50, str_ok)!=RX_FINISHED_STR_NOT_RECV)
return 0;
else
return 1;
}
int SIMCOM900::getIMEI(char *imei)
{
//_tf.setTimeout(_GSM_DATA_TOUT_); //Timeout for expecting modem responses.
//_cell.flush();
//AT command to get IMEI.
SimpleWriteln(F("AT+GSN"));
//Read response from modem
#ifdef UNO
_tf.getString("\r\n","\r\n",imei, 16);
#endif
#ifdef MEGA
_cell.getString("\r\n","\r\n",imei, 16);
#endif
//Expect str_ok.
if(gsm.WaitResp(5000, 50, str_ok)!=RX_FINISHED_STR_NOT_RECV)
return 0;
else
return 1;
}
int SIMCOM900::available()
{
return _cell.available();
}
uint8_t SIMCOM900::read()
{
return _cell.read();
}
void SIMCOM900::SimpleRead()
{
char datain;
if(_cell.available()>0) {
datain=_cell.read();
if(datain>0) {
53
Serial.print(datain);
}
}
}
void SIMCOM900::SimpleWrite(char *comm)
{
_cell.print(comm);
}
void SIMCOM900::SimpleWrite(const char *comm)
{
_cell.print(comm);
}
void SIMCOM900::SimpleWrite(int comm)
{
_cell.print(comm);
}
void SIMCOM900::SimpleWrite(const __FlashStringHelper *pgmstr)
{
_cell.print(pgmstr);
}
void SIMCOM900::SimpleWriteln(char *comm)
{
_cell.println(comm);
}
void SIMCOM900::SimpleWriteln(const __FlashStringHelper *pgmstr)
{
_cell.println(pgmstr);
}
void SIMCOM900::SimpleWriteln(char const *comm)
{
_cell.println(comm);
}
void SIMCOM900::SimpleWriteln(int comm)
{
_cell.println(comm);
}
void SIMCOM900::WhileSimpleRead()
{
char datain;
while(_cell.available()>0) {
datain=_cell.read();
if(datain>0) {
54
Serial.print(datain);
}
}
}
//--------------------------------------------/**********************************************************
Turns on/off the speaker
off_on: 0 - off
1 - on
**********************************************************/
void GSM::SetSpeaker(byte off_on)
{
if (CLS_FREE != GetCommLineStatus()) return;
SetCommLineStatus(CLS_ATCMD);
if (off_on) {
//SendATCmdWaitResp("AT#GPIO=5,1,2", 500, 50, "#GPIO:", 1);
} else {
//SendATCmdWaitResp("AT#GPIO=5,0,2", 500, 50, "#GPIO:", 1);
}
SetCommLineStatus(CLS_FREE);
}
byte GSM::IsRegistered(void)
{
return (module_status & STATUS_REGISTERED);
}
byte GSM::IsInitialized(void)
{
return (module_status & STATUS_INITIALIZED);
}
/**********************************************************
Method checks if the GSM module is registered in the GSM net
- this method communicates directly with the GSM module
in contrast to the method IsRegistered() which reads the
flag from the module_status (this flag is set inside this method)
- must be called regularly - from 1sec. to cca. 10 sec.
return values:
REG_NOT_REGISTERED - not registered
REG_REGISTERED
- GSM module is registered
REG_NO_RESPONSE - GSM doesn't response
REG_COMM_LINE_BUSY - comm line between GSM module and Arduino is not free
for communication
**********************************************************/
55
byte GSM::CheckRegistration(void)
{
byte status;
byte ret_val = REG_NOT_REGISTERED;
if (CLS_FREE != GetCommLineStatus()) return (REG_COMM_LINE_BUSY);
SetCommLineStatus(CLS_ATCMD);
_cell.println(F("AT+CREG?"));
// 5 sec. for initial comm tmout
// 50 msec. for inter character timeout
status = WaitResp(5000, 50);
if (status == RX_FINISHED) {
// something was received but what was received?
// --------------------------------------------if(IsStringReceived("+CREG: 0,1")
|| IsStringReceived("+CREG: 0,5")) {
// it means module is registered
// ---------------------------module_status |= STATUS_REGISTERED;
return (ret_val);
}
56
/**********************************************************
Method sets speaker volume
speaker_volume: volume in range 0..14
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module did not answer in timeout
-3 - GSM module has answered "ERROR" string
OK ret val:
----------0..14 current speaker volume
**********************************************************/
/*
char GSM::SetSpeakerVolume(byte speaker_volume)
{
char ret_val = -1;
if (CLS_FREE != GetCommLineStatus()) return (ret_val);
SetCommLineStatus(CLS_ATCMD);
// remember set value as last value
if (speaker_volume > 14) speaker_volume = 14;
// select speaker volume (0 to 14)
// AT+CLVL=X<CR> X<0..14>
_cell.print("AT+CLVL=");
_cell.print((int)speaker_volume);
_cell.print("\r"); // send <CR>
// 10 sec. for initial comm tmout
// 50 msec. for inter character timeout
if (RX_TMOUT_ERR == WaitResp(10000, 50)) {
ret_val = -2; // ERROR
}
else {
if(IsStringReceived(str_ok)) {
last_speaker_volume = speaker_volume;
ret_val = last_speaker_volume; // OK
}
else ret_val = -3; // ERROR
}
SetCommLineStatus(CLS_FREE);
return (ret_val);
}
*/
/**********************************************************
Method increases speaker volume
57
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module did not answer in timeout
-3 - GSM module has answered "ERROR" string
OK ret val:
----------0..14 current speaker volume
**********************************************************/
/*
char GSM::IncSpeakerVolume(void)
{
char ret_val;
byte current_speaker_value;
current_speaker_value = last_speaker_volume;
if (current_speaker_value < 14) {
current_speaker_value++;
ret_val = SetSpeakerVolume(current_speaker_value);
}
else ret_val = 14;
return (ret_val);
}
*/
/**********************************************************
Method decreases speaker volume
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module did not answer in timeout
-3 - GSM module has answered "ERROR" string
OK ret val:
----------0..14 current speaker volume
**********************************************************/
/*
char GSM::DecSpeakerVolume(void)
{
char ret_val;
byte current_speaker_value;
current_speaker_value = last_speaker_volume;
if (current_speaker_value > 0) {
current_speaker_value--;
ret_val = SetSpeakerVolume(current_speaker_value);
58
}
else ret_val = 0;
return (ret_val);
}
*/
/**********************************************************
Method sends DTMF signal
This function only works when call is in progress
dtmf_tone: tone to send 0..15
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module didn't answer in timeout
-3 - GSM module has answered "ERROR" string
OK ret val:
----------0.. tone
**********************************************************/
/*
char GSM::SendDTMFSignal(byte dtmf_tone)
{
char ret_val = -1;
if (CLS_FREE != GetCommLineStatus()) return (ret_val);
SetCommLineStatus(CLS_ATCMD);
// e.g. AT+VTS=5<CR>
_cell.print("AT+VTS=");
_cell.print((int)dtmf_tone);
_cell.print("\r");
// 1 sec. for initial comm tmout
// 50 msec. for inter character timeout
if (RX_TMOUT_ERR == WaitResp(1000, 50)) {
ret_val = -2; // ERROR
}
else {
if(IsStringReceived(str_ok)) {
ret_val = dtmf_tone; // OK
}
else ret_val = -3; // ERROR
}
SetCommLineStatus(CLS_FREE);
return (ret_val);
}
*/
59
/**********************************************************
Method returns state of user button
/**********************************************************
Method reads phone number string from specified SIM position
position:
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module didn't answer in timeout
-3 - position must be > 0
phone_number is empty string
OK ret val:
----------0 - there is no phone number on the position
1 - phone number was found
phone_number is filled by the phone number string finished by 0x00
so it is necessary to define string with at least
15 bytes(including also 0x00 termination character)
an example of usage:
GSM gsm;
char phone_num[20]; // array for the phone number string
if (1 == gsm.GetPhoneNumber(1, phone_num)) {
// valid phone number on SIM pos. #1
60
// phone number string is copied to the phone_num array
#ifdef DEBUG_PRINT
gsm.DebugPrint("DEBUG phone number: ", 0);
gsm.DebugPrint(phone_num, 1);
#endif
}
else {
// there is not valid phone number on the SIM pos.#1
#ifdef DEBUG_PRINT
gsm.DebugPrint("DEBUG there is no phone number", 1);
#endif
}
**********************************************************/
61
p_char++;
// we are on the first phone number character
// find out '"' as finish character of phone number string
p_char1 = strchr((char *)(p_char),'"');
if (p_char1 != NULL) {
*p_char1 = 0; // end of string
}
// extract phone number string
strcpy(phone_number, (char *)(p_char));
// output value = we have found out phone number string
ret_val = 1;
}
break;
case RX_FINISHED_STR_NOT_RECV:
// only OK or ERROR => no phone number
ret_val = 0;
break;
}
SetCommLineStatus(CLS_FREE);
return (ret_val);
}
/**********************************************************
Method writes phone number string to the specified SIM position
position: SMS position <1..20>
phone_number: phone number string for the writing
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module didn't answer in timeout
-3 - position must be > 0
OK ret val:
----------0 - phone number was not written
1 - phone number was written
**********************************************************/
char GSM::WritePhoneNumber(byte position, char *phone_number)
{
char ret_val = -1;
if (position == 0) return (-3);
if (CLS_FREE != GetCommLineStatus()) return (ret_val);
SetCommLineStatus(CLS_ATCMD);
ret_val = 0; // phone number was not written yet
//send: AT+CPBW=XY,"00420123456789"
62
// where XY = position,
//
"00420123456789" = phone number string
_cell.print(F("AT+CPBW="));
_cell.print((int)position);
_cell.print(F(",\""));
_cell.print(phone_number);
_cell.print(F("\"\r"));
// 5000 msec. for initial comm tmout
// 50 msec. for inter character timeout
switch (WaitResp(5000, 50, str_ok)) {
case RX_TMOUT_ERR:
// response was not received in specific time
break;
case RX_FINISHED_STR_RECV:
// response is OK = has been written
ret_val = 1;
break;
case RX_FINISHED_STR_NOT_RECV:
// other response: e.g. ERROR
break;
}
SetCommLineStatus(CLS_FREE);
return (ret_val);
}
/**********************************************************
Method del phone number from the specified SIM position
position:
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module didn't answer in timeout
-3 - position must be > 0
OK ret val:
----------0 - phone number was not deleted
1 - phone number was deleted
**********************************************************/
char GSM::DelPhoneNumber(byte position)
{
char ret_val = -1;
63
if (position == 0) return (-3);
if (CLS_FREE != GetCommLineStatus()) return (ret_val);
SetCommLineStatus(CLS_ATCMD);
ret_val = 0; // phone number was not written yet
//send: AT+CPBW=XY
// where XY = position
_cell.print(F("AT+CPBW="));
_cell.print((int)position);
_cell.print(F("\r"));
// 5000 msec. for initial comm tmout
// 50 msec. for inter character timeout
switch (WaitResp(5000, 50, str_ok)) {
case RX_TMOUT_ERR:
// response was not received in specific time
break;
case RX_FINISHED_STR_RECV:
// response is OK = has been written
ret_val = 1;
break;
case RX_FINISHED_STR_NOT_RECV:
// other response: e.g. ERROR
break;
}
SetCommLineStatus(CLS_FREE);
return (ret_val);
}
/**********************************************************
Function compares specified phone number string
with phone number stored at the specified SIM position
position:
SMS position <1..20>
phone_number: phone number string which should be compare
return:
ERROR ret. val:
---------------1 - comm. line to the GSM module is not free
-2 - GSM module didn't answer in timeout
-3 - position must be > 0
OK ret val:
64
----------0 - phone numbers are different
1 - phone numbers are the same
an example of usage:
if (1 == gsm.ComparePhoneNumber(1, "123456789")) {
// the phone num. "123456789" is stored on the SIM pos. #1
// phone number string is copied to the phone_num array
#ifdef DEBUG_PRINT
gsm.DebugPrint("DEBUG phone numbers are the same", 1);
#endif
}
else {
#ifdef DEBUG_PRINT
gsm.DebugPrint("DEBUG phone numbers are different", 1);
#endif
}
**********************************************************/
char GSM::ComparePhoneNumber(byte position, char *phone_number)
{
char ret_val = -1;
char sim_phone_number[20];
==============================BIBLIOTECA SERIAL
GSM=======================================================================
==
65
// SerialGSM version 1.1
// by Meir Michanie
// meirm@riunx.com
// error codes
// http://www.developershome.com/sms/resultCodes2.asp
#include <SerialGSM.h>
SerialGSM::SerialGSM(int rxpin,int txpin):
SoftwareSerial(rxpin,txpin)
{
verbose=false;
}
void SerialGSM::FwdSMS2Serial(){
Serial.println("AT+CMGF=1"); // set SMS mode to text
this->println("AT+CMGF=1"); // set SMS mode to text
delay(200);
this->ReadLine();
Serial.println("AT+CNMI=3,3,0,0"); // set module to send SMS data to serial out upon receipt
this->println("AT+CNMI=3,3,0,0"); // set module to send SMS data to serial out upon receipt
delay(200);
this->ReadLine();
}
void SerialGSM::SendSMS(char * cellnumber,char * outmsg){
this->Rcpt(cellnumber);
if (verbose) Serial.println(rcpt);
this->StartSMS();
this->Message(outmsg);
Serial.print(outmessage);
this->print(outmessage);
this->EndSMS();
delay(500);
this->ReadLine();
}
void SerialGSM::SendSMS(){
if (verbose) Serial.println(rcpt);
if (verbose) Serial.println(outmessage);
this->StartSMS();
Serial.print(outmessage);
this->print(outmessage);
this->EndSMS();
delay(500);
this->ReadLine();
}
66
void SerialGSM::DeleteAllSMS(){
Serial.println("AT+CMGD=1,4"); // delete all SMS
this->println("AT+CMGD=1,4"); // delete all SMS
delay(200);
this->ReadLine();
}
void SerialGSM::Reset(){
Serial.println("AT+CFUN=1,1"); // Reset Modem
this->println("AT+CFUN=1,1"); // Reset Modem
delay(200);
this->ReadLine();
}
void SerialGSM::EndSMS(){
this->print(char(26)); // ASCII equivalent of Ctrl-Z
Serial.println();
//delay(5 * 1000); // the SMS module needs time to return to OK status
}
void SerialGSM::StartSMS(){
Serial.println("AT+CMGF=1"); // set SMS mode to text
this->println("AT+CMGF=1"); // set SMS mode to text
delay(200);
this->ReadLine();
Serial.print("AT+CMGS=");
this->print("AT+CMGS=");
this->print(char(34)); // ASCII equivalent of "
Serial.print(rcpt);
this->print(rcpt);
this->println(char(34)); // ASCII equivalent of "
delay(500); // give the module some thinking time
this->ReadLine();
}
int SerialGSM::ReadLine(){
static int pos=0;
char nc;
while (this->available()){
nc=this->read();
if (nc == '\n' or (pos > MAXMSGLEN) or ((millis()> lastrec + SERIALTIMEOUT)and (pos > 0)) ){
67
nc='\0';
lastrec=millis();
inmessage[pos]=nc;
pos=0;
if (verbose) Serial.println(inmessage);
return 1;
}
else if (nc=='\r') {
}
else{
inmessage[pos++]=nc;
lastrec=millis();
}
}
return 0;
}
int SerialGSM::ReceiveSMS(){
static boolean insms=0;
if (this->ReadLine()){
// Get the number of the sms sender in order to be able to reply
if ( strstr(inmessage, "CMT: ") != NULL ){
insms=1;
int sf=6;
if(strstr(inmessage, "+CMT:")) sf++;
for (int i=0;i < PHONESIZE-1;i++){
sendernumber[i]=inmessage[sf+i];
}
sendernumber[PHONESIZE]='\0';
return 0;
}else{
if(insms) {
insms=0;
return 1;
}
}
}
return 0;
}
boolean SerialGSM::Verbose(){
return verbose;
}
void SerialGSM::Verbose(boolean var1){
verbose=var1;
}
char * SerialGSM::Sender(){
68
return sendernumber;
}
char * SerialGSM::Rcpt(){
return rcpt;
}
char * SerialGSM::Message(){
return inmessage;
}
============================================LOGICA
UTILIZADA================================================================
#include "SIM900.h"
#include <SoftwareSerial.h>
#include "sms.h"
SMSGSM sms;
69
char number[]="998919094";
char message[180];
char pos;
char *p;
void setup()
{
Serial.begin(9600);
if (gsm.begin(2400))
Serial.println("\nstatus=READY");
else Serial.println("\nstatus=IDLE");
};
void loop()
{
pos=sms.IsSMSPresent(SMS_UNREAD);
Serial.println((int)pos);
if((int)pos>0&&(int)pos<=20){
Serial.print("NOVA MENSSAGEM, POS=");
Serial.println((int)pos);
message[0]='\0';
sms.GetSMS((int)pos,number,message,180);
p=strstr(message,"testpwd");
if(p){
Serial.println("PSWD OK");
p=strstr(message,"ABRIR");
if(p){
Serial.println("LED ON");
70
digitalWrite(13,HIGH);
delay(900);
digitalWrite(13,LOW);
}
else{
p=strstr(message,"FECHAR");
if(p){
Serial.println("LED OFF");
digitalWrite(12, HIGH);
delay(900);
digitalWrite(12, LOW);
}
}
}
sms.DeleteSMS((int)pos);
}
delay(5000);
};
71