Als Vater bin ich ein riesiger Fan der TonieBoxenⓇ. Das Prinzip dahinter, dass die TonieBoxⓇ durch NFC-Technologie die TonieⓇ-Figur auf der Oberseite erkennt und entsprechend die hinterlegte Musik abspielt, ist einfach und jedes Kind versteht es. An der Oberseite gibt ein mit LED beleuchtetes Quadrat darüber Auskunft, ob die Box geladen werden muss, gerade synchronisiert oder normal läuft. Zum Laden wird die Box auf einen Ladeadapter gesteckt und schon wird der intern verbaute Akku geladen. So sehr ich und meine Kinder die TonieBoxⓇ nun lieben, umso frustrierter waren wir bisher immer beim Laden. Da entstand Idee eine TonieBoxⓇ-DIY-Ladestation zu bauen. Als Maker und Besitzer von einem 3D-Drucker wollte ich den öden Ladevorgang etwas interessanter machen und mittels Neopixel-Ring diesen Würfel noch etwas magischer machen bzw. ein Strahlen ins Gesicht meiner Kinder bringen.

Haftungsausschluss

Die hier gezeigte Modifikation ist sehr detailiert beschrieben und zeigt, wie du den original Ladeadapter der TonieBoxⓇ veränderst. Damit erlischt die Garantie und die Gewährleistung vom Hersteller, welche durch berrybase oder mir (Jörn Weise) nicht übernommen wird. Sollte es beim Zusammenbau zu Defekten oder anderen Schäden kommen, übernimmt weder berrybase noch ich (Jörn Weise) als Autor jegliche Haftung oder Schadensansprüche. Die Modifikation erfolgt durch dich und damit übernimmst du jegliche Verantwortung!

Intelligente Ladeüberwachung mit Lichtindikatoren

Wie schon erwähnt, gibt die TonieBoxⓇ visuell und über einen speziellen Ton während der Wiedergabe an, dass der Akku langsam leer ist. Auf der Oberseite der Box ist das durch ein rotes Quadrat zu erkennen. Wird nun die Ladestation angeschlossen, wird ein anderer Ton abgespielt bzw. die TonieBoxⓇ startet und danach ist das Quadrat grün.

In meinem Fall überwache ich den Strom zwischen Netzteil des Ladeadapters und TonieBoxⓇ mittels eines INA219 und verändere so die Farbe bei einem Neopixel-Ring. Der Ladeadapter ist dabei auf einem selbst gedruckten Gehäuse eingefasst und die Elektronik sitzt im Inneren, geschützt vor den Kindern. Das Gehäuse selbst ist halbtransparent, so dass die Farben vom Neopixel-Ring durch das Gehäuse scheinen können.

Wird nun die TonieBoxⓇ geladen, wird diese durch den Neopixel-Ring in wechselnden Farben angeleuchtet. Ist die TonieBoxⓇ aufgeladen, wird diese in einem grünen Schein angeleuchtet.

Damit das nicht immer sein muss, gibt es zwei getrennte Stromkreise:

• Ladeadapter mit zwischengeschalteter Strommessung
• Versorgung der Komponenten für den Lichteffekt

Damit kann die TonieBoxⓇ auch ohne Lichteffekt geladen werden, gerade über Nacht braucht es den Lichteffekt nicht. Durch einen verbauten Ein/Aus-Schalter kann zusätzlich zum separaten Stromadapter die Versorgung der Komponenten für die Lichteffekte geschaltet werden.

Das brauchst du für die TonieBoxⓇ-DIY-Ladestation

Um das hier gezeigte nachzubauen, brauchst du folgende Komponenten (der jeweilige Link geht zum Shop):

• D1 Mini
• Kupferlitzen in unterschiedlichen Farben
• Streifenrasterplatine
• Step-Down Netzteilmodul
• INA219 Stromsensor
• NeoPixel Ring mit 32 WS2812
• Wippschalter, 1-polig
• DC-Einbaubuchse für Hohlstecker 5,5×2,5mm
• Schaltnetzteil 12 mit Hohlstecker 5,5 x 2,5 mm

Zusätzlich sind noch folgende Bauteile / Werkzeuge nötig:

• Lötstation mit allem fürs Löten
• Schraubenset mit M2, M2,5 und M3 Schrauben
• Rändelmuttern mit Innengewinde
• Jumper Cable Wire zum löten
• Hexdistanz-Schrauben
• Imbusschraubenset mit M2 bis M4 – Schrauben
• Sekundenkleber
• 3D-Drucker mit halbtransparentem Filament
• Wago-Klemme
• JST-XH Stecker-Kit
• TonieboxⓇ-Ladestation

Da hier viele Produkte benötigt werden, die es bei berrybase teilweise nicht zu kaufen gibt, wurde hierfür kein Warenkorb erstellt.

Die 3D-Druckteile müssen selbst gedruckt werden, Berrybase hat kein Baukit vorbereitet, welches die 3D-Druckteile beinhaltet. Zudem wird noch separates Werkzeug benötigt.

Die Elektronik der Ladestation

Zunächst einmal ein paar Grundgedanken für die Elektronik, siehe Abbildung 1.

Mittels eines externen 12 Volt Netzteils soll der D1 Mini, der Neopixel-Ring und der INA219 mit Strom und Spannung versorgt werden. Da diese Bauteile aber maximal 5 Volt vertragen, muss die Spannung zunächst mittels StepDown-Modul auf die richtige Spannung geregelt werden. Da ich für die Zukunft nicht weiß, wie viel Strom gebraucht wird, ist das Netzteil so gewählt, dass ich 3 Ampere bzw. 36W Leistung zur Verfügung habe. Der Ein- und Ausschalter ist in der Skizze noch nicht vorhanden, dieser kam später dazu und befindet sich zwischen der 12V-Buchse und dem StepDown-Modul. Über die Pins D1 bis D3 wird der Neopixel-Ring und das INA219 angesteuert bzw. ausgelesen.

Der zweite Ladeadapter ist eine zerschnittene original TonieⓇ-Ladestation, bitte nicht die USB-Variante, die später den Akku der TonieBoxⓇ lädt. Dazwischen ist der INA219 geschaltet, der Strom und Spannung ausliest.

Für die Streifenrasterplatine hieß das, dass eine Verbindung zu dem externen 5V-Anschluss vom D1 Mini gebraucht wurde, der aber gleichzeitig die weitere Komponente mit Spannung und Strom versorgte. Letztlich sah die fertige Platine wie in Abbildung 2 aus.

An der linken unteren Ecke ist der JST-XH-Anschluss für die 5V-Versorgung zu sehen. Würde der D1 Mini nun so eingesteckt, würde dieser den Pin für 3,3V mit 5V und den GPIO15 mit Ground belegen, was fatal wäre. Damit das nicht passiert, habe ich bei der Buchsenleiste die beiden Pins entfernt. Theoretisch hätte ich die Buchsenleiste auch kürzen können, so gefiel es mir aber besser.

Bei den beiden oberen JST-XH-Buchsen, ist die linke für den Neopixel-Ring und die rechte für den INA219 vorgesehen. Bei dem Neopixel-Ring-Anschluss ist der PinOut vom Ring nicht zurückgeführt, könnte aber später so verlötet werden.

Wie was verlötet ist, sieht man auch noch mal auf der Unterseite der Platine, siehe Abbildung 3.

Dadurch zeigt sich auch, warum ich an der Stelle eine Streifenrasterplatine gewählt habe, da ich mir so unnötige Lötarbeit erspare. Einzig die Unterbrechungen beim D1 Mini und den oberen JST-XH-Buchsen mussten mit einem kleinen Bohrer hergestellt werden. Somit sind die Signale auf der Platine sauber getrennt und ich verursache keinen Kurzschluss.

Wenn du dich gerade über die Form ein bisschen wunderst: Ich wollte an der Stelle so viel Platz wie nötig verwenden, damit ich später leichter weiterer Modifikationen durchführen kann. Da das Gehäuse etwas größer ist, hat mir das etwas in die Karten gespielt. Fertig mit aufgesteckten D1 Mini sieht die Platine wie in Abbildung 4 aus.

Für die Form der Streifenrasterplatine habe ich eine Sägevorlage in Autodesk Fusion 360 erstellt, die man später ganz einfach ausschneiden und aufmalen kannst, damit die Platine richtig sitzt. Diese kann auch als Bohrschablone, siehe die Links am Ende dieses Beitrags, direkt mitgenutzt werden, damit später die Bohrlöcher passen.

Das Gehäuse für die Box

Das Gehäuse für das Projekt war mit am schwierigsten. Zum einen musste ich auf den Druckraum von meinem Drucker achten, zum anderen mussten die Maße und die Abstände für die elektrischen Komponenten passen. Nicht zuletzt sollten Gewindeeinätze bzw. Rändelmuttern mit Innengewinde den ganzen Schraubverbindungen mehr Halt geben. Um noch mehr Platz zu haben, sollte so wenig Material wie nötig für den Druck benötigt werden. Beim Deckel war die Konstruktion noch recht einfach, aber der untere Teil vom Gehäuse war da schon schwieriger, siehe Abbildung 5.

Der Neopixel-Ring wird in der Mitte auf die Stege gesetzt und später mit etwas Heißkleber fixiert. Für die diversen Bauteile sind die Maße der Bohrlöcher vermessen und ins Innere am Boden übertragen worden. Bei der Platine mit dem D1 Mini musste ich etwas warten, da erst mit der fertigen Platine die Bohrlochabstände klar waren. An der oberen rechten Ecke sieht man den Durchlass für das TonieBoxⓇ-Kabel, für die Einbaubuchse zur Spannungsversorgung der inneren Elektronik und die Aussparung für den Ein-/Ausschalter. Damit später die Kinder nicht einfach in die Elektronik fassen können, sind an allen vier Seiten größere Gewindeeinätze bzw. Rändelmuttern mit Innengewinde verbaut, die später den Deckel samt Inbusschraube fest zusammenhalten.

Wie schon erwähnt, war der Deckel die einfachste Konstruktion an der ganzen Sache, siehe Abbildung 6.

Lediglich der Adapter und ein bisschen Kabel mussten sauber geführt werden und fest im Deckel sitzen. Die vier Vertiefungen an der Seite haben den passenden Durchmesser, damit später die Inbusschrauben nicht herausragen. Je nach 3D-Drucker hat die Aussparung für den Adapter etwas Spiel, daher habe ich diesen später einfach mit etwas Sekundenkleber fixiert.

Mit insgesamt 48h Druckzeit war dies zwar nicht mein längster Druck, aber kam schon nahe an meinen zeitaufwändigsten Druck heran.

Der Zusammenbau

Wie bereits erwähnt, hat der Druck vom Gehäuse sehr lange gedauert und das Gehäuse musste mehr als einmal modifiziert werden, damit alles passt. Das war aber auch nicht weiter tragisch und passiert durchaus auch öfter in der Industrie, bis das fertige Produkt auf den Markt kommt.

Zunächst, damit später die gesamten Bauteile auch halten, mussten die Gewindeeinsätze und Hexdistanz-Schrauben in das Gehäuse verbaut werden. Bei den Gewindeeinsätzen erhitzte ein Lötkolben den Einsatz und schmolz sich dann in das Gehäuse. Die Hexdistanz-Schrauben wurden dann in die Gewindeeinsätze verschraubt, siehe Abbildung 7.

Achtung an dieser Stelle: Da die Hexdistanz-Schrauben aus Plastik sind, müssen die Gewindeeinsätze gut abgekühlt sein! Daher empfehle ich, zunächst das Gehäuse mit allen Gewindeeinsätzen zu erhitzen und dann die nötigen Lötarbeiten vorzunehmen. Die Lötstation ist ja dann bereits im Einsatz.

Für dieses Projekt müssen folgende Bauteile gelötet werden:

• Einbaubuchse für die Spannungsversorgung, Phase in der Mitte
• Die Schraubklemmen am StepDown-Modul und INA 219
• Die Platine für den D1 Mini mit allen Verbindungen und Steckern
• Beim INA 219 mit Schrägstiftleisten die Spannungsversorgung und i²c-Verbindung

Damit später alles sauber aussieht, kommen Aderendhülsen, Flachsteckhülsen, JST-XH-Stecker und Crimp-Stecker an den diversen Verbindungen zum Einsatz, siehe Abbildung 8.

Gerade das Crimpen der verschiedenen Stecker benötigt etwas Übung

Noch nicht auf dem Bild zu sehen ist eine kleine Fixierung für das TonieBoxⓇ-Ladekabel in der oberen linken Ecke. Die Wago-Klemme wurde später ebenfalls mit etwas Sekundenkleber am Boden festgeklebt, damit es nicht so raschelt, wenn man die Ladestation bewegt. Jetzt zeigt sich auch, dass noch viel Platz vorhanden ist, um später weitere Modifikationen vorzunehmen. Soll der D1 Mini mit einem neuen Update versorgt werden, so kann dieser aus dem Socket gezogen werden und im Anschluss spielend einfach wieder eingesteckt werden. Gerade beim Neopixel-Ring musst du ein bisschen beim Löten aufpassen, da hier das Anlöten von Kabellitzen etwas knifflig ist. Der Kabelbinder unten rechts dient nur zum besseren Halt, damit man später beim Zusammenbau mit dem Deckel die Kabel nicht quetscht.

An der Stelle noch ein wichtiger Hinweis zum StepDown-Modul: Dieses muss zwingend korrekt eingestellt werden, weswegen du ein Digitales Mulitmeter brauchst! Bei der Auslieferung ist keine feste Spannung oder Strom eingestellt, was über die beiden Schrauben bei den Bauteilen W 103 vorgenommen wird. Ist die Spannung zu hoch, werden alle angeschlossenen Bauteile beim ersten Einschalten defekt sein. Daher zunächst die Platine mit dem D1 Mini nicht anschließen und die Ausgangsspannung auf ~5 V bei einem Ausgangsstrom von ~ 2 A einstellen! Hier auf jeden Fall mehrfach den Strom und die Spannung prüfen, bevor die Platine angeschlossen wird.

Damit sollte der Zusammenbau der Hardware hinreichend erklärt sein. Gerade bei der Elektronik sollte ein Blick ins Kapitel Die Elektronik geworfen werden, damit auch alles richtig verbunden ist.

Der Programmcode

Bisher ist der D1 Mini und der Rest der Elektronik erst einmal nur verbunden, der letzte Teil steckt in der Programmierung. Wie in meinem früheren Blog zum Thema Visual Studio Code mit PlatformIO, habe ich den Quellcode eben über PlatformIO geschrieben. Hintergrund ist, dass schnell und einfach ein anderer MicroController eingesetzt und parametriert werden kann, sollte der D1 Mini eben nicht mehr ausreichen.

Wesentlich sind bei dem Programmcode drei Dateien:

• platformio.ini
• main.h
• main.cpp

Zwar liefert mein Repository (siehe am Ende vom Beitrag) noch weitere Dateien, aber für das Bearbeiten vom Code sind diese drei Dateien die wichtigsten, siehe Abbildung 9.

Die platformio.ini beinhaltet alle wesentlichen Konfigurationen, damit später das Projekt kompiliert werden kann. Zum einen sind die wichtigen MicroController-Bibliotheken, die PlatformIO ggf. noch nachladen muss, zum anderen auch Bibliotheken für unsere Komponenten und Basiseinstellungen hinterlegt.

Da ich mit dem Arduino Uno und dem Arduino Nano zu Anfang ein bisschen experimentiert habe, sind diese MicroController noch in der platformio.ini vorhanden. Der Default-MicroController ist aber der D1 Mini.

Interessant ist an der Stelle vllt. auch noch der Absatz mit dem build_flags, siehe Code 1.

build_flags = -D D1MINI -D DEBUG_MODE=0

Code 1: Build-flags für den D1 Mini

Damit habe ich später die Möglichkeit im Quellcode, wie in meinem Fall, die Pins für den Neopixel-Ring auf für die MicroController unterschiedlich zu definieren.

Ein kurzer Blick in die main.h sollte schnell zeigen, dass wesentliche Bibliotheken eingebunden, Defines und globale Variablen erzeugt und Funktionen deklariert werden, siehe Code 2.

/****** INCLUDES ******/
#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_INA219.h>
#include <Adafruit_NeoPixel.h>

/****** DEFINES ******/
/****** TIMER ******/
#define DEFUPDATEINTERVAL 2000
#define DEFUPDATETIMECIRVLE 100
#define DEFBRIGTHNESS       100
/****** NEOPIXEL ******/
#ifdef D1MINI
    #define DEFNEOPIN 0     //Pin D3
#endif
#ifdef ARDUINO_UNO
    #define DEFNEOPIN 8     //Pin D3
#endif

#define DEFNUMLEDS 32   //Number of LEDs
#define DEFMAXHUE 256 * 6
/****** INA219 ******/
#define DEFTHRESHOLDLOADED 50
#define DEFTHRESHOLDLOAD 400

/****** FUNCTIONS ******/
/*
 * Function: setup
 * Description: setup-function
 * Return: void
 */
void setup();

/*
 * Function: loop
 * Description: loop-function
 * Return: void
 */
void loop();

/*
 * Function: checkParameters
 * Description: Get latest paramaters from INA219
 * Return: void
 */
void checkParameters();

/*
 * Function: recolorNeopixel
 * Description: Get latest paramaters from INA219
 * IN bLoaded: Bool to that indicate loaded or not
 * Return: void
 */
void recolorNeopixel(bool bLoaded = false);

/*
 * Function from https://github.com/RoboUlbricht/arduinoslovakia/blob/master/neopixel/hsv_rainbow_circle_rotate/hsv.h
 * Based from: RoboUlbricht
 */
uint32_t getPixelColorHsv(uint16_t n, uint16_t h, uint8_t s, uint8_t v);

Adafruit_INA219 ina219;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(DEFNUMLEDS, DEFNEOPIN, NEO_GRB + NEO_KHZ800);
float shuntvoltage = 0;
float busvoltage = 0;
float current_mA = 0;
float loadvoltage = 0;
float power_mW = 0;
int iPosition = 0;
int iHue = 0;

Code 2: Quellcode von main.h

Die Kommentare und Namen sollten helfen zu verstehen, wofür die einzelnen Teile gebraucht werden. Da ich hier erst einmal meine Basisidee umgesetzt habe, ist der Umfang noch übersichtlich. Kommen wir damit zu der main.cpp, siehe Code 3.

#include "main.h"

void setup()
{
  Serial.begin(115200);
  while (!Serial)
  {
    ;
  }

  Serial.println("Serial monitor online!");
  if (!ina219.begin())
  {
    Serial.println("Failed to find INA219 chip");
    while (1)
    {
      delay(10);
    }
  }
  strip.setBrightness(DEFBRIGTHNESS);
  Serial.println("Measuring voltage and current with INA219 ...");
  strip.begin();
}

void loop()
{
  //ßSerial.print("Start loop");
  static unsigned long ulLastUpdate = 0;
  static unsigned long ulLastCircle = 0;
  static bool bPixelOff = false;

  if (millis() - ulLastUpdate > (unsigned long)DEFUPDATEINTERVAL)
  {
    checkParameters();
    ulLastUpdate = millis();
  }

  if ((int)current_mA >= (int)DEFTHRESHOLDLOAD)
  {
    if ((millis() - ulLastCircle) > (unsigned long)DEFUPDATETIMECIRVLE)
    {
      recolorNeopixel(false);
      iPosition++;
      iPosition %= (int)DEFNUMLEDS;
      iHue += 2;
      iHue %= (int)DEFMAXHUE;
      ulLastCircle = millis();
    }
    if (bPixelOff)
      bPixelOff = false;
  }

  if ((int)current_mA > (int)DEFTHRESHOLDLOADED && (int)current_mA < (int)DEFTHRESHOLDLOAD)
  {
    if ((millis() - ulLastCircle) > (unsigned long)DEFUPDATETIMECIRVLE)
    {
      recolorNeopixel(true);
      iPosition++;
      iPosition %= (int)DEFNUMLEDS;
      iHue += 2;
      iHue %= (int)DEFMAXHUE;
      ulLastCircle = millis();
    }
    if (bPixelOff)
      bPixelOff = false;
  }

  if (!bPixelOff && (int)current_mA <= (int)DEFTHRESHOLDLOADED)
  {
    strip.clear();
    strip.show();
    bPixelOff = true;
  }
}

void checkParameters()
{
  Serial.print("Start measuring");
  shuntvoltage = abs(ina219.getShuntVoltage_mV());
  busvoltage = abs(ina219.getBusVoltage_V());
  current_mA = abs(ina219.getCurrent_mA());
  power_mW = ina219.getPower_mW();
  loadvoltage = busvoltage + (shuntvoltage / 1000);

  Serial.print("Bus Voltage:   ");
  Serial.print(busvoltage);
  Serial.println(" V");
  Serial.print("Shunt Voltage: ");
  Serial.print(shuntvoltage);
  Serial.println(" mV");
  Serial.print("Load Voltage:  ");
  Serial.print(loadvoltage);
  Serial.println(" V");
  Serial.print("Current:       ");
  Serial.print(current_mA);
  Serial.println(" mA");
  Serial.print("Power:         ");
  Serial.print(power_mW);
  Serial.println(" mW");
  Serial.println("");
}

void recolorNeopixel(bool bLoaded)
{
  if (!bLoaded)
  {
    for (int i = 0; i < (int)DEFNUMLEDS; i++)
      strip.setPixelColor((i + iPosition) % (int)DEFNUMLEDS, getPixelColorHsv(i, iHue, 255, strip.gamma8(i * (255 / (int)DEFNUMLEDS))));
  }
  else
  {
    for (int i = 0; i < (int)DEFNUMLEDS; i++)
      strip.setPixelColor((i + iPosition) % (int)DEFNUMLEDS, getPixelColorHsv(i, 512, 255, strip.gamma8(i * (255 / (int)DEFNUMLEDS))));
  }
  strip.show();
}

uint32_t getPixelColorHsv(
    uint16_t n, uint16_t h, uint8_t s, uint8_t v)
{

  uint8_t r, g, b;

  if (!s)
  {
    // Monochromatic, all components are V
    r = g = b = v;
  }
  else
  {
    uint8_t sextant = h >> 8;
    if (sextant > 5)
      sextant = 5; // Limit hue sextants to defined space

    g = v; // Top level

    // Perform actual calculations

    /*
       Bottom level:
       --> (v * (255 - s) + error_corr + 1) / 256
    */
    uint16_t ww; // Intermediate result
    ww = v * (uint8_t)(~s);
    ww += 1;       // Error correction
    ww += ww >> 8; // Error correction
    b = ww >> 8;

    uint8_t h_fraction = h & 0xff; // Position within sextant
    uint32_t d;                    // Intermediate result

    if (!(sextant & 1))
    {
      // r = ...slope_up...
      // --> r = (v * ((255 << 8) - s * (256 - h)) + error_corr1 + error_corr2) / 65536
      d = v * (uint32_t)(0xff00 - (uint16_t)(s * (256 - h_fraction)));
      d += d >> 8; // Error correction
      d += v;      // Error correction
      r = d >> 16;
    }
    else
    {
      // r = ...slope_down...
      // --> r = (v * ((255 << 8) - s * h) + error_corr1 + error_corr2) / 65536
      d = v * (uint32_t)(0xff00 - (uint16_t)(s * h_fraction));
      d += d >> 8; // Error correction
      d += v;      // Error correction
      r = d >> 16;
    }

    // Swap RGB values according to sextant. This is done in reverse order with
    // respect to the original because the swaps are done after the
    // assignments.
    if (!(sextant & 6))
    {
      if (!(sextant & 1))
      {
        uint8_t tmp = r;
        r = g;
        g = tmp;
      }
    }
    else
    {
      if (sextant & 1)
      {
        uint8_t tmp = r;
        r = g;
        g = tmp;
      }
    }
    if (sextant & 4)
    {
      uint8_t tmp = g;
      g = b;
      b = tmp;
    }
    if (sextant & 2)
    {
      uint8_t tmp = r;
      r = b;
      b = tmp;
    }
  }
  return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
}

Code 3: Der Quellcode der main.cpp

Die setup()-Funktion startet zunächst einmal die serielle Verbindung, versucht eine Verbindung zum INA219 durch die i²c-Verbindung herzustellen und stellt die Helligkeit und die Verbindung zum Neopixel-Ring her.

Danach folgt die loop()-Funktion, die in einem festen Intervall die aktuellen Werte vom INA219 abfragt. Dazu wird die Funktion checkParameters() aufgerufen und alle Werte vom INA219 ausgelesen und in die entsprechende globale Variable gespeichert. Anschließend werden die Werte noch über die serielle Verbindung ausgegeben. Direkt im Anschluss wird geprüft, ob die TonieBoxⓇ nun lädt, geladen ist oder eventuell keine TonieBoxⓇ auf der Ladestation steht. Der Neopixel-Ring wird dann entsprechend eingefärbt. Sollte keine TonieBoxⓇ auf der Ladestation sein oder geladen und abgeschaltet sein, wird der Neopixel-Ring ausgeschaltet. Möglich machen dies die vorher ermittelte Werte über den Ladestrom, welche als DEFTHRESHOLDLOADED und DEFTHRESHOLDLOAD in der main.h hinterlegt sind. Durch zwei verschachtelte if-Anweisungen und eine Timer-Abfrage, wird so der Neopixel-Ring entsprechend angesteuert. An dieser Stelle soll der GitHub-User Robo Ulbricht erwähnt werden, dessen Quellcode ich zur Definition der einzelnen Farben für den Neopixel-Ring aus dem Repository hsv_rainbow_circle_rotate übernommen habe. Entsprechende Verweise findest du auch in der main.h.

Letztlich muss der komplette Quellcode noch auf den D1 Mini übertragen werden. Das habe ich in meinem Blogbeitrag zu PlatformIO genau erklärt. Dennoch soll Abbildung 10 es noch einmal kurz erläutern:

Vergewissere dich, dass in der unteren Leiste unter env der D1 Mini ausgewählt ist. Sollte dies nicht der Fall sein kannst du dies über zwei einfach Klicks erledigen. Danach drückst du den Pfeil, siehe Abbildung 10, um den Quellcode zu kompilieren und zu übertragen. Solltest du das Projekt zum ersten Mal geöffnet haben, kann es zu Fehlermeldungen kommen: Das ist erst einmal nicht schlimm, da im Hintergrund PlatformIO ggf. zunächst einmal wesentliche Pakete für den MicroController und das Framework herunterladen muss, sofern du noch nie mit dem D1 Mini und der espressif8266-Platform gearbeitet hast. Ein Indikator dafür ist die Fehlermeldung command ‘platformio-ide.build’ not found, welche dir anzeigt, dass PlatformIO erst einmal die benötigten Pakete laden muss. Je nach Internetleitung kann das ein bisschen Zeit in Anspruch nehmen. Warte einen kurzen Moment und versuchen den Upload noch einmal.

Der Finale Test

Wenn der Quellcode auf dem D1 Mini upgeloaded ist, kannst du nun testen, ob alles korrekt funktioniert. Hierzu solltest du eine nicht geladene TonieBoxⓇ auf den Ladeadapter stellen und der LED-Ring sollte anfangen in allen Farben zu leuchten. Sollte dies der Fall sein, kannst du alles zusammenbauen und deinen Kindern eine große Freude machen. Sollte unerwarteterweise etwas nicht stimmen, so solltest du mit Jumper-Kabeln und einer direkten Verbindung zum Computer prüfen, welche Stromwerte der INA219 zurückliefert. Ggf. musst du die Grenzen für Laden und Aufgeladen umdefinieren und erneut testen. Je nach Meldung im seriellen Monitor kann aber auch ein Defekt eines Bauteils die Ursache sein, die du beheben musst. An der Stelle noch einmal die dringliche Warnung, dass beim StepDown-Modul die Ausgangsspannung und -strom zuvor eingestellt werden muss!

Wo du alles findest

Damit du dieses Projekt nachbauen kannst, musst du Dir aus verschiedenen Quellen die Teile vom Projekt zusammensammeln und besorgen.

Das Programm zu diesem Blog findest du bei GitHub im Repository von berrybase. Der folgende Link leitet dich zu dem passenden Repository. Auch die .stl-Dateien für den 3D-Druck sind hier hinterlegt:
https://github.com/M3taKn1ght/TonieBox_Charger

Fazit zur DIY Ladestation

Als ich mit meiner Idee angefangen habe und meine Kinder davon Wind bekommen haben, war mir der Aufwand und die Möglichkeiten noch gar nicht bewusst. Aktuell macht der verbaute D1 Mini noch recht wenig, im Prinzip hätte es auch ein Arduino Nano getan. Jedoch ist geplant, über das WLAN eine Weboberfläche bereitzustellen, die mir weitere Kontrolle über den Neopixel-Ring gibt. Denkbar wären weitere Lichteffekte, eingebaute Zeitsteuerungen oder Anpassungen bei den Stromwerten, welche dann ins EEPROM geschrieben werden. Den Möglichkeiten mit dem D1 Mini sind da fast keine Grenzen gesetzt. Da im Inneren des Ladestation noch viel Platz ist, kann noch weitere Hardware verbaut werden. Auch die Streifenrasterplatine bietet noch viel Platz um weitere Anschlüsse anzubringen. Denkbar sind weitere Sensoren oder Aktoren oder ein kleines Status-Display an der Seite, welches Informationen über den Ladezyklus gibt. Wie du siehst, mit ein bisschen Fantasie und Kreativität kommen schnell neue Verbesserungen hinzu.