2. Logic inside the chip

All the information here are taken from the user guide provided by sure electronics
http://www.sure-electronics.net/download/DE-DP14112_Ver1.1_EN.pdf

The main aim of the microchip is to translate the complex commands we send to it in a form like: “light the LED on the 3rd row and 5th column choosing the color red”. 
Ok, but how to say exactly which LED has to light up? What’s the protocol behind the communication?

From the guide we understand that every information we want to send to the microchip is made of 3 clusters:

• the first consists of 3 bits in which we tell the microchip if we want to write or read from the RAM (the RAM configuration of the microchip corresponds to the state of each LED!) or execute more complex commands;
• then 7 bits for the address of the LED;
• finally 4 bits where we tell the microchip which configuration (a pattern) of LED light up.

Ok, one thing at a time, the last two sequences of bits need a further explanation.
The microchip’s behavior is not very intuitive at a first glance, due to the fact that it is trying to use the less number of bits to communicate the biggest number of informations possible.
The method used is the following:

Figure 2 Groups of led pointed by the number in the address bits (for 1 chip, just a 8x16 matrix)

The address specify a group of 4 led in column. From the 0 to 31 the light will be green, from 32 to 63 the reference is the same but the color is red. So this also explains how the chip manage different colors!

Ok, but I want to light a specific led, not 4!
Let’s see how:

Depending on the integer number (that we pass in its binary form) the microchip lights the LEDs corresponding to the 1 in the sequence of bits.

Examples:

Address = 0
pattern = 8

Address = 45
pattern = 5

Address = 45
pattern = 5

+

Address = 13
pattern = 2

Ok? Problems with decimal to binary convertion? Try this http://www.digitconvert.com/
Let’s get practice!

4. Having fun with the matrix

Now we know how to light up any of the LEDs in the matrix, but we are still far from done; actually we still have to specify the address and the pattern. So why not building a function who get as input the coordinates X / Y and return the lighting of the led?

Simply as follow:

void Plot (int X, int Y, int color)
{
 // color:
 // 0 -> green
 // 1 -> red

 // check the inputs value
 // in case of error return nothing
 if(color > 1 || color < 0)
    return;
 if(X<0 || X>31 || Y<0 || Y>15)  
    return;      

  // variables declaration
  int x = 0;
  int y = 0;
  int nChip = 0;
   
 

  // transform the X/Y coordinates to the number of the microchip
  // that controls the region (1,2,3 or 4) the LED you want to
  // light up
  nChip = 1 + X/16 + (Y>7?2:0);
  chipselect(nChip); // call the function chipselect to send the
                 // information to the matrix
 
  // after the selection of the chip we need just the coordinate
  // for 1 of them, so we need to change the coordinate system
  x = X%16; // columns
  y = Y%8;  // rows
 
 

  // from X/Y to address
  address = ((x*2+y/4)) + color*32;

  // from Y to pattern
  pattern[address][nChip] = pattern[address][nChip] | ((1<<(3-y%4)));      
 
 
  writebits(HT1632_ID_WR, 2);             // send ID: WRITE to RAM
  writebits(address, 6);                  // Send address
  writebits(pattern[address][nChip], 3);   // send 4 bits of data
}

Depending on the input (X,Y and color) the function selects the chip, translates the coordinates in the two variables (address and pattern) and creates an array in which store all the led state (pattern itself).

As you can see color is an integer that can take only two values:
0 for green
1 for red
For the red color the function simply add the number 32 to the address value.

Now we can use this function to build up a simple game, maybe the simplest! The evergreen PONG!

/*** Open the sketch "Step2" in the attachment at the end of the page. ***/

The logic of the game is explained in the loop() section.
We call different functions:

• first of all we call logic(), in which we update the position of the ball, the points and check for the game over;
• once the variables are updated with new values, we call a series of draw functions to physically light the correspondent LEDs (using the function Plot, of course!);
• hence a little bit of delay useful to correct the speed game, and finally we clear the matrix.

What happens if we forget to clear the matrix?
Try yourself!

How to control the game?
Why not connecting two simple potentiometers in the analog inputs of the Arduino board?
Ok, from now on it’s up to your creativity!