automatisches Einschalten des Nodes – Lösung für „alle“ Mesh-Geräte

Im letzten Basteltipp wurde das Problem behandelt, dass sich Heltec V3 Meshtastic Geräte nach einem Akkustand unter 3,1V ausschalten, und selbst nach solarer Aufladung und vollem Akku, nicht mehr selbstständig starten. Zum alten Basteltipp

In diesem Basteltipp wird die gebastelte Hardware einfach zwischen Akku und Gerät gesteckt (oder gelötet), quasi plug & play.

Falls du Hilfe bei deinem Projekt benötigst schreib uns ein Mail kontakt@meshtastic.at oder ruf uns an (Verein AKM: +43 660 2047283).

ACHTUNG: Für RAK Boards welche den am RAK Board verbauten 5V Solarladeeingang verwenden ist die Hardware so nicht geeignet.

Hier noch einmal die Problemstellung:
Viele Meshtastic-kompatible Hardwaregeräte werden häufig in autarken Nodes betrieben, die mit Solarstrom versorgt werden. In Zeiten, in denen längere Zeit keine direkte Sonneneinstrahlung auf das Solarpanel fällt, etwa im Winter, kann die Akkuspannung unter die benötigte Betriebsspannung des Meshtastic-Geräts sinken. In diesem Fall schaltet sich das Gerät aus und geht offline.

Wenn die Sonne schließlich wieder ausreichend scheint und die Akkuspannung die Betriebsspannung erneut erreicht, schaltet sich das Gerät jedoch nicht automatisch ein. Stattdessen muss die POWER ON– oder RESET-Taste auf der Hardware manuell betätigt werden. Da diese autarken Nodes oft an erhöhten und schwer zugänglichen Positionen installiert sind, ist eine automatische Wiedereinschaltung notwendig, um den Betrieb sicherzustellen.

Die Lösung ist also eine Schaltung, die die Akkuspannung kontinuierlich überwacht. Sobald die Spannung unter 3,25 V fällt, soll die Stromversorgung zum Meshtastic Gerät unterbrochen werden. Steigt die Spannung wieder auf mindestens 3,35 V, soll die Schaltung die Stromversorgung, ohne Spannungsverlust durch einen Halbleiterschalter, wieder hergestellt werden, damit das Gerät wieder startet und online geht.

Zusätzlich sollte die Schaltung energieeffizient sein und möglichst keinen Spannungsabfall in der Stromversorgung des Meshtastic-Geräts verursachen. Ein normales monostabiles Relais kommt jedoch nicht in Frage, da dies permanent Strom verbraucht.

---

Lösung:
Ein Mikrocontroller mit einem ADC-Eingang kann die Akkuspannung in regelmäßigen Abständen, z. B. alle 10 -30 Minuten, prüfen. Zwischen den Messungen soll der µC (Mikrocontroller) in einen stromsparenden Modus wechseln. Wenn die Akkuspannung unter 3,25 V fällt, wird die Stromversorgung über ein bistabiles Relais unterbrochen. Sobald die Spannung wieder auf mindestens 3,35 V steigt, soll der µC die Spannungsversorgung zum Gerät wieder aktivieren.

Der Mikrocontroller muss mit einer Mindestversorgungsspannung von 3,15 V betriebsbereit sein. Damit die Spannungsmessung korrekt funktioniert, muss die Versorgungsspannung stabilisiert werden. Hierfür eignet sich ein Fixspannungsregler wie der AMS1117 oder LM1117, der allerdings eine Dropout-Spannung von ca. 1,2 V aufweist. Dadurch kann der Mikrocontroller nur mit einer Eingangsspannung von mindestens 3,2 V – 1,2 V = 1,95 V versorgt werden.

Ein geeigneter Kandidat für diese Anforderungen ist der Atmel ATtiny85V (oder Attiny13 oder Attiny10), kombiniert mit einem Fixspannungsregler AMS1117-1.8. Dieser Mikrocontroller benötigt nur eine Mindestversorgungsspannung von 1,8 V bei einer Taktrate von 1 MHz. Bei dieser Frequenz verbraucht der ATtiny85V lediglich 300 µA im Betrieb und 0,1 µA im Ruhezustand.

Um den ADC-Eingang des Mikrocontrollers vor Überspannung zu schützen, ist ein Spannungsteiler erforderlich, der sicherstellt, dass die Versorgungsspannung des Mikrocontrollers nicht überschritten wird.
Das bistabile Relais (mit einer oder 2 Spulen) soll eine Nenn-Spulenspannung von 4,5V – 5V aufweisen, sollte aber so sensibel sein, dass eine zuverlässige Schaltung mit 3V stattfinden kann.

Die gesamte Schaltung benötigt lediglich 0,5mA im Wartemodus und 5mA im Mess- und Schaltmodus.
Der Schaltmodus dauert ca. 2 Sekunden, dann geht die Schaltung wieder für 30 Minuten in den Wartemodus.

Das Bastelprojekt:

Berechnung Spannungsteiler für Messeingang ADC1 von Tiny85:

Der Spannungsteiler ist deshalb erforderlich, da die Akkuspannung zwischen 3V und 4,3V ist und der µC nur mit 1,8V betreiben wird. Um nun den µC nicht zu beschädigen, sollte die Messpannung die Versorgungsspannung von 1,8V nicht überschritten werden.
Der Spannungsteiler besteht aus zwei Widerständen, R1 und R2, die in Reihe geschaltet sind. Die Ausgangsspannung Vout wird am Verbindungspunkt der beiden Widerstände abgegriffen. Die Berechnungsformel lautet:

Vout = Vin * (R2 / (R1 + R2))

Hierbei ist:

• Vin die Eingangsspannung der Plus Pol des Akkus (min. 3V bis max. 4,3V Li-Ion Akku)
• R1 der obere Widerstand
• Vout zwischen den beiden Widerständen (max. 2,5V)
• R2 der untere Widerstand
• GND ist die Masse also der Minus Pol des Akkus
• R1 = 6,8kΩ
• R2 = 5,1kΩ

Stückliste (diskrete Bauweise)

1           Lochrasterplatine
1           Atmel ATtiny85V
1           LM 1117 1.8
1           LED 3mm rot
2          PNP Transistor BC557 (oder BC807 oder Vergleich)
2          NPN Transistor BC546 (oder BC817 oder Vergleich)
1           Mini Relais bistabil, Spulenspannung 4,5V – 5V (eine Spule, zB. TE Axicom IM42 THT)
je 1        Widerstand 6,8kΩ , 5,1kΩ 
je 1        Widerstand 10kΩ, 4,7kΩ , 1kΩ 
je 1       Kondensator 10µF, 22µF
2          JST 2.0mm Lötsockel (Kabel anlöten tuts aber auch auch)
Ein paar Litzen

Atmel ATtiny85V 

LM 1117 1.8

BC557

BC546

LED

TE AXICOM IM42 THT

Schaltplan

  Programm für Tiny85 ( 30 Minuten Sleep pro loop)

//
//Spannungsteiler für tiny85 ADC1 Eingang (max. 1,8V Messspannung möglich)
//               _________                _________
//  + Akku -----|_R1_5.1k_|--------------|_R2_6.8k_| -----   GND Akku
//                             |
//                            ADC1
//
// ATtiny85
//   Reset --- 1 |       |8 --- VCC
// LED PB3 --- 2 | tiny  |7 --- ADC1 zum Spannungsteiler
//         --- 3 |  85   |6 --- PB1 Relaissteuerung T1 T4
//     GND --- 4 |       |5 --- PB0 Relaissteuerung T2 T3
//
//Für Relais bistabil mit 1 Spule +-/-+ 
//Relais Leerlauf    : PB0 = LOW  + PB1 = LOW (während 10 Minunten Tiefschlaf ca. 0,5 mA, im 2 Sekunden Arbeitsmodus ca. 5 mA)
//Relais + - EIN     : PB0 = HIGH + PB1 = LOW
//Relais - + AUS     : PB0 = LOW  + PB1 = HIGH
//Relais undefiniert : PB0 = HIGH + PB1 = HIGH
//
//LED auf PB3 dient als Heartbeat und Feedback

//Werte für AUSSCHALTEN
// Spannung in V     Wert
//      3,05V        1.31 
//      3,20V        1.36 (default)
const float offVoltage = 1.36;  // Wert für ausschalten einsetzen

//Werte für EINSCHALTEN
// Spannung in V     Wert
//      3,20V        1.37  
//      3,30V        1.39 
//      3,35V        1.43 (default)
const float onVoltage = 1.43;  // Wert für einschalten einsetzen

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <avr/sleep.h>
#include <avr/wdt.h>

const int analogPin = 1;             // ADC1 entspricht physischem Pin 7
const int pb0Pin = 0;                // PB0 entspricht physischem Pin 5
const int pb1Pin = 1;                // PB0 entspricht physischem Pin 6
const int pb3Pin = 3;                // PB3 entspricht physischem Pin 2
const float referenceVoltage = 1.8;  // Versorgungsspannung Tiny85 1,8V  dient zugleich als Referenzspannund


volatile int lowV = 0;// Flag Variable "Niedrige Spannung"

volatile bool wakeup = false;// Watchdog-Timer Variable

// Watchdog-Interrupt-Service-Routine
ISR(WDT_vect) {
  wakeup = true;  // Signalisiert das Aufwachen
}

// Funktion, um den Watchdog-Timer zu konfigurieren
void setupWatchdogTimer() {
  // Setzt den Watchdog-Timer auf 8 Sekunden
  WDTCR = (1 << WDCE) | (1 << WDE);                 // Aktiviert Änderungen am WDT
  WDTCR = (1 << WDIE) | (1 << WDP3) | (1 << WDP0);  // 8s Intervall + Interrupt
}

// Sleep-Modus aktivieren
void enterSleepMode() {
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // Tiefster Energiesparmodus
  sleep_enable();
  sleep_cpu();  // Schlafmodus starten

  // CPU wird nach Watchdog-Interrupt geweckt
  sleep_disable();  // Schlafmodus deaktivieren
}

void setup() {
  cli();                 // Interrupts deaktivieren
  setupWatchdogTimer();  // Watchdog-Timer einrichten
  sei();

  pinMode(analogPin, INPUT);  //ADC1 als Eingang konfigurieren
  pinMode(pb0Pin, OUTPUT);    // PB0 als Ausgang konfigurieren
  pinMode(pb1Pin, OUTPUT);    // PB1 als Ausgang konfigurieren
  pinMode(pb3Pin, OUTPUT);    // PB3 als Ausgang konfigurieren
  //Beim Start default einschalten
  digitalWrite(pb0Pin, LOW);
  digitalWrite(pb1Pin, HIGH);
  delay(500);
}

void loop() {
  digitalWrite(pb0Pin, LOW);  //Relais Leerlauf
  digitalWrite(pb1Pin, LOW);  //Relais Leerlauf

  digitalWrite(pb3Pin, HIGH);  //LED Heartbeat blinkt 1x kurz
  delay(50);
  digitalWrite(pb3Pin, LOW);
  delay(50);

  // Spannung an ADC1 messen
  int adcValue = analogRead(analogPin);
  // Spannung berechnen
  float voltage = (adcValue / 1023.0) * referenceVoltage;

  if (voltage <= offVoltage&& lowV == 0)  //Ausschalten  
  {
    //Relais + - AUS : PB0 = LOW + PB1 = HIGH
    digitalWrite(pb0Pin, LOW);
    digitalWrite(pb1Pin, HIGH);
    delay(500);
    //Relais Leerlauf
    digitalWrite(pb0Pin, LOW);
    digitalWrite(pb1Pin, LOW);

    lowV = 1;                    // Flag auf 1 setzen
    digitalWrite(pb3Pin, HIGH);  // LED blinkt 2x
    delay(500);
    digitalWrite(pb3Pin, LOW);
    delay(500);
    digitalWrite(pb3Pin, HIGH);
    delay(500);
    digitalWrite(pb3Pin, LOW);
    delay(500);

  } 
  
  if (voltage >= onVoltage && lowV == 1)  //Einschalten 
  {
    //Relais - + EIN : PB0 = HIGH  + PB1 = LOW
    digitalWrite(pb0Pin, HIGH);
    digitalWrite(pb1Pin, LOW);
    delay(500);
    //Relais Leerlauf
    digitalWrite(pb0Pin, LOW);
    digitalWrite(pb1Pin, LOW);

    lowV = 0;  // Flag auf 0 zurücksetzen

    digitalWrite(pb3Pin, HIGH);  // LED blinkt 1x lang
    delay(2000);                 //2 Sec pause
    digitalWrite(pb3Pin, LOW);
  }
  // 10 Minuten in den Schlafmodus wechseln
  for (int i = 0; i < 1; i++) {  // 10 Minuten = 75 x 8 Sekunden i < 75, !!! für debug i < 1
    enterSleepMode();
    if (!wakeup) {
      continue;  // Warten, bis der Watchdog-Interrupt ausgelöst wird
    }
    wakeup = false;  // Interrupt-Flag zurücksetzen
  }

  // Kurze Pause vor der nächsten Messung
  delay(500);
}

ANLEITUNG µC programmieren (USBasp Programmer wird benötigt)

USBasp Programmer bei Amazon

Installation der Arduino IDE und Nutzung mit dem ATtiny85

Diese Schritt-für-Schritt-Anleitung zeigt Ihnen, wie Sie die Arduino IDE installieren, die Board-Bibliothek für den ATtiny85 einbinden und einen Code mit einem USBasp-Programmer kompilieren und hochladen.

---

1. Arduino IDE herunterladen und installieren

1. Besuchen Sie die Arduino-Website: https://www.arduino.cc/en/software.
2. Laden Sie die Version der Arduino IDE herunter, die zu Ihrem Betriebssystem passt (Windows, macOS oder Linux).
3. Installieren Sie die Arduino IDE:
   • Windows: Führen Sie die heruntergeladene .exe-Datei aus und folgen Sie den Anweisungen.
   • macOS: Ziehen Sie die Arduino-Anwendung in den Ordner „Programme“.
   • Linux: Entpacken Sie das Archiv und folgen Sie der Dokumentation für Ihr System.

2. Board-Bibliothek für den ATtiny85 einbinden

1. Starten Sie die Arduino IDE.
2. Öffnen Sie das Menü Datei > Voreinstellungen.
3. Fügen Sie im Feld Zusätzliche Boardverwalter-URLs folgende URL ein:

https://drazzy.com/package_drazzy.com_index.json

(Falls bereits andere URLs eingetragen sind, trennen Sie diese mit einem Komma.)

4. Bestätigen Sie mit OK.
5. Gehen Sie zu Werkzeuge > Board > Boardverwalter.
6. Suchen Sie nach „attiny“.
7. Wählen Sie die ATTinyCore-Bibliothek von SpenceKonde aus und klicken Sie auf Installieren.

3. Board und Programmer einstellen

1. Gehen Sie zu Werkzeuge > Board > ATtiny und wählen Sie „ATtiny25/45/85 (No bootloader)“ aus.
2. Stellen Sie die folgenden Optionen ein:
   • Prozessor: ATtiny85
   • Takt: 1 MHz (Interner Oszillator)
   • Programmer: USBasp

4. USBasp-Programmer einrichten

1. Verbinden Sie den USBasp-Programmer mit Ihrem Computer.
2. Schließen Sie den ATtiny85 an den USBasp an:
   
   • VCC: Pin 8 des ATtiny85
   • GND: Pin 4 des ATtiny85
   • MOSI: Pin 5 des ATtiny85
   • MISO: Pin 6 des ATtiny85
   • SCK: Pin 7 des ATtiny85
   • RST: Pin 1 des ATtiny85
     
3. Hinweise:
   VCC und GND müssen korrekt verbunden werden, um den Mikrocontroller mit Strom zu versorgen.
   Die Pins MOSI, MISO, SCK, und RESET stellen die SPI-Schnittstelle dar, die für die Programmierung genutzt wird.
   Stelle sicher, dass die Spannung des USBasp (meist 5V oder 3,3V) mit der Versorgung des ATtiny85 kompatibel ist.
   

5. Testcode schreiben und kompilieren

Schreiben Sie Ihren Code in der Arduino IDE oder verwenden Sie ein Beispiel:

void setup() {
    pinMode(0, OUTPUT); // Pin 0 als Ausgang setzen
}

 void loop() {
    digitalWrite(0, HIGH); // Pin 0 einschalten
    delay(1000);           // 1 Sekunde warten
    digitalWrite(0, LOW);  // Pin 0 ausschalten
    delay(1000);           // 1 Sekunde warten
}

11. Klicken Sie auf das Haken-Symbol („Übersetzen“), um den Code zu kompilieren. Prüfen Sie, ob es Fehler gibt.

6. Code auf den ATtiny85 hochladen

1. Gehen Sie zu Werkzeuge > Bootloader brennen, um den Takt des ATtiny85 einzustellen (nur einmal erforderlich).
2. Klicken Sie auf das Pfeil-Symbol („Hochladen“), um den Code auf den ATtiny85 zu übertragen.
3. Die Arduino IDE zeigt „Hochladen abgeschlossen“, sobald der Vorgang erfolgreich war.

---

Hinweise:

• Falls es Probleme mit dem USBasp gibt, installieren Sie die entsprechenden Treiber. Unter Windows können Sie z. B. den „zadig“-Treiber-Installer verwenden.
• Verwenden Sie den internen 8-MHz-Oszillator, wenn keine externe Taktquelle verfügbar ist.

Mit dieser Anleitung sollten Sie erfolgreich Ihren ATtiny85 programmieren können. Viel Erfolg!

DER BASTELTIPP IST OHNE GEWÄHR AUF KORREKTE FUNKTION!