How do you control 26 LEDs? A simplistic approach is a digital output pin per LED, but you would need 26, more than most Arduino boards other than the largest and most expensive models. Another solution is to arrange them in an array of rows and columns with an LED at the intersection of each row and column. By driving the appropriate rows and columns you can control the relevant LEDs. It could now be done with three rows of 9 columns, only requiring 3 + 9 = 12 i/o pins.
How about reading 26 keyboard switches? Again, you could use 26 separate inputs, but an array of switches arranged in rows and columns will also work like it did for LEDs, only requiring 12 pins for a 3 x 9 matrix.
LEDs are diodes which only pass current in one direction. If we connected the LEDs and switches to the same matrix, we can apply voltage in one direction to drive each LED. In the reverse direction, the LED will not conduct and we can detect if a switch (in series with a resistor) is connected across any row/column intersection. We will have to turn off the LED while we check for a keyswitch, but we can do this for only a brief time and the user will not notice, provided that the LEDs are on most of the time.
The HT16K33 LED Controller Driver with keyscan is the chip used to do this on the MeinEnigma. It can control up to a 16x8 matrix of LEDs and a 3x13 matrix of keys. It takes care of driving the LEDs that have been programmed on or off and scanning the keyboard for brief times so the LEDs still appear illuminated. It has some other nice features like the ability to adjust the LED brightness, flash the LEDs at a specific rate, and to handle multiple keys pressed at the same time. It does all this over a 2-wire I2C interface, so it only takes two Arduino pins and we can share them with the other I2C devices (like the real-time clock) because they can all have unique I2C addresses.
The chip controls not only the 26 discrete LEDs, and 26 + 4 keys, but also the four 16-segment alphanumeric displays.
Programming the HT16K33 is relatively complex, but fortunately an Arduino library has been written that takes care of the details of programming it. Using the library we can simply call methods like setLed() and clearLed().
The routines provided are listed and documented in the header file ht16k33.h. The implementation is in the file ht16k33.cpp.
I don't have room here to cover the programming of the chip in detail; maybe I will do so in a future blog post. If you want to understand it, take a look at the device data sheet.
For this example we'll look at how to program the 26 discrete LEDs on the lamp and key board. Future examples will look at the alphanumeric displays and keyboard keys which are controlled by the same chip.
Let's step through the program which is listed below and available from here. We first include the "ht16k33.h" library header file and create an instance of the HT16K33 object called HT.
In order to map the LED numbers connected to the chip with the order they are physically arranged on the board, we create a lookup table called ledTable.
In the setup() method we initialize the chip by calling the HT16K33 begin() method passing it the I2C address, zero.
In the main program we demonstrate a number of ways of controlling the LEDs.
The simplest API is to call setLed(), passing the LED number to turn an LED on (or off). We do this for all LEDs in a loop. The LEDs will not actually get turned on until we call sendLed() to send the command.
Next, now that the LEDS are all on, I illustrate changing the brightness by calling setBrightness(). It supports 16 levels of brightness, implemented by changing the duty cycle that the LEDs are on.
Next we turn all LEDs off, and then turn each LED on one at a time by calling setLedNow() which immediately sets the LEDs state without needing to call sendLed().
We then turn all LEDs off in a similar fashion.
Next, we create a little light show by walking one LED on at a time, then turning them all on, and walking one LED off at at time.
Finally, we turn random LEDs on or off for 10 seconds, after which the entire cycle repeats.
Here is an animated image file showing some of the patterns:
And here is the source code:
/*
MeinEnigma Example
Demonstrates controlling the 26 discrete LEDs on the lamp and key
board.
Jeff Tranter
*/
// External library for HT16K33 chip.
#include "ht16k33.h"
HT16K33 HT;
// Lookup table of LEDs.
byte ledTable[] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 28, 29, 30, 31, 19, 20, 21, 22, 23, 24, 25, 26, 27 };
void setup() {
// Need to initialize the chip in order for displays to
// work. This also clears all display segments and LEDs.
HT.begin(0x00);
}
void loop() {
int i;
// All on.
for (i = 0; i < sizeof(ledTable); i++) {
HT.setLed(ledTable[i]);
}
HT.sendLed();
delay(1000);
// Change brightness.
for (i = 16; i >= 0; i--) {
HT.setBrightness(i);
delay(100);
}
for (i = 0; i <= 16; i++) {
HT.setBrightness(i);
delay(100);
}
// All off.
for (i = 0; i < sizeof(ledTable); i++) {
HT.clearLed(ledTable[i]);
}
HT.sendLed();
delay(1000);
// Walk all LEDs on.
for (i = 0; i < sizeof(ledTable); i++) {
HT.setLedNow(ledTable[i]);
delay(100);
}
// Walk all LEDs off.
for (i = 0; i < sizeof(ledTable); i++) {
HT.clearLedNow(ledTable[i]);
delay(100);
}
// Walk one LED on.
for (i = 0; i < sizeof(ledTable); i++) {
HT.setLedNow(ledTable[i]);
delay(100);
HT.clearLedNow(ledTable[i]);
}
// All on.
for (i = 0; i < sizeof(ledTable); i++) {
HT.setLed(ledTable[i]);
}
HT.sendLed();
// Walk one LED off
for (i = 0; i < sizeof(ledTable); i++) {
HT.clearLedNow(ledTable[i]);
delay(100);
HT.setLedNow(ledTable[i]);
}
// All off.
for (i = 0; i < sizeof(ledTable); i++) {
HT.clearLed(ledTable[i]);
}
HT.sendLed();
// Random.
for (int j=0; j < 500; j++ ) {
i = random(sizeof(ledTable));
if (random(2) == 1) {
HT.setLedNow(ledTable[i]);
} else{
HT.clearLedNow(ledTable[i]);
}
delay(20);
}
}
