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 favourite e-commerce shopping cart all the needed hardware, so that at the end you will be able to evaluate overall costs and decide if continue with the project or remove 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 physical pin||Raspberry PI BCM GPIO|
Please find below the overall picture:
Make your OS up-to-date:
sudo apt update sudo apt upgrade
RPI.GPIO should be already installed (otherwise, you can get it installed with the command “sudo apt install python3-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 the script, simply press CTRL+C. This will execute a GPIO cleanup closing all GPIOs.
This script starts with some variables set:
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 every single digit stays on. So, it also depends on the refresh rate for the 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 in all segments in all digits appearing on. A too high delay means that refresh rate is affected, resulting in a blinking effect for display digits (with the persistence of vision resulting compromised). Also, resistors affect these results. With 100ohm resistors, I reached a good result on 0.005 seconds delay.
The 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 physical 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 the 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 charge to display all 4 digits. This uses a for cycle 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 cleanup 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?