Paul's Electronics

Why switch debouncing is so important...

paul.nospam@nospam.sqlskills.com (paul) — Sat, 26 Oct 2019 13:58:00 -0800

Here's a graphic illustration of why mechanical switch debouncing is so important:

It's the output of a push-button switch when I press it. The metal contacts inside the switch bounce against each other, creating two pulses when I expected just one. If I'd been debugging something sensitive to pulses, like using the output as a clock pulse, this would have messed up the debugging.

There are various methods of debouncing switches, and the most common is to use an S-R latch.

Smoothing capacitors on power lines

paul.nospam@nospam.sqlskills.com (paul) — Fri, 25 Oct 2019 15:42:00 -0800

Well, the best laid plans of mice and men, and all that. Now I've got a long-term project to finally get back into electronics and blogging after an almost 10 year gap.

I'm building an 8-bit computer on breadboards, based on the kit and videos by Ben Eater - see here.

The first thing I want to blog about is something new I learned today. I'd always known how putting small ceramic capacitors across power lines helps to smooth out logic transitions and prevent spurious problems, but I didn't know about using larger capacitors for the same purpose.

Below is a scope plot of the rising edge of the output from a 555 clock circuit, with a 1us timebase, and no smoothing capacitors:

You can see that when the transistors in the 555 switch on, there's a big pull from the power supply and the output voltage spikes momentarily.

This next plot is with a 0.01uF ceramic capacitor across the power lines:

You can see that the voltage spike isn't so high, but then oscillates down to a steady state over a few microseconds.

Finally, here's a plot with a 10uF electrolytic capacitor across the power lines:

You can see that the rising edge is super-smooth as the capacitor provides all the necessary power without the big pull from the power supply.

You learn something every day!

Bouncing Ball with a Newhaven Display 160x128 RGB OLED

paul.nospam@nospam.sqlskills.com (paul) — Sat, 04 Feb 2017 14:52:00 -0800

Wow - it's been more than 6 years since I had some serious time to play with electronics and blogged here! Life and work just got in the way.

After spending about a week sorting out my desk/lab area, arranging everything nicely and taking stock of all the kits, boards, components and tools I've got, I'm ready to start playing and blogging again.

The first thing I decided to play with is an Arduino shield from Newhaven Display that has one of their 1.69-inch 160x128 RGB OLED display modules. It cost $50.95 and I ordered it directly from them here.

It's a really nice looking board and I got it working very quickly using the example sketch they've posted on GitHub here. When you compile and upload the sketch, this is the result:

I figured I'd play around with it so decided to write a classic bouncing ball zipping around the screen. I figured out how to use their interface, ripped out all the superfluous code from the example, and got it working.

You can see a very short YouTube video of it in action here.

And below is the code.

Enjoy!

//---------------------------------------------------------
//---------------------------------------------------------
/*
Newhaven_Bounce
Adapted from Newhaven example code
*/
//---------------------------------------------------------
// The 8 bit data bus is connected to PORTD[7..0]
#define   SDI_PIN   11    // SDI (serial mode) signal connected to pin 11
#define   SCL_PIN   13    // SCL (serial mdoe) signal connected to pin 13
#define    RS_PIN    4    // RS signal connected to pin 4
#define   RES_PIN   6     // /RES signal connected to pin 6
#define    CS_PIN   5     // /CS signal connected to pin 5
#define    PS_PIN   A0    // PS signal connected to pin A0
#define   CPU_PIN   A1    // CPU signal connected to pin A1
#define   LVL_DIR   A2    // DIR (direction control) signal of level shifter IC connected to pin A2
#define   LVL_OEN   A3    // /OE (output enable) signal of level shifter IC connected to pin A3
#define    RED  0x0000FF
#define  GREEN  0x00FF00
#define   BLUE  0xFF0000
#define  WHITE  0xFFFFFF
#define  BLACK  0x000000
/*********************************/
/****** LOW LEVEL FUNCTIONS ******/
/************* START *************/
/*********************************/
// Send command to OLED
void OLED_Command_160128RGB (unsigned char c)
{
unsigned char i;
unsigned char mask = 0x80;
digitalWrite (CS_PIN, LOW);
digitalWrite (RS_PIN, LOW);
for(i = 0; i < 8; i++)
{
digitalWrite (SCL_PIN, LOW);
if((c & mask) >> 7 == 1)
{
digitalWrite (SDI_PIN, HIGH);
}
else
{
digitalWrite (SDI_PIN, LOW);
}
digitalWrite (SCL_PIN, HIGH);
c = c << 1;
}
digitalWrite (CS_PIN, HIGH);
} // OLED_Command_160128RGB
// Send data to OLED
void OLED_Data_160128RGB (unsigned char d)
{
unsigned char i;
unsigned char mask = 0x80;
digitalWrite (CS_PIN, LOW);
digitalWrite (RS_PIN, HIGH);
for(i = 0; i < 8; i++)
{
digitalWrite (SCL_PIN, LOW);
if((d & mask) >> 7 == 1)
{
digitalWrite (SDI_PIN, HIGH);
}
else
{
digitalWrite (SDI_PIN, LOW);
}
digitalWrite (SCL_PIN, HIGH);
d = d << 1;
}
digitalWrite (CS_PIN, HIGH);
} // OLED_Data_160128RGB
// Serial write for pixel data
void OLED_SerialPixelData_160128RGB (unsigned char d)
{
unsigned char i;
unsigned char mask = 0x80;
digitalWrite (CS_PIN, LOW);
digitalWrite (RS_PIN, HIGH);
for(i = 0; i < 6; i++)
{
digitalWrite (SCL_PIN, LOW);
if ((d & mask) >> 7 == 1)
{
digitalWrite (SDI_PIN, HIGH);
}
else
{
digitalWrite (SDI_PIN, LOW);
}
digitalWrite (SCL_PIN, HIGH);
d = d << 1;
}
digitalWrite (CS_PIN, HIGH);
} // OLED_SerialPixelData_160128RG
// Write to RAM command
void OLED_WriteMemoryStart_160128RGB (void)
{
OLED_Command_160128RGB (0x22);
} // OLED_WriteMemoryStart_160128RGB
// Write one pixel of a given color
void OLED_Pixel_160128RGB (unsigned long color)
{
OLED_SerialPixelData_160128RGB (color >> 16);
OLED_SerialPixelData_160128RGB (color >> 8);
OLED_SerialPixelData_160128RGB (color);
}
// Set x,y pixel address
void OLED_SetPosition_160128RGB (unsigned char x_pos, unsigned char y_pos)
{
OLED_Command_160128RGB (0x20);
OLED_Data_160128RGB (x_pos);
OLED_Command_160128RGB (0x21);
OLED_Data_160128RGB (y_pos);
} // OLED_SetPosition_160128RGB
// Fill screen with a given color
void OLED_FillScreen_160128RGB (unsigned long color)
{
unsigned int i;
OLED_SetPosition_160128RGB (0, 0);
OLED_WriteMemoryStart_160128RGB ();
for(i = 0; i < 20480; i++)
{
OLED_Pixel_160128RGB(color);
}
} // OLED_FillScreen_160128RGB
/*===============================*/
/*===== LOW LEVEL FUNCTIONS =====*/
/*============= END =============*/
/*===============================*/
/*********************************/
/******** INITIALIZATION *********/
/************ START **************/
/*********************************/
// OLED initialization
void OLED_Init_160128RGB (void)
{
digitalWrite (RES_PIN, LOW);
delay (2);
digitalWrite (RES_PIN, HIGH);
delay (2);
// Display off, analog reset
OLED_Command_160128RGB (0x04);
OLED_Data_160128RGB (0x01);
delay (1);
// Normal mode
OLED_Command_160128RGB (0x04); 
OLED_Data_160128RGB (0x00); 
delay (1);
// Display off
OLED_Command_160128RGB (0x06);
OLED_Data_160128RGB (0x00);
delay (1);
// Turn on internal oscillator using external resistor
OLED_Command_160128RGB (0x02);
OLED_Data_160128RGB (0x01); 
// 90 hz frame rate, divider 0
OLED_Command_160128RGB (0x03);
OLED_Data_160128RGB (0x30); 
// Duty cycle 127
OLED_Command_160128RGB (0x28);
OLED_Data_160128RGB (0x7F);
// Start on line 0
OLED_Command_160128RGB (0x29);
OLED_Data_160128RGB (0x00); 
// rgb_if
OLED_Command_160128RGB (0x14);
OLED_Data_160128RGB (0x31); 
// Set Memory Write Mode
OLED_Command_160128RGB (0x16);
OLED_Data_160128RGB (0x76);
// Driving current r g b (uA)
OLED_Command_160128RGB (0x10);
OLED_Data_160128RGB (0x45);
OLED_Command_160128RGB (0x11);
OLED_Data_160128RGB (0x34);
OLED_Command_160128RGB (0x12);
OLED_Data_160128RGB (0x33);
// Precharge time r g b
OLED_Command_160128RGB (0x08);
OLED_Data_160128RGB (0x04);
OLED_Command_160128RGB (0x09);
OLED_Data_160128RGB (0x05);
OLED_Command_160128RGB (0x0A);
OLED_Data_160128RGB (0x05);
// Precharge current r g b (uA)
OLED_Command_160128RGB (0x0B);
OLED_Data_160128RGB (0x9D);
OLED_Command_160128RGB (0x0C);
OLED_Data_160128RGB (0x8C);
OLED_Command_160128RGB (0x0D);
OLED_Data_160128RGB (0x57);
// Set Reference Voltage Controlled by External Resister
OLED_Command_160128RGB (0x80);
OLED_Data_160128RGB (0x00);
// Mode set
OLED_Command_160128RGB (0x13);
OLED_Data_160128RGB (0xA0);
// Set column address start + end
OLED_Command_160128RGB (0x17);
OLED_Data_160128RGB (0);
OLED_Command_160128RGB (0x18);
OLED_Data_160128RGB (159);
// Set row address start + end
OLED_Command_160128RGB (0x19);
OLED_Data_160128RGB (0);
OLED_Command_160128RGB (0x1A);
OLED_Data_160128RGB (127);
// Display On
OLED_Command_160128RGB (0x06);
OLED_Data_160128RGB (0x01); 
}
/*===============================*/
/*======= INITIALIZATION ========*/
/*============= END =============*/
/*===============================*/
void setup ()
{
pinMode (LVL_OEN, OUTPUT);      // configure LVL_OEN as output
digitalWrite (LVL_OEN, LOW);
pinMode (LVL_DIR, OUTPUT);      // configure LVL_DIR as output
digitalWrite (LVL_DIR, HIGH);
DDRD = 0xFF;                    // configure PORTD as output
pinMode (RS_PIN, OUTPUT);       // configure RS_PIN as output
pinMode (RES_PIN, OUTPUT);      // configure RES_PIN as output
pinMode (CS_PIN, OUTPUT);       // configure CS_PIN as output
pinMode (PS_PIN, OUTPUT);       // configure PS_PIN as output
pinMode (CPU_PIN, OUTPUT);      // configure CPU_PIN as output
digitalWrite (LVL_OEN, LOW);
digitalWrite (CS_PIN, HIGH);    // set CS_PIN
pinMode (SDI_PIN, OUTPUT);      // configure SDI_PIN as output
pinMode (SCL_PIN, OUTPUT);      // configure SCL_PIN as output
PORTD = 0x00;                   // reset SDI_PIN and SCL_PIN, ground DB[5..0] of the display
digitalWrite (PS_PIN, LOW);     // reset PS_PIN
Serial.begin (57600);
}
void loop()
{
// Initialize the display
OLED_Init_160128RGB();
// Emtpy the screen
OLED_FillScreen_160128RGB(BLACK);
unsigned int xPosition = 0;
unsigned int yPosition = 0;
int xDirection = 1;
int yDirection = 1;
// Bouncing ball
while (1)
{
Serial.print (xPosition, DEC);
Serial.print (", ");
Serial.println (yPosition, DEC);
OLED_SetPosition_160128RGB (xPosition, yPosition);
OLED_WriteMemoryStart_160128RGB ();
OLED_Pixel_160128RGB (WHITE);
if (xPosition == 0)
{
xDirection = 1;
}
else if (xPosition == 159)
{
xDirection = -1;
}
if (yPosition == 0)
{
yDirection = 1;
}
else if (yPosition == 127)
{
yDirection = -1;
}
delay (10);
OLED_SetPosition_160128RGB (xPosition, yPosition);
OLED_WriteMemoryStart_160128RGB ();
OLED_Pixel_160128RGB (BLACK);
xPosition += xDirection;
yPosition += yDirection;  
}
}

Kit building: vacuum fluorescent display clock

paul.nospam@nospam.sqlskills.com (paul) — Sat, 18 Dec 2010 14:51:00 -0800

I've always been intrigued by vacuum fluorescent displays (VFDs) so I picked up the Ice Tube Clock Kit from AdaFruit Industries that uses a Russian VFD tube.

(Click any photo for a 1024x768 image.)

Here's what came in the kit:

And here are a couple of shots of the VFD tube. It has 8 x 7-segment digits, with decimal points and a minus sign.

There's a great page on AdaFruit's website that describes the circuit and the calculations that went into designing it - check it out!

The building instructions are very thorough, as always, and this time includes test points as building progresses. On the left is a shot of testing the 7805 regulator, and on the right is testing the voltage booster circuit for the VFD.

Once I had the main board made, it was time to thread the VFD into it's PCB. This was a finnicky task but with patience it only took 15 minutes. The leads from the VFD bend very easily, which is a blessing and a curse. On the left you can see what I mean, and on the right I've got it ready to solder.

And here's it soldered and nicely clipped.

Did a quick test and it worked! Then I put in the final few components on the main board and assembled the laser-cut perspex case.

Here are a couple of shots of the completed main PCB:

And the clock itself... and in it's final resting place.

Hope you enjoyed the photos - let me know if these kinds of posts are interesting!

More Arduino shields to play with...

paul.nospam@nospam.sqlskills.com (paul) — Sat, 18 Dec 2010 12:14:00 -0800

It's been quite a while since I've had bandwidth to sit down and get stuck into electronics again, but now I'm home for almost two months, so I'll be blogging more on here.

Over the last few months I've discovered some new Arduino shields to play with and ordered them up. Here's what I got:

1) The Wingshield Screwshield kit from Adafruit Industries. Took me about 5 minutes to solder together.

2) The Motor/Stepper/Servo Shield kit from Adafruit Industries. Took me about 1/2 hour to solder together.

3) The Arduino Ethernet Shield with micro SD connector. This comes assembled and I got it from SparkFun Electronics.

4) The WiShield from async_labs that provides 802.11b wireless. This also comes assembled.

5) The Joystick Shield Kit from SparkFun Electronics. Took about 15 minutes to solder together.

6) The Color LCD Shield from SparkFun Electronics. This just needed the headers soldered on.

Lots of potential for tinkering and cool stuff here!

Kit building: Four interactive light panels connected together

paul.nospam@nospam.sqlskills.com (paul) — Sat, 02 Oct 2010 07:24:00 -0800

Well, summer's over and that means I can justify being indoors playing with (and blogging about) electronics again. Expect this blog to get busy again!

Back in March I blogged about building an interactive light panel from Evil Mad Science Laboratories. Over the summer I built the other three light panel kits I'd ordered and finally got around to hooking them together and testing them out.

They fit together using 8-pin connectors in any configuration imaginable. Below are two photos of the connectors (borrowed from their website):

Below are three photos showing my four panels in a variety of configurations (click for larger versions):

Finally, I shot some short videos showing the 1 x 4 configuration in action:

http://www.youtube.com/watch?v=28PRAPQeaes (in daylight)
http://www.youtube.com/watch?v=iOIx_0jYDlE (in darkness - very cool!)

Next up will be some more Arduino stuff...

Kit building: Evil Mad Science interactive light board

paul.nospam@nospam.sqlskills.com (paul) — Fri, 12 Mar 2010 12:53:00 -0800

It's been another few weeks of traveling and client work so I haven't had any chance to tinker. Apologies to those subscribers expecting the frenetic pace of my SQL blog - ain't gonna happen. I'm at home for a few weeks now though, so should have spare cycles to get back to the Arduino.

This week I decided to build a kit, as I didn't have time to get stuck into something more intellectually challenging. A while ago I'd ordered a set of 4 interactive light panel kits from Evil Mad Science so I chose to make one of those (I've also got an RGB Peggy 2 board that I'm itching to make!).

I'm very impressed with the kit - the instructions are *excellent* - totally suitable for a novice, but easily digestable by someone more advanced without being annoyingly simple. The packaging is great too - with all components packed and labeled separately - not something I expect, but a nice time saver.

The kit took me about 4 hours of soldering and neat lead-snipping to put together. I powered it on and it worked first time. However, it's supposed to work in the dark and I couldn't get anything out of it. The board looked perfectly put together so I contacted Evil Mad Science. Windell replied within 90 minutes with some suggestions. I replied that I've got a degree in electronics so talk techie - smileys ensued and we troubleshooted (troubleshot?). I'd hooked up a spare IR LED and shown that the phototransistors were working, but obviously the IR LEDs on the board weren't - with only about 10mV foward voltage across each. The whole IR LED circuit has 24V through it, so something was sucking down the power. I traced it to a broken IR LED with very high resistance both ways, and taking 18V - no wonder it wasn't working. I swapped out the broken LED and put in another, and hey presto! Great technical support!

Great kit to put together and I'm going to build a wall tile to hang in the house somewhere!

Here's a link to a 25sec video I shot on YouTube: http://www.youtube.com/watch?v=51dUYjEgTi8

Here are some photos (click for larger images):

Left: kit contents for one board. Right: PCB (*really* well produced).

Left: ready to start soldering. Right: Completed board ready for testing.

Arduino: Windows simulator of driving matrices of 8x8 LED arrays

paul.nospam@nospam.sqlskills.com (paul) — Wed, 17 Feb 2010 08:32:00 -0800

It's been a couple of weeks since I've been able to play hands-on with electronics because I've been busy with client work and out-of-town traveling.

To continue satisfying my must-be-tinkering-with-something urges, I hit upon the idea of using some old Windows code I had lying around to allow me to program LED matrices, without the LED matrices or an Arduino. This means I can effectively be developing code for the Arduino while on the road (we travel around 50% of the year seeing our clients around the world). The old code was for a life simulator (creatures running around fighting, breeding, etc) but it had all the code to display a bitmap on screen and update it already worked out. I figured that I could use it to simulate an 8x8 LED matrix - so off I went.

What it turned into is a couple of classes that simulate a maze and an 8x8, 16x16, or 32x32 LED display. I thought the code would be useful to a bunch of you so I've zipped it up for you to download and play with. The cool thing is that I can work on the maze processing code while on the road and then come home and drop it into the Arduino environment to compile and use. As long as I have LED matrix driving code on the Arduino, it should work like a charm.

Here's a screenshot of the simulator running:

Black 'dots' are on LEDs, spaces are off LEDs, the lighter colored dot is supposed to be a different color LED to represent a person. The simulator can switch between 8x8, 16x16, and 32x32 displays by pressing the Page Up and Page Down keys. Movement is through the arrow keys. The display mode can either be static with screen changes when the person crosses a window border (i.e. the person moves around on the screen) or scrolling, where the person stays still and the maze moves around. Pressing S switches between the two modes.

The code is in a zip file: Maze021710.zip (12.1k) and I've been using VS 2005 Professional to develop and debug.

There are plenty of comments in the code and I'm happy to answer questions about it.

Enjoy!

Arduino: cascading shift registers to drive 7-segment displays with PC input

paul.nospam@nospam.sqlskills.com (paul) — Sun, 31 Jan 2010 15:33:00 -0800

In the last post I figured out how to drive a 74HC595 shift register to control 8 LEDs from only 3 digital outputs of the Arduino. Now I've taken that a step further and cascaded (sometimes called daisy-chained) four 595s together to drive 7-segment displays and also added code to accept input from the PC.

Instead of using 10-LED bar graphs like I did last time, I've moved on to 7-segment displays - which are more challenging and provide a more meaningful output. The 7-segment displays I have are common-cathode, wired as shown below:

    a           a - pin 14       dp (decimal point) - pin 9
   ---          b - pin 13       common cathode - pins 12 and 4
f |   | b       c - pin 8
   --- g        d - pin 7
e | | c       e - pin 6
   --- . dp     f - pin 2
    d           g - pin 1

The code to illuminate decimal digits on a 7-segment display is pretty straightforward. I assigned each of the 7 segment-pins on the display to an output on the 595, from QA through QG (see the circuit diagram below). Each pin from QA to QG is assigned a binary value of 2 ^ pin#, so figuring out which pins to make high to produce each decimal digit is just a matter of adding together the binary values representing each pin necessary to light up the right segments. You can see this array being initialized in the setup() function.

I've also moved to a proper coding style, with g_ prefixing each global variable to distinguish them from local variables inside functions and methods. It's a good practice to define unchanging variables as const to allow the compiler to optimize the code around them - this also prevents mistakes where the code accidentally tries to change the value - the compiler won't allow it as the variable is effectively read-only and a difficult-to-debug bug is avoided.

To daisy-chain 595s together is really simple - connect the serial output (pin 9) of the 'lowest' 595 to the serial input (pin 14) of the next one in the chain, and connect all the latch (pin 12) and clock (pin 11) inputs together. When the first 595 accepts a new bit, the highest bit in the register will be pushed out of it's serial line as input to the next 595 in the chain. Enough bits must be pushed to fill all the 595s with new data correctly. In the previous post I only had a single 595 so I only had to push 8 bits of data from the Arduino. With two 595s I need to push 16 bits, with the first 8 bits effectively flowing through the first 595 and into the second. And so on with more 595s in the chain.

Care must be taken to push the 8-bit values in the correct order - the 8 bits for the 595 furthest from the Arduino must be pushed first, and the 8 bits for the 595 nearest the Arduino in the chain must be pushed last. I do this in the code in the sendSerialData() function by passing in the number of registers in use, plus a pointer to an array of bytes. Each element in the array has the byte to be pushed to the corresponding register - with the highest register number the furthest away from the Arduino. The code then iterates backwards through the away, pushing each byte in succession.

Rather than doing the obvious count-from-0-to-9999 code, I decided to figure out how to read input from the PC. This is done in the readNumberFromPC() function. If it detects that something has been sent from the PC, it reads each character, with a 10ms delay between each character read to ensure that all characters are received from the PC. Without the delay, the Arduino executes so fast that it may read the first character from the input stream, try again, and the next character hasn't made it over the slow (compared to the Arduino!) link from the PC - resulting in the input being chopped into two parts. This delay doesn't cause a problem with the 595s as their outputs are latched, and so stay the way they were set until the next update - preventing any display flickering.

In the loop() function, the logic to put the correct digit-byte in the register array is hard-coded. In the next rev I'll make this register-count agnostic.

As far as the circuit is concerned, I've got one 220ohm resistor on each 7-segment common cathode going to ground, which produces a bright enough display. I've also added a 100nF decoupling capacitor on the Vcc pin of each 595 to forestall any noise problems.

The complete circuit diagram is as below (click for a larger version):

Here's the breadboard layout, with a close up of IC2 (click for larger versions):

Once I'd figured out the wiring for one of the displays, adding the other three was pretty easy. At this point I ran out of 595s so I couldn't take the experiment any further, but I do have a bunch more on the way from Jameco.

I took a short (40s) video of the board in action - check it out here on YouTube.

And all the code is below(to download as a text file click here). Drop me a comment if you find this stuff useful!

[Edit: 12/19/10 - here's a link to someone who built a clock based on my code below.]

Next up - replacing some of the shift registers with transistors to allow a bigger fan-out from the Arduino.

/*
Driving multiple 7-seg displays with 74HC595 shift registers.

Feel free to re-use.

   01/30/2010
*/

// This pin gets sets low when I want the 595s to listen
const int g_pinCommLatch = 6;

// This pin is used by ShiftOut to toggle to say there's another bit to shift
const int g_pinClock     = 7;

// This pin is used to pass the next bit
const int g_pinData    = 4;

// Definitions of the 7-bit values for displaying digits
byte g_digits [10];

// Current number being displayed
int g_numberToDisplay = 0;

// Number of shift registers in use
const int g_registers = 4;

// Array of numbers to pass to shift registers
byte g_registerArray [g_registers];

void setup()
{
pinMode (g_pinCommLatch, OUTPUT);
pinMode (g_pinClock, OUTPUT);
pinMode (g_pinData, OUTPUT);

Serial.begin (56600);

// Setup the digits array
// a = 8 b = 4 c = 2 d = 64 e = 32 f = 1 g = 16
g_digits [0] = 8 + 4 + 2 + 64 + 32 + 1;
g_digits [1] = 4 + 2;
g_digits [2] = 8 + 4 + 16 + 32 + 64;
g_digits [3] = 8 + 4 + 16 + 2 + 64;
g_digits [4] = 1 + 16 + 4 + 2;
g_digits [5] = 8 + 1 + 16 + 2 + 64;
g_digits [6] = 8 + 1 + 16 + 2 + 64 + 32;
g_digits [7] = 8 + 4 + 2;
g_digits [8] = 8 + 4 + 2 + 64 + 32 + 1 + 16;
g_digits [9] = 8 + 4 + 2 + 1 + 16 + 64;
} // setup

// Simple function to send serial data to one or more shift registers by iterating backwards through an array.
// Although g_registers exists, they may not all be being used, hence the input parameter.
void sendSerialData (
byte registerCount, // How many shift registers?
byte *pValueArray)   // Array of bytes with LSByte in array [0]
{
// Signal to the 595s to listen for data
digitalWrite (g_pinCommLatch, LOW);

for (byte reg = registerCount; reg > 0; reg--)
{
    byte value = pValueArray [reg - 1];

    for (byte bitMask = 128; bitMask > 0; bitMask >>= 1)
    {
      digitalWrite (g_pinClock, LOW);

      digitalWrite (g_pinData, value & bitMask ? HIGH : LOW);

      digitalWrite (g_pinClock, HIGH);
    }
}
// Signal to the 595s that I'm done sending
digitalWrite (g_pinCommLatch, HIGH);
} // sendSerialData

// Print a message specifying valid inputs, given the number of registers defined and then consume all current input.
void badNumber ()
{
int dummy;

Serial.print ("Please enter a number from 0 to ");
for (int loop = 0; loop < g_registers; loop++)
{
    Serial.print ("9");
}
Serial.println (" inclusive.");

while (Serial.available () > 0)
{
    dummy = Serial.read ();

    // Necessary to get all input in one go.
    delay (10);
}
} //badNumber

// Read a number from the PC with no more digits than the defined number of registers.
// Returns: number to display. If an invalid number was read, the number returned is the current number being displayed
//
int readNumberFromPC ()
{
byte incomingByte;
int numberRead;
byte incomingCount;

if (Serial.available () > 0)
{
    numberRead = 0;
    incomingCount = 0;

    while (Serial.available () > 0)
    {
      incomingByte = Serial.read () - 48;
      incomingCount++;

      if (incomingByte < 0 || incomingByte > 9 || incomingCount > g_registers)
      {
        badNumber ();
        return g_numberToDisplay;
      }

      numberRead = 10 * numberRead + incomingByte;

      // Necessary to get all input in one go.
      delay (10);
    }

    Serial.print ("Now displaying: ");
    Serial.println (numberRead, DEC);

    return numberRead;
}

return g_numberToDisplay;
} // readNumberFromPC

void loop()
{
g_numberToDisplay = readNumberFromPC ();

if (g_numberToDisplay < 10)
{
    g_registerArray [3] = g_digits [0];
    g_registerArray [2] = g_digits [0];
    g_registerArray [1] = g_digits [0];
    g_registerArray [0] = g_digits [g_numberToDisplay];
}
else if (g_numberToDisplay < 100)
{
    g_registerArray [3] = g_digits [0];
    g_registerArray [2] = g_digits [0];
    g_registerArray [1] = g_digits [g_numberToDisplay / 10];
    g_registerArray [0] = g_digits [g_numberToDisplay % 10];
}
else if (g_numberToDisplay < 1000)
{
    g_registerArray [3] = g_digits [0];
    g_registerArray [2] = g_digits [g_numberToDisplay / 100];
    g_registerArray [1] = g_digits [(g_numberToDisplay % 100) / 10];
    g_registerArray [0] = g_digits [g_numberToDisplay % 10];
}
else
{
    g_registerArray [3] = g_digits [g_numberToDisplay / 1000];
    g_registerArray [2] = g_digits [(g_numberToDisplay % 1000) / 100];
    g_registerArray [1] = g_digits [(g_numberToDisplay % 100) / 10];
    g_registerArray [0] = g_digits [g_numberToDisplay % 10];
}

sendSerialData (g_registers, g_registerArray);
} // loop

Arduino: figuring out shift registers

paul.nospam@nospam.sqlskills.com (paul) — Thu, 28 Jan 2010 10:35:00 -0800

One of the parts that makes possible the scrolling message kit I built over the weekend (see Kit building: Hansen Hobbies mini-scrolling LED sign kit) is a shift register. This is a very neat device that uses at least 2 inputs to load 8 parallel outputs. The idea is to pulse a clock input for each bit of data in the 8-bit register, loading each bit in succession until all 8 bits have been loaded. The shift registers in the kit I made are 74HC164s, which means that the outputs immediately go high or low to relfect the bits as they're loaded into the shift register and shifted along into their desired positions. Many people prefer a latched shift register, where the outputs reflect a steady-state of the register until all 8 new bits have been loaded, and then the outputs change to the new bits in the register (i.e the latched register has two registers - a true shift register and a storage register).

The simple algorithm to load a latched shift-register is:

pull the latch pin low

pull the clock pin low
pull the data pin high or low to reflect bit 1
pull the clock pin high

<repeat for bits 2 through 8>

pull the latch pin high

It's up to you whether you load the 8-bit value as MSB (most-significant-bit) first or LSB (least-significant-bit) first - you'll soon work out if you've got it the wrong way around!

I'm going to use a 74HC595 shift register that can source 35mA per output - perfect for driving the LEDs in my 10-bar LED arrays.

There are two ways to implement the logic above - using the Arduino shiftOut function or writing one yourself. I played around with both to make sure I fully understood what's going on - and I like bit-twiddling in C/C++. The Arduino site has a good language reference on shiftOut (see here) and also a tutorial on using the 74HC595 (see here). I decided to figure out how to use the chip myself so I internalized how to do it in future - but I'm not trying to be a purist and re-inventing the wheel.

The circuit is pretty simple - remember to pull the OutputEnable (active low) pin low and the MemoryClear (active low) pin high.

And a photo (click for larger image):

The code I used is below, with the two different functions to push data out to the shift register. I had a problem with the code where I originally had the counter variable in the loop() function as a byte and the LEDs counted to the end and then stopped. I put in the serial output to do some testing and connected up with Windows HyperTerminal - so much easier to do it with this than when trying to debug code I'd written in the storage engine of SQL Server :-) Of course as soon as the counter value reached 256, it overflowed and was stored as 0, so no more LEDs being lit up. If you do this, don't forget to hangup before trying to upload a sketch to the Arduino otherwise it won't be able to grab the COM port.

Here's the code:

/*
Driving a 74HC595 shift register

   01/27/2010
*/

// This pin gets sets low when I want the 595 to listen
const int pinCommLatch = 2;

// This pin is used by ShiftOut to toggle to say there's another bit to shift
const int pinClock     = 3;

// This pin is used to pass the next bit
const int pinData    = 4;

void setup()
{
pinMode (pinCommLatch, OUTPUT);
pinMode (pinClock, OUTPUT);
pinMode (pinData, OUTPUT);

//Serial.begin (56600);
} // setup

// Using the builtin shiftOut function
void sendSerialData1 (
byte value)
{
// Signal to the 595 to listen for data
digitalWrite (pinCommLatch, LOW);

shiftOut (pinData, pinClock, MSBFIRST, value);

// Signal to the 595 that I'm done sending
digitalWrite (pinCommLatch, HIGH);
} // sendSerialData1

// Using my own method with as few instructions as possible
// Gotta love C/C++ for bit-twiddling!
void sendSerialData2 (
byte value)
{
// Signal to the 595 to listen for data
digitalWrite (pinCommLatch, LOW);

for (byte bitMask = 128; bitMask > 0; bitMask >>= 1)
{
    digitalWrite (pinClock, LOW);

    digitalWrite (pinData, value & bitMask ? HIGH : LOW);

    digitalWrite (pinClock, HIGH);
}

// Signal to the 595 that I'm done sending
digitalWrite (pinCommLatch, HIGH);
} // sendSerialData2

void loop()
{
for (int counter = 1; counter < 256; counter++)
{
    sendSerialData2 (counter);

    delay (75);
}
} // loop

I recorded a quick video of the code above driving the 595 to get the LEDs to count from 1 to 255 in binary - checkout it on YouTube here.

Next up - daisy-chaining multiple shift-registers.