kopia lustrzana https://github.com/jamesgao/kiln_controller
Add additional LED code
James Gao
rodzic
b736e8bfb5
commit
91913e8c48
|
|
@ -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"
|
||||
|
|
@ -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)
|
||||
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
from Adafruit_alphanumeric import AlphaScroller
|
||||
from stepper import Regulator
|
||||
|
||||
Ładowanie…
Reference in New Issue