Skip to main content

Mission6_Seven_Segment_Display

You can always see 7-segment displays around you used to display digits, like in a timer, clock, etc. In this mission, you are going to learn how it works and show a number on it. Let's start.

What you need

The parts you will need are all included in the Maker kit.

  • SwiftIO board
  • Shield
  • 7-segment display

Circuit

  1. Place the shield on top of your SwiftIO board.

  2. Connect the 7-segment display to pins reserved for it on the shield. Make sure the decimal point is at the bottom.

Circuit diagram

Example code

// Import the SwiftIO library to use everything in it.
import SwiftIO

// Import the board library to use the Id of the specific board.
import MadBoard

// Set the number to be displayed.
let number = 6
// Initialize an instance of SevenSegment.
let sevenSeg = SevenSegment()

while true {
// Display the number.
sevenSeg.print(number)
}

Background

7-segment display

Why is it called a 7-segment display? Yeah, that's because it contains seven segments 🤣. They are A, B, C, D, E, F, G, which are 7 LEDs. You can control them separately.

7-segment display

The anodes of 7 LEDs are connected together. You can see a pin for the power connection. If you want A to be illuminated, you need to set the pin to low voltage.

The way you set these LEDs decides how the display looks. For example, to display the number 3, you will turn on A, B, C, D, G, and turn off E, F. Besides these numbers, you can also display characters.

Code analysis

In this mission, you will separate the code into two files. It makes your code more clear and organized.

  • The file SevenSegment.swift sets the 7-segment display and provides some easy-to-use functionalities.
  • The file main.swift is to show the digit on the 7-segment display.

SevenSegment.swift

Let's look at this file in detail.

import SwiftIO 
import MadBoard

As always, import the necessary libraries: SwiftIO and SwiftIOBoard. SwiftIO is used to control the input and output of the SwiftIO board. SwiftIOBoard defines the pin name of the board.

final class SevenSegment {
...
}

Then you will write the code in a class named SevenSegment. Briefly speaking, the class contains a block of code that allows you to create many instances with similar characteristics. It usually has methods (function in a class) and properties (constant or variable in a class).

The class can be inherited usually, but with the keyword final, it cannot be inherited any longer.

note

The class is a reference type. So if you create an instance and assign it to different constants, they all point to the same one. If you change any of the instances, all will change with it. That is why the class is used in your projects. Since the corresponding hardware is unique, any setting will cause changes in the hardware.

static let a = DigitalOut(Id.D8)
static let b = DigitalOut(Id.D7)
static let c = DigitalOut(Id.D6)
static let d = DigitalOut(Id.D5)
static let e = DigitalOut(Id.D4)
static let f = DigitalOut(Id.D2)
static let g = DigitalOut(Id.D3)

Initialize the 7 digital pins. To better identify the segments later, you name these pins as a, b, c... The pins should match the segments, or the final display will go wrong.

The keyword static makes these properties belong to the class, rather than to any instance of the class.

let leds = [a, b, c, d, e, f, g]

To simplify the code, you put them into an array. In this way, you can iterate them instead of dealing with them one by one manually.

An array is a collection of ordered values of the same type. To access its element, you can use its index. The index starts from 0. So if you want to access a, the code is written as led[0].

let ledState: [UInt8] = [
0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110,
0b01101101, 0b01111101, 0b00000111, 0b01111111, 0b01101111
]

This array stores the LED states of numbers from 0 to 9.

How does it work? There are 7 LEDs in total, so you can use a byte to represent its states. The bit corresponds to an LED. 1 means the LED is on, 0 means off. The image below shows the digit 0:

  • You will start from the least significant bit and reserve that bit for a.
  • For digit 0, all segments need to light on except g. So the last seven bits are all 1.
  • The most significant bit doesn't match any LED, and you can leave it as 0.
  • Then you need to tell the computer the type of this data. So add 0b for binary numbers.
Rrepresent 7 segments using a binary data
public func print(_ number: Int) {
...
}

After the preparation above, you are ready to set the 7-segment display.

You will create a method to show the number you pass to it. The keyword public allows you to use this method in other files.

let num = number % 10

Declare a constant to store the digit to be displayed. Since the 7-segment display can only show one digit, you use the remainder operator %. The number will be divided by 10 to get the remainder. For example, if the number is 45, num will be 5.

let value = ledState[num]

The num is then used as an index to access the elements in the array ledState. In this way, you get the exact value that stores the states of each LED. If num is 5, the value will be 0b01101101.

for i in 0..<7{
...
}

There are 7 LEDs in total, so you will iterate 7 times using a for-in loop. Here you will use the loop with a numeric range. ..< is the half-open range operator, which means i starts from 0 to 7 but doesn't include 7.

At first, i equals 0. After the code inside the brackets is executed, i will be 1 and restarts the code. Then repeat the process until all number is reached.

let state = (value >> i) & 0x01

This statement is to get the value of each bit. Let's look at the operators here:

  • >>: right shift, all bits will move to the right. The bits on the right will be discarded, and 0 will be added to the empty bits on the left.
  • &: bitwise AND operator, it will calculate each corresponding bit of two data. Only when both two bits are 1, the result will be 1, or it will be 0.
Bit calculation

Suppose the value is 0b01011011. At first, i=0, the value remains unchanged and is calculated with 0x01, so the state will be 1, which represents LED a; when i=1, the state equals the last second bit of value, 1, which represents LED b; and so on.

Calculate the state of each LED
if state == 0 {
leds[i].write(true)
} else {
leds[i].write(false)
}

After you get the value of the state, that is, you know the state of the LED, it's time to set the output!

The if-else statement is to decide the output voltage. If the value of state equals 0, write true to turn off the LED. Or, the pin outputs a low voltage to illuminate the LED. As iterating over each bit, the states of all LEDs will be set.

main.swift

This file is quite simple since all work related to the 7-segment has been done in the other file. Let's take a quick look.

Import the libraries. Then, of course, set the number you want to display.

Create an instance of the class SevenSegment, so you can use its method to display the number.

At last, use dot syntax to access the method and pass the number to it.

Well, it's done 🥳.

This project uses one way to organize your code. There are still other ways, and you'll look into it later.

Reference

DigitalOut - set whether the pin output a high or low voltage.

SwiftIOBoard - find the corresponding pin id of SwiftIO board.