Mit Old Tower geht es dann in eine etwas andere Richtung, bleibt aber dem Retro-Charme treu. Man spielt einen kleinen Abenteurer, der sich durch verwinkelte Level voller Fallen und – sagen wir mal – ziemlich unfreundlicher Fledermäuse bewegt. Viel mehr als Geschick und ein gutes Timing hat man dabei nicht zur Verfügung. Aber genau das reicht auch.

Was beide Titel gemeinsam haben: Sie sind schnell erklärt, aber schwer zu meistern. Gerade am Anfang wirkt alles noch angenehm machbar, doch schon nach wenigen Leveln kommen neue Mechaniken dazu, die einen ordentlich fordern können. Und genau das macht den Reiz aus.

In meinem neuen Video bekommt ihr einen direkten Einblick ins Gameplay – inklusive kleiner Aha-Momente, ein bisschen Verzweiflung und natürlich jeder Menge Spaß.

Wenn ihr selbst einen Blick riskieren wollt, findet ihr die Spiele hier:

• Gravity Duck 64: https://wpqrek.itch.io/gravity-duck-64
• Old Tower: https://retrosouls.itch.io/old-tower-commodore-64

Schaut gerne rein – sowohl ins Video als auch in die Spiele. Es lohnt sich.

Das Konzept der Sendung war damals recht einzigartig: Die Zuschauer konnten den kleinen Troll in kurzen Spielchen mit den DTMF-Tastentönen ihrer Telefon von Zuhause steuern. Auf dem Bildschirm sahen sie dann das Ergebnis ihrer Tastendrücke. Heute durch die stark unterschiedlichen Laufwege und -zeiten moderner TV-Verbreitungswege undenkbar – und auch damals schon nicht immer ganz problemlos.

Egal, vier Jahre lief das Ganze. Und ich wollte gerne mitspielen, hatte aber nie das Glück durchzukommen. Das plagt mich bis heute, wie ich auch in meiner Podcast-Episode zu Hugo kundtat. In der Episode gehe ich noch ein bisschen genauer auf das Spiel, die Sendung und die Produktion ein.

Pad One, Please! Der nächste Retro-Podcast

#005: Hugo trollt TV und Games

Play Episode Pause Episode

Mute/Unmute Episode Rewind 10 Seconds 1x Fast Forward 30 seconds

00:00 / 14:03

Amazon Apple Podcasts Deezer RSS Spotify

RSS Feed

Teilen

Link

Embed

Nun gibt es aber ja seit einer ganzen Weile Arduino- und ESP-Boards, mit denen man famose Dinge erschaffen kann wenn man dem Thema etwas Zeit widmet. Und da ich hier noch ein altes Telefon der Deutschen Bundespost rumfliegen habe, was den Retro-Charackter der Aktion nur noch weiter verstärkt, habe ich mich dran gemacht aus dem Telefon ein viel zu großes Numpad zu bauen, mit dem auch gleich noch Hugo Spielen kann.

Teileliste

Viel braucht es für dieses Projekt nicht, nämlich nur den ESP und das Telefon:

• Retro-Telefon „FeTAp“, hier ein FeTAp 0111 aus 1987
• ESP 32 S3 Zero
• optional: DIY Platine um Kabelwirrwarr zu vermeiden (siehe „Schaltplan“)

Naja gut, und natürlich Schraubendreher, einen Lötkolben und was man zu dessen Verwendung halt so benötigt.

Schaltplan

Damit das Ganze funktionieren kann, muss das Tastenfeld mit dem ESP32 verbunden werden. An dem Tastenfeld des Telefons ist ein kurzes Flachband. Also, genau genommen ist es auf der Platine des Telefons und muss von der befreit werden. Danach müssen folgende Pins entsprechend mit dem ESP32 verbunden werden.

Um es für mich etwas angenehmer zu gestalten, habe ich mir eine kleine Platine dafür gebaut. Ich bin immer noch begeistert für welche schmale Mark man heutzutage selbstgestaltete PCBs produzieren lassen kann. Ich pack hier mal meine Lösung in Form einer Gerber-File hin, mit der eine Nachbestellung möglich ist – Verwendung auf eigene Gefahr:

Funktionsweise

Das kleine ESP-Board ist in der Lage, als HID (Human Interface Device) über USB zu agieren. Damit gibt es sich in diesem Fall sozusagen als Keyboard aus. Drücke ich eine der Tasten auf dem Telefon, so wird ein Tastendruck (Keyboard.press()) ausgelöst, für 80 Milisekunden gehalten und danach wird die Taste wieder „losgelassen“ (Keyboard.release()).

Um den richtigen Tastendruck zu ermitteln, wird das Tastenfall in schnellen Intervallen auf Tastendrücke abgefragt – so wie es das Telefon selbst zuvor auch gemacht hat. Das Tastenfeld ist dabei als eine Art Matrix aufgebaut. Man kann Spannung dabei Zeilen und Reihenweise anlegen. Gebe ich also beispielsweise eine Spannung auf Spalte 2 und Zeile 3, so muss bei Druck der Taste 8 eine Spannung anliegen sofern diese gerade gedrückt wird. So funktioniert im Groben die Erkennung welche Taste gerade gedrückt wird. Simpel aber doch irgendwie faszinierend, wenn ich mir vorstelle in welchem flotten Intervall der ESP da über alle möglichen Konstellationen immer und immer wieder drüber ballert.

Software

Die Software besteht im Wesentlichen aus einer einzigen Datei. Ich entwickle in PlattformIO, entsprechend handelt es sich bei dem Projekt um ein solches. Ihr könnt den Code aber auch in die Arduino IDE kopieren, dann müsste ihr nur dafür sorgen dass ihr die entsprechend für den ESP32 S3 Zero konfiguriert. Außerdem müsst ihr vermutlich das #include <Arduino.h> rausnehmen und dem Sketch eine .ino-Dateiendung geben. Mehr dazu auch in der Readme. Das Projekt könnt ihr auf meinem GIthub-Profil auschecken oder runterladen.

Fazit

Das Projekt hier hat mir wahnsinnig Spaß gemacht. Ich hab keine Ahnung, ob es da draussen wirklich noch andere Verrückte gibt, die sich an sowas erfreuen. Aber falls ja: Hey, schön das du da bist und viel Spaß mit dem Projekt. Wer keine Lust auf basteln hat: Ich habe kürzlich erfahren, dass im Hi-Score in Hannover auch etwas ähnliches für jeden zum ausprobieren und Spielen stehen soll. Diese Werbung hier ist absolut freiwillig und unbezahlt, ich finde in der Retro-Community muss man zusammenhalten und gute Ideen teilen.

Und wenn ihr das Projekt mal umgesetzt haben solltet: Ich würde mich super über Rückmeldung freuen. Viel Spaß beim Zocken!

Im Multi-Spiel, wie auch in einer Hülle und Fülle anderer Pong-Klone aus dieser Zeit, werkelt ein AY-3-8500-IC. Was auch der Grund ist, warum alle Konsolen dieser Ära in etwa die gleichen Features hatten.

Technische Daten dieses ICs im Überblick:

• Hersteller: General Instrument (USA)
• Soundausgabe: Über einen Pin generiert der Chip einfache Tonsignale: z. B. Tonfrequenzen ~967 Hz (Ballaufprall), ~488 Hz (Abprall), ~1950 Hz (Punktgewinn) bei ~32 ms Pulsdauer.
• Bezeichnung: AY-3-8500 („Ball & Paddle“) – Einführung etwa 1976.
• Bauform: 28-poliges DIP-Gehäuse.
• Betriebsspannung: typische Versorgung z. B. 6-12 V (häufig 9 V) bei den Konsolen.
• Takt: ca. 2 MHz externer Takt (z. B. 2,01216 MHz ±1 %) zur Generierung der Bildsignale.
• Stromaufnahme: typischerweise rund 30 mA.
• Bildausgabe: Schwarz/Weiß – das IC erzeugt Zeilen- und Bildsynchronsignale, Horizontalzählung bis etwa 128 Punkte pro Zeile, Vertikal bis etwa 312 Zeilen (bei PAL-Modellen). Wikipedia

Der AY-3-8500 war sozusagen der Standard-Chip zahlreicher Pong-Konsolen der ersten Generation, da er nahezu die komplette Logik der Spielemechanik (Ballbewegung, Kollisionsprüfung, Schlägersteuerung) sowie die Video- und Tonerzeugung auf einem einzigen IC integrierte. Dies ermöglichte niedrige Stückkosten und einfache Konstruktionen.

In der Praxis bedeutet das für eine Konsole wie die von Universum: Der Großteil der Elektronik beschränkt sich auf den AY-3-8500, einen Taktgenerator (z. B. Kristalloszillator oder Resonator), Potentiometer für die Steuerung, RF-Modulator bzw. Bildaufbereitung und Netzteil bzw. Batterieversorgung.
Für Farbversionen und Varianten mit erweiterten Spielen kamen Varianten wie der AY-3-8610 (10 Spiele) oder zusätzliche Farb-Encoder (z. B. AY-3-8515) zum Einsatz.

Die Universum TV-Multi-Spiel Konsole reiht sich ein in die Ära der Heim-Pong-Geräte, die ab Mitte der 70er Jahre aufkamen. Gemäß der Videospielgeschichte war diese Phase durch festverdrahtete bzw. IC-basierte Konsolen geprägt – Wechselmodule waren selten.
Für den Verbraucher bedeutete dies: relativ kostengünstiger Einstieg ins Heimvideospielen, einfache Technik, begrenzte Farb- und Steuerungsmöglichkeiten, aber hoher Nostalgiewert heute.
Die Nutzung eines weit verbreiteten ICs wie dem AY-3-8500 bedeutete zudem, dass zahlreiche Hersteller ähnliche Geräte mit sehr ähnlicher Technik herausbrachten – was heute die Sammler- und Reparatur-Gemeinschaft durchaus erleichtert.

Grüße aus der DDR: Das Bildschirmspiel 01

Den AY-3-8500 umgibt zudem noch eine Besonderheit: Er war einiger der wenigen westlichen Chips, die damals in die DDR importiert werden durften. Auch in der DDR wollte man gerne Zocken, war aber nicht in der Lage unter wirtschaftlichen Aspekten einen Spiele-Chip wie den AY-3-8500 zu kopieren, wie man das mit anderen Chips bereits erfolgreich getan hatte.

Da das Ding aber rein zum Zocken gedacht war, gabs eine Ausnahme: Der Chip durfte aus dem Westen eingeführt werden. Im Jahre 1977 beschloss das Ministerium für Elektrotechnik und Elektronik daher, das Bildschirmspielgerät 01 zu produzieren. Wie Deutsch kann der Name einer Spielekonsole nur sein.

Gerade rechtzeitig um unter dem Weihnachtsbaum 1979 zu liegen wurde die Konsole fertig. Für happige 500 DDR-Mark war sie zu haben. Vermutlich mit ein Grund, warum am Ende weniger als 1000 von ihnen produziert wurden. Heute sind die Konsolen echte Sammlerstücke und werden zu hohen Preisen gehandelt, wenn man sie denn noch in akzeptablem Zustand finden kann.

Rein Spielerisch bekam man natürlich aufgrund des verbauten Chips dasselbe Erlebnis wie im Westen, nur das eben das Gehäuse war ein anderes und sämtliche sonstigen Komponenten des Bildschirmspielgeräts kamen aus DDR-Produktion. Apropos Gehäuse: Davon gab es drei Varianten. Am verbreitetsten war die klassisch schwarze Variante. Daneben existierte eine Weiße mit dunklen Controllern und eine komplett Weiße. Für letztere kann man heute vermutlich eine Niere hergeben, möchte man als Sammler in den Genus einer solchen kommen.

+ relativ günstig
+ kompakt
+ überschaubarer Stromverbrauch
+ optional mit GPS und Bluetooth
+ USB-Anschluss für schnellere Datenübertragung

– min. 5 V Versorgungsspannung (SIM800L lief auch mit 3.7 V)
– Status LED ungenau (moniert nicht verbunden zu sein, obwohl Daten gesendet und empfangen werden)

Videoanleitung

Hardware

Für mein Test-Setup verwende ich ein ESP32-WROOM-32D-Board. Andere Boards sind möglich. Ich verwende dieses Board aufgrund der Hardware-Serial, über die die Kommunikation zwischen ESP und A7670E-LTE-Modem läuft. Die Beschriftung auf dem Modem ist ein bisschen unübersichtlich. Auf meinem Board von oben nach unten:
G: GND, R: RXD, T: TXT, K: PWRKEY, V: VCC, G: GND, S-SLEEP

Für mein Setup genügt es, vom ESP TX/RX über Kreuz zu verbinden: Also: TX vom ESP auf RX vom Modem und umgekehrt. Außerdem teilen sich ESP und A7670E einen Ground. Das wars dann aber auch. Ich hatte zwischenzeitlich einen 2200μF-Kondensator verbaut, bis ich gesehen habe das genau für diesen Zweck bereits ein 4700μF-Kondensator auf dem Modem verbaut ist. Trotzdem kackte das Modem beim Einbuchen ins LTE-Netz ab und an ab – die Stromversorgung scheint da aber wohl dann nicht der Grund gewesen zu sein?!

Software

Getestet wurde das hier mit dem A7670E-Modul. Allerdings sollten die meisten Sketches auch mit anderen Boards von SIMCom funktionieren, sofern sie den gleichen Befehlssatz unterstützen.

Basis Sketch

Um es auch für Einsteiger verständlich zu halten, teile ich die einzelnen Funktion in kleine Snippets auf. So könnt ihr euch das raussuchen, was für euer Szenario am besten passt. Diese basieren auf folgender Basis, die zunächst nichts weiter macht als die Kommunikation mit dem A7670E sicherzustellen und die Antworten des Moduls im Serial Monitor euer (Arduino-)IDE anzuzeigen.

#include <Arduino.h>

#define RX_PIN 17 // RX-Pin des ESP-Boards
#define TX_PIN 16 // TX-Pin des ESP-Boards
HardwareSerial modem(2);

void setup() {
  Serial.begin(115200);

  delay(1000);
  Serial.println("Serial connection ready");

  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT"); // AT = Attention, Modem muss mit "OK" antworten
}

void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp); // Jede Antwort des Modems in der Serial gekennzeichnet ausgeben
    }
  }
}

Serial connection ready
Modem: AT
Modem: OK

Mobilfunkstatus Sketch

Um zu prüfen, ob das A7670E-Modul mit dem Mobilfunknetz verbunden ist, können wir es einfach selbst fragen.

#include <Arduino.h>

#define RX_PIN 17
#define TX_PIN 16
HardwareSerial modem(2);

void setup() {
  Serial.begin(115200);

  delay(1000);
  Serial.println("Serial connection ready");

  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT");
}

void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp);
    }
  }

  static unsigned long lastRun = millis() - 18000;
  if (millis() - lastRun > 20000) { // Nach 2 Sekunden alle 20 Sekunden aktualisieren
    lastRun = millis();

    modem.println("AT+CSQ");      // Signalstärke
    modem.println("AT+CEREG?");   // LTE Netzregistrierung
    modem.println("AT+CGATT?");   // Datenregistrierung
    modem.println("AT+CGACT?");   // PDP Kontext aktiv? (Datenverbindung)
    modem.println("AT+CGPADDR");  // IP-Adresse
    modem.println("AT+NETOPEN?"); // Socket-Service Status
  }
}

Modem: AT+CSQ
Modem: +CSQ: 26,99
Modem: OK
Modem: AT+CEREG?
Modem: +CEREG: 0,1
Modem: OK
Modem: AT+CGATT?
Modem: +CGATT: 1
Modem: OK
Modem: AT+CGACT?
Modem: +CGACT: 1,1
Modem: +CGACT: 8,1
Modem: OK
Modem: AT+CGPADDR
Modem: +CGPADDR: 1,10.76.56.42
Modem: +CGPADDR: 8,0.0.0.0,254.128.0.0.0.0.0.0.194.209.178.131.245.194.29.154
Modem: OK
Modem: AT+NETOPEN?
Modem: +NETOPEN: 0
Modem: OK

+CSQ: 26,99: 26 ist die Signalqualität, Skala 0-31, 26 = ziemlich guter Empfang
+CEREG: 0,1: Erfolgreich im LTE-Netz eingebucht
+CGATT: 1: Datenverbindung aktiv
+CGACT: 1,1 & +CGACT: 8,1: Zwei Datenkontexte offen
+CGPADDR: 1,10.76.56.42
+CGPADDR: 8,0.0.0.0,254.128.0.0.0.0.0.0.194.209.178.131.245.194.29.154: IP-Adressen, die das Board erhalten hat

Ping Sketch

Ein grundlegender Test von Netzwerk-Kommunikation ist ein „ping“: Ein kleines Datenpaket wird an einen Server gesendet. Kommt das Paket an antwortet der Server und der Nutzer sieht, wie lange das Datenpaket auf Reise war.

#include <Arduino.h>

#define RX_PIN 17
#define TX_PIN 16
HardwareSerial modem(2);

void setup() {
  Serial.begin(115200);

  delay(1000);
  Serial.println("Serial connection ready");

  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT");
}

void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp);
    }
  }

  static unsigned long lastRun = millis() - 18000;
  if (millis() - lastRun > 20000) {
    lastRun = millis();

    modem.println("AT+CPING=\"8.8.8.8\",1,4"); // 4 Pings an Google DNS senden
  }
}

Modem: AT+CPING="8.8.8.8",1,4
Modem: OK
Modem: +CPING: 1,8.8.8.8,92,130,114
Modem: +CPING: 1,8.8.8.8,92,40,114
Modem: +CPING: 1,8.8.8.8,92,15,114
Modem: +CPING: 1,8.8.8.8,92,30,114
Modem: +CPING: 3,4,4,0,15,130,40

AT+CPING=“8.8.8.8″,1,4: 8.8.8.8 ist die Ziel-IP-Adresse, 1 steht für IPv4 (2 wäre IPv6), 4 ist die Anzahl der Wiederholungen
+CPING: 1,8.8.8.8,92,130,114: 1: Ping erfolgreich, der vorletzte Wert (hier 130) ist die Laufzeit in ms, die anderen Werte bitte dem Manual entnehmen
+CPING: 3,4,4,0,15,130,40: Zusammenfassung über die 4 Pings

Daten via HTTP abrufen (HTTP GET-Request)

#include <Arduino.h>

#define RX_PIN 17
#define TX_PIN 16
HardwareSerial modem(2);

void setup() {
  Serial.begin(115200);

  delay(1000);
  Serial.println("Serial connection ready");

  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT");
}

void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp);
    }
  }

  static unsigned long lastRun = millis() - 18000;
  if (millis() - lastRun > 20000) {
    lastRun = millis();

    modem.println("AT+HTTPINIT"); // HTTP-Service des Modems starten

    
    modem.println("AT+HTTPPARA=\"URL\",http://httpbin.org/get"); // Abzurufende Adresse
    modem.println("AT+HTTPACTION=0"); // 0 = GET, 1 = POST, 2 = HEAD, 3 = DELETE, 4 = PUT

    delay(2500); // Wir gehen davon aus, in 2.5s die Antwort zu erhalten. Vermutlich besser: AT+HTTPACTION auswerten, liefert die Content-Length

    modem.println("AT+HTTPHEAD"); // Ausgabe des Response Headers

    delay(200);

    modem.println("AT+HTTPREAD=99999"); // "Unsaubere Implementierung": Eigentlich AT+HTTPREAD? nutzen um Länge der Antwort zu ermitteln
    modem.println("AT+HTTPTERM"); // HTTP-Service nach Verwendung stoppen
  }
}

Modem: AT+HTTPINIT
Modem: ERROR
Modem: AT+HTTPPARA="URL",http://httpbin.org/get
Modem: OK
Modem: AT+HTTPACTION=0
Modem: OK
Modem: +HTTPACTION: 0,200,255
Modem: AT+HTTPHEAD
Modem: +HTTPHEAD: 226
Modem: HTTP/1.1 200 OK
Modem: Date: Fri, 05 Sep 2025 15:28:01 GMT
Modem: Content-Type: application/json
Modem: Content-Length: 255
Modem: Connection: keep-alive
Modem: Server: gunicorn/19.9.0
Modem: Access-Control-Allow-Origin: *
Modem: Access-Control-Allow-Credentials: true
Modem: OK
Modem: AT+HTTPREAD?
Modem: +HTTPREAD: LEN,255
Modem: OK
Modem: AT+HTTPREAD=99999
Modem: OK
Modem: AT+HTTPTERM
Modem: OK
Modem: +HTTPREAD: 255
Modem: {
Modem: "args": {},
Modem: "headers": {
Modem: "Accept": "*/*",
Modem: "C "origin": "80.187.118.156",
Modem: "url": "http://httpbin.org/get"
Modem: }
Modem: +HTTPREAD: 0

+HTTPACTION: 0,200,255: 0 = Type der Anfrage (GET), 200 = Statuscode des Servers, 255 = Länge der Antwort in Bytes
+HTTPHEAD: 226: Start Ausgabe des Headers, 226 Bytes
+HTTPREAD: LEN,255: Eine Response liegt vor, 255 Bytes
+HTTPREAD: 255: Beginn der Ausgabe des Response bis HTTPREAD: 0

Daten via HTTP senden (HTTP POST, PUT, PATCH)

Im vorangegangenen Beispiel beim Abruf der Daten via HTTP haben wir etwas „gefuttelt“ was die Antworten anging. So haben wir mit delay gearbeitet und gehofft, dass bis dahin eine Antwort da ist. Damit kommen wir jetzt nicht mehr durch. Um den Code weiter lesbar zu halten, habe ich die Logik in einzelne Funktionen aufgeteilt.

#include <Arduino.h>

#define RX_PIN 17
#define TX_PIN 16
HardwareSerial modem(2);

String waitForURC(const char* token, unsigned long timeoutMs = 10000) { // URC: Unsolicited Result Code, Ereignisbasierte Melungen des Modems abfragen. In unserem Fall für die Antwort nach dem POST genutzt
  unsigned long start = millis();
  String buffer;

  while (millis() - start < timeoutMs) {
    while (modem.available()) {
      String line = modem.readStringUntil('\n');
      line.trim();

      if (line.length() > 0) {
        Serial.println("URC: " + line);
      }

      if (line.startsWith(token)) {
        return line;
      }
    }
  }
  Serial.println("Timeout beim Warten auf URC: " + String(token));
  return "";
}

void readHttpResponse() {
  modem.println("AT+HTTPREAD=99999"); // Wir lesen pauschal alles; Hier könnte man auch mit der genauen Zahl an Bytes arbeiten (was sauberer wäre), aber das LTE-Modul liefert nur solange Daten zurück, wie sie vorliegen.
  
  String response;
  unsigned long startTime = millis();

  while (millis() - startTime < 15000) {
    while (modem.available()) {
      String line = modem.readStringUntil('\n');
      line.trim();

      if (line.startsWith("+HTTPREAD:")) continue;
      if (line == "OK") {
        Serial.println("HTTP-Body:");
        Serial.println(response);
        return;
      }

      response += line + "\n";
    }
  }
  Serial.println("Timeout beim Lesen der Response!");
}

void httpPost(const char* url, const char* json) { // Methode speziell für den HTTP POST-Prozess
  modem.println("AT+HTTPINIT");
  modem.printf("AT+HTTPPARA=\"URL\",\"%s\"\r\n", url);
  modem.println("AT+HTTPPARA=\"CONTENT\",\"application/json\""); // Festsetzen des Inhalts auf JSON
  modem.printf("AT+HTTPDATA=%d,5000\r\n", strlen(json)); // Dem Modem mitteilen, dass gleich Daten kommen, die es für die Übermittlung aufzeichnen soll

  String dl = waitForURC("DOWNLOAD", 5000); // Warten bis das Modem mit "DOWNLOAD" antwortet, dann senden unseres JSON
  if (dl.length() > 0) {
    modem.print(json);
    if (waitForURC("OK", 5000).length() == 0) { // Im Anschluss auf die Bestätigung der Übertragung durch das Modem warten
      Serial.println("Modem or connection stuck, too many data sent or check wiring");
      return;
    }
  }

  modem.println("AT+HTTPACTION=1"); // 1 = POST
  String action = waitForURC("+HTTPACTION:", 15000); // Hier optimierter Ablauf: Sobald die Anfrage vom Modem versendet wurde, geht's weiter...

  if (action.length() > 0) {
    int method, status, len;
    if (sscanf(action.c_str(), "+HTTPACTION: %d,%d,%d", &method, &status, &len) == 3) {
      Serial.printf("HTTP Status: %d, Length: %d\n", status, len);

      if (status == 200 || status == 201) { // Status code 200/201 stehen für eine erfolgreiche Anfragen bei POST
        readHttpResponse(); // Auslesen der Antwort in einer eigenen Funktion dafür
      } else {
        Serial.println("Unexpected response");
      }
    }
  }

  modem.println("AT+HTTPTERM");
}

void setup() {
  Serial.begin(115200);

  delay(1000);
  Serial.println("Serial connection ready");

  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT");
}

void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp);
    }
  }

  static unsigned long lastRun = millis() - 18000;
  if (millis() - lastRun > 20000) {
    lastRun = millis();
    const char* json = "{\"temperature\":25.3,\"battery_level\":\"83\"}"; // Unsere Daten verpackt in JSON

    httpPost("http://httpbin.org/post", json); // Start des HTTP Post
  }
}

Serial connection ready
Modem: AT
Modem: OK
URC: AT+HTTPINIT
URC: OK
URC: AT+HTTPPARA="URL","http://httpbin.org/post"
URC: OK
URC: AT+HTTPPARA="CONTENT","application/json"
URC: OK
URC: AT+HTTPDATA=41,5000
URC: DOWNLOAD
URC: OK
URC: AT+HTTPACTION=1
URC: OK
URC: +HTTPACTION: 1,200,488
HTTP Status: 200, Length: 488
HTTP-Body:
AT+HTTPREAD=99999

Modem: +HTTPREAD: 488
Modem: {
Modem: "args": {},
Modem: "data": "{\"temperature\":25.3,\"battery_level\":\"83\"}",
Modem: "files": {},
Modem: "form": {},
Modem: "headers": {
Modem: "Accept": "*/*",
Modem: "Cache-Control": "no-cache",
Modem: "Content-Length": "41",
Modem: "Content-Type": "application/json",
Modem: "Host": "httpbin.org",
Modem: "X-Amzn-Trace-Id": "Root=1-68bd430d",
Modem: "url": "http://httpbin.org/post"
Modem: }
Modem: AT+HTTPTERM
Modem: OK
Modem: +HTTPREAD: 0

Dadurch das mit waitForURC auf ein Ereignis warten, verschieben sich hier die Ausgaben ein wenig.
AT+HTTPDATA=41,5000: Unsere zu sendenden Daten sind 41 Bytes lang, Timeout: 5 Sekunden
+HTTPACTION: 1,200,488: Die Übertragung war erfolgreich, 488 Bytes lang ist die Antwort
AT+HTTPREAD=99999: Wir lesen pauschal 99999 Bytes, das Modem liefert aber nur so viel Daten zurück wie vorhanden; Wir hätten hier auch die 488 aus der HTTPACTION-Antwort verwenden können. Das wäre sauberer gewesen, aber in manchen Fällen (bspw. „chunked“-Responses) liegt wieder Wert nicht vor. Wir haben es uns also einfacher gemacht
+HTTPREAD: 488: Beginn der Ausgabe der Antwort des Servers, enthält als Bestätigung unter „data“ das, was wir geposted haben

Besonderheiten bei HTTPS

Das 7670E-Modul ist dazu in der Lage Daten unverschlüsselt über HTTP, als auch verschlüsselt via HTTPS zu übertragen. Im besten Fall ist dazu nicht viel mehr nötig, als in den hier genannten Beispielen auf „http://“ ein „https://“ zu machen. Allerdings steckt der Teufel da gerne im Detail, denn HTTPS ≠ HTTPS.

Hier ein Mini-Exkurs: Werden im Netz Daten verschlüsselt übertragen, kommen dazu unterschiedliche Mechanismen zu tragen. So wird zum einen ein Verschlüsselungsalgorithmus zwischen Client und Server ausgehandelt., heutzutage oft TLS 1.2 oder größer. Neben diesem wird ein passendes Zertifikat benötigt. Gerade wenn es günstig sein soll, wird heute oft Lets Encrypt verwendet – mach ich auch so. Damit die Kommunikation aber wirklich sicher ist, müssen Betriebssysteme, Browser oder eben LTE-Module mit HTTPS-Support aber die Stammzertifikate der Anbieter kennen. Ein weiteres Thema ist Server Name Indication (SNI) in Verbindung mit virtuellen Hosts. Kurz um: Viele Dinge, die entweder eine vermeintlich sichere Verbindung unsicher machen können oder sie erst gar nicht zustand kommen lassen.

Wenn die Übertragung nicht gelingt…

…geht’s an Debugging. Folgende Sachen könnt ihr prüfen:

SNI aktivieren
Das Modul hat zur Laufzeit 8 SSL-Konfiguration im Speicher. Per Default ist da wenig konfiguriert, außer die Art der TLS-Verschlüsselung mit der Gegenseite automatisch ausgehandelt werden soll. Was dabei nicht konfiguriert wird ist Server Name Indication. Das kann aber essentiell sein, nämlich dann, wenn euer Server mit Virtual Hosts arbeitet. Aktiviert SNI vor dem AT+HTTPINIT mit:

modem.println("AT+CSSLCFG=\"enableSNI\",0,1")

SNI wird für den SSL-Kontext „0“ mit „1“ aktiviert. SSL-Kontext 0 ist der erste der genannten 8 möglichen und wird per default verwendet. Um die SSL-Kontext-ID anzupassen, kann man den Befehl AT+HTTPPARA=“SSLCFG“,2 nutzen, wobei hier die 2 symbolisch für die ID des Index steht, also 0-7.

HTTPACTION auswerten
Einen GET-Request starten wir ja mit AT+HTTPACTION=0. Das Modul gibt neben einem „OK“ auch weitere Informationen aus, im besten Fall sowas: +HTTPACTION: 0,200,81
Die 0 steht für die Art der Anfrage (GET), die 200 für den vom Server gesendeten Statuscode und 81 ist die Länge der Antwort. Ist die Antwort nicht erfolgreich, ist interessant was dort statt 200 steht. Eine 706 würden auf Probleme beim Lesen der Antwort hindeuten, aber gleichzeitig bekräftigen, dass der TLS-Handshake zuvor erfolgreich war, während eine 715 eben genau auf Probleme bei ebendiesem hinweisen würden. In dem Fall müsste man prüfen, ob der verwendete TLS-Standard auf deinem Server von dem LTE-Modul überhaupt unterstützt wird.

HTTP-Header auslesen
Mit AT+HTTPHEAD lässt sich nach dem Absenden der Anfrage der Antwort-Header auslesen. Hier können auch Hinweise auf das Problem aufgeführt sein, wenn man Glück hat. Das oben angesprochene SNI-Problem könnte beispielsweise hier benannt werden.

HTTPS GET Beispiel Sketch

Die oben genannte Punkte sind in diesem Beispiel berücksichtig, welcher bei mir erfolgreich funktionierte.

#include <Arduino.h>
 
#define RX_PIN 17
#define TX_PIN 16
HardwareSerial modem(2);


String waitForURC(const char* token, unsigned long timeoutMs = 10000) {
  unsigned long start = millis();
  String buffer;
 
  while (millis() - start < timeoutMs) {
    while (modem.available()) {
      String line = modem.readStringUntil('\n');
      line.trim();
 
      if (line.length() > 0) {
        Serial.println("URC: " + line);
      }
 
      if (line.startsWith(token)) {
        return line;
      }
    }
  }
  Serial.println("Timeout beim Warten auf URC: " + String(token));
  return "";
}


void setup() {
  Serial.begin(115200);
 
  delay(1000);
  Serial.println("Serial connection ready");
 
  modem.begin(115200, SERIAL_8N1, RX_PIN, TX_PIN);
  modem.println("AT");

  
}
 
void loop() {
  while (modem.available()) {
    String resp = modem.readStringUntil('\n');
    resp.trim();
    if (resp.length() > 0) {
      Serial.println("Modem: " + resp);
    }
  }
 
  static unsigned long lastRun = millis() - 18000;
  if (millis() - lastRun > 20000) {
    lastRun = millis();
 
    modem.println("AT+CSSLCFG=\"enableSNI\",0,1"); // SNI für SSL config ID 0 aktivieren
    
    modem.println("AT+HTTPINIT");
    
    modem.println("AT+HTTPPARA=\"URL\",https://phil.cossnet.de/lte_modul_test.html"); // Kleine selbstgehostete Test-HTML-Datei
    modem.println("AT+HTTPACTION=0");
 

    String response = waitForURC("+HTTPACTION", 5000); // Auf Antwort warten, offenbar dauert es bei HTTPS länger als bei HTTP
    if (response.length() > 0) {
      modem.println("AT+HTTPHEAD");
      modem.println("AT+HTTPREAD=99999");
    }
 
    delay(200);
    modem.println("AT+HTTPTERM");
  }
}

So ging es mir mit meinem Nokia 5110: Ich habe es damals geliebt. Es war eins der ersten Nokias mit Snake. Ein so einfaches Spiel, das zumindest die Älteren unter uns wahrscheinlich alle noch kennen. Bisher stand es etwas verloren in meinem Regal. Und somit war es der perfekte Kandidat für dieses Projekt: Ein mit LEDs versehener Fotorahmen, welcher die Innereien des Nokia 51110 so richtig zur Geltung bringen sollte.

Die Komponenten

• Fotorahmen „SANNAHED“, 25x25cm, 6,- Euro
• D1 Mini, ESP8266*, ca. 5,- Euro
• WS2812B-LED-Streifen, 5V, 60 LEDs/m, 9,- Euro
• Magentkontaktstecker, ca. 3,-/Stk.
• USB-Stromanschlussboard, ca. 1,- Euro
• Sperrdiode, ca. 0,50 Euro
• Selbstgestalteter Fotohintergrund, ca. 5,- Euro
• Klebepads oder 2-Komponentenkleber, zwischen 2,- und 5,- Euro
• etwas Kabel, Lötkolben, Schrumpfschläuche

*) Wie sich während der Arbeit rausstellte, endet in der nahen Zukunft die Unterstützung von ESP8266-Boards seitens der eingesetzten WLED-Software. Für neue Projekte werden deshalb ESP32-basierte Boards empfohlen, die sich preislich aber nur wenig unterscheiden dürften.

Das Exponat

Das Nokia lies sich recht einfach auseinandernehmen: Nachdem man die Batterie entfernt hatte, offenbarten sich auf der Rückseite einige Torx-Schrauben mit denen man schnell im inneren war. Dort ging es dann ebenso schnell weiter. Das muss natürlich bei jedem Gerät der Fall sein, auch wenn früher noch mehr Teile verschraubt statt verklebt waren. Anders als es heute oft gängige Praxis ist. Wenn euer Exponat da etwas widerspenstiger ist, habt bitte im Hinterkopf: Verletzt euch nicht! Displays können brechen, Batterien können auslaufen oder man kann beim Versuch etwas aufzuhebeln abrutschen. Denkt da an eure Finger und eure Gesundheit. Lest dazu bitte auch folgenden Absatz.

Vorsicht: Gefahr!

Eine Sache, die man unabhängig von eurem Bastelvorhaben nicht unterschätzen sollte, ist die potentielle Gefahr, die von alten Batterien und Akkus ausgehen kann. Ich war überrascht zu sehen, dass bereits in meinem Nokia 5110 von 1998 ein Lithium-Ionen-Akku verbaut war. Die sind heute überall und sehr sicher, dennoch weiß man nie ob im inneren bereits Zersetzungseffekte eingetreten sind. Ich will das Thema auch gar nicht zu sehr stressen, das Netz ist voll mit Artikeln zu dem Thema. So viel nur: Ich habe mich bewußt dazu entschieden, den Akku auf dem Wertstoffhof abzugeben und ihn nicht in den Fotorahmen zu kleben.

Der kreative Teil

Nachdem das Telefon in seine Einzelteile zerlegt war, ging es um die Positionierung. Beim Nokia 5110 kommen viele ähnlich große zum Einsatz. Wenige Kleinteile, was die Positionierung etwas erschwerte. Nachdem ich mich für ein Layout entschieden hatte, ging es ans „designen“ des Hintergrunds. Ich habe das Wort absichtlich in Anführungszeichen gepackt: Denn hier muss man wirklich kein Experte oder Grafiker sein. Die Hardware, illuminiert durch die LEDs, ist der eigentliche Hingucker. Mit ein paar kurzen Texten, Erklärungen oder einfachen grafischen Elementen kann man viel erreichen.

In meinem Fall habe ich mir folgende Fragen gestellt:

• Wo positioniere ich den Namen des Telefons prominient?
• Kann ich einen kurzen Text schreiben, der etwas über die Geschichte erzählt?
• Kann ich die einzelnen Komponenten (Logic Board, Tastenfeld, Cover, …) benennen?
• Kann ich mit Pfeilgrafiken auf bestimmte Bauteile oder Features hinweisen?
• Wo soll der Rahmen stehen und welche Farbe hat er: empfiehlt sich ein heller oder ein dunkler Hintergrund?
• Welche zeitgemäße, moderne oder zurückhaltende Schriftart verwende ich?

In Affinity Photo habe ich daraufhin ein bisschen gebastelt, geschoben und experimentiert. Wenn ihr kein Grafikprogramm habt, könnt ihr euch das kostenfreie Tool GIMP besorgen, was in der Bedienung als Anfänger vielleicht etwas hakelig sein kann. Alternativ würde ich noch Canva ins Rennen werfen, was man eingeschränkt nach Registrierung kostenfrei nutzen kann.

Hardware & Software

Zum Einsatz kommen einmal mehr ein ESP8266-Board mit WLED-Software. Wie oben bereits angerissen, sollte man laut WLED-Website für neue Projekte inzwischen ESP32-Boards verwenden, da der 8266er-Chipsatz nicht mehr lange unterstützt werden wird.

Auf den ESP wird dann einfach die WLED-Software über den bekannten Webinstaller geflashed. Danach verbinde ich das zusätzliche USB-Board, an welches später das Netzteil angeschlossen wird, mit dem ESP und dem LED-Steifen. Dazwischen kommt noch eine Diode: Wird Strom an die externe USB-Buchse angeschlossen, soll dieser den ESP und den LED-Streifen versorgen. Schließe ich aber z.B. für ein Software-Update ein USB-Kabel an den ESP direkt an, soll dieser nicht den LED-Streifen mit Strom versorgen. Das könnte eine zu Hohe Last für den ESP oder euren USB-Anschluss am Rechner sein.

Apropos: Insbesondere wenn ihr sehr viele LEDs anschließen wollt, solltet ihr euch Gedanken um die Dicke eurer Kabel machen. Sind die zu dünn, können die sich auch entsprechend erhitzen und in Flammen aufgehen. Ich empfehle da immer den Rechner vom WLED-Projekt.

Danach habe ich die einzelnen LEDs mit dem Streifen verlötet. Dabei ist es wichtig auf die Reihenfolge zu achten! Auf den Streifen befindet sich ein kleiner Pfeil, welche die Laufrichtung anzeigt.

Um den Rahmen von seinem Innenleben trennen zu können, habe ich Magnetkontakte verwendet. Die hatte ich noch rumfliegen, boten sich an, sind aber komplett optional.

Komponenten befestigen

Nachdem das Foto auf dem Hintergrund aufgeklebt wurde, wurden die einzelnen Komponenten des 5110 wieder rum auf das Foto geklebt. Hierbei habe ich anfangs mit kleinen Klebepads gearbeitet. Die funktionieren auch gut, allerdings sollte man einerseits nicht zu wenige von ihnen verwenden und diese nicht in Türmchenbauweise zu hoch stapeln. Sowohl die Platine des Tastenfelds als auch das Cover der Front – beides große aber leichte Teile – kamen mir nach 1-2 Tagen entgegen.

Ich habe mich dann dazu entschieden, mit 2-Komponentenkleber aus dem Discounter weiterzumachen. Der war günstig, hält aber nach seinen 2 Stunden Trocknungszeit richtig gut. Als Abstandshalter verwende ich kleine Elemente aus dem 3D-Drucker. Da kann man aber auch sicher ein Stückchen Holz oder ähnliches verwenden, wenn man keinen 3D-Drucker zur Hand hat.

Im Nachgang würde ich definitiv immer wieder den Weg mit dem Kleber gehen. Es ist einfach super ärgerlich, wenn man 2 Tage später auf den Fotorahmen schaut und sich wundert, warum Teile plötzlich eine Etage tiefer liegen als erwartet und schlimmsten Falls noch etwas beschädigen.

Konfiguration

In der WLED-Oberfläche lassen sich nun unterschiedliche Segmente konfigurieren. In meinem Fall befinden neben dem LED-Streifen, der innen einmal um den Rahmen geht, 5 weitere LEDs unter der alten Hardware des Nokia. Über die Segmente ist mir mögliche, unterschiedliche Farben und Effekte für jede LED zu konfigurieren. So stelle ich ein:

• LED 1, Tastenfeld, Segment 1: Grün
• LED 2-3, Display, Segment 2: Weiß mit leichtem Blauton
• LED 4-5, Platine, Segment 3: Wechselnder, Bunter Farbeffekt

Die dann folgenden LEDs sind Teil des Streifens. Auch hier konfiguriere ich unterschiedliche Farben, sodass die einzelnen Komponenten (bunt) und Texte (weiß) unterschiedlich beleuchtet werden. Für wen das zu theoretisch war: Im Video zeige ich das nochmal ganz genau. Im Video wie hier der Hinweis: Speichern nicht vergessen, dass geschieht nämlich nicht automatisch!

Fazit

Ich bin mit dem Ergebnis sehr zufrieden. Bei der Konfiguration der LEDs tobe ich mich vielleicht noch ein bisschen aus, das ist mir vielleicht einen ticken zu farbintensiv. Aber da hat man ja alle Möglichkeiten dank WLED. Ein bisschen Zeit und Geduld sollte man für das Projekt mitbringen. Es sind, abhängig von der Anzahl der verwendeten LEDs, schon einige Arbeitsschritte. Aber es lohnt sich. Was die Kosten angeht, stehe ich am Ende bei irgendwas um die 20-30 Euro. Einige der Komponenten hatte ich noch hier und das Nokia 5110 habe ich jetzt natürlich nicht in die Rechnung mit aufgenommen – das ist eh unbezahlbar.

Ein Beispiel ist die Nutzung von Python-Skripten für Projekte wie die AWTRIX-Bibliothek. Statt stundenlang Dokumentationen zu wälzen oder sich durch Foren zu kämpfen, können Maker KI-gestützte Tools wie Chatbots oder Codegeneratoren nutzen, um sich passgenaue Skripte erstellen und erklären zu lassen. Die KI kann beispielsweise dabei helfen, MQTT-Kommunikation für eine smarte LED-Matrix zu implementieren oder ein Skript zur Ansteuerung spezifischer Hardware-Komponenten zu schreiben.

Allerdings ist der erste Entwurf oft nicht perfekt. Iterationen sind entscheidend: Es kann mehrere Versuche brauchen, bis die KI genau das gewünschte Ergebnis liefert. Durch präzisere Prompts, das Testen und Anpassen des generierten Codes oder gezieltes Nachfragen lässt sich die Qualität deutlich steigern.

Kurz gesagt: Generative KI ist ein mächtiges Werkzeug für Maker – nicht als Ersatz für Wissen und Erfahrung, sondern als Booster für kreative Projekte. Wer bereit ist, mit ihr zu experimentieren, kann viele Hürden schneller überwinden und seine Ideen effizienter umsetzen.

Das Projekt basiert auf der LoRa-Technologie (Long Range), die speziell für die Übertragung kurzer Nachrichten bei minimalem Energieverbrauch über große Distanzen entwickelt wurde. Wie der Name „Meshtastic“ schon andeutet, wird dabei ein sogenanntes Mesh-Netzwerk aufgebaut. In diesem schließen sich die Teilnehmer automatisch zusammen, um Datenpakete weiterzuleiten. Dies ermöglicht eine deutliche Erweiterung der Reichweite – vorausgesetzt, in der Umgebung sind ausreichend viele Nutzer aktiv.

Praktische Einsatzmöglichkeiten gibt es viele: Von der Überwachung der Garage, über das Übermitteln von Wetterdaten, bis hin zur Benachrichtigung, wenn die Waschmaschine fertig ist. Unter optimalen Bedingungen wurden sogar Reichweiten von bis zu 331 Kilometern erzielt, in städtischen Gebieten ist da mit „etwas“ weniger zu rechnen.

In meinem aktuellen Video teste ich die Reichweite von Meshtastic unter verschiedenen Bedingungen und Standorten. Dabei nutze ich ein einfaches Setup mit günstigen Komponenten, um zu sehen, was unter realistischen Bedingungen möglich ist. Das Ergebnis und weitere Eindrücke findet ihr im Video. Schaut gerne vorbei, um mehr über Meshtastic zu erfahren und einen Blick auf die Testergebnisse zu werfen!

Telegram Proxy

Für den Test habe ich mir ein kleines Script geschrieben, welches die API des Meshtastic Webinterfaces nutzt. Empfangene Nachrichten werden von folgendem Script abgerufen und dann an meinen Telegram-Bot weitergeleitet. Somit kann ich direkt sehen, ob eine Nachricht empfangen wurde oder nicht. Falls Interesse besteht mit dem Script zu experimentieren, hier ist es:

import requests
import time
from meshtastic import mesh_pb2  # Meshtastic Protobuf-Dateien nutzen

# Meshtastic HTTP-API-Konfiguration
MESHTASTIC_IP = "192.168.178.98"  # IP-Adresse des Meshtastic-Geräts
FROM_RADIO_URL = f"http://{MESHTASTIC_IP}/api/v1/fromradio"
SEND_URL = f"http://{MESHTASTIC_IP}/api/v1/send"

# Telegram-Konfiguration
BOT_TOKEN = "abc..." # Telegram-Bot Token
CHAT_ID = "123..."   # Telegram Chat ID
TELEGRAM_URL = f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage"

# Funktion: Nachricht an Telegram senden
def send_to_telegram(message):
    try:
        response = requests.post(
            TELEGRAM_URL, data={"chat_id": CHAT_ID, "text": message}
        )
        if response.status_code == 200:
            print("Nachricht erfolgreich an Telegram gesendet!")
        else:
            print(f"Fehler beim Senden an Telegram: {response.status_code}, {response.text}")
    except Exception as e:
        print(f"Telegram-Fehler: {e}")

# Funktion: Nachrichten von Meshtastic abrufen (Protobuf-Format)
def get_messages():
    try:
        response = requests.get(FROM_RADIO_URL, stream=True)
        if response.status_code == 200:
            for raw_message in response.iter_content(chunk_size=None):
                if raw_message:
                    process_protobuf_message(raw_message)
        else:
            print(f"Fehler beim Abrufen von Nachrichten: {response.status_code}, {response.text}")
    except Exception as e:
        print(f"Fehler beim Abrufen der Nachrichten: {e}")

# Funktion: Protobuf-Nachricht verarbeiten
def process_protobuf_message(raw_message):
    try:
        # Protobuf-Daten dekodieren
        message = mesh_pb2.FromRadio()
        message.ParseFromString(raw_message)
        print(message)

        # Nur Textnachrichten verarbeiten
        if message.packet.decoded.payload.decode("utf-8") and message.packet.decoded.portnum == 1:
            text_message = message.packet.decoded.payload.decode("utf-8")
            rx_rssi = message.packet.rx_rssi
            #sender_id = message.packet["from"]

            # Nachricht an Telegram weiterleiten
            print(f"Neue Nachricht: {text_message}")
            send_to_telegram(f"Received: {text_message} (RX RSSI: {rx_rssi} dBm)")

            # ACK-Nachricht zurücksenden
            #send_ack(sender_id, text_message)
    except Exception as e:
        print(f"Fehler beim Verarbeiten der Protobuf-Nachricht: {e}")

# Funktion: ACK-Nachricht über HTTP-API senden
def send_ack(destination_id, original_message):
    ack_message = f"ack: {original_message}"
    try:
        response = requests.post(
            SEND_URL,
            json={"destinationId": destination_id, "text": ack_message}
        )
        if response.status_code == 200:
            print(f"ACK gesendet an {destination_id}: {ack_message}")
        else:
            print(f"Fehler beim Senden der ACK: {response.status_code}, {response.text}")
    except Exception as e:
        print(f"Fehler beim Senden der ACK: {e}")

# Hauptschleife
try:
    print("Starte Abfrage... (Drücke STRG+C zum Beenden)")
    while True:
        get_messages()
        time.sleep(1)  # CPU-Schonzeit
except KeyboardInterrupt:
    print("Beendet.")

Man muss sich zunächst selbst einen Telegram-Bot einrichten, um die Nachrichten dann später abzusetzen. Dazu müssen dann die ID des Bots sowie eine Chat-ID hinterlegt werden.

1. Santa’s Workout 4

Link: Santa’s Workout 4 – Jingle All The Way
Ein unterhaltsames Puzzle-Spiel mit weihnachtlichem Flair! Ihr helft Santa dabei, sich auf seinen großen Tag vorzubereiten, indem ihr verschiedene Aufgaben löst und Hindernisse überwindet. Perfekt für die Feiertage!

2. Tiburoncy

Link: Tiburoncy – C64
In diesem spannenden Arcade-Spiel übernehmt ihr die Kontrolle über einen kleinen Deflin, der in bunten Unterwasserlandschaften Hindernissen ausweichen und Beute sammeln muss. Einfach zu lernen, aber schwer zu meistern!

3. Super GP 64

Link: Super GP 64
Für Fans von Rennspielen ist Super GP 64 ein Muss. Rast über klassische Pixel-Strecken und beweist euer Können hinter dem Steuer. Die schnellen Rennen und die stilvolle Retro-Grafik sorgen für reichlich Adrenalin.

4. Sky Savior

Link: Sky Savior 64
In Sky Savior nehmt ihr Platz in einem futuristischen Flugzeug, um feindliche Wellen abzuwehren und eure Highscores zu knacken. Die actionreiche Steuerung und die liebevolle Grafik machen dieses Spiel zu einem Highlight.

5. Nixy and the Seeds of Doom

Link: Nixy and the Seeds of Doom
Dieses Adventure-Spiel kombiniert Erkundung, knifflige Rätsel und eine fantasievolle Geschichte. Schließt euch Nixy an, um eine bedrohte Welt zu retten. Ein echtes Juwel für Retro-Fans!

Weitere Ressourcen

Falls ihr noch mehr Lust auf C64-Spiele habt, bietet Lemon64 eine umfangreiche Liste von Public-Domain-Spielen für den C64.

Also, Emulator anwerfen oder den echten C64 starten und los geht’s mit einem Hauch Nostalgie!

Zu der Zeit war ich 12 Jahre und begeistert von der Möglichkeit, das mein kleiner Pager an der Hose überall wo ich war plötzlich losgehen könnte und mich mit einer persönlichen Nachricht über etwas informieren könnte oder ich dank den kostenfreien DPA-Meldungen etwas spannendes aus der weiten Welt erfahren würde. Zugegeben, aufgrund der hohen Gebühren scheuten sich potentielle Nachrichten Verfasser eher mir etwas mitzuteilen und so bimmelte es eher wenn die DPA sich meldete.

Gefunkt wurde auf 448,475 MHz mit dem POCSAG-Protokoll. Deutschland wurde dabei von Quix in 5 Zonen eingeteilt. Als Nutzer musste man mitteilen, in welcher man sich befand damit dort die Aussendung der Nachrichten stattfinden konnte. Textnachrichten durften dabei bis zu 117 Zeichen lang sein, also nicht mehr so lang wie eine einfache SMS. Apropos SMS: Anders als bei einer SMS, die bei ausgeschaltetem Gerät oder im Funkloch beim Anbieter darauf wartet an den Nutzer übertragen zu werden, waren „Quixe“ einfach verloren wenn man gerade mal nicht „auf Empfang“ war. Einer der größten Nachteile der Technik.

Wollte man eine Nachricht aufgeben, so hatte man gleich 2 Hürden: Zum einen kostete es bis zu 2,40 Mark eine Textnachricht loszuwerden. Zum anderen musste man mit Menschen reden! Zwar war der Versand später auch via BTX, Windows-Software oder Fax möglich. Aber gerade zum Start bestand die einfachste Möglichkeit darin, einen Operator anzurufen dem man dann die Nachricht diktierte.

Richtig alt wurde das Ganze nicht: Die SMS fand schnell weitere Verbreitung. Sie war etwas günstiger, konnte von Handy zu Handy geschickt werden und sie war eben auch zuverlässiger. So geriet das Geschäftsmodell der Pager bereits 1998 in Schieflage, konnte aber nochmal gerettet und bis Ende 2001 fortgeführt werden. Seitdem gehört die Technik zumindest in der breiten Maße zum alten Eisen. Funkamateure nutzen die alten Pager teils noch im Hobbybereich und es mag sicher auch noch andere Dienste geben, bei denen Pager von Nutzen und im Einsatz sind. Aber vermutlich werden viele der nach 2000 geborenen heutzutage nicht mal mehr wissen, wozu so ein Gerät eigentlich gut war.

In meinem Video habe ich meinen alten „Quix News 1“ wiederbelebt. Damals hat der gute 149,- Mark gekostet. Und tatsächlich hat all die Jahre noch eine alte Nachricht im Speicher des Quix überlebt…

Inhalt des Videos

Inzwischen sieht das etwas anders aus. Da ich mir vorstellen kann, dass dieses Jahr beim Einen oder der Anderen ein 3D Drucker auf dem Wunschzettel stehen könnte, dachte ich, ich fasse meine Erfahrungen die zum Start nützlich sein könnten für Beginner einfach mal zusammen. Rausgekommen ist ein 15-minütiges Video, in dem ich u.a. aber nicht ausschließlich die folgenden Themen anreiße:

• Software zur Erstellung von eigenen 3D-Modellen
• Download von fertigen Modellen und was zu beachten ist
• Sinnvolle Tools und Hilfsmittel
• Der richtige Standort für den neuen Drucker
• Was kostet 3D drucken eigentlich?
• Slicer Software: Was soll das und was muss ich da einstellen?
• Tipps zu gängigen Problemen, denen man sich als Anfänger häufig konfrontiert sieht

Links aus dem Video

Hier findet ihr die im Video verlinkten Websites.

• FreeCAD
• Fusion360
• Blender
• Thingiverse
• Printables
• Ultimaker Cura