Edge-Lit Seven Segment Display

Now apply solder to the 5V and GND pads you just cleared on the *BACK* side of the LED strip, strip and tin the tips of the 26 AWG wires, then solder them to the power pads. Carefully bend the wires upwards to a 90 degree angle just past the solder join.

Since both power wires are white, mark the ends with a sharpie so that you will be able to tell them apart later.

It’s a good idea to test the connections now before placing the wire inside the display frame. Make sure all the LEDs light up and there are no shorts. The next step is to assemble the acrylic pieces and LED strips for the digits in the display. We’ll repeat the same process for each pair of digits.

Step 6: Embed the LED Strip and Segments for the Digits in the Acrylic Frame

Now we’ll start adding the LED strip and acrylic segment pieces into the frame. We’ll start from the middle of the strip and work outwards with each half of the strip following the path shown below:

Take the 28 pixel LED strp and slot it into the frame as shown so that the power wires fit into the slot hanging down between the digits, and there are 14 LEDs available for each digit. The input end of the LED strip, which contains the signal wire, should go inside the rightmost (from our current view) of the two digits. We will attach this LED strip around the perimeter of each seven segment display. Peel the paper away from the middle of the strip as you go, but only stick a small portion of the strip at a time, because you will probably have to remove and re-seat portions of it periodically to make sure the segment pieces fit properly.

Assemble one digit at a time, starting with the rightmost of the two digits (the one containing the signal input wire). Each of the seven small segments in the digit corresponds to two LEDs on the strip. Alternate sticking down two pixels of the LED strip, then adding one segment. Place all of the small segments with the etched side facing upwards. Edge lighting effects look much better if any etching is on the back side of the illuminated acrylic. If you’re not sure which side is etched, scratch both sides with a fingernail, and you should be able to feel the grooves on the etched side.

Place the segments into the frame as you go. It is important that everything fits snugly, so each time you stick down part of the acrylic strip, press the segment into place on top of the strip, and make sure the segments fit well into the perimeter of the digit. A small tweezers is helpful if you need to lift off and re-seat the LED strip.

The display is coded as a clock, but there is a lot of additional potential additional functionality. It could be a countdown timer, a temperature display, a social media follower count display, or basically a display of any metric that can be represented in numbers.

Disclaimer: the code provided below is somewhat hacky and not incredibly well documented. It works, but could be significantly improved. I hope to find time to improve and update it, but for now, I’m putting out what I have, because I’m not sure when I’ll be able to improve it.

Edge Lit Seven Segment Display Code Files

1 file(s) 2.96 KB

Download

I programmed the Lolin D1 Mini Pro with the Arduino IDE.  The code, shown below, connects to the internet, and uses the “NTPClient” library (available through the Arduino library manager) to obtain the correct time. The NTPClient object reads the time from the NTP server every 10 minutes. It formats and sends a time string over the serial port every 10 seconds. 

#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>


/* OTA Time Access via WiFi */
const char* ssid      = "YOUR SSID HERE";
const char* password  = "YOUR PASSWORD HERE";

char timeString[8];
// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);
/* End OTA Time Access via WiFi */

void setup() {
  Serial.begin(57600);

  // Initialize WiFi Connection
  //  Serial.print("Connecting to ");
  //  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(200);
//    Serial.print(".");
  }
  delay(200);
  // Print local IP address and start web server
  //  Serial.println("");
  //  Serial.println("WiFi connected.");
  //  Serial.println("IP address: ");
  //  Serial.println(WiFi.localIP());
  //  IPAddress ip = WiFi.localIP();


// Initialize a NTPClient to get time
  timeClient.begin();
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 0
  timeClient.setTimeOffset(-25200);  // GMT-7
  timeClient.setUpdateInterval(600*1000);  // in Milliseconds. We update every 10 min

}

void printTimeSerial() {
    sprintf(timeString, "%02d:%02d:%02d", timeClient.getHours(), timeClient.getMinutes(), timeClient.getSeconds());
    Serial.println(timeString);
}

boolean sendTime = true;
int lastSec;
void loop() {
  // Send time every 10 seconds when transitioning from seconds = 4 to seconds = 5
  timeClient.update();
  int sec = timeClient.getSeconds() % 10;
  if (sec == 5 and lastSec == 4) {
    printTimeSerial();
  }
  lastSec = sec;
}

Due to the way the LED strip is laid out, the order of the LEDs in the adjacent digits in each pair is different. The first LEDs in the strip illuminate the left (higher place value) digit, and the second half of the strip illuminates the right (lower place value) digit. The code takes this into account with an offset of 14 pixels for the rightmost digit. Each pair of digits is coded the same way, so code-wise you could easily extend this display to 8, 10 or any even number of digits. 

The Circuit Python code running on the Itsy Bitsy polls the serial port to read the time strings sent from the ESP8266. It sets a new base time with every new time string it receives, then tracks the current time using the monotonic() function from the time library.

The code uses the adafruit_fancyled library to chose colors in HSV format and apply gamma correction before they are displayed. The color of the numbers evolves over a 60-second cycle that restarts at the top of every minute.

The indices of the segments required to display any given number on the LEDs are stored as bits in the array digitSegments, and unpacked in the function drawStripDigit.