Thanks for this I'm going to try it out now.

Hi Andy,

I've been messing around with your program and I have questions/comments.

As is the program isn't toggling leds so I attempted to fix it.

On line 37 you have this, but it doesn't seem right to me.

changedInputs &= 1<<i;

I'm still thinking of what this should be but I have changed it to

changedInputs = 1<<i

That enabled the leds to light up but they just flash instead of staying lit till the next button press. This is due to the last state variable being activated twice per press (On then OFF). So the last state is always a 0. Also at this point the incorrect LED is being triggered. It's the proper row but the wrong column (col 1 instead of 0 when there is a button press on col 0)

Line 12 is to set the active column, with the shift it is moving from right most column to the left most. It seems that the buttons are the opposite? Or maybe its the saved button state information that is filpped? For now I've swapped the button connections (even though I triple checked and they were already correct...) and that works.

cols = 1<<colToCheck;

I've got the toggling working on the leds and with the hardware connection change the correct led is lighting. Here is the edited code.

#include "mbed.h"
 
// Row / Col pin setup.
// defines must match number of pins in the bus structures.
 
#define numberOfCols 2
BusOut cols(p22,p23);
 
#define numberOfInRows 1
BusIn inRows(p26);
 
#define numberOfOutRows 2
BusOut outRows(p25,p24);

// Holds the last state of each input pin in a 2d array.
// Not very memory efficent but simple.
int lastState[numberOfInRows][numberOfCols]; 
 
// Sets the output states. Each col is stored as a seperate value.
// Within each col each bit indicates the state of an output row pin.
// e.g. with outRows(p25,p24) and outputState[this col] = 0x02
// p25 would be high and p24 low.
int outputState[numberOfCols]; // last state of each row/column
 
// Sets the outputs and checks the inputs for a given col.
// returns a binary mask of which inputs have changed.
// 0 = nothing has changed. 0x01 = least significant row has changed, 0x03 = two least significant rows changed etc...
int scanCol(int colToCheck)
{
    int changedInputs = 0; //init value
    outRows = outputState[colToCheck];
    cols = 1<<colToCheck; //sets active column
    wait(0.01);
    for (int i=0; i<numberOfInRows; i++) {
        if (inRows[i] != lastState[i][colToCheck]) { //does the current state of the selected in row equal the last state
            // row i, col colToCheck has changed
            //changedInputs = 1<<i;   //changed &= to =
            if (inRows[i] == 1) {
                changedInputs = 1<<i;
            }
            lastState[i][colToCheck] = inRows[i];
        }
    }
    cols = 0; //turn off Ouptuts
    outRows = 0; //turn off Outputs
    return changedInputs;
}
 
main ()
{
    printf("Matrix Start\n\n");
    int currentCol = 0;
    while (true) {
        //wait(1);
        int changedPins = scanCol(currentCol); // get a list of changed button states for the current column
        outputState[currentCol] ^= changedPins; // toggle the LED related to the changed button. (use a bitwise exclusive or)
        //  for more complex button press logic use this...
        /*
        for (int i=0; i<numberOfInRows; i++)
          if (changedPins & (1<<i)) {
            // input row i, col currentCol has changed
            // lastState[i][currentCol] gives current state of that pin.
          }
        */
        currentCol++;
        if (currentCol == numberOfCols) {
            currentCol  = 0;
        }
    }
}

Tomorrow I will try and hook up the full 8x8 matrix and see if this will scale up properly. Let me know if you see any issues with the edited code, or the above.

Thanks, Ryan

Line 37 - you're correct there is an error there, I'm not sure what I was thinking with an & there. But it should be

changedInputs |= 1<<i;

We want to do a binary OR so that a flag gets set for each button that's down. Your fix will only return the highest row that has had a button change rather than all of them. True it's unlikely that two buttons will ever change at the exact same time but we should still cope with that situation correctly.

You've changed scanCol to only flag up buttons that have been pressed this scan rather than buttons that have changed in either direction. That certainly gives the behavior you want right now but what if at some point in the future you want to detect when a button is released or measure how long a button is held for? Personally I'd keep the scanning code so that it flags any button change and then put any required the direction sensitivity in the code that calls it.

//       outputState[currentCol] ^= changedPins; // toggle the LED related to the changed button. (use a bitwise exclusive or)
        //  for more complex button press logic use this...

        for (int i=0; i<numberOfInRows; i++) {
          if (changedPins & (1<<i)) {             // input row i, col currentCol has changed
            if (lastState[i][currentCol]) // button is now down
               outputState[currentCol] |= 1<<i // set the i'th bit
            else // button is now up
               outputState[currentCol] &= ~(1<<i) // clear the i'th bit 
          }       
       }

Also I just realized the LEDs are probably doing the opposite of what they should. The column line gets set high when we scan a column. Which means we should set the LED row lines low to turn an LED on not the high that is currently used. Rather than deal with negative logic in the code it's probably more intuitive to keep it so that the outputState variable uses a 1 to indicate on and 0 to indicate off and then invert it when we output the values to the pins.

int scanCol(int colToCheck)
{
    int changedInputs = 0; //init value
    outRows = ~outputState[colToCheck]; //  LED outputs low for on, outputState is 1 for on so use the bitwise inverse 
   ... row scan logic...
    cols = 0; //turn off column
    outRows = 0xffff; //turn off all LED outputs
    return changedInputs;
}

And one final tidy up. We really should set an initial value for outputState rather than just hoping that it starts with all 0's.

for (int i = 0;i<numberOfCols;i++)
  outputState[i] = 0;

somewhere near the start of main().

Ok I will change that line to |=, that makes sense.

In regards to the button presses, I forgot to mention that these buttons are momentary so they will never be held high unless someone is physically doing that. The program I will be writing only need buttons to trigger when they are 1's so this is fine as I have it. Good to know for the future though.

As for the LEDs, as in the schematic they will only trigger if the row is set High and the column is set low so that bit of code you posted will work in the opposite manner (all on, then a button press turns an LED off).

I found that if I change

outRows = outputState[colToCheck];

to

outRows = outputState[1>>colToCheck];

Then the Leds line up with the button positions correctly. However this breaks again when I add the 3rd and final column.

Right now I have the matrix set up as 4x3 (2 rows of leds, 2 rows of buttons and 3 columns). Adding another row was simple and caused no issue however when I added a 3rd column the led triggering has become strange. A button press currently lights the Next 2 LED's (not the one above the button), they are on the correct row though. For example if the matrix is like this:

• A) L, L, L
• B) L, L, L
• C) B, B, B
• D) B, B, B
• _ _1_2_3

• C1 triggers leds A2 + A3 (should be A1),
• C2 triggers leds A3 + A1 (should be A2)
• C3 triggers leds A1 + A2 (should be A3).
• The same goes for button presses on row D except leds trigger on row B.

I'm investigating this at the moment, it would seem that there is a bit shift happening and perhaps some bitwise operation to trigger all the leds except for the one I want. Or maybe columns are being stuck high when they should be reset. But I don't get it at the moment because it looks like the leds are triggered on a per column basis so this shouldn't be happening.

And yea I added the init of output state in the beginning of main.

Thanks, Ryan

For the diagram in your initial post the column must be high and the row low for an LED to turn on, you are saying yours are the other way around.

If your LEDs are the other way around and they turn on when the column is low and the row high then the best thing to do is invert the column output so that the column lines are idle high and active low. This also means that the buttons will be low for active and high for idle.

int scanCol(int colToCheck)
{
    int changedInputs = 0;
    outRows = outputState[colToCheck]; // no longer invert this, we want a 1 for LED on in the row.
    cols = ~(1<<colToCheck);  // all high other than the active bit
    wait(0.01);
    for (int i=0; i<numberOfInRows; i++) {
      if (inRows[i] != lastState[i][colToCheck]) {
        if (inRows[i] == 0) {  // low == pressed
            changedInputs != 1<<i;
        }
        lastState[i][colToCheck] = inRows[i];  // note - lastState will also contain 0 for pressed and 1 for not pressed.
      }
    }
    cols = 0xffff; // all columns to 1
    outRows = 0; // all rows to 0
    return changedInputs;
}

Also it would be a good idea to add

inRows.mode(PullUp);

at the start of main so that the button inputs are pulled high (the new idle state) when not pressed.

Thanks andy that fixed it all up. I actually didn't notice that the leds in the example schematic I posted were active low on the rows, sorry about that. I was using that schematic and another one to build my matrix, the second schematic suggested I make use of active High on the rows since there are pull ups in the micro controller.

Anyways, you've been a big help. Take it easy.

Ryan

You're welcome.