I'm using an Arduino Nano to make some sort of "console" and I'm currently designing the controller. However, I would like at least two of them with 6 buttons each. I have reserved 4 pins for the VGA output so there simply aren't enough pins.
The controller only consists of the 6 buttons, with a cable going back to the arduino. The cable must include power and ground. I have considered using radio but that's out of scope for me at the moment.
You could use the good, old, R2R DAC:
simulate this circuit – Schematic created using CircuitLab
All r should be small enough wrt to R to pull down the push button output when it is released. Some good values you can start with are:
Better yet, use one \$100k\Omega\$ resistor for R and two of them in series for the 2R resistor.
I will not dig in how this circuit works, refer to wikipedia for an explaination, what you want to know is that if we associate a digital number to the push button states, the output voltage is an analog representation of such number.
If the button is pressed, we say it is 1, if it is not pressed we say it is 0. SW1 is the LSB, i.e. the rightmost bit, while SW6 is the MSB, i.e. the leftmost.
As an example, if you press SW6, 3 and 2 the digital number is \$D=100110\$, which in decimal is 38.
The output voltage depends on \$V_{dd}\$ and is: $$ V_{out}=V_{dd}\frac{D}{2^N} $$ where N is the number of switches, in this case 6.
You can sample the analog voltage with the arduino ADC and then convert it back to a digital representation of the status.
Since you have an eight bit converter, the routine will be pretty neat:
uint_8t sw_status;
while(1) {
sw_status = adc_read() >> 2;
// do something with sw_status. the lsb represents SW1, and so on, e.g.:
if (sw_status & (1 << 3)) {
//SW3 is pressed here!
}
}
There are some problems with this. First of all, you need precise resistors, or you will get non monotonic behavior which is very bad. The ADC on the nano should be precise enough, but you need to check if it accepts rail to rail inputs. And you get some error because you do not have SPDT push buttons, and you need to use the pull down. Moreover, if you have long wires going to the console, you will probably need to buffer the signal to avoid spurious reads.
All in all this works, requires not many components but is suboptimal at the least. I would definitely go for i2c IO expanders. But this solution is pretty neat and a bit out of the box, and deserves some evaluating.
The classical approach here is to use some kind of IO extender IC. In the simplest case, this would simply be a parallel-to-serial-shift register, for example some variant of the 74xx165:
The picture is from the Texas Instruments SN74LV165A datasheet.
The idea is the following: When the SH pin is pulled low, the values at pins A-H are stored in the internal flipflops, so this is where you connect your switches/buttons that either connect the pin directly to supply voltage (if pressed, for example), or ground the pin throug a (largish) resistor:
simulate this circuit – Schematic created using CircuitLab
That way, when the button is pressed, the voltage at the input is "high", otherwise it's low. It's usually recommendable to connect a capacitor in parallel to the resistor, because that will counter so-called "bouncing". The actual resistor and capacitor values aren't critical – if you use a resistor value that's too small, you'll draw a lot of current with every button pressed, and if you choose a capacitor value too large, buttons will appear to take a long time until they are effectively pressed and released, but in general, something like 10kOhm and 10nF – 100nF, values abundant in most part boxes, should do well for human interaction.
Yet another hint: if you need to go shopping for parts, buy so-called resistor networks; for example, there's parts that contain 8 identical resistors that have one common pin (which you'd connect to ground here, and 8 individual pins. That way, you save yourself a lot of soldering work, and your circuit can look very clean and tidy.
Now, having pulled SH "high" again, the input values are stored in the flipflops.
Now your microcontroller would start to send a clock signal (high,low,high,low,…) to the CLK input. At every rising edge (i.e. low-to-high transition), an input value appears at QH, and the internal states are pushed one step "to the right", meaning that the second flipflop then contains the old value of the first, the third flipflop the old value of the second and so on. After six clock cycles, all the 8 input values have been sequentially shown on QH. That's why this shift register is usually also called a parallel to serial converting shift register.
You can actually daisy-chain those: if you take a second shift register and attach its QH to your shift register SER input, then the output values will be "concatenated" to your first shift registers values. That way, with only three pins on your Arduino (one pin driving SH, one pin driving CLK, and one pin reading the serial output from QH), you can have virtually unlimited amounts of buttons – and that at a unit price of less than 20ct per 8 inputs
The only limiting part is that you regularly have to pull down SH, pull it back up, and generate 8*(N_shiftregisters) clock cycles; this has to be done often enough not to miss a key press – but usually, with microcontrollers running at MHz's, and with SPI hardware that actually is meant for nothing different than talking to such shift registers, this isn't a problem at all – it's not uncommon to see someone query shift registers a couple thousand times per second.
If you have 3 I/O pins, you could charlieplex them.
(You should add a pull down resistor before each I/O pin.)
Image source: http://www.pcbheaven.com/wikipages/images/charlieplexing_1302615143.jpg
Now as a note, you have to test all the possible combinations (6 in total) before determining which buttons are pressed and which ones are not. If you activity one pair of pins and find that there is continuity, there are three possibilities, where current could flow through two pressed down buttons (kinda in series), one pressed down button or all 3.
This is what I mean:
Also, ensure you DO NOT set any OUTPUT to LOW. If you want to prevent something from burning, put like a 1kΩ resistor at each terminal. But that would unintentionally create a voltage divider.
You state parameters of:
Using a digital interface instead of an analog one will give you improved noise tolerance and eliminate accuracy requirements of DAC resistors.
If you search for "I2C keypad controller", you will get several possibilities.
Features of a keypad controller which you might want to take into consideration when selecting a part are inbuilt key debouncing (makes your software/hardware a bit simpler), ESD protection (the user could be a cat), and a user-definable address (so you can have more than one on the same I/O pins).
One of them is the MAX7360 Keypad Controller (this is not a product recommendation as I have no experience with it, and EE.SE is not a product recommendation site).
If you find that your selected device prefers to work with a 3.3 V I²C bus but your Nano works with 5 V, you can use a level-shifter.
Another point to consider is if you can physically solder the device - some of the ones I found use a BGA package. If you have a hot-air soldering station then that will be usable for you, otherwise go for one with pins at the edges.
