Published January 24, 2026 © GPL3+

HT16K33 4-Digit 16-Segment Display with Custom PCB

A custom-designed HT16K33-based 4-digit 16-segment display with I2C control, animations, and reusable firmware for embedded projects.

BeginnerProtip4 hours626

HT16K33 4-Digit 16-Segment Display with Custom PCB

Things used in this project

Hardware components

HT16K33 LED Driver (I2C)

16-Segment LED Display

Custom PCB (HT16K33 Display Board)

Pin Headers / Connectors

220R Resistors

Software apps and online services

Arduino IDE

Adafruit_LEDBackpack Library

Adafruit_GFX Library

Wire (I2C) Library

Arduino NANO ESP32

KiCad

Hand tools and fabrication machines

Soldering Iron

Multimeter

Flux and Solder Wire

USB Cable

Story

Project Overview

This project is an Arduino-based 4-digit counter built around the HT16K33 I2C LED driver and a custom 4-digit 16-segment display PCB.The main goal was to create a fully controllable, reusable display module that goes beyond standard 7-segment limitations and allows custom segment mapping and animations.

Unlike typical font-based display libraries, this project uses raw segment control, making it ideal for custom PCB layouts and advanced visual effects.

Why I Built This Project

Most ready-made 16-segment displays rely on predefined fonts, which become restrictive when:

Using a custom PCB

Working with non-standard segment wiring

Creating animations or segment-level effects

I wanted a solution where every segment is directly addressable, so the same hardware can be reused in:

Counters

Clocks

Menus

Animated indicators

This project serves as a clean and extensible base for those use cases.

How It Works

At the core of the design is the HT16K33, an I2C LED driver that handles:

Segment multiplexing

LED current control

Display refreshing

The microcontroller communicates with the HT16K33 over I2C, sending 16-bit raw segment data for each digit using writeDigitRaw().

Key Concepts:

Each segment (A–S) is mapped manually using bit definitions

Digits (0–9) are defined as bitmasks in a lookup table

A simple counter increments from 0000 to 9999

The structure is ready for state machines and animations

Hardware Design

Custom-designed PCB for a 4-digit 16-segment display

Optimized segment routing for clean animation effects

HT16K33 configured at I2C address 0x70

Schematics and PCB files are included to allow easy replication or modification.

Custom HT16K33 4-Digit 16-Segment Display PCB Design

Live PCB

Firmware

The firmware is written in Arduino C++ and focuses on:

Readability

Modularity

Easy expansion for animations

No blocking display logic is used, making it suitable for real-time embedded applications.

Video Demonstration

The full build process, PCB design, wiring, and live animation demos are shown in the video below.

Conclusion

This project demonstrates how the HT16K33 can be used far beyond simple alphanumeric displays.By controlling segments directly, it becomes possible to build custom displays with rich animations while keeping the hardware simple and reliable.

This code and hardware can be used as a foundation for more advanced display-driven projects.

Code

/*
  TeknoTrek YouTube Channel
   Electronics  Arduino  PCB Design  LED Animations  Embedded Systems

  For more projects and short tutorials:

   YouTube: https://www.youtube.com/@TeknoTrek

   Subscribe to support the channel and stay updated!
*/



#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>

Adafruit_AlphaNum4 display;

/* ===================== */
/* SEGMENT TANIMLARI     */
/* ===================== */
#define SEG_A  (1 << 0)
#define SEG_B  (1 << 1)
#define SEG_C  (1 << 2)
#define SEG_D  (1 << 3)
#define SEG_E  (1 << 4)
#define SEG_F  (1 << 5)
#define SEG_G  (1 << 6)
#define SEG_H  (1 << 7)
#define SEG_K  (1 << 8)
#define SEG_L  (1 << 9)
#define SEG_M  (1 << 10)
#define SEG_N  (1 << 11)
#define SEG_O  (1 << 12)
#define SEG_P  (1 << 13)
#define SEG_S  (1 << 15)

/* ===================== */
/* HARF TANIMLARI        */
/* ===================== */
uint16_t CHAR_T = SEG_A | SEG_B | SEG_L | SEG_O;
uint16_t CHAR_E = SEG_A | SEG_B | SEG_H | SEG_G | SEG_S | SEG_E | SEG_F;
uint16_t CHAR_K = SEG_H | SEG_G | SEG_S | SEG_M | SEG_P;
uint16_t CHAR_N = SEG_H | SEG_G | SEG_K | SEG_P | SEG_D | SEG_C;
uint16_t CHAR_O = SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_H;
uint16_t CHAR_R = SEG_A | SEG_B | SEG_C | SEG_N | SEG_S | SEG_H | SEG_G | SEG_P;
uint16_t CHAR_SPACE = 0;

/* ===================== */
/* KAYAN METN           */
/* ===================== */
uint16_t text[] = {
  CHAR_T, CHAR_E, CHAR_K, CHAR_N, CHAR_O,
  CHAR_T, CHAR_R, CHAR_E, CHAR_K,
  CHAR_SPACE, CHAR_SPACE, CHAR_SPACE, CHAR_SPACE
};
#define TEXT_LEN (sizeof(text) / sizeof(text[0]))

/* ===================== */
/* STATE TANIMLARI       */
/* ===================== */
enum AnimationState {
  STATE_WAVE,
  STATE_MATRIX,
  STATE_FILL,
  STATE_PULSE,
  STATE_SCROLL   //  EN SON
};

AnimationState currentState = STATE_WAVE;
unsigned long stateStartTime = 0;
const unsigned long STATE_DURATION = 4000;

/* ===================== */
/* SETUP                 */
/* ===================== */
void setup() {
  Wire.begin();
  display.begin(0x70);
  display.clear();
  display.writeDisplay();
  randomSeed(analogRead(A0));
  stateStartTime = millis();
}

/* ===================== */
/* STATE GE          */
/* ===================== */
void nextState() {
  currentState = (AnimationState)((currentState + 1) % 5);
  stateStartTime = millis();
  display.clear();
}

/* ===================== */
/* LOOP                  */
/* ===================== */
void loop() {
  if (millis() - stateStartTime > STATE_DURATION) {
    nextState();
  }

  switch (currentState) {
    case STATE_WAVE:   animWave();   break;
    case STATE_MATRIX: animMatrix(); break;
    case STATE_FILL:   animFill();   break;
    case STATE_PULSE:  animPulse();  break;
    case STATE_SCROLL: scrollText(); break;
  }
}

/* ===================== */
/* ANMASYONLAR          */
/* ===================== */

//  Wave
void animWave() {
  static uint8_t d = 0, b = 0;
  display.clear();
  display.writeDigitRaw(d, (1 << b));
  display.writeDisplay();

  b++;
  if (b >= 16) { b = 0; d = (d + 1) % 4; }
  delay(30);
}

//  Matrix
void animMatrix() {
  display.clear();
  for (int d = 0; d < 4; d++) {
    display.writeDigitRaw(d, random(0x0000, 0xFFFF));
  }
  display.writeDisplay();
  delay(80);
}

//  Dolma
void animFill() {
  static uint16_t frame = 0;
  frame = (frame << 1) | 1;
  if (frame == 0xFFFF) frame = 0;

  for (int d = 0; d < 4; d++) {
    display.writeDigitRaw(d, frame);
  }
  display.writeDisplay();
  delay(120);
}

//  Pulse
void animPulse() {
  static bool on = false;
  on = !on;

  for (int d = 0; d < 4; d++) {
    display.writeDigitRaw(d, on ? 0xFFFF : 0x0000);
  }
  display.writeDisplay();
  delay(200);
}

//  Kayan "teknoTrek" (SON ANMASYON)
void scrollText() {
  static int pos = 0;

  display.clear();
  display.writeDigitRaw(0, text[pos]);
  display.writeDigitRaw(1, text[pos + 1]);
  display.writeDigitRaw(2, text[pos + 2]);
  display.writeDigitRaw(3, text[pos + 3]);
  display.writeDisplay();

  pos++;
  if (pos > TEXT_LEN - 4) pos = 0;
  delay(300);
}

/*
  TeknoTrek YouTube Channel
   Electronics  Arduino  PCB Design  LED Animations  Embedded Systems

  For more projects and short tutorials:
   YouTube: https://www.youtube.com/@TeknoTrek

   Subscribe to support the channel and stay updated!
*/


#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>

Adafruit_AlphaNum4 display;

/******** SEGMENT TANIMLARI ********/
#define SEG_A (1 << 0)
#define SEG_B (1 << 1)
#define SEG_C (1 << 2)
#define SEG_D (1 << 3)
#define SEG_E (1 << 4)
#define SEG_F (1 << 5)
#define SEG_G (1 << 6)
#define SEG_H (1 << 7)
#define SEG_K (1 << 8)
#define SEG_L (1 << 9)
#define SEG_M (1 << 10)
#define SEG_N (1 << 11)
#define SEG_O (1 << 12)
#define SEG_P (1 << 13)
#define SEG_R (1 << 14)
#define SEG_S (1 << 15)

/******** HALKA TANIMLARI ********/
uint16_t innerRing[] = {
  SEG_K, SEG_L, SEG_M, SEG_N,
  SEG_P, SEG_O, SEG_R, SEG_S
};

uint16_t outerRing[] = {
  SEG_A, SEG_B, SEG_C, SEG_D,
  SEG_E, SEG_F, SEG_G, SEG_H
};

#define INNER_LEN 8
#define OUTER_LEN 8

/******** ZAMANLAMALAR ********/
#define STEP_TIME   140
#define DIGIT_WAVE  180
#define HOLD_TIME   500
#define CLEAR_TIME  300

/******** STATE MACHINE ********/
enum State {
  FLOWER_INNER,
  FLOWER_OUTER,
  HOLD_FULL,
  CLEAR_ALL
};

State currentState = FLOWER_INNER;

uint32_t lastTick = 0;
int digitIndex = 0;
int stepIndex  = 0;

uint16_t digitState[4] = {0, 0, 0, 0};

void setup() {
  Wire.begin();
  display.begin(0x70);
  display.clear();
  display.writeDisplay();
}

void loop() {
  uint32_t now = millis();

  switch (currentState) {

    /********   HALKA ********/
    case FLOWER_INNER:
      if (now - lastTick >= STEP_TIME) {
        lastTick = now;

        if (stepIndex < INNER_LEN) {
          digitState[digitIndex] |= innerRing[stepIndex];
          display.writeDigitRaw(digitIndex, digitState[digitIndex]);
          display.writeDisplay();
          stepIndex++;
        } else {
          stepIndex = 0;
          digitIndex++;
          if (digitIndex >= 4) {
            digitIndex = 0;
            currentState = FLOWER_OUTER;
          }
          lastTick += DIGIT_WAVE;
        }
      }
      break;

    /********  DI HALKA ********/
    case FLOWER_OUTER:
      if (now - lastTick >= STEP_TIME) {
        lastTick = now;

        if (stepIndex < OUTER_LEN) {
          digitState[digitIndex] |= outerRing[stepIndex];
          display.writeDigitRaw(digitIndex, digitState[digitIndex]);
          display.writeDisplay();
          stepIndex++;
        } else {
          stepIndex = 0;
          digitIndex++;
          if (digitIndex >= 4) {
            digitIndex = 0;
            currentState = HOLD_FULL;
            lastTick = now;
          }
          lastTick += DIGIT_WAVE;
        }
      }
      break;

    /********  TAM DOLU BEKLE ********/
    case HOLD_FULL:
      if (now - lastTick >= HOLD_TIME) {
        currentState = CLEAR_ALL;
        lastTick = now;
      }
      break;

    /********  TEMZLE ********/
    case CLEAR_ALL:
      if (now - lastTick >= CLEAR_TIME) {
        for (int i = 0; i < 4; i++) digitState[i] = 0;
        display.clear();
        display.writeDisplay();
        currentState = FLOWER_INNER;
        digitIndex = 0;
        stepIndex = 0;
        lastTick = now;
      }
      break;
  }
}

/*
  TeknoTrek YouTube Channel
   Electronics  Arduino  PCB Design  LED Animations  Embedded Systems

  For more projects and short tutorials:
   YouTube: https://www.youtube.com/@TeknoTrek

   Subscribe to support the channel and stay updated!
*/


#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>

Adafruit_AlphaNum4 display;

/* ================= SEGMENT TANIMLARI ================= */
#define SEG_A (1 << 0)
#define SEG_B (1 << 1)
#define SEG_C (1 << 2)
#define SEG_D (1 << 3)
#define SEG_E (1 << 4)
#define SEG_F (1 << 5)
#define SEG_G (1 << 6)
#define SEG_H (1 << 7)
#define SEG_K (1 << 8)
#define SEG_L (1 << 9)
#define SEG_M (1 << 10)
#define SEG_N (1 << 11)
#define SEG_O (1 << 12)
#define SEG_P (1 << 13)
#define SEG_R (1 << 14)
#define SEG_S (1 << 15)

/* ================= RAKAMLAR =================
   3 rakam dzeltilmitir (G OFF, E ON)
*/
uint16_t digits[10] = {
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_H,        // 0
  SEG_C | SEG_D,                                                        // 1
  SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G | SEG_N | SEG_S,        // 2
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_N | SEG_S,        // 3
  SEG_C | SEG_D | SEG_H | SEG_N | SEG_S,                                // 4
  SEG_A | SEG_B | SEG_D | SEG_E | SEG_F | SEG_H | SEG_N | SEG_S,        // 5
  SEG_A | SEG_B | SEG_D | SEG_E | SEG_F | SEG_G | SEG_H | SEG_N | SEG_S,// 6
  SEG_A | SEG_B | SEG_M | SEG_O,                                        // 7
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_H |
  SEG_N | SEG_S,                                                        // 8
  SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_H |
  SEG_N | SEG_S                                                         // 9
};

void setup() {
  Wire.begin();
  display.begin(0x70);
  display.clear();
  display.writeDisplay();
}

void loop() {
  static uint16_t count = 0;

  display.clear();

  uint8_t d0 = (count / 1000) % 10;
  uint8_t d1 = (count / 100)  % 10;
  uint8_t d2 = (count / 10)   % 10;
  uint8_t d3 = count % 10;

  bool started = false;

  if (d0 != 0) {
    display.writeDigitRaw(0, digits[d0]);
    started = true;
  }

  if (started || d1 != 0) {
    display.writeDigitRaw(1, digits[d1]);
    started = true;
  }

  if (started || d2 != 0) {
    display.writeDigitRaw(2, digits[d2]);
    started = true;
  }

  // Son digit her zaman yazlr
  display.writeDigitRaw(3, digits[d3]);

  display.writeDisplay();

  count++;
  if (count > 9999) count = 0;

  delay(100);
}

Credits

TeknoTrek

1 project • 0 followers

YouTube electronics creator sharing DIY circuits, PCB designs, Arduino projects, and hands-on engineering tutorials.