My Retropie Portable Build

So I have got most the schematic drawn up for the button matrix, I still have a number of items to put on the schematic most importantly a logic level shifter as the shift registers are logic level 5v devices along with the inverter.

But a description of the circuit function.

The matrix is polled approx every 1 to 5 milliseconds, With the SPI bus set to run on a 6.25MHz clock,  The SPI input is expecting a 32bit binary value, these 32 bits represent the buttons.

Once a read starts chip enable 0 is activated turning on the shift registers, firstly a single bit is loaded into the shift register, then Chip enable 1 is activated, to connect the register clock to the SPI clock to start clocking through the buttons.

As the clock cycles through the button matrix, the inverter facilitates the output of the data on the shift registers output lines on the falling edge of the clock, as the clock cycles the data through the registers if a button is pressed it sends a logic 1 to the SPI bus, to indicate a button that has been pressed, once a cycle is complete, this 32 bit value can be analysed to see which buttons have been pressed

once this is in memory it can then be analysed to see which buttons have been pressed by means of a lookup table.

The reason for a 6.25MHz clock is the speed of the chips being used, the shift registers cant operate much faster, but in saying that I could easily use a slower clock as at 6.25MHz clock I can do a full matrix read in approx 6 to 7 microseconds

I would like some feedback to know if this design is sound, and then I'll have to spend time working out the code on how to read the matrix, and how to assign the lookup table

Hi Paul,

There are other ways to design keyboard circuits that reduce the need for so many parts, you've got 37 parts here not including the buttons. These can be reduced to 2 parts, like two MCP23017 chips, and they are available in through-hole and surface-mount versions.

I've not tried it for a games system, so you'd have to experiment to rule it in or out, but I think if you software-enable pull-ups and configure the MCP chips to be all inputs, then you can configure it to signal via interrupt when any switch input changes. No need to do so much scanning basically.

Anyway, regardless of what you go with, it is best to prototype a bit of this (e.g. on a breadboard) before creating a PCB, i.e. by PCB creation stage there should be near-100% confidence that worst-case nothing other than one or two 'bodge' wires may be necessary to get the prototype working. Not all of it needs to be prototyped, but at least some buttons and a few of the chips.

Each chip should have a 100nF capacitor across the supply rails, as close to the chip as possible, this may also be indicated in the datasheets for the ICs. Also, the Pi is a 3.3V logic device, it's a bit dangerous to run the circuit shown above from 5V. Although it could be level-converted, it is better to power off the 3.3V rail provided you don't draw too much current (which a keyboard driver circuit shouldn't anyway). Also, for U5, 74LS366, the 74HC would be used instead (LS isn't suitable for 3.3V operation).

Hi Shabaz,

Thanks for the suggestion I'll make a change to my schematic, I'm reading up on the chip now, trying to find the SPI commands, as I've started coding the source file to read the button states, but you know of anyone with programming experience that might be able to help me ensure my code is correct, and enable it is a pre-configured key mapping?

Attached is the code I have worked out so far, still needs work be aware its currently written for my current schematic

I read up on the chip, It’s a lot more difficult to program SPI commands have way too much overhead, but another option I have is it use a 74HC166 which is a proper input chip, but the reasoning behind my design is the ability to source parts, not easy to do here in Australia

Regards

Paul

#include <bcm2835.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    
    if (!bcm2835_init())
        return 1;
        
    const int start_poll = 0x01;                                  // Initial Byte sent to Shift Register to do button read by setting Qa in the shift register to logic high
    char button_state[]= {0x00, 0x00, 0x00, 0x00];                  // 32 bit 4 byte array to store the button states
    
        
    bcm2835_spi_begin();
    bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST);      // Set Byte Transfer Read Order
    bcm2835_spi_setDataMode(BCM2835_SPI_MODE0);                   // Default Transfer Mode
    bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_64);    // Clock set to RPi 2 to 3.90625MHz or on RPi 3 to 6.25 MHz
    
        
    bcm2835_spi_chipSelect(BCM2835_SPI_CS0);                      // Enable Shift Registers Only
    bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW);      // Set Shift Register Enable Polarity to Active Low
    bcm2835_spi_transfer(start_poll);                              // Set First Shift Register Qa Output to Logic High
    bcm2835_spi_chipSelect(BCM2835_SPI_CS1);                      // Select All devices and Register Clock 
    bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS1, LOW);      // Set Chip Enable Polarity to Active Low
    bcm2835_spi_transfern(button_state, sizeof(button_state));    // Read the button Status
    
    
    bcm2835_spi_end();
    return 0;
}

Hi Paul,

I've not coded using the library you're using or for this device, so cannot help much here.

It may be instead worthwhile using a GPIO library (such as wiringPi or some other one, I don't know what's recommended these days for Pi), otherwise you'll need to modify and retest bits of code if you change Pi variant.

Another suggestion is using a logic analyzer (some are low-cost, search for 'salae logic' for instance) when coding for hardware like this.

Hi Paul,

I've not coded using the library you're using or for this device, so cannot help much here.

It may be instead worthwhile using a GPIO library (such as wiringPi or some other one, I don't know what's recommended these days for Pi), otherwise you'll need to modify and retest bits of code if you change Pi variant.

Another suggestion is using a logic analyzer (some are low-cost, search for 'salae logic' for instance) when coding for hardware like this.

Hi Shabaz,

I Redesigned my Key Matrix, and re wrote my code.  I'm using 74HC165 now, which are proper input shift registers or PISO registers, don't need to use protection diodes on the pins, and the IC's are 3.3v logic level.

Now below is my code to communicate with the shift registers using wiringPi, but what concerns me it does not tell me if the Chip Select is in Active Low or Active High mode, when it accesses the SPI bus.  I can always test this when my chips arrive had to buy a tube of 50 of them from RS Components and got some breakout boards so I can easily breadboard the IC's as they are an SOIC package.  But if WiringPi cant use the SPI bus correctly, cause of the simple nature of the shift registers I could manually shift the data in but this is alot of coding work to do this, and I prefer not to go down this path.

#include <wiringPi.h>
#include <wiringPiSPI.h>
#include <stdio.h>

int main(void)
{
    
    char button_state[]= {0x00, 0x00, 0x00, 0x00];                  // 32 bit 4 byte array to store the button states
    int i;
            
    wiringPiSetup();                                            // Initialise Wiring Pi
    wiringPiSPISetup (0, 3000000);                                // Initialise Wiring Pi SPI interface With 3MHz clock
    pinMode (26, OUTPUT);                                        // Setup Parallel Load pin as Output
    
    digitalWrite (26, LOW);                                        // Pull Parallel Load Pin to Logic Low to load data
    delayMicroseconds (1);                                        // Wait one Microsecond for data to stabilise
    digitalWrite (26, HIGH);                                    // Pull Parallel Load Pin to Logic High to load data into serial register
    
    wiringPiSPIDataRW (0, button_state, sizeof(button_state));    // Read data from Shift Registers with SPI of a 32bit value
        
    for (i = 0; i < 3; i++)
    {
        printf(button_state[i], "\n");
    }
}

for the moment the code only just prints out the contents of the array, but eventually I need to find out how to map this data to a device tree overlay that references specific assigned keyboard buttons.

Regards

Paul

Hi Paul,

Each input that is connected to a switch needs a resistor (in your case a pull-down resistor, such as a 10 k resistor) otherwise each input is floating until a switch is pressed.

Is the requirement to have the Chip select be normally low, and then to go high when accessing the chips? If so, you could wire it to any other pin on the Pi and manually set it. Or, just permanently wire it high if that works for your circuit (I have not checked). Also, 100nF capacitors are needed.

Use what you're most comfortable with, I just personally feel using a library like wiringPi is far reduced coding (and more reliable) compared to trying to access BCM.. registers manually.

Also, no matter how confident you are, I'd suggest just buying a few of the ICs and trying it out, rather than buying a tube of 50 if there's a risk your design may change and use a different device. ebay Australia (I would not normally suggest ebay, but if you're struggling to obtain fewer quantities from a distributor) has them in single quantity: https://www.ebay.com.au/itm/74HC165-8-bit-parallel-in-out-Shift-Register-IC/254545886099?epid=1963682493&hash=item3b441d…

The Clock Enable is Active Low, and when it is pulled low starts clocking the data out serially on the rising edge of pulse.

And I have investigated manually clocking out the data using the GPIO and not the SPI protocol, but it adds a lot more to the code, which I can do, but SPI can read the data in approx 6 microseconds whereas if I code it manually and ensure the slowest delay time of one microsecond per data read I’m looking at approx 40 microseconds to read the data but in thinking that thru, it’s still a short space of time, but I still need to poll the registers.

Also if I increase the component count again, I can use shotky diodes to tie, all the input lines to a single GPIO pin looking for a button push, and essentially give me an interrupt. But prevent the other lines from being affected.  As much as I could interface a standard row and column approach, I want to keep the amount of GPIO I use to a minimum if I need more in future if I use the same 32 button input hardware.

ill do a bit more work, and clean up the schematic and I’ll also write the code that handles the data scan manually using wiringpi

i Didn’t mind buying the tube and the IC is a standard one for adding in more inputs, so don’t worry I’ll end up using them. And the tube only cost me $25

its late here I’ll do it during the day, bed time for me

Regards

Paul