MicroPython 74HC595

A MicroPython library for 74HC595 8-bit shift registers.

There's both an SPI version and a bit-bang version, each with a slightly different interface.

SPI Version

You can use either HSPI or SPI. This version is significantly faster than the bit-bang version, but is limited to writing whole bytes of data.

SPI Example

Basic Usage

from machine import Pin, SPI
from sr_74hc595_spi import SR

spi = SPI(1, 100000)
rclk = Pin(5, Pin.OUT)

oe = Pin(33, Pin.OUT, value=0)    # low enables output
srclr = Pin(32, Pin.OUT, value=1) # pulsing low clears data

sr = SR(spi, rclk, 2) # chain of 2 shift registers

sr.pin(2,1)  # set pin 2 high of furthest shift register
sr.pin(2)    # read pin 2
sr.pin(2,0)  # set pin 2 low

sr.toggle(8) # toggle first pin of closest shift register

sr[0] = 0xff # set all pins high on furthest shift register
sr[1] = 240  # set half pins high on closest shift register
sr[1]        # read pins

oe.value(0)  # disable outputs
oe.value(1)  # enable outputs

# pulse to clear shift register memory
srclr.value(1)
srclr.value(0)

SPI Methods

Construct with a reference to spi and the rclk pin used for latching and an optional number of cascading shift registers.

Pins srclr and oe are optional. If you don't need to clear the outputs, connect srclr to vcc. If you don't need to disable the outputs, connect oe to gnd.

__init__(spi, rclk, len=1, srclr=None, oe=None)

Read the boolean value of a pin. First pin is index 0. If you are cascading shift registers, the first pin of the second shift register is index 8 and so on. Index 0-7 are the furthest away shift register from the serial data in.

pin(index)

Writes a boolean value to a pin. This updates the internal buffer of pin values then writes all of the values to each shift register in the chain.

pin(index, value, latch=True)

This toggles a single pin by index. Helper for reading a pin then writing the opposite value.

toggle(index, latch=True)

This lets you treat the class like a list, where each index represents a whole shift register. Returns an 8-bit value for the shift register by index, where lowest index is furthest away.

__getitem__(index)

Write an 8-bit value to a shift register at the given index.

__setitem__(index, value)

Private method for sending the entire internal buffer over SPI.

_write(latch=False)

Private method for pulsing the rclk pin, which latches the outputs from the shift register to the storage register and makes the outputs appear.

_latch()

Bit Bang Version

This version lets you have greater control over sending individual bits of data at the expense of the performance you get using SPI.

Bit Bang Example

Basic Usage

from machine import Pin
from sr_74hc595_bitbang import SR

ser = Pin(23, Pin.OUT)
rclk = Pin(5, Pin.OUT)
srclk = Pin(18, Pin.OUT)

# construct without optional pins
sr = SR(ser, srclk, rclk)

sr.clear()  # raises RuntimeError because you haven't provide srclr pin
sr.enable() # raises RuntimeError because you haven't provide oe pin

# reconstruct with all pins
oe = Pin(33, Pin.OUT, value=0)    # low enables output
srclr = Pin(32, Pin.OUT, value=1) # pulsing low clears data

sr = SR(ser, srclk, rclk, srclr, oe)

sr.bit(1)  # send high bit, do not latch yet
sr.bit(0)  # send low bit, do not latch yet
sr.latch() # latch outputs, outputs=0000_0010

sr.bit(1, 1) # send high bit and latch, outputs=0000_0101
sr.bit(0, 1) # send low bit and latch, outputs=0000_1010

sr.bits(0xff, 4) # send 4 lowest bits of 0xff (sends 0x0f), outputs=1010_1111

sr.clear(0) # clear the memory but don't latch yet
sr.latch()  # next latch shows the outputs have been reset

sr.bits(0b1010_1010, 8) # write some bits
sr.clear()  # clear the memory and latch, outputs have been reset

sr.enable()  # outputs enabled
sr.enable(0) # outputs disabled

Bit Bang Methods

Construct with references to each of the pins needed to write to the shift register(s).

Pins ser, srclk and rclk are required. Pins srclr and oe are optional. If you don't need to clear the outputs, connect srclr to vcc. If you don't need to disable the outputs, connect oe to gnd.

__init__(ser, srclk, rclk, srclr=None, oe=None)

Writes a single value and can optionally latch to make it visible.

bit(value, latch=False)

Write multiple (num_bits) values from the supplied value and optionally can latch.

bits(value, num_bits, latch=False)

Pulses the rclk pin to latch the outputs. Without this, all of the bits you have written are remain hidden.

latch()

Clears the shift register memory by pulsing the srclr pin. You will get a runtime error unless you have provided this pin on construct.

clear(latch=True)

Toggles the output of the shift register by toggling the output enable (oe) pin. You will get a runtime error unless you have provided this pin on construct.

enable(enabled=True)

Private method for pulsing the srclk pin, which tells the shift register to read the current state of the ser pin and copy it to the shift register memory.

_clock()

Chaining

You can connect multiple 74HC595 shift registers together to form a chain.

Connect each shift registers rclk, srclk, oe and srclr together. If you don't need to disable outputs, you can tie each oe to ground. If you don't need to clear any outputs, you can tie each srclr to vcc.

Your micro controller provides data to just the first shift registers ser pin.

The QH\`` output pin on the first shift register goes into the next shift register ser` pin and so on.

When clocking in data, the values appear on the closest shift register to the micro controller first, before overflowing into each chained shift register.

Parts

• TinyPICO $20.00 USD
• 74HC595 DIP-16 $0.77 AUD - 10pcs
• 74HC595 breakout $0.88 AUD

Connections

Links

• TinyPICO Getting Started
• micropython.org
• 74HC595 datasheet

License

Licensed under the MIT License.

Copyright (c) 2021 Mike Causer