MediKit

Aus HRW FabLab MediaWiki
Wechseln zu: Navigation, Suche
MediKit

Medikit1.jpeg

Entwickler

Enis Ince, Michael Gurevich, Enis Uysal

Projektdateien

Google Drive

Verwendete Programmiersprache

Arduino, C

Eingesetzte Software

Arduino IDE, Autodesk Fusion 360 , Cura

Verwendete Arduino-Bibliotheken

WiFi, WiFiClientSecure, Time, UniversalTelegramBot,

Eingesetzte Hardware

Ultimaker 2+, Ultimaker 3


MediKit ist eine smarte Pillenbox, die ihren Anwender per Push-Notification benachrichtigt und ihn daran erinnert seine Tabletten einzunehmen.
Der Vorteil an dieser Box ,ist, dass auch Angehörige des Anwenders Zugriff auf die Notification haben und gegebenenfalls zusätzlich nochmal daran erinnern können, falls die Tabletten nicht eingenommen wurden.
Die Box erkennt, ob das Fach geöffnet wurde und schickt eine Nachricht an die Angehörigen, ob die Box geöffnet wurde oder nicht. Sollte die Box nicht geöffnet werden, werden alle registrierten Nutzer erneut informiert.


Motivation[Bearbeiten]

Medikit Prototyp
Präsentationsplakat Medikit

Durch die von dem Modul angebotene Veranstaltung in Düsseldorf und dem Projekt-Tindern, hat sich unsere Gruppe auf die Umsetzung der Box geeinigt. Da dieses Projekt zur Hilfe für Menschen mit Behinderungen gedacht ist und uns zahlreiche Beispiele beim Projekt-Tindern gezeigt wurden, wir uns jedoch mit keinem der Projekte identifizieren konnten, haben wir uns dazu entschlossen, diese Box für eine Person zu entwickeln, die aus unserem eigenen Bekanntenkreis stammt. Diese Person vergisst es immer wieder ihre Tabletten zu sich zu nehmen, da sie an Demenz leidet und wir ihr eine Vereinfachung bieten wollten, damit sie sich leichter daran erinnern kann.

Idee[Bearbeiten]

Um dies zu ermöglichen, haben wir eine Box entwickelt, wo der Nutzer seine Medikamente oder Ähnliches lagert und per Applikation benachrichtigt wird, sobald er diese einnehmen soll. Außerdem soll ohne die Benachrichtigung erkannt werden können, welche Medikamente eingenommen werden sollen. Deshalb haben wir uns für eine Box mit mehreren Fächern entschieden, die jeweils eine LED-Leuchte besitzen und angehen, sobald die eingestellte Zeit erreicht ist. Wir haben uns für eine Gesamtanzahl von 14 Fächern entschieden, da viele Medikamente entweder morgens oder abends eingenommen werden sollen und die Box somit für mindestens eine Woche ausreicht. Alternativ kann die Box zum Beispiel auch für zwei Wochen verwendet werden. Da unsere Bezugsperson an Demenz leidet, ist unser System darauf ausgelegt, nicht nur den Nutzer, sondern auch zum Beispiel den Pfleger oder den Angehörigen zu benachrichtigen, um den Nutzer gegebenenfalls anderweitig zu erinnern. Aus diesem Grund haben wir ebenfalls einen Button in die Box eingebaut, der eine Benachrichtigung sendet, dass die Box verwendet wurde. Die Zeitintervalle können zu jederzeit angepasst werden, falls sich die Einnahmezeiten des Nutzers ändern.

Telegram[Bearbeiten]

Unsere erste Wahl war eine Benachrichtigung per E-Mail, aber wir haben uns doch aufgrund von leichterer Zugänglichkeit für eine Benachrichtigung via WhatsApp entschieden, welche die meist verbreitetste Messenger-App ist. Im Laufe der Entwicklung merkten wir jedoch, dass Telegram als Applikation die bessere Alternative darstellt. Dies hängt damit zusammen, dass WhatsApp aktiv gegen APIs vorgeht und veraltete Bibliotheken nutzt. Des Weiteren wird eine SIM-Karte für die Anwendung von WhatsApp benötigt. Telegram hingegen benötigt nur eine Internet-Verbindung. Wir haben einen interaktivem Dialog mit dem Bot entwickelt, um die Einstellung der Fächer zu vereinfachen und über den selben Chat benachrichtigt zu werden.

Beispiel-Dialog[Bearbeiten]

Hardware[Bearbeiten]

Produktionskosten[Bearbeiten]

Benötigte Produkte
Beschreibung Kosten in €/Stück Anzahl
ESP-32 8,99 1
Powerbank 8,50 1
Breadboard 3,85 1
Drahtkabel 0,10 32
LED-Leuchten 0,99 14
Button 0,99 1
Gesamtkosten: 26,52€



3D-Druck[Bearbeiten]

Die Box wurde mittels eines CAD-Programms konzipiert und durch einen 3D-Drucker gefertigt. Sie besteht aus 14 gleich großen Fächern, in denen die betroffene Person ihre tägliche Ration an Tabletten aufbewahren kann. In den jeweiligen Fächern wurden außerdem zwei kleine Löcher hinterlassen, um die LED-Leuchten besser in den einzelnen Fächern zu fixieren. Durch App-Konfigurationen kann zudem eingestellt werden, wann die Person die Tabletten einzunehmen hat, wann die Erinnerung gesendet und wann eine erneute Benachrichtigung gesendet werden soll, damit der verbaute Mikrocontroller die einzelnen Befehle ausführen kann. Im unteren Teil der Box wurde ein Hohlraum illustriert, um die benötigte Technik dort platzsparend unterbringen zu können. Dieser besitzt ebenfalls eine Einkerbung für ein Schiebefach, um eine spätere Veränderung der Technik leichter zugänglich zu machen. Des Weiteren ist ein Loch für einen Knopf enthalten.

Elektronik[Bearbeiten]

Die ESP32 ist mit einer Powerbank verbunden. Alternativ kann man auch mit einem Netzstecker und einem Mikro-USB-Kabel für die nötige Stromzufuhr sorgen. Außerdem werden 14 (eins pro Fach) Pins benötigt, um die entsprechenden LED-Leuchten anzusteuern. Diese sind über ein Breadboard per Drahtkabeln mit dem ESP32 verbunden. Hierbei ist darauf zu achten, dass nicht alle nummerierten Pins vom ESP32 verwendet werden können, da einige nur als Output dienen und andere bei einer Verwendung als Input zu einer unvorhergesehenen Reaktion (wie zum Beispiel einem permanenten Reboot) führen können. Wir empfehlen daher, die von uns verwendeten Pins zu verwenden. Ebenfalls wird ein Pin für die Verknüpfung mit dem Button benötigt. Da die große Anzahl an Kabeln (32 Stück), sowie der geringe Innenraum der Box wenig Spielraum lassen, empfehlen wir möglichst kurze Kabel zu verwenden, um Platz zu sparen.

Code[Bearbeiten]

Hier werden die einzelnen Bestandteile des Codes für den ESP32 beschrieben und erläutert, um ein besseres Verständnis für die eigene Implementation zu bekommen. Falls der Code verwendet werden soll, empfehlen wir, die Projektdatei herunterzuladen.

Einbindungen[Bearbeiten]

Es müssen vier Bibliotheken eingebunden werden, damit der Code funktioniert. Zwei dieser Bibliotheken sind standardmäßig in Arduino IDE enthalten (WiFi & Time). Die beiden anderen müssen vorher heruntergeladen werden (WifiClientSecure & UniversalTelegramBot).

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <time.h>
#include <UniversalTelegramBot.h>
WLAN[Bearbeiten]

Dieser Teil wird benötigt, um den ESP32 mit dem W-LAN zu verbinden. Die SSID und das Passwort müssen hinzugefügt werden. Falls der ESP32 keine Verbindung zum Internet herstellen kann, wird der restliche Code nicht weiter ausgeführt.

// Initialize Wifi connection to the router
char ssid[] = " ";     // your network SSID (name)
char password[] = " "; // your network key
WiFiClientSecure client;
void setup() {
  Serial.begin(115200);
  Serial.print("Connecting Wifi: ");
  Serial.println(ssid);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
       Serial.print(".");
       delay(500);
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}
Zeit[Bearbeiten]

Mit Hilfe von diesem Code wird die richtige Zeitzone eingestellt und die richtige Umwandlung in ein verwendbares Zeitform gewährleistet.

int timezone = 1 *3600;
int dst = 0;
void setup(){
  configTime(timezone, dst, "pool.ntp.org","time.nist.gov");
  Serial.println("\nWaiting for Internet time");

  while(!time(nullptr)){
     Serial.print("*");
     delay(1000);
  }
  Serial.println("\nTime response....OK");   
}
Telegram-Verbindung[Bearbeiten]

Hier werden die Standard-Nutzer-ID, sowie der Bot Token eingestellt. Die Standard-ID kann ausgelassen werden, jedoch ist es unumgänglich einen Bot Token zu benutzen. Dieser kann mit anderen Telegram-Bots, wie zum Beispiel "Botfather" generiert werden.

String defaultID =  ""; // TelegramID || Get from Botfather
// Initialize Telegram BOT
 // your Bot Token (Get from Botfather)
#define BOTtoken ""
UniversalTelegramBot bot(BOTtoken, client);
int Bot_mtbs = 1000; //mean time between scan messages
long Bot_lasttime;   //last time messages' scan has been done
Telegram-Nachrichten[Bearbeiten]

Hier wird der Text für den ersten Dialog definiert. Dieser beinhaltet weitere Befehle, die man an einem /NameDesBefehels erkennt. Telegram ist dazu in der Lage diese klickbar zu machen. Des Weiteren befindet sich hier eine Funktion, um aus den enum-Werten für die Wochentage, die nur Zahlen sind, richtige Texte zu erstellen, die für den weiteren Dialog benötigt werden.

String startText = "Wir können starten. Bitte wähle einen der folgenden Befehle aus, um das jeweilige Fach zu bearbeiten.\n /fach0 \n /fach1 \n /fach2 \n /fach3 \n /fach4 \n /fach5 \n /fach6 \n /fach7 \n /fach8 \n /fach9 \n /fach10 \n /fach11 \n /fach12 \n /fach13  ";
String fachText = String("Welchen Befehl möchtest du ausführen ? \n /zeit - Benachrichtigungszeit einstellen \n /licht - Licht einstellen \n /umschalten - Fach an- oder ausschalten");


String enumToName(enum day tago) 
{
   switch (tago) 
   {
      case 1: return "Montag";
      case 2: return "Dienstag";
      case 3: return "Mittwoch";
      case 4: return "Donnerstag";
      case 5: return "Freitag";
      case 6: return "Samstag";
      case 0: return "Sonntag";
   }
}
Initialisierung der Fächer[Bearbeiten]

Hier werden die Anzahl der Fächer definiert, sowie das zunächst ausgewählte Fach ausgewählt. Der String fachString wird benötigt, um eine sinnvolle Ausgabe des aktuellen Fachs zu garantieren.

int fachNummer = 0;
String fachString = "0";
const int fachAnzahl = 14;

Hier wird das enum für die Wochentage erzeugt.

//Wochentage
enum day {
  Montag = 1,
    Dienstag = 2,
    Mittwoch = 3,
    Donnerstag = 4,
    Freitag = 5,
    Samstag = 6,
    Sonntag = 0
};

Hier wird eine Struktur für ein Fach mit gewissen Eigenschaften entwickelt. Die Eigenschaften beinhalten die festgelegte Zeit (Minute, Stunde, Tag), ob das Fach aktiviert ist, ob das Licht aktiviert ist, sowie den zugehörigen Licht-Pin für den ESP32.

//Fach Objekt
struct fachObject {
  int licht;
  bool enabled = true;
  bool lichtAn = false;
  int stunde = 0;
  int minute = 0;
  day tag = Montag;

}
abteile[fachAnzahl];

Hier werden die Licht-Pins für die Fächer definiert. und zunächst auf aus gesetzt (INPUT). Wir weichen hier vom gängigen Befehl ab (digitalWrite), da es ansonsten zu Komplikationen mit dem ESP32 kommt, der durch zu viele gleichzeitig aktivierte Pins in den Reboot-Modus geschaltet wird.

void setup() {

  pinMode(0, OUTPUT);
  abteile[0].licht = 13;
  abteile[1].licht = 12;
  abteile[2].licht = 14;
  abteile[3].licht = 27;
  abteile[4].licht = 26;
  abteile[5].licht = 25;
  abteile[6].licht = 33;
  abteile[7].licht = 32;
  abteile[8].licht = 16;
  abteile[9].licht = 17;
  abteile[10].licht = 19;
  abteile[11].licht = 21;
  abteile[12].licht = 22;
  abteile[13].licht = 23;

  for (int i = 0; i < 14; i++) {
    pinMode(abteile[i].licht, INPUT);
  }
}
Zeit Funktionen[Bearbeiten]

Hier wird ein String zurückgegeben, der die aktuelle Zeit eines bestimmten Faches enthält, um dem Nutzer diese im Dialog anzeigen zu können.

String zeitPunkt(int f){
  if (f>=0 && f<14){
  String stundeText;
      String minuteText;
      if (abteile[f].stunde>=0 && abteile[f].stunde<10){
        stundeText=(String) 0 + (String) abteile[f].stunde;
        }
        else if (abteile[f].stunde>=10 && abteile[f].stunde<24){
           stundeText= (String) abteile[f].stunde;
        }
              if (abteile[f].minute>=0 && abteile[f].minute<10){
        minuteText=(String) 0 + (String) abteile[f].minute;
        }
        else if (abteile[f].minute>=10 && abteile[f].minute<60){
           minuteText= (String) abteile[f].minute;
        }
        return enumToName(abteile[f].tag) + " um " + stundeText + ":" + minuteText;
        }
        else return "Fehler!";
}

Diese Funktion gibt die aktuelle Zeit für das aktuell ausgewählte Fach aus. Es handelt sich quasi um eine Erweiterung der Funktion zeitPunkt().

     void aktuelleZeit(){
      
           String aktuelleZeit = "Aktuell erhälst du für das Fach " + (String) fachNummer + " am " + zeitPunkt(fachNummer) + " eine Benachrichtigung.";
         bot.sendMessage(defaultID, aktuelleZeit, "");
         Serial.println("Stunde: " + (String) abteile[fachNummer].stunde + " Minute: " + (String) abteile[fachNummer].minute + " Tag: " + (String) abteile[fachNummer].tag);
         }


Diese Funktion gibt die möglichen Befehle, um die Zeiten für die Fächer einzustellen aus. Diese beinhalten /Minute, /Stunde und /Tag.

      void zeit(){ 
        String zeitText = "Hier kannst du den Benachrichtigungszeitpunkt für das Fach " + (String) fachNummer + " einstellen. Was möchtest du verändern ? \n /tag - Wochentag einstellen \n /stunde - Stunde einstellen \n /minute - Minute einstellen";
       bot.sendMessage(defaultID, zeitText, "");
       aktuelleZeit();
         
        }

Erweiterte Zeitfunktionen[Bearbeiten]

Diese Funktion gibt die möglichen Befehle aus, um den Tag, an dem eine Benachrichtigung erscheinen soll einzustellen.

void tag() {
  String tagText = "An welchem Tag möchtest du eine Benachrichtigung für das Fach " + (String) fachNummer + " bekommen?\n /t1 - Montag \n /t2 - Dienstag \n /t3 - Mittwoch \n /t4 - Donnerstag \n /t5 - Freitag \n /t6 - Samstag \n /t0 - Sonntag \n ";
  bot.sendMessage(defaultID, tagText, "");
}

Diese Funktion stellt den Tag für das ausgewählte Fach ein. Als Parameter erhält sie einen String (die letzte erhaltene Nachricht) und prüft diesen, ob er eine sinnvolle Zahl erhält. Anschließend stellt die Funktion den Tag um.

void tag2(String lastMessage) {
  String zahl;
  if (strstr(lastMessage.c_str(), "/t")) {
    for (char & c: lastMessage) {
      if (isdigit(c)) {
        zahl += c;
      }
    }
    int zahl2 = zahl.toInt();
    if (zahl2 >= 0 && zahl2 < 7) {
      abteile[fachNummer].tag = (day) zahl2;
    }
    String wochenTag = (String) enumToName(abteile[fachNummer].tag);
    String tag2Text = "Tag für das Fach " + (String) fachNummer + " wurde auf " + wochenTag + " gesetzt.";
    bot.sendMessage(defaultID, tag2Text, "");
    restart();
  } else {
    bot.sendMessage(defaultID, "Fehler!", "");
    restart();
  }
  aktuelleZeit();
}


Diese Funktion gibt die möglichen Befehle aus, um die Stunde, an der eine Benachrichtigung erscheinen soll einzustellen.

void stunde() {
  String stundeText = "An welcher Stunde möchtest du eine Benachrichtigung für das Fach " + (String) fachNummer + " bekommen?\n /s01 /s02 /s03 /s04 \n /s05 /s06 /s07 /s08 \n /s09 /s10 /s11 /s12 \n /s13 /s14 /s15 /s16 \n /s17 /s18 /s19 /s20 \n /s21 /s22 /s23 /s24 ";
  bot.sendMessage(defaultID, stundeText, "");
}

Diese Funktion stellt die Stunde für das ausgewählte Fach ein. Als Parameter erhält sie einen String (die letzte erhaltene Nachricht) und prüft diesen, ob er eine sinnvolle Zahl erhält. Anschließend stellt die Funktion die Stunde um.

 void stunde2(String lastMessage) {
  String zahl;
  if (strstr(lastMessage.c_str(), "/s")) {
    for (char & c: lastMessage) {
      if (isdigit(c)) {
        zahl += c;
      }
    }
    int zahl2 = zahl.toInt();
    if (zahl2 >= 0 && zahl2 < 24) {
      abteile[fachNummer].stunde = zahl2;
      String stunde2Text = "Stunde für das Fach " + (String) fachNummer + " wurde auf " + abteile[fachNummer].stunde + " Uhr gesetzt.";
      bot.sendMessage(defaultID, stunde2Text, "");
      restart();
    } else {
      bot.sendMessage(defaultID, "Fehler!", "");
      restart();
    }
  }
  aktuelleZeit();
}


Diese Funktion gibt die möglichen Befehle aus, um die Minute, an der eine Benachrichtigung erscheinen soll einzustellen.

void minute() {
  String minuteText = "An welcher Minute möchtest du eine Benachrichtigung für das Fach " + (String) fachNummer + " bekommen? Du kannst auch eine eigene Zahl eingeben, wenn es dem Format folgt:\n /m00 \n /m10 \n /m20 \n /m30 \n /m40 \n /m50 ";
  bot.sendMessage(defaultID, minuteText, "");
}

Diese Funktion stellt die Minute für das ausgewählte Fach ein. Als Parameter erhält sie einen String (die letzte erhaltene Nachricht) und prüft diesen, ob er eine sinnvolle Zahl erhält. Anschließend stellt die Funktion die Minute um.

void minute2(String lastMessage) {
  String zahl;
  if (strstr(lastMessage.c_str(), "/m")) {
    for (char & c: lastMessage) {
      if (isdigit(c)) {
        zahl += c;
      }
    }
    int zahl2 = zahl.toInt();
    if (zahl2 >= 0 && zahl2 < 60) {
      abteile[fachNummer].minute = zahl2;
      String minute2Text = "Minute für das Fach " + (String) fachNummer + " wurde auf " + abteile[fachNummer].minute + " gesetzt.";
      bot.sendMessage(defaultID, minute2Text, "");
      restart();
    } else {
      bot.sendMessage(defaultID, "Fehler!", "");
      restart();
    }
  }

  aktuelleZeit();
}
Sonstige Funktionen[Bearbeiten]

Diese Funktion sendet einen Standard-Text, um den Telegram-Dialog erneut zu beginnen.

void restart(){
   bot.sendMessage(defaultID, "Drücke /start, um die Befehle erneut zu sehen.", "");
}


Diese Funktion stellt das ausgewählte Fach ein. Als Parameter erhält sie einen String (die letzte erhaltene Nachricht) und prüft diesen, ob er eine sinnvolle Zahl erhält. Anschließend stellt die Funktion das ausgewählte Fach um.

 void fach(String lastMessage){
    String zahl;
      if (strstr(lastMessage.c_str(), "fach")){
        for(char& c : lastMessage) {
          if (isdigit(c)) {zahl+=c;}
           }
           int fa = atoi(zahl.c_str());
      if (fa >=0 && fa<14){
      fachNummer = fa;
       fachString = (String) fachNummer;
   }
 }
        zahl =String (fachNummer);
        String messago = "Du hast Fach " + zahl + " gewählt.";
        bot.sendMessage(defaultID, messago, "");
  }

Diese Funktion wird über den Button-Druck aufgerufen. Sie sendet eine Telegram-Nachricht an den Nutzer, dass die Box verwendet wurde und schaltet alle Lichter aus.

void button() {
  for (int i; i < fachAnzahl; i++) {
    abteile[i].lichtAn = false;
    pinMode(abteile[i].licht, INPUT);
  }
  String buttonMessage = "Der Nutzer hat die Pillenbox verwendet. Lichter wurden ausgeschaltet.";
  bot.sendMessage(defaultID, buttonMessage, "");
  restart();
}

Diese Funktion dient zu Test- und Veranschaulichungszwecken. Mit dieser kann man das Licht für das aktuelle Fach einschalten.

  void licht() {
    abteile[fachNummer].lichtAn = true;
    pinMode(abteile[fachNummer].licht, OUTPUT);
    digitalWrite(abteile[fachNummer].licht, LOW);
    String ligthMessage = "Das Licht für Fach " + fachString + " wurde eingeschaltet.";
    bot.sendMessage(defaultID, ligthMessage, "");
    restart();
  }


Mit dieser Funktion lassen sich einzelne Fächer aus- oder anschalten, um gegebenenfalls keine Benachrichtigung für das Fach zu erhalten, falls dieses nicht benötigt wird.

void enabled() {
  Serial.println("Status Eingeschaltet vorher " + (String) abteile[fachNummer].enabled + " Boxnummer" + (String) fachNummer);
  String state = "";
  if (abteile[fachNummer].enabled == true) {
    state = "ausgeschaltet";
    abteile[fachNummer].enabled = false;
  } else if (abteile[fachNummer].enabled == false) {
    state = "eingeschaltet";
    abteile[fachNummer].enabled = true;
  }
  Serial.println("Status Eingeschaltet danach " + (String) abteile[fachNummer].enabled + " Boxnummer" + (String) fachNummer);
  String enabledMessage = "Fach " + fachString + " wurde " + state + ".";
  bot.sendMessage(defaultID, enabledMessage, "");
  restart();
}
Loop-Funktion[Bearbeiten]

Dieser Abschnitt prüft, ob der Button betätigt wurde und führt gegebenenfalls die Button-Funktion aus.

void loop() {

  int buttonVal = digitalRead(0);
  if (buttonVal > 0) {
    button();
  }

Dieser Abschnitt aktualisiert die aktuelle Zeit und speichert die Werte für den Tag, die Stunde und die Minute in eigenen Variablen ab.

  time_t now = time(nullptr);
  struct tm * p_tm = localtime( & now);
  int tago = p_tm - > tm_wday;
  int stundo = p_tm - > tm_hour;
  int minuto = p_tm - > tm_min;

Dieser Abschnitt prüft für jedes Fach, ob die eingestellte Zeit erreicht ist und ob das Fach überhaupt aktiviert ist. Falls diese Bedingungen erfüllt sind, wird das Licht für das zutreffende Fach aktiviert und eine Benachrichtigung an den Nutzer verschickt mit der Erinnerung das Fach zu öffnen.

  for (int i = 0; i < 14; i++) {
    if (abteile[i].stunde == stundo && abteile[i].minute == minuto && abteile[i].tag == tago && abteile[i].enabled == true && abteile[i].lichtAn == false) {
      abteile[i].lichtAn = true;
      pinMode(abteile[i].licht, OUTPUT);
      digitalWrite(abteile[i].licht, LOW);
      bot.sendMessage(defaultID, "Die gewünschte Zeit " + zeitPunkt(i) + " ist erreicht. Es ist an der Zeit Fach " + (String) i + " zu öffnen.", "");
    }
  }

Dieser Abschnitt prüft, ob der Bot eine neue Nachricht empfangen hat und speichert diese in einer Variable(lastMessage) ab. Je nach Inhalt der Nachricht, führt das Programm die gewünschte Funktion aus.

  if (millis() > Bot_lasttime + Bot_mtbs) {
    int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    while (numNewMessages) {
      Serial.println("got response");
      for (int i = 0; i < numNewMessages; i++) {
        if (defaultID != bot.messages[i].chat_id) {
          bot.sendMessage(defaultID, "Neuer Nutzer. Senden Sie eine Nachricht, um wieder benachrichtigt zu werden.", "");
        }
        defaultID = bot.messages[i].chat_id;
        String lastMessage = bot.messages[i].text;
        if (lastMessage == "/start") {
          bot.sendMessage(defaultID, startText, "");
        } else if (strstr(lastMessage.c_str(), "fach") != nullptr) {
          fach(lastMessage);
          bot.sendMessage(defaultID, fachText, "");
        } else if (lastMessage == "/licht") {
          licht();
        } else if (lastMessage == "/umschalten") {
          enabled();
        } else if (lastMessage == "/zeit") {
          zeit();
        } else if (lastMessage == "/tag") {
          tag();
        } else if (lastMessage == "/stunde") {
          stunde();
        } else if (lastMessage == "/minute") {
          minute();
        } else if (lastMessage == "/button") {
          button();
        } else if (strstr(lastMessage.c_str(), "/t") != nullptr) {
          tag2(lastMessage);
        } else if (strstr(lastMessage.c_str(), "/s") != nullptr) {
          stunde2(lastMessage);
        } else if (strstr(lastMessage.c_str(), "/m") != nullptr) {
          minute2(lastMessage);
        }
      }
      numNewMessages = bot.getUpdates(bot.last_message_received + 1);
    }

    Bot_lasttime = millis();
  }
}

Aufgetretene Probleme[Bearbeiten]

Zuerst wollten wir eine Box entwickeln, die mehrere einzelne, herausnehmbare Boxen enthält. Das Problem hierbei war jedoch die einzelnen Boxen zu fertigen , da Sie meistens zu groß waren und die Box generell größer entwickelt werden müsste. Bei der Herstellung der Box ist uns außerdem aufgefallen, dass die einzelnen Boxen bei einem möglichen Sturz aus ihren Aussparungen herausfallen, sodass die Zuordnung der einzelnen Boxen sich als schwierig erwiesen hat. Die einzelnen Boxen mussten außerdem jeweils mit einer kleinen Batterie versehen werden, um die LED-Leuchten, die in die Boxen verbaut werden sollten, mit Strom versorgt werden. Die Bezugsperson wollte jedoch eine kleinere Box mit einzelnen Fächern, sodass wir uns gegen unsere erste Konstruktion entschieden haben.
Bei dem zweiten Versuch haben wir eine Box mit Klappen für die einzelnen Fächer konstruiert. Hierbei hat sich jedoch herausgestellt, dass der 3D-Druck zu ungenau war und wir somit keine benutzbaren Klappen fertigen konnten. Ein weiteres Problem war außerdem das lichtundurchlässige Filament, wodurch das LED-Licht aus den Fächern nicht zum Vorschein kam. Auch durch zahlreiches Herumexperimentieren, sind wir auf kein zufriedenstellendes Ergebnis gekommen, sodass wir uns auf die finale Version mit durchsichtigen Schiebereglern geeinigt haben.

Vorherige Versionen[Bearbeiten]

Anbei befinden sich Vorversionen von unserer Box:

Erweiterungs-Möglichkeiten[Bearbeiten]

Sound Benachrichtigung[Bearbeiten]

Sinnvoll wäre es an der Box einen Lautsprecher einzufügen, um dem Nutzer zur Benachrichtigungszeit eine auditive Mitteilung senden zu können.

Optimiertes Boxdesign[Bearbeiten]

In zukünftigen Versionen empfiehlt es sich einen anderen Verschluss-Mechanismus für die Fächer einzufügen. Wir hatten ebenfalls einen anderen geplant, welcher jedoch aufgrund von Problemen mit dem 3D-Druck nicht zustande kommen konnte.

Alternative Sensorik[Bearbeiten]

Ebenfalls ist eine andere Sensorik, als die Nutzung eines Buttons sinnvoll, um zu erkennen, ob der Nutzer die Box verwendet hat. Wir hatten mehrere Ideen, wie zum Beispiel einen Lichtsensor oder Gewichtssensor für die einzelnen Fächer einzubauen, die wir jedoch nicht weiter verfolgt haben, als wir gemerkt haben, dass es zu relativ ungenauen Erkennung kommen könnte.

Alternative Benachrichtigungsmöglichkeiten[Bearbeiten]

Für unseren Zweck hat eine einzige Benachrichtigungsform in Form von Telegram ausgereicht. Für andere Anwender könnte es jedoch Sinn machen, die Benachrichtigungsmöglichkeiten zu erweitern, zum Beispiel in Form von E-Mails oder SMS.