Published May 2, 2016 © CC BY-NC-SA

HUB75 LED Display Driver

This is custom 5x5cm Arduino UNO board that allows simple connection to HUB75 interface LED displays.

BeginnerFull instructions provided2 hours26,982

Things used in this project

Hardware components

ATmega328 with Arduino Optiboot (Uno)

Resistor 10k ohm

Capacitor 22 pF

Capacitor 100 nF

16 MHz Crystal

Capacitor 470 µF

DC Barrel Power Jack/Connector

Two pins screw terminal block 3.5mm pitch

SparkFun Pushbutton switch 12mm

DIP Socket, 28 Contacts

Generic Jumper (0.1")

Male Header 40 Position 1 Row (0.1")

Resistor 330 ohm

RUEF250U FUSE

Ribbon Cable Connector 2x8

Hand tools and fabrication machines

Soldering iron (generic)

Story

This is custom 5x5cm Arduino UNO board that allows simple connection to HUB75 interface LED displays.If you are not familiar with such displays you can buy one from Adafruit 16X32 RGB LED MATRIX PANEL, or from Aliexpress

HUB75 interface LED displays usually comes with flat cable for data and power cable. So after you soldered this PCB all you need to do is to connect power cable to screw terminal. and plug flat cable to PCB and LED display.

Pinout compatible with Adafruit "RGB matrix Panel" library, but I wanted to understand how HUB75 interface works. So I wrote my own library.

Five free pins can be used to connect sensors or other devices. See examples below.

Gerber files for Seeedstudio Fusion PCB service attached. It will cost you 10$ to produce 10 of this PCB.Also Eagle schematic and board layout files attached.

Schematic

Parts list

You will need flowing parts:

ATmega328 with Arduino Optiboot (Uno)
Resistor 10k
Capacitor 2pF x2
Capacitor 100nF x5
Crystal 16MHz
Capacitor 470uF x2
DC Barrel Power Jack/Connector likethis
Two pins screw terminal block 3.5mm pitch likethis
Switch likethisoptional if you want reset button.
DIP Socket, 28 Contacts optional
Two jumpers
Break Away Headers 18 pins likethis
Resistor 330 Ohm x5 (optional)
RUEF250U FUSE(optional)
Ribbon Cable Connector 2x8 likethisprobably you also can use one likethisYou can also solder two rows of headers. It works fine also.

RUEF250U is 3A fuse. It is optional. You can simply short it connections with wire if you don't want it.Resistors 300 Ohm also optional. You can solder header before resistors as you can see on photo.

The Board

1 / 2 • The board

As you can see it is no USB interface on board, so you will need some USB to serial cable to upload sketches. I am using SparkFun FTDI Basic Breakout - 5V

FTDI connector

Using jumpers board can be configured for panels with 3 bits of row address (A,B,C) usually 16x32 or for panels with four bits of address (A,B,C,D) usually 32x32 panels or larger.

For panels with 3 bits of row address you need to short NOD1,NOD2 jumper as you can see on picture.

For panels with 4 bits of row address you need to remove jumpers from NOD1,NOD2 and put them on USED1,USED2 headers.

It is no voltage regulator on board. Please use good 5V power supply. For 16x32 panel you will need about 2A power supply. For 32x32 panel you will need about 3A power supply.

Connect 5V power supply only to Barrel Power Connector. The connector in lower left corner is for connected external devices as RTC, sensors etc. Traces on board for this connector too narrow for 2A needed to power LED matrix!

HUB75 Interface

1 / 3

HUB75 interface used for lot of LED displays. It is couple of links below if you want to learn about it.It is slight differences between panels, but for panels used by Adafruit and many others basically you need is to do flowing to operate the display:

Clock in data for entire row (use R1,G1,B1,R2,G2,B2 for data and CLK for clock)
OE high
Select line address (A,B,C,D)
LAT high
LAT low
OE low

Repeat for each line

My Library

As I wrote before, this board will work just fine with Adafruit "RGB matrix Panel" library. But it was interesting to write my own. So I did. You can download latest version from GitHub HUB75driver or you can download attached HUB75driver.zip zip file.

This library will work with normal Arduino Uno as well.

HUB75driver library parameters

Refresh rate 125FPS

12bits of clolors, 4 bits per color (RGB)

3500 bytes of program memory

RAM: 40 bytes + 768 bytes if no double buffering and 1536 bytes if double buffering used

It takes 7ms to fill all matrix using draw_point() function (512 times)

Usage examples

Following couple of examples of what you can do with this board and 16x32 panel

Clock example is clock.zip, it is uses connected via I2C DS1307 breakout board as RTC

Clock

Scrolling text example is scrolltext.zip

Temperature display temperature.zip using Adafruit libraries and DS18B20 sensor.

Temperature display

References

Inline assembler

http://www.nongnu.org/avr-libc/user-manual/inline_asm.html

http://www.codeproject.com/Articles/15971/Using-Inline-Assembly-in-C-C

https://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html

http://asm.sourceforge.net/articles/rmiyagi-inline-asm.txt

http://www.atmel.com/webdoc/AVRLibcReferenceManual/inline_asm_1io_ops.html

HUB75 interface

https://learn.adafruit.com/32x16-32x32-rgb-led-matrix/how-the-matrix-works

https://github.com/hzeller/rpi-rgb-led-matrix

https://esdblog.org/how-to-drive-4096-rgb-leds-each-24bit-rgb-brightness-with-one-stm32-microcontroller-without-much-cpu-load/

Schematics

Code

// Library to drive HUB75 interface 32x16 LED matrix using Arduino Uno
// RGBmatrixPanel Arduino library for Adafruit 
// Written by Limor Fried/Ladyada & Phil Burgess/PaintYourDragon for
// Adafruit Industries used as example, and couple of lines of code taken from it
// Pins usaga compatible with Adafruit RGBmatrixPanel Arduino library
// https://learn.adafruit.com/32x16-32x32-rgb-led-matrix/
// Pins mapping for HUB75 interface A A0,B A1,C A2,R1 2,R2 5,B1 4,B2 7,G1 3,G2 6,LAT A3,CLK 8,OE 9

#include "HUB75driver.h"

static HUB75driver *activePanel = NULL;

HUB75driver::HUB75driver()
{
	
}

uint8_t HUB75driver::init(boolean dbuf,boolean extra_dim)
{
	/*Initialisation of matrix
	if dbuf=true double buffering used
	extra_dim alows additional dimming. brightness will reduce by half
	in this case swapBuffers() function need to be called to update picture
	Pin mapping:
	A A0,B A1,C A2,R1 2,R2 5,B1 4,B2 7,G1 3,G2 6,LAT A3,CLK 8,OE 9
	*/

	use_dbuf = dbuf;
	swap_needed = 0;
	cp_back_to_front = 0;
	half_brightness = extra_dim;
	activePanel = this; // For interrupt hander

	DDRD = DDRD | B11111100;//sets pins 2 to 7 as outputs without changing the value of pins 0 & 1, which are RX & TX
	DDRC = DDRC | B00001111;//Set pins A0,A1,A2,A3 as output
	DDRB = DDRB | B00000011;//Set pins 8,9 as output
	PORTD = PORTD & B00000011;//Zero to outputs 2 to 7
	PORTC = PORTC & B11111000;//Zero to A0,A1,A2
	PORTB = (PORTB & B11111110) | B00000010;//* - CLK low,9 OE high

	// Allocate and initialize matrix buffer:
	buffsize = 32 * 8 * 3; // x3 = 3 bytes holds 4 planes "packed"
	matrixbuff[0] = (uint8_t *)calloc(buffsize, sizeof(uint8_t));//allocate for single buffer
	if (matrixbuff[0] == NULL) return 1;
	if (dbuf) {//If double buffering used
		matrixbuff[1] = (uint8_t *)calloc(buffsize, sizeof(uint8_t));//Alocate for second buffer
		if (matrixbuff[1] == NULL) return 1;
		display_buffer_index = 0;
		draw_buffer_index = 1;
	}
	else {
		display_buffer_index = 0;
		draw_buffer_index = 0;
	}
	
	
	return 0;
}

ISR(TIMER1_COMPA_vect) {
	activePanel->drive();//Matrix refrshing function
}

void HUB75driver::drive()
{
	/*
	This function refreshing matix
	Using 4 bits per color,3 bytes packed like this:
	3 byte per 2 pixels
	32*3 bytes per line
	First 32 bytes bits 7 to 2 is bit 0 in format B2,G2,R2,B1,G1,R1,x,x
	Second 32 bytes bit 1
	Third 32 bytes bit 2
	Bit4 packed in lass two bits of each byte 
	Binary Code Modulation used as it faster then PWM
	Function execution time 24us for bits 0,1,2 and 65us for bit 4
	*/

	//*** Debug ***
	//long int time_start = micros();
	//*****
	

	uint16_t  addr_pre;
	uint8_t  *ptr,*ptr1,*ptr2;
	img = matrixbuff[display_buffer_index];
	boolean latch_needed = false;

	switch (pwm_count)
	{
	case 0:
	case 1:
	case 3:
		//For bits 0,1,2
		//Calculate starting address for relevant bit
		if (pwm_count == 0) addr_pre = line * 96;
		else if (pwm_count == 1) addr_pre = line * 96 + 32;
		else addr_pre = line * 96 + 64;
		//Pointer to start of buffer
		buffptr = &img[addr_pre];
		ptr = (uint8_t *)buffptr;
		//Clock in data for 32 columns
		//~12us for 32 data shift commands
		//x4 pixels can be driven if 64us period will be selected
		{
			__asm__ (
				pew pew pew pew pew pew pew pew
				pew pew pew pew pew pew pew pew
				pew pew pew pew pew pew pew pew
				pew pew pew pew pew pew pew pew
				::[ptr]  "e" (ptr),
				[data] "I" (_SFR_IO_ADDR(PORTD))
				: "r0", "memory"
				);
		}//asm
		latch_needed = true;
		break;
	case 7:
		//For bit 3
		//Calculate starting address for relevant bit
		addr_pre = line * 96;
		//Pointers to start of buffer
		buffptr = &img[addr_pre];
		ptr = (uint8_t *)buffptr;
		buffptr = &img[addr_pre + 32];
		ptr1 = (uint8_t *)buffptr;
		buffptr = &img[addr_pre + 64];
		ptr2 = (uint8_t *)buffptr;
		//Clock in data for 32 columns
		//~52us for 32 data shift commands
		{
			__asm__ (
				pew1 pew1 pew1 pew1 pew1 pew1 pew1 pew1
				pew1 pew1 pew1 pew1 pew1 pew1 pew1 pew1
				pew1 pew1 pew1 pew1 pew1 pew1 pew1 pew1
				pew1 pew1 pew1 pew1 pew1 pew1 pew1 pew1
				::[ptr]  "e" (ptr), [ptr1]  "e" (ptr1), [ptr2]  "e" (ptr2),
				[data] "I" (_SFR_IO_ADDR(PORTD))
				: "r1","r0", "memory"
				);
		}//asm
		latch_needed = true;
		break;
	case 16:
		if (half_brightness) {
			{
				__asm__ (
					"CLR __tmp_reg__ \n\t"
					pew2 pew2 pew2 pew2 pew2 pew2 pew2 pew2
					pew2 pew2 pew2 pew2 pew2 pew2 pew2 pew2
					pew2 pew2 pew2 pew2 pew2 pew2 pew2 pew2
					pew2 pew2 pew2 pew2 pew2 pew2 pew2 pew2
					::[data] "I" (_SFR_IO_ADDR(PORTD))
					:"r0", "memory"
					);
			}//asm
		}//if
		latch_needed = true;
		break;
	default:
		break;
	}
	

	if (latch_needed) {
		//Display clocked in data
		PORTB |= B00000010; //OE high
		PORTC = (PORTC & B11111000) + line; //Select line
		__asm__  (
			"SBI %[portc] , 3\n\t" //LAT high PORTC
			"CBI %[portc] , 3\n\t" //LAT low
			"CBI %[portb] , 1\n\t" //OE low
			::[portc] "I" (_SFR_IO_ADDR(PORTC)), [portb] "I" (_SFR_IO_ADDR(PORTB))
			);
	}//if
	
	//Counters for lines and Binary Code Modulation
	
	if (pwm_count < pwm_count_max) {//15 levels per bit
		pwm_count++;
	}
	else {
		pwm_count = 0;
		if (line < 7) line++;//Line counter 0-7
		else {
			line = 0;
			if (swap_needed==1) {//If double buffering mode
				
				if (display_buffer_index == 0) {
					display_buffer_index = 1;
					draw_buffer_index = 0;
				}
				else {
					display_buffer_index = 0;
					draw_buffer_index = 1;
				}
				if (cp_back_to_front) memcpy(matrixbuff[draw_buffer_index], matrixbuff[display_buffer_index], buffsize);
				swap_needed = 0;
			}
		}
	}
	
	//*** Debug ***
	//long elapsed = micros() - time_start;
	//Serial.println(elapsed);
	//********************
}


void HUB75driver::draw_point(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b)
{
	/*Function to draw point on matrix
	Coordinates starts from 0,0
	Using 4 bits per color,3 bytes packed like this
	3 byte per 2 pixels
	32*3 bytes per line
	First 32 bytes is bit 0 in format B2,G2,R2,B1,G1,R1,x,x
	Second 32 bytes bit 1
	Third 32 bytes bit 2
	Bit4 packed in lass two bits of each byte
	First byte B2G2
	Second R2B1
	THird G1R1
	*/

	if (x < 0 || x>31 || y < 0 || y>15) return;

	uint16_t addr_0, addr_1, addr_2;
	uint16_t base = (y%8) * 96;//32*3=96
	addr_0 = base + x;
	addr_1 = addr_0 + 32;
	addr_2 = addr_0 + 64;
	uint8_t  *ptr, *ptr1, *ptr2,*img_ptr;
	img_ptr = matrixbuff[draw_buffer_index];
	
	buffptr = &img_ptr[addr_0];
	ptr = (uint8_t *)buffptr;
	buffptr = &img_ptr[addr_1];
	ptr1 = (uint8_t *)buffptr;
	buffptr = &img_ptr[addr_2];
	ptr2 = (uint8_t *)buffptr;
	
	if (y < 8) {
		//Set bits 4,3,2 - B1,G1,R1
		//Bit0
		__asm__ (
			copy_bitl
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (0), [ptr] "e" (ptr)
			:"r16", "memory"
			);
		//Bit1
		__asm__ (
			copy_bitl
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (1), [ptr] "e" (ptr1)
			: "r16","memory"
			);
		//Bit2
		__asm__ (
			copy_bitl
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (2), [ptr] "e" (ptr2)
			: "r16", "memory"
			);
		//Bit3
		__asm__ (
			copy_bitl3
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [ptr1] "e" (ptr1), [ptr2] "e" (ptr2)
			: "r16", "memory"
			);
	}
	else {
		//Set bits 7,6,5 - B2,G2,R2
		//Bit0
		__asm__ (
			copy_bith
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (0), [ptr] "e" (ptr)
			: "r16", "memory"
			);
		//Bit1
		__asm__ (
			copy_bith
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (1), [ptr] "e" (ptr1)
			: "r16", "memory"
			);
		//Bit2
		__asm__ (
			copy_bith
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [bit] "I" (2), [ptr] "e" (ptr2)
			: "r16", "memory"
			);
		//Bit3
		__asm__ (
			copy_bith3
			:
			: [r] "r" (r), [g] "r" (g), [b] "r" (b), [ptr] "e" (ptr), [ptr1] "e" (ptr1)
			: "r16", "memory"
			);
	}
}

void HUB75driver::clear()
{
	//Clear panel
	memset(matrixbuff[draw_buffer_index], 0, buffsize);
}

void HUB75driver::swapBuffers(boolean cp_old)
{
	//If double buffer mode used this function need to be called each time new information 
	//need to be displayed
	//Only flag raised here Actual swap will be synchronised with end of frame
	if (use_dbuf) {
		swap_needed = 1;
		cp_back_to_front = cp_old;
	}
}

void HUB75driver::start()
{
	//Start refreshing Nothing will be displayed before this function called
	//Set timer1
	cli();// disable global interrupts
	TCCR1A = 0;// set entire TCCR1A register to 0
	TCCR1B = 0;// same for TCCR1B
	TCNT1 = 0;//initialize counter value to 0

	TCCR1B |= (1 << CS10); //No prescaller
	TCCR1B |= (1 << WGM12);//CTC mode
	if (half_brightness) {
		OCR1A = 496;//31nsec
		pwm_count_max = 32;
	}
	else {
		OCR1A = 992;//992-62nsec
		pwm_count_max = 16;
	}

	TIMSK1 |= (1 << OCIE1A); // enable timer compare interrupt
	sei();//allow interrupts
}

void HUB75driver::debug() {
	pwm_count_max = 16;
	Serial.print("pwm_count=");
	Serial.println(pwm_count);
	Serial.print("line=");
	Serial.println(line);
}

// HUB75driver.h

#ifndef _HUB75DRIVER_h
#define _HUB75DRIVER_h

#if defined(ARDUINO) && ARDUINO >= 100
	#include "arduino.h"
#else
	#include "WProgram.h"
#endif

#define bit0 B00000001
#define bit1 B00000010
#define bit2 B00000100
#define bit3 B00001000
#define RSTBITSRGB1 B11100011
#define RSTBITSRGB2 B00011111

//Assembly cod for bits 0,1,2
#define pew "ld  __tmp_reg__, %a[ptr]+"    "\n\t"   \
      "out %[data]    , __tmp_reg__" "\n\t"   \
      "SBI 5 , 0"     "\n\t"   \
      "CBI 5 , 0"     "\n\t"

//Assembly cod for bit 3
#define pew1 "ld  __tmp_reg__, %a[ptr]+"    "\n\t"   \
      "bst __tmp_reg__,1 " "\n\t"   \
      "bld r1 , 7 " "\n\t"   \
      "bst __tmp_reg__,0 " "\n\t"   \
      "bld r1,6 " "\n\t"   \
	  "ld  __tmp_reg__, %a[ptr1]+"    "\n\t"   \
	  "bst __tmp_reg__,1 " "\n\t"   \
	  "bld r1,5 " "\n\t"   \
	  "bst __tmp_reg__,0 " "\n\t"   \
	  "bld r1,4 " "\n\t"   \
	  "ld  __tmp_reg__, %a[ptr2]+"    "\n\t"   \
	  "bst __tmp_reg__,1 " "\n\t"   \
	  "bld r1,3 " "\n\t"   \
	  "bst __tmp_reg__,0 " "\n\t"   \
	  "bld r1,2 " "\n\t"   \
      "out %[data]    , r1" "\n\t"   \
      "SBI 5 , 0"     "\n\t"   \
      "CBI 5 , 0"     "\n\t"

#define copy_bitl "ld  r16, %a[ptr]" "\n\t"\
	"bst %[b] , %[bit] " "\n\t"\
	"bld r16 , 4 " "\n\t"\
	"bst %[g] , %[bit] " "\n\t"\
	"bld r16 , 3 " "\n\t"\
	"bst %[r] , %[bit] " "\n\t"\
	"bld r16 , 2 " "\n\t"\
	"st %a[ptr] , r16 \n\t"

#define copy_bith "ld  r16, %a[ptr]" "\n\t"\
	"bst %[b] , %[bit] " "\n\t"\
	"bld r16 , 7 " "\n\t"\
	"bst %[g] , %[bit] " "\n\t"\
	"bld r16 , 6 " "\n\t"\
	"bst %[r] , %[bit] " "\n\t"\
	"bld r16 , 5 " "\n\t"\
	"st %a[ptr] , r16 \n\t"

#define copy_bitl3 \
	"ld  r16, %a[ptr1] \n\t" \
	"bst %[b] , 3   \n\t" \
	"bld r16 , 0  \n\t" \
	"st %a[ptr1] , r16 \n\t" \
	"ld  r16, %a[ptr2]" "\n\t" \
	"bst %[g] , 3  \n\t" \
	"bld r16 , 1  \n\t" \
	"bst %[r] , 3  \n\t" \
	"bld r16 , 0  \n\t" \
	"st %a[ptr2] , r16 \n\t"

#define copy_bith3 \
	"ld  r16, %a[ptr] \n\t" \
	"bst %[b] , 3   \n\t" \
	"bld r16 , 1  \n\t" \
	"bst %[g] , 3  \n\t" \
	"bld r16 , 0  \n\t" \
	"st %a[ptr] , r16 \n\t" \
	"ld  r16, %a[ptr1]" "\n\t" \
	"bst %[r] , 3  \n\t" \
	"bld r16 , 1  \n\t" \
	"st %a[ptr1] , r16 \n\t"

//Assembly code to switch off all pixels
#define pew2 "out %[data]    , __tmp_reg__" "\n\t"   \
      "SBI 5 , 0"     "\n\t"   \
      "CBI 5 , 0"     "\n\t"

//#define push_bit0
class HUB75driver
{
public:
	HUB75driver();
	uint8_t init(boolean dbuf=false, boolean extra_dim=false);
	void drive();
	void draw_point(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b);
	void clear();
	void swapBuffers(boolean cp_old = false);
	void start();
	void debug();

private:
	uint8_t         *matrixbuff[2],pwm_count_max;
	boolean use_dbuf,half_brightness,cp_back_to_front;
	volatile uint8_t pwm_count,line,display_buffer_index,draw_buffer_index,swap_needed;
	int buffsize;
	volatile uint8_t *buffptr, *img;
};

#endif

Credits

Alex Stepanov

4 projects • 22 followers

Analog engineer

HUB75 LED Display Driver

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Schematic

The Board

HUB75 Interface

My Library

References

Custom parts and enclosures

Eagle PCB layout

Gerber files for Seeedstudio Fusion PCB service

Schematics

Eagle schematic

Code

My library to drive 16x32 led matrix zip

Clock example

HUB75driver class

HUB75driver class header file

Scrolling text example

Temperature display example uses Adafruit library

Credits

Alex Stepanov

Comments

Embed the widget on your own site

HUB75 LED Display Driver

HUB75 LED Display Driver

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Schematic

The Board

HUB75 Interface

My Library

References

Custom parts and enclosures

Eagle PCB layout

Gerber files for Seeedstudio Fusion PCB service

Schematics

Eagle schematic

Code

My library to drive 16x32 led matrix zip

Clock example

HUB75driver class

HUB75driver class header file

Scrolling text example

Temperature display example uses Adafruit library

Credits

Alex Stepanov

Comments

Related channels and tags