any tutorials on this?

Never used one but from the code, I saw this:

int dataIn = 2;
int load = 3;
int clock = 4;

and on the left of your picture are the connections:
DIN
CS
CLK

so I think they match up like this:

int dataIn = 2; //DIN
int load = 3; //CS
int clock = 4; //CLK

but there are 10 pins.. only 3 to make this work?

Ruffsta:
but there are 10 pins.. only 3 to make this work?

Looks that way. Check out the link to the tutorial in the code that pyro_65 linked to. It'll be 5 of course though since you'll need vcc and ground.

3 are already mentioned. The other 2 are Gnd and Vcc, not much imagination required here.

The other 5 pins are the same and they are the output side (DOUT is the opposite of DIN). These modules can be daisy chained. If you wanted to add the second or more modules you connect the 'output' of one board to the 'input' of another.

k, ty

code doesn't work..

int dataIn = 2;
int load = 3;
int clock = 4;
 
int maxInUse = 1;    //change this variable to set how many MAX7219's you'll use
 
int e = 0;           // just a varialble
 
                     // define max7219 registers
byte max7219_reg_noop        = 0x00;
byte max7219_reg_digit0      = 0x01;
byte max7219_reg_digit1      = 0x02;
byte max7219_reg_digit2      = 0x03;
byte max7219_reg_digit3      = 0x04;
byte max7219_reg_digit4      = 0x05;
byte max7219_reg_digit5      = 0x06;
byte max7219_reg_digit6      = 0x07;
byte max7219_reg_digit7      = 0x08;
byte max7219_reg_decodeMode  = 0x09;
byte max7219_reg_intensity   = 0x0a;
byte max7219_reg_scanLimit   = 0x0b;
byte max7219_reg_shutdown    = 0x0c;
byte max7219_reg_displayTest = 0x0f;
 
void putByte(byte data) {
  byte i = 8;
  byte mask;
  while(i > 0) {
    mask = 0x01 << (i - 1);      // get bitmask
    digitalWrite( clock, LOW);   // tick
    if (data & mask){            // choose bit
      digitalWrite(dataIn, HIGH);// send 1
    }else{
      digitalWrite(dataIn, LOW); // send 0
    }
    digitalWrite(clock, HIGH);   // tock
    --i;                         // move to lesser bit
  }
}
 
void maxSingle( byte reg, byte col) {    
//maxSingle is the "easy"  function to use for a     //single max7219
 
  digitalWrite(load, LOW);       // begin    
  putByte(reg);                  // specify register
  putByte(col);//((data & 0x01) * 256) + data >> 1); // put data  
  digitalWrite(load, LOW);       // and load da shit
  digitalWrite(load,HIGH);
}
 
void maxAll (byte reg, byte col) {    // initialize  all  MAX7219's in the system
  int c = 0;
  digitalWrite(load, LOW);  // begin    
  for ( c =1; c<= maxInUse; c++) {
  putByte(reg);  // specify register
  putByte(col);//((data & 0x01) * 256) + data >> 1); // put data
    }
  digitalWrite(load, LOW);
  digitalWrite(load,HIGH);
}
 
void maxOne(byte maxNr, byte reg, byte col) {    
//maxOne is for adressing different MAX7219's,
//whilele having a couple of them cascaded
 
  int c = 0;
  digitalWrite(load, LOW);  // begin    
 
  for ( c = maxInUse; c > maxNr; c--) {
    putByte(0);    // means no operation
    putByte(0);    // means no operation
  }
 
  putByte(reg);  // specify register
  putByte(col);//((data & 0x01) * 256) + data >> 1); // put data
 
  for ( c =maxNr-1; c >= 1; c--) {
    putByte(0);    // means no operation
    putByte(0);    // means no operation
  }
 
  digitalWrite(load, LOW); // and load da shit
  digitalWrite(load,HIGH);
}
 
 
void setup () {
 
 
  pinMode(dataIn, OUTPUT);
  pinMode(clock,  OUTPUT);
  pinMode(load,   OUTPUT);
 
  beginSerial(9600); //------------------------------------first error, this is not defined
  digitalWrite(13, HIGH);  
 
//initiation of the max 7219
  maxAll(max7219_reg_scanLimit, 0x07);      
  maxAll(max7219_reg_decodeMode, 0x00);  // using an led matrix (not digits)
  maxAll(max7219_reg_shutdown, 0x01);    // not in shutdown mode
  maxAll(max7219_reg_displayTest, 0x00); // no display test
   for (e=1; e<=8; e++) {    // empty registers, turn all LEDs off
    maxAll(e,0);
  }
  maxAll(max7219_reg_intensity, 0x0f & 0x0f);    // the first 0x0f is the value you can set
                                                  // range: 0x00 to 0x0f
}  
 
void loop () {
 
 
  //if you use just one MAX7219 it should look like this
  
   maxSingle(1,1);                       //  + - - - - - - -
   maxSingle(2,2);                       //  - + - - - - - -
   maxSingle(3,4);                       //  - - + - - - - -
   maxSingle(4,8);                       //  - - - + - - - -
   maxSingle(5,16);                      //  - - - - + - - -
   maxSingle(6,32);                      //  - - - - - + - -
   maxSingle(7,64);                      //  - - - - - - + -
   maxSingle(8,128);                     //  - - - - - - - +
 
  delay(2000);
 
}

Time to get your scope out.

let me use yours so i can see what you see..

this code works.. just need to switch pins on the arduino to 8,9 and 10

 unsigned char i;
 unsigned char j; 
/*port definition*/
int Max7219_pinCLK = 10;
int Max7219_pinCS = 9;
int Max7219_pinDIN = 8;

unsigned char disp1[38][8]={
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//0
{0x10,0x18,0x14,0x10,0x10,0x10,0x10,0x10},//1
{0x7E,0x2,0x2,0x7E,0x40,0x40,0x40,0x7E},//2
{0x3E,0x2,0x2,0x3E,0x2,0x2,0x3E,0x0},//3
{0x8,0x18,0x28,0x48,0xFE,0x8,0x8,0x8},//4
{0x3C,0x20,0x20,0x3C,0x4,0x4,0x3C,0x0},//5
{0x3C,0x20,0x20,0x3C,0x24,0x24,0x3C,0x0},//6
{0x3E,0x22,0x4,0x8,0x8,0x8,0x8,0x8},//7
{0x0,0x3E,0x22,0x22,0x3E,0x22,0x22,0x3E},//8
{0x3E,0x22,0x22,0x3E,0x2,0x2,0x2,0x3E},//9
{0x8,0x14,0x22,0x3E,0x22,0x22,0x22,0x22},//A
{0x3C,0x22,0x22,0x3E,0x22,0x22,0x3C,0x0},//B
{0x3C,0x40,0x40,0x40,0x40,0x40,0x3C,0x0},//C
{0x7C,0x42,0x42,0x42,0x42,0x42,0x7C,0x0},//D
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x7C},//E
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x40},//F
{0x3C,0x40,0x40,0x40,0x40,0x44,0x44,0x3C},//G
{0x44,0x44,0x44,0x7C,0x44,0x44,0x44,0x44},//H
{0x7C,0x10,0x10,0x10,0x10,0x10,0x10,0x7C},//I
{0x3C,0x8,0x8,0x8,0x8,0x8,0x48,0x30},//J
{0x0,0x24,0x28,0x30,0x20,0x30,0x28,0x24},//K
{0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x7C},//L
{0x81,0xC3,0xA5,0x99,0x81,0x81,0x81,0x81},//M
{0x0,0x42,0x62,0x52,0x4A,0x46,0x42,0x0},//N
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//O
{0x3C,0x22,0x22,0x22,0x3C,0x20,0x20,0x20},//P
{0x1C,0x22,0x22,0x22,0x22,0x26,0x22,0x1D},//Q
{0x3C,0x22,0x22,0x22,0x3C,0x24,0x22,0x21},//R
{0x0,0x1E,0x20,0x20,0x3E,0x2,0x2,0x3C},//S
{0x0,0x3E,0x8,0x8,0x8,0x8,0x8,0x8},//T
{0x42,0x42,0x42,0x42,0x42,0x42,0x22,0x1C},//U
{0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18},//V
{0x0,0x49,0x49,0x49,0x49,0x2A,0x1C,0x0},//W
{0x0,0x41,0x22,0x14,0x8,0x14,0x22,0x41},//X
{0x41,0x22,0x14,0x8,0x8,0x8,0x8,0x8},//Y
{0x0,0x7F,0x2,0x4,0x8,0x10,0x20,0x7F},//Z
{0x8,0x7F,0x49,0x49,0x7F,0x8,0x8,0x8},//Chinese character
{0xFE,0xBA,0x92,0xBA,0x92,0x9A,0xBA,0xFE},//Chinese character
};



void Write_Max7219_byte(unsigned char DATA) 
{   
            unsigned char i;
	    digitalWrite(Max7219_pinCS,LOW);		
	    for(i=8;i>=1;i--)
          {		  
             digitalWrite(Max7219_pinCLK,LOW);
             digitalWrite(Max7219_pinDIN,DATA&0x80);//Obtain the MSB of the data
             DATA = DATA<<1;
             digitalWrite(Max7219_pinCLK,HIGH);
           }                                 
}


void Write_Max7219(unsigned char address,unsigned char dat)
{
        digitalWrite(Max7219_pinCS,LOW);
        Write_Max7219_byte(address);           //
        Write_Max7219_byte(dat);               //
        digitalWrite(Max7219_pinCS,HIGH);
}

void Init_MAX7219(void)
{
 Write_Max7219(0x09, 0x00);       //decode: BCD
 Write_Max7219(0x0a, 0x03);       //Brightness
 Write_Max7219(0x0b, 0x07);       //
 Write_Max7219(0x0c, 0x01);       //
 Write_Max7219(0x0f, 0x00);       //
}



void setup()
{
  
  pinMode(Max7219_pinCLK,OUTPUT);
  pinMode(Max7219_pinCS,OUTPUT);
  pinMode(Max7219_pinDIN,OUTPUT);
  delay(50);
  Init_MAX7219();
}


void loop()
{ 
   for(j=0;j<38;j++)
  {
   for(i=1;i<9;i++)
    Write_Max7219(i,disp1[j][i-1]);
   delay(500);
  } 		
}

k, what i don't get in this code.. is:

{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//0
{0x10,0x18,0x14,0x10,0x10,0x10,0x10,0x10},//1
{0x7E,0x2,0x2,0x7E,0x40,0x40,0x40,0x7E},//2
{0x3E,0x2,0x2,0x3E,0x2,0x2,0x3E,0x0},//3
{0x8,0x18,0x28,0x48,0xFE,0x8,0x8,0x8},//4
{0x3C,0x20,0x20,0x3C,0x4,0x4,0x3C,0x0},//5
{0x3C,0x20,0x20,0x3C,0x24,0x24,0x3C,0x0},//6
{0x3E,0x22,0x4,0x8,0x8,0x8,0x8,0x8},//7
{0x0,0x3E,0x22,0x22,0x3E,0x22,0x22,0x3E},//8
{0x3E,0x22,0x22,0x3E,0x2,0x2,0x2,0x3E},//9
{0x8,0x14,0x22,0x3E,0x22,0x22,0x22,0x22},//A
{0x3C,0x22,0x22,0x3E,0x22,0x22,0x3C,0x0},//B
{0x3C,0x40,0x40,0x40,0x40,0x40,0x3C,0x0},//C
{0x7C,0x42,0x42,0x42,0x42,0x42,0x7C,0x0},//D
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x7C},//E
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x40},//F
{0x3C,0x40,0x40,0x40,0x40,0x44,0x44,0x3C},//G
{0x44,0x44,0x44,0x7C,0x44,0x44,0x44,0x44},//H
{0x7C,0x10,0x10,0x10,0x10,0x10,0x10,0x7C},//I
{0x3C,0x8,0x8,0x8,0x8,0x8,0x48,0x30},//J
{0x0,0x24,0x28,0x30,0x20,0x30,0x28,0x24},//K
{0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x7C},//L
{0x81,0xC3,0xA5,0x99,0x81,0x81,0x81,0x81},//M
{0x0,0x42,0x62,0x52,0x4A,0x46,0x42,0x0},//N
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//O
{0x3C,0x22,0x22,0x22,0x3C,0x20,0x20,0x20},//P
{0x1C,0x22,0x22,0x22,0x22,0x26,0x22,0x1D},//Q
{0x3C,0x22,0x22,0x22,0x3C,0x24,0x22,0x21},//R
{0x0,0x1E,0x20,0x20,0x3E,0x2,0x2,0x3C},//S
{0x0,0x3E,0x8,0x8,0x8,0x8,0x8,0x8},//T
{0x42,0x42,0x42,0x42,0x42,0x42,0x22,0x1C},//U
{0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18},//V
{0x0,0x49,0x49,0x49,0x49,0x2A,0x1C,0x0},//W
{0x0,0x41,0x22,0x14,0x8,0x14,0x22,0x41},//X
{0x41,0x22,0x14,0x8,0x8,0x8,0x8,0x8},//Y
{0x0,0x7F,0x2,0x4,0x8,0x10,0x20,0x7F},//Z
{0x8,0x7F,0x49,0x49,0x7F,0x8,0x8,0x8},//Chinese character
{0xFE,0xBA,0x92,0xBA,0x92,0x9A,0xBA,0xFE},//Chinese character

trying to make sense of it..

you can the code here: http://www.linksprite.com/download/showdownload.php?lang=en&id=223
or
here (takes you to the same exact same place): http://www.linksprite.com/upload/file/1347631413.txt

Moderator edit: Tags corrected

trying to make sense of it..

They're bit patterns, for your dot-matrix display.
Eight bytes per character, each byte with eight bits.
At the moment, they're consuming precious RAM - they might be better placed in PROGMEM.

again, i'm new.. so.. i'm at a loss here..

they might be better placed in PROGMEM

sorry, but i don't know how to do that yet or how to modify the code to do such..

i just got this for him and he soldered it all up - (since i have soldered for years, i taught him how to and he does exceptionally well).. so the coding is not what we are used to.

i thought getting this thing - (the arduino and such), for my son was going to be fun.. something we could do together as a father/son time thing, but in the end - it's more confusing than anything. starting to wonder why i even bothered getting him this even tho he's into building and coding stuff, but i think this may be just too much for him at 13 - i know it is for me at 39...

Never underestimate a 13 year old when it comes to computer technology ...

Did you start wih easier stuff like the LED blinker and reading an analog input? I find it is good to get the basics right and build on that.

is there a way to control each led in the matrix individually or a better way to display what we want it to display vs bit patterns?

I only said they "might" be better in PROGMEM - I don't know what else you have in mind to do with this device.
If you were going to build some kind of message matrix with multiple devices, it might be better to save RAM for user-specified messages.

However, there is nothing magical about PROGMEM, it is just another memory space on the processor, and there are lots of tutorials and threads on the topic.

marco_c:
Never underestimate a 13 year old when it comes to computer technology ...

Did you start wih easier stuff like the LED blinker and reading an analog input? I find it is good to get the basics right and build on that.

yeah, we got tired of making leds blink, so i go on ebay and get random stuff (such as this) and then go from there.. we did a few digit leds, still trying to get the 3 digit and 2 digits to work.. but in time i guess.

we played around with a sensor (4 pin)..

we want to get into multiplexing - building cubes and dancing images.. he wants to build a torrent (or whatever he calls it).. i have a project i am working on with crossroads.

we have a couple of lcd's yet to play with.. but yeah, multiplexing and the such is what we want to accomplish the most,

AWOL:
I only said they "might" be better in PROGMEM - I don't know what else you have in mind to do with this device.
If you were going to build some kind of message matrix with multiple devices, it might be better to save RAM for user-specified messages.

However, there is nothing magical about PROGMEM, it is just another memory space on the processor, and there are lots of tutorials and threads on the topic.

we just want it to display different things.. .nothing special at this time.. i have more max7219's if ever needed.. i stocked up on those :slight_smile:

i mean, it's a red dot 8x8 matrix.. nothing we really can use it for or need it for.. was just something to mess and learn with..

we were inspired such vids:

the wiring and soldering doesn't bother me - it's the rest that does..his coding is off tho

those are crazy! wish we were in that league of arduino! but alas, we are new and dealing with all this simple (yet confusing) stuff for now.

k, getting back on subject here... is there another way to control each dot individually other than bit patterns?

thanks

is there another way to control each dot individually other than bit patterns?

No you have to do it through bit patterns. Why is that a problem?

There's a MAX7219 on the board, yes?
It has 8 registers you write to, 1 for each column of data, at addresses 0x01 thru 0x08.
You want a single LED on, you write to the register for that column with the data you want.
I use SPI to control MAX7219s vs the shiftout/bit bang discussed so far, hardware transfer vs a software transfer.

an example would be:

digitalWrite(SSpin, LOW); // SSpin is generally D10
SPI.transfer(register0);     // declared earlier in code as 'byte register0 = 0x01;
SPI.transfer(data_to_write);  // control in your code = 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 for the 8 LEDs one at a time
digitalWrite(SSpin, HIGH);

if you made an array of the register numbers and the data:

byte registerAddress[] = {1,2,3,4,5,6,7,8;};  // registerAddress[0] = 1, [1] = 2, etc. up to [7] = 8
byte data_to_write [8];  // data_to_write [0] = data for  registerAddress[0], ... data_to_write [7] = data for  registerAddress[7]

then you put the above in a loop and just call it when your code changed something:

if (dataChanged_flag ==1){   // flag is set when the code makes a change to data_to_write[0] thru data_to_write[7]
dataChanged_flag = 0; // clear the flag
for (x =0; x<8; x=x+1){
digitalWrite(SSpin, LOW); // SSpin is generally D10
SPI.transfer(registerAddress[x]);  // send Register address 1 to 8
SPI.transfer(data_to_write[x]);  // send data for associated register
digitalWrite(SSpin, HIGH);
}