Proteus C51 simulation learning board 8 - matrix keyboard

Matrix keyboard, Proteus provides a variety of matrix keyboards, including calculators, telephones, and custom layouts. Encapsulating multiple keys is more vivid. In order to clarify the internal wiring diagram, it is still built using keys.

Before talking about the principle of matrix keyboard, let’s talk about why we use matrix keyboard?

When there are a large number of keys, in order to save IO resources, the keys are usually arranged in a matrix form, and each key is identified by rows and columns. For example, 8 IOs can identify 4*4=16 keys, which is twice as many as directly driving 8 keys.

Principle 1-Reversal scanning method:

In the default state, P10-7 all output high level 1;

First, P1=0x0F, the row line output is 0. If key 7 is pressed, P10=P14=0, then read the row value & 0x0F=0x0E; then read the column value & 0xF0=0xE0, the sum of the two values ​​= 0xEE, and it can be detected that one of the 16 keys is pressed.

  KeyPort=0x0f; //Line output is all 0

  cord_h=KeyPort&0x0f; //Read column line value

  if(cord_h!=0x0f) //First check if any button is pressed

  {

    DelayMs(10); //debounce

    if((KeyPort&0x0f)!=0x0f)

    {

      cord_h=KeyPort&0x0f; //Read column line value

      KeyPort=cord_h|0xf0; //Output current column line value

      cord_l=KeyPort&0xf0; //Read line value

      while((KeyPort&0xf0)!=0xf0);//Wait for release and output

      return(cord_h+cord_l); //Last combination code value of keyboard

    }

  }

  return(0xff); //Return the value

Principle 2 - Line-by-line scanning method:

In the default state, P10-7 all output high level 1;

Then rows P10-P17 output 0xFE=1111 1110, that is, P10=0. So after key 7 is pressed, P14=0, and continue to detect P10-P17=1110 1110=0xEE, so key 7 is pressed.

Then output 0xFD=1111 1101...

 KeyPort=0xf0; //The upper four bits are high, and the lower four bits are low

 if(KeyPort!=0xf0) // indicates a key is pressed

 {

    DelayMs(10); //debounce

    if(KeyPort!=0xf0)

    { //Indicates that a key is pressed

      KeyPort=0xfe; //Detect the first line

      if(KeyPort!=0xfe)

      {

        Val=KeyPort&0xf0;

        Val+=0x0e;

        while(KeyPort!=0xfe);

        DelayMs(10); //debounce

        while(KeyPort!=0xfe);

        return Val;

      }

      KeyPort=0xfd; //Detect the second line

      if(KeyPort!=0xfd)

      {

        Val=KeyPort&0xf0;

        Val+=0x0d;

        while(KeyPort!=0xfd);

        DelayMs(10); //debounce

        while(KeyPort!=0xfd);

        return Val;

      }

      KeyPort=0xfb; //Detect the third line

      if(KeyPort!=0xfb)

      {

        Val=KeyPort&0xf0;

        Val+=0x0b;

        while(KeyPort!=0xfb);

        DelayMs(10); //debounce

        while(KeyPort!=0xfb);

        return Val;

      }

      KeyPort=0xf7; //Detect the fourth line

      if(KeyPort!=0xf7)

      {

        Val=KeyPort&0xf0;

        Val+=0x07;

        while(KeyPort!=0xf7);

        DelayMs(10); //debounce

        while(KeyPort!=0xf7);

        return Val;

      }

     }

   }

The two principles are actually very similar, one is round-robin training, and the other is direct row and column reversal detection, which is easy to understand. If you are doing a physical object, it is best to add pull-up resistors and capacitors, so that the hardware can play a certain anti-shake function, and coupled with the software's anti-shake function, the detection will be more reliable.