Premesso che ho cercato ovunque nel forum senza trovare alcun post simile al mio caso.
Hardware utilizzato
Arduino Leonardo R3 con Arduino GSM Shield R3
Ho realizzato un semplice programma che a fronte di un segnale digitale ad un PIN
invia un messaggio SMS.
Durante il funzionamento segnalo visivamente con il blink di un led lo stato del dispositivo.
Tutto funziona correttamente se l’Arduino è collegata tramite USB al PC e lo sketch è stato appena caricato.
Se scollego l'Arduino e lo ricollego sempre alla porta USB, lo sketch non parte più.
Idem se lo alimento solo con una tensione 7,5 volts.(no USB)
Ovvero sembra addirittura che lo sketch si sia volatilizzato.
Importante:
Ho caricato uno sketch di esempio (BlinkWithoutDelay) e funziona correttamente anche scollegato all’ USB del PC (quindi alimentato l’Arduino con l’alimentatore sempre da 7,5 Volts).
Ma se togli lo shield e colleghi la Leonardo, il tuo sketch parte? Cioè, vedi il tuo programma che fa il lampeggio del LED mentre è in attesa del segnale sul pin?
No ..
non mi funziona.
Probabilmente perchè faccio riferimento a librerie del GSM e non trova lo shield.
Mentre volevo mettere in evidenzia che caricando il semplice esempio di blink di un led
e con GSM shield collegato riparte sempre!!
Aggiornamento:
ho caricato lo sketch di esempio sendSMS e mi parte regolarmente ad ogni riavvio.
mentre il mio sketch che riporto no.
mi potete aiutare??
GRAZIE
// Include the GSM library
#include <GSM.h>
#define remotenum "+39xxxxxxxx"
#define PINNUMBER "xxxx"
const int buttonPin = 9; // the pin that the pushbutton is attached to
const int ledPin = 13; // the pin that the LED is attached to
const long ritardo=10000; // delay to alarm
const long interval_blink_alarm = 100; // interval at which to blink (milliseconds)
const long interval_blink_ok = 1000; // interval at which to blink (milliseconds)
int ledState = LOW; // ledState used to set the LED
long previousMillis = 0; // will store last time LED was updated
int Level_State = 0; // current state of the button
int lastLevel_State = 0; // previous state of the button
unsigned long time_begin_on; // millisecon to start change state
unsigned long time_begin_off; // millisecon to start change state
unsigned long time_now; // elapsed time in millisecond
boolean disp = true;
boolean noGSM =true;
boolean PIN_in_allarme = false;
int tentativi=3;
// connection state
boolean Connected = false;
void Send_SMS(const char*);
// initialize the library instance
GSM gsmAccess;
GSM_SMS sms;
void setup() {
// initialize the button pin as a input:
pinMode(buttonPin, INPUT);
// initialize the LED as an output:
pinMode(ledPin, OUTPUT);
// initialize serial communication:
// initialize serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
Serial.println("Inizializzazione GSM Shield");
// Start GSM shield
while(tentativi>0)
{
if(gsmAccess.begin(PINNUMBER)==GSM_READY){
Connected = true;
tentativi=0;
}
else
{
Serial.println("GSM non connesso!!");
delay(1000);
tentativi--;
}
}
if (Connected){
Serial.println("GSM inizializzato");
}
else {
Serial.println("GSM NON inizializzato");
}
}
void loop() {
unsigned long currentMillis = millis();
if (!Connected){ // GSM KO
// Blink LED for GSM not active
if(currentMillis - previousMillis > interval_blink_alarm) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
else { // GSM OK
if (! PIN_in_allarme) {
// Blink LED for normal activity
if(currentMillis - previousMillis > interval_blink_ok) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
// read the level input pin:
Level_State = digitalRead(buttonPin);
if (Level_State==HIGH) { // livello OK
if (Level_State==HIGH && lastLevel_State == LOW) {
time_begin_on = millis();
lastLevel_State = HIGH;
disp=true;
}
time_now = millis();
if (time_now - time_begin_on > ritardo ) {
PIN_in_allarme= false;
if (disp) {
disp=false;
digitalWrite(ledPin, LOW);
Serial.println("Allarme disattivato");
Send_SMS("Allarme disattivato");
delay(1000);
}
}
}
else { //livello KO
if (Level_State==LOW && lastLevel_State == HIGH) {
time_begin_off = millis();
lastLevel_State = LOW;
disp=true;
}
time_now = millis();
if (time_now - time_begin_off > ritardo ) {
PIN_in_allarme= true;
if (disp) {
disp=false;
digitalWrite(ledPin, HIGH);
Serial.println("Allarme ATTIVATO");
Send_SMS("Allarme ATTIVATO");
delay(1000);
}
}
}
}
}
void Send_SMS(const char* Mex)
{
sms.beginSMS(remotenum);
sms.print(Mex);
sms.endSMS();
}
Più che altro, non hanno mai spiegato a cosa serve quel comando.
L'hanno inserito per una sorta di compatibilità con la UNO.
Nell'Arduino UNO infatti aprendo il serial monitor la scheda si resetta, lo sketch parte dall'inizio e nel serial monitor appaiono tutte le informazioni cosi come scritte dal programmatore.
Nella Leonardo no. Puoi aprire 100 volte il serial monitor (tranne che a 1200baud, ma lo standard è 9600) che la scheda non si resetta. Se lo apri 5 secondi dopo aver alimentato la scheda ti perdi eventualmente parte delle scritte iniziali, se ci sono.
Allora si sono inventati un while che blocca l'esecuzione fino a che non si apre la seriale.
Piccolo problema.... e se non apro la seriale? Lo sketch si blocca e rimane li in attesa.
Quindi quando progetti sketch che sai che collegherai la seriale sporadicamente e solo per debug non mettere il While.
Anche sulla YUN è così, ci ho perso un po' di tempo per capirlo.
PaoloP:
Piccolo problema.... e se non apro la seriale? Lo sketch si blocca e rimane li in attesa.
Quindi quando progetti sketch che sai che collegherai la seriale sporadicamente e solo per debug non mettere il While.
Avrebbero dovuto implementare anche un timeout per far uscire da quel while a prescindere dall'apertura della seriale.