🥇Monitoraggio SMS del peso di tre arnie a 30$

No, non si tratta di una proposta commerciale, questa è la spesa per i componenti del sistema che potrai assemblare dopo aver letto l'articolo.

Un po' di contesto:

Qualche tempo fa ho deciso di iniziare a fare apicoltura, e finalmente ho ottenuto le api... per un'intera stagione, ma non sono uscite dall'inverno.
E questo nonostante avessi seguito tutte le procedure corrette: nutrimento autunnale e isolamento prima del freddo.
L'alveare era un classico modello in legno 'Dadant' a 10 telai realizzato con assi di 40 mm.
Ma in quell'inverno, a causa delle 'oscillazioni' di temperatura, anche gli apicoltori esperti hanno subito perdite significativamente più alte del solito.

Così è nata l'idea di un sistema per monitorare lo stato dell'alveare.
Dopo aver pubblicato diversi articoli su Habr e aver interagito nei forum di apicoltura, ho deciso di partire da soluzioni semplici per arrivare a quelle più complesse.
Il peso è l'unico parametro indiscutibile, ma di solito i sistemi esistenti monitorano solo un 'alveare di riferimento'.
Se vi è un problema (ad esempio un'uscita di sciame, una malattia delle api), i dati non sono più rilevanti.

Pertanto, ho deciso di monitorare la variazione di peso di tre alveari contemporaneamente con un microcontrollore, e aggiungere le altre 'funzionalità' in seguito.
Il risultato è stato un sistema autonomo con un'autonomia di circa un mese con una sola carica della batteria 18650, che invia statistiche una volta al giorno.
Ho cercato di semplificare la struttura il più possibile, affinché potesse essere replicata anche senza schemi, seguendo solo le foto.

La logica di funzionamento è la seguente: al primo avvio o ripristino, i dati dei sensori installati sotto le arnie vengono memorizzati nella EEPROM.
Poi, ogni giorno, dopo il tramonto, il sistema si 'sveglia', legge i dati e invia un SMS con la variazione di peso delle ultime 24 ore e dalla momentanea accensione.
Inoltre, viene trasmesso il valore della tensione della batteria e, se scende sotto i 3,5 V, viene inviato un avviso di necessità di ricarica, poiché al di sotto di 3,4 V il modulo di comunicazione non si accende e anche le letture del peso diventano imprecise.

«Ricordi come tutto è iniziato. Tutto era nuovo e di nuovo.»

Sì, questo era esattamente il set di 'hardware' iniziale, anche se solo i sensori di tensione e i cavi sono sopravvissuti fino alla versione finale, ma andiamo con ordine.
In realtà, il rotolo di cavo non sarà necessario, ma costava esattamente come 30 metri a taglio.

Se non ti spaventa smontare 3 LED SMD e una cinquantina di punti di saldatura normale, allora sei sulla strada giusta!

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

Arduino Pro Mini 3V
Si noti il chip del convertitore lineare — deve essere precisamente a 3.3V — sul chip con la marcatura KB 33/LB 33/DE A10 — ho avuto problemi con i cinesi, e tutta la partita
di schede nel negozio si è rivelata con regolatori da 5 volt e cristalli da 16 MHz.
USB-Ttl con chip CH340 — può andare anche quello da 5 volt, ma durante il flashing del microcontrollore, sarà necessario scollegare Arduino dal modulo GSM per non 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 questo? Neoway M590 — è un costruttore che richiede configurazioni particolari, il GSM SIM800L — non mi piaceva il livello logico non standard di 2.8V, che richiede un'interfaccia anche con Arduino a tre volt.
Inoltre, la soluzione di AiThinker ha un consumo energetico minimo (non ho mai visto un assorbimento superiore a 100mA durante l'invio di SMS).
Antenna GSM GPRS 3DBI (nella foto sopra — scheda rettangolare con "codina", a ore 9)
Pacchetto di avviamento dell'operatore che ha una buona copertura nel luogo in cui si trova il vostro apiario.
Sì, il pacchetto deve essere prima attivato su un normale telefono, DISATTIVARE LA RICHIESTA PIN all'accesso, e ricaricare il credito.
Attualmente ci sono molte opzioni con nomi nello stile di "Sensore", "IoT" — hanno una tariffa mensile leggermente inferiore.
Cavo dupont 20cm femmina-femmin
3 pezzi di HX711 — ADC per bilance.
6 celle di carico per pesi fino a 50kg.
15 metri di cavo telefonico a 4 fili — per collegare i moduli di peso all'ARDUINO.
Fotorisistor GL5528 (importante esattamente questo, con resistenza al buio di 1MΩ e resistenza alla luce di 10-20kΩ) e due normali resistori da 20k.
Pezzetto di nastro biadesivo "spesso" 18x18mm — per fissare l'arduino al modulo di comunicazione.
Porta batterie 18650 e, naturalmente, la batteria stessa ~2600mAh.
Un po' di cera o paraffina (candela a pastiglia per aromaterapia) — per la protezione contro l'umidità dell'HX711.
Un pezzo di legno 25x50x300mm per la base delle celle di carico.
Una dozzina di viti autofilettanti con rondella da 4,2x19 mm per fissare i sensori alla base.

La batteria può essere presa da laptop di recupero — è molto più economica di una nuova e la capacità sarà molto maggiore rispetto alla cinese UltraFire — io ho ottenuto 1500 contro 450 (quella del fuoco è 6800 😉.

Inoltre, serviranno mani abili, un saldatore EPSN-25, colofonia e stagno POS-60.

Cinque anni fa usavo un saldatore sovietico con punta in rame (non sono mai riuscito a farmi piacere le stazioni di saldatura — ne ho provata una, ma ho sempre finito col saldare con l'EPSN).
Ma dopo che si è rotto e diversi mostri cinesi hanno fatto la loro comparsa, l'ultimo era chiamato Sparta — una cosa tanto dura quanto il nome, mi sono fermato
su un dispositivo con regolatore di temperatura.

Eccoci!

Per prima cosa, saldiamo due LED dal modulo GSM (il posto dove si trovavano è cerchiato in un ovale arancione)
Inseriamo la SIM con i contatti rivolti verso il circuito stampato, l'angolo smussato nella foto è contrassegnato con una freccia.

Poi facciamo la stessa procedura con il LED sulla scheda Arduino (ovale a sinistra del chip quadrato),
Saldamo un connettore a quattro pin (1),
Prendiamo due resistori da 20k, pieghiamo i contatti da un lato, saldiamo la giuntura nel foro del pin A5, gli altri contatti su RAW e GND della Arduino (2),
Accorciamo i pin del fotoresistore a 10 mm e lo saldiamo ai contatti GND e D2 della scheda (3).

È ora di usare il nastro biadesivo blu: fissiamolo sul supporto della SIM del modulo di comunicazione, e sopra di esso — l'Arduino — il pulsante rosso (o argentato) deve essere rivolto verso di noi e posizionato sopra la SIM.

Saldare l'alimentazione: il positivo dal condensatore del modulo di comunicazione (4) al contatto RAW dell'Arduino.
Il fatto è che il modulo di comunicazione richiede un'alimentazione di 3,4-4,2V, e il suo contatto PWR è collegato a un convertitore step-down, quindi per alimentarlo con batteria li-ion è necessario bypassare questa parte del circuito.

Nell'Arduino, invece, alimentiamo tramite un convertitore lineare — a basse correnti di consumo, la caduta di tensione drop-out è di 0,1V.
Tuttavia, fornendo una tensione stabilizzata ai moduli HX711, eliminiamo la necessità di modificarli per una tensione più bassa (e allo stesso tempo riduciamo i rumori derivanti da tale operazione).

Successivamente, saldiamo i ponticelli (5) tra i contatti PWR-A1, URX-D4 e UTX-D5, il ‘terra’ GND-G (6) e infine l'alimentazione dal supporto delle batterie 18650 (7), collegando l'antenna (8).
Ora prendiamo il convertitore USB-TTL e colleghiamo con fili Dupont ai contatti RXD-TXD e TXD-RXD di ARDUINO (header 1), GND-GND:

Nella foto sopra c'è la prima versione (su tre) del sistema utilizzato per il debug.

Ora ci allontaneremo per un po' dal saldatore e passeremo alla parte software.
Descriverò la sequenza di azioni per Windows:
Innanzitutto, è necessario scaricare e installare/estrarre il programma Arduino IDE — la versione attuale è 1.8.9, ma io utilizzo la 1.6.4.

Per comodità, estraiamo l'archivio nella cartella C:arduino-«numero_tua_versione», all'interno troveremo le cartelle /dist, drivers, examples, hardware, java, lib, libraries, reference, tools, e anche il file eseguibile arduino (oltre ad altri).

Ora avremo bisogno di una libreria per lavorare con l'ADC HX711 — il pulsante verde "clone or download" — download ZIP.
Il contenuto (la cartella HX711-master) va nella directory C:arduino-«numero_tua_versione»libraries.

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

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

Andiamo alla voce "Strumenti" - selezioniamo la scheda "Arduino Pro o Pro Mini", il processore Atmega 328 3.3V 8 MHz, porta — numero diverso da COM1 di sistema (questo appare dopo l'installazione del driver CH340 quando è collegato l'adattatore USB-TTL).

Ok, copiamo il seguente sketch (programma) e incolliamolo nella finestra di 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 inseriamo il nostro numero di telefono con il prefisso internazionale al quale arriveranno gli SMS.

Ora premiamo il tasto di verifica (sopra il numero uno nello screenshot sopra) — se in basso (sotto il tre nello schermo) appare "Compilazione completata" — possiamo procedere a caricare il firmware nel microcontrollore.

Quindi, USB-TTL è connesso ad ARDUINO e al computer, inseriamo la batteria carica nel supporto (di solito su una nuova Arduino il LED inizia a lampeggiare con una frequenza di un secondo).

Ora per il caricamento — pratichiamo a premere il pulsante rosso (argentato) del microcontrollore — questo deve essere fatto esattamente in un momento preciso!!!
Fatto? Premiamo il pulsante "Carica" (sopra il numero due nello screenshot) e guardiamo attentamente la riga in basso nell'interfaccia (sotto il tre dello schermo).
Appena la scritta "compilazione" cambia in "caricamento" — premiamo il pulsante rosso (reset) — se tutto è ok — le luci sul adattatore USB-TTL lampeggiano felici, e in basso nell'interfaccia appare la scritta "Caricato".

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

Nella foto è mostrata la seconda versione del banco di prova.

Alla prima accensione, il sistema confronta i byte numero 500 e 501 dell'EEPROM; se sono uguali, significa che i dati di calibrazione non sono stati scritti e l'algoritmo passa alla sezione di configurazione.
La stessa cosa accade se al momento dell'accensione il fotodiodo è coperto (con il tappo di una penna) — si attiva la modalità di reset dei parametri.

I sensori di pressione devono già essere installati sotto gli alveari, poiché registriamo semplicemente il livello iniziale di zero e poi misuriamo il cambiamento di peso (per ora arriveranno solo zeri, poiché non abbiamo ancora collegato nulla).
Su Arduino, in questo caso, inizierà a lampeggiare il LED integrato del pin 13.
Se il reset non avviene, il LED si accende per 12 secondi.
Successivamente, 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 a sua volta.
Questo ritardo è stato impostato per non ricevere interferenze dal modulo GSM in funzione (dopo lo spegnimento, continua a 'fondere' per un po').

In seguito, abbiamo un'interruzione attivata dal fotodiodo sul secondo pin (è attivato il pull-up del positivo tramite la funzione pullup).
Dopo l'attivazione, il fotoreistore viene controllato per altri 3 minuti per escludere attivazioni duplicate o errate.
È interessante notare che, senza alcuna regolazione, il sistema si attiva 10 minuti dopo il tramonto astronomico in condizioni nuvoled, e 20 minuti in un cielo sereno.
Sì, per evitare che il sistema venga ripristinato ad ogni accensione, deve essere connesso almeno il primo modulo HX711 (pini DT-D10, SCK-A0).

Poi vengono rilevati i valori dai trasduttori di peso, si calcola la variazione del peso dall'attivazione precedente (il primo numero nella riga dopo Hive) e dal primo avvio, si verifica la tensione della batteria e queste informazioni vengono inviate via SMS:

A proposito, hai ricevuto l'SMS? Congratulazioni! Siamo a metà strada! La batteria può essere rimossa dal supporto, il computer non ci serve più.

A proposito, il centro di controllo voli è risultata così compatto che può stare in un barattolo di maionese; nel mio caso, ho usato una scatoletta trasparente di 30x60x100mm (da biglietti da visita).

Sì, il sistema in sonno consuma circa 2.3 mA, il 90% dei quali è dovuto al modulo di comunicazione, che non si spegne completamente ma passa in modalità standby.

Iniziamo a produrre i sensori, iniziamo con lo schema di posizionamento dei sensori:

Questo è il piano dell'arnia — vista dall'alto.

Tradizionalmente, si installano 4 sensori agli angoli (1,2,3,4)

Noi misureremo in modo diverso. Anzi, in realtà in un terzo modo. Poiché in un altro modo operano i ragazzi di BroodMinder:

In questa costruzione, i sensori sono posizionati nei punti 1 e 2, i punti 3 e 4 si basano su un travetto.
Quindi sui sensori graverebbe solo metà del peso.
Sì, questo metodo ha una minore precisione, ma è difficile immaginare che le api costruiscano tutte le cornici con "linguette" di cera lungo un solo lato dell'arnia.

Dunque, propongo di ridurre completamente i sensori al punto 5 — così non c'è bisogno di schermare il sistema, e usando arnie leggere ci si può addirittura accontentare di un solo sensore.

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

Quindi, su un alveare installeremo due celle di carico e un modulo HX711, lo schema di cablaggio è il seguente:

Dal circuito ADC all'Arduino c'è un cavo telefonico a 4 fili lungo 5 metri — dobbiamo ricordarci che le api non amano i dispositivi GSM nell'alveare..

In generale, lasciamo «coda» di 8 cm sui sensori, spelliamo la coppia intrecciata e cabliamo tutto come nella foto sopra.

Prima di iniziare la parte di falegnameria, posizioniamo la cera/paraffina in un contenitore adatto a fondere a bagnomaria.

Ora prendiamo il nostro blocco e lo dividiamo in tre segmenti di 100 mm.

Poi segniamo una scanalatura longitudinale di larghezza 25 mm e profondità di 7-8 mm, rimuoviamo il superfluo con una sega e uno scalpello: deve risultare un profilo a p.

La cera è calda? — Immergiamo le nostre schede ADC — questo le proteggerà dall'umidità/nebbia:

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

E infine, fissiamo i sensori con delle 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:

Spelliamo i nostri cavi telefonici, torciamo i fili colorati tra loro, saldiamo.

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

Ora, per l'ultima verifica, posizioniamo i sensori nei settori del cerchio, sopra mettiamo un pezzo di compensato, azzeriamo il controller (mettiamo la batteria con il cappuccio della penna sopra il fotodiodo).

In questo modo il LED sulla scheda Arduino dovrebbe lampeggiare e riceverai un SMS di test.

Dopo, rimuoviamo il cappuccio dal fotoresistore e andiamo a riempire una bottiglia di plastica da 1,5 litri d'acqua.
Mettiamo la bottiglia sul compensato e se sono già passati alcuni minuti dall'accensione, rimettiamo il cappuccio sul fotoresistore (simulando il tramonto).

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

Congratulazioni! Il sistema è stato assemblato con successo!

Se ora facciamo attivare nuovamente il sistema, la prima colonna dei pesi mostrerà zeri.

Sì, in condizioni reali è preferibile orientare il fotoresistore verticalmente verso l'alto.

Ora fornirò una breve guida all'uso:

Installare i sensori di peso sotto le pareti posteriori degli alveari (sotto le pareti anteriori posizionare un pezzo di legno/spessore di circa 30 mm).
Riparare il fotoresistore e posizionare la batteria — il LED dovrebbe lampeggiare e riceverai un SMS di test con il testo "INITIAL BOOT OK".
Posizionare il blocco centrale il più lontano possibile dagli alveari e in modo che i cavi non intralcino il lavoro con le api.
Ogni sera, dopo il tramonto, verrà inviato un SMS con il cambiamento di peso della giornata e da quando è stato avviato.
Quando la tensione della batteria raggiunge il valore di 3,5 V, l'SMS si concluderà con la frase «!!! CARICARE LA BATTERIA !!!»
Il tempo di funzionamento con una batteria da 2600 mAh è di circa un mese.
In caso di sostituzione della batteria, le variazioni giornaliere di peso degli alveari non vengono memorizzate.