4 digit 7 segment display is widely known and used in clock, simple screens and low cost number displaying. Raspberry PI can directly manage it by using proper GPIO connections and a few lines of python code
4 Digit 7 Segment Display is a simple electronic display, similar to Single 7 segment display, but composed of 4 digits than can show at the same time 4 chars. It also has dot leds, but in different confiurations (single for each digit, central colon, etc).
It is used within a wide number application, usually to diplay time.
Its operation is based on persistence of vision principle: you can drive one digit at time, so you must drive each digit at a speed so that human eye cannot perceive power off moments.
When using 4-digit 7-segment display, please notice that if it is common anode, the common anode pin connects to the power source; if it is common cathode, the common cathode pin connects to the GND. This guide is based on cathode one, nut anode works with the same code by inverting digit selection logic.
These devices have a simple internal wiring diagrams:
As shown in picture, once configured A…DP pins to 1 (HIGH) to diplay correct number, pins 12, 9, 8 and 6 drive in what digit position to display. For cathode elements, these four pins must all stay to 1 (HIGH) except for the digit you want to power on. For anode elements, these pins must all stay to 0 (LOW) except for the digit you want to power on.
Followin picture shows also the pinout for the cathodic 4 digit display I’m going to use:
In this article we’ll control our 4 Digit 7 segment display from a Raspberry PI Zero W. This article applies also to newer Raspberry PI boards.
What We Need
As usual, I suggest adding from now to your favorite e-commerce shopping cart all needed hardware, so that at the end you will be able to evaluate overall costs and decide if continuing with the project or removing them from the shopping cart. So, hardware will be only:
- Raspberry PI Zero W (including proper power supply or using a smartphone micro usb charger with at least 3A) or newer Raspberry PI Board
- high speed micro SD card (at least 16 GB, at least class 10)
- Dupont Wiring
- Solderless breadboard
- a 4 digit 7 segment display
- 4x resistors (100 Ohm used)
Many of listed hardware (except from Raspberry PI Zero W and micro SD Card) can be bought alone or can be also found in the useful Elegoo starter kit.
Prepare cabling according to following wiring diagram:
This wiring produces the following mapping between Display and Raspberry PI:
|Display Segment||Display Pin||Raspberry PI phisical pin||Raspberry PI BCM GPIO|
Please find below the overall picture:
Make your OS up-to-date:
sudo apt update sudo apt upgrade
sudo apt install rpi.gpio
Get from my download area seg4DigitDisplay.py script:
This script can be used by simply calling from terminal:
Value to be displayed must be set in “toDisplay” variable inside the script:
toDisplay="16.30" # numbers and digits to display
This variable can be set with four numbers and one dot or no dot after each number. A space will deploy a powered off digit corresponding to its position. Please find below some valid examples:
- 1 2.3 (there is a space between “1” and “2”)
- 1.2 3. (there is a space between “2” and “3”)
- 123. (there is a space before “1”)
To stop script, simply press CTRL+C. This will execute a GPIO clenaup closing all GPIOs.
This script starts with some variables setting:
toDisplay="16.30" # numbers and digits to display delay = 0.005 # delay between digits refresh
toDisplay sets what you want to show in your display.
Delay is the time each single digit stays on. So, from it also depends the refresh rate for overall display. This is an important variable. A too low delay means that Raspberry PI could not be able to disable/enable GPIOs so fast, thus resulting with all segments in all digis appearing on. A too high delay means that refresh rate is affeted, resulting in a blinking effect for display digits (with persistence of vision resulting compromised). Also resistors affect these results. With 100ohm resistors I reached a good result on 0.005 seconds delay.
Following section defines what Raspberry PI pins we are going to use. We will use BCM naming convention. Please refer to Raspberry PI Pinout for phisical to BCM relations
selDigit = [14,15,18,23] # Digits: 1, 2, 3, 4 display_list = [24,25,8,7,1,12,16] # define GPIO ports to use #disp.List ref: A ,B ,C,D,E,F ,G digitDP = 20 #DOT = GPIO 20
Then GPIOs are also all set as output:
GPIO.setwarnings(False) for pin in display_list: GPIO.setup(pin,GPIO.OUT) # setting pins for segments for pin in selDigit: GPIO.setup(pin,GPIO.OUT) # setting pins for digit selector GPIO.setup(digitDP,GPIO.OUT) # setting dot pin GPIO.setwarnings(True)
Warnings are disabled because this script will leave display active after execution.
An array is prepared to manage easily segments activation for each single number (so that arrSeg shows 0, arrSeg shows 1, etc):
arrSeg = [[1,1,1,1,1,1,0],\ [0,1,1,0,0,0,0],\ [1,1,0,1,1,0,1],\ [1,1,1,1,0,0,1],\ [0,1,1,0,0,1,1],\ [1,0,1,1,0,1,1],\ [1,0,1,1,1,1,1],\ [1,1,1,0,0,0,0],\ [1,1,1,1,1,1,1],\ [1,1,1,1,0,1,1]]
Then the two main functions come. As you can remember, we defined what to display as a string in toDisplay variable. spliToDisplay function splits this string in an array of 4 elements, so that each element is a simple number (or space). Also dots are added to the element that the dot is following.
def splitToDisplay (toDisplay): # splits string to digits to display arrToDisplay=list(toDisplay) for i in range(len(arrToDisplay)): if arrToDisplay[i] == ".": arrToDisplay[(i-1)] = arrToDisplay[(i-1)] + arrToDisplay[i] # dots are concatenated to previous array element while "." in arrToDisplay: arrToDisplay.remove(".") # array items containing dot char alone are removed return arrToDisplay
With an array so composed, the showDsiplay function takes in charge to display all 4 digits. This uses a for cicle with 4 steps. Each step enables a digit by putting its selector to 0 (LOW). This is because we are using a cathode Display.
def showDisplay(digit): for i in range(0, 4): #loop on 4 digits selectors (from 0 to 3 included) sel = [1,1,1,1] sel[i] = 0 GPIO.output(selDigit, sel) # activates selected digit if digit[i].replace(".", "") == " ": # space disables digit GPIO.output(display_list,0) continue numDisplay = int(digit[i].replace(".", "")) GPIO.output(display_list, arrSeg[numDisplay]) # segments are activated according to digit mapping if digit[i].count(".") == 1: GPIO.output(digitDP,1) else: GPIO.output(digitDP,0) time.sleep(delay)
With anode displays modify the two rows according to the following:
sel = [0,0,0,0] sel[i] = 1
Finally, the main loop is an infinite number of recalls to previously defined functions in pipe.
try: while True: showDisplay(splitToDisplay(toDisplay)) except KeyboardInterrupt: print('interrupted!') GPIO.cleanup() sys.exit()
The “except KeyboardInterrup” manages a Keyboard interrupt (CTRL+C) so that this trigger passes a GPIO clenanup before exiting, so powering off the whole circuit.
We are sorry that this post was not useful for you!
Let us improve this post!
Tell us how we can improve this post?