The Simpsons TV – 3.5″ Screen Version

Connect an HDMI monitor and power source to the Raspberry Pi as shown in the picture above. At this time, the IP address assigned to the Pi should scroll up on the screen, take a note and jot it down. You should now be able to log into the Raspberry Pi remotely on a computer logged into the same network as the Pi.

Using a terminal program, such as Putty, establish a SSH session with the Raspberry Pi at the IP address you noted on the HDMI screen connected to the Pi as it booted (reference example picture above). Alternately, in Windows, you can type the following at a system command prompt to establish an SSH session with the Pi:

ssh raspberrypi.local -l pi

If you didn’t see the IP address or if it changed, you can type “ping raspberrypi” at a system command prompt on your computer to see what IP address is returned.

Once the SSH session is established, you will need to enter the login credentials of the Raspberry Pi. The default user is “pi” and the password is “raspberry” as shown below:

login as: pi
[email protected]'s password:
Linux raspberrypi 5.10.63-v7+ #1496 SMP Wed Dec 1 15:58:11 GMT 2021 armv7l

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Mon Feb 14 05:05:40 2022

SSH is enabled and the default password for the 'pi' user has not been changed.
This is a security risk - please login as the 'pi' user and type 'passwd' to set a new password.

[email protected]:~ $

Now, we need to update the OS. In the terminal, type:

sudo apt-get update

After that finishes, type:

sudo apt-get upgrade

You may get a prompt asking, “Do you want to continue? [Y/n]”. Type Y and hit <ENTER>

Enabling USB Drive Support:

A USB drive will later be needed to copy your video files over to the Pi’s SD card. We will need to install a couple of packages to allow easy mounting and dismounting of a USB drive to the Pi with the following commands:

sudo apt-get install usbmount

Again, you may get a prompt asking, “Do you want to continue? [Y/n]”. Type Y and hit <ENTER>

sudo apt-get install eject

Now, we will finish up USB drive support by editing the systemd-udevd.service file. To do this, type the following command:

sudo nano /lib/systemd/system/systemd-udevd.service

Scroll down to where it says:

PrivateMounts=yes

Change it to:

PrivateMounts=no

Save the file by typing Ctrl-o, hit <ENTER>, then exit the editor by typing Ctrl-x

Configure Auto Log-In at Boot

We need to make sure the Raspberry Pi just boots up without being stopped to Login on the 3.5″ LCD. To do this, enter the following in the terminal at a command prompt:

sudo raspi-config

• Select “1 System Options“
• Select “S5 Boot / Auto Login“
• Select “B2 Console Autologin“
• Select “OK“
• Select “Finish“

The system will ask you, “Would you like to reboot now?”

Select “Yes“.

If you accidentally select “No”, no worries – you can still reboot by entering the following command:

sudo reboot -h now

Install 3.5″ LCD Graphics Drivers:

First, we will need to install the git package. Git allows you to clone files and file structures from github. This is needed to install the 3.5″ LCD graphics drivers. To install the git package, type the following command:

sudo apt-get install git

You may get a prompt asking, “Do you want to continue? [Y/n]”. Type Y and hit <ENTER>

Instructions come with with the iUniker 3.5″ LCD that tell you how to install the display drivers. You should follow those instructions. For the one I got, the instructions state to type the following commands:

cd ~/
git clone https://github.com/tianyoujian/MZDPI.git
cd MZDPI/mzp351hv00br
sudo chmod +x mzdpi-hvga-autoinstall
sudo ./mzdpi-hvga-autoinstall

Most likely, you will have encountered errors on that last command due to several package dependencies not being installed. You can install these dependencies manually or type the following command to install all the dependencies from the last command:

sudo apt --fix-broken install

This will install several packages. You may get prompts asking “Do you want to continue? [Y/n]”. Type Y and hit <ENTER> for each of these.

Once these package installations all complete, type the following command again:

sudo ./mzdpi-hvga-autoinstall

This time, this command should complete successfully. At this point, if you reboot, system video will be sent to the 3.5″ LCD (if attached) – the HDMI port will not work. No worries though – your SSH session “look” will not change.

NOTE: To re-enable the HDMI port, you can edit the config.txt file using the following command:

sudo nano /boot/config.txt

scroll to “include mzp351hv00br.txt” and comment it out by putting a “#” in front of it. This will look like, “#include mzp351hv00br.txt“.

Save the file by typing Ctrl-o, then exit the editor by typing Ctrl-x

The next time you reboot, the video will be sent back out the HDMI connector.

To re-enable output to the 3.5″ LCD, just re-edit the config.txt file again and remove the “#” so that you have “include mzp351hv00br.txt” again. Save and exit. The next time you reboot, the video will be sent to the 3.5″ LCD.

Enable Audio Output:

Some of the GPIO pins on the Raspberry Pi Zero 2 have special alternate functions. One of those functions happens to be PWM audio output on pins 18 and 19. This project utilizes only the audio output on GPIO 19. So, to enable the PWM audio output on pin 19, we need to first edit the config.txt file located in the /boot/ directory again. To do this, type the following command:

sudo nano /boot/config.txt

Scroll to the bottom of this file and add the following text:

dtparam=audio=on
dtoverlay=audremap,enable_jack,pins_19

Save the file by typing Ctrl-o, then exit the editor by typing Ctrl-x

Next, we need to edit the rc.local file by typing the following command:

sudo nano /etc/rc.local

Add the following text towards the bottom, but before Exit 0.

sudo raspi-gpio set 19 op a5

This enables alternate function 5 (PWM output) on the GPIO19 pin.

Save the file by typing Ctrl-o, then exit the editor by typing Ctrl-x.

Simplify Boot Text:

For this next step, we will minimize the amount of boot text spewed out during the power ON process. We will also change the font size displayed on the screen so that channel and selection text will be clearly visible on the small display.

To start, type the following command:

sudo nano /boot/cmdline.txt

This file consists of a single line of a long list of parameters. scroll across and locate where it says console=tty1. Change just this text to:

console=tty3

continue scrolling until you locate fsck.repair=yes. Remove this text.

Now, go to the end of this line and add the following text:

consoleblank=0 logo.nologo quiet splash

Save the file by typing Ctrl-o, then exit the editor by typing Ctrl-x.

Increase System Font Size:

Now, we need to increase the system font size so that it is easier to see on the 3.5″ screen (needed for the program message outputs from the player.py python script). To increase the font size, type the following command:

sudo dpkg-reconfigure console-setup

Select UTF-8 -> Guess Optimal Character Set -> Terminus -> 16X32

NOTE: To revert back to the original font, type the above command again, but select:

UTF-8 -> Guess Optimal Character Set -> Do not change the boot/kernel font

Install OMXPlayer:

The omxplayer is the application used to actually play the videos. There are two pieces to install the omxplayer, the application itself and the omxplayer wrapper that allows our python script to interface to the omxplayer application.

So, the first step is to install the omxplayer application. To do this, enter the following command:

sudo apt-get install omxplayer

You may get a prompt asking, “Do you want to continue? [Y/n]”. Type Y and hit <ENTER>

To install the omxplayer wrapper and its dependencies, follow these steps in order (NOTE: some of these packages may already be installed via previous steps – but, follow these steps just to be sure):

sudo apt-get install -y libdbus-1-3
sudo apt-get install -y libdbus-1-dev
sudo apt-get install python-pip
sudo apt-get install python-dev
sudo apt-get install libglib2.0-dev
sudo pip2 install omxplayer-wrapper
sudo pip install --upgrade --no-deps --force-reinstall pathlib

For some of these steps, you may get a prompt asking, “Do you want to continue? [Y/n]”. Type Y and hit <ENTER>

Set Up Directory Structure:

Now, we need to set up the directory structure for “The Simpsons TV”. To do this, execute the following commands:

sudo mkdir ~/simpsonstv
sudo mkdir ~/simpsonstv/videos
sudo mkdir ~/simpsonstv/videos/"The Simpsons"

The directories under ~/simpsonstv/videos/ are considered to be “Channels“. So, continue using the sudo mkdir ~/simpsonstv/videos/<Channel> command for as many channels as you want. For example, on mine, I made directories(Channels) for Horror, Comedy, Action, Animated, Family, and Sci-Fi. When changing a “channel” in the python script, it is actually just switching to a different subdirectory. NOTE: If you want to make a directory with a space in it, be sure to put it in quotes just like was done in the command shown above making “The Simpsons” directory.

Creating player.py Python script:

We now are ready to create the python script that will run everything. It will be named “player.py” to be consistent with the original project. To create this python script, enter the following command (or, you can download the player.py file in this section and copy it to the ~/simpsonstv/ directory on the Pi):

sudo nano ~/simpsonstv/player.py

Then copy/paste the following text into the nano text editor (paste in the nano editor by copying the text below, then selecting your terminal window, then right-clicking your mouse.):

######################################################################################
# player.py
# Version:   1.0
# Author:    D.J. Hatfield
# Date:      2/21/2022
# Device:    Raspberry Pi Zero 2 W
# Purpose:   At startup, this script will start playing videos in the first subdirectory
#            under the "~/simpsonstv/videos/" specified by the "Directories" string array.
#            The next video in the same directory will automatically be played once the
#            existing video has completed playing.  All videos will be played in the current
#            specified directory and will loop around again once all are complete.
#
#
#            It also utilizes two "VCR" button inputs to implement the following features:
#             Right Button (GPIO 25):
#                -Quickly tap the button to select the next video in the current directory
#                -Press and hold the button for > 2 seconds to select the next "Channel"
#                 ("Channels" are just subdirectories under the ~/simpsonstv/videos/ directory and
#                  are specified in the "Directories" string array)
#             Left Button (GPIO 26):
#                -Quckly tap the button to pause or play the current video
#                -Press and hold the button for > 1 second to rewind current video by 10 seconds
#                 (continue holding to keep rewinding additional 10 seconds every second the button
#                  is pressed)
#             Press and hold BOTH the Right and Left buttons for > 5 seconds to shutdown the
#             OMXPlayer and exit this Python script and return to a command prompt.  NOTE: once
#             this Python script is terminated, the safe shutdown functionality will not work.
#             You will need to either restart this Python script to re-enable this functionality
#             or issue a "sudo shutdown now" command from a command prompt to safely shutdown the
#             Pi.
#
#             Additionally, this script monitors the Shutdown input (GPIO 11).  If this pin
#             is asserted (active LOW) for > 50mS, the Pi will be Shut down.
###########################################################################################


from omxplayer.player import OMXPlayer
from pathlib import Path
import os
import RPi.GPIO as GPIO
#import time as time_ - makes sure we don't override time
import time as time_
GPIO.setmode(GPIO.BCM)
GPIO.setup(26, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Set GPIO 26 as input with pull-up
GPIO.setup(25, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Set GPIO 25 as input with pull-up
GPIO.setup(11, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Set GPIO 11 as input with pull-up


# Add/change your video subdirectories in the Directories string array
# These are the "Channels"
Directories = ["The Simpsons", "Horror", "Action", "Comedies", "Animated", "Sci-Fi"]


#     <<<ROUTINES>>>
#-----------------------------------------------------------------------------------------------------------------
# millis(): Returns the number of milliseconds elapsed since power up.
def millis():
    return int(round(time_.time() * 1000))
#-----------------------------------------------------------------------------------------------------------------
# displayDirectoryVideo():  Displays the currently selected Video and Channel on the LCD
#                           Returns nothing
def displayDirectoryVideo():
    #Must specify "global" variables - otherwise, the routine would create its own unique copy
    # of these variables when they are used.
    global Root_Path
    global Current_Directory
    global Current_Video
    global VIDEO_PATH
    global PlayTimer
    global playNew
    os.system("clear")  #clear the LCD screen
    Current_Video = videos[Video_Pointer]  #Set current video to that specified by the Video_Pointer
    VIDEO_PATH = Path(Root_Path + Current_Directory + "/" + Current_Video)
    print("")
    print("")
    print("")
    print("  Channel: " + Current_Directory)  #Print the "Channel" (directory) on the LCD screen
    print("  " + Current_Video[0:len(Current_Video)-4])  #Print the video selected on the LCD screen
    PlayTimer = millis()
    playNew = True  #Trigger starting the play of the new video in 1.5 seconds
#-----------------------------------------------------------------------------------------------------------------
# nextVideo(): Select the next video by incrementing the Video_Pointer;  Loops around once the end is reached
#              Returns nothing
def nextVideo():
    #Must specify "global" variables - otherwise, the routine would create its own unique copy
    # of these variables when they are used.
    global Video_Pointer
    global videos
    global manualSelect
    global player
    manualSelect = True  #Set the flag to indicate the next video was manually selected
    player.quit()        #Stop the currently playing video - this kills the current OMXPlayer instance
    Video_Pointer += 1   # Increment Video_Pointer
    if(Video_Pointer > (len(videos)-1)):
      Video_Pointer = 0  #Loop Video_Pointer back around once end of videos is reached
    displayDirectoryVideo() #Display Channel and Selected Video on the LCD screen


#-----------------------------------------------------------------------------------------------------------------
# getVideos(): Update the videos string array with a list of videos in the currently selected channel (directory)
#              Returns nothing
def getVideos():
    #Must specify "global" variables - otherwise, the routine would create its own unique copy
    # of these variables when they are used.
    global videos
    global Current_Directory
    global Root_Path
    videos = []  #Clear out the videos string array
    for file in os.listdir(Root_Path + Current_Directory):  #Cycle through all files in the current directory and
        if file.lower().endswith('.mp4'):                   #add to videos string array if it is an mp4 video file
            videos.append(file)
    videos.sort() #Rearrange the videos in the videos array in alpha-numerical order


#-----------------------------------------------------------------------------------------------------------------
# switchDirectory(): Select the next channel (directory) in the Directories string array - also point to the first
#                    video in this newly selected channel.
#                    Returns nothing
def switchDirectory():
    #Must specify "global" variables - otherwise, the routine would create its own unique copy
    # of these variables when they are used.
    global Video_Pointer
    global Directory_Pointer
    global Current_Directory
    global Directories
    global manualSelect
    global player
    manualSelect=True   #Set the flag to indicate the next video was manually selected
    player.quit()       #Stop the currently playing video - this kills the current OMXPlayer instance
    Video_Pointer = 0   #Set video pointer to the first video in the newly specified channel
    Directory_Pointer +=1 #Increment the Channel Pointer
    if(Directory_Pointer > (len(Directories)-1)):
      Directory_Pointer = 0  #Loop the Channel pointer back around once end of channels is reached
    Current_Directory = Directories[Directory_Pointer]  #Set current channel specified by the Directory_Pointer
    getVideos()         #Identify all videos in the newly specified channel (directory)
    displayDirectoryVideo()  #Display Channel and Selected Video on the LCD screen
#-----------------------------------------------------------------------------------------------------------------
# autoPlayNext(): Executed when an instance of OMXPlayer exits.  It automatically starts playing the next video in
#                 the current channel if the last video played to completion.  It will not try to play a video if
#                 OMXPlayer was shutdown by the user manually (i.e. selecting through videos for the next video).
#                 In the case of a manual video selection, the video will be played in the main loop.
#                 Returns nothing
def autoPlayNext(code):
   #Must specify "global" variables - otherwise, the routine would create its own unique copy
   # of these variables when they are used.
   global Video_Pointer
   global videos
   global manualSelect
   global Video_Pointer
   if (manualSelect == True):  #If this routine was entered by the user manually selecting the next video,
     manualSelect = False      # clear the manualSelect flag and,
     return                    # return doing nothing else - the main loop will handle manual select operations
   Video_Pointer +=1 # If this routine was entered due to a video completing playback, increment the Video_Pointer
   if(Video_Pointer > (len(videos)-1)):  #Loop the video pointer back around once the end of videos is reached
     Video_Pointer = 0
   displayDirectoryVideo()     #Display Channel and Selected Video on the LCD screen


#--------------------------------------------------------------
#     <<<INITIALIZATION>>>     Executed only once at script start
os.system("clear")             #Clear the LCD screen
Video_Pointer = 0              #Set Video Pointer to point to the first video file in the current channel
oneShotNextVideo = False       #Controls incrementing video pointer only ONCE per right button press
oneShotNextDirectory = False   #Controls incrementing directory pointer only ONCE per extended right button press
manualSelect = False           #Indicates manual video select vs automatic selection of new video file
PlayTimer = 0                  #Delays playing next video (allows user to read Channel/Video selection on LCD
Root_Path = "/home/pi/simpsonstv/videos/"  #Path to this application's video channels(subdirectories)
Directory_Pointer = 0          #Set Channel (directory) pointer to first entry
Current_Directory = Directories[0] #Point current Channel to first directory in the Directories string array
getVideos()                    #populate videos string array with all video files located in the current channel
Current_Video = videos[0]      #Point current video to first video in the videos string array
VIDEO_PATH = Path(Root_Path + Current_Directory + "/" + Current_Video) #Set video path
player = OMXPlayer(VIDEO_PATH) #Start playing video specified by the video path
player.exitEvent += lambda _, exit_code: autoPlayNext(exit_code) #Set OMXPlayer exit event handler to call the
                                                                 # autoPlayNext() routine when OMXPlayer exits
Button1Timer = millis()        #Used to debounce VCR right button for select next video indication
Button2Timer = millis()        #Used to debounce VCR left button for select pause/play indication
ShutDownTimer = millis()       #Used to debounce Shutdown signal from the safe shutdown circuit
ExitPythonTimer = millis()     #Used to debounce the long press of BOTH left & right buttons to exit python script
seekTimer = millis()           #Used to debounce left button rewind long press
seekToggle = True              #Used to pulse a 10 second rewind for every second the left button is pressed
playNew = False                #When true, triggers playing a new video 1.5 seconds after a new video selection.
oneShotPlayPause = False       #Used to control executing a play or pause command only ONCE per left button press
skipPause = False              #Prevents executing a play/pause command during long (rewind) press of left button


#----------------------------------------------------------------------------------------------------------------
#     <<<MAIN>>>     Main program loop - continuously executes
while (True):


   input1 = GPIO.input(25)  #Read VCR right button input
   input2 = GPIO.input(26)  #Read VCR left button input
   ShutItDown = GPIO.input(11)  #Read Shutdown signal input
   #Check GPIO 25 and debounce high and low going pulses to see if
   #commanded to switch to next video in the current directory
   #or if commanded to go to the next channel (directory) if button pressed longer than 2 seconds
   if((input1 == True) and (oneShotNextVideo == False)):
     Button1Timer = millis()
     oneShotNextDirectory = False
   #Debounce right button (GPIO 25) going to the active state (LOW) for 100mS to select next video
   if((input1 == False)):
     temp = millis()
     if((temp - Button1Timer) >= 100):
        PlayTimer = millis()
        if(oneShotNextVideo == False):
          oneShotNextVideo = True
          nextVideo()
        oneShotCheckLow = True
     #Continue checking for button press > 2 seconds for change channel (directory)
     if((temp - Button1Timer) >= 2000):
        if(oneShotNextDirectory == False):
          switchDirectory()
          oneShotNextDirectory = True


   #Debounce right button (GPIO 25) going to the inactive state (HIGH) for 50mS
   if((input1 == True) and (oneShotNextVideo == True) and (oneShotCheckLow == True)):
      oneShotCheckLow = False
      Button1Timer = millis()
   if((input1 == True) and (oneShotNextVideo == True)):
      temp = millis()
      if((temp - Button1Timer) >= 50):
        oneShotNextVideo = False
   #-------------------------------------------------------------
   #Check GPIO 26 and debounce high and low going pulses to see if
   #commanded to switch to pause or rewind 10 seconds if pressed longer than 1 second
   if((input2 == True) and (oneShotPlayPause == False)):
     Button2Timer = millis()
     skipPause = False
   #Debounce left button (GPIO 26) going to the active state (LOW) for 100mS to toggle pause/play
   if((input2 == False)):
     temp = millis()
     if((temp - Button2Timer) >= 100):
       if((oneShotPlayPause == False) and (skipPause == False)):
         oneShotPlayPause = True
     #Continue checking for button press > 1 second for rewind
     if((temp - Button2Timer) >= 1000):
       if(seekToggle == True):
         try:                        #Implement exception handler (try: and except:) - prevents python script from
                                     # crashing if exception occurs during (try:) code
           player.seek(-10)          #Rewind video 10 seconds - causes exception if OMXPlayer has been terminated
           seekToggle = False
           seekTimer = millis()
           oneShotPlayPause = False
           skipPause = True
         except Exception as e:      #Exception handler - executes if exception occurs during above try:
           Nothing = 0               #  Exception code:does nothing-just catches exception/prevents Python crash
       #Continue rewinding 10 seconds for every 1 second the left button is pressed
       if((temp - seekTimer) >= 1000):
         seekToggle = True
         seekTimer = millis()


   #Debounce left button (GPIO 26) going to the inactive state (HIGH) for 50mS
   if((input2 == True) and (oneShotPlayPause == True)):
      temp = millis()
      if((temp - Button2Timer) >= 50):
        try:                         #Implement exception handler (try: and except:) - prevents python script from
                                     # crashing if exception occurs during (try:) code
          player.play_pause()        #Toggle video play/pause - causes exception if OMXPlayer has been terminated
          oneShotPlayPause = False
        except Exception as e:       #Exception handler - executes if exception occurs during above try:
          Nothing = 0                #  Exception code:does nothing-just catches exception/prevents Python crash


   #-------------------------------------------------------------
   #Check for special case of both VCR buttons pressed > 5 seconds (command to exit player.py Python script)
   if ((input1 == False) and (input2 == False)):
     temp = millis()
     if ((temp - ExitPythonTimer) >= 5000):
       player.quit()                 #Shut down OMXPlayer
       print("Exiting Python script")
       quit()                        #Exit player.py Python script
   else:
     ExitPythonTimer = millis()


   #-------------------------------------------------------------
   #Check GPIO pin 11 for signal to safetly shutdown Pi (active low)
   #  this signal is only debounced on assertion for 50mS
   temp = millis()
   if ((ShutItDown == False) and ((temp - ShutDownTimer) >= 50)):
     os.system("clear")              #Clear the LCD screen
     print("")
     print("")
     print("  Shutting Down...")     #Print "Shutting Down..." message on the LCD screen
     os.system("sudo shutdown -h now") #Shut down the Raspberry Pi - the safe shutdown circuit will monitor the
                                       # status LED signal and remove power once activity ceases
   if (ShutItDown == True):          #Reset ShutDown timer if ShutItDown signal deasserts before timer times out
     ShutDownTimer = millis()


   #-------------------------------------------------------------
   #Play next selection 1.5 seconds after last command to change video or directory
   #  This allows enough time for a user to read the channel (directory) and
   #  new video selected on the screen
   #  This is controlled by the playNew boolean variable.  When playNew is set, it
   #  triggers playing the new video 1.5 seconds later
   temp = millis()
   if((temp - PlayTimer) >= 1500 and (playNew == True)):
     player=OMXPlayer(VIDEO_PATH)   #Start playing video specified by the video path
     player.exitEvent = lambda _, exit_code: autoPlayNext(exit_code) #Set OMXPlayer exit event handler to call the
                                                                     # autoPlayNext() routine when OMXPlayer exits
     playNew = False                #Reset the playNew flag
     manualSelect = False           #Reset the manualSelect flag (indicates automatic play unless changed by user)

Before you save, you should modify line 51 of the python code with your directories (“channels”). Line 51 above defines a string array called Directories. This line of code is explicitly:

Directories = ["The Simpsons", "Horror", "Action", "Comedies", "Animated", "Sci-Fi"] 

Change the entries to match the sub-directories you created in the ~/simpsonstv/videos/ directory. The order in this string array determines the order that the “channels” will sequence through when you press the “Next Channel” function on the VCR. Feel free to add or delete “channels”.

When you are done editing, save the file by typing Ctrl-o. Give it the filename “player.py“, then exit the editor by typing Ctrl-x.

Almost there! All that is left on the software side of things is to copy your video files into their “Channels” and configure the system to automatically start running the player.py python script at startup.