Salve a tutti ho acquistato Arduino Gprs Shield V2.0 e Duemilanove ed ho subito provato a collegarli mettendo la sim. Sono andato su questo link GPRS Shield V2.0 | Seeed Studio Wiki per provare degli esempi di codice per vedere se funzionava ma ho notato che provando questo codice
/*Note: this code is a demo for how to using GPRS Shield to send SMS message and dial a voice call.
The microcontrollers Digital Pin 7 and hence allow unhindered communication with GPRS Shield using SoftSerial Library.
IDE: Arduino 1.0 or later */
#include <SoftwareSerial.h>
#include <String.h>
SoftwareSerial mySerial(7,8);
void setup()
{
mySerial.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the GPRS baud rate
delay(500);
}
void loop()
{
//after start up the program, you can using terminal to connect the serial of gprs shield,
//if you input 't' in the terminal, the program will execute SendTextMessage(), it will show how to send a sms message,
//if input 'd' in the terminal, it will execute DialVoiceCall(), etc.
if (Serial.available())
switch(Serial.read())
{
case 't':
SendTextMessage();
break;
case 'd':
DialVoiceCall();
break;
}
if (mySerial.available())
Serial.write(mySerial.read());
}
///SendTextMessage()
///this function is to send a sms message
void SendTextMessage()
{
mySerial.print("AT+CMGF=1\r"); //Because we want to send the SMS in text mode
delay(100);
mySerial.println("AT + CMGS = \"+86186*****308\"");//send sms message, be careful need to add a country code before the cellphone number
delay(100);
mySerial.println("How are you ?");//the content of the message
delay(100);
mySerial.println((char)26);//the ASCII code of the ctrl+z is 26
delay(100);
mySerial.println();
}
///DialVoiceCall
///this function is to dial a voice call
void DialVoiceCall()
{
mySerial.println("ATD + +86186*****308;");//dial the number
delay(100);
mySerial.println();
}
void ShowSerialData()
{
while(mySerial.available()!=0)
Serial.write(mySerial.read());
}
ed impostando il valore di baud rate corretto, sul monitor seriale visualizzo caratteri indecifrabili del tipo "mþ?mþmþÿÿÿ" e continuano all'infinito.
Sono io che sbaglio qualcosa?
Grazie in anticipo
Sono riuscito a visualizzare i comandi at sul terminale ma qualcuno mi può spiegare perchè visualizzo spesso le risposte a metà? Ad esempio la risposta "OK" a volte la ricevo così "O" e anche altre risposte spesso sono incomplete.
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
unsigned char buffer[64]; // buffer array for data recieve over serial port
int count=0; // counter for buffer array
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
if (GPRS.available()) // if date is comming from softwareserial port ==> data is comming from gprs shield
{
while(GPRS.available()) // reading data into char array
{
buffer[count++]=GPRS.read(); // writing data into array
if(count == 64)break;
}
Serial.write(buffer,count); //if no data transmission ends, write buffer to hardware serial port
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
count = 0; // set counter of while loop to zero
}
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
}
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i<count;i++)
{ buffer[i]=NULL;} // clear all index of array with command NULL
}
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
unsigned char buffer[64]; // buffer array for data recieve over serial port
int count=0; // counter for buffer array
char inData[120];
char inChar=-1;
byte index = 0;
unsigned long myTime;
myTime = millis();
boolean ricevuto = false;
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
while(1) {
if (Serial.available() > 0) {
if(index < 119) {
inChar = Serial.read();
if (inChar == 'j') break; // Uscita per 'j'
inData[index] = inChar;
index++;
inData[index] = '\0';
myTime = millis();
}
else {
break;
}
}
if ((millis() - myTime) > 1000) break; // Timeout ad 1 sec.
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
}
}
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i<count;i++)
{ buffer[i]=NULL;} // clear all index of array with command NULL
}
No, occhio non devi copiare ... quello doveva servire da spunto per capire il problema ... NON credo che il GPRS ti dia il carattere di 'j' per indicare che ha finito ... quello lo dava lui con un tasto ...
Devi più che altro capire la logica e dare tempo alla seriale di ricevere tutti i dati ... ad esempio con un piccolo meccanismo di timeout come quello che era implementato li ... se non ti arriva più nulla per NNNN milli allora è finito, oppure, se l'ultimo carattere è CR (non so se il GPRS termina con un carriage return) allora è finito ...... giochini del genere .....
Però non capisco una cosa...io non ricevo una stringa incompleta come nel post che mi hai segnalato...io ricevo per esempio invece di "ciao" ---->"co" oppure altre volte "cio" e non è sempre uguale cambia ogni volta quello che ricevo non penso sia un problema di buffer giusto?
davix10:
Però non capisco una cosa...io non ricevo una stringa incompleta come nel post che mi hai segnalato...io ricevo per esempio invece di "ciao" ---->"co" oppure altre volte "cio" e non è sempre uguale cambia ogni volta quello che ricevo non penso sia un problema di buffer giusto?
Hai letto male il thread ... difatti anche li NON era un problema di buffer, ma di tempi ...
... con il loop che hai messo tu (come era in quel thread), basta un minimo ritardo nell'arrivo di un carattere che la while esce dal loop perché NON trova disponibile alcun carattere in arrivo dalla seriale. Chi ti garantisce che il modulo GPRS mandi sempre i caratteri a velocità costante e non abbia un, seppur minimo ritardo ?
davix10:
Ma quindi se mettessi un delay potrebbe funzionare?
Mmm ... puoi provare, ma ... la scelta migliore sarebbe implementare, come è stato fatto nell'altro thread, in assenza di un carattere che indica la fine della stringa, un meccanismo di timeout ...
... "se non ricevo caratteri per NNNN millisecondi allora esco". In questo modo è più flessibile e sicura
Puoi darmi una mano con il codice? sono alle prime armi...io ho provato a farlo così
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
int count=0; // counter for buffer array
char inData[120];
char inChar=-1;
byte index = 0;
unsigned long time;
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
if (GPRS.available()) // if date is comming from softwareserial port ==> data is comming from gprs shield
{
while(GPRS.available()) // reading data into char array
{
if(index < 119) {
inChar = Serial.read();
if (inChar == '\r') break; // Uscita per 'j'
inData[index] = inChar;
index++;
inData[index] = '\0';
time = millis();
}
else {
break;
}
}
if ((millis() - time) > 1000) break; // Timeout ad 1 sec.
Serial.write(buffer,count); //if no data transmission ends, write buffer to hardware serial port
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
count = 0; // set counter of while loop to zero
}
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
}
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i<count;i++)
{ buffer[i]=NULL;} // clear all index of array with command NULL
}
così mi da errore qui if ((millis() - time) > 1000) break;
... per forza, stai cercando di fare una "break" al di fuori del ciclo ... da quale ciclo quella "break" dovrebbe farti uscire ???
Allora, dovresti modificare il ciclo di while() così :
while (1) { // da questo while esci solo con un "break"
if (GPRS.available()) { // almeno un carattere disponibile dal GPRS
if(index < 119) { // verifichi se hai posto nel buffer ...
inChar = GPRS.read(); // ... SI, leggi un carattere dal GPRS
if (inChar == '\n') break; // se esso è uguale al terminatore '\n' esci (... metti il carattere che veramente termina la stringa)
inData[index] = inChar; // altrimenti memorizzi il carattere
index++; // incrementi l'indice
inData[index] = '\0'; // metti il fine stringa (nel caso non arrivassero altri caratteri)
time = millis(); // ti segni quando è arrivato l'ultimo carattere
}
else { // ... NO, hai finito lo spazio del tuo buffer
break; // devi uscire !
}
}
if ((millis() - time) > 750) { // Ti chiedi se il tempo trascorso dall'ultimo carattere ricevuto è > 750 mSec (... decidi tu quanto vuoi aspettare)
break; // ... SI, tempo scaduto, esci !
}
}
... non l'ho provato, ma ad occhio dovrebbe andare
Fammi sapere,
Guglielmo
P.S. : Cerca di capire cosa fa e non fare semplicemente un "brutale" copia/incolla !!!
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
int count=0; // counter for buffer array
unsigned char inData[120];
char inChar=-1;
int index = 0;
unsigned long time;
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
while (1) { // da questo while esci solo con un "break"
if (GPRS.available()) { // almeno un carattere disponibile dal GPRS
if(index < 119) { // verifichi se hai posto nel buffer ...
inChar = GPRS.read(); // ... SI, leggi un carattere dal GPRS
if (inChar == '\n') break; // se esso è uguale al terminatore '\n' esci (... metti il carattere che veramente termina la stringa)
inData[index] = inChar; // altrimenti memorizzi il carattere
index++; // incrementi l'indice
inData[index] = '\0'; // metti il fine stringa (nel caso non arrivassero altri caratteri)
time = millis(); // ti segni quando è arrivato l'ultimo carattere
}
else { // ... NO, hai finito lo spazio del tuo buffer
break; // devi uscire !
}
}
if ((millis() - time) > 750) { // Ti chiedi se il tempo trascorso dall'ultimo carattere ricevuto è > 750 mSec (... decidi tu quanto vuoi aspettare)
break; // ... SI, tempo scaduto, esci !
}
}
Serial.write(inData,index); // if no data transmission ends, write buffer to hardware serial port
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
index = 0; // set counter of while loop to zero
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
}
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i<index;i++)
{ inData[i]=NULL;} // clear all index of array with command NULL
}
In compilazione non mi da nessun errore ma in pratica è come se fosse lo stesso che avevo prima perchè continuo a non ricevere tutti i caratteri.
... esatto, a questo punto è l'unica soluzione ...
while (1) { // da questo while esci solo con un "break"
if (GPRS.available()) { // almeno un carattere disponibile dal GPRS
if(index < 119) { // verifichi se hai posto nel buffer ...
inChar = GPRS.read(); // ... SI, leggi un carattere dal GPRS
Serial.print("Carattere ricevuto = 0x"); // --- PER DEBUG
Serial.println(inChar, HEX); // --- ci stampiamo il valore HEX del carattere ricevuto (così vediamo anche caratteri di controllo)
if (inChar == '\n') break; // se esso è uguale al terminatore '\n' esci (... metti il carattere che veramente termina la stringa)
inData[index] = inChar; // altrimenti memorizzi il carattere
index++; // incrementi l'indice
inData[index] = '\0'; // metti il fine stringa (nel caso non arrivassero altri caratteri)
time = millis(); // ti segni quando è arrivato l'ultimo carattere
}
else { // ... NO, hai finito lo spazio del tuo buffer
Serial.println("Esco per Buffer Full"); // --- PER DEBUG
break; // devi uscire !
}
}
if ((millis() - time) > 750) { // Ti chiedi se il tempo trascorso dall'ultimo carattere ricevuto è > 750 mSec (... decidi tu quanto vuoi aspettare)
Serial.println("Esco per Timeout"); // --- PER DEBUG
break; // ... SI, tempo scaduto, esci !
}
}
Serial.print ("Ricevuto = "); // --- PER DEBUG
Serial.println(inData); // --- PER DEBUG
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include <SoftwareSerial.h>
SoftwareSerial GPRS(7, 8);
int count=0; // counter for buffer array
unsigned char inData[120];
char inChar=-1;
int index = 0;
unsigned long time;
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
while (1) { // da questo while esci solo con un "break"
if (GPRS.available()) { // almeno un carattere disponibile dal GPRS
if(index < 119) { // verifichi se hai posto nel buffer ...
inChar = GPRS.read(); // ... SI, leggi un carattere dal GPRS
Serial.print("Carattere ricevuto = 0x"); // --- PER DEBUG
Serial.println(inChar, HEX); // --- ci stampiamo il valore HEX del carattere ricevuto (così vediamo anche caratteri di controllo)
if (inChar == '\n') break; // se esso è uguale al terminatore '\n' esci (... metti il carattere che veramente termina la stringa)
inData[index] = inChar; // altrimenti memorizzi il carattere
index++; // incrementi l'indice
inData[index] = '\0'; // metti il fine stringa (nel caso non arrivassero altri caratteri)
time = millis(); // ti segni quando è arrivato l'ultimo carattere
}
else { // ... NO, hai finito lo spazio del tuo buffer
Serial.println("Esco per Buffer Full"); // --- PER DEBUG
break; // devi uscire !
}
}
if ((millis() - time) > 750) { // Ti chiedi se il tempo trascorso dall'ultimo carattere ricevuto è > 750 mSec (... decidi tu quanto vuoi aspettare)
Serial.println("Esco per Timeout"); // --- PER DEBUG
break; // ... SI, tempo scaduto, esci !
}
}
Serial.print ("Ricevuto = "); // --- PER DEBUG
Serial.println(inData); // --- PER DEBUG
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
index = 0;
}
/* Serial.write(inData,index); // if no data transmission ends, write buffer to hardware serial port
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
index = 0; // set counter of while loop to zero
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
*/
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i<index;i++)
{ inData[i]=NULL;} // clear all index of array with command NULL
}
Questo è quello che mi scrive error: call of overloaded 'write(unsigned char [120])' is ambiguous
