9 Pieces of Pi: Slice 3: Trickle Down to the Brave New World (This Way!)

Introduction

Another piece involving LEDs. This time I chose some small SOT23 amber ones.

The Work

Here it is on a small table in my workroom.

The following video shows it working.

Edit media

Dimensions x Small Medium Large Custom

Subject (required) Brief Description Tags (separated by comma) Video visibility in search results Visible Hidden

Parent content

9 Pieces of Pi: Slice 3: Trickle Down to the Brave New World (This Way!)

Poster

Upload Preview

Ok

Cancel

At the start I was going to have it as another canvas on the wall but, as it gradually developed, it went through

a phase where I was going to have the grid of LEDs sitting in a preservative jar, but I didn't entirely like that

either so it finally ended up as this free-standing kind of 'ship' idea. That's art for you!

The rolling flicker, that you see partway through the video, isn't apparent in real life. The matrix is scanned and

is interacting with the electronic shutter of the camera's video sensor. Unfortunately, the video also makes the

LEDs look very much brighter than they appear to the eye.

The Technical Stuff

Here's the circuit diagram.

The circuit is a bit messy (too many components) and could be greatly simplified. When I started this challenge

I decided I'd try and recycle old parts I've got lying around, rather than just keep buying new stuff, but it does

mean that some of this design is getting a bit convoluted. The shift registers keep appearing because I have

several tubes of them (they were originally excess parts for products manufactured about 25 years ago that

were kept as spares and which I later rescued from going into an electrical-waste skip. I looked them up on

TI's website and, amazingly, they still make them; probably because they had an automotive use).

Rather than try and drive 36 LEDs using GPIO lines, the LEDs are arranged in a 6x6 matrix, with 6 columns

and 6 rows. The drivers to those rows and columns are, in turn, controlled by shift register outputs, thus

reducing the GPIO count to four. I'm going to have a 1:6 multiplex on the columns and present the data on

the rows. When I experimented with a single LED I found I needed about 10mA to get the illumination I wanted

for a reasonable 'dot' on the paper. That means the row drive will need to work at something like 60mA

[in order to average 10mA] and the column drive will need to cope with up to 360mA [if all 6 LEDs are on].

Because I didn't have a good option handy for driving the 360mA if I put it on the high side, and the shift

register isn't quite rated for doing it if I did it on the low side, I decided to put BS170 MOSFETs on the low

side for the 360mA and 2N3906 transistors on the high side for the row drive since I have plenty of both.

For the level-conversion up from the Pi's 3.3V GPIO pins to the shift register 5V CMOS inputs, this time

around I experimented with using BSS138 MOSFETs in a common-gate configuration (similar to a

cascode-type arrangement) where the MOSFET shields the Pi from the 5V. The BSS138 parts are in a

surface-mount SOT23 package but they're very easy to work with and there's no problem soldering them

with an ordinary soldering iron. [Although it worked adequately for the piece, the output waveforms aren't

ideal. They stall momentarily around the 3V point.]

Here's the interface board as I've built it on a small prototyping board with the wiring done with wire-wrap

wire soldered to the pads.

For the display part, I super-glued the LEDs down to a piece of fairly heavy cartridge paper. They actually

face down towards the paper, so the pixel is formed by the light that gets reflected back up through the

body and what spills out the sides. Visually, it was much more comfortable to look at than having the very

bright dot of light from the die directly visible.

Here they are, glued to the paper, before the wiring was done.

The paper was then glued to part of a chop-stick, which acts as the mast, and strands of wire from a stranded

cable were used to wire the matrix to the drive parts on the circuit board.

The Code

Once I had the hardware built and working, I needed to come up with some code. Again I've used Python. That

probably isn't a particularly good decision, given that it needs reasonably accurate timing, but I'm really pushed

for time here and so this is the point where 'good design' flies out the window and 'whatever works' is now the

order of the day. In practice it worked surprisingly well, with the only noticeable blemishes coming when the Pi

starts doing network stuff (whenever the network connector LED flashes, the display stutters).

Here's the code. I won't go through it in detail - hopefully it's fairly understandable. Getting the right LEDs to light

up, when I wanted them to, took a few iterations of the code but it's very easy to debug something when you can

literally see the results of what you're doing displayed in front of you.

# Trickle-Down (slice3.py)
import time
import RPi.GPIO as GPIO
import random
# set GPIO direction for pins we are using to output
GPIO.setmode(GPIO.BCM)
GPIO.setup(18,GPIO.OUT) #clock
GPIO.setup(4,GPIO.OUT) #latch
GPIO.setup(15,GPIO.OUT) #data
GPIO.setup(14,GPIO.OUT) #enable
# set them to appropriate start levels
GPIO.output(18,False)
GPIO.output(4,False)
GPIO.output(15,False)
GPIO.output(14,True)
# set up the frame store
displayStore = [[True,False,False,False,False,False,True,True],
[False,False,False,False,False,False,True,True],
[False,False,False,False,False,False,True,True],
[False,False,False,False,False,False,True,True],
[False,False,False,False,False,False,True,True],
[False,False,False,False,False,False,True,True],
[True,True,True,True,True,True,True,True,True],
[True,True,True,True,True,True,True,True,True]]
# start off with something sensible and in range in variables
fillFrame = True
currentRow = 0
currentCol = 0
nextRow = 0
nextCol = 0
displayCol = 5
frameCount = 0
floodCount = 0
testCount = 0
def outputToShiftRegisters(displayStore,displayCol):
  #two more dummy bits
  GPIO.output(18,True) # shift clock high
  GPIO.output(18,False) # shift clock low
  GPIO.output(18,True) # shift clock high
  GPIO.output(18,False) # shift clock low
  #then the column data
  for x in range(0,6): # do for the 6 bits of col data
    if x == displayCol: #set up data
      GPIO.output(15,True)
    else:
      GPIO.output(15,False)
    GPIO.output(18,True) # shift clock high
    GPIO.output(18,False) # shift clock low
  #two dummy bits
  GPIO.output(18,True) # shift clock high
  GPIO.output(18,False) # shift clock low
  GPIO.output(18,True) # shift clock high
  GPIO.output(18,False) # shift clock low
  #then the row data
  for x in range(0,6): # do for the 6 bits of row data
    if displayStore[5-x][displayCol] == False:
      GPIO.output(15,True)
    else:
      GPIO.output(15,False)
    GPIO.output(18,True) # shift clock high
    GPIO.output(18,False) # shift clock low
  #disable output drive, latch outputs, then re-enable
  GPIO.output(14,True) #enable low (s/r outputs off)
  GPIO.output(4,True) # register clock high
  GPIO.output(4,False) # register clock low
  GPIO.output(14,False) #enable high (s/r outputs back on)
  return
# main loop of the program
while testCount < 100000:
  #wait for 2ms (gives 83Hz refresh on LEDs)
  time.sleep(0.002)
  #update column count
  displayCol = displayCol + 1
  if displayCol > 5:
    displayCol = 0
    #ready to draw next frame?
    if frameCount > 39:
      frameCount = 0
      if fillFrame == True: # True, so state is trickling down
        displayStore[currentRow][currentCol] = False
        if (displayStore[currentRow + 1][currentCol] == False) and (displayStore[currentRow][currentCol + 1] == False):
          if (random.randint(0,100) > 50):
            currentRow = currentRow + 1
          else:
            currentCol = currentCol + 1
        else:
          if (displayStore[currentRow + 1][currentCol] == False) and (displayStore[currentRow][currentCol + 1] == True):
            currentRow = currentRow + 1
          else:
            if (displayStore[currentRow + 1][currentCol] == True) and (displayStore[currentRow][currentCol + 1] == False):
              currentCol = currentCol + 1
            else:
              if (displayStore[currentRow][currentCol + 1] == True) and (displayStore[currentRow + 1][currentCol] == True):
                displayStore[currentRow][currentCol] = True
                if (currentRow == 0) and (currentCol == 0):
                  fillFrame = False
                  floodCount = 6
                else:
                  currentCol = 0
                  currentRow = 0
        displayStore[currentRow][currentCol] = True
      else: # False, so state is flooding up
        floodCount = floodCount - 1
        if floodCount >= 0:
          for row in range(0,6): # do for 6 rows
            for col in range(0,6): # and 6 columns
              if ((col > floodCount) or (row > floodCount)):
                displayStore[row][col] = False
              else:
                displayStore[row][col] = True
        else:
          displayStore[0][0] = True
          fillFrame = True
          currentCol = 0
          currentRow = 0
    else:
      frameCount = frameCount + 1
  outputToShiftRegisters(displayStore,displayCol)
  testCount = testCount + 1
GPIO.cleanup()

Links to the previous slices:

9 Pieces of Pi: Slice 1: The Long Way Round

9 Pieces of Pi: Slice 2: Manifesto for Art Electronic

If you are interested in my other blogging here on Element14, this link takes you to an index page where many of them are listed: jc2048 Blog Index

I'm following along with this Design Challenge as an independent participant, not as one of the challengers. I'm not entering the competition for the prizes.