Utilizzo delle Celle di Carico (LoadCell)

In questo progetto sono state utilizzate delle celle di carico per capire se l’arnia è stata sottratta.

Sfruttiamo questo tipo di sensore con lo scopo di verificare l’effettivo spostamento di essa: se viene rilevato un cambiamento repentino del peso, vuol dire che l’arnia è stata sollevata o il suo contenuto interno sottratto. Verrebbe pertanto inviato un SMS di allerta, in cui verranno fornite le coordinate precise (convertite in un link di google maps, costantemente aggiornate, in modo da localizzarla istantaneamente ed in maniera rapida), il livello di umidità e di temperatura. L’allarme resterà in funzione anche se successivamente il peso tornasse standard (in caso dopo il furto i ladri riappoggiassero l’arnia su un piano), finchè il proprietario non lo disattiverà dal proprio cellulare.

Utilizzeremo questo tipo di frame per contenere la cella di carico

Informazioni sulle Arnie

Com’è fatta un’arnia?


A FONDO

É la base di appoggio di tutta l’arnia. Viene sollevato dal suolo attraverso l’uso di pedane di materiale adatto a sostenere il peso dell’arnia ed è costituito da un insieme di listelli di legno di diverse misure. Le caratteristiche principali sono due: ha un’apertura sulla base che consente l’utilizzo di un fondo mobile (C) ed  del fondo antivarroa (B)non ha listelli di legno nella parte anteriore che risulta quindi aperta e sulla quale viene posta una griglia metallica (D).

BFONDO ANTIVARROA

É una rete di metallo il cui utilizzo si è molto diffuso negli ultimi anni a causa dell’acaro parassita varroa destructor. Quando il parassita precipita oltre la rete non è più in grado di risalireall’interno del nido.
 

CFONDO MOBILE

É una lastra di metallo estraibile attraverso la parte posteriore del fondo dell’arnia. Permette di controllare indirettamente non solo le attività delle api senza doverle disturbare aprendo l’arnia (es.: sarà per esempio possibile capire se hanno iniziato ad utilizzare le scorte di miele, nel qual caso si potranno osservare sulla lastra gli opercoli di cera delle celle un tempo chiuse e piene di miele) ma è possibile anche effettuare il conteggio della varroa e verificare lo stato di infestazione della famiglia.

DGRIGLIA METALLICA

É una griglia di metallo posta nella parte anteriore dell’arnia attraverso la quale le api entrano ed escono dal nido. Preclude ad animali di maggiori dimensioni di penetrare nel nido.

ENIDO

É una scatola di legno d’abete costituita da quattro pannelli. Al suo interno, nella parte superiore, presenta anteriormente e posteriormente delle scanalature che sono i punti di appoggio per i telaini da nido.

FTELAINI DA NIDO

Sono formati da quattro listelli di legnoIl superiore è il più lungo dei quattro e fa da sostegno a tutto il telaino appoggiandosi alle rientranze sulla parte anteriore e posteriore del nido. Dei telaini di un’arnia è il più grande. Il telaino viene “armato” facendovi passare dentro verticalmente in più punti un filo di ferro sul quale si pone poi il foglio cereo.

GESCLUDI REGINA

Si tratta di una griglia metallica che viene prodotta tramite stampi che presenta delle fessurecalibrate per permettere il passaggio esclusivamente alle api operaie impedendo alla regina, di dimensioni maggiori, di poter passare.

HMELARIO

Si tratta di una scatola in legno di abete che viene posta sopra all’escludi regina. Come il nido presenta delle scanalature nella parte anteriore e posteriore per permettere l’appoggio dei telaini da melario. E’ alto poco più della metà del nido.

ITELAINI DA MELARIO

Costituiti da quattro listelli di legno di cui il superiore più lungo per permettere l’appoggio sulle scanalature del melario. E’ alto circa la metà di un telaino da nido. Dato che solo le operaie riescono a raggiungere questi telaini grazie all’escludi regina (G)questi telaini non contengono covata.

LCOPRIFAVO

É una lastra di abete con un foro centrale ai cui lati vengono montati quattro regoli che permettono di tener sollevato il tetto (M)Il foro centrale può essere utilizzato per somministrare alimenti alle api.

MTETTO

Ha un’anima di legno d’abete su cui viene fissata una lamiera metallica per garantire una maggiore protezione all’arnia contro gli agenti atmosferici.

Fonte: https://www.ilmielebuono.it

Il peso di un’Arnia (vuota) può arrivare a 25Kg ovviamente il peso varia a seconda della capacità e la grandezza di essa. Esistono quattro tipi diversi di arnie denominati:

1)Langstroth: ha una capacità totale di 85L.

2)Dadant: questo tipo di arnia si suddivide in due diversi tipi: Dadant1 : che pesa 19Kg ed ha una capacità di 84L Dadant2: che pesa 22Kg ed ha una capacità di 86L

3)Lusitana: ha una capacità totale di 66L

Revisione – codice invio SMS con informazioni riguardo GPS, Peso, Temperatura ed Umidità

17/01/2019

Il codice precedente inviava le informazioni riguardo localizzazione GPS, Peso, Temperatura ed Umidità senza fare un refresh dei dati. I dati venivano quindi acquisiti una sola volta (all’avvio) e comunicati in loop, senza aggiornarli nel tempo.
Abbiamo quindi provveduto a revisionare il codice, diminuendo la latenza di acquisizione ed invio delle informazioni acquisite dai sensori (GPS, DHT11 e Cella di Carico).

Sono state utilizzate le seguenti librerie, compatibili con IDE Arduino:

  • HX711, per acquisire dati relativi al peso dalla Cella di Carico
  • SimpleDHT, per interfacciare il sensore DHT11 per rilevare Temperatura ed Umidità
  • TinyGSM, per la gestione della SIM e connessione dati (GPRS/GSM)
  • StreamDebugger, consente il debug dei comandi eseguiti nel codice Arduino

Codice Arduino (aggiornato al 17/01/2019):

#define TINY_GSM_MODEM_SIM808
int pon = 9;
#define SerialMon SerialUSB
#define SerialAT Serial1

//Cella di carico
#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

//DHT11
#include <SimpleDHT.h>
int pinDHT11 = 2;
SimpleDHT11 dht11(pinDHT11);
byte temperature = 0;
byte humidity = 0;
int err = SimpleDHTErrSuccess;

//GSM
#define TINY_GSM_MODEM_SIM808
#define SerialMon SerialUSB
#define SerialAT Serial1
#define TINY_GSM_DEBUG SerialMon
#define SMS_TARGET  "+39xxxxxxxxxx" //NUMERO DI CELLULARE!
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

String latitudine;
String longitudine;


void setup() {
  //Cella di Carico - Setup
  Serial.begin(9600);
  Serial.println("calcolo della tara");
  Serial.println("non mettere nulla sul piatto");
  delay (100);
  bilancia.set_scale(253); //inserire il valore di scala
  bilancia.tare(20); // il peso a vuoto e' considerato tara
  Serial.println("sistema pronto - system ready");

  //DHT11 Setup
  Serial.begin(9600);
  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() {

  //GSM
  DBG("Initializing modem...");
  if (!modem.restart()) {
    delay(10000);
  }
  bool res;
  String modemInfo = modem.getModemInfo();
  DBG("Modem:", modemInfo);
  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);

    int counter = 0;
    String pieces[30];
    int ultimavirgola = 0;
    int a = 0;
      for (a = 0; a < gps_raw.length(); a++) {
        if (gps_raw.substring(a, a + 1) == ",") {
          pieces[counter] = gps_raw.substring(ultimavirgola, a);
          DBG("trovata una virgola");
          ultimavirgola = a + 1;
          DBG("b");
          counter++;
        }
  
        if (a == gps_raw.length() - 1) {
          pieces[counter] = gps_raw.substring(ultimavirgola, a);
        }

        latitudine = pieces[3];
        longitudine = pieces[4];
        DBG("https://www.google.com/maps?q=loc:"); DBG(latitudine); DBG(","); DBG(longitudine);
      }
    
#endif

  // Cella di carico
  peso=pesa();

  //DHT11
  int temperature=temp();
  int humidity=humd(); 

#if defined(SMS_TARGET)
  //if(gps_raw!="0,,,,,,,,,,,,,,,,,,,,"){
    res = modem.sendSMS(SMS_TARGET, "https://www.google.com/maps?q=loc:" + pieces[3] + "," + pieces[4] + "  Peso: " + peso + " g" + "  Temperatura: " + (int)temperature + " C" + "  Umidita': " + (int)humidity + " H");

    DBG("SMS:", res ? "OK" : "fail");

#endif
    int i = 15;
    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();
  }
}


int temp(){
  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);
  }

  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);

  return int(temperature);
}

int humd(){
  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);
  }

  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);

  return int(humidity);
}

int pesa(){
  peso = bilancia.get_units(20), 3;
  if (!(peso == pesoprec)) // se e' variato il peso
  {
    pesoprec = peso; // memorizza il peso corrente
    Serial.print("peso - weigth: ");
    Serial.print(peso);
    Serial.println("g");
  }

  return peso;
}

Prossimo step: inviare un messaggio con “Coordinate non disponibili” quando il segnale GPS non è presente, pur continuando a comunicare le informazioni relative al Peso, alla Temperatura e all’Umidità.

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.