Add additional LED code

master
James Gao 2014-10-15 11:10:54 -07:00
rodzic b736e8bfb5
commit 91913e8c48
4 zmienionych plików z 446 dodań i 0 usunięć

Wyświetl plik

@ -0,0 +1,154 @@
#!/usr/bin/python
import smbus
# ===========================================================================
# Adafruit_I2C Class
# ===========================================================================
class Adafruit_I2C(object):
@staticmethod
def getPiRevision():
"Gets the version number of the Raspberry Pi board"
# Courtesy quick2wire-python-api
# https://github.com/quick2wire/quick2wire-python-api
# Updated revision info from: http://elinux.org/RPi_HardwareHistory#Board_Revision_History
try:
with open('/proc/cpuinfo','r') as f:
for line in f:
if line.startswith('Revision'):
return 1 if line.rstrip()[-1] in ['2','3'] else 2
except:
return 0
@staticmethod
def getPiI2CBusNumber():
# Gets the I2C bus number /dev/i2c#
return 1 if Adafruit_I2C.getPiRevision() > 1 else 0
def __init__(self, address, busnum=-1, debug=False):
self.address = address
# By default, the correct I2C bus is auto-detected using /proc/cpuinfo
# Alternatively, you can hard-code the bus version below:
# self.bus = smbus.SMBus(0); # Force I2C0 (early 256MB Pi's)
# self.bus = smbus.SMBus(1); # Force I2C1 (512MB Pi's)
self.bus = smbus.SMBus(busnum if busnum >= 0 else Adafruit_I2C.getPiI2CBusNumber())
self.debug = debug
def reverseByteOrder(self, data):
"Reverses the byte order of an int (16-bit) or long (32-bit) value"
# Courtesy Vishal Sapre
byteCount = len(hex(data)[2:].replace('L','')[::2])
val = 0
for i in range(byteCount):
val = (val << 8) | (data & 0xff)
data >>= 8
return val
def errMsg(self):
print "Error accessing 0x%02X: Check your I2C address" % self.address
return -1
def write8(self, reg, value):
"Writes an 8-bit value to the specified register/address"
try:
self.bus.write_byte_data(self.address, reg, value)
if self.debug:
print "I2C: Wrote 0x%02X to register 0x%02X" % (value, reg)
except IOError, err:
return self.errMsg()
def write16(self, reg, value):
"Writes a 16-bit value to the specified register/address pair"
try:
self.bus.write_word_data(self.address, reg, value)
if self.debug:
print ("I2C: Wrote 0x%02X to register pair 0x%02X,0x%02X" %
(value, reg, reg+1))
except IOError, err:
return self.errMsg()
def writeRaw8(self, value):
"Writes an 8-bit value on the bus"
try:
self.bus.write_byte(self.address, value)
if self.debug:
print "I2C: Wrote 0x%02X" % value
except IOError, err:
return self.errMsg()
def writeList(self, reg, list):
"Writes an array of bytes using I2C format"
try:
if self.debug:
print "I2C: Writing list to register 0x%02X:" % reg
print list
self.bus.write_i2c_block_data(self.address, reg, list)
except IOError, err:
return self.errMsg()
def readList(self, reg, length):
"Read a list of bytes from the I2C device"
try:
results = self.bus.read_i2c_block_data(self.address, reg, length)
if self.debug:
print ("I2C: Device 0x%02X returned the following from reg 0x%02X" %
(self.address, reg))
print results
return results
except IOError, err:
return self.errMsg()
def readU8(self, reg):
"Read an unsigned byte from the I2C device"
try:
result = self.bus.read_byte_data(self.address, reg)
if self.debug:
print ("I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" %
(self.address, result & 0xFF, reg))
return result
except IOError, err:
return self.errMsg()
def readS8(self, reg):
"Reads a signed byte from the I2C device"
try:
result = self.bus.read_byte_data(self.address, reg)
if result > 127: result -= 256
if self.debug:
print ("I2C: Device 0x%02X returned 0x%02X from reg 0x%02X" %
(self.address, result & 0xFF, reg))
return result
except IOError, err:
return self.errMsg()
def readU16(self, reg, little_endian=True):
"Reads an unsigned 16-bit value from the I2C device"
try:
result = self.bus.read_word_data(self.address,reg)
# Swap bytes if using big endian because read_word_data assumes little
# endian on ARM (little endian) systems.
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
if (self.debug):
print "I2C: Device 0x%02X returned 0x%04X from reg 0x%02X" % (self.address, result & 0xFFFF, reg)
return result
except IOError, err:
return self.errMsg()
def readS16(self, reg, little_endian=True):
"Reads a signed 16-bit value from the I2C device"
try:
result = self.readU16(reg,little_endian)
if result > 32767: result -= 65536
return result
except IOError, err:
return self.errMsg()
if __name__ == '__main__':
try:
bus = Adafruit_I2C(address=0)
print "Default I2C bus is accessible"
except:
print "Error accessing default I2C bus"

Wyświetl plik

@ -0,0 +1,93 @@
#!/usr/bin/python
import time
from copy import copy
from Adafruit_I2C import Adafruit_I2C
# ============================================================================
# LEDBackpack Class
# ============================================================================
class LEDBackpack:
i2c = None
# Registers
__HT16K33_REGISTER_DISPLAY_SETUP = 0x80
__HT16K33_REGISTER_SYSTEM_SETUP = 0x20
__HT16K33_REGISTER_DIMMING = 0xE0
# Blink rate
__HT16K33_BLINKRATE_OFF = 0x00
__HT16K33_BLINKRATE_2HZ = 0x01
__HT16K33_BLINKRATE_1HZ = 0x02
__HT16K33_BLINKRATE_HALFHZ = 0x03
# Display buffer (8x16-bits)
__buffer = [0x0000, 0x0000, 0x0000, 0x0000, \
0x0000, 0x0000, 0x0000, 0x0000 ]
# Constructor
def __init__(self, address=0x70, debug=False):
self.i2c = Adafruit_I2C(address)
self.address = address
self.debug = debug
# Turn the oscillator on
self.i2c.write8(self.__HT16K33_REGISTER_SYSTEM_SETUP | 0x01, 0x00)
# Turn blink off
self.setBlinkRate(self.__HT16K33_BLINKRATE_OFF)
# Set maximum brightness
self.setBrightness(15)
# Clear the screen
self.clear()
def setBrightness(self, brightness):
"Sets the brightness level from 0..15"
if (brightness > 15):
brightness = 15
self.i2c.write8(self.__HT16K33_REGISTER_DIMMING | brightness, 0x00)
def setBlinkRate(self, blinkRate):
"Sets the blink rate"
if (blinkRate > self.__HT16K33_BLINKRATE_HALFHZ):
blinkRate = self.__HT16K33_BLINKRATE_OFF
self.i2c.write8(self.__HT16K33_REGISTER_DISPLAY_SETUP | 0x01 | (blinkRate << 1), 0x00)
def setBufferRow(self, row, value, update=True):
"Updates a single 16-bit entry in the 8*16-bit buffer"
if (row > 7):
return # Prevent buffer overflow
self.__buffer[row] = value # value # & 0xFFFF
if (update):
self.writeDisplay() # Update the display
def getBufferRow(self, row):
"Returns a single 16-bit entry in the 8*16-bit buffer"
if (row > 7):
return
return self.__buffer[row]
def getBuffer(self):
"Returns a copy of the raw buffer contents"
bufferCopy = copy(self.__buffer)
return bufferCopy
def writeDisplay(self):
"Updates the display memory"
bytes = []
for item in self.__buffer:
bytes.append(item & 0xFF)
bytes.append((item >> 8) & 0xFF)
self.i2c.writeList(0x00, bytes)
def clear(self, update=True):
"Clears the display memory"
self.__buffer = [ 0, 0, 0, 0, 0, 0, 0, 0 ]
if (update):
self.writeDisplay()
led = LEDBackpack(0x70)

Wyświetl plik

@ -0,0 +1,196 @@
#!/usr/bin/python
import threading
import time
import datetime
from Adafruit_LEDBackpack import LEDBackpack
# ===========================================================================
# Alphanumeric Display
# ===========================================================================
# This class is meant to be used with the 4-character alphanumeric
# displays available from Adafruit
class Alphanumeric(object):
disp = None
# Hexadecimal character lookup table
lut = [
0b0000000000000001,
0b0000000000000010,
0b0000000000000100,
0b0000000000001000,
0b0000000000010000,
0b0000000000100000,
0b0000000001000000,
0b0000000010000000,
0b0000000100000000,
0b0000001000000000,
0b0000010000000000,
0b0000100000000000,
0b0001000000000000,
0b0010000000000000,
0b0100000000000000,
0b1000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0000000000000000,
0b0001001011001001,
0b0001010111000000,
0b0001001011111001,
0b0000000011100011,
0b0000010100110000,
0b0001001011001000,
0b0011101000000000,
0b0001011100000000,
0b0000000000000000, #
0b0000000000000110, # !
0b0000001000100000, # "
0b0001001011001110, # #
0b0001001011101101, # $
0b0000110000100100, # %
0b0010001101011101, # &
0b0000010000000000, # '
0b0010010000000000, # (
0b0000100100000000, # )
0b0011111111000000, # *
0b0001001011000000, # +
0b0000100000000000, # ,
0b0000000011000000, # -
0b0000000000000000, # .
0b0000110000000000, # /
0b0000110000111111, # 0
0b0000000000000110, # 1
0b0000000011011011, # 2
0b0000000010001111, # 3
0b0000000011100110, # 4
0b0010000001101001, # 5
0b0000000011111101, # 6
0b0000000000000111, # 7
0b0000000011111111, # 8
0b0000000011101111, # 9
0b0001001000000000, # :
0b0000101000000000, # ;
0b0010010000000000, # <
0b0000000011001000, # =
0b0000100100000000, # >
0b0001000010000011, # ?
0b0000001010111011, # @
0b0000000011110111, # A
0b0001001010001111, # B
0b0000000000111001, # C
0b0001001000001111, # D
0b0000000011111001, # E
0b0000000001110001, # F
0b0000000010111101, # G
0b0000000011110110, # H
0b0001001000000000, # I
0b0000000000011110, # J
0b0010010001110000, # K
0b0000000000111000, # L
0b0000010100110110, # M
0b0010000100110110, # N
0b0000000000111111, # O
0b0000000011110011, # P
0b0010000000111111, # Q
0b0010000011110011, # R
0b0000000011101101, # S
0b0001001000000001, # T
0b0000000000111110, # U
0b0000110000110000, # V
0b0010100000110110, # W
0b0010110100000000, # X
0b0001010100000000, # Y
0b0000110000001001, # Z
0b0000000000111001, # [
0b0010000100000000, #
0b0000000000001111, # ]
0b0000110000000011, # ^
0b0000000000001000, # _
0b0000000100000000, # `
0b0001000001011000, # a
0b0010000001111000, # b
0b0000000011011000, # c
0b0000100010001110, # d
0b0000100001011000, # e
0b0000000001110001, # f
0b0000010010001110, # g
0b0001000001110000, # h
0b0001000000000000, # i
0b0000000000001110, # j
0b0011011000000000, # k
0b0000000000110000, # l
0b0001000011010100, # m
0b0001000001010000, # n
0b0000000011011100, # o
0b0000000101110000, # p
0b0000010010000110, # q
0b0000000001010000, # r
0b0010000010001000, # s
0b0000000001111000, # t
0b0000000000011100, # u
0b0010000000000100, # v
0b0010100000010100, # w
0b0010100011000000, # x
0b0010000000001100, # y
0b0000100001001000, # z
0b0000100101001001, # {
0b0001001000000000, # |
0b0010010010001001, # }
0b0000010100100000, # ~
0b0011111111111111]
special = dict(degree= 0b0000000011100011, cone=0b0010100000001000)
# Constructor
def __init__(self, address=0x70, debug=False):
self.disp = LEDBackpack(address=address, debug=debug)
def writeCharRaw(self, charNumber, value):
"Sets a digit using the raw 16-bit value"
if (charNumber > 4):
return
# Set the appropriate digit
self.disp.setBufferRow(charNumber, value)
def writeChar(self, charNumber, value, dot=False):
"Sets a single decimal or hexademical value (0..9 and A..F)"
if (charNumber > 4):
return
if value in special:
value = self.special[value]
else:
value = self.lut[ord(value)]
# Set the appropriate digit
self.disp.setBufferRow(charNumber, value | (dot << 14))
class AlphaScoller(threading.Thread):
def __init__(self, address=0x70, interval=.25):
self.interval = interval
self.disp = Alphanumeric(address)
super(AlphaScroller, self).__init__()
self.value = " "
def set_text(self, text, pad=True):
self.text = text
if pad:
self.text += " "
self.counter = 0
def set_speed(self, interval):
self.interval = interval
def run(self):
counter = 0
while True:
for i in range(4):
char = self.value[(counter+i) % len(self.value)]
self.disp.writeChar(i, char)
time.sleep(interval)
counter += 1

3
kiln/manager.py 100644
Wyświetl plik

@ -0,0 +1,3 @@
from Adafruit_alphanumeric import AlphaScroller
from stepper import Regulator