Driving 7-Segment Displays with Arduino and ICs

Using 7 Segment Displays with and without Arduino

Some time ago, I was asked to make a video about a 7 segment Arduino clock, and I thought it sounded like a cool project. Now, everybody knows what an Arduino is, but those 7 segment displays are kinda old school and not often used in modern consumer electronics.

Different Types of 7 Segment Displays

There are different species of this display. There is a really simple one with only one digit in a case, and the more common two digits in one case. And whatever kind of display you get, always check the datasheet to find the pinout.

Understanding the Datasheet

In my case, I have a LTS546AG. What do we learn from the datasheet? First of all, we see that we are basically working with 8 individual LEDs, 7 for the bars and one for the decimal point. These LEDs are connected in a common anode configuration.

Controlling the Bars and Dot

We check the datasheet and see that the bars are labeled from A to G and the dot is DP. We scroll down a bit, and there it is. Now we know which pin is which bar, and we can use this display to our heart's desire.

Displaying Numbers without an Arduino

The easy solution is a BCD to 7 segment display driver. I'm using a SN74LS247, which has an active low level, which means it is capable of controlling all individual cathodes of our display.

Using a Binary Counter

We can use a 4-bit binary counter, the SN74290. Why this counter? Well, it has a BCD count sequence, so these two are pretty easy to combine.

Building a Homemade Range Meter

Now whenever we connect clock A to ground, the counter goes 1 up, and we see the next number. You can for example hook it up to a button and display the count on the 7 segment display.

Using an I2C Driver

For more advanced projects, we can use an I2C driver. The SAA1064 is a popular choice, and it supports up to 16 digits.

Building the Circuit

Here is my schematic. We connect pin 1 directly to ground to set the I2C address to 0x70. I use a 2.2 nanofrads capacitor on pin 2 to set the speed for the multiplexing.

Writing the Code

We need code, and code for I2C is a bit more advanced. So let's use a cool SAA1064 library.

When the circuit is done, we can upload the example code, and all digits do the right thing. Now I can display all kinds of things pretty easily on my display without using too much processing power of the Arduino.

Driving 7-Segment Displays with Arduino and ICs

Seven-segment displays are a common way to display numerical information in digital circuits. They consist of seven LED segments that can be individually lit up to form digits from 0 to 9. In this article, we will explore how to drive 7-segment displays using Arduino and ICs.

Hardware Requirements

• Arduino Board (e.g. Arduino Uno)
• 7-Segment Display Module (Common Anode or Common Cathode)
• ICs (Integrated Circuits) such as ULN2003, 74HC595, or CD4026
• Jumper Wires

Software Requirements

• Arduino IDE (Version 1.8.x or later)

Understanding the 7-Segment Display

A 7-segment display consists of seven LED segments, labeled a to g. Each segment can be individually lit up to form digits from 0 to 9.

Using ICs to Drive the 7-Segment Display

ICs such as ULN2003, 74HC595, or CD4026 can be used to drive the 7-segment display. These ICs provide a convenient way to control multiple LEDs with fewer pins.

ULN2003

The ULN2003 is an 8-channel Darlington transistor array that can be used to drive the 7-segment display. Each channel can sink up to 500mA, making it suitable for high-current applications.

74HC595

The 74HC595 is an 8-bit serial-in/parallel-out shift register that can be used to drive the 7-segment display. It provides a convenient way to control multiple LEDs with fewer pins.

CD4026

The CD4026 is a BCD-to-7-segment decoder that can be used to drive the 7-segment display. It provides a convenient way to control multiple LEDs with fewer pins.

Arduino Code

const int digitPins[] = {2, 3, 4, 5};
const int segmentPins[] = {6, 7, 8, 9, 10, 11, 12};

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
  }
  for (int i = 0; i < 7; i++) {
    pinMode(segmentPins[i], OUTPUT);
  }
}

void loop() {
  // Display the digit 5
  displayDigit(5);
  delay(1000);
  
  // Display the digit 3
  displayDigit(3);
  delay(1000);
}

void displayDigit(int digit) {
  for (int i = 0; i < 4; i++) {
    digitalWrite(digitPins[i], LOW);
  }
  switch (digit) {
    case 0:
      // Display the digit 0
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[1], HIGH); // b
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[3], HIGH); // d
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[5], HIGH); // f
      break;
    case 1:
      // Display the digit 1
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[5], HIGH); // f
      break;
    case 2:
      // Display the digit 2
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[3], HIGH); // d
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[6], HIGH); // g
      break;
    case 3:
      // Display the digit 3
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[5], HIGH); // f
      digitalWrite(segmentPins[6], HIGH); // g
      break;
    case 4:
      // Display the digit 4
      digitalWrite(segmentPins[1], HIGH); // b
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[5], HIGH); // f
      digitalWrite(segmentPins[6], HIGH); // g
      break;
    case 5:
      // Display the digit 5
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[6], HIGH); // g
      break;
    case 6:
      // Display the digit 6
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[1], HIGH); // b
      digitalWrite(segmentPins[3], HIGH); // d
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[5], HIGH); // f
      break;
    case 7:
      // Display the digit 7
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[5], HIGH); // f
      break;
    case 8:
      // Display the digit 8
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[1], HIGH); // b
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[3], HIGH); // d
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[5], HIGH); // f
      break;
    case 9:
      // Display the digit 9
      digitalWrite(segmentPins[0], HIGH); // a
      digitalWrite(segmentPins[1], HIGH); // b
      digitalWrite(segmentPins[2], HIGH); // c
      digitalWrite(segmentPins[4], HIGH); // e
      digitalWrite(segmentPins[5], HIGH); // f
      break;
  }
}

• a - Segment A
• b - Segment B
• c - Segment C
• d - Segment D
• e - Segment E
• f - Segment F
• g - Segment G
• dp - Decimal Point

• a - Arduino Digital Pin 2-9
• b - Arduino Digital Pin 3-10
• c - Arduino Digital Pin 4-11
• d - Arduino Digital Pin 5-12
• e - Arduino Digital Pin 6-13
• f - Arduino Digital Pin 7-14
• g - Arduino Digital Pin 8-15
• dp - Not connected or Arduino Digital Pin 9-16 (optional)

• Vcc - Positive Supply Voltage (5V)
• GND - Ground
• SHCP - Shift Register Clock Pulse (Arduino Digital Pin)
• STCP - Storage Register Clock Pulse (Arduino Digital Pin)
• DS - Serial Data Input (Arduino Digital Pin)
• Q0-Q7 - Parallel Output Bits

• Vcc - Arduino 5V Pin
• GND - Arduino GND Pin
• SHCP - Arduino Digital Pin (e.g. Pin 4)
• STCP - Arduino Digital Pin (e.g. Pin 5)
• DS - Arduino Digital Pin (e.g. Pin 6)

• Vcc - Positive Supply Voltage (5V)
• GND - Ground
• IN1-IN7 - Input Bits
• OUT1-OUT7 - Output Bits

• Vcc - Arduino 5V Pin
• GND - Arduino GND Pin
• IN1-IN7 - 74HC595 Q0-Q7 Output Bits

        +-----------+       +-----------+
        |           |       |           |
        |  Arduino  |       | 74HC595  |
        |           |       |           |
        +-----------+       +-----------+
             |                       |
             |  (digital pins)    (serial data)
             |                       |
             v                       v
        +-----------+       +-----------+
        |           |       |           |
        | ULN2003A |       | 7-Segment  |
        |           |       | Display   |
        +-----------+       +-----------+
      

// Define shift register pins
const int shcp = 4;  // SHCP pin
const int stcp = 5;  // STCP pin
const int ds = 6;   // DS pin

void setup() {
  pinMode(shcp, OUTPUT);
  pinMode(stcp, OUTPUT);
  pinMode(ds, OUTPUT);

  // Initialize shift register
  digitalWrite(shcp, LOW);
  digitalWrite(stcp, LOW);
}

void loop() {
  // Example: Display '1' on the first digit
  byte data = B00000110; // Binary representation of '1'

  // Shift out data to the shift register
  shiftOut(ds, shcp, MSBFIRST, data);

  // Latch data into the output registers
  digitalWrite(stcp, HIGH);
  delayMicroseconds(10); // Ensure sufficient pulse width
  digitalWrite(stcp, LOW);

  delay(1000); // Wait for 1 second
}