beelogger – Kalibrierung & Test

Zum Test der Sensoren bzw. der Sensorkonfiguration sowie der Sleep-Funktionen beim beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe) und zur Kalibrierung der Spannungsüberwachung stehen mehrere Sketche zur Verfügung.
Hierzu gehören die Einstellung und Alarmfunktion der RTC (Echtzeituhr), der Test des Temperatursensors der RTC, der Sleep-Mode des ATmega, welcher durch den Alarm der RTC über einen Interrupt aufgeweckt wird, das Auslesen der Akku- und Solarspannung, sowie die Akku-Schutzfunktion. Für den Test-Programmcode werden daher keine Sensoren oder Module benötigt.

Der System-Check-Sketch testet Sensoren und konfigurierbar diverse Systemfunktionen.

Der Test-Programmcode ermöglicht es die speziellen Funktionen des beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe) für den Sleep-Mode zu testen.

Der Kalibrierung-Programmcode dient dazu, die fertigungsbedingten Toleranzen der verwendeten Bauteile eines beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe) bei der Spannungsmessung von Akku und Solarzelle auszugleichen. Da die Akkuspannung für eine Software-Funktion zum Akku-Schutz verwendet wird, ist die Kalibrierdung zwingen notwendig, damit der Test- und Haupt-Programmcode lauffähig ist.

Libraries

<Wire.h> – in der Arduino-Software bereits enthalten
<Sodaq_DS3231.h> – https://github.com/SodaqMoja/Sodaq_DS3231
<LowPower.h> – https://github.com/rocketscream/Low-Power

Kalibrierung-Programmcode
für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

Alle elektronischen Komponenten des beeloggers mit seinen Spannungsreglern, Widerständen und dem ATmega unterliegen fertigungsbedingten Toleranzen. Um diese Toleranzen bei der Messung der Spannung von Akku und Solarzelle möglichst gut zu kompensieren, muss eine Kalibrierung für jeden beelogger-Solar durchgeführt werden. Hierfür sind zwei Werte zu ermitteln:

Kalib_Spannung
Kalib_Bitwert

Für die Variable ‘Kalib_Spannung’ sollte mit einem möglichst hochwertigen Multimeter die Spannung des Akkus direkt gemessen und in Millivolt hinterlegt werden. Der Akku sollte bei dieser Messung gut geladen und nicht eingebaut sein.
Der Wert der Variable ‘Kalib_Bitwert’ wird über den Kalibrierung-Programmcode ermittelt. Dieser Wert gibt die mit allen Toleranzen gemessene Akku-Spannung durch den beelogger-Solar wieder.

Kalibrieriert wird mit diesem Sketch der Spannungsteiler bestehend aus B-R1 und B-R2. Ein Wechsel des LiIon-Akku erfordert keine neue Kalibrierung.

Für die Messung der Solarspannung werden die gleichen Werte zur Kompensation verwendet, da diese Messung ohnehin nur eine Momentaufnahme darstellt und auch keine weiteren Auswirkungen auf den Programmablauf hat.

Der Programmcode zur Kalibrierung initialisiert auch die RTC, so dass diese über den RTC-Batterieanschluß automatisch weiterläuft, wenn die normale Spannungsversorgung fehlt.

Bevor der Kalibrierung-Programmcode aufgespielt wird, muss die Spannung des Akkus in Millivolt in der Variable ‘Kalib_Spannung’ hinterlegt werden. Wenn der FTDI-Adapter das System zusätzlich mit Strom versorgt, könnte dieser das Ergebnis der Spannungsmessung bzw. Kalibrierung beeinflussen. Daher sollte nach dem Upload und vor der Ausführung des Kalibrierung-Programmcode, VCC des FTDI-Adapters vom beelogger-Solar getrennt werden, damit das System ausschließlich vom Akku versorgt wird. Die serielle Konsole wird hierbei weiterhin funktionieren.
Hinweis: Je nach Ausführung des FTDI-Adapters, kann durch Entfernen des Spannungsjumpers am FTDI-Adapter die Versorgung durch den FTDI getrennt werden.

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

* Version 2.0

// beelogger.de - Arduino Datenlogger für Imker

// Erläuterungen dieses Programmcodes unter https://beelogger.de

#include <Sodaq_DS3231.h>

#include <Wire.h>

int Kalib_Spannung = 1000; //Hier ist der gemessene Wert der Akkuspannung in Millivolt einzutragen

int Kalib_Bitwert = 0;

float Batteriespannung = 999.99;

byte Power_Pin=4;

void setup() {

Serial.begin(9600);

Serial.println("beelogger Kalibrierung 09.10.2019");

pinMode(Power_Pin, OUTPUT);

digitalWrite(Power_Pin, HIGH);

delay(5);

Serial.println("Starte Uhrbaustein:");

Serial.flush();

rtc.begin();

rtc.setDateTime(1);

digitalWrite(Power_Pin, LOW);

Serial.println("Uhrbaustein initialisiert.");

Serial.flush();

if (Kalib_Spannung == 0) {

Serial.println("Kein Wert fuer 'Kalib_Spannung' eingetragen.");

Serial.println("Die Kalibrierung kann nicht durchgefuehrt werden.");

while(true){};

}

Kalib_Bitwert = analogRead(A6);

Kalib_Bitwert = 0;

for(byte j=0 ;j < 16; j++) {

Kalib_Bitwert += analogRead(A6);

}

Kalib_Bitwert = Kalib_Bitwert >>2;

Serial.print("Hinterlegter Wert fuer 'Kalib_Spannung': ");

Serial.println(Kalib_Spannung);

Serial.println();

Serial.print("Gemessener Wert fuer 'Kalib_Bitwert': ");

Serial.println(Kalib_Bitwert);

Serial.println();

Batteriespannung = (map(Kalib_Bitwert, 0, Kalib_Bitwert, 0, Kalib_Spannung)) / 1000.0;

Serial.print("Die mit dieser Kalibrierung ermittelte Akkuspannung betraegt:");

Serial.print(Batteriespannung);

Serial.println(" V");

Serial.println();

}

void loop() {

}

Ausgabe des seriellen Monitors (9600 baud):

beelogger Kalibierung

Starte Uhrbaustein:

Uhrbaustein initialisiert.

Hinterlegter Wert fuer 'Kalib_Spannung': 3754

Gemessener Wert fuer 'Kalib_Bitwert': 1483

Die mit dieser Kalibrierung ermittelte Akkuspannung betraegt:3.75 V

Programmcode downloaden:

Download

Test-Programmcode
für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

Im Programmcode ist zunächst das Weckintervall in Stunden und Minuten anzugeben. Mit diesem regelmäßigen Intervall wird der ATmega aus dem Schlafmodus geweckt, um Messungen und den Versand der Daten vorzunehmen. Hierfür stehen die Variablen ‘WeckIntervallStunden’ und ‘WeckIntervallMinuten’ zur Verfügung.

Der Test-Programmcode wurde mit einem Intervall von einer Minute vorkonfiguriert. Generell ist es bei einem regelmäßigen Intervall nicht notwenig, zuvor die korrekte Uhrzeit einzustellen. Für eigene Entwicklungen oder zukünftige Erweiterungen wurde diese Option jedoch im Programmcode aufgenommen. Hierfür übernimmt die RTC die Uhrzeit aus dem Programmcode, die automatisch während der Compilierung im Rahmen des Uploads auf den ATmega hinterlegt wird. Voraussetzung ist natürlich eine korrekt eingestellte Uhrzeit am PC.

Der Programmcode stellt zudem sicher, dass zukünftig automatisch mit dem Upload des Test- oder Haupt-Programmcodes, die korrekte Uhrzeit der RTC eingestellt werden kann.

Der Programmcode enthält zudem zwei besondere Funktionen, die speziell für den Akku- bzw. Solarbetrieb entwickelt wurden:

Um den Akku zu schonen und ihm somit eine lange Lebensdauer zu ermöglichen, kann über die Variable ‘VMinimum’ die maximale Spannung eingestellt werden, ab der keine Messungen und auch kein Versand von Daten mehr erfolgt. Aber auch um den korrekten Betrieb des GSM-Moduls, welches eine minimale Spannung von 3,8V benötigt, sicherzustellen, kann die Funktion eingesetzt werden. Diese Lösung ersetzt natürlich keine im Akku integrierte Schutzschaltung vor Tiefenentladung
Damit der beelogger auch während einer längeren Zeitspanne ohne Aufladung (beispielsweise im Winter mit zugescheiten Solarzellen) Sensordaten ermittelt und versendet, kann über die Variable ‘VAlternativ’ die maximale Spannung eingestellt werden, ab der das Weckintervall verändert bzw. verlängert wird. Die Länge dieses temporären Weckintervalls wird über ‘AlternativIntervallStunden’ und ‘AlternativIntervallMinuten’ eingestellt.

Beispiel:

WeckIntervallMinuten = 30
VMinimum = 3.75 // 11.5 – 12V Akku
VAlternativ = 3.8 // 11.9 – 12V Akku
AlternativIntervallMinuten = 180

Bei einer Spannung die höher ist als 3,8V, werden die Messwerte wie in den Intervallen konfiguriert (hier 30 min) abgefragt und versendet. Ab einer Spannung von 3,8V und geringer, werden Messungen und Versand der Daten nur noch alle 3 Stunden (180min) durchgeführt. Bei einer Spannung die kleiner oder gleich 3,75V ist, werden weder Messungen vorgenommen, noch Daten versendet. Solabld der Akku durch die Solarzelle aufgeladen wird und die Akkuspannung die eingestellten Werte erreicht bzw. überschreitet, nimmt der beelogger seinen Betrieb wieder auf.

Da der Test-Programmcode weder Sensoren, noch einen nRF24L01 oder ein GSM-Modul verwendet, dient diese Erläuterung primär der Konfiguation des Haupt-Programmcodes für den beelogger.

Die Batterie CR1220 des DS3231 muss für den Test eingelegt sein, da auch die RTC während der Schlafphase von der Stromversorgung getrennt wird, um eine weitere Stromeinsparung zu erreichen. Alternativ kann mit Hilfe der Lötfelder, wie unter Aufbau beschrieben, der Batterieanschluss der RTC mit dem LiIon-Akku verbunden werden.
Diese Option nicht bei EE-Prom-Systemen verwenden.

Die RTC verfügt zudem über einen eingebauten Temperatursensor. Sofern kein oder nur ein Temperatursensor aktiviert ist und keine andere Konfiguration vorgenommen wurde, liefert die RTC im Haupt-Programmcode die Daten für ‘TempOut’, welche auch für die Temperaturkompensation der Stockwaage verwendet wird.

Ohne die Werte der Kalibrierung für die Spannungsmessung, wird immer eine Batteriespannung von 0V ermittelt. Dadurch greift der Programmcode zum Schutz des Akkus und es wird nach der Messung der Akkuspannung keine weitere Aktion mehr vorgenommen. Diese zuvor ermittelten Werte sind somit vor dem Upload einzutragen.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

// beelogger.de - Arduino Datenlogger für Imker

// Erläuterungen dieses Programmcodes unter https://beelogger.de

#include <Sodaq_DS3231.h>

#include <Wire.h>

#include <LowPower.h>

// Intervalle

//----------------------------------

byte WeckIntervallMinuten = 1;

byte AlternativIntervallMinuten = 6;

float VAlternativ = 3.8; // Minimale Spannung ab der automatisch das alternative Intervall aktiviert wird

float VMinimum = 3.75; // Minimale Spannung ab der keine Messungen und auch kein Versand von Daten erfolgt

//----------------------------------

// Kalibrierung

//----------------------------------

int Kalib_Spannung = 1000; // Hier muss der Wert aus der Kalibrierung eingetragen werden

int Kalib_Bitwert = 100; // Hier muss der Wert aus der Kalibrierung eingetragen werden

//----------------------------------

float Batteriespannung = 999.99;

float Solarspannung = 999.99;

float RTCTemp;

volatile bool ok_sleep = false;

#define USB_RX 0 // Pin 0 RX-USB

#define USB_TX 1 // Pin 1 TX-USB

#define DS3231_Interrupt_Pin 2

#define Power_Pin 4

#define Batterie_messen A6

#define Solarzelle_messen A7

void setup() {

Serial.begin(9600);

Serial.println("beelogger Test 09.10.2019 ");

Serial.println("beelogger Test Uhr, Kalibrierwerte und On/Off: ");

pinMode(Power_Pin, OUTPUT);

digitalWrite(Power_Pin, HIGH);

if ( Kalib_Bitwert == 100) {

Serial.println();

Serial.println("Bitte Kalibrierwerte eintragen! ");

Serial.println();

WeckIntervallMinuten = 10;

}

Spannungen_messen();

delay(5);

rtc.begin();

DateTime pc_tim = DateTime(__DATE__, __TIME__);

long l_pczeit = pc_tim.get();

DateTime aktuell = rtc.now();

long l_zeit = aktuell.get();

if (l_pczeit > l_zeit) rtc.setDateTime(pc_tim.get());

rtc.clearINTStatus();

pinMode(DS3231_Interrupt_Pin, INPUT_PULLUP);

ok_sleep = true;

delay(5);

display_time();

display_interval();

Alarm_konfigurieren();

SleepNow(false);

}

void loop() {

Spannungen_messen();

display_time();

display_temp();

display_interval();

Alarm_konfigurieren();

SleepNow(true);

}

void display_time() {

DateTime aktuell = rtc.now();

Serial.print("Datum und Uhrzeit: ");

Serial.print(aktuell.date(), DEC);

Serial.print('.');

Serial.print(aktuell.month(), DEC);

Serial.print('.');

Serial.print(aktuell.year(), DEC);

Serial.print(' ');

Serial.print(aktuell.hour(), DEC);

Serial.print(':');

Serial.print(aktuell.minute(), DEC);

Serial.print(':');

Serial.print(aktuell.second(), DEC);

Serial.println();

Serial.flush();

}

void display_temp() {

RTCTemp = rtc.getTemperature();

Serial.print("Temperatur ueber Sensor in RTC: ");

Serial.println(RTCTemp);

Serial.println();

Serial.flush();

}

void display_interval() {

Serial.println();

Serial.print("Eingestelltes Weckintervall: ");

Serial.print(WeckIntervallMinuten);

Serial.println(" Minute(n)");

Serial.flush();

}

void Spannungen_messen() {

Batteriespannung = Messe_Spannung(Batterie_messen);

Serial.print(F(" Batterie [V]: "));

Serial.println(Batteriespannung);

Serial.flush();

if (Batteriespannung > VMinimum) {

Solarspannung = Messe_Spannung(Solarzelle_messen);

Serial.print(F(" Solarspannung [V]: "));

Serial.println(Solarspannung);

Serial.flush();

}

float Messe_Spannung (byte Pin) {

int Messung_Spannung;

float Spannung;

Messung_Spannung = analogRead(Pin);

Messung_Spannung = 0;

for (byte j = 0 ; j < 16; j++) {

Messung_Spannung += analogRead(Pin);

}

Messung_Spannung = Messung_Spannung >> 2;

Spannung = (float)map(Messung_Spannung, 0, Kalib_Bitwert, 0, Kalib_Spannung) / 1000.0;

return (Spannung);

}

void Alarm_konfigurieren() {

byte Minute, IntervallMinuten;

if (Batteriespannung > VAlternativ) {

IntervallMinuten = WeckIntervallMinuten;

} else {

Serial.println("Batteriespannung unter Grenzwert, alternatives Intervall aktiviert");

Serial.println();

IntervallMinuten = AlternativIntervallMinuten;

}

DateTime aktuell = rtc.now();

long timestamp = aktuell.get();

aktuell = timestamp + IntervallMinuten * 60;

rtc.enableInterrupts(aktuell.hour(), aktuell.minute(), 0);

}

void WakeUp() {

detachInterrupt(0);

ok_sleep = false;

}

void SleepNow(byte power_off) {

delay(100);

if (power_off) {

Serial.println("Sleep-Modus mit Power-Off ist aktiviert, bitte warten ... ");

digitalWrite(Power_Pin, LOW);

delay(5);

}

else {

Serial.println("Sleep-Modus mit Power-ON started, bitte warten ... ");

}

Serial.flush();

Serial.end(); // Serial aus

delay(50);

digitalWrite(USB_RX, LOW); // Port aus

pinMode(USB_TX, INPUT);

digitalWrite(USB_TX, LOW); // Port aus

TWCR &= ~(bit(TWEN) | bit(TWIE) | bit(TWEA));

digitalWrite (A4, LOW);

digitalWrite (A5, LOW);

delay(1);

attachInterrupt(0, WakeUp, LOW);

if (ok_sleep) {

LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);

}

else {

Serial.begin(9600);

Serial.println("Sleep-Modus konnte nicht aktiviert werden");

}

digitalWrite(Power_Pin, HIGH);

delay (5);

rtc.begin();

rtc.clearINTStatus();

while (digitalRead(DS3231_Interrupt_Pin) == false) {};

ok_sleep = true;

Serial.begin(9600);

Serial.println("Sleep-Modus wurde beendet");

Serial.println();

delay(5);

}

Ausgabe des seriellen Monitors (9600 baud):

beelogger Solar Test Uhr und Kalibrierwerte:

Datum und Uhrzeit: 22.12.2018 12:9:25

Eingestelltes Weckintervall: 1 Minute(n)

Sleep-Modus mit Power-ON gestartet, bitte warten ...

Sleep-Modus wurde beendet

Batteriespannung: 4.11 V

Solarspannung: 1.20 V

Datum und Uhrzeit: 22.12.2018 12:10:0

Temperatur ueber Sensor in RTC: 21.25

Eingestelltes Weckintervall: 1 Minute(n)

Sleep-Modus mit Power-Off ist aktiviert, bitte warten ...

Sleep-Modus wurde beendet

Batteriespannung: 4.12 V

Solarspannung: 1.25 V

Datum und Uhrzeit: 22.12.2018 12:11:0

Temperatur ueber Sensor in RTC: 21.00

Programmcode downloaden:

Download

System-Check und Testprogramm zur Sensorkonfiguration:

Neben den nachstehenden Einstellungen der Sensoren kann es auch notwendig sein zu prüfen welche Sensoren im System aktiv sind.
Dazu haben wir ein kleines Testprogramm erstellt, welches

– eine Auflistung aller DS18B20 durchführt,
– die Belegung der I2C-Adressen anzeigt,
– die DHT 22 testet,
– ein optional vorhandes EE-Prom bei Adresse 0x53, 0x57 auf Größe prüft,
– den beelogger nach dem Systemtest in den Sleep-Mode versetzt,
– und, wenn konfiguriert:
         – einen separaten Test für den Uhrbaustein DS3231 macht
         – die schaltbare Stromversorgung abschaltet
         – eine angeschlossene SD-Karte testet (benötigt SDFat-Bibliothek)

#define System_with_DS3231 0 // 0 = ohne oder 1 = mit DS3231

#define Power_off_at_End 0 // 0 = aus, 1= Power an

#define Test_SD_Card 0 // 0 = aus, 1= Power an

`Download`

Beispiel der Monitorausgabe:

System Check 180819

Suche One-Wire-Bus, I2C-Bus

Looking for 1-Wire devices... (i.e. DS18B20)

at Pin: D3

Found '1-Wire' device with address:

0x28, 0xFF, 0xAB, 0x84, 0xA1, 0x16, 0x05, 0xF8

One-Wire scan done.

I2CScanner ready!

starting scanning of I2C bus from 8 to 119...

addr: 0x8

addr: 0x9 addr: 0xA addr: 0xB addr: 0xC

addr: 0xD addr: 0xE addr: 0xF addr: 0x10

addr: 0x11 addr: 0x12 addr: 0x13 addr: 0x14

... ... ...

addr: 0x51 addr: 0x52 addr: 0x53 addr: 0x54

addr: 0x55 addr: 0x56 addr: 0x57 found! addr: 0x58

addr: 0x59 addr: 0x5A addr: 0x5B addr: 0x5C

addr: 0x5D addr: 0x5E addr: 0x5F addr: 0x60

addr: 0x61 addr: 0x62 addr: 0x63 addr: 0x64

addr: 0x65 addr: 0x66 addr: 0x67 addr: 0x68 found!

addr: 0x69 addr: 0x6A addr: 0x6B addr: 0x6C

addr: 0x6D addr: 0x6E addr: 0x6F addr: 0x70

addr: 0x71 addr: 0x72 addr: 0x73 addr: 0x74

addr: 0x75 addr: 0x76 found! addr: 0x77

I2C scan done

Info:

BH1750 - 0x23, 0x5C

Si7021 - 0x40

SHT31 - 0x44, 0x45

AT24C32 - 0x57

DS3231 - 0x68

BME280 - 0x76, 0x77

MCP23017 - 0x20, 0x21, 0x22, 0x23

DHT 1:

DHT 2:

EE-Prom Test: EE-Prom at: 0x57

1, 2, 3, 4,

EE-Prom: 4 kByte

Sleep forever!

Der komplette Programmcode für den Arduino Datenlogger mit Stockwaage für Imker ist unter Programmcode zu finden.

beelogger – Kalibrierung & Test

Libraries

Kalibrierung-Programmcode für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

Test-Programmcode für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

System-Check und Testprogramm zur Sensorkonfiguration:

Download

Kalibrierung-Programmcode
für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

Test-Programmcode
für beelogger-Solar und beelogger-Universal (erweiterte Ausbaustufe)

`Download`