Como sei como fazer isso? Podes ser mais explicito sff.
Posso te dar mais dados, precisas dos dados da bateria do telemovel? do carregador?
/***********************************************************
* SMS Alarm
This Software uses Arduino connected to a mobile phone(SIEMENS C75)
and it sends a SMS when a certain amount of light is off (LDR) and it sends
another (SMS) after light values are restored.
Copyright (C) 2012 Carlos Oliveira
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*
***********************************************************/
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
A2 -Analog input A2 (Light Sensor LDR)
2 -RX (phone) 2
3 -TX (phone) 3
*/
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
/***********************************************************
* PDU encoder setup
* Copyright (C) 2010 Daniel Richman
***********************************************************/
/* From hexdump.h ALIEN Project Daniel Richman */
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
/* To select the 4 bits we do this */
#define first_four(byte) (0x0F & (byte))
/* Last four: Shift left to get to a number < 16 */
#define last_four(byte) ((0xF0 & (byte)) >> 4)
/* The MSB goes first. */
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
/*
*/
//**********************************************************
// End of PDU encoder setup
//init
SoftwareSerial phone=SoftwareSerial(rxPin, txPin);
int ledPin = 13; //Used for DEBUG
int sensorPin = A2;
int sensorValue = 0;
int estado=0;
//estado=3 for testing serial communication with mobile
boolean flagLUZoff=false;
boolean flagSMS=false;
/***********************************************************
* Setup *
***********************************************************/
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(9600); // DEBUG
while (!Serial) {;
// wait for serial port toconnect.Needed for Leonardo only
}
//C75 init ----------------------------------------------
pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);
phone.begin(9600);
}
/***********************************************************
* LOOP *
***********************************************************/
void loop() // run over and over
{
automatoMain();
}
/***********************************************************
* Automato *
***********************************************************/
void automatoMain() {
switch(estado) {
case 0://check light value
digitalWrite(ledPin, HIGH);
delay(1000);
sensorValue = analogRead(sensorPin);
digitalWrite(ledPin, LOW);
delay(1000);
if (sensorValue < 900){
flagLUZoff=true;
estado=1;
}
else{
flagLUZoff=false;
estado=2;
}
break;
case 1:// SMS send Light OFF
delay(1000);
if(flagLUZoff && !flagSMS){
Serial.println("Sending SMS light is OFF"); // DEBUG
send_sms("351969999999","Light is OFF!");
flagSMS=true;
}
delay(1000);
estado=0;
break;
case 2:// SMS send Light ON
if(!flagLUZoff && flagSMS){
Serial.println("Sending SMS light is ON"); // DEBUG
send_sms("351969999999","Light is ON!");
flagSMS=false;
}
delay(1000);
estado=0;
break;
case 3://Phone communication tests (via Serial COM)
if (phone.available())
Serial.write(phone.read());
if (Serial.available())
phone.write(Serial.read());
break;
default:
break;
}
}
/***********************************************************
* SMS PDU encript
This part of the code is not written by me, nevertheless I had to
change some parts (documented) in order to work correctly under
Arduino V1.0. And also I added a converter function for the phone
number, but only works for phone number with 12 digits.
code was taken from Tim Zaman site:
([url=http://www.timzaman.nl/?p=47&lang=en]http://www.timzaman.nl/?p=47&lang=en[/url])
**********************************************************
Copyright (C) 2010 Daniel Richman (/Timbobel) (/Oliveira)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
For a full copy of the GNU General Public License,
see . <http://www.gnu.org/licenses/>.
*
***********************************************************/
void hexdump_byte(unsigned char byte)
{
phone.write(hexdump_a(byte));
phone.write(hexdump_b(byte));
}
/***********************************************************
* convert Phone (C.Oliveira) *
*this only works if your phone number has 12 digits, if not*
*use the old conversion method *
***********************************************************/
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
phone.write(pho[y+1]);
phone.write(pho[y]);
}
}
//**********************************************************
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
phone.println("AT+CMGF=0");
delay(1500);
phone.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
phone.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
/* Phone number is hardcoded if digits diferent from 12
[url=http://twit88.com/home/utility/sms-pdu-encode-decode]http://twit88.com/home/utility/sms-pdu-encode-decode[/url]
use the utility to convert into pdu format, just fullfil
the receiver number and press convert button.
Hexadecimal PDU Message
below the example for: 351987654321
output:
AT+CMGW=14 <--- size of, use above
0011000C915391785634120000AA
*/
// phone.print("0011000C915391785634120000AA"); // mobile: 351987654321 OLD METHOD for phones with digits !=12
phone.print("0011000C91"); // using the convertPhone function , for phones # with digits =12
convertPhone(recPhone);
phone.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
phone.write(0x1A); // Ctrl+Z
phone.write(0x0D); // CR
phone.write(0x0A); // LF
delay(5000);
}AT
OK
AT+CMGF?
+CMGF: 0
OK
AT+CMGF=1
ERROR
/***********************************************************
* SMS Alarm
This Software uses Arduino connected to a mobile phone(SIEMENS C75)
and it sends a SMS when a certain amount of light is off (LDR) and it sends
another (SMS) after light values are restored.
Copyright (C) 2012 Carlos Oliveira
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*
***********************************************************/
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
A2 -Analog input A2 (Light Sensor LDR)
2 -RX (phone) 2
3 -TX (phone) 3
*/
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
/***********************************************************
* PDU encoder setup
* Copyright (C) 2010 Daniel Richman (more in the function)
***********************************************************/
/* From hexdump.h ALIEN Project Daniel Richman */
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
/* To select the 4 bits we do this */
#define first_four(byte) (0x0F & (byte))
/* Last four: Shift left to get to a number < 16 */
#define last_four(byte) ((0xF0 & (byte)) >> 4)
/* The MSB goes first. */
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
/*
*/
//**********************************************************
// End of PDU encoder setup
//init
SoftwareSerial phone=SoftwareSerial(rxPin, txPin);
int ledPin = 13; //Used for DEBUG
int sensorPin = A2;
int sensorValue = 0;
int estado=3;
//estado=3 for testing serial communication with mobile;
boolean flagLUZoff=false;
boolean flagSMS=false;
/***********************************************************
* Setup *
***********************************************************/
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(9600); // DEBUG
while (!Serial) {;
// wait for serial port toconnect.Needed for Leonardo only
}
//C75 init ----------------------------------------------
pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);
phone.begin(9600);
}
/***********************************************************
* LOOP *
***********************************************************/
void loop() // run over and over
{
automatoMain();
}
/***********************************************************
* Automato *
***********************************************************/
void automatoMain() {
switch(estado) {
case 0://check light value
digitalWrite(ledPin, HIGH);
delay(1000);
sensorValue = analogRead(sensorPin);
digitalWrite(ledPin, LOW);
delay(1000);
if (sensorValue < 900){
flagLUZoff=true;
estado=1;
}
else{
flagLUZoff=false;
estado=2;
}
break;
case 1:// SMS send Light OFF
delay(1000);
if(flagLUZoff && !flagSMS){
Serial.println("Sending SMS light is OFF"); // DEBUG
send_sms("351964002176","Light is OFF!");
flagSMS=true;
}
delay(1000);
estado=0;
break;
case 2:// SMS send Light ON
if(!flagLUZoff && flagSMS){
Serial.println("Sending SMS light is ON"); // DEBUG
send_sms("351969999999","Light is ON!");
flagSMS=false;
}
delay(1000);
estado=0;
break;
case 3://Phone communication tests (via Serial COM)
if (phone.available())
Serial.write(phone.read());
if (Serial.available())
phone.write(Serial.read());
break;
default:
break;
}
}
/***********************************************************
* SMS PDU encript
This part of the code is not written by me, nevertheless I had to
change some parts (documented) in order to work correctly under
Arduino V1.0. And also I added a converter function for the phone
number, but only works for phone number with 12 digits.
code was taken from Tim Zaman site:
(http://www.timzaman.nl/?p=47&lang=en)
**********************************************************
Copyright (C) 2010 Daniel Richman (/Timbobel) (/Oliveira)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
For a full copy of the GNU General Public License,
see . <http://www.gnu.org/licenses/>.
*
***********************************************************/
void hexdump_byte(unsigned char byte)
{
phone.write(hexdump_a(byte));
phone.write(hexdump_b(byte));
}
/***********************************************************
* convert Phone (C.Oliveira) *
*this only works if your phone number has 12 digits, if not*
*use the old conversion method *
***********************************************************/
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
phone.write(pho[y+1]);
phone.write(pho[y]);
}
}
//**********************************************************
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
phone.println("AT+CMGF=0");
delay(1500);
phone.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
phone.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
/* Phone number is hardcoded if digits diferent from 12
http://twit88.com/home/utility/sms-pdu-encode-decode
use the utility to convert into pdu format, just fullfil
the receiver number and press convert button.
Hexadecimal PDU Message
below the example for: 351987654321
output:
AT+CMGW=14 <--- size of, use above
0011000C915391785634120000AA
*/
// phone.print("0011000C915391785634120000AA"); // mobile: 351987654321 OLD METHOD for phones with digits !=12
phone.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
phone.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
phone.write(0x1A); // Ctrl+Z
phone.write(0x0D); // CR
phone.write(0x0A); // LF
delay(5000);
}
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
2 -RX (phone) 2
3 -TX (phone) 3
*/
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
#define ledPin 13 //Used for DEBUG
SoftwareSerial phone = SoftwareSerial(rxPin, txPin);
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(9600); // DEBUG
while (!Serial) {;
// wait for serial port to connect.Needed for Leonardo only
}
pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);
phone.begin(9600);
}
void loop() // run over and over
{
if (phone.available()) Serial.write(phone.read());
if (Serial.available()) phone.write(Serial.read());
}
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
A2 -Analog input A2 (Light Sensor LDR)
2 -RX (phone) 2
3 -TX (phone) 3
*/
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
Para fazer esses testes basta este código:Código: [Seleccione]/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(9600); // DEBUG
Serial3.begin(9600);
}
void loop() // run over and over
{
if (Serial3.available()) Serial.write(Serial3.read());
if (Serial.available()) Serial3.write(Serial.read());
}
Mas não vai fazer diferença. Acho que o problema não está no código e sim no hardware.
#include <NewSoftSerial.h>
const int PIN_RX = 9;
const int PIN_TX =10;
NewSoftSerial com(PIN_RX, PIN_TX);
void setup() {
[b]com.begin(19200);[/b]
delay(3000);
com.println("ATD12045");
}
void loop() {
}/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(9600); // DEBUG
Serial3.begin(9600);
}
void loop() // run over and over
{
if (Serial3.available()) Serial.write(Serial3.read());
if (Serial.available()) Serial3.write(Serial.read());
}
esqueci me de dizer no video que agora, quando escrevo AT no serial monitor so o pino RX pisca laranja
Pode sempre tirar o atmega do arduino e usar o arduino como um adaptador usb-serial.Ele não consegue tirar o atmega do mega.
Não tens nenhum cabo USB-TTL para ligares directamente o PC ao telemovel e fazeres os primeiros testes com os comandos AT? Uma vez já tive que fazer o mesmo mas com um siemens c55 e comecei assim para primeiro estabelecer a ligação e ver k os comandos AT estavam a funcionar como esperado. Depois de testares assim, passas para o arduino..
Então, é meter um programa sem nada, ou seja abrir o exemplo BareMinimum, meter isso no Arduino e pode usar directamente como se um cabo usb-serial se trate.
Não tens nenhum cabo USB-TTL para ligares directamente o PC ao telemovel e fazeres os primeiros testes com os comandos AT? Uma vez já tive que fazer o mesmo mas com um siemens c55 e comecei assim para primeiro estabelecer a ligação e ver k os comandos AT estavam a funcionar como esperado. Depois de testares assim, passas para o arduino..
Infelizmente não tenho. Mas tu depois ligaste quais fios do telemovel ao arduino? so o gnd tx e rx ou mais algum? usaste alguma divisor ? diodo de zener?
Não tens nenhum cabo USB-TTL para ligares directamente o PC ao telemovel e fazeres os primeiros testes com os comandos AT? Uma vez já tive que fazer o mesmo mas com um siemens c55 e comecei assim para primeiro estabelecer a ligação e ver k os comandos AT estavam a funcionar como esperado. Depois de testares assim, passas para o arduino..
Infelizmente não tenho. Mas tu depois ligaste quais fios do telemovel ao arduino? so o gnd tx e rx ou mais algum? usaste alguma divisor ? diodo de zener?
Só liguei o GND, Rx e Tx com ligações directas para testar. Mas o cabo que usei era USB - LVTTL (3.3V)
Mas neste site que encontrei, também usaram essas resistências, para o mesmo telemóvel, e parece que resultou:
http://alumni.ipt.pt/~pmad/gsm_alarm.php (http://alumni.ipt.pt/~pmad/gsm_alarm.php)
Não tens nenhum cabo USB-TTL para ligares directamente o PC ao telemovel e fazeres os primeiros testes com os comandos AT? Uma vez já tive que fazer o mesmo mas com um siemens c55 e comecei assim para primeiro estabelecer a ligação e ver k os comandos AT estavam a funcionar como esperado. Depois de testares assim, passas para o arduino..
Infelizmente não tenho. Mas tu depois ligaste quais fios do telemovel ao arduino? so o gnd tx e rx ou mais algum? usaste alguma divisor ? diodo de zener?
Só liguei o GND, Rx e Tx com ligações directas para testar. Mas o cabo que usei era USB - LVTTL (3.3V)
Tou mesmo desconfiado que se eu ligar entre o tx do arduino e o rx do telemovel um diodo zener 3.3v que isto fica bem diferente deste divisor que eu fiz. Porque segundo as contas que aqui fizeram no inicio..
Vout = R2 / (R1+R2) * Vin
Substituindo:
3 = 18000 / (12000 + 18000) * 5
3 = 3
este divisor resitivo que fiz usa uma resistencia de 12k e de 18k...que jogam contra os 5volts do arduino dá 3volts..
e ja li aqui em mais projectos que o pessoal usou um diodo de zener 3.3v
e agora tu tambem me falaste desse valor... sera que o problema é mesmo esse????? de 3 para 3.3v faz assim tanta diferença??
Eu antes disse para ligares o tx ao rx e vice-versa, mas agora que me pus a pensar, utilizando o código em branco o correto não seria ligar o tx ao tx e o rx ao rx? Porque quando o computador envia a informação supostamente o pino que fica "activo" é o rx, portanto a informação terá de sair do rx para o rx do telemóvel e o mesmo se passa com o tx. Ou estarei errado?
Pedrorock visite onde isso do baundrate onde tava a info?Procurei "siemens c35 baudrate" no google e aparecem vários sites a falar em 19200 para o siemens c35.
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial3.available()) Serial.write(Serial3.read());
if (Serial.available()) Serial3.write(Serial.read());
}Pedro eu ontem tinha tentado o baudrate mas nao tinha dado por isso devia ser das ligacoes.. olha tentei agora outra vez so fazer AT e passado uns 10segundos diz ERROR.
Isso é bom sinal.Pedro eu ontem tinha tentado o baudrate mas nao tinha dado por isso devia ser das ligacoes.. olha tentei agora outra vez so fazer AT e passado uns 10segundos diz ERROR.Tenta em 9600 para ver o que acontece.
Sim quando ligo para o telemovel recebo RING no serial monitor
Código: [Seleccione]/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
Serial3.println("AT");
}
void loop() // run over and over
{
if (Serial3.available()) Serial.write(Serial3.read());
}
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
//Serial -------------------------------------------------
// Open serial communications and wait for port to open:
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
delay(2000);
Serial3.println("AT");
}
void loop() // run over and over
{
if (Serial3.available()) Serial.write(Serial3.read());
}/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
char info[200];
int index = 0;
char inChar;
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}Então eu vou-te enviar outro código para poderes enviar as coisas pelo serial monitor.
Aqui vai:Código: [Seleccione]/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
char info[200];
int index = 0;
char inChar;
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
Experimenta este código. Com este podes enviar os comandos pelo serial monitor. Não sei se vai funcionar porque não o testei
//GSM Remote control V 3.0
//Created by Antonis G. Kanaris, January 27, 2012.
#include <PulsesIR_Toyotomi.h>
PulsesIR_Toyotomi pulsesIR_Toyotomi(13);//Pin 13 Ir led pin
//int IRledPin=13; //IR Led pin
int indicatorPin=5; //Indicator Led pin
String readString;
String admin="xxxxxxxxxx"; //admin number pdu code example 30123456 -> 03214365
//read http://www.dreamfabric.com/sms/
char c;
void delsms(){
Serial.println("AT+CMGD=1");//Delete sms
}
void readsmsAT(){
Serial.println("AT+CMGR=1");//Read sms AT command
delay(3000);
}
void sendsms_temp(){//Return with sms temperature room degree celcius.
int temp=int(analogRead(3)*0.488);//Read temperature sensor LM35
//if (0<temp<99) { }
byte hightemp=byte(temp/10);//convert temp to pdu format
byte lowtemp=byte(temp%10);
byte lowtemp1=bitWrite(lowtemp,4,1);
byte lowtemp2=bitWrite(lowtemp1,5,1);
int lb1=bitRead(lowtemp,0);
int newhightemp=bitWrite(hightemp,7,lb1);
int newhightemp1=bitWrite(newhightemp,4,1);
int newhightemp2=bitWrite(newhightemp1,5,1);
int newlowtemp2=lowtemp2>>1;
Serial.println("AT+CMGF=0");//Start send sms with temperature to pdu format
delay(3000);
Serial.println("AT+CMGS=16");//Maybe for you is 15 or 17 read http://www.dreamfabric.com/sms/
delay(3000);
Serial.print("0011000C91xxxxxxxxxxxx10000AA02");//pdu sms temp to admin,
//read http://www.dreamfabric.com/sms/
Serial.print(newhightemp2,HEX);
Serial.print(newlowtemp2,HEX);
delay(3000);
Serial.write(26);//Ctrl-z
delay(20000);
}
void setup() {
//pinMode(IRledPin,OUTPUT);
pinMode(indicatorPin,OUTPUT);
delay(12000);//first time connect cable arduino with phone...
Serial.begin(9600);
delay(3000);
Serial.println("AT+CPMS=\"ME\",\"SM\"");//Set memory phone
delay(3000);
Serial.println("ATE=0");//Echo off
delay(3000);
}
void loop()
{
readString=0;//format readString...
readsmsAT();
// read phone reply if available
while(Serial.available() > 0)
{
c=Serial.read(),BYTE;
readString+=c;
}
delay(1000);
Serial.println(readString);//serial monitor display sms pdu format
delay(3000);
if (readString.indexOf(admin)>0 && readString.indexOf("36F770C")>0)// admin number and //pdu on1
{
//digitalWrite(indicatorPin, HIGH);//only for test
pulsesIR_Toyotomi.SendACCodeOn();//AC Toyotomi on
delay(5000);
//sendsms_temp();//send sms to admin temperature room
//digitalWrite(indicatorPin, LOW);//only for test
}
if (readString.indexOf(admin)>0 && readString.indexOf("44FA33106")>0)// admin number and //pdu OFF1
{
pulsesIR_Toyotomi.SendACCodeOff();//AC Toyotomi off
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("364791E")>0)// admin number and //pdu dry
{
pulsesIR_Toyotomi.SendACCode_modeDry();//AC Toyotomi Dry
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("4E3F79B0D")>0)// admin number and //pdu cool
{
pulsesIR_Toyotomi.SendACCode_modeCool();//AC Toyotomi cool
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("4C13AFD0D")>0)// admin number and //pdu Auto
{
pulsesIR_Toyotomi.SendACCode_modeAuto();//AC Toyotomi mode Auto
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("3C6B01B")>0)// admin number and //pdu Fan
{
pulsesIR_Toyotomi.SendACCode_modeFan();//AC Toyotomi mode Fan
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("4E872980E")>0)// admin number and //pdu heat
{
pulsesIR_Toyotomi.SendACCode_modeHeat();//AC Toyotomi Heat
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("7C6B01BC47EDF01")>0)// admin //number and pdu Fan low
{
pulsesIR_Toyotomi.SendACCode_modeFanspeedLow();//AC Toyotomi Fan speed low
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("AC6B01BD42E93D3F536")>0)// //admin number and pdu Fan medium
{
pulsesIR_Toyotomi.SendACCode_modeFanspeedMedium();//AC Toyotomi Fan speed //medium
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("8C6B01B844E9FD1")>0)// admin //number and pdu Fan high
{
pulsesIR_Toyotomi.SendACCode_modeFanspeedHigh();//AC Toyotomi Fan speed high
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("8C6B01B14AED3DF")>0)// admin //number and pdu Fan auto
{
pulsesIR_Toyotomi.SendACCode_modeFanspeedAuto();//AC Toyotomi Fan speed Auto
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("7D4721B0E9AC100")>0)// admin //number and pdu Temp 30
{
pulsesIR_Toyotomi.SendACCode_Temp_30();//AC Toyotomi Temp 30
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("7D4721B0E92D500")>0)// admin //number and pdu Temp 25
{
pulsesIR_Toyotomi.SendACCode_Temp_25();//AC Toyotomi Temp 25
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("7D4721B0E92C100")>0)// admin //number and pdu Temp 20
{
pulsesIR_Toyotomi.SendACCode_Temp_20();//AC Toyotomi Temp 20
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("7D4721B0E8AD900")>0)// admin //number and pdu Temp 16
{
pulsesIR_Toyotomi.SendACCode_Temp_16();//AC Toyotomi Temp 16
delay(3000);
}
if (readString.indexOf(admin)>0 && readString.indexOf("F4721B0E")>0)// admin number and //pdu temp
{
sendsms_temp();
delay(3000);
}
if (readString.length()>40)//delete sms if sms received
{
delsms();
}
delay(10000);//delay start loop again for check new sms...
}Já tentaste enviar uma mensagem para o telemóvel para ver o que recebes no PC?
Hmm, mas com esse telemóvel a sms tem de estar codificada em PDU? E para enviar também a tens de enviar codificada?
É suposto receberes alguma coisa.
/*
HARDWARE SETUP
13 -Led pin Debug 13 (used for status)
*/
#define ledPin 13 //Used for DEBUG
char info[200];
int index = 0;
char inChar;
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}Tenta enviar "AT+CMGR=0" ou "AT+CMGR=1". Serve para ler um determinado SMS. Vê se obtens alguma resposta.
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
int index = 0;
char inChar;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
if (String(info) == "sms") {
send_sms(numero,"teste");
} else {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Olha, experimenta isto:Alterei o código desse link. Inicializa na mesma o telemóvel pelo serial monitor. Quando estiver pronto para enviar a sms envia pelo serial monitor o texto "sms". Dentro de uns segundos deves receber uma sms. Ah, altera também o número na variável numero (não apagues o 351).
Depois diz se funcionou.
Se funcionar passamos a próxima fase.Código: [Seleccione]Olha, experimenta isto:
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
int index = 0;
char inChar;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
if (String(info) == "sms") {
send_sms(numero,"teste");
} else {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
AT+CMGL=0
Serve para ver o index das sms que ainda não leste. Experimenta e diz o que obteste.
Alterei o código desse link. Inicializa na mesma o telemóvel pelo serial monitor. Quando estiver pronto para enviar a sms envia pelo serial monitor o texto "sms". Dentro de uns segundos deves receber uma sms. Ah, altera também o número na variável numero (não apagues o 351).
Depois diz se funcionou.
Se funcionar passamos a próxima fase.Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \Olha, experimenta isto:
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
int index = 0;
char inChar;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
if (String(info) == "sms") {
send_sms(numero,"teste");
} else {
Serial3.println(String(info));
}
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
AT+CMGL=0
Serve para ver o index das sms que ainda não leste. Experimenta e diz o que obteste.
Ah, já não sabia o que fazer porque o código estava correto.
Experimenta isto e diz o que obtiveste:
AT+CMGF=0
Ups, enganei-me. Queria dizer para testares isto:
AT+CMGL=0
079153912601000004008000002180319173114097206A91598426B5DA20C8F8940641C8A734380585CF6F79185476D3E5E573B8FD9E83CA6DD0383C0F83C2F432283C07C9686810FD4D7ECF41EF39889C0ECF41E430685E6E87DD61103B7DAE9741EA3068FC6EC3E565500C044FEBF56150BB4C4E8751B4B4FB9C2A83E4E571591C06BDEB747918749687E9E939885E66CB62B9180E07C3DD00Corresponde a:
Ups, enganei-me. Queria dizer para testares isto:
AT+CMGL=0
AT+CMGL=0
+CMGL: 5,0,,146
079153912601000004008000002180319173114097206A91598426B5DA20C8F8940641C8A734380585CF6F79185476D3E5E573B8FD9E83CA6DD0383C0F83C2F432283C07C9686810FD4D7ECF41EF39889C0ECF41E430685E6E87DD61103B7DAE9741EA3068FC6EC3E565500C044FEBF56150BB4C4E8751B4B4FB9C2A83E4E571591C06BDEB747918749687E9E939885E66CB62B9180E07C3DD00
OK
Ups, enganei-me. Queria dizer para testares isto:
AT+CMGL=0
AT+CMGL=0
+CMGL: 5,0,,146
079153912601000004008000002180319173114097206A91598426B5DA20C8F8940641C8A734380585CF6F79185476D3E5E573B8FD9E83CA6DD0383C0F83C2F432283C07C9686810FD4D7ECF41EF39889C0ECF41E430685E6E87DD61103B7DAE9741EA3068FC6EC3E565500C044FEBF56150BB4C4E8751B4B4FB9C2A83E4E571591C06BDEB747918749687E9E939885E66CB62B9180E07C3DD00
OK
Ok, isso significa que a sms com index 5 está com o estado 0 (não lida) e tem 146 caracteres.
E isso que está por baixo é o código PDU da mensagem.
Experimenta outra vez o mesmo para ver se retorna alguma coisa, porque não sei se o telemóvel já classificou essa sms como lida.
Depois é ver o que retorna quando não há sms lidas e de x em x segundos por exemplo ir verificando se há sms novas. Caso haja lê-se.
Já agora, tu queres que qualquer número possa enviar a sms ou apenas o teu número?
Excelente, mas agora volta a fazer a mesma coisa, mas sem sms por ler. Para poder ver o que é que recebes se não houver sms para ler para poder programar para quando ler x acontecer y.
Sim, a ideia era essa. Mas queres que ele receba de qualquer número a sms ou só de um?
Se for só de um é muito simples, se quiseres que ele receba de mais números já é mais complicado, mas nada que não se faça.
Ok, então envia a sms com o texto que queres do teu telemóvel para o cartão do siemens e lê com o comando que te tinha dito antes.
Posta aqui os resultados.
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char info2[] = "07915391131213F4040C915391460012670000";
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0");
delay(10);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
if (String(info2).indexOf(String(info1))>0) {
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}Mas mandaste a sms? Com esse código não ves nada do que ele retorna, apenas recebes uma mensagem a dizer que o led acendeu quando ele receber a sms, experimenta.
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char info2[] = "07915391131213F4040C915391460012670000";
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info2).indexOf(String(info1))>0) {
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
} //int IRledPin=13; //IR Led pin
int indicatorPin=13; //Indicator Led pin
String readString;
String admin="xxxxxxxxxx"; //admin number pdu code example 30123456 -> 03214365
char c;
void delsms(){
Serial.println("AT+CMGD=1");//Delete sms
}
void readsmsAT(){
Serial.println("AT+CMGR=1");//Read sms AT command
delay(3000);
}
Serial.print(newhightemp2,HEX);
void setup() {
//pinMode(IRledPin,OUTPUT);
pinMode(indicatorPin,OUTPUT);
delay(12000);//first time connect cable arduino with phone...
Serial.begin(9600);
delay(3000);
Serial.println("AT+CPMS=\"ME\",\"SM\"");//Set memory phone
delay(3000);
Serial.println("ATE=0");//Echo off
delay(3000);
}
void loop()
{
readString=0;//format readString...
readsmsAT();
// read phone reply if available
while(Serial.available() > 0)
{
c=Serial.read(),BYTE;
readString+=c;
}
delay(1000);
Serial.println(readString);//serial monitor display sms pdu format
delay(3000);
if (readString.indexOf(admin)>0 && readString.indexOf("36F770C")>0)// admin number and //pdu on1
{
digitalWrite(indicatorPin, HIGH);//only for test
delay(5000);
/
}
delsms();
}
delay(10000);//delay start loop again for check new sms...
}rglove
Estive a ver o código e acho que não está bem.
É preciso enviar algum comando para iniciar o telemóvel? Ou pode-se logo enviar o comando para ler as sms?Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char info2[] = "07915391131213F4040C915391460012670000";
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info2).indexOf(String(info1))>0) {
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Experimenta. Envia o tal comando para ler a sms e vê se recebes alguma coisa no serial monitor.
É preciso enviar algum comando para iniciar o telemóvel? Ou pode-se logo enviar o comando para ler as sms?Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char info2[] = "07915391131213F4040C915391460012670000";
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(info2))>0) {
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Experimenta. Envia o tal comando para ler a sms e vê se recebes alguma coisa no serial monitor.
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //ligar luz em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999"; // por enquanto não serve para nada, todos os números são aceites
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
Serial3.println("AT+CMGL=0");
delay(10);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Ok, acho que já descobri o erro (pelo menos um deles).
Tinha trocado na função indexOf as 2 variáveis.
Fica assim então:É preciso enviar algum comando para iniciar o telemóvel? Ou pode-se logo enviar o comando para ler as sms?Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char info2[] = "07915391131213F4040C915391460012670000";
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(info2))>0) {
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Experimenta. Envia o tal comando para ler a sms e vê se recebes alguma coisa no serial monitor.
rglove
Esse ainda tem um problema.
Estás a procurar o inicio do código PDU, que tem info como numero telemovel, data, etc, mas não estás a procurar o texto em si.
Vê este aqui:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //ligar luz em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999"; // por enquanto não serve para nada, todos os números são aceites
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
Serial3.println("AT+CMGL=0");
delay(10);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(13,HIGH);
Serial.println("Led ligado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //ligar luz em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999"; // por enquanto não serve para nada, todos os números são aceites
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
Serial3.println("AT+CMGL=0");
delay(10);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(13,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada")
Serial.println("SMS Enviado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
:)
Agora é só adicionar o send_sms(numero, mensagem) abaixo do código para acender o LED e isso já fica a funcionar. Também se pode adicionar o delete.
EDIT:
Usa este código. Edita o número para o teu (mantém o 351).Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //ligar luz em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351999999999"; // por enquanto não serve para nada, todos os números são aceites
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(9600); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
Serial3.println("AT+CMGL=0");
delay(10);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(13,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada")
Serial.println("SMS Enviado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
int index = 0;
char inChar;
char numero[13] = "351964002176";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
if (String(info) == "sms") {
send_sms(numero,"teste");
} else {
Serial3.println(String(info));
}
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}O conteúdo da mensagem é "ligar luz"?
Se sim, então com esse código para comunicar através do PC, envia novamente a mensagem para o telemóvel e usa o AT+CMGL=0 para ler a mensagem e mete aqui o que recebes.
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
int index = 0;
char inChar;
char numero[13] = "351964002176";
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
if (String(info) == "sms") {
send_sms(numero,"teste");
} else {
Serial3.println(String(info));
}
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
if (Serial3.available()) Serial.write(Serial3.read());
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
} #define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Abre o Serial Monitor. Envia a SMS e vê se a luz acende. Se não, copia o que aparece no Serial Monitor.
O meu não tem a parte para reencaminhar os comandos do PC.
EDIT:
Tenta este:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \Abre o Serial Monitor. Envia a SMS e vê se a luz acende. Se não, copia o que aparece no Serial Monitor.
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
O meu não tem a parte para reencaminhar os comandos do PC.
EDIT:
Tenta este:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \Abre o Serial Monitor. Envia a SMS e vê se a luz acende. Se não, copia o que aparece no Serial Monitor.
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
delay(1000);
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
while (Serial3.available() >0) {}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
rglove, e pedrock agredeço a vossa ajuda e paciencia por hoje, mas tenho que me ir deitar, quando regressar aqui leio as vossas alteracoes, e envio para o arduino, tenho que me ir deitar se nao a mulher mete me fora de casa. muito obrigado
[quote author=rglove link=topic=5212.msg57734#msg57734 date=1344906033]
[quote author=r16 link=topic=5212.msg57732#msg57732 date=1344905184]
rglove, e pedrock agredeço a vossa ajuda e paciencia por hoje, mas tenho que me ir deitar, quando regressar aqui leio as vossas alteracoes, e envio para o arduino, tenho que me ir deitar se nao a mulher mete me fora de casa. muito obrigado
[/quote]
Amanhã é outro dia... Depois diz como correu!
[/quote]
boas pessoal, bem isto ja ta a bombar ...mas agora ta aqui uma coisa mal..
o codigo que tenho a funcionar é:
[code#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}]Substitui:
while (Serial3.available() >0) {}
Por:
while (Serial3.available() >0) {Serial3.read();}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
//send_sms(numero, "REGA LIGADA");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Basta meter um else if abaixo do if que verificava se tinha "ligar luz", mas desta vez com o "ligar rega".
Já meti o PDU para "ligar rega".
Aqui tens:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}Desculpa os posts seguidos, mas só agora é que reparei que estava a dizer mal, tens de colocar essas linhas a seguir ao if Serial3.available() <= 0 e não a seguir a if Serial3.available().
Fica assim:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Experimenta e diz se está a funcionar
91131213F4040C915391460012670000218061616AT+CMGR=1
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C9153914600126700002180616161
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616
Mensagem Apagada
+CMGR: 1,,27
07915391131213F4040C915391460012670000218061616MGR=1
Mensagem Apagada
+CMGR: 1,,27#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
delay(1000);
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Faltava aí um delay. Tenta assim:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
delay(1000);
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
OK
Mensagem Apagada
AT+CMGD=1
OK
AT+CMGR=1
+CMGR: 0,,0
OK
Mensagem Apagada
AT+CMGD=1
OK
AT+CMGR=1
+CMGR: 0,,0
OK
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
delay(1000);
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) { //Para debug - Reencaminha comandos do PC para o telemóvel
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(3);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0"); //read received unread messages
delay(1000);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0)
{ //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0)
{ //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
Serial3.println("AT+CMGD=1");
delay(1000);
while (Serial3.available() >0) {Serial3.read();}
Serial.println("Mensagem Apagada");
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Fiz umas alterações e usei outro comando, que serve para ler as mensagens novas. O outro lia a mensagem na posição 1, ou seja, a mais antiga, e por isso tinha-se que apagar sempre. Desta maneira, se resultar, é melhor.
Vê se funciona:Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) { //Para debug - Reencaminha comandos do PC para o telemóvel
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(3);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0"); //read received unread messages
delay(1000);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0)
{ //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0)
{ //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
Serial3.println("AT+CMGD=1");
delay(1000);
while (Serial3.available() >0) {Serial3.read();}
Serial.println("Mensagem Apagada");
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
m Apagada
AT+CMGL=0
OK
Mensagem Apagada
AT+CMGL=0
OK
Mensagem Apagada
AT+CMGL=0
OK
Mensagem Apagada
AT+CMGL=0
OK
Mensagem Apagada
AT+CMGL=0
OK
Mensagem Apagada
AT+CMGL=0
OK
Mensagem Apagada
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) { //Para debug - Reencaminha comandos do PC para o telemóvel
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0"); //read received unread messages
delay(1000);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(3);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0)
{ //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0)
{ //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
//Serial3.println("AT+CMGD=1");
//delay(1000);
//while (Serial3.available() >0) {Serial3.read();}
//Serial.println("Mensagem Apagada");
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Comentei a parte para apagar a mensagem. Testa e põe aqui o que aparece no serial monitor.Código: [Seleccione]#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) { //Para debug - Reencaminha comandos do PC para o telemóvel
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGL=0"); //read received unread messages
delay(1000);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(3);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0)
{ //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0)
{ //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
//Serial3.println("AT+CMGD=1");
//delay(1000);
//while (Serial3.available() >0) {Serial3.read();}
//Serial.println("Mensagem Apagada");
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
#define num_to_char(number) ((number) < 10 ? \
('0' + (number)) : \
(('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
int ledPin = 13; //Used for DEBUG
boolean flagLUZoff=false;
boolean flagSMS=false;
char info[200];
char info1[400];
char OnSMS[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
int index = 0;
char inChar;
char inChar1;
char numero[13] = "351964002176"; // por enquanto apenas serve para enviar SMS, todos os números são aceites para ligar a luz
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
}
void loop() // run over and over
{
if (Serial.available()>0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
index = 0;
memset( &info, 0, sizeof(info) );
break;
}
}
}
Serial3.println("AT+CMGR=1");
delay(100);
if (Serial3.available()>0) {
while (1) {
inChar1 = Serial3.read();
info1[index] = inChar1;
index++;
delay(2);
if (Serial3.available() <= 0) {
Serial.println(String(info1));
if (String(info1).indexOf(String(OnSMS))>0) { //Se "ligar luz"(em PDU) está na mensagem recebida, ligar LED
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
else if (String(info1).indexOf(String(ligarrega))>0) { //Se "ligar rega"(em PDU) está na mensagem recebida, ligar Led
digitalWrite(ledPin,HIGH);
Serial.println("Led ligado");
delay(1000);
send_sms(numero, "Luz ligada");
Serial.println("SMS Enviado");
Serial3.println("AT+CMGD=1");
delay(1000);
Serial.println("Mensagem Apagada");
digitalWrite(ledPin,LOW);
while (Serial3.available() >0) {Serial3.read();}
}
index = 0;
memset( &info1, 0, sizeof(info1) );
break;
}
}
}
}
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}/*Program for modem Siemens MC35i for control Digital Outputs via SMS.
Develop by Hugo Santos
e-mail: hugo.santos@i9box.
Started on 20/02/2012
*/
#include <icrmacros.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <Tone.h>
const int beep_freq[] = { 200, 400, 600, 800, 1000, 1200, 1400};
Tone beep;
SoftwareSerial pic(2, 3); //RX2 TX3
char sender_ID[14];
char corpo[4];
char incoming_modem_data[50];
char sms_array[120];
char counter[7];
boolean estado_botao = false;
boolean sendSMS = false;
char eeprom_SMS_Number[14];
char auth_SMS_Number;
//Pins Name
const short int picReset = 4;
const short int speaker = 5;
const short int pin10 = 10;
const short int pin11 = 11;
const short int pin12 = 12;
const short int pin13 = 13;
const short int pinA0 = A0;
const short int pinA1 = A1;
const short int pinA2 = A2;
const short int progPin = A3;
void setup()
{
beep.begin(speaker);
Serial.begin(9600);
pic.begin(9600);
pic.listen();
delay(7000);//Delay for modem wakeup
read_auth_SMS_Number();//To load the SMS auth number stored on the eeprom at startup
Serial.println(eeprom_SMS_Number);
//Setup Pins
pinMode(picReset,OUTPUT);
pinMode (speaker,OUTPUT);// Connected to a Speaker to beep functions
pinMode (pin10,OUTPUT);
pinMode (pin11,OUTPUT);
pinMode (pin12,OUTPUT);
pinMode (pin13,OUTPUT);
pinMode (pinA0,INPUT);
pinMode (pinA1,INPUT);
pinMode (pinA2,INPUT);
pinMode (progPin,INPUT);//Connected to a swith for PC program SMS Number
//Set pins
digitalWrite(picReset,LOW);//Used to Reset the Counter on the pic PIN RA0--Normal pulled down
digitalWrite(pin10, LOW);//Set de default status
digitalWrite(pin11, LOW);//Set de default status
digitalWrite(pin12, LOW);//Set de default status
digitalWrite(pin13, LOW);//Set de default status
digitalWrite(pinA0, LOW);//Set de default status
digitalWrite(pinA1, LOW);//Set de default status
digitalWrite(pinA2, LOW);//Set de default status
//Setup the aut_number via VB program
if( digitalRead(progPin) == 1 ){
change_auth_number();
}
//_____________________________________________
Serial.println("AT"); //Set Modem to Text Mode
delay(30);
Serial.print(0x0d,BYTE); //Give an Enter @ final of the AT Command
delay(30);
Serial.println("AT+CMGF=1");
clear_SMS_Modem_Memory(); //To prevent some seend SMS when modem was offline to became deleted
Serial.flush();//Clear the pc Buffer to remove unexpected data
}
void loop()
{
check_Incoming_SMS();
verify_Data_Received();
}
//_____________________________
void change_auth_number(){
char read_data_pc[10];
beep.play(beep_freq[4], 1000);
delay(200);
beep.play(beep_freq[1], 1000);
//Serial.println("Waiting for new SMS Number:");
while (Serial.available() <= 10);
if(Serial.read() == 83){
for(int i= 0; i<= 8;i++){
read_data_pc[i] = Serial.read();
//Serial.println(read_data_pc[i]);
EEPROM.write((i + 4),read_data_pc[i]);
}
}
EEPROM.write(0,char(43));//+
EEPROM.write(1,char(51));//3
EEPROM.write(2,(char)(53));//5
EEPROM.write(3,char(49));//1
}
//_____________________________
String read_auth_SMS_Number(){
for(int i=0;i<=12;i++){
eeprom_SMS_Number[i] = EEPROM.read(i);
}
eeprom_SMS_Number[13] = '\0';
return eeprom_SMS_Number;
}
//_____________________________
String read_pic16F887A()
{
pic.print("R");//To seend an order to pic give me back the counter number It will reply with 6 bytes
while(pic.available() < 6) {};
for (int i = 0; i < 6;){
counter[i++] = pic.read();
counter[i] = '\0';
}
return counter;
}
//_____________________________
void check_Incoming_SMS()
{
int i = 0 ;
while (Serial.available() > 0) {
incoming_modem_data[i] = Serial.read();
delay(80);//To give some conversion delay
i++;
if(i >= 49)break; //Prevents from big array error
}
}
//____________________________
void verify_Data_Received()
{
//In this function we will try to filter the array data to see if it is a real message AT+CMI or just a RING or an ERROR output from the modem pc
if(incoming_modem_data[5] == (0x54) && incoming_modem_data[6] == (0x49)){
incoming_modem_data[11]= 0x00;//For clear the array element to prevent for a loop
extract_SMS_Data();//Jump to the extract_SMS_Data function to get values
}
}
//____________________________
void extract_SMS_Data(){
Serial.print("AT+CMGR=");//Send instrution to read the SMS
delay(30);
Serial.print(incoming_modem_data[14]); //Position of the SMS Received
delay(30);
Serial.print(0x0d,BYTE);//Makes an Enter @ the end
int i=0;
while (Serial.available() > 0) {
sms_array[i] = Serial.read();
delay(80);//To give some conversion delay
//pc.println(i); //Diagnose
//pc.println(sms_array[i]);
i++;
if(i >= 98)break; //Prevents from big array error
}
//pc.println(get_SMS_ID_Sender());
//pc.println(get_corpo_sms());
get_SMS_ID_Sender();
get_corpo_sms();
clear_Received_SMS();
functions_List();
}
//________________________
String get_SMS_ID_Sender()
{
int l = 33; //Position were the array starts to get the SMS Sender ID
for (int j = 0;j<=12;j++){
sender_ID[j] = sms_array[l];
l++;
}
sender_ID[13] = '\0'; //Terminate the String element on the array
return sender_ID;
}
//________________________
String get_corpo_sms(){
int l = 73;
for( int i = 0;i<= 2; i++){
corpo[i] = sms_array[l];
l++;
}
corpo[3] = '\0'; //Para terminar a string de dados
return corpo;
}
//____________________________
void clear_Received_SMS(){
Serial.print("AT+CMGD=");
Serial.println(incoming_modem_data[14]);
delay(100);
Serial.print(0x0d,BYTE);
delay(100);
}
//________________________
void functions_List(){
//Digital outputs_________________
if (strcmp(corpo, "on1") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin10, HIGH);
delay(30);
send_SMS(String(eeprom_SMS_Number),"Saida 1 ", "Activada");
//send_SMS(String(eeprom_SMS_Number),"Contador = ",read_pic16F887A());
}
if (strcmp(corpo, "of1") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin10, LOW);
send_SMS(String(eeprom_SMS_Number),"Saida 1 ", "Desactivada");
}
if (strcmp(corpo, "on2") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin11, HIGH);
delay(30);
send_SMS(String(eeprom_SMS_Number),"Saida 2 ", "Activada");
}
if (strcmp(corpo, "of2") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin11, LOW);
send_SMS(String(eeprom_SMS_Number),"Saida 2 ", "Desactivada");
}
if (strcmp(corpo, "on3") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin12, HIGH);
delay(30);
send_SMS(String(eeprom_SMS_Number),"Saida 3 ", "Activada");
//send_SMS(String(eeprom_SMS_Number),"Contador = ",read_pic16F887A());
}
if (strcmp(corpo, "of3") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin12, LOW);
send_SMS(String(eeprom_SMS_Number),"Saida 3 ", "Desactivada");
}
if (strcmp(corpo, "on4") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin13, HIGH);
delay(30);
send_SMS(String(eeprom_SMS_Number),"Saida 4 ", "Activada");
//send_SMS(String(eeprom_SMS_Number),"Contador = ",read_pic16F887A());
}
if (strcmp(corpo, "of4") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(pin13, LOW);
send_SMS(String(eeprom_SMS_Number),"Saida 4 ", "Desactivada");
}
if (strcmp(corpo, "ctd") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
send_SMS(String(eeprom_SMS_Number),"Contador = ",read_pic16F887A());
}
if (strcmp(corpo, "rst") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
digitalWrite(picReset,HIGH);
delay(40);
digitalWrite(picReset,LOW);
send_SMS(String(eeprom_SMS_Number),"Contador ","Resetado");
}
if (strcmp(corpo, "an0") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
send_SMS(String(eeprom_SMS_Number),"Valor Analogico Entrada 0 = ",analogRead(pinA0));
}
if (strcmp(corpo, "an1") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
send_SMS(String(eeprom_SMS_Number),"Valor Analogico Entrada 1 = ",analogRead(pinA1));
}
if (strcmp(corpo, "an2") == 0 && strcmp(sender_ID, eeprom_SMS_Number) == 0) //strcmp compara a string com o valor caso seja verdadeiro devolde valor 0
{
send_SMS(String(eeprom_SMS_Number),"Valor Analogico Entrada 2 = ",analogRead(pinA2));
}
}
//_________________________________________________________________
void send_SMS(String destination, String body, String message){
Serial.println("AT+CMGF=1"); //Set the modem in SMS mode
delay(500); //Waits for 500ms important!!!
Serial.print("AT+CMGS="); //AT command for start the SMS send
Serial.print(destination);//Insert the destination number
Serial.println(); //Give a new line
delay(500); //Waits for 500ms
Serial.print(body);//Seends the pre body
Serial.print(message);//Seends the message
Serial.println(26, BYTE); //Seend a CTRL-Z for end the text insertion
}
//________________________________________________________________
void clear_SMS_Modem_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial.print("AT+CMGD=");
Serial.print(i);
Serial.println(0x0d,BYTE);
delay(100);
}
beep.play(beep_freq[0], 1000);
delay(200);
beep.play(beep_freq[2], 1000);
delay(200);
beep.play(beep_freq[4], 1000);
}
Ok. Estou a modificar o código.
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
Serial3.flush(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
Serial3.flush();
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Estive a melhorar o código e a organizá-lo. Espero que funcione... Testa-o bem e depois diz-me.
Aqui tens:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
Serial3.flush(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
Serial3.flush();
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
AT+CMGD=1
AT+CMGR=1
OK
Mensagem Apagada
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(100);
Serial3.flush(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
Serial3.flush();
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Faltava um delay:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(100);
Serial3.flush(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
Serial3.flush();
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
EDIT: Já sei porque é. Espera um pouco...
EDIT2: Acho que o problema é que estava a usar a função flush(), mas esta já não faz a mesma coisa no arduino 1.0
Aqui tens:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
OK
Mensagem Apagada
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C91539146001267000
Mensagem Apagada
AT+CMGR=1
+CMGR: 0,,0
OK
Mensagem Apagada
AT+CMGR=1
+CMGR: 0,,0
OK
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
if (index > 40) //Mensagens válidas têm mais de 40 caracteres
{
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
}
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Tenta assim:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(1000);
if (Serial3.available()>0) //Se há alguma coisa para ler...
{
int index = 0;
while (Serial3.available()>0) //Enquanto há para ler...
{
info[index] = Serial3.read(); //Ler
index++;
delay(2);
}
//Acabou de ler tudo
if (index > 40) //Mensagens válidas têm mais de 40 caracteres
{
Serial.println(String(info)); //Envia string lida para o PC
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
}
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
SMS apagados
+CMGR: 0,,28
07915391131213F4040C915391460012670000218071615232400AECF4392C07C9CB3
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071615232400AECF42CE
O
Mensagem Apagada
SMS apagados
+CMGR: 0,,28
07915391131213F4040C9153914600126700002180716103104AF2CE
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610310400AECF4392C07C9CBE730
O
TG
Rega Ligada
SMS Enviado
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610310400AECF90C3
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610
TG
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610310400AECF4392C07C9CBE73
O
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610310400AECF4392C07C9CE
O
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C9153914600126700002180716103100C97B0
O
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610OATM1
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C91539146001267000021807161031040A4C9E
O
Mensagem Apagada
+CMGR: 1,,28
07915391131213F4040C915391460012670000218071610310400AECF4392C07C9CBE7
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
}
//Passou 1s
Serial.println("Mensagem Lida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("Fim da Mensagem Lida");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}Testa este:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
}
//Passou 1s
Serial.println("Mensagem Lida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("Fim da Mensagem Lida");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Põe aqui o que aparece no Serial Monitor.
codeSMS apagados
Mensagem Lida:
OK
Fim da Mensagem Lida
Mensagem Apagada
Mensagem Lida:
AT+CMGR=1
+CMGR: 0,,0
OK
Fim da Mensagem Lida
Mensagem Apagada
Mensagem Lida:
AT+CMGR=1
+CMGR: 0,,0
OK
Fim da Mensagem Lida
Mensagem Apagada
Mensagem Lida:
AT+CMGR=1
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR: 0,,")>0 && String(info).indexOf("+CMGR: 0,,0")<0)
{
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Tinha aí informação útil. Espero que seja desta: ;DCódigo: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR: 0,,")>0 && String(info).indexOf("+CMGR: 0,,0")<0)
{
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",0")<0)
{
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Tenta assim:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",0")<0)
{
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
SMS apagados
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,24
07915391131213F4040C9153914600126700002180811034944005D4F29C2E07
OK
//Fim da Mensagem\
Mensagem Apagada
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C9153914600126700002180811044234009ECF4392C07B1EB7A
OK
//Fim da Mensagem\
Led ligado
SMS Enviado
Mensagem Apagada
SMS apagados
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,28
07915391131213F4040C915391460012670000218081108434400AECF4392C07C9CBE730
OK
//Fim da Mensagem\
Rega Ligada
SMS Enviado
Mensagem Apagada
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0)
{
//Serial.println("//Mensagem Recebida:");
//Serial.println(String(info)); //Envia string lida para o PC
//Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Usa este código e diz me o que aparece no Serial Monitor:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
int startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Mensagem Recebida:");
Serial.println(String(info)); //Envia string lida para o PC
Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0)
{
//Serial.println("//Mensagem Recebida:");
//Serial.println(String(info)); //Envia string lida para o PC
//Serial.println("//Fim da Mensagem\\");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
{ LigarLuz(); }
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
{LigarRega(); }
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Led ligado"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
SMS apagados
//Mensagem Recebida:
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C9153914600126700002180812090444009ECF4392C07B1EB7A
OK
//Fim da Mensagem\
Led ligado
SMS Enviado
Mensagem Apagada
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C9153914600126700002180812001124009ECF4392C07B1EB7A
OK
//Fim da Mensagem\
Led ligado
SMS Enviado
Mensagem Apagada
Tenta comentar os send_sms.
SMS apagados
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
Adiciona Serial.println("Loop"); no inicio do loop e vê se o loop pára mesmo.
Substitui:
int startTime = millis(); //Grava o tempo em que começou a ler
Por:
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
;)Substitui:
int startTime = millis(); //Grava o tempo em que começou a ler
Por:
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
Penso que podemos agora ir dormir :) FUNCIONA.
Sem a tua a tua ajuda, nada disto seria possivel.
Amanha irei fazer um video colocar no youtube para veres o funcionamento do mesmo ainda em breadboard.
Dizer um obrigado é pouco...
;)Substitui:
int startTime = millis(); //Grava o tempo em que começou a ler
Por:
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
Penso que podemos agora ir dormir :) FUNCIONA.
Sem a tua a tua ajuda, nada disto seria possivel.
Amanha irei fazer um video colocar no youtube para veres o funcionamento do mesmo ainda em breadboard.
Dizer um obrigado é pouco...
Boa noite então.
Ainda falta a parte para só aceitar mensagens tuas. Trato disso amanhã.
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
Serial.println("//Mensagem Recebida:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Aqui tens o código para só aceitar mensagens tuas. Vê se funciona sff.Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
Serial.println("//Mensagem Recebida:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim da Mensagem\
Ele agora só escreve quando recebe uma mensagem. Enviaste alguma?
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Recebido:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim"); //DEBUG
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
//Serial.println("//Mensagem Recebida:"); //DEBUG
//Serial.println(String(info)); //DEBUG
//Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Testa assim:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Recebido:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim"); //DEBUG
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
//Serial.println("//Mensagem Recebida:"); //DEBUG
//Serial.println(String(info)); //DEBUG
//Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
//Recebido:
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C9153914600126700002180916143124009ECF4392C07B1EB7A
OK
//Fim
Mensagem de outra pessoa
Mensagem Apagada
//Recebido:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim
//Recebido:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim
//Recebido:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
String adminPDU = converterNumero(numero);
Serial.print("adminPDU=");
Serial.println(adminPDU);
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Recebido:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim"); //DEBUG
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
//Serial.println("//Mensagem Recebida:"); //DEBUG
//Serial.println(String(info)); //DEBUG
//Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Usa este e diz me o que aparece no Serial Monitor:Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; // Numero que recebe e envia SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados");
String adminPDU = converterNumero(numero);
Serial.print("adminPDU=");
Serial.println(adminPDU);
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
delay(100);
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
Serial.println("//Recebido:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim"); //DEBUG
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
//Serial.println("//Mensagem Recebida:"); //DEBUG
//Serial.println(String(info)); //DEBUG
//Serial.println("//Fim da Mensagem\\"); //DEBUG
String adminPDU = converterNumero(numero);
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
int index = 0;
char numero[13];
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
numero[y]=(pho[y+1]);
numero[y+1]=(pho[y]);
}
return numero;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
SMS apagados
adminPDU=539146001267ºê!!ë
//Recebido:
OK
//Fim
//Recebido:
AT+CMGR=1
+CMGR: 0,,0
OK
//Fim
int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; //Numero que recebe e envia SMS
String adminPDU = converterNumero(numero); //Para verificação de remetente das SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados"); //DEBUG
Serial.println("Inicio do Loop"); //DEBUG
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
Serial.println("//Mensagem Recebida:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim da Mensagem\\"); //DEBUG
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
char num[13];
int data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
num[y]=(pho[y+1]);
num[y+1]=(pho[y]);
}
num[y] = '\0';
return num;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Já está.
E só aparece alguma coisa no Serial quando receber uma mensagem.Código: [Seleccione]int ledPin = 13; //Used for DEBUG
char info[400];
char ligarluz[] = "ECF4392C07B1EB7A"; //"ligar luz" em PDU
char desligarluz[] = "E4F29C9D3E87E520765D0F"; //"desligar luz" em PDU
char ligarrega[] = "ECF4392C07C9CBE730"; //"ligar rega" em PDU
char desligarrega[] = "E4F29C9D3E87E52079F91C06"; //"desligar rega" em PDU
char numero[13] = "351964002176"; //Numero que recebe e envia SMS
String adminPDU = converterNumero(numero); //Para verificação de remetente das SMS
void setup()
{
pinMode(ledPin,OUTPUT); // LED DEBUG
Serial.begin(19200); // DEBUG
Serial3.begin(19200);
clear_SMS_Memory(); //Apagar SMS 1-30
Serial.println("SMS apagados"); //DEBUG
Serial.println("Inicio do Loop"); //DEBUG
}
void loop() // run over and over
{
CheckPCserial(); //Para Debug - Reencaminha comandos do PC para o telemóvel
Serial3.println("AT+CMGR=1"); //ler mensagem na posição 1
int index = 0;
unsigned long startTime = millis(); //Grava o tempo em que começou a ler
while (millis() < (startTime+1000)) //Timeout de 1s
{
if (Serial3.available()>0){
info[index] = Serial3.read(); //Ler
index++; }
//if (String(info).indexOf("OK")>0) break;
}
//Passou 1s
if (String(info).indexOf("+CMGR:")>0 && String(info).indexOf(",,0")<0) //Vê se existe uma mensagem
{
Serial.println("//Mensagem Recebida:"); //DEBUG
Serial.println(String(info)); //DEBUG
Serial.println("//Fim da Mensagem\\"); //DEBUG
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40) //Verifica se o número do "admin" está no início da mensagem PDU
{
Serial.println("Mensagem do admin");
if (String(info).indexOf(String(ligarluz))>0) //Se "ligar luz" (em PDU) está na mensagem recebida, ligar luz
LigarLuz();
else if (String(info).indexOf(String(desligarluz))>0)
DesligarLuz();
else if (String(info).indexOf(String(ligarrega))>0) //Senão, Se "ligar rega" (em PDU) está na mensagem recebida, ligar rega
LigarRega();
else if (String(info).indexOf(String(desligarrega))>0)
DesligarRega();
}
else Serial.println("Mensagem de outra pessoa"); //DEBUG
Serial3.println("AT+CMGD=1"); //Apagar mensagem
delay(1000);
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
Serial.println("Mensagem Apagada");
memset( &info, 0, sizeof(info) ); //Limpar array info
}
}
void LigarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarLuz()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Luz desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Luz desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void LigarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Ligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Ligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void DesligarRega()
{
digitalWrite(ledPin,HIGH); //LED aceso
Serial.println("Rega Desligada"); //Debug
delay(1000); //Debug
send_sms(numero, "Rega Desligada"); //Enviar SMS
Serial.println("SMS Enviado"); //Debug
digitalWrite(ledPin,LOW); //LED apagado
}
void CheckPCserial()
{
int index = 0;
if (Serial.available()>0) {
while (1) {
info[index] = Serial.read();
index++;
delay(2);
if (Serial.available() <= 0) {
Serial3.println(String(info));
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
void clear_SMS_Memory(){
unsigned short i = 0;
for(i=1;i<=30;i++){
Serial3.print("AT+CMGD=");
Serial3.println(i);
delay(100);
}
while (Serial3.available()>0) Serial3.read(); //Limpar resposta
}
#define num_to_char(number) ((number) < 10 ? ('0' + (number)) : (('A' - 10) + (number)) )
#define first_four(byte) (0x0F & (byte))
#define last_four(byte) ((0xF0 & (byte)) >> 4)
#define hexdump_a(byte) num_to_char( last_four(byte))
#define hexdump_b(byte) num_to_char(first_four(byte))
void hexdump_byte(unsigned char byte)
{
Serial3.write(hexdump_a(byte));
Serial3.write(hexdump_b(byte));
}
String converterNumero(char *pho){
char num[13];
int data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
num[y]=(pho[y+1]);
num[y+1]=(pho[y]);
}
num[y] = '\0';
return num;
}
void convertPhone(char *pho){
size_t data_length,y;
data_length = strlen(pho);
for (y = 0; y < data_length; y=y+2)
{
Serial3.write(pho[y+1]);
Serial3.write(pho[y]);
}
}
void send_sms(char *recPhone, char *data)
{
size_t data_length, x;
char l;
long i;
long n;
data_length = strlen(data);
i = data_length * 7;
/* Round i up to a multiple of 8 */
if (i & 0x07) i = (i & ~0x07) + 0x08;
/* Calculate the number of message octets */
i = i / 8;
Serial3.println("AT+CMGF=0");
delay(1500);
Serial3.print("AT+CMGS="); // Send SMS Comand
//phone.print("AT+CMGW="); //Send SMS to mobile draft folder (DEBUG)
delay(1500);
Serial3.println(i + 14); //change it if necessary (see example below) Fixed number for 12 digits phone.
delay(1500);
Serial3.print("0011000C91"); // using the convertPhone function , for phones # with digits =12, like all numbers in Portugal.
convertPhone(recPhone);
Serial3.print("0000AA");
hexdump_byte(data_length & 0xFF);
l = 0;
n = 0;
for (x = 0; x < data_length; x++)
{
if (data[x] == '$') data[x] = 0x02;
n |= (data[x] & 0x7F) << l;
l += 7;
if (l >= 8)
{
hexdump_byte(n & 0xFF);
l -= 8;
n >>= 8;
}
}
if (l != 0)
{
hexdump_byte(n & 0xFF);
}
// Code changed for Arduino v1.0
Serial3.write(0x1A); // Ctrl+Z
Serial3.write(0x0D); // CR
Serial3.write(0x0A); // LF
delay(5000);
}
Inicio do Loop
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,27
07915391131213F4040C9153914600126700002180919193654009ECF4392C07B1EB7A
OK
//Fim da Mensagem\
Mensagem de outra pessoa
Mensagem Apagada
Substitui:
if (String(info).indexOf(adminPDU)>0 && String(info).indexOf(adminPDU)<40)
Por:
if (String(info).indexOf(adminPDU)>0)
SMS apagados
Inicio do Loop
//Mensagem Recebida:
AT+CMGR=1
+CMGR: 0,,28
07915391131213F4040C915391460012670000218091024582400A2076FA1C9683D8753D
OK
//Fim da Mensagem\
Mensagem do admin
Mensagem Apagada
Bem observado. ta a funcionar sim :) vou fazer agora o video pra por no youtubeAinda bem... :D
Bem observado. ta a funcionar sim :) vou fazer agora o video pra por no youtubeAinda bem... :D
O ideal era filtrar esse tipo de coisas, mas não é fácil. É preciso um conversor PDU->Texto :-\
#include <Ethernet.h>
#include <SPI.h>
/*
Simple Ethernet Test
Arduino server outputs simple text to browser
The circuit:
* Arduino Duemilanove
* Arduino Ethernet shield
* Basic FTDI breakout 5V
*LED connected to GND and digital pin 4 via resistor
By Minde
http://www.sciencprog.com/
*/
Byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x49, 0xD6 };
Byte IP[] = {192,168,1,70}; // IP address of WiShield
Byte gateway[] = {192,168,1,254}; // router or gateway IP address
Byte subnet[] = {255,255,255,0};
String password= "12345"; // Altere sua senha
Int tries = 0; // tentativas ao digitar a senha
Boolean proceed = true; //Flag que permite a exibição DA página protegida
Server server(6969); //server port
Int ledPin = 4; // LED pin
Int LEDpin = 7;
String state = String(3);
Word Adc = 0;
String readString = String(30); //string for fetching data from address
Boolean LEDON = false; //LED status flag
Void Portada();
Void setup(){
//start Ethernet
Ethernet.begin(mac, IP, gateway, subnet);
//Set pin 4 to output
PinMode(LEDpin,OUTPUT);
DigitalWrite(LEDpin,LOW);
State = "OFF";
String state = String(3);
//enable serial datada print
Serial.begin(9600);
}
Void loop(){
// Create a client connection
Client client = server.available();
If (client) {
While (client.connected()){
Char c = client.read();
If (readString.length() < 30){
ReadString += c;
}
Serial.print(c);
If (c == '\n') {
if(readString.trim() == ("GET /?pwd="+password+" HTTP/1.1")){
//client.println("<h1>Clave Ok</h1>");
Proceed = true;
Portada();
}else{
//Pagina de login
Client.println("HTTP/1.1 200 OK");
Client.println("Content-Type: text/HTML; charset=utf-8");
Client.println();
Client.println("<form action='./' method='get'>");
Client.println("Senha: <input type='text' name='pwd' />");
Client.println("<input type='submit' value='OK' />");
Client.println("</form>");
if(tries++ >0)
Client.println("<small>senha incorreta!</small>");
}
//client.println("HTTP/1.1 200 OK");
//client.println("Content-Type: text/HTML");
/*
Client.println();
Client.print("<body style=background-color:#ffffff>");
Client.println("<h1>Control de Acceso</h1>");
Client.println("<form method=get name=LED>");
Client.println("<input type=""password"" name=C>");
Client.println("<input type=submit value=submit></form>");
*/
//clearing string for next read
ReadString="";
//stopping client
Client.stop();
}
}
}
}
Void Portada(){
While(proceed){
// Create a client connection
Client client = server.available();
Client.println("HTTP/1.1 200 OK");
Client.println("Content-Type: text/HTML ; charset=utf-8");
Client.println();
If (client) {
// an http request ends with a blank line
Boolean currentLineIsBlank = true;
Client.println("<form method=get name=form>");
While (client.connected()) {
If (client.available()) {
Char c = client.read();
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
If (readString.length() < 30) {
ReadString.concat(c);
}
If (c == '\n' && currentLineIsBlank) {
// send a standard http response header
Int LED = readString.indexOf("LED=");
If (readString.substring(LED,LED+5) == "LED=T") {
DigitalWrite(LEDpin,HIGH);
State = "ON";
}
Else if (readString.substring(LED,LED+5) == "LED=F") {
DigitalWrite(LEDpin,LOW);
State = "OFF";
}
Int MODO = readString.indexOf("auth=");
If (readString.substring(MODO,MODO+11) == "auth=logoff") {
Proceed = false;
Serial.println("Proceed false");
Tries=-1;
Client.println("<center><h5><a href=\"./?auth=login\"\"> Você fez Logoff. Clique para voltar.</a></h5></center></form>");
break;
}
client.println("<img src='http://dl.dropbox.com/u/6916111/tvoff.png' style=\"position:fixed;left:68px;top:80px;width:636px;height:431px;z-index:1;padding:0;\">");
if (state == "ON") {
// client.print("TESTE ");
client.println("<img src='http://dl.dropbox.com/u/6916111/tvon.png' type='image' style=\"position:fixed;left:254px;top:146px;width:146px;height:93px;z-index:2;padding:0;\">");
client.println("<a href=\"./?LED=F\" src='http://dl.dropbox.com/u/6916111/off.png' type='image' style=\"position:fixed;left:254px;top:146px;width:146px;height:93px;z-index:2;padding:0;\">");
}
else {
client.println("<img src='http://dl.dropbox.com/u/6916111/off.png' type='image' style=\"position:fixed;left:254px;top:146px;width:146px;height:93px;z-index:2;padding:0;\">");
client.println("<a href=\"./?LED=T\" src='http://dl.dropbox.com/u/6916111/tvon.png' type='image' style=\"position:fixed;left:254px;top:146px;width:146px;height:93px;z-index:2;padding:0;\">");
}
//client.print("LED is ");
// client.print(state);
client.print("<br><br>");
client.println("<a href=\"./?auth=logoff\"\">[Logoff]</a>");
client.println("</form>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
readString = "";
// close the connection:
client.stop();
}
}
}