Geautomatiseerd TV Series & Anime Releasedatum Notificatiesysteem

Onderdelen en benodigdheden

JLCPCB Customized PCB	×	1
Arduino Nano 33 IoT	×	1
Raspberry Pi 3 Model B (of Raspberry Pi 4)	×	1
Raspberry Pi 4 Model B (of Raspberry Pi 3)	×	1
SparkFun Nokia 5110 Scherm	×	1
Serial MP3 Player by OPEN-SMART	×	1
RGB Diffused Common Anode LED	×	1
Flash Memory Card, SD Card	×	2
Weerstand 220 ohm	×	12
Pushbutton Switch 6x6x5	×	4
DC Power Jack 2.1mm Barrel-Type PCB Mount	×	1

Benodigde tools en machines

Solderbout (generiek)

Lijmpistool (generiek)

Apps en online services

Arduino IDE

KiCad

NotePad++

Over dit project

Beschrijving

Hoewel er talloze web- en mobiele apps zijn om releasedata van favoriete series bij te houden, wilde ik een apparaat maken dat mij vanaf nul – hardware én software – waarschuwt wanneer een nieuwe aflevering van een serie of anime in mijn lijst uitkomt, met diverse features.

Allereerst maakte ik een webapplicatie – TV Series / Anime Release Date Tracker – in PHP om een series/anime-lijst aan te maken en informatie over releasedata te verzamelen. Hiervoor gebruikte ik de TVMAZE REST API, die het mogelijk maakt om episode-informatie precies op releasedatum op te halen, zonder ingewikkelde codering. Vervolgens stelde ik een LAMP-server (met MariaDB) in op de Raspberry Pi om de applicatie te draaien. Voor wie geen Raspberry Pi heeft of niet wil gebruiken als host, publiceerde ik een gratis versie van de applicatie met een gebruiksvriendelijke interface op mijn website. De broncode vind je hieronder.

Na het regelen van de data-overdracht met de webapplicatie, gebruik ik een Arduino Nano 33 IoT als ontwikkelbord om data van de applicatie te verzamelen. Meer info hieronder over hoe ik de response verwerk met een delimiter. Voor het beheren van features en modi op de Nano 33 IoT, ontwierp ik een gebruikersinterface (menu) met een Nokia 5110 Scherm en drukknoppen.

Om gemeld te worden wanneer een nieuwe aflevering uitkomt met de openingsong, gebruikte ik een Serial MP3 Player Module (OPEN-SMART) vanwege de eenvoudige UART-commando's. Hierdoor kon ik ook een MP3 Player-modus toevoegen om alle openingsnummers af te spelen – wat het apparaat tot een leuke accessoire voor mijn kamer maakte.

Na het voltooien van het ontwerp op een breadboard en het testen van de code, ontwierp ik een PCB (TV Series / Anime Release Date Notifier) met een unieke retro-telefoonvorm voor een frisse look en gebruiksgemak.

Grote dank aan JLCPCB voor het sponsoren van dit project.

Geautomatiseerd TV Series & Anime Releasedatum Notificatiesysteem

Stap 1: PCB ontwerpen en solderen (TV Series / Anime Release Date Notifier)

De PCB is ontworpen met KiCad. De Gerber-bestanden zijn bijgevoegd – je kunt ze bij JLCPCB bestellen om het project na te bouwen.

Eerst soldeerde ik headers, drukknoppen, 220Ω weerstanden, de voedingsjack en de 5mm Anode RGB LED.

Componentenlijst op de PCB:

A1 (Headers voor Arduino Nano 33 IoT)
J1 (Headers voor Serial MP3 Player)
J2 (Headers voor DS3231 – niet verplicht)
J3 (Headers voor Nokia 5110 Scherm)
J4 (Voedingsjack)
D1 (5mm Anode RGB LED)
K1, K2, K3, K4 (Drukknoppen)
R1–R12 (220Ω weerstanden)

Stap 2: LAMP-webserver met MariaDB opzetten op Raspberry Pi

Als je nieuw bent met Raspberry Pi-programmeren, raadpleeg de goed uitgelegde instructies op de officiële Raspberry Pi-website.

Open een terminalvenster via Accessories > Terminal.
Installeer apache2: sudo apt-get install apache2 -y
Test de server: open Chromium (Internet > Chromium Web Browser) en ga naar https://localhost of gebruik het IP-adres van de Pi (hostname -I).
Installeer PHP: sudo apt-get update && sudo apt-get install php -y
Installeer MariaDB en PHP-MySQL: sudo apt-get install mariadb-server php-mysql -y
Voer sudo mysql_secure_installation uit voor beveiliging:
- Huidig wachtwoord voor root: Enter
- Root-wachtwoord instellen: Y, wachtwoord bot
- Anonieme gebruikers verwijderen: Y
- Root remote login verbieden: Y
- Test database verwijderen: Y
- Privilege tables herladen: Y
Maak database tvseries aan: sudo mysql -uroot -p → wachtwoord bot → create database tvseries;
GRANT ALL PRIVILEGES ON tvseries.* TO 'root'@'localhost' IDENTIFIED BY 'bot';
FLUSH PRIVILEGES;
Ctrl+D om af te sluiten.
Installeer php-curl voor API-aanroepen: sudo apt-get install php-curl
Herstart apache: sudo service apache2 restart

Stap 3: Informatie ophalen van TVMAZE REST API

TVMAZE biedt een gratis, gebruiksvriendelijke REST API. Bekijk de endpoints op TVMAZE REST API.

Ik gebruikte de optie Episode by Date om alle afleveringen van een serie op een specifieke datum op te halen.

URL: /shows/:id/episodesbydate?date=:date
Datum: ISO 8601 formaat
Voorbeeld: https://api.tvmaze.com/shows/1/episodesbydate?date=2013-07-01

Als er een aflevering is uitgezonden op de gegeven datum, geeft de API een array met volledige episode-info terug. Anders een HTTP 404.

Hieronder mijn favoriete series/anime-lijst voor dit project:

One Piece – TV ID: 1505 – tvmaze.com/shows/1505/one-piece
My Hero Academia – TV ID: 13615 – tvmaze.com/shows/13615/boku-no-hero-academia
Westworld – TV ID: 1371 – tvmaze.com/shows/1371/westworld
The Simpsons – TV ID: 83 – tvmaze.com/shows/83/the-simpsons
The Late Late Show with James Corden – TV ID: 2831 – tvmaze.com/shows/2831/the-late-late-show-with-james-corden

Ik voegde The Late Late Show toe om de code te testen, aangezien het een dagelijkse show is.

Stap 4: TV Series / Anime Release Date Tracker ontwikkelen (PHP) en series-tabel aanmaken

De applicatie is in PHP geschreven. De broncode staat in de codesectie. Als je niet met PHP wilt werken, download dan TV-Series-Anime-Episode-Tracker.zip en upload het naar de Raspberry Pi.

Installatie

Download TV-Series-Anime-Episode-Tracker.zip (bevat index.php en query.php).
Pak uit.
Verplaats naar servermap: sudo mv /home/pi/Downloads/TV-Series-Anime-Episode-Tracker/ /var/www/html/
Ga naar: https://localhost/TV-Series-Anime-Episode-Tracker/

Features

Bij eerste opening van index.php wordt de tabel series automatisch aangemaakt – melding: Database Table Created!
Als de tabel al bestaat: Database Table Found!
Voeg series toe aan de database via MySQL terminal: sudo mysql -uroot -p → wachtwoord bot → USE tvseries; → INSERT INTO `series` (`series_name`, `tv_id`, `status`) VALUES ('One Piece', '1505', 'Pending'); De status voorkomt herhaalde notificaties.
Op query.php vraagt de applicatie de TVMAZE API af. Als er een nieuwe aflevering is, print het een string die de Arduino kan parsen: %Series_Name%Season%Episode_Number%Episode_Name%
Bijv: %The Late Late Show%2020%91%Jason Schwartzman, Alicia Key%
Geen nieuwe aflevering: No Entry Found!

Code Uitleg

1) index.php

Database-instellingen: "localhost", "root", "bot", "tvseries".
checkDatabase(): controleert of tabel series bestaat.
createTable(): maakt tabel aan en informeert gebruiker.

2) query.php

Class query met TVMAZE API-pad.
define_user(): verbindingsinstellingen en tabelnaam.
check_ep_release_date(): gebruikt file_get_contents() om te checken of er een nieuwe aflevering is op de huidige datum. Wijzigt status van Pending naar Released om herhaling te voorkomen.
track_db_entries(): voert de check uit voor elke serie in de tabel.

Stap 4.1: Webapplicatie draaien zonder Raspberry Pi

Voor abonnees van mijn website (TheAmplituhedron) heb ik een gratis versie van de tracker gemaakt met gebruiksvriendelijke interface. Contacteer mij voor toegang.

Applicatie: theamplituhedron.com/dashboard/TV-Series-Anime-Episode-Tracker/

Stap 5: Arduino Nano 33 IoT opzetten

Download de benodigde drivers – Arduino SAMD Core – zoals uitgelegd hier.

Voor WiFi: installeer de WiFiNINA bibliotheek.

Voor Nokia 5110 scherm: installeer LCD5110_Basic bibliotheek.

Ik gebruik de tweede seriële poort (Serial1) op de Nano 33 IoT voor communicatie met de Serial MP3 Player.

Seriële poorten op Arduino Nano 33 IoT:

"De USB-connector is direct verbonden met de USB-host-pins van de SAMD21. Dit stelt je in staat de Nano 33 IoT als USB-client of USB-host te gebruiken. Deze poort kan ook als virtuele seriële poort dienen via het Serial object. De RX0 en TX1 pinnen zijn een tweede seriële poort beschikbaar als Serial1."

Stap 6: Commando's sturen naar Serial MP3 Player (OPEN-SMART)

Ik maakte een playlist met openingsnummers van mijn favoriete series/anime. Je kunt mijn playlist downloaden: opening_songs.zip.

Het is eenvoudig om de Serial MP3 Player te gebruiken met de Nano 33 IoT als je de UART-commando's kent. Let op: deze commando's werken alleen voor de OPEN-SMART module.

Instructies uit de handleiding:

"De module is een simpele MP3-speler gebaseerd op een hoogwaardige audiochip. Ondersteunt 8kHz–48kHz MP3 en WAV. Er zit een TF-kaartsocket op bord. De MCU stuurt afspelen via UART-commando's (wisselen, volume, speelmodus). Compatibel met Arduino/AVR/ARM/PIC."

"Zorg dat je micro-SD-kaart geformatteerd is als FAT16 of FAT32 en nummers bevat. Maak mappen '01' en '02', en plaats nummers met namen 001xxx.mp3, 002xxx.mp3, etc."

Sla je nummers op in map '01' met opeenvolgende nummers: 001One Piece-Opening.mp3, 002My Hero Academia-Opening.mp3, etc.

Om UART-commando's te sturen, maakte ik de functie send_command_to_MP3_player. Deze stuurt elke byte via Serial1 (RX0/TX1). Alle commando's beginnen met 0x7E en eindigen met 0xEF. De tweede byte is het aantal bytes ertussen.

// MP3 Player Commando's
static int8_t select_SD_card[] = {0x7e, 0x03, 0X35, 0x01, 0xef}; // 7E 03 35 01 EF
static int8_t play_song_1[] = {0x7e, 0x04, 0x41, 0x00, 0x01, 0xef}; // 7E 04 41 00 01 EF
static int8_t play_song_2[] = {0x7e, 0x04, 0x41, 0x00, 0x02, 0xef};
static int8_t play_song_3[] = {0x7e, 0x04, 0x41, 0x00, 0x03, 0xef};
static int8_t play_song_4[] = {0x7e, 0x04, 0x41, 0x00, 0x04, 0xef};
static int8_t play_song_5[] = {0x7e, 0x04, 0x41, 0x00, 0x05, 0xef};
static int8_t play[] = {0x7e, 0x02, 0x01, 0xef};
static int8_t pause[] = {0x7e, 0x02, 0x02, 0xef};
static int8_t next_song[] = {0x7e, 0x02, 0x03, 0xef};
static int8_t previous_song[] = {0x7e, 0x02, 0x04, 0xef};

Stap 7: Arduino Nano 33 IoT programmeren

Benodigde bibliotheken includen
WiFi-instellingen definiëren (SSID, wachtwoord)
IP-adres van Raspberry Pi invoeren
Pad van applicatie (query.php) definiëren
Ethernet client library initialiseren
Nokia 5110 scherm instellingen definiëren
Grafieken voor schermmodi (tv, music) definiëren
Monochrome afbeeldingen maken via Monochrome Image Converter
MP3 Player commando's definiëren
Menu-opties en modus met volatile boolean variabelen
Besturingsknoppen en RGB LED pinnen definiëren
Seriële communicatie voor MP3 Player op Serial1 initiëren
Verbinden met WiFi-netwerk
Verbinding verifiëren op seriële monitor en Nokia 5110 scherm
read_buttons(): knoppen uitlezen (Rechts, OK, Links, Exit)
change_menu_options(): optie verhogen/verlagen met Rechts/Links
interface(): menu weergeven
Als Init Tracker geselecteerd: verbinden met webapplicatie
Bij binnenkomende data: response ophalen van webapplicatie
Met endsWith() checken op percentage-teken (delimiter)
Als delimiter aanwezig: string splitsen op %} → Series_Name, Season, Episode, Episode_Name
Informatie printen en openingslied afspelen tot Exit ingedrukt wordt
Lege response: No Released Episode Detected :(
TV-icoon tekenen tijdens wachten op volgende request
Als MP3 Player modus: muzieknoot-icoon, besturing met knoppen
Als Sleep modus: na 10 seconden slapestand activeren, resterende seconden tonen

Aansluitingen en aanpassingen

// Aansluitingen
// Arduino Nano 33 IoT:
// Nokia 5110 Scherm
// D2 -------------------------- SCK (Clk)
// D3 -------------------------- MOSI (Din)
// D4 -------------------------- DC
// D5 -------------------------- RST
// D6 -------------------------- CS (CE)
// RGB
// D9 -------------------------- R
// D10 -------------------------- G
// D11 -------------------------- B
// LEFT_BUTTON
// A0 --------------------------- S
// OK_BUTTON
// A1 --------------------------- S
// RIGHT_BUTTON
// A2 --------------------------- S
// EXIT_BUTTON
// A3 --------------------------- S
// DS3231 (Optioneel voor Nano, niet nodig voor Nano 33 IoT)
// A4 --------------------------- SDA
// A5 --------------------------- SCL

Na het uploaden van de code, alle componenten via headers op de print zetten. Er is ook een aansluitslot voor DS3231 RTC Module voor wie de Nano 33 IoT wil vervangen door een gewone Nano – dan moet je releasedata handmatig invoeren voor een afteltimer.

Let op: je kunt een luidspreker of hooftelefoon aansluiten op de Serial MP3 Player. Ik gebruik de meegeleverde luidspreker (OPEN-SMART).

Modi en Features

WiFi verbinding: Toont Waiting... Attempting to connect to WiFi → na succes: Connected to WiFi!!!
Hoofdmenu: A.Init Tracker, B.MP3 Player, C.Sleep – schakelen met Rechts/Links, selecteren met OK.
A. Init Tracker:
- Verbinden met localhost (Raspberry Pi). Succes: Connected to the server!!!, Fout: Connection Error!!!
- Bij nieuwe aflevering: episode-info printen (Serie, Seizoen, Episode, Naam), openingslied afspelen, RGB-kleur per serie (One Piece=Rood, My Hero Academia=Groen, Westworld=Blauw, The Simpsons=Geel, The Late Late Show=Paars). Blijft tonen tot Exit ingedrukt.
- Elke aflevering maar één keer notificeren.
- Na Exit: TV-icoon tekenen tijdens wachten op volgende request.
- Geen nieuwe aflevering: No Released Episode Detected :( → TV-icoon.
- Exit tijdens TV-icoon: terug naar menu.
B. MP3 Player: Muzieknoot-icoon. Besturing: Rechts=Volgend, Links=Vorig, OK=Pauze. Exit=terug naar menu.
C. Sleep: Na 10 seconden slapestand activeren, seconden aftellen tonen. RGB-kleurpatroon als nachtlampje. Exit=terug naar menu, sluimer uitschakelen.

Video's en Conclusie

Na afloop bevestigde ik het apparaat aan mijn boekenkast met een lijmpistool. Het werkt fantastisch!

Code

Series_Release_Date_Notifier.ino Arduino

////////////////////////////////////////////////////
// TV Series / Anime New Episode
// Release Date Notifier
// -------------------------
// Arduino Nano 33 IoT
// by Kutluhan Aktar
////////////////////////////////////////////////////
// Get informed when new episodes of your favorite shows are on release with their opening songs via Nano 33 IoT and Raspberry Pi.
// I developed a corroborating web application in PHP for this project, named TV Series / Anime Release Date Tracker.
// You can either use a Raspberry Pi as the server, explained in the project tutorial, or TheAmplituhedron with the real-time database interface if you are a member.
// For more information: https://www.theamplituhedron.com/projects/TV-Series-Anime-New-Episode-Release-Date-Notifier/
// You can use the mentioned web application in free version on TheAmplituhedron as the host server if you are a subscriber:
// https://www.theamplituhedron.com/dashboard/TV-Series-Anime-Episode-Tracker/

// Connections
// Arduino Nano 33 IoT:
// Nokia 5110 Screen
// D2 --------------------------- SCK (Clk)
// D3 --------------------------- MOSI (Din)
// D4 --------------------------- DC
// D5 --------------------------- RST
// D6 --------------------------- CS (CE)
// RGB
// D9 --------------------------- R
// D10 --------------------------- G
// D11 --------------------------- B
// LEFT_BUTTON
// A0 --------------------------- S
// OK_BUTTON
// A1 --------------------------- S
// RIGHT_BUTTON
// A2 --------------------------- S
// EXIT_BUTTON
// A3 --------------------------- S
// DS3231 (Optional for Nano and Not Required for Nano 33 IoT)
// A4 --------------------------- SDA
// A5 --------------------------- SCL

#include <SPI.h>
#include <WiFiNINA.h>
#include <LCD5110_Basic.h>

char ssid[] = "[_SSID_]";
char pass[] = "[_PASSWORD_]";
int keyIndex = 0;
int status = WL_IDLE_STATUS;

IPAddress server(192, 168, 1, 22);
// char server[] = "www.theamplituhedron.com";

String application = "/TV-Series-Anime-Episode-Tracker/query.php";
// String HEDRON = "[_HEDRON_]";
// String application = "/dashboard/TV-Series-Anime-Episode-Tracker/" + HEDRON;

WiFiClient client;
// WiFiSSLClient client;

LCD5110 myGLCD(2,3,4,5,6);
extern uint8_t SmallFont[];
extern uint8_t MediumNumbers[];
extern uint8_t tv[];
extern uint8_t music[];

static int8_t select_SD_card[] = {0x7e, 0x03, 0X35, 0x01, 0xef};
static int8_t play_song_1[] = {0x7e, 0x04, 0x41, 0x00, 0x01, 0xef};
static int8_t play_song_2[] = {0x7e, 0x04, 0x41, 0x00, 0x02, 0xef};
static int8_t play_song_3[] = {0x7e, 0x04, 0x41, 0x00, 0x03, 0xef};
static int8_t play_song_4[] = {0x7e, 0x04, 0x41, 0x00, 0x04, 0xef};
static int8_t play_song_5[] = {0x7e, 0x04, 0x41, 0x00, 0x05, 0xef};
static int8_t play[] = {0x7e, 0x02, 0x01, 0xef};
static int8_t pause[] = {0x7e, 0x02, 0x02, 0xef};
static int8_t next_song[] = {0x7e, 0x02, 0x03, 0xef};
static int8_t previous_song[] = {0x7e, 0x02, 0x04, 0xef};

volatile boolean TV = false;
volatile boolean Music = false;
volatile boolean Sleep = false;
volatile boolean Activated = false;

#define B_Exit A3
#define B_Right A2
#define B_OK A1
#define B_Left A0

#define redPin 9
#define greenPin 10
#define bluePin 11

int Right, OK, Left, Exit;
int selected = 0;

void setup() {
  pinMode(B_Exit, INPUT);
  pinMode(B_Right, INPUT);
  pinMode(B_OK, INPUT);
  pinMode(B_Left, INPUT);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  adjustColor(0, 0, 0);
  myGLCD.InitLCD();
  myGLCD.setFont(SmallFont);
  Serial.begin(9600);
  Serial1.begin(9600);
  send_command_to_MP3_player(select_SD_card, 5);
  
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("Communication with WiFi module failed!");
    myGLCD.print("Connection Failed!", 0, 8);
    while (true);
  }
  
  while (status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    myGLCD.print("Waiting...", 0, 8);
    myGLCD.print("Attempting to", 0, 16);
    myGLCD.print("connect to", 0, 24);
    myGLCD.print("WiFi !!!", 0, 32);
    status = WiFi.begin(ssid, pass);
    delay(10000);
  }
  
  Serial.println("Connected to wifi");
  myGLCD.clrScr();
  myGLCD.print("Connected to", 0, 8);
  myGLCD.print("WiFi!!!", 0, 16);
  delay(2000);
  myGLCD.clrScr();
}

void loop() {
  read_buttons();
  change_menu_options();
  interface();
  
  if(TV == true){
    do{
      myGLCD.invertText(true);
      myGLCD.print("A.Init Tracker", 0, 16);
      myGLCD.invertText(false);
      delay(100);
      if(OK == HIGH){
        myGLCD.clrScr();
        Activated = true;
        while(Activated == true){
          if (client.connect(server, 80)) {
            Serial.println("connected to server");
            myGLCD.print("Connected to", 0, 8);
            myGLCD.print("the server!!!", 0, 16);
            client.println("GET " + application + " HTTP/1.1");
            client.println("Host: 192.168.1.22");
            client.println("Connection: close");
            client.println();
          }else{
            myGLCD.print("Connection", 0, 8);
            myGLCD.print("Error!!!", 0, 16);
          }
          delay(2000);
          
          String response = "";
          while (client.available()) {
            char c = client.read();
            response += c;
          }
          
          if(response != "" && response.endsWith("%")){
            int delimiter = response.indexOf("%");
            int delimiter_1 = response.indexOf("%", delimiter + 1);
            int delimiter_2 = response.indexOf("%", delimiter_1 +1);
            int delimiter_3 = response.indexOf("%", delimiter_2 +1);
            int delimiter_4 = response.indexOf("%", delimiter_3 +1);
            
            String Series_Name = response.substring(delimiter + 1, delimiter_1);
            String Season = response.substring(delimiter_1 + 1, delimiter_2);
            String Episode = response.substring(delimiter_2 + 1, delimiter_3);
            String Episode_Name = response.substring(delimiter_3 + 1, delimiter_4);
            
            myGLCD.clrScr();
            myGLCD.print(Series_Name, 0, 0);
            myGLCD.print(Season + " x " + Episode, 0, 16);
            myGLCD.print(Episode_Name, 0, 32);
            
            if(Series_Name == "One Piece") { send_command_to_MP3_player(play_song_1, 6); adjustColor(255,0,0); }
            if(Series_Name == "My Hero Academia") { send_command_to_MP3_player(play_song_2, 6); adjustColor(0,255,0); }
            if(Series_Name == "Westworld") { send_command_to_MP3_player(play_song_3, 6); adjustColor(0,0,255); }
            if(Series_Name == "The Simpsons") { send_command_to_MP3_player(play_song_4, 6); adjustColor(255,255,0); }
            if(Series_Name == "The Late Late Show") { send_command_to_MP3_player(play_song_5, 6); adjustColor(80,0,80); }
            
            volatile boolean song = true;
            while(song == true){
              read_buttons();
              if(Exit == HIGH){
                song = false;
                send_command_to_MP3_player(pause, 4);
                adjustColor(0,0,0);
              }
            }
            myGLCD.clrScr();
          }else{
            myGLCD.clrScr();
            myGLCD.print("No Released", 0, 0);
            myGLCD.print("Episode", 0, 16);
            myGLCD.print("Detected :(", 0, 32);
            delay(5000);
            myGLCD.clrScr();
          }
          
          myGLCD.drawBitmap(8, 0, tv, 60, 48);
          delay(10 * 1000);
          myGLCD.clrScr();
          
          read_buttons();
          if(Exit == HIGH){
            Activated = false;
            myGLCD.clrScr();
          }
        }
      }
    }while(TV == false);
  }
  
  if(Music == true){
    do{
      myGLCD.invertText(true);
      myGLCD.print("B.MP3 Player", 0, 24);
      myGLCD.invertText(false);
      delay(100);
      if(OK == HIGH){
        myGLCD.clrScr();
        Activated = true;
        while(Activated == true){
          read_buttons();
          myGLCD.drawBitmap(8, 0, music, 60, 48);
          if(Right == true) send_command_to_MP3_player(next_song, 4);
          if(Left == true) send_command_to_MP3_player(previous_song, 4);
          if(OK == true) send_command_to_MP3_player(pause, 4);
          if(Exit == HIGH){
            Activated = false;
            myGLCD.clrScr();
            send_command_to_MP3_player(pause, 4);
          }
        }
      }
    }while(Music == false);
  }
  
  if(Sleep == true){
    do{
      myGLCD.invertText(true);
      myGLCD.print("C.Sleep", 0, 32);
      myGLCD.invertText(false);
      delay(100);
      if(OK == HIGH){
        myGLCD.clrScr();
        myGLCD.print("Entering", CENTER, 0);
        myGLCD.print("Sleep Mode", CENTER, 8);
        myGLCD.print("in", CENTER, 16);
        myGLCD.print("Seconds", CENTER, 40);
        myGLCD.setFont(MediumNumbers);
        for (int s=10; s>=0; s--){
          myGLCD.printNumI(s, CENTER, 24, 2, '0');
          delay(1000);
        }
        myGLCD.enableSleep();
        Activated = true;
        while(Activated == true){
          adjustColor(255,0,0); delay(500);
          adjustColor(0,255,0); delay(500);
          adjustColor(0,0,255); delay(500);
          adjustColor(255,255,0); delay(500);
          adjustColor(80,0,80); delay(500);
          read_buttons();
          if(Exit == HIGH){
            Activated = false;
            myGLCD.clrScr();
            myGLCD.disableSleep();
            myGLCD.setFont(SmallFont);
            adjustColor(0,0,0);
          }
        }
      }
    }while(Sleep == false);
  }
}

void read_buttons(){
  Right = digitalRead(B_Right);
  OK = digitalRead(B_OK);
  Left = digitalRead(B_Left);
  Exit = digitalRead(B_Exit);
}

void send_command_to_MP3_player(int8_t command[], int len){
  Serial.print("\nMP3 Command => ");
  for(int i=0;i<len;i++){
    Serial1.write(command[i]);
    Serial.print(command[i], HEX);
  }
  delay(1000);
}

void interface(){
  myGLCD.print("Menu Options :", 0, 0);
  myGLCD.print("A.Init Tracker", 0, 16);
  myGLCD.print("B.MP3 Player", 0, 24);
  myGLCD.print("C.Sleep", 0, 32);
}

void change_menu_options(){
  if(Right == true) selected++;
  if(Left == true) selected--;
  if(selected < 0) selected = 3;
  if(selected > 3) selected = 1;
  delay(100);
  switch(selected){
    case 1: TV = true; Music = false; Sleep = false; break;
    case 2: TV = false; Music = true; Sleep = false; break;
    case 3: TV = false; Music = false; Sleep = true; break;
  }
}

void adjustColor(int red, int green, int blue){
  red = 255 - red;
  green = 255 - green;
  blue = 255 - blue;
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);
}

index.php PHP

<?php
$conn_database = mysqli_connect("localhost", "root", "bot", "tvseries");

function checkDatabase($table, $conn){
  $sql = "SHOW TABLES FROM `tvseries` LIKE '$table'";
  $check = mysqli_num_rows(mysqli_query($conn, $sql));
  return ($check > 0) ? true : false;
}

function createTable($table_name, $conn){
  if(!checkDatabase($table_name, $conn)){
    $sql = "CREATE TABLE `$table_name`(
      id int(11) AUTO_INCREMENT PRIMARY KEY NOT NULL,
      series_name varchar(255) NOT NULL,
      tv_id varchar(255) NOT NULL,
      status varchar(255) NOT NULL
    );";
    if(mysqli_query($conn, $sql)){
      echo "Database Table Created!";
    }else{
      echo "Error!";
    }
  }else{
    echo "Database Table Found!";
  }
}

createTable("series", $conn_database);
?>

query.php PHP

<?php
error_reporting(0);

class query{
  const ROOT = "https://api.tvmaze.com/shows/";
  const PATH = "/episodesbydate?date=";
  public $conn, $table_name;
  
  public function define_user($conn, $table_name){
    $this->conn = $conn;
    $this->table_name = $table_name;
  }
  
  private function check_ep_release_date($API_ID, $series_name, $status){
    $date = date("Y-m-d");
    $URL = self::ROOT.$API_ID.self::PATH.$date;
    if($get_content = json_decode(file_get_contents((String)$URL))){
      if($status != "Released"){
        echo "%".$series_name."%".$get_content[0]->season."%".$get_content[0]->number."%".$get_content[0]->name."%";
        $sql = "UPDATE `$this->table_name` SET `status`='Released' WHERE series_name='$series_name'";
        mysqli_query($this->conn, $sql);
      }
    }else{
      if($status != "Pending"){
        $sql = "UPDATE `$this->table_name` SET `status`='Pending' WHERE series_name='$series_name'";
        mysqli_query($this->conn, $sql);
      }
    }
  }
  
  public function track_db_entries(){
    $sql = "SELECT * FROM `$this->table_name` ORDER BY `id` DESC";
    if($result = mysqli_query($this->conn, $sql)){
      $check = mysqli_num_rows($result);
      if($check > 0){
        while($row = mysqli_fetch_assoc($result)){
          $this->check_ep_release_date($row['tv_id'], $row['series_name'], $row['status']);
        }
      }else{
        echo "No Entry Found!";
      }
    }else{
      echo "No Database Found!";
    }
  }
}

$conn_database = mysqli_connect("localhost", "root", "bot", "tvseries");
$table = "series";
$q = new query();
$q->define_user($conn_database, $table);
$q->track_db_entries();
?>

Custom parts and enclosures

gerber_ycEfXzZq6h.zip
tv-series-anime-episode-tracker_gCfN0nFiA8.zip
opening_songs_y2LCEw79tg.zip
tv_Iz2isO8nGI.c
music_SA2xR86cZw.c

Schema's

Arduino-gebaseerde Vacuum Fluorescent Display (VFD) Controller Kit DIY Arduino J.A.R.V.I.S. Stemassistent met Arc Reactor Design

Productieproces

3d printen

Automatisering Besturingssysteem

Industriële technologie