Codice: invio delle coordinate con parsing

Abbiamo unito lo sketch del parsing con quello delle coordinate, il problema principale che abbiamo riscontrato è stato individuare le parti importanti dei due codici e unirle in modo corretto.

Il codice:

#define TINY_GSM_MODEM_SIM808

int pon=9;

#define SerialMon SerialUSB

#define SerialAT Serial1

#define TINY_GSM_DEBUG SerialMon

#define SMS_TARGET “+393391356849”

const char apn[] = “YourAPN”;
const char user[] = “”;
const char pass[] = “”;

#include <TinyGsmClient.h>

#ifdef DUMP_AT_COMMANDS
#include <StreamDebugger.h>
StreamDebugger debugger(SerialAT, SerialMon);
TinyGsm modem(debugger);
#else
TinyGsm modem(SerialAT);
#endif

void setup() {

SerialMon.begin(9600);

delay(3000);
DBG(“BeeSafe ON…”);

pinMode(pon, OUTPUT);
digitalWrite(pon, HIGH);
delay(3000);
digitalWrite(pon, LOW);
<<<<
delay(3000);

TinyGsmAutoBaud(SerialAT);
}

void loop() {

DBG(“Initializing modem…”);
if (!modem.restart()) {
delay(10000);
return;
}
bool res;
String modemInfo = modem.getModemInfo();
DBG(“Modem:”, modemInfo);

//pin 1234

String imei = modem.getIMEI();
DBG(“IMEI:”, imei);

String cop = modem.getOperator();
DBG(“Operator:”, cop);

IPAddress local = modem.localIP();
DBG(“Local IP:”, local);

int csq = modem.getSignalQuality();
DBG(“Signal quality:”, csq);

int battLevel = modem.getBattPercent();
DBG(“Battery lavel:”, battLevel);

float battVoltage = modem.getBattVoltage() / 1000.0F;
DBG(“Battery voltage:”, battVoltage);

String gsmLoc = modem.getGsmLocation();
DBG(“GSM location:”, gsmLoc);

String gsmTime = modem.getGSMDateTime(DATE_TIME);
DBG(“GSM Time:”, gsmTime);
String gsmDate = modem.getGSMDateTime(DATE_DATE);
DBG(“GSM Date:”, gsmDate);

String ussd_balance = modem.sendUSSD(“*111#”);
DBG(“Balance (USSD):”, ussd_balance);

String ussd_phone_num = modem.sendUSSD(“*161#”);
DBG(“Phone number (USSD):”, ussd_phone_num);

#if defined(TINY_GSM_MODEM_SIM808)
modem.enableGPS();
String gps_raw = modem.getGPSraw();
modem.disableGPS();
DBG(“GPS raw data:”, gps_raw);
#endif

#if defined(SMS_TARGET)
res = modem.sendSMS(SMS_TARGET, String(“Hello from BeeSafe -> IMEI: “) + imei);
DBG(“SMS:”, res ? “OK” : “fail”);

#endif

while (1){
#if defined(TINY_GSM_MODEM_SIM808)
modem.enableGPS();
String gps_raw = modem.getGPSraw();

DBG(“GPS raw data:”, gps_raw);

String input = ;
int counter = 0;
String pieces[30];
int ultimavirgola = 0;
int a=0;
for (a = 0; a < input.length(); a++) {

if (input.substring(a, a+1) == “,”) {

pieces[counter] = input.substring(ultimavirgola, a);

ultimavirgola = a + 1;

counter++;

}

if (a == input.length()-1) {
pieces[counter] = input.substring(ultimavirgola, a);

}

}

#endif
#if defined(SMS_TARGET)
res = modem.sendSMS(SMS_TARGET, String(“GPS raw data: “) + gps_raw);
DBG(“SMS:”, res ? “OK” : “fail”);

#endif
int i=600;
while (i>0){
delay (1000);
i–;
DBG(“Invio sms tra “,i);
DBG(” secondi”);
}
}
#if defined(CALL_TARGET)
DBG(“Calling:”, CALL_TARGET);

// This is NOT supported on M590
res = modem.callNumber(CALL_TARGET);
DBG(“Call:”, res ? “OK” : “fail”);

if (res) {
delay(1000L);

// Play DTMF A, duration 1000ms
modem.dtmfSend(‘A’, 1000);

for (char tone=’0′; tone<=’4′; tone++) {
modem.dtmfSend(tone);
}

delay(5000);

res = modem.callHangup();
DBG(“Hang up:”, res ? “OK” : “fail”);
}
#endif

modem.gprsDisconnect();
if (!modem.isGprsConnected()) {
DBG(“GPRS disconnected”);
} else {
DBG(“GPRS disconnect: Failed.”);
}

modem.poweroff();
DBG(“Poweroff.”);

while (true) {
modem.maintain();
}
}

Invio coordinate GPS formattate (Parsing)

Abbiamo lavorato sullo sketch Arduino per poter mandare coordinate GPS con relativo messaggio da inviare sul cellulare scritto nel codice con Parsing.

Parsing: frammentazione di una stringa di testo

Esempio di Parsing:

String input = “1,1,20181206123453.000,45.652260,8.784088,219.900,0.00,11.4,1,,1.3,2.4,2.0,,10,7,,,48,,”;

String pieces[30];

// Keep track of current position in array
int counter = 0;

void setup(){
Serial.begin(9600);

}

void loop() {
// Keep track of the last comma so we know where to start the substring
int ultimavirgola = 0;
int i=0;

for (i = 0; i < input.length(); i++) {

// Loop through each character and check if it’s a comma
if (input.substring(i, i+1) == “,”) {

// Grab the piece from the last index up to the current position and store it
pieces[counter] = input.substring(ultimavirgola, i);

// Update the last position and add 1, so it starts from the next character
ultimavirgola = i + 1;
// Increase the position in the array that we store into
counter++;

}

// If we’re at the end of the string (no more commas to stop us)
if (i == input.length()-1) {
// Grab the last part of the string from the lastIndex to the end
pieces[counter] = input.substring(ultimavirgola, i);

}

}

for (i=0; i<=counter; i++){

}

String latitudine=pieces[3];
String longitudine=pieces[4];
String linkgoogle = “https://www.google.com/maps?q=loc:”

Serial.print(“https://www.google.com/maps?q=loc:”);Serial.print(latitudine);Serial.print(“,”);Serial.println(longitudine);
// https://www.google.com/maps/@45.6495896,8.8119812,15z
//http://maps.google.com/maps?q=loc:36.26577,-92.54324

// }

// Data is now available in pieces array
// pieces[0] is first item
// pieces[1] is second item, and so on
// You can call toInt() on the data to convert it to an int

// ex. int value = pieces[0].toInt();

}

Programmazione Maduino DHT11+cella di carico

Abbiamo unito i due codici dei sensori, specificatamente del DHT11 (sensore di umidità e temperatura) e la cella di carico (impiegato per rilevare gli spostamenti della cella di carico).  Il codice che segue è il risultato del nostro lavoro di oggi:

#include “HX711.h”
#define DOUT A1
#define CLK A0
HX711 bilancia(DOUT, CLK);
int peso = 0; // zona di memorizzazione del peso corrente
int pesoprec = 0; // zona di memorizzazione dell’ultimo peso esposto

#include <SimpleDHT.h>
int pinDHT11 = 2;
SimpleDHT11 dht11(pinDHT11);

void setup()
{
Serial.begin(9600);
Serial.println(“calcolo della tara – tare”);
Serial.println(“non mettere nulla sul piatto – don’t place anything on the scale…”);
delay (100);
bilancia.set_scale(253); // inserire il valore di scala, al posto di 2022 – insert scale value instead of 2022
bilancia.tare(20); // il peso a vuoto e’ considerato tara
Serial.println(“sistema pronto – system ready”);

}

void loop()
{
byte temperature = 0;
byte humidity = 0;
int err = SimpleDHTErrSuccess;
peso = bilancia.get_units(20), 3;

if (!(peso == pesoprec)) // se e’ variato il peso
{

Serial.print(“peso – weigth: “);
Serial.print(peso);
Serial.println(“g”);
}

if ((err = dht11.read(&temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
Serial.print(“Lettura fallita, err=”); Serial.println(err);delay(1000);
return;
}

Serial.print(“Temperatura: “);
Serial.print((int)temperature); Serial.print(” *C, “);
Serial.println(” “);
Serial.print(“Umidita’: “);
Serial.print((int)humidity); Serial.println(” H”);

delay(500);

}

Implementazione di Sensori Aggiuntivi

Dopo aver implementato ed ottimizzato l’invio via SMS delle coordinate GPS, utilizzando la scheda Maduino SIM-808 e i moduli GSM/GPRS e GPS, sono state analizzate ulteriori informazioni aggiuntive utilizzando due moduli: il modulo con sensore DHT11 permette di rilevare Temperatura ed Umidità, mentre il kit con cella di carico ed elettronica di interfaccia può essere utilizzata come sistema di antifurto che notifica il sollevamento dell’arnia rispetto la sua posizione originale.

Specifiche – DHT11:

Il modulo basato su sensore DHT11 permette di misurare variazioni di temperatura e variazioni di umidità relative.
È presente un’interfaccia seriale a filo singolo che ne facilita l’utilizzo.
Il sensore DHT11 viene calibrato in modo estremamente preciso: i coefficienti di calibrazione sono memorizzati nella memoria OTP e vengono richiamati durante il processo di rilevamento, in questo modo non vi è alcuna necessità di ricalibrare il sensore.

Caratteristiche Tecniche – DHT11:

  • Temperatura:
    • risoluzione: 1°C
    • precisione: ±2℃
    • range di misurazione: da 0°C a +50°C
  • Umidità:
    • risoluzione: 1%RH
    • precisione: ±5%RH (0~50°C)
    • range di misurazione: 20%RH ~ 90%RH (25°C)
  • Alimentazione DHT11:
    • Tensione – Vin: da 3,3Vdc a 5,5Vdc
    • Corrente – Iin: da 0,5mA a 2,5mA
  • Segnale d’Uscitadigitale, comunicazione tramite single-bus
  • Tempo di Rilevazione (medio): ±2sec
  • Dimensioni (mm): 29x18x7
  • Peso: 30 grammi
  • Datasheet – DHT11

Piedinatura – modulo DHT11:

VCC è l’alimentazione (+3,3Vdc/+5,5Vdc)
GND è la massa
DOUT rappresenta l’uscita Digitale (Digital-OUT)

Codice Esempio – Arduino:
/*
VCC: 5V

 GND: GND
 DATA: pin 2
/*
#include <SimpleDHT.h>
int pinDHT11 = 2;
SimpleDHT11 dht11(pinDHT11);
void setup() {
Serial.begin(9600);
}
void loop() {
byte temperature = 0;
byte humidity = 0;
int err = SimpleDHTErrSuccess;
if ((err = dht11.read(&temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
Serial.print(“Lettura fallita, err=”); Serial.println(err);delay(1000);
return;
}
Serial.print(“Temperatura: “);
Serial.print((int)temperature); Serial.print(” *C, “);
Serial.println(” “);
Serial.print(“Umidita’: “);
Serial.print((int)humidity); Serial.println(” H”);
// DHT11 sampling rate is 1HZ.
delay(1500);
}

 

Specifiche – cella di carico:

La cella di carico è gestita attraverso una scheda di interfaccia che permette di gestire i valori in uscita dal modulo stesso, in quanto essa lavora in tensioni molto basse
(nell’ordine dei uV/mV).
La scheda elettronica di interfaccia è basata sul chip HX711, un convertitore
analogico-digitale a 24 bit, specifico per interfacciare la cella di carico a un microcontrollore come Arduino, Fishino o altri compatibili.

                                                          Nella foto sopra è rappresentato il kit con cella di carico (arancione) e la scheda d’interfaccia (scheda verde, a destra) collegata ad Arduino Uno.

Caratteristiche Tecniche – cella di carico:

  • Materiale: lega di alluminio
  • Capacità (portata): 20 kg
  • Sensibilità di uscita: 2 mV / V ( ±0,15)
  • Non linearità (% sul Fondo Scala): 0,02
  • Isteresi (% sul Fondo Scala) : 0,02
  • Ripetibilità (% sul Fondo Scala): 0,02
  • Creep dopo 30 minuti (% sul Fondo Scala): 0,03
  • Effetto della temperatura sulla sensibilità (% sul Fondo Scala): 0,002
  • Effetto della temperatura sullo zero (% sul Fondo Scala): 0,005
  • Resistenza d’ingresso: 1 kohm (±10)
  • Resistenza di uscita: 1 kohm (±10)
  • Resistenza di isolamento: 5000 Mohm
  • Temperatura di lavoro: da -30°C a +70°C
  • Alimentazione: 10Vdc – 15Vdc(max)
  • Uscita analogica, collegata a pin A+ e A- dell’interfaccia HX711
  • Dimensioni (mm): 131x30x22

Caratteristiche Tecniche – interfaccia HX711:

  • Convertitore analogico-digitale a 24 bit
  • Alimentazione: +5Vdc (Arduino)
  • Uscita digitale, pin DT ed SCK
  • Datasheet – HX711

Collegamenti tra Cella di Carico e scheda di interfaccia HX711:

Filo ROSSO della cella di carico -> E+ (positivo) della scheda di interfaccia
Filo NERO della cella di carico -> E- (negativo) della scheda di interfaccia
Filo BIANCO (OUT–) della cella di carico > A- (negativo) della scheda di interfaccia
Filo VERDE (OUT+) della cella di carico -> A+ (positivo) della scheda di interfaccia

Piedinatura – scheda di interfaccia HX711:

                                                                                     VCC collegato a +5V di Arduino
GND collegato a GND di Arduino
SCK collegato al pin A0 di Arduino
DT collegato al pin A1 di Arduino

Configurazione Cella di Carico e interfacciamento con Arduino: link

Codice Esempio – Arduino:
#include<stdio.h>
#include<string.h>
#define DEBUG true
int pon=9;
int poff=6;
int lowp=5;
void setup() {
pinMode(pon, OUTPUT);
pinMode(poff, OUTPUT);
pinMode(lowp, OUTPUT);
digitalWrite(poff, LOW);
digitalWrite(lowp, HIGH);
digitalWrite(pon, HIGH);
SerialUSB.begin(115200);
while (!SerialUSB) {
; // wait for serial port to connect
}
Serial1.begin(115200);
digitalWrite(pon, LOW);
delay(3000);
digitalWrite(pon, HIGH);
delay(5000);
sendData(“AT+GPS=1 “,1000,DEBUG);
}
void loop() {
sendData(“AT+GPSRD=1”,1000,DEBUG);
delay(1000);
}
String sendData(String command, const int timeout, boolean debug) {
String response = “”;
Serial1.println(command);
long int time = millis();
while( (time+timeout) > millis()) {
while(Serial1.available()) {
char c = Serial1.read();
response+=c;
}
}
if(debug) {
SerialUSB.print(response);
}
return response;
}

Scelta della SIM Card

Confronto tra le offerte di diversi operatori telefonici per la scelta della microSIM da utilizzare.

Vodafone:

  • Costo SIM: 10
  • Costo SMS: 0.29€
  • Costo chiamate: 0.29€/min con scatto alla risposta

WIND:

  • Costo SIM: 10€
  • Costo SMS: 0.29
  • Costo chiamate: 0.29€/min senza scatto alla risposta

ILIAD:


Costo SIM: 9.99€

Offerta “Voce” 4.99€/mese – comprensivi di:

  • 40 MB di internet
  • SMS e chiamate illimitati

Confrontando i costi e le offerte proposte, abbiamo infinte optato per una microSIM di operatore Iliad.