🥇Monitoraggio SMS del peso di tre alveari per 30$

No, non è un'offerta commerciale, questo è il costo dei componenti del sistema che potrai assemblare dopo aver letto l'articolo.

Un po' di contesto:

Qualche tempo fa ho deciso di iniziare a tenere delle api, e sono arrivate… per un'intera stagione, ma non sono sopravvissute all'inverno.
E questo nonostante avessi fatto tutto correttamente: nutrizione autunnale, isolamento prima del freddo.
L'alveare era un classico in legno del sistema "Dadant" con 10 telai di legno da 40 mm.
Ma quell'inverno, a causa delle "oscillazioni" di temperatura, anche apicoltori esperti hanno perso molti più alveari del solito.

Così è nata l'idea di un sistema di monitoraggio dello stato dell'alveare.
Dopo aver pubblicato alcuni articoli su Habr e scambiato opinioni sul forum degli apicoltori, ho deciso di procedere dall semplice al complesso.
Il peso è l'unico parametro indiscutibile, ma solitamente i sistemi esistenti monitorano solo un "alveare standard".
Se qualcosa va storto (per esempio, l'uscita di un sciame, malattia delle api), le misurazioni diventano irrilevanti.

Pertanto, è stato deciso di monitorare il cambiamento di peso di tre alveari contemporaneamente con un microcontrollore, aggiungendo poi le "funzionalità" successive.
Alla fine è emerso un sistema autonomo con un'autonomia di circa un mese con una sola carica della batteria 18650 e invio di statistiche una volta al giorno.
Ho cercato di semplificare il design il più possibile, in modo che potesse essere replicato anche senza schemi, solo osservando le foto.

La logica di funzionamento è la seguente: alla prima accensione/azzeramento, i valori dei sensori installati sotto gli alveari vengono memorizzati nella EEPROM.
Poi, ogni giorno, dopo il tramonto, il sistema "si sveglia", legge le misurazioni e invia un SMS con la variazione di peso delle 24 ore e dal momento dell'accensione.
Inoltre, viene inviato il valore della tensione della batteria e, nel caso scenda sotto 3,5V, viene emesso un avviso di necessità di ricarica, poiché al di sotto di 3,4V il modulo di comunicazione non si accende, e le misurazioni del peso diventano già "inaffidabili".

"Ti ricordi come è iniziato tutto. Era tutto una novità e si ripeteva."

Sì, proprio questo set di "hardware" era originariamente previsto, anche se solo i sensori di forza e i cavi sono sopravvissuti fino alla versione finale, ma procediamo con ordine.
In realtà, un rotolo di cavo non è necessario, semplicemente è costato quanto 30 metri a pezzi.

Se non ti spaventa smontare 3 LED SMD e una cinquantina di punti di saldatura tradizionale (a inserzione) — allora avanti!

Quindi, avremo bisogno del seguente set di attrezzature/materiali:

Arduino Pro Mini 3V
È importante prestare attenzione al chip del convertitore lineare: deve essere esattamente a 3.3V - sul chip con la marcatura KB 33/LB 33/DE A10 - ai miei cinesi sono riusciti a combinare qualche guaio e tutta la partita
di schede in negozio si è rivelata con regolatori a 5 volt e cristalli a 16 MHz.
USB-Ttl con chip CH340 - può andare bene anche 5 volt, ma durante il caricamento del microcontrollore, dovrai scollegare Arduino dal modulo GSM per evitare di bruciare quest'ultimo.
Le schede con chip PL2303 non funzionano su Windows 10.
Modulo di comunicazione GSM Goouu Tech IOT GA-6-B o AI-THINKER A-6 Mini.
Perché mi sono fermato su di lui? Neoway M590 - un modulo che richiede una certa dose di pazienza, GSM SIM800L - non mi è piaciuto il livello di logica non standard a 2.8V, che necessita di adattamento anche con l'Arduino a 3 volt.
Inoltre, la soluzione di AiThinker ha un consumo energetico minimo (quando invio SMS non ho visto correnti superiori a 100mA).
Antenna GSM GPRS 3DBI (nella foto sopra - una scheda rettangolare con 'coda', ore 9)
Pacchetto di avviamento di un operatore con una buona copertura nel luogo in cui si trova il tuo apiario.
Sì, il pacchetto deve essere attivato in anticipo su un normale telefono, DISATTIVARE LA RICHIESTA PIN all'accesso e ricaricare il credito.
Ora ci sono molte opzioni con nomi tipo 'Sensore', 'IoT' - hanno una tariffa mensile leggermente inferiore.
cavo dupont 20 cm femmina-femmina - 3 pezzi (per collegare Arduino a USB-TTL)
3 pezzi HX711 - ADC per bilance
6 celle di carico fino a 50 kg
15 metri di cavo telefonico a 4 fili - per collegare i moduli di peso ad ARDUINO.
Fotoresistore GL5528 (importante che sia proprio questo, con resistenza al buio di 1 MΩ e resistenza alla luce di 10-20 kΩ) e due normali resistori da 20 k
Un pezzo di nastro biadesivo 'spesso' 18x18 mm - per fissare Arduino al modulo di comunicazione.
Portabatterie 18650 e, di fatto, la batteria stessa ~2600mAh.
Un po' di cera o paraffina (candela a tablet per aromaterapia) - per la protezione dall'umidità dell'HX711.
Un segmento di trave di legno 25x50x300 mm per la base delle celle di carico.
Una dozzina di viti autofilettanti con rondella 4.2x19 mm per fissare i sensori alla base.

Puoi prendere la batteria da un laptop smontato - è molto più economica di una nuova, e la capacità sarà di gran lunga superiore a quella della cinese UltraFire - ho ottenuto 1500 contro 450 (mentre il Fire ha 6800 😉

Inoltre, avrai bisogno di mani ferme, un saldatore EPSN-25, colofonia e saldatura POS-60.

Cinque anni fa utilizzavo un saldatore sovietico con punta di rame (non ho mai gradito le stazioni di saldatura — ne ho provata una in fase di test, ed ho terminato il circuito con un EPSN).
Ma dopo la sua rottura e alcune terribili imitazioni cinesi, l'ultima si chiamava Sparta — un oggetto tanto robusto quanto il suo nome, mi sono fermato
su un dispositivo con termoregolatore.

Dunque, partiamo!

Per iniziare, dissaldiamo due LED dal modulo GSM (il posto in cui si trovavano è cerchiato in un ovale arancione)
Inseriamo la SIM con i contatti rivolti verso il circuito stampato, l'angolo smussato nella foto è indicato dalla freccia.

Successivamente, eseguiamo la stessa procedura con il LED sulla scheda Arduino (ovale a sinistra del chip quadrato),
Saldando una striscia a quattro contatti (1),
Prendiamo due resistori da 20k, torciamo i pin da un lato, saldiamo la torsione nel foro di contatto A5, i pin rimanenti in RAW e GND dell'Arduino (2),
Accorciamo i pin del fotoreistor a 10mm e li saldiamo ai pin GND e D2 della scheda (3).

Ora è il momento di nastro adesivo biadesivo — lo incolliamo sul supporto della SIM del modulo di comunicazione, e sopra — Arduino — il pulsante rosso (argentato) è rivolto verso di noi e si trova sopra la SIM.

Saldando l'alimentazione: il positivo del condensatore del modulo di comunicazione (4) al pin RAW dell'Arduino.
Il fatto è che il modulo di comunicazione richiede un'alimentazione di 3.4-4.2V, e il suo pin PWR è collegato a un convertitore step-down, quindi per funzionare da li-ion bisogna fornire la tensione bypassando questa parte del circuito.

Dall'altra parte, sull'Arduino forniamo l'alimentazione tramite un convertitore lineare — a bassi consumi, la caduta di tensione (drop-out) è di 0.1V.
Invece fornendo tensione stabilizzata ai moduli HX711, ci liberiamo dalla necessità di rielaborarli per un voltaggio più basso (e allo stesso tempo dall'aumento di rumore a causa di questa operazione).

Poi saldiamo dei ponticelli (5) tra i contatti PWR-A1, URX-D4 e UTX-D5, la 'terra' GND-G (6) e infine l'alimentazione dal supporto per batterie 18650 (7), colleghiamo l'antenna (8).
Ora prendiamo un convertitore USB-TTL e colleghiamo con fili Dupont all'ARDUINO (striscia 1) i pin RXD-TXD e TXD-RXD, GND-GND:

Nella foto sopra — la prima versione (su tre) del sistema, utilizzata per il debugging.

E ora ci allontaniamo per un momento dal saldatore e passiamo alla parte software.
Descriverò la sequenza di azioni per Windows:
Innanzitutto, è necessario scaricare e installare/decomprimere il programma Arduino IDE — versione attuale — 1.8.9, ma io uso la 1.6.4

Per semplificare, decomprimiamo l'archivio nella cartella C:arduino-«numero_della_tua_versione», all'interno avremo le cartelle /dist, drivers, examples, hardware, java, lib, libraries, reference, tools, e anche il file eseguibile arduino (oltre a molti altri).

Ora ci servirà una libreria per lavorare con l'ADC HX711 — pulsante verde «clone or download» — download ZIP.
Il contenuto (cartella HX711-master) va nella directory C:arduino-«numero_della_tua_versione»libraries

E naturalmente un driver per USB-TTL dallo stesso github — dall'archivio decompresso si avvia semplicemente il file di installazione SETUP.

Ok, avviamo e configuriamo il programma C:arduino-«numero_della_tua_versione»arduino

Accediamo alla voce «Strumenti»-selezioniamo la scheda «Arduino Pro o Pro Mini», processore Atmega 328 3.3V 8 MHz, porta — numero diverso da COM1 di sistema (che appare dopo aver installato il driver CH340 con l'adattatore USB-TTL collegato)

Ok, copiamo il seguente sketch (programma) e lo incolliamo nella finestra dell'Arduino IDE

char phone_no[]="+123456789012"; // Your phone number that receive SMS with counry code 
#include <avr/sleep.h>  // ARDUINO sleep mode library
#include <SoftwareSerial.h> // Sofrware serial library
#include "HX711.h" // HX711 lib. https://github.com/bogde/HX711
#include <EEPROM.h> // EEPROM lib.
HX711 scale0(10, 14);
HX711 scale1(11, 14);
HX711 scale2(12, 14);
#define SENSORCNT 3
HX711 *scale[SENSORCNT];

SoftwareSerial mySerial(5, 4); // Set I/O-port TXD, RXD of GSM-shield  
byte pin2sleep=15; //  Set powerON/OFF pin

float delta00; // delta weight from start
float delta10;
float delta20;
float delta01; // delta weight from yesterday
float delta11;
float delta21;

float raw00; //raw data from sensors on first start
float raw10;
float raw20;
float raw01; //raw data from sensors on yesterday
float raw11;
float raw21;
float raw02; //actual raw data from sensors
float raw12;
float raw22;

word calibrate0=20880; //calibration factor for each sensor
word calibrate1=20880;
word calibrate2=20880;

word daynum=0; //numbers of day after start

int notsunset=0;

boolean setZero=false;

float readVcc() { // Read battery voltage function
  long result1000;
  float rvcc;  
  result1000 = analogRead(A5);
  rvcc=result1000;
  rvcc=6.6*rvcc/1023;
  return rvcc;
}

void setup() { // Setup part run once, at start

  pinMode(13, OUTPUT);  // Led pin init
  pinMode(2, INPUT_PULLUP); // Set pullup voltage
  Serial.begin(9600);
  mySerial.begin(115200); // Open Software Serial port to work with GSM-shield
  pinMode(pin2sleep, OUTPUT);// Itit ON/OFF pin for GSM
  digitalWrite(pin2sleep, LOW); // Turn ON modem
  delay(16000); // Wait for its boot 

scale[0] = &scale0; //init scale
scale[1] = &scale1;
scale[2] = &scale2;

scale0.set_scale();
scale1.set_scale();
scale2.set_scale();

delay(200);

setZero=digitalRead(2);

if (EEPROM.read(500)==EEPROM.read(501) || setZero) // first boot/reset with hiding photoresistor
//if (setZero)
{
raw00=scale0.get_units(16); //read data from scales
raw10=scale1.get_units(16);
raw20=scale2.get_units(16);
EEPROM.put(500, raw00); //write data to eeprom
EEPROM.put(504, raw10);
EEPROM.put(508, raw20);
for (int i = 0; i <= 24; i++) { //blinking LED13 on reset/first boot
    digitalWrite(13, HIGH);
    delay(500);
    digitalWrite(13, LOW);
    delay(500);
  }
}
else {
EEPROM.get(500, raw00); // read data from eeprom after battery change
EEPROM.get(504, raw10);
EEPROM.get(508, raw20);
digitalWrite(13, HIGH); // turn on LED 13 on 12sec. 
    delay(12000);
digitalWrite(13, LOW);
}

delay(200); // Test SMS at initial boot

//
  mySerial.println("AT+CMGF=1");    //  Send SMS part
  delay(2000);
  mySerial.print("AT+CMGS="");
  mySerial.print(phone_no); 
  mySerial.write(0x22);
  mySerial.write(0x0D);  // hex equivalent of Carraige return    
  mySerial.write(0x0A);  // hex equivalent of newline
  delay(2000);
  mySerial.println("INITIAL BOOT OK");
  mySerial.print("V Bat= ");
  mySerial.println(readVcc());
 if (readVcc()<3.5) {mySerial.print("!!! CHARGE BATTERY !!!");}
  delay(500);
  mySerial.println (char(26));//the ASCII code of the ctrl+z is 26
  delay(3000);

//  

raw02=raw00;
raw12=raw10;
raw22=raw20;

//scale0.power_down(); //power down all scales 
//scale1.power_down();
//scale2.power_down();

}

void loop() {

  attachInterrupt(0, NULL , RISING); // Interrupt on high lewel
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); //Set ARDUINO sleep mode
  digitalWrite(pin2sleep, HIGH); // Turn OFF GSM-shield
  delay(2200);
  digitalWrite(pin2sleep, LOW); // Turn OFF GSM-shield
  delay(2200);
  digitalWrite(pin2sleep, HIGH);
  digitalWrite(13, LOW);
  scale0.power_down(); //power down all scales 
  scale1.power_down();
  scale2.power_down();
  delay(90000);
  sleep_mode(); // Go to sleep
  detachInterrupt(digitalPinToInterrupt(0)); // turn off external interrupt

  notsunset=0;
 for (int i=0; i <= 250; i++){
      if ( !digitalRead(2) ){ notsunset++; } //is a really sunset now? you shure?
      delay(360);
   }
  if ( notsunset==0 )
  { 
  digitalWrite(13, HIGH);
  digitalWrite(pin2sleep, LOW); // Turn-ON GSM-shield
  scale0.power_up(); //power up all scales 
  scale1.power_up();
  scale2.power_up();
  raw01=raw02;
  raw11=raw12;
  raw21=raw22;
  raw02=scale0.get_units(16); //read data from scales
  raw12=scale1.get_units(16);
  raw22=scale2.get_units(16);

  daynum++; 
  delta00=(raw02-raw00)/calibrate0; // calculate weight changes 
  delta01=(raw02-raw01)/calibrate0;
  delta10=(raw12-raw10)/calibrate1;
  delta11=(raw12-raw11)/calibrate1; 
  delta20=(raw22-raw20)/calibrate2;
  delta21=(raw22-raw21)/calibrate2;

  delay(16000);
  mySerial.println("AT+CMGF=1");    //  Send SMS part
  delay(2000);
  mySerial.print("AT+CMGS="");
  mySerial.print(phone_no); 
  mySerial.write(0x22);
  mySerial.write(0x0D);  // hex equivalent of Carraige return    
  mySerial.write(0x0A);  // hex equivalent of newline
  delay(2000);
  mySerial.print("Turn ");
  mySerial.println(daynum);
  mySerial.print("Hive1  ");
  mySerial.print(delta01);
  mySerial.print("   ");
  mySerial.println(delta00);
  mySerial.print("Hive2  ");
  mySerial.print(delta11);
  mySerial.print("   ");
  mySerial.println(delta10);
  mySerial.print("Hive3 ");
  mySerial.print(delta21);
  mySerial.print("   ");
  mySerial.println(delta20);

  mySerial.print("V Bat= ");
  mySerial.println(readVcc());
  if (readVcc()<3.5) {mySerial.print("!!! CHARGE BATTERY !!!");}
  delay(500);
  mySerial.println (char(26));//the ASCII code of the ctrl+z is 26
  delay(3000);

  }

}

Nella prima riga, tra virgolette char phone_no[]=»+123456789012″; — al posto di 123456789012 mettiamo il nostro numero di telefono con il prefisso internazionale, a cui arriveranno gli SMS.

Ora premiamo il pulsante di verifica (sopra il numero uno nello screenshot sopra) — se in basso (sotto il tre nello screenshot) compare «Compilazione completata» — possiamo caricare il firmware nel microcontrollore.

Così, USB-TTL collegato ad ARDUINO e al computer, inseriamo una batteria carica nel supporto (di solito sulla nuova Arduino inizia a lampeggiare un LED con una frequenza di un secondo).

Ora il caricamento — alleniamoci a premere il pulsante rosso (argentato) del microcontrollore — dovremo farlo esattamente in un momento prestabilito!!!
C'è? Premi il pulsante «Carica» (sopra il numero due nello screenshot) e guarda attentamente la riga in basso nell'interfaccia (sotto il tre dello schermo).
Appena la scritta «compilazione» cambia in «caricamento» — premi il pulsante rosso (reset) — se tutto va bene — sul adattatore USB-TTL lampeggeranno felici le luci, e in basso nell'interfaccia comparirà la scritta «Caricati»

Ora, mentre aspettiamo l'arrivo dell'SMS di test sul telefono, ti spiegherò come funziona il programma:

Nella foto — la seconda versione del banco di prova.

Al primo avvio, il sistema confronta i byte numero 500 e 501 dell'EEPROM; se sono uguali, significa che i dati di calibrazione non sono stati registrati e l'algoritmo passa alla sezione di configurazione.
Lo stesso accade se il fotoresistore è coperto (con il cappuccio di una penna) all'accensione: si attiva la modalità di ripristino dei parametri.

I sensori di peso devono già essere installati sotto gli alveari, poiché registriamo semplicemente il livello iniziale di zero e poi misuriamo la variazione del peso (ora riceveremo solo zeri, poiché non abbiamo ancora collegato nulla).
Sull'Arduino inizierà a lampeggiare il LED integrato del pin 13.
Se non avviene il ripristino, il LED si accende per 12 secondi.
Dopo di che, viene inviata un SMS di test con il messaggio "INITIAL BOOT OK" e la tensione della batteria.
Il modulo di comunicazione si spegne e dopo 3 minuti la scheda Arduino mette le schede ADC HX711 in modalità sleep e si addormenta.
Questo ritardo è stato impostato per non captare interferenze dal modulo GSM in funzione (dopo lo spegnimento, emette interferenze per un certo periodo).

Successivamente, abbiamo un'interruzione dal fotoresistore al secondo pin (è attivato il pull-up positivo con la funzione pullup).
Dopo l'attivazione, per ulteriori 3 minuti viene controllato lo stato del fotoresistore, per escludere attivazioni ripetute/falsi allarmi.
Curiosamente, senza alcuna regolazione, il sistema si attiva 10 minuti dopo il tramonto astronomico in condizioni di tempo nuvoloso e dopo 20 minuti in condizioni di tempo sereno.
Sì, per evitare che il sistema effettui un ripristino ad ogni accensione, deve essere collegato almeno il primo modulo HX711 (pin DT-D10, SCK-A0).

Successivamente vengono letti i valori dai sensori di peso, si calcola la variazione del peso rispetto all'attivazione precedente (il primo numero nella riga dopo Hive) e dall'accensione iniziale, si controlla la tensione della batteria e queste informazioni vengono inviate via SMS:

A proposito, hai ricevuto l'SMS? Congratulazioni! Siamo a metà strada! Puoi rimuovere la batteria dal supporto; il computer non ci servirà più.

A proposito, il centro di controllo del volo è stato realizzato in modo così compatto che può essere contenuto in un barattolo di maionese; nel mio caso, si è rivelata perfetta una scatola semitrasparente di dimensioni 30x60x100mm (per biglietti da visita).

Sì, il sistema in standby consuma circa 2.3mA, principalmente a causa del modulo di comunicazione, che non si spegne completamente, ma passa in modalità attesa.

Iniziamo a fabbricare i sensori; per prima cosa esaminiamo lo schema di posizionamento dei sensori:

Questo è il piano dell'alveare - vista dall'alto.

In modo classico, vengono installati 4 sensori agli angoli (1, 2, 3, 4)

Misureremo in modo diverso. Anzi, in modo addirittura differente. Poiché i ragazzi di BroodMinder fanno diversamente:

In questa configurazione, i sensori sono installati nelle posizioni 1 e 2, i punti 3 e 4 si appoggiano su una trave.
In questo modo, sui sensori grava solo metà del peso.
Sì, questo metodo ha una minore precisione, ma è difficile immaginare che le api riempiano tutte le cornici con "lingue" di cera lungo un unico lato dell'arnia.

Quindi, propongo di ridurre i sensori al punto 5: in questo modo non è necessaria schermatura del sistema e, usando arnie leggere, si può tranquillamente utilizzare un solo sensore.

In generale, sono stati testati due tipi di moduli con HX711, due tipi di sensori e due varianti di connessione — con un ponte completo di Wheatstone (2 sensori) e con uno parziale, dove la seconda parte è integrata con resistori da 1k con tolleranza dello 0,1%.
Ma l'ultimo metodo è indesiderato e non raccomandato nemmeno dai produttori di sensori, quindi descriverò solo il primo.

Dunque, su un'arnia installeremo due sensori di tensione e un modulo HX711; lo schema di cablaggio è il seguente:

Dal circuito ADC all'Arduino ci sono 5 metri di cavo telefonico a 4 fili — ricordiamo come le api non amino i dispositivi GSM nell'arnia..

In generale, lasciamo "cavi" dai sensori lunghi 8 cm, speliamo la coppia intrecciata e cabliamo tutto come nella foto sopra.

Prima di iniziare la parte in legno, mettiamo la cera/paraffina in un contenitore adeguato a sciogliersi a bagnomaria.

Adesso prendiamo la nostra trave e la dividiamo in tre segmenti di 100 mm.

Poi tracciamo una scanalatura longitudinale larga 25 mm e profonda 7-8 mm; con un seghetto e uno scalpello rimuoviamo l'eccesso — deve venire un profilo a forma di P.

La cera si è sciolta? — immergiamo le nostre schede ADC in essa — questo le proteggerà dall'umidità/dal vapore:

Posizioniamo tutto su una base di legno (necessario trattarla con un antisettico contro la decomposizione):

E infine, fissiamo i sensori con le viti autofilettanti:

C'era anche un'opzione con nastro adesivo blu, ma per motivi di umanità non la riporto 😉

Dalla parte di Arduino facciamo quanto segue:

Speliamo i nostri cavi telefonici, attorcigliamo i fili colorati tra loro e saldiamo.

Dopo di che, saldiamo ai contatti della scheda come nella foto:

Tutto, ora per la verifica finale, posizioniamo i sensori nei settori del cerchio, sopra — un pezzo di compensato, azzeriamo il controller (mettiamo la batteria con il cappuccio della penna sul fotodiodo).

Il LED su Arduino deve lampeggiare e riceverai un SMS di prova.

Poi rimuoviamo il cappuccio dal fotosensore e andiamo a riempire una bottiglia di plastica da 1,5 litri con acqua.
Posizioniamo la bottiglia su un pannello di compensato e, se sono già passati alcuni minuti dall'accensione, rimettiamo il cappuccio sul fotoreattore (imitando un tramonto).

Dopo tre minuti, il LED su Arduino si accenderà e dovresti ricevere un SMS con valori di peso di circa 1 kg su tutte le posizioni.

Congratulazioni! Il sistema è stato assemblato con successo!

Se ora costringi il sistema a funzionare di nuovo, nella prima colonna del peso appariranno zero.

Sì, nelle condizioni reali, è preferibile orientare il fotoreattore verticalmente verso l'alto.

Ora fornirò una breve guida all'uso:

Installare i sensori di peso sotto le pareti posteriori degli alveari (per quelle anteriori inserire una barra/una tavola spessa ~30mm)
Ombreggiare il fotoreattore e posizionare la batteria: il LED deve lampeggiare e dovresti ricevere un SMS di prova con il testo «INITIAL BOOT OK»
Posizionare l'unità centrale alla massima distanza dagli alveari e in modo che i cavi non siano d'intralcio durante il lavoro con le api.
Ogni sera, dopo il tramonto, sarà inviato un SMS con la variazione di peso delle ultime 24 ore e da quando è stato avviato.
Quando la tensione della batteria raggiunge i 3,5V, l'SMS si concluderà con la frase «!!! CHARGE BATTERY !!!»
Il tempo di funzionamento con una batteria da 2600mAh è di circa un mese.
In caso di sostituzione della batteria, le variazioni di peso giornaliere degli alveari non saranno memorizzate.