Dot Matrix & InventOne

October 4, 2018 · 8 min read

Introduction

Hey there! Do you want to get your hands on some cool stuff? Here is a tutorial on how to write virtually any text using the dot matrix. We would be using the InventOne dev board to control a dot matrix displaying conveniently any text we want it to display.

Note that you can cascade any amount of dot matrices together to get a somewhat large screen of display, MAX7219 enables this feature. For more tutorial on the MAX7219 chip check out the datasheet of the microchip and to know how an LED matrix work check out this great tutorial by Dejan Nedelkovski.

List of Components

MAX7219 LED matrix module

Jumper wires

InventOne dev board

NB: You can order for your components from any of these sites hub360, aliexpress, ebay. Please click this link to order for your inventone dev board.

Tutorial

Let’s get down to business, we’ve added a picture of the circuit diagram which we made using fritzing the circuit is pretty easy and all you need to do is connect the legs from the module to inventone. To ease the connection, we’ve added the appropriate pin connection from the dot matrix to inventone in the code. The dot matrix module allows for cascading to do this just connect the output pins from one module to the input of the other ensuring that you connect pins having the same label.

Code

We would be making use of MaxMatrix library provided by Riyas, check out his git repo  to download the zip file of the library if you don’t have it yet. Sparkfun has a tutorial on how to add new libraries to your Arduino IDE. To change the text being displayed by the matrix just scroll down to the text [ ] section, presently you have “Never Give Up Your Dream”  you can change the text to anything you want to be displayed.

Note that we didn’t say much about the code, that’s because you need not bother much about the code if you just want to get your Matrix up and running in no time. But if you are interested in understanding the code proper, you can go through the tutorial which we talked about previously.

/*
VCC - 5v
GND - GND
DIN - IO16
CS - IO13
CLK - IO12

*/

#include <MaxMatrix.h>
#include <pgmspace.h>

PROGMEM const unsigned char CH[] = {
  3, 8, B00000000, B00000000, B00000000, B00000000,          B00000000, // space
  1, 8, B01011111, B00000000, B00000000, B00000000,          B00000000, // !
  3, 8, B00000011, B00000000, B00000011, B00000000,          B00000000, // "
  5, 8, B00010100, B00111110, B00010100, B00111110,          B00010100, // #
  4, 8, B00100100, B01101010, B00101011, B00010010,          B00000000, // $
  5, 8, B01100011, B00010011, B00001000, B01100100,          B01100011, // %
  5, 8, B00110110, B01001001, B01010110, B00100000,          B01010000, // &
  1, 8, B00000011, B00000000, B00000000, B00000000,          B00000000, // '
 3, 8, B00011100, B00100010, B01000001, B00000000,          B00000000, // (
  3, 8, B01000001, B00100010, B00011100, B00000000,          B00000000, // )
  5, 8, B00101000, B00011000, B00001110, B00011000,          B00101000, // *
  5, 8, B00001000, B00001000, B00111110, B00001000,          B00001000, // +
  2, 8, B10110000, B01110000, B00000000, B00000000,           B00000000, // ,
  4, 8, B00001000, B00001000, B00001000, B00001000,          B00000000, // -
  2, 8, B01100000, B01100000, B00000000, B00000000,          B00000000, // .
  4, 8, B01100000, B00011000, B00000110, B00000001,          B00000000, // /
  4, 8, B00111110, B01000001, B01000001, B00111110,          B00000000, // 0
  3, 8, B01000010, B01111111, B01000000, B00000000,          B00000000, // 1
  4, 8, B01100010, B01010001, B01001001, B01000110,          B00000000, // 2
  4, 8, B00100010, B01000001, B01001001, B00110110,          B00000000, // 3
  4, 8, B00011000, B00010100, B00010010, B01111111,          B00000000, // 4
  4, 8, B00100111, B01000101, B01000101, B00111001,          B00000000, // 5
 4, 8, B00111110, B01001001, B01001001, B00110000,   B00000000, // 6
 4, 8, B01100001, B00010001, B00001001, B00000111,          B00000000, // 7
 4, 8, B00110110, B01001001, B01001001, B00110110,          B00000000, // 8
  4, 8, B00000110, B01001001, B01001001, B00111110,          B00000000, // 9
  2, 8, B01010000, B00000000, B00000000, B00000000,           B00000000, // :
  2, 8, B10000000, B01010000, B00000000, B00000000,          B00000000, // ;
  3, 8, B00010000, B00101000, B01000100, B00000000,           B00000000, // <
  3, 8, B00010100, B00010100, B00010100, B00000000,          B00000000, // =
  3, 8, B01000100, B00101000, B00010000, B00000000,          B00000000, // >
  4, 8, B00000010, B01011001, B00001001, B00000110,          B00000000, // ?
  5, 8, B00111110, B01001001, B01010101, B01011101,          B00001110, // @
  4, 8, B01111110, B00010001, B00010001, B01111110,          B00000000, // A
  4, 8, B01111111, B01001001, B01001001, B00110110,          B00000000, // B
  4, 8, B00111110, B01000001, B01000001, B00100010,          B00000000, // C
  4, 8, B01111111, B01000001, B01000001, B00111110,          B00000000, // D
  4, 8, B01111111, B01001001, B01001001, B01000001,          B00000000, // E
  4, 8, B01111111, B00001001, B00001001, B00000001,          B00000000, // F
  4, 8, B00111110, B01000001, B01001001, B01111010,          B00000000, // G
  4, 8, B01111111, B00001000, B00001000, B01111111,          B00000000, // H
  3, 8, B01000001, B01111111, B01000001, B00000000,           B00000000, // I
  4, 8, B00110000, B01000000, B01000001, B00111111,           B00000000, // J
  4, 8, B01111111, B00001000, B00010100, B01100011,          B00000000, // K
  4, 8, B01111111, B01000000, B01000000, B01000000,           B00000000, // L
  5, 8, B01111111, B00000010, B00001100, B00000010,          B01111111, // M
  5, 8, B01111111, B00000100, B00001000, B00010000,           B01111111, // N
  4, 8, B00111110, B01000001, B01000001, B00111110,          B00000000, // O
 4, 8, B01111111, B00001001, B00001001, B00000110,          B00000000, // P
  4, 8, B00111110, B01000001, B01000001, B10111110,          B00000000, // Q
  4, 8, B01111111, B00001001, B00001001, B01110110,          B00000000, // R
  4, 8, B01000110, B01001001, B01001001, B00110010,          B00000000, // S
 5, 8, B00000001, B00000001, B01111111, B00000001,          B00000001, // T
  4, 8, B00111111, B01000000, B01000000, B00111111,          B00000000, // U
  5, 8, B00001111, B00110000, B01000000, B00110000,          B00001111, // V
  5, 8, B00111111, B01000000, B00111000, B01000000,          B00111111, // W
  5, 8, B01100011, B00010100, B00001000, B00010100,          B01100011, // X
  5, 8, B00000111, B00001000, B01110000, B00001000,           B00000111, // Y
  4, 8, B01100001, B01010001, B01001001, B01000111,          B00000000, // Z
 2, 8, B01111111, B01000001, B00000000, B00000000,          B00000000, // [
  4, 8, B00000001, B00000110, B00011000, B01100000,          B00000000, // \ backslash
  2, 8, B01000001, B01111111, B00000000, B00000000,          B00000000, // ]
  3, 8, B00000010, B00000001, B00000010, B00000000,           B00000000, // hat
  4, 8, B01000000, B01000000, B01000000, B01000000,          B00000000, // _
  2, 8, B00000001, B00000010, B00000000, B00000000,          B00000000, // `
  4, 8, B00100000, B01010100, B01010100, B01111000,          B00000000, // a
  4, 8, B01111111, B01000100, B01000100, B00111000,          B00000000, // b
  4, 8, B00111000, B01000100, B01000100, B00101000,          B00000000, // c
  4, 8, B00111000, B01000100, B01000100, B01111111,           B00000000, // d
  4, 8, B00111000, B01010100, B01010100, B00011000,           B00000000, // e
  3, 8, B00000100, B01111110, B00000101, B00000000,           B00000000, // f
  4, 8, B10011000, B10100100, B10100100, B01111000,          B00000000, // g
  4, 8, B01111111, B00000100, B00000100, B01111000,           B00000000, // h
  3, 8, B01000100, B01111101, B01000000, B00000000,          B00000000, // i
  4, 8, B01000000, B10000000, B10000100, B01111101,           B00000000, // j
  4, 8, B01111111, B00010000, B00101000, B01000100,           B00000000, // k
  3, 8, B01000001, B01111111, B01000000, B00000000,           B00000000, // l
  5, 8, B01111100, B00000100, B01111100, B00000100,          B01111000, // m
  4, 8, B01111100, B00000100, B00000100, B01111000,          B00000000, // n
  4, 8, B00111000, B01000100, B01000100, B00111000,          B00000000, // o
  4, 8, B11111100, B00100100, B00100100, B00011000,           B00000000, // p
  4, 8, B00011000, B00100100, B00100100, B11111100,           B00000000, // q
  4, 8, B01111100, B00001000, B00000100, B00000100,           B00000000, // r
  4, 8, B01001000, B01010100, B01010100, B00100100,           B00000000, // s
  3, 8, B00000100, B00111111, B01000100, B00000000,          B00000000, // t
  4, 8, B00111100, B01000000, B01000000, B01111100,          B00000000, // u
  5, 8, B00011100, B00100000, B01000000, B00100000,           B00011100, // v
  5, 8, B00111100, B01000000, B00111100, B01000000,           B00111100, // w
  5, 8, B01000100, B00101000, B00010000, B00101000,          B01000100, // x
  4, 8, B10011100, B10100000, B10100000, B01111100,           B00000000, // y
  3, 8, B01100100, B01010100, B01001100, B00000000,           B00000000, // z
  3, 8, B00001000, B00110110, B01000001, B00000000,          B00000000, // {
  1, 8, B01111111, B00000000, B00000000, B00000000,          B00000000, // |
  3, 8, B01000001, B00110110, B00001000, B00000000,          B00000000, // }
  4, 8, B00001000, B00000100, B00001000, B00000100,          B00000000, // ~
};

int DIN = 16; // DIN pin of MAX7219 module
int CLK = 12; // CLK pin of MAX7219 module
int CS = 13; // CS pin of MAX7219 module
int maxInUse = 3;

MaxMatrix m(DIN, CS, CLK, maxInUse);

byte buffer[10];

char text[]= "Never Give Up Your Dream. ";

// Scrolling text

void setup() {
  m.init(); // module initialize
  m.setIntensity(1); // dot matix intensity 0-15
}

void loop() {

  printStringWithShift(text, 100); // (text, scrolling      speed)

}
// Display=the extracted characters with scrolling
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);

  for (int i = 0; i < buffer[0] + 1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
// Extract the characters from the text string
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
}
}