Help understanding this code!

jvidoza · October 13, 2016, 12:42am

Im currently building a scrolling led message board. The following code works perfectly on my LED matrix with max7219. But i dont quite understand the code! I need a step by step lesson for this code!

thank you guys

#include <MaxMatrix.h>
#include <avr/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 data = 12;    // DIN pin of MAX7219 module
int load = 11;    // CS pin of MAX7219 module
int clock = 10;  // CLK pin of MAX7219 module
 
int maxInUse = 1;  //how many MAX7219 are connected
 
MaxMatrix m(data, load, clock, maxInUse); // define Library
 
byte buffer[10];
 
char string1[] = " LOL      ";  // Scrolling Text
 
 
void setup(){
  m.init(); // module MAX7219
  m.setIntensity(5); // LED Intensity 0-15
}
 
void loop(){
  
  byte c;
  delay(100);
  m.shiftLeft(false, true);
  printStringWithShift(string1, 100);  // Send scrolling Text
 
}
 
// Put extracted character on Display
void printCharWithShift(char c, int shift_speed){
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(maxInUse*8, 0, buffer);
  m.setColumn(maxInUse*8 + buffer[0], 0);
  
  for (int i=0; i<buffer[0]+1; i++) 
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
 
// Extract characters from Scrolling text
void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

TomGeorge · October 13, 2016, 1:27am

Hi,
Welcome to the Forum

Please read the first post in any forum entitled how to use this forum.
http://forum.arduino.cc/index.php/topic,148850.0.html
then look down to item #7 about how to post your code.
It will be formatted in a scrolling window that makes it easier to read.

Thanks.. Tom...

jvidoza · October 13, 2016, 3:25am

Thanks tom!

jremington · October 13, 2016, 3:51am

It is unreasonable to expect forum members to go through and explain the code line by line, so ask a couple of questions about the parts that confuse you the most.

sterretje · October 13, 2016, 6:40am

The basics of the code are quite simple.

The below defines the information for the MAX7219 to display a character.

PROGMEM const unsigned char CH[] = {
...
...
}

For each character 7 bytes are used; for now it's not relevant what it means. The PROGMEM indicates that the data is stored in program memory so it does not eat away RAM.

You can have a look at http://www.asciitable.com/ and try to find a resemblence in the sequence of the characters.

The first 32 (0..31, 0x00..0x1F) ascii characters are non-printable. The function printCharWithShift() checks for this and does nothing (returns immediately) if one of those characters is detected.
Else it subtracts 32 from the value of the character (e.g. capital L is represented by the value 76 and 32 is subtracted from it (result 44). You now go back to CH and start counting; the first 'row' is 0 and you count to 44. What do you find?

The function now makes a copy (using memcpy_P) of the 7 bytes that it found into a small byte array called buffer; memcpy_P is a special version of memcpy that copies from PROGMEM instead of normal (RAM) memory/]]. Using writeSprite(), the data is written to the MAX7219.

I can not explain in detail the rest of the code of that function; I do not have the MAX7219 nor the library. You can analyze the library to see what is happening; the library will consist of one or more .h and .cpp (or .c) files. You will mostly be interested in the .cpp/.c files as they define what a function does. Use a decent editor (e.g. notepad++ under windows, vi under linux); grep (linux) or grepWin (Windows) can also be useful to look for functions in the library.

The function printStringWithShift() loops through the text that you passed as an argument (pointer to character array, *s) and for each character in the text calls printCharWithShift(). By incrementing the pointer, it will pass the next character.

So initially s will point to the first space in " LOL "; after s++ it will point to the first 'L' and so on.

As you might know, C-strings are nul ('\0', 0 (see the ascii table)) terminated. The function will stop calling printCharWithShift() once it detects that s points to the (a) nul character.

That should do for now For full understanding, you need to analyze the library and need the datasheet of the MAX7219.

kesispass · January 4, 2019, 9:32pm

hello

Can I change the sens of scrolling? I have for devices and the text is scrolling up to down and I want it to scroll left o right.

wvmarle · January 6, 2019, 11:19am

I'm quite sure it's possible, but not with the information given (lack of details on the connected hardware and how it is addressed). After all scrolling is just a matter of changing the images step by step to give the impression of scrolling.

Whether you can do it, I don't know, depends on your skills. A full understanding of the sketch you posted would be a good start.

sterretje · January 6, 2019, 11:52am

wvmarle:
A full understanding of the sketch you posted would be a good start.

wendsn · April 16, 2020, 10:19pm

how do I add the characters Ç and ç. I'm not getting. the ASCII code for them are: 128 Ç and 135 ç. can you help me please?

Topic		Replies	Views
MAX7219 LED Matrix and 16*2 LCD scrolling Massage code Programming	14	2034	May 5, 2021
I am having some issues coding two 8 by 8 LED displays. Can you help me. Programming	3	710	May 5, 2021
MaxMatrix MAX7219 code issues Programming	2	563	May 5, 2021
MAX7219 LED Matrix "ROTATE TEXT" Programming	9	12550	May 5, 2021
LED Matrix using MAX7219 for Arduino Programming	6	1085	May 5, 2021

Help understanding this code!

Related topics