🥇SMS-Überwachung des Gewichts von drei Bienenstöcken für 30 $

Nein, dies ist kein kommerzielles Angebot, sondern der Preis der Systemkomponenten, die Sie nach dem Lesen des Artikels zusammenstellen können.

Ein wenig Hintergrundgeschichte:

Vor einiger Zeit beschloss ich, Bienen zu halten, und sie tauchten tatsächlich auf... für eine ganze Saison, aber sie überstanden den Winter nicht.
Und das trotz der Tatsache, dass ich anscheinend alles richtig gemacht habe — Herbstfütterung, Isolierung vor der Kälte.
Der Bienenstock war ein klassischer Holz-Bienenstock des Typs "Dadant" mit 10 Waben aus 40-mm-Platten.
Aber in diesem Winter verloren selbst erfahrene Imker aufgrund der Temperaturschwankungen weit mehr als gewöhnlich.

So entstand die Idee eines Überwachungssystems für den Zustand des Bienenstocks.
Nach der Veröffentlichung mehrerer Artikel auf Habr und dem Austausch im Forum der Imker beschloss ich, von einfach zu komplex zu arbeiten.
Das Gewicht ist der einzige unumstrittene Parameter, aber in der Regel überwachen die bestehenden Systeme nur einen 'Sprichwort'-Bienenstock.
Wenn mit diesem etwas nicht stimmt (zum Beispiel ein Schwarmabgang, Krankheiten der Bienen), werden die Werte irrelevant.

Deshalb wurde entschieden, die Gewichtsentwicklung von drei Bienenstöcken gleichzeitig mit einem Mikrocontroller zu überwachen, während die anderen 'Extras' später hinzugefügt werden.
Am Ende entstand ein autonomes System mit einer Betriebsdauer von etwa einem Monat mit einer einzigen Ladung der 18650-Batterie und dem Versand von Statistiken einmal täglich.
Ich versuchte, die Konstruktion so einfach wie möglich zu halten, damit sie sogar ohne Schaltpläne, nur anhand von Fotos, wiederholt werden kann.

Die Logik der Funktion ist wie folgt: Bei der ersten Inbetriebnahme/Rücksetzung werden die Sensorwerte, die unter den Bienenstöcken installiert sind, im EEPROM gespeichert.
Jeden Tag, nach Sonnenuntergang, 'erwacht' das System, liest die Werte aus und sendet eine SMS mit der Gewichtänderung seit dem letzten Tag und seit dem Moment der Aktivierung.
Außerdem wird der Wert der Batteriespannung übertragen, und wenn dieser auf 3,5 V sinkt, wird eine Warnung zur Aufladung ausgegeben, da der Kommunikationsmodul bei unter 3,4 V nicht aktiviert wird und auch die Gewichtswerte bereits 'verfälscht' werden.

„Du erinnerst dich, wie alles begann. Alles war erstmals und wieder.“

Ja, genau dieses Set an 'Hardware' war ursprünglich so, allerdings überlebten nur die Dehnungssensoren und Kabel bis zur Endversion, aber darüber später mehr.
In der Tat wird eine Kabelrolle nicht benötigt, sie war einfach im selben Preisrahmen wie 30 Meter fertig.

Wenn Sie keine Angst vor dem Ausbau von 3 SMD-LEDs und einem halben Dutzend herkömmlicher (Steck-)Lötpunkte haben, dann auf geht's!

Also, wir benötigen die folgende Ausrüstung/Materialien:

Arduino Pro Mini 3V
Es ist wichtig auf den Linearregler zu achten – er muss genau 3.3V haben – auf dem Chip mit der Kennzeichnung KB 33/LB 33/DE A10 – bei mir haben die Chinesen etwas durcheinandergebracht, und die gesamte Charge
von Platinen im Geschäft war mit 5-Volt-Reglern und Quarzen mit 16MHz.
USB-Ttl auf dem Chip CH340 – kann sogar 5-Volt sein, aber dann muss man während des Flashens des Mikrokontrollers Arduino vom GSM-Modul trennen, um das letztere nicht zu beschädigen.
Platinen mit dem Chip PL2303 funktionieren nicht unter Windows 10.
GSM Kommunikationsmodul Goouu Tech IOT GA-6-B oder AI-THINKER A-6 Mini.
Warum habe ich mich für dieses entschieden? Neoway M590 – ein Konstrukt, das spezielle Tanzen mit dem Tamburin erfordert, GSM SIM800L – hatte keinen Gefallen an der nicht-standardisierten 2.8V Logikpegel erforderlich, die selbst mit einer drei-Volt-Arduino abgestimmt werden muss.
Außerdem hat die Lösung von AiThinker einen minimalen Stromverbrauch (beim Senden von SMS habe ich keinen Strom über 100mA gesehen).
GSM GPRS Antenne 3DBI (auf dem obigen Foto – rechteckige Platine mit "Schwanz", um 9 Uhr)
Starterpaket eines Anbieters, der eine gute Abdeckung in der Gegend hat, wo Ihr Bienenhaus liegt.
Ja, das Paket muss zuerst auf einem normalen Telefon aktiviert werden, PIN-Anforderung beim Zugriff DEAKTIVIEREN und Guthaben aufladen.
Jetzt gibt es viele Optionen mit Namen wie „Sensor“, „IoT“ – diese haben etwas geringere monatliche Gebühren.
Dupont Kabel 20cm männlich-weiblich – 3 Stück (zum Anschluss des Arduino an USB-TTL)
3 Stück HX711 – ADC für Waagen
6 Dehnungssensoren für ein Gewicht von bis zu 50 kg
15 Meter 4-adriges Telefonkabel – zur Verbindung der Gewichtsmodule mit ARDUINO.
Fotowiderstand GL5528 (wichtig genau dieser, mit einem Dunkelwiderstand von 1MΩ und Lichtwiderstand von 10-20kΩ) und zwei normale Widerstände von 20k
Ein Stück doppelseitiges „dickes“ Klebeband 18x18mm – zur Befestigung des Arduino am Kommunikationsmodul.
Batteriehalter 18650 und etwas näher die Batterie ~2600mAh.
Ein wenig Wachs oder Paraffin (Teelicht für Aromalampe) – zum Schutz des HX711 gegen Feuchtigkeit.
Stück Holzblock 25x50x300mm für die Basis der Dehnungssensoren.
Ein Dutzend selbstschneidende Schrauben mit Unterlegscheibe 4,2x19 mm zur Befestigung der Sensoren an der Basis.

Die Batterie kann von Notebookreparaturen entnommen werden – deutlich günstiger als eine neue, und die Kapazität wird viel größer sein als bei der chinesischen UltraFire – ich habe 1500 gegen 450 erhalten (die des Feuers 6800 😉

Zusätzlich werden geschickte Hände, ein Lötkolben EPSN-25, Kolophonium und Lötzinn POS-60 benötigt.

Vor 5 Jahren benutzte ich einen sowjetischen Lötkolben mit einer Kupferspitze (Lötkolbenstationen gefielen mir nicht — ich testete sie und stellte dann das EPSN-Schema fertig).
Aber nach dem Ausfall und mehreren schrecklichen chinesischen Raubkopien, die letzte hieß Sparta — ein ebenso robustes Teil wie der Name, stoppte ich
bei einem Produkt mit Temperaturregler.

Los geht's!

Zuerst entlöten wir zwei LEDs aus dem GSM-Modul (der Platz, an dem sie waren, ist mit einem orangefarbenen Oval umrandet)
Die SIM-Karte setzen wir mit den Kontaktflächen zur Platine ein, die abgeschrägte Ecke auf dem Foto ist mit einem Pfeil gekennzeichnet.

Als Nächstes führen wir das gleiche Verfahren mit der LED auf der Arduino-Platine durch (Oval links vom quadratischen Chip),
Wir löten eine Buchse mit vier Kontakten (1)
Wir nehmen zwei Widerstände von 20k, verdrillen die Anschlüsse auf einer Seite und löten die Verdrillung in das Loch für den Kontakt A5, die verbleibenden Anschlüsse in RAW und GND von Arduino (2),
Der Fotowiderstand wird auf 10 mm gekürzt und an die Anschlüsse GND und D2 der Platine gelötet (3).

Jetzt ist es Zeit für das blaue Klebeband von doppelseitigem Klebeband — wir kleben es auf den Halter der SIM-Karte des Kommunikationsmoduls und oben darauf — Arduino — der rote (silberne) Knopf ist zu uns gerichtet und liegt über der SIM-Karte.

Wir löten die Stromversorgung: Plus von dem Kondensator des Kommunikationsmoduls (4) an den Kontakt RAW der Arduino.
Das liegt daran, dass das Modul selbst für seine Versorgung 3,4-4,2 V benötigt und sein Kontakt PWR auf einen Step-Down-Spannungswandler geführt wird. Daher muss die Spannung für den Betrieb von Li-Ion die Schaltung umgehen.

Bei Arduino hingegen speisen wir die Stromversorgung durch einen linearen Wandler — bei niedrigen Stromverbrauchswerten beträgt der Spannungsabfall bei dropout 0,1 V.
Da wir jedoch stabilisierte Spannung an die HX711-Module anlegen, entfällt die Notwendigkeit, sie für eine niedrigere Spannung zu modifizieren (und gleichzeitig wird das Rauschen durch diese Maßnahme verringert).

Dann löten wir Brücken (5) zwischen den Kontakten PWR-A1, URX-D4 und UTX-D5, „Erde“ GND-G (6) und schließlich die Stromversorgung vom Halter für 18650-Batterien (7), anschließend schließen wir die Antenne an (8).
Jetzt nehmen wir einen USB-TTL-Wandler und verbinden ihn mit Dupont-Kabeln mit der ARDUINO (Buchse 1) die Kontakte RXD-TXD und TXD-RXD, GND-GND:

Auf dem obigen Foto ist die erste Version (von drei) des Systems zu sehen, das zur Fehlerbehebung verwendet wurde.

Jetzt lenken wir für eine Weile von dem Lötkolben ab und gehen zum Softwareteil über.
Ich werde die Reihenfolge der Schritte für Windows beschreiben:
Zuerst müssen wir das Programm herunterladen und installieren/entpacken Arduino IDE — die aktuelle Version ist 1.8.9, ich benutze jedoch 1.6.4

Zur Vereinfachung entpacken wir das Archiv in den Ordner C:arduino-«Ihre_Version», darin befinden sich die Ordner /dist, drivers, examples, hardware, java, lib, libraries, reference, tools sowie die ausführbare Datei arduino (neben anderen).

Jetzt benötigen wir eine Bibliothek zur Arbeit mit dem ADC HX711 — der grüne Knopf „clone or download“ — download ZIP.
Der Inhalt (Ordner HX711-master) wird in das Verzeichnis C:arduino-«Ihre_Version»libraries gelegt

Und natürlich den Treiber für USB-TTL von demselben GitHub — aus dem entpackten Archiv wird einfach die Setup-Datei gestartet.

Ok, starten und konfigurieren wir das Programm C:arduino-«Ihre_Version»arduino

Gehen Sie zu „Werkzeuge“ - wählen Sie die Platine „Arduino Pro oder Pro Mini“, Prozessor Atmega 328 3.3V 8 MHz, Port — eine Nummer außer dem systemeigenen COM1 (dies erscheint nach der Installation des CH340 Treibers beim angeschlossenen USB-TTL Adapter)

Ok, kopieren Sie den folgenden Sketsch (Programm) und fügen Sie ihn in das Fenster der Arduino IDE ein

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

  }

}

In der ersten Zeile, in Anführungszeichen char phone_no[]=„+123456789012“; — anstelle von 123456789012 setzen wir unsere Telefonnummer mit der Landesvorwahl, an die die SMS gesendet werden.

Jetzt drücken wir die Überprüfen-Schaltfläche (über der Eins im obigen Screenshot) — wenn unten (unter der Drei im Screenshot) „Kompilierung abgeschlossen“ steht — können wir den Mikrocontroller programmieren.

So, USB-TTL ist mit ARDUINO und dem Computer verbunden, legen Sie den aufgeladenen Akku in das Halter (normalerweise beginnt bei neuen Arduino-Modellen die LED mit einer Frequenz von einmal pro Sekunde zu blinken).

Nun die Programmierung — wir üben das Drücken des roten (silbernen) Knopfes am Mikrocontroller — das muss genau im richtigen Moment gemacht werden!!!
Verstanden? Drücken Sie die Taste „Hochladen“ (über der Zwei im Screenshot), und schauen Sie aufmerksam auf die Zeile am unteren Rand der Schnittstelle (unter der Drei im Screenshot).
Sobald die Meldung „Kompilierung“ zu „Hochladen“ wechselt — drücken Sie den roten Knopf (Reset) — wenn alles in Ordnung ist — blitzen die Lichter am USB-TTL Adapter erfreulich auf, und unten in der Schnittstelle steht „Hochgeladen“

Jetzt, während wir auf die Ankunft der Test-SMS auf dem Telefon warten, erkläre ich, wie das Programm funktioniert:

Das Foto zeigt die zweite Version des Teststands.

Beim ersten Einschalten vergleicht das System die Bytes Nummer 500 und 501 im EEPROM, wenn sie gleich sind, bedeutet das, dass die Kalibrierungsdaten nicht gespeichert sind, und der Algorithmus wechselt zum Abschnitt der Einstellungen.
Das Gleiche passiert, wenn der Fotoresistor beim Einschalten beschattet ist (mit dem Kappen einer Kugelschreibers) – der Reset-Modus wird aktiviert.

Die Dehnungssensoren sollten bereits unter den Beuten installiert sein, da wir einfach den Anfangswert null fixieren und dann die Gewichtänderung messen (jetzt kommen einfach Nullen, da wir noch nichts angeschlossen haben).
Auf dem Arduino beginnt dabei die eingebaute LED an Pin 13 zu blinken.
Wenn kein Reset erfolgt, leuchtet die LED für 12 Sekunden.
Nach diesem wird eine Test-SMS mit der Nachricht „INITIAL BOOT OK“ und der Batteriespannung gesendet.
Das Kommunikationsmodul wird abgeschaltet, und nach 3 Minuten versetzt die Arduino-Platine die HX711-ADC-Platinen in den Schlafmodus und schläft selbst ein.
Diese Verzögerung wurde eingeführt, um keine Störungen durch den laufenden GSM-Modul zu empfangen (nach dem Ausschalten „brummt“ er eine Zeit lang).

Dann haben wir eine Unterbrechung durch den Lichtsensor am zweiten Pin (die Plusspannung wird durch die Pull-Up-Funktion gehalten).
Dabei wird nach der Auslösung noch 3 Minuten der Zustand des Fotoresistors überprüft – um wiederholte/falsche Auslösungen auszuschließen.
Bemerkenswert ist, dass das System ohne jegliche Einstellungen 10 Minuten nach dem astronomischen Sonnenuntergang bei bewölktem Wetter und 20 Minuten bei klarem Wetter auslöst.
Ja, um bei jedem Einschalten einen Reset zu vermeiden, muss mindestens das erste HX711-Modul (Pins DT-D10, SCK-A0) angeschlossen sein.

Dann werden die Werte der Dehnungssensoren erfasst, die Gewichtänderung seit der letzten Auslösung (die erste Zahl in der Zeile nach Hive) und seit dem ersten Einschalten berechnet, die Batteriespannung überprüft und diese Informationen werden als SMS gesendet:

Übrigens, haben Sie die SMS erhalten? Herzlichen Glückwunsch! Wir sind auf der Mitte des Weges! Die Batterie kann jetzt aus dem Halter entfernt werden, den Computer benötigen wir nicht mehr.

Übrigens, das Steuerzentrum hat sich als so kompakt herausgestellt, dass es in ein Mayonnaise-Glas passt; in meinem Fall hat eine durchsichtige Box mit den Maßen 30x60x100mm (von Visitenkarten) hervorragend gepasst.

Ja, das schlafende System verbraucht ~2.3mA – zu 90% wegen des Kommunikationsmoduls – es schaltet sich nicht vollständig aus, sondern wechselt in den Wartemodus.

Lassen Sie uns mit der Herstellung der Sensoren beginnen; zunächst werfen wir einen Blick auf das Schema der Sensoranordnung:

Das ist der Plan des Bienenstocks – Ansicht von oben.

Klassischerweise werden 4 Sensoren in den Ecken installiert (1,2,3,4)

Wir werden die Messung jedoch anders vornehmen. Genauer gesagt sogar auf eine dritte Weise. Denn anders machen es die Jungs von BroodMinder:

In dieser Konstruktion sind die Sensoren an den Positionen 1 und 2 installiert, die Punkte 3 und 4 stützen sich auf den Balken.
Dann lastet nur die Hälfte des Gewichts auf den Sensoren.
Ja, diese Methode hat eine geringere Genauigkeit, aber es ist dennoch schwer vorstellbar, dass Bienen alle Wabenrahmen entlang einer Wand des Bienenstocks mit "Zungen" aus Wachs zugebaut haben.

So schlage ich vor, die Sensoren komplett auf Punkt 5 zu konzentrieren — dann wird die Notwendigkeit für die Abschirmung des Systems überflüssig, und bei Verwendung leichter Bienenstöcke könnte man sogar mit nur einem Sensor auskommen.

Insgesamt wurden zwei Arten von Modulen am HX711 getestet, zwei Arten von Sensoren und zwei Varianten ihrer Verbindung — mit einer vollständigen Wheatstone-Brücke (2 Sensoren) und mit einer halben, wobei der zweite Teil mit 1k-Widerständen mit einer Toleranz von 0,1% ergänzt wird.
Aber die letzte Methode ist unerwünscht und wird sogar von den Herstellern der Sensoren nicht empfohlen, daher beschreibe ich nur die erste.

Also werden wir zwei Dehnungssensoren und ein HX711-Modul auf einen Bienenstock installieren, das Verdrahtungsschema ist folgendes:

Vom ADC-Board zum Arduino verläuft ein 5 Meter langes vieradriges Telefonkabel — Wir erinnern uns, wie Bienen GSM-Geräte im Bienenstock nicht mögen..

Also lassen wir an den Sensoren "Schwänze" von 8 cm, schälen das verdrillte Paar und löten alles wie auf dem obigen Foto.

Bevor wir mit dem Holzteil beginnen, stellen Sie Wachs/Wachs in einem geeigneten Behälter zum Schmelzen in ein Wasserbad.

Jetzt nehmen wir unseren Balken und teilen ihn in drei Stücke von je 100 mm.

Danach markieren wir den langen Schlitz mit einer Breite von 25 mm und einer Tiefe von 7-8 mm, entfernen das Überflüssige mit einer Säge und einem Meißel — es sollte ein U-Profil herauskommen.

Ist das Wachs geschmolzen? — Tauchen Sie unsere ADC-Boards dort hinein — das schützt sie vor Feuchtigkeit/Nebel:

Wir platzieren das alles auf einem Holzuntergrund (dies muss mit einem Holzschutzmittel gegen Fäulnis behandelt werden):

Und schließlich fixieren wir die Sensoren mit Schrauben:

Es gab auch eine Option mit blauer Isolierband, aber aus humanitären Gründen zeige ich diese nicht 😉

Von Seiten des Arduino machen wir Folgendes:

Wir schälen unsere Telefonkabel, verdrillen die farbigen Adern miteinander und verzinnen sie.

Danach löten wir sie an die Kontakte des Boards, wie auf dem Foto:

Alles, jetzt für die endgültige Überprüfung platzieren wir die Sensoren in den Sektoren des Kreises, oben — ein Stück Sperrholz, setzen den Controller zurück (setzten die Batterie mit einem auf den Fotodiode gesetzten Kappen von einem Kugelschreiber).

Der LED an der Arduino sollte aufblitzen und eine Test-SMS eingehend sein.

Als Nächstes entfernen wir die Abdeckung vom Lichtsensor und holen Wasser in die 1,5-Liter-Plastikflasche.
Wir stellen die Flasche auf die Spanplatte, und wenn seit dem Einschalten einige Minuten vergangen sind, setzen wir die Abdeckung wieder auf den Fotowiderstand (um den Sonnenuntergang nachzuahmen).

Nach drei Minuten leuchtet die LED am Arduino, und Sie sollten eine SMS mit Gewichtswerten von etwa 1 kg auf allen Positionen erhalten.

Herzlichen Glückwunsch! Das System wurde erfolgreich zusammengebaut!

Wenn Sie das System jetzt erneut auslösen, werden in der ersten Gewichtsspalte Nullen angezeigt.

Ja, unter realen Bedingungen sollte der Fotowiderstand vertikal nach oben ausgerichtet werden.

Nun gebe ich eine kurze Anleitung zur Nutzung:

Die Dehnungsmessstreifen unter die hinteren Wände der Bienenstöcke anbringen (vorne eine Leiste oder ein Brett mit einer Dicke von ca. 30 mm verwenden).
Den Fotowiderstand beschatten und die Batterie anschließen – die LED sollte aufblitzen und eine Test-SMS mit dem Text „INITIAL BOOT OK“ eintreffen.
Den Hauptblock so weit wie möglich von den Bienenstöcken entfernt platzieren, sodass die Kabel bei der Arbeit mit den Bienen nicht stören.
Jeden Abend nach Sonnenuntergang wird eine SMS mit der Gewichtänderung über 24 Stunden und seit dem Start eintreffen.
Wenn die Batteriespannung 3,5 V erreicht, endet die SMS mit dem Satz „!!! BATTERIE AUFLADEN !!!“
Die Betriebszeit mit einer 2600 mAh starken Batterie beträgt etwa einen Monat.
Im Falle eines Batteriewechsels werden die täglichen Gewichtänderungen der Bienenstöcke nicht gespeichert.