Monday, May 20, 2013
fongtoy 2096 refactoring notes
Now I am refactoring ft2090 to 2096, getting stuck in spi read/write function because I always forgot the strange thing of SPI write and read happen at the same time, and to read, you must first write.
# *****************************************************************************
# TestMCP23S17SpiSlaveSelector() v1.0 tlfong01 2013may20hkt1101
# Description
# Setup 2 SPI channels, one for MCP23S17 (sub address 0), one for 25LC256
# Setup MCP23S17 Port A and Port B all 8 pins output
# Select EEPROM 25LC256
# Write 1 byte to EEPROM
# Read 1 byte from EEPROM
# *****************************************************************************
def SpiWrite(spiChannel, spiWriteList):
spiReadList = spiChannel.xfer2(spiWriteList)
return spiReadList
def SelectSpiSlave(spiChannel, mcp23s17SubAddress, spiSlaveSubAddress):
loadDecoderDataControlByte = spiSlaveSubAddress | 0b00000000 # bit 4 = 0 loads HC137 decoder
latchDecoderDataControlByte = spiSlaveSubAddress | 0b00001000 # bit 4 = 1 latches HC137 decoder
WriteDataByteMcp23s17(spiChannel, mcp23s17SubAddress, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, loadDecoderDataControlByte)
WriteDataByteMcp23s17(spiChannel, mcp23s17SubAddress, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, latchDecoderDataControlByte)
def WriteEepromDataByte(spiChannel, startAddress, dataByte):
# *** Constants and variables ***
EePromCommandWriteLatchEnable = 0x06
EepromCommandWrite = 0x02
FiveMilliSeconds = 0.005
startAddressUpper = startAddress >> 8
startAddressLower = startAddress & 0x00ff
# *** Write data byte ***
SpiWrite(spiChannel, [EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
SpiWrite(spiChannel, [EepromCommandWrite, startAddressUpper, startAddressLower, dataByte])
time.sleep(FiveMilliSeconds)
def ReadEepromDataByte(spiChannel, startAddress):
# *** Constants and variables ***
EepromCommandRead = 0x03
FiveMilliSeconds = 0.005
DummyDataByte = 0x00
readSpiDataList = [0x00, 0x00, 0x00, 0x00, 0x00]
startAddressUpper = startAddress >> 8
startAddressLower = startAddress & 0x00ff
# *** Read data byte ***
readSpiDataList = SpiWrite(spiChannel, [EepromCommandRead, startAddressUpper, startAddressLower, DummyDataByte])
dataByte = readSpiDataList[3]
return dataByte
def TestMcp23S17SpiSlaveSelector01(mcp23S17Address, eepromSubAddress, testStartAddress, testDataByte):
# *** Set up SPI channel 00 for MCP23S17, channel 01 for EEPROM 25LC256 ***
SpiChannel0 = 0
SpiChipEnable0 = 0
SpiChipEnable1 = 1
Mcp23s17SubAddress0 = 0
spiChannel00 = spidev.SpiDev()
spiChannel00.open(SpiChannel0, SpiChipEnable0)
spiChannel01 = spidev.SpiDev()
spiChannel01.open(SpiChannel0, SpiChipEnable1)
# *** Set up MCP23s17 Port A all out to drive HC137 #1, Port B to drive 2 74HC137 #2 ***
All8pinOutput = 0x00
SetupMcp23s17Ports(spiChannel00, Mcp23s17SubAddress0, All8pinOutput, All8pinOutput)
# *** Select EEPROM 25LC256 ***
SelectSpiSlave(spiChannel00, Mcp23s17SubAddress0, eepromSubAddress)
# *** Write Eeprom ***
WriteEepromDataByte(spiChannel01, startAddress = testStartAddress, dataByte = testDataByte)
print "Write data byte = ", hex(testDataByte)
# *** Read Eeprom ***
readBackDataByte = ReadEepromDataByte(spiChannel01, startAddress = testStartAddress)
print "Read data byte = ", hex(readBackDataByte)
# *** Close SPI channel ***
spiChannel00.close()
spiChannel01.close()
# *****************************************************************************
# !/usr/bin/python2.7
#
# Project
# fongtoy ft2081 - tlfong01 2013may13
# License & Warranty
# GNU GPLv3. For hobbist without any warranty. Use at your own risk.
# Hardware & software
# Raspberry Pi Bv2 512MB, Av2 256 MB, Raspbian Wheezy, Python 2.7.3,
# RPI.GPIO 0.5.0a, PythonWiringPi 1.0.5, RPIO v0.8.4, GuzuntyPi v1.6-04
# Development style
# Functional/Object/StateMachine (MitOcwSc601), Prototyping, Test-driven,
# Iterative Incremental, Refactoring, Agile/Pair
# References
# GuzuntyPi Input/Output Expander Rev 1.6-04 (CPLD)
# Mcirochip Application Notes AN1043 (GPIO Expander)
# Microchip Application Notes AN1081 (Matrix Keypad)
# ShenZhen YaJingDa Electronics YJD1602A-1 20070908 (LCD1602)
# PowerTip PC-1602F 20041011 (LCD1602)
# Sitronix ST7066U Dot Matrix LCD Controller/Driver 20030301
# *****************************************************************************
# *** Project Titles **********************************************************
ProgramTitle1 = "MCP23S17 Slave Device Selector Test 01 - tlfong01 2013may20"
ProgramTitle2 = "ft208906 20130520m"
# *** Imports *****************************************************************
import sys
import time
import smbus
import pdb
import spidev
import RPIO as GPIO
from RPIO import PWM
from enum import Enum
import wiringpi
import wiringpi2
from subprocess import call
GPIO.setmode(GPIO.BCM)
smBus1 = smbus.SMBus(1)
I2cBaseAddress20 = 0x20
I2cBaseAddress21 = 0x21
I2cBaseAddress22 = 0x22
I2cBaseAddress23 = 0x23
I2cBaseAddress24 = 0x24
I2cBaseAddress25 = 0x25
I2cBaseAddress26 = 0x26
I2cBaseAddress27 = 0x27
Mcp23017BaseAddress1 = 0x22 # LED, button
Mcp23008BaseAddress1 = 0x24 # stepping motors
Mcp23008BaseAddress2 = 0x25 # keypad
Mcp23008BaseAddress3 = 0x26 # LCD1602
Mcp23017BaseAddressSystemB1 = 0x20
Mcp23008BaseAddressSystemB1 = 0x21
Mcp23008BaseAddressSystemB1 = 0x21
RPiGPIOgen2 = 27 # P1-13 Test LED
RPiGPIOgen9 = 30 # P5-05 Buzzer
RPiGPIOgen10 = 31 # P5-06 Button
LEDpin = RPiGPIOgen2
BuzzerPin = RPiGPIOgen9
ButtonPin = RPiGPIOgen10
RPiTxD = 14 # P1-08 UART TxD
RPiRxD = 15 # P1-10 UART RxD
TxdPin = RPiTxD
RxdPin = RPiRxD
# * PCM, Clock, Interrupt *
RPiGPIOgen1 = 18 # P1-12 PCM_CLK
RPiGPIOGclk = 04 # P1-07 GPIO_GCLK
RPiGPIOgen6 = 25 # P1-22 IOx/keypad interrupt
RPiPcm = RPiGPIOgen1
RPiGpclk0 = RPiGPIOGclk
RpiGpioSpiSelect0 = 7 # SPI_CE1_N P1-26
RpiGpioSpiSelect1 = 8 # SPI_CE0_N P1-24
RpiGpioSpiMiso = 9 # SPI_MISO P1-21
RpiGpioSpiMosi = 10 # SPI_MOSI P1-10
RpiGpioSpiClk = 11 # SPI_SCLK P1-23
SpiClockPin = RpiGpioSpiClk
SpiMosiPin = RpiGpioSpiMosi
SpiMisoPin = RpiGpioSpiMiso
SpiSelect0Pin = RpiGpioSpiSelect0
SpiSelect1Pin = RpiGpioSpiSelect1
RpiGpioGen0 = 17 # GPIO_GEN0 P1-11 Jtag TCK
RpiGpioGen3 = 22 # GPIO_GEN0 P1-15 Jtag TDO
RpiGpioGen4 = 23 # GPIO_GEN4 P1-16 Jtag TDI
RpiGpioGen5 = 24 # GPIO_GEN5 P1-18 Jtag TMS
JtagTckPin = RpiGpioGen0
JtagTdoPin = RpiGpioGen3
JtagTdiPin = RpiGpioGen4
JtagTmsPin = RpiGpioGen5
# * GPIO Input/Output/Interrupt pin list ***************************************
OutputPinList = [LEDpin, BuzzerPin, TxdPin, RPiGpclk0, RPiPcm]
InputPinWithPullUpList = [ButtonPin, RxdPin, RPiGPIOgen6]
InputPinWithNoPullUpList = []
# * Input/Output pin list for debugging only *
# OutputPinList = [LEDpin, BuzzerPin, TxdPin, SpiClockPin, SpiMosiPin, SpiSelect0Pin, SpiSelect1Pin]
# InputPinWithPullUpList = [ButtonPin, RxdPin, RPiGPIOgen6, SpiMisoPin]
# JtagOutputPinList = [JtagTckPin, JtagTdoPin, JtagTmsPin, JtagTdiPin]
# JtagInputPinList = []
# JtagOutputPinList = [JtagTckPin, JtagTdoPin, JtagTmsPin]
# JtagInputPinList = [JtagTdiPin]
# *** Global constants *********************************************************
OnTime = 0.1 # On time = 0.01 second (10mS)
OffTime = 0.25 # Off time = 0.25 second (25 mS)
# *** Basic GPIO Setup/Read/Write Functions ***********************************
# * Nibble names *
LowNibble = 0
HighNibble = 1
# BothNibble = 2 # full byte of 8 bits
# * Nibble constants *
HighNibble1LowNibble0 = 0xf0
HighNibble0LowNibble1 = 0x0f
# * LED and buzzer states *
Off = False
On = True
# * Button states *
ButtonPressed = False
ButonReleased = True
# * Interrupt states *
Low = False
High = True
# * Setup, Read/Write GPIO pins *
# * Individual pins *
setupOutputPin = lambda oPin: GPIO.setup(oPin, GPIO.OUT) # set GPIO pin as output
setupInputPinWithNoPullUp = lambda iPin: GPIO.setup(iPin, GPIO.IN, pull_up_down=GPIO.PUD_OFF) # set GPIO pin as input, no pull up
setupInputPinWithPullUp = lambda iPin: GPIO.setup(iPin, GPIO.IN, pull_up_down=GPIO.PUD_UP) # set GPIO pin as input, with pull up
writeOutputPin = lambda oPin, oValue: GPIO.output(oPin, oValue) # write value to output pin
readInputPin = lambda iPin: GPIO.input(ButtonPin) # read value from input pin
setupWriteOutputPin = lambda oPin, oValue: (setupOutputPin(oPin), writeOutputPin(oPin, oValue)) # set and write
def SetupGPIO():
SetupGPIOpins(OutputPinList, InputPinWithNoPullUpList, InputPinWithPullUpList )
def CleanUpGpio():
GPIO.cleanup()
def SetupGPIOpins(outputPinList, inputPinWithNoPullUpList, inputPinWithPullUpList):
for oPin in outputPinList:
setupWriteOutputPin(oPin, Off)
for iPin in inputPinWithNoPullUpList:
setupInputPinWithNoPullUp(iPin)
for iPin in inputPinWithPullUpList:
setupInputPinWithPullUp(iPin)
# * Basic LED/Buzzer/Button Functions *
def pulsePin(oPin, onTime, offTime): # blink LED or beep buzzer
writeOutputPin(oPin, On)
time.sleep(onTime)
writeOutputPin(oPin, Off)
time.sleep(offTime)
def echoPin(iPin, oPin): # echo input pin to output pin, e.g. button to LED or buzzer
while True:
if readInputPin(iPin) == ButonReleased:
pass
else:
pulsePin(oPin, OnTime, OffTime)
break
continue
def togglePin(oPin, toggleTime): # toggle pin
writeOutputPin(oPin, On)
time.sleep(toggleTime)
writeOutputPin(oPin, Off)
time.sleep(toggleTime)
# * Testing Buzzer/LED/Button/UART/JTAG/Interrupt *
def TestBuzzer(): # beep 4 times
SetupGPIO()
for i in range (4):
pulsePin(BuzzerPin, OnTime, OffTime)
def TestLED(): # blink 4 times
SetupGPIO()
for i in range (4):
pulsePin(LEDpin, OnTime, OffTime)
def TestGpioPin(oPin, toggleTime, toggleCount):
for i in range(toggleCount):
togglePin(oPin, toggleTime)
def TestButtonEchoBuzzer(): #
SetupGPIO()
print "\n", "Press button 4 times.", "\n"
for i in range (4):
echoPin(ButtonPin, BuzzerPin)
def TestButtonEchoTxD(): #
SetupGPIO()
print "\n", "Press button 4 times.", "\n"
for i in range (4):
echoPin(ButtonPin, TxdPin)
def TestButtonEchoRxD(): #
SetupGPIO()
print "\n", "Press button 4 times.", "\n"
for i in range (4):
echoPin(ButtonPin, RxdPin)
def TestRxdEchoTxD(): #
SetupGPIO()
print "\n", "RxD Echo TxD - Press button 4 times.", "\n"
for i in range (4):
echoPin(RxdPin, TxdPin)
def TestButtonEchoLED(): #
SetupGPIO()
print "\n", "Press button 4 times.", "\n"
for i in range (4):
echoPin(ButtonPin, LEDpin)
def TestTxdPin(): # blink 4 times
SetupGPIO()
for i in range (4):
pulsePin(TxdPin, OnTime, OffTime)
def TestRxdPin(): # blink 4 times
SetupGPIO()
for i in range (4):
pulsePin(RxdPin, OnTime, OffTime)
def TestTxdPinRxdPin1(): # blink, read 4 times
SetupGPIO()
for i in range (4):
writeOutputPin(TxdPin, On)
if readInputPin(RxdPin) == High:
print "RxD input = High"
else:
print "RxD input = Low"
time.sleep(1)
writeOutputPin(TxdPin, Off)
if readInputPin(RxdPin) == High:
print "RxD input = High"
else:
print "RxD input = Low"
time.sleep(1)
def TestTxdPinRxdPin2(): #
SetupGPIO()
print "\n", "Short to Ground RxdPin 4 times.", "\n"
for i in range (4):
echoPin(RxdPin, TxdPin)
def SetupJtagGpio():
SetupGPIOpins(outputPinList = JtagOutputPinList, inputPinWithNoPullUpList = JtagInputPinList, inputPinWithPullUpList = [])
def TestJtagPins(toggleTime, testCount):
SetupJtagGpio()
Beep(1)
for i in range(testCount):
togglePin(JtagTckPin, toggleTime)
Beep(1)
for i in range(testCount):
togglePin(JtagTdoPin, toggleTime)
Beep(1)
for i in range(testCount):
togglePin(JtagTmsPin, toggleTime)
for i in range(testCount):
writeOutputPin(JtagTdoPin, 1)
if readInputPin(JtagTdiPin) == 1:
print "JtagTdiPin = 1"
else:
print "JtagTdiPin = 0"
time.sleep(1)
writeOutputPin(JtagTdoPin, 0)
if readInputPin(JtagTdiPin) == 1:
print "JtagTdiPin = 1"
else:
print "JtagTdiPin = 0"
time.sleep(1)
Beep(3)
GPIO.cleanup()
def TestInterruptPinFallingEdgeDetection(): # !!! OUT OF DATE, not sure if still working !!!
GPIO.cleanup() # set all input pins no pull up, disable all interutp detection setting
SetupGPIO()
GPIO.set_low_event(InterruptPin) # set up low level detection
for i in range(30):
if GPIO.event_detected(InterruptPin):
break
else:
print "No interrupt detected.", i
time.sleep(1)
continue
GPIO.set_low_event(InterruptPin, enable = False) # disable detection
print "End of test, or interrupt detected"
# *** Printing and debugging functions ****************************************
# * Set/Reset one bit of a byte *
def SetDataBit(dataByte, bitIndex):
setDataByte = 0x01 << bitIndex
dataByte = dataByte | setDataByte
return dataByte
def ResetDataBit(dataByte, bitIndex):
resetDataByte = ~(0x01 << bitIndex)
dataByte = dataByte & resetDataByte
return dataByte
# * Print nibble/byte as 4/8 bit pattern for debugging *
def PrintFourBitPattern(message, dataByte):
fourBitPattern = ConvertIntegerToFourBitPattern(dataByte)
print message, fourBitPattern
def PrintEightBitPattern(message, dataByte):
eightBitPattern = ConvertIntegerToEightPattern(dataByte)
print message, eightBitPattern
def ConvertIntegerToFourBitPattern(integer):
FourBitPattern = [""]
for k in range(4):
FourBitPattern = [i+j for i in ['0','1'] for j in FourBitPattern]
return FourBitPattern[integer]
def ConvertIntegerToEightPattern(integer):
EightBitPattern = [""]
for k in range(8):
EightBitPattern = [i+j for i in ['0','1'] for j in EightBitPattern]
return EightBitPattern[integer]
# * Beep/Start/Stop program functions *
def StartProgram():
message = "\n" + "*** Start Program - " + ProgramTitle1 + " ***" + "\n"
CleanUpGpio()
SetupGPIO()
StartBeep()
print message
def StopProgram():
SetupGPIO()
StopBeep()
# print "\n" + "*** Resetting GPIO input, no pull up/down, no event detect. ***" + "\n"
CleanUpGpio()
print "\n" + "*** Stop Program ***" + "\n"
def Beep(count):
for i in range(count):
pulsePin(BuzzerPin, OnTime, OffTime)
def StartBeep():
Beep(2)
time.sleep(1)
def StopBeep():
Beep(2)
def OneBeep():
Beep(1)
def FourBeeps():
Beep(4)
# *** Mcp23008, Mcp23017 IO Expander Functions ********************************
# *** Mcp23008/Mcp23017 Bank0/Bank1 register address offset arrays ************
Mcp23008RegisterAddressOffsetArray = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a]
RegisterAddressOffsetArrayBank0 = [0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14,
0x01, 0x03, 0x05, 0x07, 0x09, 0x0b, 0x1d, 0x0f, 0x11, 0x13, 0x15]
RegisterAddressArrayMcp23s17 = [0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14,
0x01, 0x03, 0x05, 0x07, 0x09, 0x0b, 0x1d, 0x0f, 0x11, 0x13, 0x15]
HalfHighHalfLow = 0xf0
HalfLowHalfHigh = 0x0f
Nibble1HighNibble2Low = 0xf0
Nibble1LowNibble2High = 0x0f
HighNibbleInputLowNibbleOutput = 0xf0
AllOutputByte = 0x00
AllInputByte = 0xff
AllHighByte = 0xff
AllLowByte = 0x00
AllPullUpByte = 0xff
InputOutputDirection = 0
InputPolarity = 1
InterruptEnable = 2
DefaultValue = 3
CompareMode = 4
BankInterruptPinMode = 5
PullUp = 6
InterruptFlag = 7
InterruptCapture = 8
PortStatus = 9
OutputLatch = 10
# *** Mcp23008 Functions ******************************************************
def SetupPortAllOutputMcp23008(registerBaseAddress):
WriteDataByteMcp23008(registerBaseAddress, InputOutputDirection, AllOutputByte)
def SetupPortAllInputMcp23008(registerBaseAddress):
WriteDataByteMcp23008(registerBaseAddress, InputOutputDirection, AllInputByte)
def WriteDataByteMcp23008(registerBaseAddress, dataRegisterIndex, dataByte):
addressOffset = Mcp23008RegisterAddressOffsetArray[dataRegisterIndex]
smBus1.write_byte_data(registerBaseAddress, addressOffset, dataByte)
def ReadDataByteMcp23008(registerBaseAddress, dataRegisterIndex):
addressOffset = Mcp23008RegisterAddressOffsetArray[dataRegisterIndex]
dataByte = smBus1.read_byte_data(registerBaseAddress, addressOffset)
return dataByte
def WriteDataBitMcp23008(registerBaseAddress, dataRegisterIndex, bitNumber, dataBit):
addressOffset = Mcp23008RegisterAddressOffsetArray[dataRegisterIndex + 11]
dataByte = smBus1.read_byte_data(registerBaseAddress, addressOffset)
bitMask = 0x01 << bitNumber
if (dataBit == 1):
dataByte = dataByte | bitMask
else:
dataByte = dataByte & (~bitMask)
smBus1.write_byte_data(registerBaseAddress, addressOffset, dataByte)
def ToggleGpMcp23008(registerBaseAddress, toggleTime, toggleCount):
SetupMcp23008PortAllOutput(registerBaseAddress)
for i in range(toggleCount):
WriteDataByteMcp23008(registerBaseAddress, OutputLatch, AllHighByte)
time.sleep(toggleTime)
WriteDataByteMcp23008(registerBaseAddress, OutputLatch, AllLowByte)
time.sleep(toggleTime)
def ReadGpMcp23008(registerBaseAddress, count):
SetupMcp23008PortAllInput(registerBaseAddress)
for i in range(count):
dataByte = ReadDataByteMcp23008(registerBaseAddress, PortStatus)
PrintEightBitPattern("Data byte read = ", dataByte)
time.sleep(1)
# *** Mcp23017 Functions ******************************************************
def SetupMcp23017BothPortAllOutput(registerBaseAddress):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortA, AllOutputByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortB, AllOutputByte)
def SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortA, AllOutputByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortB, AllInputByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, PullUp, PortB, AllPullUpByte)
def WriteDataByte(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType, dataByte):
if (portType == PortA) | (portType == PortA):
addressOffset = registerAddressArray[dataRegisterIndex]
if (portType == PortB):
addressOffset = registerAddressArray[dataRegisterIndex + 11]
smBus1.write_byte_data(registerBaseAddress, addressOffset, dataByte)
def WriteDataBit(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType, bitNumber, dataBit):
if (portType == PortA) | (portType == PortA):
addressOffset = registerAddressArray[dataRegisterIndex]
if (portType == PortB):
addressOffset = registerAddressArray[dataRegisterIndex + 11]
dataByte = smBus1.read_byte_data(registerBaseAddress, addressOffset)
bitMask = 0x01 << bitNumber
if (dataBit == 1):
dataByte = dataByte | bitMask
else:
dataByte = dataByte & (~bitMask)
smBus1.write_byte_data(registerBaseAddress, addressOffset, dataByte)
def ReadDataByte(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType):
if (portType == PortA):
addressOffset = registerAddressArray[dataRegisterIndex]
if (portType == PortB):
addressOffset = registerAddressArray[dataRegisterIndex + 11]
dataByte = smBus1.read_byte_data(registerBaseAddress, addressOffset)
return dataByte
def ReadDataBit(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType, bitNumber):
if (portType == PortA):
addressOffset = registerAddressArray[dataRegisterIndex]
if (portType == PortB):
addressOffset = registerAddressArray[dataRegisterIndex + 11]
dataByte = smBus1.read_byte_data(registerBaseAddress, addressOffset)
bitMask = 0x01 << bitNumber
dataByte = dataByte & bitMask
if (dataByte == 0):
dataBit = 0
else:
dataBit = 1
return dataBit
def ReadUpperNibble(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType):
dataByte = ReadDataByte(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType)
upperNibble = dataByte >> 4
return upperNibble
def ReadLowerNibble(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType):
dataByte = ReadDataByte(registerBaseAddress, registerAddressArray, dataRegisterIndex, portType)
lowerNibble = dataByte & 0x0f
return lowerNibble
# * Config interrupts *
def EnableInterruptOnChangeHighNibble(registerBaseAddress):
EnableInterruptHighNibble = 0xf0
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortA, EnableInterruptHighNibble)
def DisableInterruptOnChangeHighNibble(registerBaseAddress):
DisableInterruptHighNibble = 0x00
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortA, DisableInterruptHighNibble)
def SetInterruptOnChangeDefaultHighNibble(registerBaseAddress):
DefaultValueByte = 0xf0
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptOnChangeDefaultValue, PortA, DefaultValueByte)
def SetInterruptOnChangeCompareDefaultHighNibble(registerBaseAddress):
InterruptOnChangeDefaultValueHighNibble = 0xf0 # GP4~7 change from default value will cause interrupt
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, CompareMode, PortA, InterruptOnChangeDefaultValueHighNibble)
def SetInterruptOutputPushPull(registerBaseAddress): # interrupt pin open drain, no auto add inc, no slew rate
PushPull = 0b00111010 # 0x32, seq/slew disabled, interrupt output drive drive (push pull) active High
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, PushPullOpenDrain, PortA, PushPull)
def SetInterruptOutputOpenDrain(registerBaseAddress): # interrupt pin open drain, no auto add inc, no slew rate
OpenDrain = 0b00111000 # 0x34, seq/slew disabled, interrupt output open drain (don't care active High or Low)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, PushPullOpenDrain, PortA, OpenDrain)
# * Poll interrupts *
def ReadInterruptFlagHighNibble(registerBaseAddress):
interruptFlagByte = ReadDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptFlag, PortA)
interruptFlagNbble = interruptFlagByte >> 4
return interruptFlagNibble
def ReadInterruptCaptureHighNibble(registerBaseAddress):
interruptCaptureByte = ReadDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptCapture, PortA)
interruptCaptureNibble = interruptCaptureByte >> 4
return interruptCaptureNibble
def ReadInterruptCaptureLowNibble(registerBaseAddress):
interruptCaptureByte = ReadDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptCapture, PortB)
interruptCaptureNibble = interruptCaptureByte & 0x0f
return interruptCaptureNibble
def DetectOneInterrupt(registerBaseAddress): # !!! NOT tested !!!
interruptFlagNibble = ReadInterruptFlagHighNibble(registerBaseAddress)
interruptCaptureNibble = ReadInterruptCaptureHighNibble(registerBaseAddress)
print "Interrupt capture high nibble = ", ConvertIntegerToFourBitPattern(interruptCaptureNibble)
print "Interrupt capture high nibble = ", ConvertIntegerToFourBitPattern(interruptCaptureNibble)
ClearInterruptOnChangeHighNibble(registerBaseAddress) # !!! clear interrupt !!!
time.sleep(2)
# * System A Test Functions (port toggling, poll interrupts) ******************
def ToggleMcp23017GP(registerBaseAddress, toggleTime, toggleCount):
SetupMcp23017BothPortAllOutput(registerBaseAddress)
for i in range(toggleCount):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllHighByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortB, AllHighByte)
time.sleep(toggleTime)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllLowByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortB, AllLowByte)
time.sleep(toggleTime)
def ToggleMcp23017B1(registerBaseAddress, toggleTime, toggleCount):
SetupMcp23017BothPortAllOutput(registerBaseAddress)
for i in range(toggleCount):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllHighByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortB, AllHighByte)
time.sleep(toggleTime)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllLowByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortB, AllLowByte)
time.sleep(toggleTime)
def TestToggleMcp23017GP():
ToggleMcp23008GP(Mcp23017BaseAddress1, ToggleTime, ToggleCount)
def TestDetectInterrupt(count): # !!! NOT Tested !!!
RegisterBaseAddress = Mcp23008BaseAddress2
SetupKeypadInterruptHighNibbleCompareDefaultValueOpenDrainOutput(RegisterBaseAddress)
for i in range(count):
DetectOneInterrupt(RegisterBaseAddress)
# *** System B test functions *************************************************
def TestToggleMcp23017SystemB1(count):
ToggleTime = 0.5
ToggleCount = 4
registerBaseAddress = Mcp23017BaseAddressSystemB1
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(count):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllHighByte)
time.sleep(ToggleTime)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllLowByte)
time.sleep(ToggleTime)
def TestToggleMcp23017PortAoutput(registerBaseAddress, toggleTime, toggleCount):
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(toggleCount):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllHighByte)
time.sleep(toggleTime)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, AllLowByte)
time.sleep(toggleTime)
def TestReadMcp23017SystemB1(count):
registerBaseAddress = Mcp23017BaseAddressSystemB1
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(count):
dataByte = ReadDataByte(Mcp23017BaseAddressSystemB1, RegisterAddressOffsetArrayBank0, PortStatus, PortB)
PrintEightBitPattern("Data byte read = ", dataByte)
time.sleep(1)
def TestReadMcp23017PortBinput(registerBaseAddress, readTime, readCount):
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(readCount):
dataByte = ReadDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, PortStatus, PortB)
PrintEightBitPattern("MCP23x17 Port B data byte read = ", dataByte)
time.sleep(1)
def TestBlinkMcp23017SystemB1GPIObit(bitNumber, onTime, offTime, count) :
registerBaseAddress = Mcp23017BaseAddressSystemB1
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(count):
WriteDataBit(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, bitNumber, High)
time.sleep(onTime)
WriteDataBit(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, bitNumber, Low)
time.sleep(offTime)
def TestReadMcp23017SystemB1GPIObit(bitNumber, count):
registerBaseAddress = Mcp23017BaseAddressSystemB1
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
for i in range(count):
dataBit = ReadDataBit(registerBaseAddress, RegisterAddressOffsetArrayBank0, PortStatus, PortB, bitNumber)
if (dataBit == High):
print "Data bit is High"
else:
print "Data bit is Low"
time.sleep(1)
# *** Decimal Keypad **********************************************************
# * Mcp23017 based decimal keypad *********************************************
# * Configuration *
# Mcp23017 GPIO direction - Port A = output, Port B = input
# Keypad pin assignment - GPA0~A2 = Col0~2, GPB0~B3 = Row0~3
KeypadInterruptPinMcp23017 = RPiGPIOgen6
# * Local constants *
RegisterBaseAddress = 0x20
OutputLatchRegisterResetValue = 0x00
PortStatusRegisterResetValue = 0x00
InterruptCaptureRegisterResetValue = 0x00
InterruptFlagRegisterResetValue = 0x00
# * Polling modes *
NoPollJustGetKeyEverySecond = 0
PollRowStatusNibble = 1
PollMcp23017Interrupt = 2
# * Setup keypad *
def SetupKeypadMcp017(registerBaseAddress):
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
SetupKeypadInterruptMcp23017(registerBaseAddress) # buggy !!!!!!!!!!
ClearKeypadInterruptMcp23017(registerBaseAddress)
WriteKeypadColumnsAllLowMcp23017(registerBaseAddress)
# * Setup/Clear/Check keypad interrupt *
def SetupKeypadInterruptMcp23017(registerBaseAddress):
SetKeypadInterruptEnableMcp23017(registerBaseAddress)
SetKeypadDefaultValueMcp23017(registerBaseAddress)
SetKeypadEnableCompareDefaultValueMcp23017(registerBaseAddress)
SetKeypadBankInterruptDriverModeMcp23017(registerBaseAddress)
def SetKeypadInterruptEnableMcp23017(registerBaseAddress):
EnableInterruptLowNibble = 0x0f
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortB, EnableInterruptLowNibble)
def SetKeypadInterruptDisableMcp23017(registerBaseAddress):
DisableInterruptByte = 0x00
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortB, DisableInterruptByte)
def SetKeypadDefaultValueMcp23017(registerBaseAddress):
DefaultValueByte = 0x0f # row status nibble is all bits high if no key pressed
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, DefaultValue, PortB, DefaultValueByte)
def SetKeypadEnableCompareDefaultValueMcp23017(registerBaseAddress):
InterruptOnChangeDefaultValueLowNibble = 0x0f # GPB0~3 change from default value will cause interrupt
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, CompareMode, PortB, InterruptOnChangeDefaultValueLowNibble)
def SetKeypadBankInterruptDriverModeMcp23017(registerBaseAddress):
# bit 7 = 0 (Bank = 0, reg with each port are in the same bank (addresses are sequential))
# bit 6 = 0 (No mirror, INTA and INTB independent)
# bit 5 = 1 (Sequential operation disabled)
# bit 4 = 1 (Slew rate disabled)
# bit 3 = 0 (Disable MCP23S17 address pins, Don't care for Mcp23017)
# bit 2 = 0 (Interrupt driver push pull, no open drain)
# bit 1 = 1 (Interrrupt active high)
# bit 0 = 0 (Unimplemented, read as 0)
# 0b00110010 = 0x32
Bank0DriverPushPullHighActive = 0x32
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, BankInterruptPinMode, PortB, Bank0DriverPushPullHighActive)
def ClearKeypadInterruptMcp23017(registerBaseAddress):
WriteKeypadColumnsAllLowMcp23017(registerBaseAddress)
time.sleep(0.5)
dummyRead = ReadInterruptCaptureLowNibble(registerBaseAddress)
# * Write columns *
def WriteKeypadColumnsMcp23017(registerBaseAddress, columnDataByte):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, columnDataByte)
def WriteKeypadColumnsAllLowMcp23017(registerBaseAddress):
WriteKeypadColumnsMcp23017(registerBaseAddress, AllLowByte)
# * Read rows *
def GetKeypadRowDataNibbleMcp23017(registerBaseAddress):
rowDataByte = ReadDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, PortStatus, PortB)
rowDataNibble = rowDataByte & 0x0f
return rowDataNibble
# * Get Row Number, Column Number, and Key Number *
def GetKeypadRowNumberMcp23017(registerBaseAddress):
RowDataNibbleTuple = 0b1110, 0b1101, 0b1011, 0b0111, 0b1111, 0b0000
rowDataNibble = GetKeypadRowDataNibbleMcp23017(registerBaseAddress)
# *** Begin debugging *****************************************************
PrintFourBitPattern("Row pattern = ", rowDataNibble)
rowNumber = RowDataNibbleTuple.index(rowDataNibble)
print ("Row number = ", rowNumber)
# *** End debugging *******************************************************
rowNumber = RowDataNibbleTuple.index(rowDataNibble)
return rowNumber
def GetKeypadColumnNumberMcp23017(registerBaseAddress):
ColumnNibbleTuple = 0b1110, 0b1101, 0b1011
NoKeyPressNibble = 0b1111
for columnNibble in (ColumnNibbleTuple):
WriteKeypadColumnsMcp23017(registerBaseAddress, columnNibble)
rowDataNibble = GetKeypadRowDataNibbleMcp23017(registerBaseAddress)
if rowDataNibble != NoKeyPressNibble:
break
columnNumber = ColumnNibbleTuple.index(columnNibble)
return columnNumber
def GetKeypadKeyNumberMcp23017(registerBaseAddress):
rowNumber = GetKeypadRowNumberMcp23017(registerBaseAddress)
columnNumber = GetKeypadColumnNumberMcp23017(registerBaseAddress)
keyNumber = (rowNumber * 3) + (columnNumber + 1)
return keyNumber
# * Get keys *
def GetKeypadKeyMcp23017(registerBaseAddress, checkPressingKeyMode):
if (checkPressingKeyMode == NoPollJustGetKeyEverySecond):
print "Read key every second"
time.sleep(1)
LoopUntilOneSecondEnded()
elif (checkPressingKeyMode == PollRowStatusNibble):
print "Polling Gpio"
LoopUntilKeypadRowDataNibbleChangeMcp23017(registerBaseAddress)
elif (checkPressingKeyMode == PollMcp23017Interrupt):
print "Polling Mcp23017 interrupt INTB"
LoopUntilKeypadInterruptPinMcp23017Active(registerBaseAddress)
keyNumber = GetKeypadKeyNumberMcp23017(registerBaseAddress)
return keyNumber
def GetKeypadKeySequenceMcp23017(registerBaseAddress, checkPressingKeyMode, count):
for i in range (count):
OneBeep()
keyNumber = GetKeypadKeyMcp23017(registerBaseAddress, checkPressingKeyMode)
print "Key", i + 1, " = ", keyNumber
time.sleep(0.25)
# * No polling, just read key at the end of each second *
def LoopUntilOneSecondEnded():
time.sleep(1)
# * Poll row status *
def LoopUntilKeypadRowDataNibbleChangeMcp23017(registerBaseAddress):
WriteKeypadColumnsMcp23017(registerBaseAddress, AllLowByte)
NoKeyPressedNibble = 0xf
rowDataNibble = NoKeyPressedNibble
while (rowDataNibble == NoKeyPressedNibble):
rowDataNibble = GetKeypadRowDataNibbleMcp23017(registerBaseAddress)
time.sleep(0.05) # debouncing time 50mS
# * Poll Mcp23017 interrupt pin *
def LoopUntilKeypadInterruptPinMcp23017Active(registerBaseAddress):
# Mcp23017 INTB shifted up to 5V) logical level, then connected to Mcp23017 GPB5
KeypadInterruptPinNumber = 5
ClearKeypadInterruptMcp23017(registerBaseAddress)
interruptDataBit = High # !!! ULN2803 inverts Mcp23017 INTB, so interrupt is now Low active !!!
while (interruptDataBit == High):
interruptDataBit = ReadDataBit(registerBaseAddress, RegisterAddressOffsetArrayBank0, PortStatus, PortB, KeypadInterruptPinNumber)
time.sleep(0.1) # debouncing time
# * Test Mcp23017 Decimal keypad *
def TestKeypadMcp23017(registerBaseAddress, checkPressingKeyMode, keyCount):
SetupKeypadMcp017(registerBaseAddress)
GetKeypadKeySequenceMcp23017(registerBaseAddress, checkPressingKeyMode, keyCount)
SetupKeypadMcp017(registerBaseAddress)
# * Mcp23008 x 2 based decimal keypad functions *******************************
RegisterBaseAddress1 = 0x21
RegisterBaseAddress1 = 0x22
# Mcp23008 #1 0x21 port = output, GP0~2 = Rows 0~2
# Mcp23008 #2 0x22 port = input, GP0~3 = Columns 0~3
KeypadInterruptPinMcp23008 = RPiGPIOgen6
# * Local constants *
OutputLatchRegisterResetValue = 0x00
PortStatusRegisterResetValue = 0x00
InterruptCaptureRegisterResetValue = 0x00
InterruptFlagRegisterResetValue = 0x00
# * Polling modes *
NoPollJustGetKeyEverySecond = 0
PollRowStatusNibble = 1
PollMcp23017Interrupt = 2
# * Setup keypad *
def SetupKeypadMcp23008(registerBaseAddress1, registerBaseAddress2):
SetupPortAllOutputMcp23008(registerBaseAddress1)
SetupPortAllInputMcp23008(registerBaseAddress2)
#SetupKeypadInterruptMcp23008(registerBaseAddress)
#ClearKeypadInterruptMcp23008(registerBaseAddress)
WriteKeypadColumnsAllLowMcp23008(registerBaseAddress1)
# * Setup/Clear/Check keypad interrupt *
#def SetupKeypadInterruptMcp23008(registerBaseAddress):
# SetKeypadInterruptEnableMcp23008(registerBaseAddress)
# SetKeypadDefaultValueMcp23008(registerBaseAddress)
# SetKeypadEnableCompareDefaultValueMcp23008(registerBaseAddress)
# SetKeypadBankInterruptDriverModeMcp23008(registerBaseAddress)
#def SetKeypadInterruptEnableMcp23008(registerBaseAddress):
# EnableInterruptLowNibble = 0x0f
# WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortB, EnableInterruptLowNibble)
#def SetKeypadInterruptDisableMcp23008(registerBaseAddress):
# DisableInterruptByte = 0x00
# WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InterruptEnable, PortB, DisableInterruptByte)
#def SetKeypadDefaultValueMcp23008(registerBaseAddress):
# DefaultValueByte = 0x0f # row status nibble is all bits high if no key pressed
# WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, DefaultValue, PortB, DefaultValueByte)
#def SetKeypadEnableCompareDefaultValueMcp23008(registerBaseAddress):
# InterruptOnChangeDefaultValueLowNibble = 0x0f # GPB0~3 change from default value will cause interrupt
# WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, CompareMode, PortB, InterruptOnChangeDefaultValueLowNibble)
#def SetKeypadBankInterruptDriverModeMcp23008(registerBaseAddress):
# bit 7 = 0 (Bank = 0, reg with each port are in the same bank (addresses are sequential))
# bit 6 = 0 (No mirror, INTA and INTB independent)
# bit 5 = 1 (Sequential operation disabled)
# bit 4 = 1 (Slew rate disabled)
# bit 3 = 0 (Disable MCP23S17 address pins, Don't care for Mcp23017)
# bit 2 = 0 (Interrupt driver push pull, no open drain)
# bit 1 = 1 (Interrrupt active high)
# bit 0 = 0 (Unimplemented, read as 0)
# 0b00110010 = 0x32
# Bank0DriverPushPullHighActive = 0x32
# WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, BankInterruptPinMode, PortB, Bank0DriverPushPullHighActive)
#def ClearKeypadInterruptMcp23008(registerBaseAddress):
# WriteKeypadColumnsAllLowMcp23008(registerBaseAddress)
# time.sleep(0.5)
# dummyRead = ReadInterruptCaptureLowNibble(registerBaseAddress)
# * Write columns *
def WriteKeypadColumnsMcp23008(registerBaseAddress, columnDataByte):
WriteDataByteMcp23008(registerBaseAddress, OutputLatch, columnDataByte)
def WriteKeypadColumnsAllLowMcp23008(registerBaseAddress):
WriteKeypadColumnsMcp23008(registerBaseAddress, AllLowByte)
# * Read rows *
def GetKeypadRowDataNibbleMcp23008(registerBaseAddress):
rowDataByte = ReadDataByteMcp23008(registerBaseAddress, PortStatus)
rowDataNibble = rowDataByte & 0x0f
return rowDataNibble
# * Get Row Number, Column Number, and Key Number *
def GetKeypadRowNumberMcp23008(registerBaseAddress):
RowDataNibbleTuple = 0b1110, 0b1101, 0b1011, 0b0111, 0b1111, 0b0000
rowDataNibble = GetKeypadRowDataNibbleMcp23008(registerBaseAddress)
# *** Begin debugging *****************************************************
PrintFourBitPattern("Row pattern = ", rowDataNibble)
rowNumber = RowDataNibbleTuple.index(rowDataNibble)
print ("Row number = ", rowNumber)
# *** End debugging *******************************************************
rowNumber = RowDataNibbleTuple.index(rowDataNibble)
return rowNumber
def GetKeypadColumnNumberMcp23008(registerBaseAddress1, registerBaseAddress2):
ColumnNibbleTuple = 0b1110, 0b1101, 0b1011
NoKeyPressNibble = 0b1111
for columnNibble in (ColumnNibbleTuple):
WriteKeypadColumnsMcp23008(registerBaseAddress1, columnNibble)
rowDataNibble = GetKeypadRowDataNibbleMcp23008(registerBaseAddress2)
if rowDataNibble != NoKeyPressNibble:
break
columnNumber = ColumnNibbleTuple.index(columnNibble)
return columnNumber
def GetKeypadKeyNumberMcp23008(registerBaseAddress1, registerBaseAddress2):
rowNumber = GetKeypadRowNumberMcp23008(registerBaseAddress2)
columnNumber = GetKeypadColumnNumberMcp23008(registerBaseAddress1, registerBaseAddress2)
keyNumber = (rowNumber * 3) + (columnNumber + 1)
return keyNumber
# * Get keys *
def GetKeypadKeyMcp23008(registerBaseAddress1, registerBaseAddress2, checkPressingKeyMode):
if (checkPressingKeyMode == NoPollJustGetKeyEverySecond):
print "Read key every second"
time.sleep(1)
LoopUntilOneSecondEnded()
elif (checkPressingKeyMode == PollRowStatusNibble):
print "Polling Gpio"
LoopUntilKeypadRowDataNibbleChangeMcp23008(registerBaseAddress1, registerBaseAddress2)
elif (checkPressingKeyMode == PollMcp23017Interrupt):
print "Polling Mcp23017 interrupt INTB"
LoopUntilKeypadInterruptPinMcp23008Active(registerBaseAddress2)
keyNumber = GetKeypadKeyNumberMcp23008(registerBaseAddress1, registerBaseAddress2)
return keyNumber
def GetKeypadKeySequenceMcp23008(registerBaseAddress1, registerBaseAddress2, checkPressingKeyMode, count):
for i in range (count):
OneBeep()
keyNumber = GetKeypadKeyMcp23008(registerBaseAddress1, registerBaseAddress2, checkPressingKeyMode)
print "Key", i + 1, " = ", keyNumber
time.sleep(0.25)
# * No polling, just read key at the end of each second *
def LoopUntilOneSecondEnded():
time.sleep(1)
# * Poll row status *
def LoopUntilKeypadRowDataNibbleChangeMcp23008(registerBaseAddress1, registerBaseAddress2):
WriteKeypadColumnsMcp23008(registerBaseAddress1, AllLowByte)
NoKeyPressedNibble = 0xf
rowDataNibble = NoKeyPressedNibble
while (rowDataNibble == NoKeyPressedNibble):
rowDataNibble = GetKeypadRowDataNibbleMcp23008(registerBaseAddress2)
time.sleep(0.05) # debouncing time 50mS
# * Poll interrupt pin *
def LoopUntilKeypadInterruptPinMcp23008Active(registerBaseAddress):
# Mcp23017 INTB shifted up to 5V) logical level, then connected to Mcp23017 GPB5
KeypadInterruptPinNumber = 5
ClearKeypadInterrupt(registerBaseAddress)
interruptDataBit = High # !!! ULN2803 inverts Mcp23017 INTB, so interrupt is now Low active !!!
while (interruptDataBit == High):
interruptDataBit = ReadDataBit(registerBaseAddress, RegisterAddressOffsetArrayBank0, PortStatus, PortB, KeypadInterruptPinNumber)
time.sleep(0.1) # debouncing time
# * Test Decimal keypad Mcp23008 *
def TestKeypadMcp23008(registerBaseAddress1, registerBaseAddress2, checkPressingKeyMode, keyCount):
SetupKeypadMcp23008(registerBaseAddress1, registerBaseAddress2)
GetKeypadKeySequenceMcp23008(registerBaseAddress1, registerBaseAddress2, checkPressingKeyMode, keyCount)
SetupKeypadMcp23008(registerBaseAddress1, registerBaseAddress2)
def TestKeypadMcp23017PollingMode(i2cRegisterBaseAddress):
TestKeypadMcp23017(i2cRegisterBaseAddress, checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
# * LCD1602/1604/2004 Functions ***********************************************
LcdRegisterBaseAddress = Mcp23008BaseAddress3 # 0x26
# * LCD1602A-1 16-pin connector (Mcp23008 GPIO 6-pin connector) Pin numbering *
# Pin 04 (Pin 1) RegisterSelect
# Pin 06 (Pin 2) WriteEnable
# Pin 11 (Pin 3) DataBit4 = 2
# Pin 12 (Pin 4) DataBit5 = 3
# Pin 13 (Pin 5) DataBit6 = 4
# Pin 14 (Pin 6) DataBit7 = 5
# LCD1602 software initialization procedure
# Part 1 - Pseudo 8 bit instructions to config 4 bit instruction mode (0x30, 0x30, 0x30, 0x20)
# 1. Power on, wait 20mS (> 15mS)
# 2. Write 0x3, wait 5mS (> 4.1mS) # set 8 bit interface
# 3. Write 0x3, wait 1mS (> 100uS) # set 8 bit interface
# 4. Write 0x3, wait 1mS (> 37uS) # set 8 bit interface
# 5. Write 0x2, wait 1mS (> 37uS) # set 4 bit interface
# Part 2- 4 bit instructions to config display characteristics (0x28, 0x08, 0x01, 0x06, 0x02)
# 6. Write 0x2, wait 1mS (> 37uS) 0x8 wait 1mS (> 37uS) (2 lines, 5x8 dot)
# 7. Write 0x0, wait 1mS (> 37uS) 0x8 wait 1mS (> 37uS) (cursor on, no blinking, blank screen)
# 8. Write 0x0, wait 1mS (> 37uS) 0x1 wait 2mS (> 1.52mS)(clear display)
# 9. Write 0x0, wait 1mS (> 37uS) 0xe (DisplayOnCursorOnCursorBlinkOff)
# a. Write 0x0, wait 1mS (> 37uS) 0x2 wait 2mS (cursor home)
# * LCD1602A-1 16-pin connector pin numbering *
RegisterSelect = 0 # 0 = instruction register, 1 = data register
WriteEnable = 1 # 1 = enable, 0 = disable
DataBit4 = 2
DataBit5 = 3
DataBit6 = 4
DataBit7 = 5
# * Constant data bytes *
AllZeroDataByte = 0x00
AllOneDataByte = 0xff
# * Write Enable/Disable, Select Data/Instruction masks *
EnableWriteMask = 0x02 # 0b 0000 0010
DisableWriteMask = 0xfd # 0b 1111 1101
SelectDataRegisterMask = 0x01 # 0b 0000 0001
SelectInstructionRegisterMask = 0xfe # 0b 1111 1110
# Register selection constant *
InstructionRegister = 0
DataRegister = 1
# * LCD1602A-1 control instructions *
# * Instruction codes *
EightBitInstructionMode = 0x3
FourBitInstructionMode = 0x2
TwoLineFiveTimesEightDot1 = 0x2
TwoLineFiveTimesEightDot2 = 0x8
DisplayOnCursorOnCursorBlinkOff1 = 0x0
DisplayOnCursorOnCursorBlinkOff2 = 0xe
ClearDisplay1 = 0x0
ClearDisplay2 = 0x1
CursorIncrementDisplayNoShift1 = 0x0
CursorIncrementDisplayNoShift2 = 0x6
CursorHome1 = 0x0
CursorHome2 = 0x2
# * Instruction timing *
# PowerOnResetDelay = 0.05 # 50mS
# VeryLongOperationDelay = 0.005 # 5mS
# LongOperationDelay = 0.002 # 2mS
# ShortOperationDelay = 0.00005 # 50uS
# WritePulseLength = 0.00005 # 50uS
PowerOnResetDelay = 0.1 # 100mS
VeryLongOperationDelay = 0.01 # 10mS
LongOperationDelay = 0.01 # 10mS
ShortOperationDelay = 0.001 # 1mS
WritePulseLength = 0.001 # 1mS
# * Mcp23008 LCD functions ****************************************************
def LcdGpioSetupMcp23008(registerBaseAddress):
SetupPortAllOutputMcp23008(registerBaseAddress)
def LcdConfigurationMcp23008(registerBaseAddress):
dataControlByte = AllZeroDataByte
# PrintEightBitPattern("dataControlByte01 = ", dataControlByte)
LcdDisableWriteMcp23008(registerBaseAddress, dataControlByte)
time.sleep(PowerOnResetDelay)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, VeryLongOperationDelay)
# PrintEightBitPattern("dataControlByte02 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte03 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte04 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, FourBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte05 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, TwoLineFiveTimesEightDot1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte06 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, TwoLineFiveTimesEightDot2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte07 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, DisplayOnCursorOnCursorBlinkOff1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte08 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, DisplayOnCursorOnCursorBlinkOff2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte09 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, ClearDisplay1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte10 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, ClearDisplay2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte11 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, CursorIncrementDisplayNoShift1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte12 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, CursorIncrementDisplayNoShift2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte13 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, CursorHome1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte14 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, CursorHome2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte15 = ", dataControlByte)
return dataControlByte
def LcdSelectDataRegisterMcp23008(registerBaseAddress, dataByte):
dataByte = dataByte | SelectDataRegisterMask
LcdWriteDataByteMcp23008(registerBaseAddress, dataByte)
return dataByte
def LcdSelectInstructionRegisterMcp23008(registerBaseAddress, dataByte):
dataByte = dataByte & SelectInstructionRegisterMask
LcdWriteDataByteMcp23008(registerBaseAddress, dataByte)
return dataByte
def LcdEnableWriteMcp23008(registerBaseAddress, dataByte):
dataByte = dataByte | EnableWriteMask
LcdWriteDataByteMcp23008(registerBaseAddress, dataByte)
return dataByte
def LcdDisableWriteMcp23008(registerBaseAddress, dataByte):
dataByte = dataByte & DisableWriteMask
LcdWriteDataByteMcp23008(registerBaseAddress, dataByte)
return dataByte
def LcdWritePulseMcp23008(registerBaseAddress, dataByte):
LcdEnableWriteMcp23008(registerBaseAddress, dataByte)
time.sleep(WritePulseLength)
LcdDisableWriteMcp23008(registerBaseAddress, dataByte)
return dataByte
def LcdWriteDataByteMcp23008(registerBaseAddress, dataByte):
WriteDataByteMcp23008(registerBaseAddress, OutputLatch, dataByte)
return dataByte
def LcdWriteDataNibbleMcp23008(registerBaseAddress, dataByte, dataNibble, registerType, operationDelay):
dataNibble = dataNibble << 2
dataByte = dataByte & 0b11000011
dataByte = dataByte | dataNibble
if (registerType == InstructionRegister):
dataByte = LcdSelectInstructionRegisterMcp23008(registerBaseAddress, dataByte)
elif (registerType == DataRegister):
dataByte = LcdSelectDataRegisterMcp23008(registerBaseAddress, dataByte)
LcdDisableWriteMcp23008(registerBaseAddress, dataByte)
dataByte = LcdWriteDataByteMcp23008(registerBaseAddress, dataByte)
LcdWritePulseMcp23008(registerBaseAddress, dataByte)
time.sleep(operationDelay)
return dataByte
def LcdWriteCharFourBitModeMcp23008(registerBaseAddress, dataControlByte, asciiChar, registerType):
charUpperNibble = ord(asciiChar) >> 4
charLowerNibble = ord(asciiChar) & 0x0f
LcdWriteCharTwoNibblesMcp23008(registerBaseAddress, dataControlByte, charUpperNibble, charLowerNibble, registerType)
return dataControlByte
def LcdWriteDataByteFourBitModeMcp23008(registerBaseAddress, dataControlByte, dataByte, registerType):
upperNibble = dataByte >> 4
lowerNibble = dataByte & 0x0f
LcdWriteCharTwoNibblesMcp23008(registerBaseAddress, dataControlByte, upperNibble, lowerNibble, registerType)
return dataControlByte
def LcdWriteCharTwoNibblesMcp23008(registerBaseAddress, dataControlByte, upperNibble, lowerNibble, registerType):
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, upperNibble, registerType, ShortOperationDelay)
# PrintEightBitPattern("dataControlByte01 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23008(registerBaseAddress, dataControlByte, lowerNibble, registerType, ShortOperationDelay)
# PrintEightBitPattern("dataControlByte02 = ", dataControlByte)
return dataControlByte
def LcdWriteCharStringMcp23008(registerBaseAddress, dataControlByte, string):
for asciiChar in (string):
LcdWriteCharFourBitModeMcp23008(registerBaseAddress, dataControlByte, asciiChar, DataRegister)
return dataControlByte
def LcdMoveCursorMcp23008(registerBaseAddress, dataControlByte, rowNumber, columnNumber):
if (rowNumber == 1):
cursorByte = 0x80 | (0x00 + (columnNumber - 1)) # command = 0x80, row 1 DDRAM start address = 0x10
elif (rowNumber == 2):
cursorByte = 0x80 | (0x40 + (columnNumber - 1)) # row 2 DDRAM start address = 0x40
LcdWriteDataByteFourBitModeMcp23008(registerBaseAddress, dataControlByte, cursorByte, InstructionRegister)
# charUpperNibble = cursorByte >> 4
# charLowerNibble = cursorByte & 0x0f
# dataControlByte = LcdWriteDataNibble(registerBaseAddress, dataControlByte, charUpperNibble, InstructionRegister, ShortOperationDelay)
# dataControlByte = LcdWriteDataNibble(registerBaseAddress, dataControlByte, charLowerNibble, InstructionRegister, ShortOperationDelay)
return dataControlByte
# * Test LCD1602 Mcp23008 *
def TestLcdMcp23008(registerBaseAddress):
LcdGpioSetupMcp23008(registerBaseAddress)
dataControlByte = LcdConfigurationMcp23008(registerBaseAddress)
dataControlByte = LcdMoveCursorMcp23008(registerBaseAddress, dataControlByte, 1, 1)
dataControlByte = LcdWriteCharStringMcp23008(registerBaseAddress, dataControlByte, ProgramTitle1)
dataControlByte = LcdMoveCursorMcp23008(registerBaseAddress, dataControlByte, 2, 1)
dataControlByte = LcdWriteCharStringMcp23008(registerBaseAddress, dataControlByte, ProgramTitle2)
# * MCP23017 LCD Functions ****************************************************
def LcdGpioSetupMcp23017(registerBaseAddress):
#registerBaseAddress = Mcp23017BaseAddressSystemB1
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
def LcdConfigurationMcp23017(registerBaseAddress):
dataControlByte = AllZeroDataByte
# PrintEightBitPattern("dataControlByte01 = ", dataControlByte)
LcdDisableWriteMcp23017(registerBaseAddress, dataControlByte)
time.sleep(PowerOnResetDelay)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, VeryLongOperationDelay)
# PrintEightBitPattern("dataControlByte02 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte03 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte04 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, FourBitInstructionMode, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte05 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, TwoLineFiveTimesEightDot1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte06 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, TwoLineFiveTimesEightDot2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte07 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, DisplayOnCursorOnCursorBlinkOff1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte08 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, DisplayOnCursorOnCursorBlinkOff2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte09 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, ClearDisplay1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte10 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, ClearDisplay2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte11 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, CursorIncrementDisplayNoShift1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte12 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, CursorIncrementDisplayNoShift2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte13 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, CursorHome1, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte14 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, CursorHome2, InstructionRegister, LongOperationDelay)
# PrintEightBitPattern("dataControlByte15 = ", dataControlByte)
return dataControlByte
def LcdSelectDataRegisterMcp23017(registerBaseAddress, dataByte):
dataByte = dataByte | SelectDataRegisterMask
LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
return dataByte
def LcdSelectInstructionRegisterMcp23017(registerBaseAddress, dataByte):
dataByte = dataByte & SelectInstructionRegisterMask
LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
return dataByte
def LcdEnableWriteMcp23017(registerBaseAddress, dataByte):
dataByte = dataByte | EnableWriteMask
LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
return dataByte
def LcdDisableWriteMcp23017(registerBaseAddress, dataByte):
dataByte = dataByte & DisableWriteMask
LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
return dataByte
def LcdWritePulseMcp23017(registerBaseAddress, dataByte):
LcdEnableWriteMcp23017(registerBaseAddress, dataByte)
time.sleep(WritePulseLength)
LcdDisableWriteMcp23017(registerBaseAddress, dataByte)
return dataByte
def LcdWriteDataByteMcp23017(registerBaseAddress, dataByte):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, dataByte)
return dataByte
def LcdWriteDataNibbleMcp23017(registerBaseAddress, dataByte, dataNibble, registerType, operationDelay):
dataNibble = dataNibble << 2
dataByte = dataByte & 0b11000011
dataByte = dataByte | dataNibble
if (registerType == InstructionRegister):
dataByte = LcdSelectInstructionRegisterMcp23017(registerBaseAddress, dataByte)
elif (registerType == DataRegister):
dataByte = LcdSelectDataRegisterMcp23017(registerBaseAddress, dataByte)
#print "MCP23017 dataControlByte = ", hex(dataByte)
#pdb.set_trace()
LcdDisableWriteMcp23017(registerBaseAddress, dataByte)
dataByte = LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
LcdWritePulseMcp23017(registerBaseAddress, dataByte)
time.sleep(operationDelay)
return dataByte
def LcdWriteCharFourBitModeMcp23017(registerBaseAddress, dataControlByte, asciiChar, registerType):
charUpperNibble = ord(asciiChar) >> 4
charLowerNibble = ord(asciiChar) & 0x0f
LcdWriteCharTwoNibblesMcp23017(registerBaseAddress, dataControlByte, charUpperNibble, charLowerNibble, registerType)
return dataControlByte
def LcdWriteDataByteFourBitModeMcp23017(registerBaseAddress, dataControlByte, dataByte, registerType):
upperNibble = dataByte >> 4
lowerNibble = dataByte & 0x0f
LcdWriteCharTwoNibblesMcp23017(registerBaseAddress, dataControlByte, upperNibble, lowerNibble, registerType)
return dataControlByte
def LcdWriteCharTwoNibblesMcp23017(registerBaseAddress, dataControlByte, upperNibble, lowerNibble, registerType):
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, upperNibble, registerType, ShortOperationDelay)
# PrintEightBitPattern("dataControlByte01 = ", dataControlByte)
dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, lowerNibble, registerType, ShortOperationDelay)
# PrintEightBitPattern("dataControlByte02 = ", dataControlByte)
return dataControlByte
def LcdWriteCharStringMcp23017(registerBaseAddress, dataControlByte, string):
for asciiChar in (string):
LcdWriteCharFourBitModeMcp23017(registerBaseAddress, dataControlByte, asciiChar, DataRegister)
return dataControlByte
def LcdMoveCursorMcp23017(registerBaseAddress, dataControlByte, rowNumber, columnNumber):
if (rowNumber == 1):
cursorByte = 0x80 | (0x00 + (columnNumber - 1)) # command = 0x80, row 1 DDRAM start address = 0x10
elif (rowNumber == 2):
cursorByte = 0x80 | (0x40 + (columnNumber - 1)) # row 2 DDRAM start address = 0x40
LcdWriteDataByteFourBitModeMcp23017(registerBaseAddress, dataControlByte, cursorByte, InstructionRegister)
# charUpperNibble = cursorByte >> 4
# charLowerNibble = cursorByte & 0x0f
# dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, charUpperNibble, InstructionRegister, ShortOperationDelay)
# dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, charLowerNibble, InstructionRegister, ShortOperationDelay)
return dataControlByte
# * Test LCD1602 functions *
def TestLcdMcp23017(i2cRegisterBaseAddress):
LcdGpioSetupMcp23017(i2cRegisterBaseAddress)
dataControlByte = LcdConfigurationMcp23017(i2cRegisterBaseAddress)
dataControlByte = LcdMoveCursorMcp23017(i2cRegisterBaseAddress, dataControlByte, 1, 1)
dataControlByte = LcdWriteCharStringMcp23017(i2cRegisterBaseAddress, dataControlByte, ProgramTitle1)
dataControlByte = LcdMoveCursorMcp23017(i2cRegisterBaseAddress, dataControlByte, 2, 1)
dataControlByte = LcdWriteCharStringMcp23017(i2cRegisterBaseAddress, dataControlByte, ProgramTitle2)
# *** Unipolar Stepping Motor 28BYJ48/NPM-PF35/PX245 **************************
# Unipolar Stepping Motor Switching Sequence
# 1. Wave sequence = 1 - 3 - 2 - 4 (A-, B-, A+, B+)
# 2. Full step sequence = 13 - 14 - 24 - 23 (A-B-, A-B+, A+B+, A+B-)
# 3. Half step sequence = 13 - 1 - 14 - 4 - 24 - 2 - 23 - 3
# 4. One step swing = 1 - 3 - 1 - 3 (A-, B-, A-, B-)
# Winding A-(1) A+(2) B-(3) B+(4) COM
# NPM PF35 Black Yellow Brown Orange Red
# 28BYJ48 Pink Orange Blue Yellow Red
# PX245 Black Green Blue Red Yelow/White
# * Convert decimal pin number to hex *
def convert1PinToHex(p): # convert 1 of 8 high pin to hex
hexString = 0x01
for count in range(p-1):
hexString = hexString << 1
return hexString
def convert2PinToHex(p1, p2): # convert 2 of 8 high pins to hex
return (convert1PinToHex(p1) | convert1PinToHex(p2))
def convert2PinToHighNibble(p1, p2): # convert 2 of 8 high pins to high nibble
lowNibble = convert1PinToHex(p1) | convert1PinToHex(p2)
highNibble = lowNibble << 4
return highNibble
# * Move unipolar stepping motor *
def WriteMotorWindingWaveSequence1324(RegisterBaseAddress, NibbleType, StepCount, StepTime): # move motor using 13-24 sequence
# Set port all output
WriteDataByte(Mcp23008BaseAddress1, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortA, AllOutputByte)
if NibbleType == LowNibble:
hexString1 = convert2PinToHex(1, 3)
hexString2 = convert2PinToHex(2, 4)
else:
hexString1 = convert2PinToHighNibble(1, 3)
hexString2 = convert2PinToHighNibble(2, 4)
for i in range(StepCount):
WriteDataByte(Mcp23008BaseAddress1, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, hexString1)
time.sleep(StepTime)
WriteDataByte(Mcp23008BaseAddress1, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, hexString2)
time.sleep(StepTime)
def WriteMotorWindingFullStepSequence13232414(RegisterBaseAddress, NibbleType, StepCount, StepTime): #move motor using 13-23-24-14 sequence
# Set port all output
WriteDataByte(Mcp23008BaseAddress1, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortA, AllOutputByte)
if NibbleType == LowNibble:
motorWindingActivationPatternArray = (0x05, 0x06, 0x0a, 0x09)
else:
motorWindingActivationPatternArray = (0x50, 0x60, 0xa0, 0x90)
for i in range(StepCount):
for pattern in motorWindingActivationPatternArray:
WriteDataByte(Mcp23008BaseAddress1, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, pattern)
time.sleep(StepTime)
def TestConvert1PinToHex(): # test convert 1 high pin to hex
print "*** Testing 1 pin number decimal 0 ~ 7 converted to hexdecimal 0x01 ~ 0x80"
for d in range(8):
print hex(convert1PinToHex(d))
def TestConvert2PinToHex(p1, p2): # test convert 2 high pins to hex
print "*** Testing 2 pin numbers decimal 0 ~ 7 converted to hexdecimal"
print "Pin 1 = ", p1, "Pin 2 = ", p2
print "Hex = ", hex(convert2PinToHex(p1, p2))
def TestConvert2PinToHighNibble(p1, p2): # test convert 2 of 8 high pins to high nibble
print "*** Testing 2 pin numbers decimal 0 ~ 7 converted to high nibble"
print "Pin 1 = ", p1, "Pin 2 = ", p2
print "HighNibble = ", hex(convert2PinToHighNibble(p1, p2))
def MoveTwoMotors(RegisterBaseAddress):
OneBeep()
WriteMotorWindingWaveSequence1324(Mcp23008BaseAddress1, LowNibble, TwentyTimes, FiftyMilliSeconds)
OneBeep()
WriteMotorWindingWaveSequence1324(Mcp23008BaseAddress1, HighNibble, TwentyTimes, FiftyMilliSeconds)
OneBeep()
WriteMotorWindingFullStepSequence13232414(Mcp23008BaseAddress1, LowNibble, TwentyTimes, OneHundredMilliSeconds)
OneBeep()
WriteMotorWindingFullStepSequence13232414(Mcp23008BaseAddress1, HighNibble, TwentyTimes, OneHundredMilliSeconds)
def TestMotor():
MotorRegisterBaseAddress = Mcp23008BaseAddress1
MoveTwoMotors(MotorRegisterBaseAddress)
def MoveUnipolarSteppingMotor(registerBaseAddress, NibbleType, StepCount, StepTime):
SetupPortAoutputPortBinputPullUpMcp23017(registerBaseAddress)
if NibbleType == LowNibble:
hexString1 = convert2PinToHex(1, 3)
hexString2 = convert2PinToHex(2, 4)
else:
hexString1 = convert2PinToHighNibble(1, 3)
hexString2 = convert2PinToHighNibble(2, 4)
for i in range(StepCount):
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, hexString1)
time.sleep(StepTime)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, hexString2)
time.sleep(StepTime)
def TestMoveMotor():
registerBaseAddress = Mcp23017BaseAddressSystemB1
nibbleType = LowNibble
stepCount = OneHundredTimes
stepTime = OneHundredMilliSeconds
MoveUnipolarSteppingMotor(registerBaseAddress, nibbleType, 500, 0.05)
# * Demultiplexer *************************************************************
DemuxRegisterBaseAddress = 0x20
def DemuxGpioSetup(registerBaseAddress):
UpperNibbleInputLowerNibbleOutput = 0xf0 # Input (GP4~7, Row0~3), Output (GP0~3, Column0~2, 3 reserved)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, InputOutputDirection, PortA, UpperNibbleInputLowerNibbleOutput)
InitialControlDateByte = 0x00
return InitialControlDateByte
def DemuxAddressLatch(controlDataByte, latchAction):
DemuxAddressLatchMask = 0b00001000
Enable = 1
Disable = 0
if (latchAction == Enable):
controlDataByte = controlDataByte | DemuxAddressLatchMask
elif (latchAction == Disable):
controlDataByte = controlDataByte & ~(DemuxAddressLatchMask)
return controlDataByte
def SetDemuxChannel(registerBaseAddress, controlDataByte, addressNibble):
Enable = 1
Disable = 0
controlDataByte = controlDataByte & 0b11110000
addressNibble = addressNibble & 0b00000111
controlDataByte = controlDataByte | addressNibble
controlDataByte = DemuxAddressLatch(controlDataByte, Disable)
PrintEightBitPattern("demuxDataByte = ", controlDataByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, controlDataByte)
controlDataByte = DemuxAddressLatch(controlDataByte, Enable)
PrintEightBitPattern("demuxDataByte = ", controlDataByte)
WriteDataByte(registerBaseAddress, RegisterAddressOffsetArrayBank0, OutputLatch, PortA, controlDataByte)
return controlDataByte
def TestDemux(demuxRegisterBaseAddress, channelNumber):
controlDataByte = DemuxGpioSetup(demuxRegisterBaseAddress)
controlDataByte = SetDemuxChannel(demuxRegisterBaseAddress, controlDataByte, channelNumber)
def TestDemuxLcd(demuxRegisterBaseAddress, lcdRegisterBaseAddress, channelNumber1, channelNumber2):
Row1 = 1
Row2 = 2
Row3 = 3
Row4 = 4
Column1 = 1
# Setup one Mcp23008 for Demultiplexor, another Mcp23008 for LCD1602/LCD2004
controlDataByte = DemuxGpioSetup(demuxRegisterBaseAddress)
LcdGpioSetup(lcdRegisterBaseAddress)
# Select demux channelNumber1
controlDataByte = SetDemuxChannel(demuxRegisterBaseAddress, controlDataByte, channelNumber1)
# Display two lines in the LCD at this channel
dataControlByte = LcdConfiguration(lcdRegisterBaseAddress)
dataControlByte = LcdMoveCursor(lcdRegisterBaseAddress, dataControlByte, Row1, Column1)
dataControlByte = LcdWriteCharString(lcdRegisterBaseAddress, dataControlByte, "Channel 1 01")
dataControlByte = LcdMoveCursor(lcdRegisterBaseAddress, dataControlByte, Row2, Column1)
dataControlByte = LcdWriteCharString(lcdRegisterBaseAddress, dataControlByte, "2013-01-28 v201")
time.sleep(2)
# Select demux channelNumber2
controlDataByte = SetDemuxChannel(demuxRegisterBaseAddress, controlDataByte, channelNumber2)
# Display two lines in the LCD at this channel
dataControlByte = LcdConfiguration(lcdRegisterBaseAddress)
dataControlByte = LcdMoveCursor(lcdRegisterBaseAddress, dataControlByte, Row1, Column1)
dataControlByte = LcdWriteCharString(lcdRegisterBaseAddress, dataControlByte, "Channel 2 01")
dataControlByte = LcdMoveCursor(lcdRegisterBaseAddress, dataControlByte, Row2, Column1)
dataControlByte = LcdWriteCharString(lcdRegisterBaseAddress, dataControlByte, "2013-01-30 v204")
time.sleep(2)
# * SPI using bit banging (from Arduino/Netduino, not tested here *************
# SpiClockPin = RPiGpioGen11
# SpiMosiPin = RPiGpioGen10
# SpiMisoPin = RPiGpioGen9
# SpiSelect0Pin = RPiGpioGen8
# SpiSelect1Pin = RPiGpioGen7
def TestRfm12b(registerBaseAddress):
SetupGPIOpins(OutputPinList, InputPinWithNoPullUpList, InputPinWithPullUpList )
def SpiSelectDevice(deviceNumber):
if (deviceNumber == 0):
writeOutputPin(SpiSelect0Pin, Low)
else:
writeOutputPin(SpiSelect1Pin, Low)
def SpiDisSelectDevice(deviceNumber):
if (deviceNumber == 0):
writeOutputPin(SpiSelect0Pin, High)
else:
writeOutputPin(SpiSelect1Pin, High)
def SpiClockPulse():
writeOutputPin(SpiClockPin, High)
time.sleep(1)
writeOutputPin(SpiClockPin, Low)
time.sleep(1)
def SpiWriteBit(dataBit):
if (dataBit == 1):
writeOutputPin(SpiMosiPin, High)
else:
writeOutputPin(SpiMosiPin, Low)
def SpiReadBit(inputPin):
dataBit = readInputPin(inputPin)
# print dataBit
return dataBit
# * Test Spi functions *
def TestSpiSelectDevice(deviceNumber, count):
print "Now testing SPI device select pin", deviceNumber, ",..."
for i in range (count):
SpiSelectDevice(deviceNumber)
time.sleep(1)
SpiDisSelectDevice(deviceNumber)
time.sleep(1)
def TestSpiClockPulse(count):
for i in range (count):
SpiClockPulse()
def TestSpiWriteBit(count):
for i in range (count):
SpiWriteBit(1)
time.sleep(1)
SpiWriteBit(0)
time.sleep(1)
def TestSpiReadBit(inputPin, count):
for i in range (count):
dataBit = SpiReadBit(inputPin)
if (dataBit == True):
dataLevel = "High"
else:
dataLevel = "Low"
print "dataBitRead at pin number ", inputPin, " = ", dataLevel
time.sleep(1)
# * WiringPi Python wrapping SPI test functions *******************************
def TestWiringPiSpi():
print "\n" + "*** Start testing wiringPi SPI, ... ***" + "\n"
spi = spidev.SpiDev() # create spidev object
spi.open(0,0) # open SPI0, CE0_N
SendByteList = [0x55, 0xaa, 0xAA]
ReadByteList = spi.xfer2(SendByteList)
print "Bytes read = " + hex(ReadByteList[0]) + " " + hex(ReadByteList[1]) + " " + hex(ReadByteList[2])
print "\n" + "*** Stop testing wiringPi SPI, ... ***" + "\n"
# * RFM12b 434Mhz Wireless Transceiver Functions ******************************
# * Arduino C++ functions *
# define wkupOn 0x820E // turn on wake up timer (also xtl, lvd)
# define wkupOff 0x820C // turn off wake up timer (xtl, lvd still on)
# define wkup2ms 0XE002 // wake up every 2mS
# define config01 0x80D7
# define power01 0x8239
# define freq01 0xA640
# define drate01 0xC647
# define rxctrl01 0x94A0
# define fifors01 0xCA81
# define syncpt01 0xCED4
# define afc01 0xC483
# define txctrl01 0x9850
# define pll01 0xCC77
# define wkup01 0xE000
# define ldc01 0xC800
# define lbdclk01 0xC400
# define lvdOn 0x820C // turn on low voltage detection (also xtal, mcu clk)
# define lvd27 0xC064 // set low voltage threshold 2.7V (2.2 + 0.1 * 4) 2MHz,
# define status 0x0000 // read status to execute command and clear interrupt
#void RFM12B01::setupRfm12b()
# {
# putWord(0x80D7); //enable tx, rx fifo, 433MHz, 12.0pF
# // putWord(0x8239); //enable xmitt, syn, xtal, disable clk
# putWord(0xA640); //operation frequency ???
# putWord(0xC647); //data rate 4.8kbps
# putWord(0x94A0); //VDI,FAST,134kHz,0dBm,-103dBm
# putWord(0xC2AC); //clk rec auto, digi fltr,DQD4
# putWord(0xCA81); //fifo8,sync 1, sync, no fifo fill
# putWord(0xCED4); //sync pattern d4
# putWord(0xC483); //offset VDI hi, no restrict, afc, afc out
# putWord(0x9850); //90kHz, max o/p pwr (odBm)
# putWord(0xCC17); //10MHz, 620uA, disable pll dit, 256kbps
# putWord(0xE000); //wake up timer not used
# putWord(0xC800); //low duty cycle not used
# putWord(0xC040); //1.66MHz,2.2V low battery
# }
#void RFM12B01::testSetupClock2Mhz()
# {
# putWord(0xC064);
# }
def PrintDoubleSpaceLine(line):
print "\n" + line + "\n"
def WaitSeconds(count):
time.sleep(count)
# * Rfm12b 2 byte commands *
SetExternalMpuClockFrequency1Mhz = [0xc0, 0x04] # 1 MHz, 2.7V (2.2 + 0.1 * 4)
SetExternalMpuClockFrequency2Mhz = [0xc0, 0x64] # 2 MHz, 2.7V (2.2 + 0.1 * 4)
SetExternalMpuClockFrequency5Mhz = [0xc0, 0xc4] # 5 MHz, 2.7V (2.2 + 0.1 * 4)
SetExternalMpuClockFrequency10Mhz = [0xc0, 0xe4] # 10 MHz, 2.7V (2.2 + 0.1 * 4)
EnableWakeupTimerEnableXtlLvd = [0x82, 0x0e]
DisableWakeupTimerEnableXtlLvd = [0x82, 0x0c]
SetWakeUpTimer2Ms = [0xe0, 0x02]
ClearInterrupt = [0x00, 0x00]
def TestRfm12bSet2Mhz():
PrintDoubleSpaceLine("*** Start testing RFM12B 2 MHz ***")
rfm12bSpi = spidev.SpiDev() # create spi object to entertain RFM12B
rfm12bSpi.open(0,0) # open sci channel 0 and select slave device 0
ExternalMpuClockFrequency2Mhz = [0xC0, 0x64]
receiveByteList = rfm12bSpi.xfer2(ExternalMpuClockFrequency2Mhz)
print "Bytes read = " + hex(receiveByteList[0]) + " " + hex(receiveByteList[1])
PrintDoubleSpaceLine("*** Stop testing RFM12B ***")
def TestRfm12bSet1Mhz():
PrintDoubleSpaceLine("*** Start testing RFM12B 1 MHz ***")
rfm12bSpi = spidev.SpiDev() # create spi object to entertain RFM12B
rfm12bSpi.open(0,0) # open sci channel 0 and select slave device 0
ExternalMpuClockFrequency2Mhz = [0xc0, 0x04]
receiveByteList = rfm12bSpi.xfer2(ExternalMpuClockFrequency2Mhz)
print "Bytes read = " + hex(receiveByteList[0]) + " " + hex(receiveByteList[1])
PrintDoubleSpaceLine("*** Stop testing RFM12B ***")
def OpenSpiChannel(spiObject, spiChannelNumber, spiDeviceNumber):
spiObject.open(spiChannelNumber, spiDeviceNumber)
def Rfm12bSendCommand1(spiChannelNumber, spiDeviceNumber, sendByteList):
rfm12bSpi = spidev.SpiDev()
rfm12bSpi.open(spiChannelNumber, spiDeviceNumber)
receiveByteList = rfm12bSpi.xfer2(sendByteList)
def Rfm12bSendCommand2(rfm12bSpi, sendByteList):
receiveByteList = rfm12bSpi.xfer2(sendByteList)
def Rfm12bTest1(spiChannelNumber, spiDeviceNumber):
PrintDoubleSpaceLine("*** Start Test 1 ***")
rfm12bSpi = spidev.SpiDev() # create spi object to entertain RFM12B
rfm12bSpi.open(0,0) # open sci channel 0 and select slave device 0
Rfm12bSendCommand1(spiChannelNumber, spiDeviceNumber, SetExternalMpuClockFrequency2Mhz)
WaitSeconds(2)
Rfm12bSendCommand1(spiChannelNumber, spiDeviceNumber, SetExternalMpuClockFrequency5Mhz)
WaitSeconds(2)
Rfm12bSendCommand1(spiChannelNumber, spiDeviceNumber, SetExternalMpuClockFrequency10Mhz)
WaitSeconds(2)
Rfm12bSendCommand1(spiChannelNumber, spiDeviceNumber, SetExternalMpuClockFrequency1Mhz)
WaitSeconds(2)
PrintDoubleSpaceLine("*** Stop Test 1 ***")
def Rfm12bTest2(spiChannelNumber, spiDeviceNumber):
PrintDoubleSpaceLine("*** Start Test 2 ***")
rfm12bSpi = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi, spiChannelNumber, spiDeviceNumber)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency2Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency5Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency10Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency1Mhz)
WaitSeconds(2)
PrintDoubleSpaceLine("*** Stop Test 2 ***")
def Rfm12bTest3a(spiChannelNumber, spiDeviceNumber):
PrintDoubleSpaceLine("*** Start Test 3a ***")
rfm12bSpi = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi, spiChannelNumber, spiDeviceNumber)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency2Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency5Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency1Mhz)
WaitSeconds(2)
Rfm12bSendCommand2(rfm12bSpi, TurnOnWakeupXtlLvd)
Rfm12bSendCommand2(rfm12bSpi, WakeUpEvery2Ms)
# WaitSeconds(2)
# Rfm12bSendCommand2(rfm12bSpi, TurnOffWakeupTurnOnXtlLvd)
PrintDoubleSpaceLine("*** Stop Test 3a ***")
def Rfm12bTest3b(spiChannelNumber, spiDeviceNumber):
PrintDoubleSpaceLine("*** Start Test 3b 2013feb2601 ***")
rfm12bSpi = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi, spiChannelNumber, spiDeviceNumber)
Rfm12bSendCommand2(rfm12bSpi, SetExternalMpuClockFrequency2Mhz)
Rfm12bSendCommand2(rfm12bSpi, TurnOnWakeupXtlLvd)
for i in range (100000):
Rfm12bSendCommand2(rfm12bSpi, WakeUpEvery2Ms)
time.sleep(0.005)
Rfm12bSendCommand2(rfm12bSpi, ClearInterrupt)
time.sleep(0.010)
Rfm12bSendCommand2(rfm12bSpi, TurnOffWakeupTurnOnXtlLvd)
PrintDoubleSpaceLine("*** Stop Test 3b ***")
def Rfm12bTest3c(spiChannelNumber, spiDeviceNumber0, spiDeviceNumber1):
PrintDoubleSpaceLine("*** Start Test 3c 2013feb2602 ***")
rfm12bSpi00 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi00, spiChannelNumber, spiDeviceNumber0)
Rfm12bSendCommand2(rfm12bSpi00, SetExternalMpuClockFrequency5Mhz)
rfm12bSpi01 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi01, spiChannelNumber, spiDeviceNumber1)
Rfm12bSendCommand2(rfm12bSpi01, SetExternalMpuClockFrequency10Mhz)
PrintDoubleSpaceLine("*** Stop Test 3c ***")
def Rfm12bTest3d(spiChannelNumber, spiDeviceNumber0, spiDeviceNumber1):
PrintDoubleSpaceLine("*** Start Test 3d 2013feb2603 ***")
rfm12bSpi00 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi00, spiChannelNumber, spiDeviceNumber0)
Rfm12bSendCommand2(rfm12bSpi00, SetExternalMpuClockFrequency2Mhz)
rfm12bSpi01 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi01, spiChannelNumber, spiDeviceNumber1)
Rfm12bSendCommand2(rfm12bSpi01, SetExternalMpuClockFrequency5Mhz)
for i in range(4):
Beep(1)
Rfm12bSendCommand2(rfm12bSpi00, DisableWakeupTimerEnableXtlLvd)
Rfm12bSendCommand2(rfm12bSpi00, ClearInterrupt)
time.sleep(2)
Beep(2)
Rfm12bSendCommand2(rfm12bSpi00, EnableWakeupTimerEnableXtlLvd)
Rfm12bSendCommand2(rfm12bSpi00, SetWakeUpTimer2Ms)
time.sleep(2)
Beep(3)
Rfm12bSendCommand2(rfm12bSpi01, DisableWakeupTimerEnableXtlLvd)
Rfm12bSendCommand2(rfm12bSpi01, ClearInterrupt)
time.sleep(2)
Beep(4)
Rfm12bSendCommand2(rfm12bSpi01, EnableWakeupTimerEnableXtlLvd)
Rfm12bSendCommand2(rfm12bSpi01, SetWakeUpTimer2Ms)
time.sleep(2)
PrintDoubleSpaceLine("*** Stop Test 3d ***")
def TestRfm12bExtMpuClock(spiChannelNumber, Rfm12bSpiDeviceNumber0, Rfm12bSpiDeviceNumber1):
PrintDoubleSpaceLine("*** Start RFM12B Test ***")
rfm12bSpi00 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi00, spiChannelNumber, Rfm12bSpiDeviceNumber0)
Rfm12bSendCommand2(rfm12bSpi00, SetExternalMpuClockFrequency5Mhz)
rfm12bSpi01 = spidev.SpiDev()
OpenSpiChannel(rfm12bSpi01, spiChannelNumber, Rfm12bSpiDeviceNumber1)
Rfm12bSendCommand2(rfm12bSpi01, SetExternalMpuClockFrequency2Mhz)
PrintDoubleSpaceLine("*** Stop Test ***")
def TestDualRfm12bExtMpuClock(spiChannelNumber):
TestRfm12bExtMpuClock(spiChannelNumber, Rfm12bSpiDeviceNumber0 = 0, Rfm12bSpiDeviceNumber1 = 1)
# * RPIO Servo PWM Functions **************************************************
# *** RPIO.PWM/Servo References ***********************************************
# RPIO.PWM, PWM via DMA for the Raspberry Pi
# http://pythonhosted.org/RPIO/pwm_py.html
# PCA9685 16-channel, 12-bit PWM Fm+ I2 C-bus LED controller
# http://www.nxp.com/documents/data_sheet/PCA9685.pdf
# TSSOP28\SSOP28\DIP28 Adapter
# http://item.taobao.com/item.htm?spm=a230r.1.14.108.UHRZYa&id=12717853271
# Adafruit 16-Channel 12-bit PWM/Servo Driver - I2C interface - PCA9685
# http://www.adafruit.com/products/815
# http://learn.adafruit.com/adafruits-raspberry-pi-lesson-8-using-a-servo-motor/servo-motors
# http://learn.adafruit.com/adafruits-raspberry-pi-lesson-8-using-a-servo-motor/the-pwm-and-servo-kernel-module
# *** Seeeduino & Towerpro SG90 Test Program (tlfong01 2009jan08) *************
# http://www.todopic.com.ar/foros/index.php?topic=24768.5;wap2
# /******************************************************************************
# * Hello Servo - Turn TowerPro SG90 servo to middle position
# * Created - 2009jan07, Last update - 2008jan07
# * Function - Turn servo to middle position
# * MPU/Programming language - Seeeduino v1.1/Arduino v12.0
# * Author - TL Fong (tlfong01, TaoBao)
# * Copyright - Creative Commons Attribution - ShareAlike 3.0 Licence
# *
# * Test procedure
# * (1) FIRST run the program, [!!! DO NOT POWER ON YET !!! tlfong01 2013mar13]
# * (2) Manually turn servo clockwise or counterclock to limit,
# * (3) Connect 5V power and MPU signal to servo,
# * (4) WARNING - Disconnect 5V power before stopping program,
# *
# * TowerPro SG90 Spec
# * CCW end 900uS, CW end 2100uS, middle 1500uS, 3.0 to 6.0V,
# * 9g, 22 * 11.5 * 27mm, 0.12sec/60 degrees (4.8V no load),
# * stall torque 17.5ozin/1.2 kgcm) (4.8V), dead band 7usec,
# * coreless motor, all nylon gear, RMB30 (TaoBao).
# *
# * Notes
# * 1. To turn counter clockwise limit, change pulse width from 1500 to 900.
# * 2. To turn clockwise limit, change pulse width from to 2100.
# *** RPi GPIO pin numbering **************************************************
# RPiGPIOgen1 = 18 # (P1-12, BCM GPIO 18) PCM_CLK
# RPiGPIOGclk = 04 # (P1-07, BCM GPIO 04) GPIO_GCLK
# RPiPcm = RPiGPIOgen1
# RPiGpclk0 = RPiGPIOGclk
# *** Test servo functions ****************************************************
CounterClockwiseLimitPulseWidth = 900 # CCW limit = 900 uS = 0.9 mS
ClockwiseLimitPulseWidth = 2100 # CW limit = 2100 uS = 2.1 mS
MiddlePositionPulseWidth = 1500 # Middle position = 1500 uS = 1.5 mS
def TestRpioServo():
PrintDoubleSpaceLine("*** Testing RPIO.PCM tlfong01 2013mar25 ***")
RpioServoController = PWM.Servo() # default 20ms subcycle
RpioServoController.set_servo(RPiPcm, CounterClockwiseLimitPulseWidth)
RpioServoController.set_servo(RPiGpclk0, MiddlePositionPulseWidth)
time.sleep(600)
def SetClock(channelNumber, frequency, rpiPin, timeSeconds): # maximum frequency = 100 Hz
cycleTime = 1000000 / frequency
startTime = (cycleTime / 2) / 10
pulseWidth = ((cycleTime / 2) / 10) - 1
PWM.setup()
PWM.init_channel(channelNumber, cycleTime)
PWM.add_channel_pulse(channelNumber, rpiPin, startTime, pulseWidth)
time.sleep(timeSeconds)
PWM.clear_channel_gpio(channelNumber, rpiPin)
PWM.cleanup()
def SetRpiGpClk0(frequencyHz, waitTime):
SetClock(channelNumber = 0, frequency = frequencyHz, rpiPin = RPiGpclk0, timeSeconds = waitTime)
def TestRpioClock(): # !!! works for 100/50/25Hz, other frequencies not working !!!
PrintDoubleSpaceLine("*** Testing RPIO.PCM tlfong01 2013mar27 ***")
PrintDoubleSpaceLine("*** Testing 100 Hz, 4 seconds ***")
Beep(3)
SetRpiGpClk0(100, 2)
# PrintDoubleSpaceLine("*** Testing 50 Hz, 4 seconds ***")
# Beep(3)
# SetRpiGpClk0(50, 2)
# PrintDoubleSpaceLine("*** Testing 25 Hz, 4 seconds ***")
# Beep(3)
# SetRpiGpClk0(25, 2)
# *** Guzunty Pi CPLD (XC9572XL) Functions ************************************
# *** Core 16o8i **************************************************************
# https://raw.github.com/Guzunty/Pi/master/src/gz_16o8i/gz_16o8i.rpt
# * 16o8i Fitter Report Summary *
# * 17 Outputs **
# Signal Name Loc Pin
# outputs<0> FB1_2 1
# outputs<1> FB1_5 2
# outputs<2> FB1_6 3
# outputs<3> FB1_8 4
# outputs<4> FB1_15 8
# outputs<5> FB1_17 9
# outputs<6> FB2_2 35
# outputs<7> FB2_5 36
# outputs<8> FB2_6 37
# outputs<9> FB2_8 38
# outputs<10> FB2_15 43
# outputs<11> FB2_17 44
# outputs<12> FB3_2 11
# outputs<13> FB3_5 12
# outputs<14> FB3_8 13
# outputs<15> FB3_9 14
# miso FB4_17 34
# ** 11 Inputs **
# Signal Name Loc Pin Type
# inputs<6> FB1_11 6~ GCK/I/O [GCK2]
# inputs<7> FB1_14 7~ GCK/I/O [GCK3]
# inputs<0> FB3_14 19 I/O
# inputs<1> FB3_15 20 I/O
# inputs<2> FB3_16 24 I/O
# inputs<3> FB3_17 22 I/O
# inputs<4> FB4_2 25 I/O
# inputs<5> FB4_5 26 I/O
# sclk FB4_11 28 I/O
# mosi FB4_14 29 I/O
# sel FB4_15 33 I/O
# * Guzunty Pi 16o8i Pin numbering ********************************************
# Pin O0 = Winding 1 (Unipolar stepping motor A- winding)
# Pin O1 = Winding 2 (Unipolar stepping motor A+ winding)
# Pin O2 = Winding 3 (Unipolar stepping motor B- winding)
# Pin O3 = Winding 4 (Unipolar stepping motor B+ winding)
# Pin O4 = Column 0 (Decimal keypad Column 0)
# Pin O5 = Column 1 (Decimal keypad Column 1)
# Pin O5 = Column 2 (Decimal keypad Column 2)
# Pin O7 = Reserved
# Pin O8 = RegisterSelect (LCD1602A)
# Pin O9 = WriteEnable (LCD1602A)
# Pin O10 = DataBit4 (LCD1602A)
# Pin O11 = DataBit5 (LCD1602A)
# Pin O12 = DataBit6 (LCD1602A)
# Pin O13 = DataBit7 (LCD1602A)
# Pin O14 = Reserved
# Pin O15 = Reserved
# Pin I0 = Row 0 (Decimal keypad Row 0)
# Pin I1 = Row 1 (Decimal keypad Row 1)
# Pin I2 = Row 2 (Decimal keypad Row 2)
# Pin I3 = Row 2 (Decimal keypad Row 3)
# Pin I4 = Reserved
# Pin I5 = Reserved
# Pin I6 = Reserved
# Pin I7 = Reserved
# *** Guzunty Pi 28BYJ48 Unipolar Stepping Motor Functions ********************
def WindingHex(windingTuple):
windingHex0 = 0x01 << (windingTuple[0] - 1)
windingHex1 = 0x01 << (windingTuple[1] - 1)
windingHex = windingHex0 | windingHex1
return windingHex
def TestGuzuntyPiSteppingMotor(windingTuple0, windingTuple1, stepCount, stepTime):
PrintDoubleSpaceLine("*** Start testing Guzunty Pi Stepping Motor ***")
windingHex0 = WindingHex(windingTuple0)
windingHex1 = WindingHex(windingTuple1)
guzuntypiSpi = spidev.SpiDev()
guzuntypiSpi.open(0, 0)
Beep(4)
for i in range(stepCount):
guzuntypiSpi.xfer2([windingHex0, 0x00])
time.sleep(stepTime)
guzuntypiSpi.xfer2([windingHex1, 0x00])
time.sleep(stepTime)
guzuntypiSpi.close()
PrintDoubleSpaceLine("*** Stop testing GuzuntyPi ***")
# *** Guzunty Pi Decimal Keypad Fuctions **************************************
AllColumnLowTuple = (0b01110000, 0b00000000)
Column0LowTuple = (0b00010000, 0b00000000)
Column1LowTuple = (0b00100000, 0b00000000)
Column2LowTuple = (0b01000000, 0b00000000)
ColumnLowTupleTuple = (Column0LowTuple, Column1LowTuple, Column2LowTuple)
def LoopUntilKeypadRowDataNibbleChangeGuzuntyPi(spi, allColumnLowTuple):
NoKeyPressedNibble = 0x0f
rowDataNibble = NoKeyPressedNibble
while (rowDataNibble == NoKeyPressedNibble):
rowDataNibble = GetKeypadRowDataNibbleGuzuntyPi(spi, allColumnLowTuple)
time.sleep(0.05) # debouncing time 50mS
def GetKeypadRowDataNibbleGuzuntyPi(spi, twoByteTuple):
twoByteList = [twoByteTuple[0], twoByteTuple[1]]
rowDataByteList = spi.xfer2(twoByteList)
rowDataNibble = 0x0f & (rowDataByteList[0])
return rowDataNibble
def GetKeypadColumnNumberGuzuntyPi(spi):
NoKeyPressRowDataNibble = 0b1111
for i in range(3):
rowDataNibble = GetKeypadRowDataNibbleGuzuntyPi(spi, ColumnLowTupleTuple[i])
if rowDataNibble != NoKeyPressRowDataNibble:
break
columnNumber = i
print "Column number = ", columnNumber
return columnNumber
def GetKeypadRowNumberGuzuntyPi(spi):
rowDataNibble = GetKeypadRowDataNibbleGuzuntyPi(spi, AllColumnLowTuple)
DataNibbleTuple = (0b00001110, 0b00001101, 0b00001011, 0b00000111)
for dataNibble in (DataNibbleTuple):
if (dataNibble == rowDataNibble):
break
rowNumber = DataNibbleTuple.index(dataNibble)
# PrintFourBitPattern("Row data nibble = ", rowDataNibble)
print "Row number = ", rowNumber
return rowNumber
def GetKeyNumberGuzuntyPi(rowNumber, columnNumber):
keyNumber = (rowNumber * 3) + (columnNumber + 1)
print "Key number = ", keyNumber
return keyNumber
def TestKeypadGuzuntyPi():
# *** setup GuzuntyPi ***
spiGuzuntyPi = spidev.SpiDev()
spiGuzuntyPi.open(0, 0)
keyNumber = 99
while (keyNumber != 12):
print "\nPress any key between 0 and 9. Press # to exit, ...\n"
LoopUntilKeypadRowDataNibbleChangeGuzuntyPi(spiGuzuntyPi, AllColumnLowTuple)
columnNumber = GetKeypadColumnNumberGuzuntyPi(spiGuzuntyPi)
rowNumber = GetKeypadRowNumberGuzuntyPi(spiGuzuntyPi)
keyNumber = GetKeyNumberGuzuntyPi(rowNumber, columnNumber)
time.sleep(0.5)
# *** End of keypad test ***
spiGuzuntyPi.close()
# LCD1602 software initialization procedure
# Part A - Pseudo 8 bit instructions to config 4 bit instruction mode (0x30, 0x30, 0x30, 0x20)
# 1. Power on, wait 20mS (> 15mS)
# 2. Write 0x3, wait 5mS (> 4.1mS) # set 8 bit interface
# 3. Write 0x3, wait 1mS (> 100uS) # set 8 bit interface
# 4. Write 0x3, wait 1mS (> 37uS) # set 8 bit interface
# 5. Write 0x2, wait 1mS (> 37uS) # set 4 bit interface
# Part B - 4 bit instructions to config display characteristics (0x28, 0x08, 0x01, 0x06, 0x02)
# 6. Write 0x2, wait 1mS (> 37uS) 0x8 wait 1mS (> 37uS) (2 lines, 5x8 dot)
# 7. Write 0x0, wait 1mS (> 37uS) 0x8 wait 1mS (> 37uS) (cursor on, no blinking, blank screen)
# 8. Write 0x0, wait 1mS (> 37uS) 0x1 wait 2mS (> 1.52mS)(clear display)
# 9. Write 0x0, wait 1mS (> 37uS) 0xe (DisplayOnCursorOnCursorBlinkOff)
# a. Write 0x0, wait 1mS (> 37uS) 0x2 wait 2mS (cursor home)
# RegisterSelect = 0 # 0 = instruction register, 1 = data register
# WriteEnable = 1 # 1 = enable, 0 = disable
# DataBit4 = 2
# DataBit5 = 3
# DataBit6 = 4
# DataBit7 = 5
# AllZeroDataByte = 0x00
# AllOneDataByte = 0xff
# EnableWriteMask = 0x02 # 0b 0000 0010
# DisableWriteMask = 0xfd # 0b 1111 1101
# SelectDataRegisterMask = 0x01 # 0b 0000 0001
# SelectInstructionRegisterMask = 0xfe # 0b 1111 1110
# InstructionRegister = 0
# DataRegister = 1
# EightBitInstructionMode = 0x3
# FourBitInstructionMode = 0x2
# TwoLineFiveTimesEightDot1 = 0x2
# TwoLineFiveTimesEightDot2 = 0x8
# DisplayOnCursorOnCursorBlinkOff1 = 0x0
# DisplayOnCursorOnCursorBlinkOff2 = 0xe
# ClearDisplay1 = 0x0
# ClearDisplay2 = 0x1
# CursorIncrementDisplayNoShift1 = 0x0
# CursorIncrementDisplayNoShift2 = 0x6
# CursorHome1 = 0x0
# CursorHome2 = 0x2
# PowerOnResetDelay = 0.05 # 50mS
# VeryLongOperationDelay = 0.005 # 5mS
# LongOperationDelay = 0.002 # 2mS
# ShortOperationDelay = 0.00005 # 50uS
# WritePulseLength = 0.00005 # 50uS
# * Guzunty Pi LCD1602 Functions **********************************************
def LcdConfigurationGuzuntyPi(spi):
dataControlByte = 0x00
LcdDisableWriteGuzuntyPi(spi, dataControlByte)
time.sleep(PowerOnResetDelay)
LcdWriteDataNibbleGuzuntyPi(spi, EightBitInstructionMode, InstructionRegister, VeryLongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, EightBitInstructionMode, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, FourBitInstructionMode, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, TwoLineFiveTimesEightDot1, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, TwoLineFiveTimesEightDot2, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, DisplayOnCursorOnCursorBlinkOff1, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, DisplayOnCursorOnCursorBlinkOff2, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, ClearDisplay1, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, ClearDisplay2, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, CursorIncrementDisplayNoShift1, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, CursorIncrementDisplayNoShift2, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, CursorHome1, InstructionRegister, LongOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, CursorHome2, InstructionRegister, LongOperationDelay)
def LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte):
twoByteList = [0x00, dataControlByte]
rowDataByteList = spi.xfer2(twoByteList)
def LcdDisableWriteGuzuntyPi(spi, dataControlByte):
DisableWriteAndMask = 0xfd # 0b 1111 1101
dataControlByte = dataControlByte & DisableWriteAndMask
LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte)
def LcdEnableWriteGuzuntyPi(spi, dataControlByte):
EnableWriteOrMask = 0x02 # 0b 0000 0010
dataControlByte = dataControlByte | EnableWriteOrMask
LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte)
def LcdWritePulseGuzuntyPi(spi, dataControlByte):
LcdEnableWriteGuzuntyPi(spi, dataControlByte)
time.sleep(WritePulseLength)
LcdDisableWriteGuzuntyPi(spi, dataControlByte)
def LcdSelectInstructionRegisterGuzuntyPi(spi, dataControlByte):
SelectInstructionRegisterAndMask = 0xfe # 0b 1111 1110
dataControlByte = dataControlByte & SelectInstructionRegisterAndMask
LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte)
def LcdSelectDataRegisterGuzuntyPi(spi, dataControlByte):
SelectDataRegisterOrMask = 0x01 # 0b 0000 0001
dataControlByte = dataControlByte | SelectDataRegisterOrMask
LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte)
def LcdWriteDataNibbleGuzuntyPi(spi, dataNibbleByte, registerType, operationDelay):
dataControlByte = dataNibbleByte << 2
if (registerType == InstructionRegister):
LcdSelectInstructionRegisterGuzuntyPi(spi, dataControlByte)
#elif (registerType == DataRegister):
else:
LcdSelectDataRegisterGuzuntyPi(spi, dataControlByte)
#print "dataControlByte = ", hex(dataControlByte)
#pdb.set_trace()
LcdDisableWriteGuzuntyPi(spi, dataControlByte)
LcdWriteDataControlByteGuzuntyPi(spi, dataControlByte)
LcdWritePulseGuzuntyPi(spi, dataControlByte) # perhaps include it in LcdWriteDataByteGuzuntyPi()
time.sleep(operationDelay)
#def LcdWriteDataNibbleMcp23017(registerBaseAddress, dataByte, dataNibble, registerType, operationDelay):
# dataNibble = dataNibble << 2
# dataByte = dataByte & 0b11000011
# dataByte = dataByte | dataNibble
# if (registerType == InstructionRegister):
# dataByte = LcdSelectInstructionRegisterMcp23017(registerBaseAddress, dataByte)
# elif (registerType == DataRegister):
# dataByte = LcdSelectDataRegisterMcp23017(registerBaseAddress, dataByte)
# LcdDisableWriteMcp23017(registerBaseAddress, dataByte)
# dataByte = LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
# LcdWritePulseMcp23017(registerBaseAddress, dataByte)
# time.sleep(operationDelay)
# return dataByte
def LcdMoveCursorGuzuntyPi(spi, rowNumber, columnNumber):
if (rowNumber == 1):
cursorByte = 0x80 | (0x00 + (columnNumber - 1)) # command = 0x80, row 1 DDRAM start address = 0x10
elif (rowNumber == 2):
cursorByte = 0x80 | (0x40 + (columnNumber - 1)) # row 2 DDRAM start address = 0x40
LcdWriteDataByteFourBitModeGuzuntyPi(spi, cursorByte, InstructionRegister)
def LcdWriteDataByteFourBitModeGuzuntyPi(spi, dataByte, registerType):
upperNibble = dataByte >> 4
lowerNibble = dataByte & 0x0f
LcdWriteCharTwoNibblesGuzuntyPi(spi, upperNibble, lowerNibble, registerType)
def LcdWriteCharTwoNibblesGuzuntyPi(spi, upperNibble, lowerNibble, registerType):
LcdWriteDataNibbleGuzuntyPi(spi, upperNibble, registerType, ShortOperationDelay)
LcdWriteDataNibbleGuzuntyPi(spi, lowerNibble, registerType, ShortOperationDelay)
def LcdWriteCharStringGuzuntyPi(spi, string):
for asciiChar in (string):
LcdWriteCharFourBitModeGuzuntyPi(spi, asciiChar)
def LcdWriteCharFourBitModeGuzuntyPi(spi, asciiChar):
charUpperNibble = ord(asciiChar) >> 4
charLowerNibble = ord(asciiChar) & 0x0f
LcdWriteCharTwoNibblesGuzuntyPi(spi, charUpperNibble, charLowerNibble, DataRegister)
def TestLcdGuzuntyPi():
spiGuzuntyPi = spidev.SpiDev()
spiGuzuntyPi.open(0, 0)
LcdConfigurationGuzuntyPi(spiGuzuntyPi)
LcdMoveCursorGuzuntyPi(spiGuzuntyPi, 1, 1)
#pdb.set_trace()
#LcdMoveCursorGuzuntyPi(spiGuzuntyPi, 2, 1)
#pdb.set_trace()
#LcdWriteCharFourBitModeGuzuntyPi(spiGuzuntyPi, "A")
#pdb.set_trace()
#LcdWriteCharFourBitModeGuzuntyPi(spiGuzuntyPi, "A")
#pdb.set_trace()
#LcdWriteCharFourBitModeGuzuntyPi(spiGuzuntyPi, "A")
#pdb.set_trace()
LcdWriteCharStringGuzuntyPi(spiGuzuntyPi, ProgramTitle1)
spiGuzuntyPi.close()
# * Guzunty Pi 8p8i core PWM functions ****************************************
# * Robot Arm Functions *
# * Set 1 Robot Arm pwm duty cycle
def SetPwmDutyCycle0(spiChannel, stateVector, index):
spiChannel.xfer2([index, stateVector[index]])
# * Set all Robot Arm pwm duty cycles
def SetRobotArmPwmDutyCycle(spiChannel, robotArmStateVector):
for i in range(len(robotArmStateVector)):
SetPwmDutyCycle0(spiChannel, robotArmStateVector, i)
# * Robot Neck Functions *
# * Set 1 Robot Neck pwm duty cycle
def SetPwmDutyCycle4(spiChannel, stateVector, index):
spiChannel.xfer2([index + 4, stateVector[index]]) # *** Robot Neck PWM start at 4
# * Set all Robot Neck pwm duty cycles
def SetRobotNeckPwmDutyCycle(spiChannel, robotNeckStateVector):
for i in range(len(robotNeckStateVector)):
SetPwmDutyCycle4(spiChannel, robotNeckStateVector, i)
# * Move servo *
def MoveServo(spiChannel, PwmNumber, PwmDutyCycle):
spiChannel.xfer2([PwmNumber, PwmDutyCycle])
# *****************************************************************************
# *****************************************************************************
# *****************************************************************************
# *****************************************************************************
# *****************************************************************************
# * Test reset, all left most, right most, middle, shoulder only *
def TestGuzuntyPiRobotArm():
PrintDoubleSpaceLine("*** Start testing Guzunty Pi Robot Arm ***")
# Open SPI Channel 0,0 for Guzunty Pi
spiGuzuntyPi = spidev.SpiDev()
# spiGuzuntyPi.open(0, 0)
spiGuzuntyPi.open(0, 1)
# * PWM duty cycle calibration *
# CwMax = 13 # for 14.4 KHz clock
# CcwMax = 30
CwMax = 6 # for 7.2 KHz clock
CcwMax = 16
RightMost = CwMax
LeftMost = CcwMax
Middle = (RightMost + LeftMost) / 2
OpenFully = RightMost
CloseFully = LeftMost
OpenHalf = Middle
UpMost = RightMost
DownMost = LeftMost
# * Robot arm parts numbering *
Shoulder = 0
Elbow = 1
Wrist = 2
Hand = 3
# * Robot neck parts numbering *
NeckLeftRight = 4
NeckUpDown = 5
# * Bobot head parts numbering *
HeadEye = 6
HeadEar = 7
# * Robot arm state vector constants *
RobotArmStateVectorReset = [RightMost, Middle, RightMost, LeftMost]
RobotArmStateVectorAllMiddle = [Middle, Middle, Middle, Middle, Middle]
RobotArmStateVectorAllRightMost = [RightMost, RightMost, RightMost, RightMost]
RobotArmStateVectorAllLeftMost = [LeftMost, LeftMost, LeftMost, LeftMost]
# * Robot neck state vector constants *
RobotNeckStateVectorReset = [Middle, Middle]
RobotNeckStateVectorAllMiddle = [Middle, Middle]
RobotNeckStateVectorAllRightMostUpMost = [RightMost, UpMost]
RobotNeckStateVectorAllLeftMostDownMost = [LeftMost, DownMost]
# *** Robot arm functions *************************************************
# Robot arm state vector variable *
robotArmStateVector = []
# * Robot arm reset *
robotArmStateVector = RobotArmStateVectorReset[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# * All servos left most *
robotArmStateVector = RobotArmStateVectorAllLeftMost[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# * All servos right most *
robotArmStateVector = RobotArmStateVectorAllRightMost[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# * All servos middle *
robotArmStateVector = RobotArmStateVectorAllMiddle[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# * Robot arm reset *
robotArmStateVector = RobotArmStateVectorReset[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# * Shoulder middle *
robotArmStateVector[Shoulder] = Middle
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Shoulder)
time.sleep(1)
# * Shoulder right most *
robotArmStateVector[Shoulder] = RightMost
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Shoulder)
time.sleep(1)
# * Shoulder left most *
robotArmStateVector[Shoulder] = LeftMost
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Shoulder)
time.sleep(1)
# * Hand fully open *
robotArmStateVector[Hand] = OpenFully
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Hand)
time.sleep(1)
# * Hand fully close *
robotArmStateVector[Hand] = CloseFully
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Hand)
time.sleep(1)
# * Hand half open *
robotArmStateVector[Hand] = OpenHalf
SetPwmDutyCycle0(spiGuzuntyPi, robotArmStateVector, Hand)
time.sleep(1)
# * Robot arm reset *
robotArmStateVector = RobotArmStateVectorReset[:]
SetRobotArmPwmDutyCycle(spiGuzuntyPi, robotArmStateVector)
time.sleep(1)
# *** Robot Neck Functions ************************************************
# Robot neck state vector variable *
robotNeckStateVector = []
# * Robot neck reset *
robotNeckStateVector = RobotNeckStateVectorReset[:]
SetRobotNeckPwmDutyCycle(spiGuzuntyPi, robotNeckStateVector)
time.sleep(1)
# * All servos right most up most *
robotNeckStateVector = RobotNeckStateVectorAllRightMostUpMost[:]
SetRobotNeckPwmDutyCycle(spiGuzuntyPi, robotNeckStateVector)
time.sleep(1)
# * All servos left most down most *
robotNeckStateVector = RobotNeckStateVectorAllLeftMostDownMost[:]
SetRobotNeckPwmDutyCycle(spiGuzuntyPi, robotNeckStateVector)
time.sleep(1)
spiGuzuntyPi.close()
PrintDoubleSpaceLine("*** Stop testing Guzunty Pi ***")
# *****************************************************************************
# * Test one servo *
def TestGuzuntyPiServo(testTime):
PrintDoubleSpaceLine("*** Start testing Guzunty Pi Servo ***")
spiGuzuntyPi = spidev.SpiDev()
spiGuzuntyPi.open(0, 1)
for i in range(2, 32):
print "Duty cycle = ", i
MoveServo(spiGuzuntyPi, PwmNumber = 6, PwmDutyCycle = i)
time.sleep(testTime)
spiGuzuntyPi.close()
PrintDoubleSpaceLine("*** Stop testing Guzunty Pi ***")
# *** 7-segment LED functions *********************************************
def TestSetGpClk0WiringPi1(frequency):
io = wiringpi.GPIO(wiringpi.GPIO.WPI_MODE_PINS)
# io.pinMode(7, io.OUTPUT)
# io.digitalWrite(7, io.HIGH)
io.pinMode(7, io.GPIO_CLOCK) # not working !!!
io.gpioClockSet (7, frequency) # not working !!!
def TestSetGpClk0WiringPi2(frequency):
wiringpi2.wiringPiSetupSys
wiringpi2.pinMode(7, 1) # OK
wiringpi2.digitalWrite(7, 1) # OK
# wiringpi2.pinMode(7, GPIO_CLOCK) # not working !!!
# wiringpi2.digitalWrite(7, frequency) # not working !!!
def TestSetGpClk0Subprocess(frequency):
returnCode = call(["gpio mode 7 clock", "gpio clock 7 960000"], shell = True)
time.sleep(4)
returnCode = call("gpio clock 7 4800000", shell=True)
time.sleep(4)
returnCode = call("gpio clock 7 2400000", shell=True)
time.sleep(4)
returnCode = call("gpio clock 7 15000", shell=True)
time.sleep(4)
# *** Backup 2013apr17 ***
#def TestLedDriverCore():
#
# # *** Set GPCLK0 pin to 4.68 KHz ***
# returnCode = call(["gpio mode 7 clock"], shell = True)
# returnCode = call("gpio clock 7 4688", shell=True)
# # *** Setup SPI channel ***
# spiGuzuntyPi = spidev.SpiDev()
# spiGuzuntyPi.open(0, 0)
# # *** Load 4 7-segment patterns to digit pattern list ***
# SevenSegments0 = 0x3f
# SevenSegments1 = 0x06
# SevenSegments2 = 0x5b
# SevenSegments3 = 0x4f
# sevenSegmentsList = [SevenSegments0, SevenSegments1, SevenSegments2, SevenSegments3]
# sevenSegmentsListAllHigh = [0xff, 0xff, 0xff, 0xff]
# sevenSegmentsListAllLow = [0x00, 0x00, 0x00, 0x00]
# # *** Write digit pattern list to Guzunty Pi ***
# for i in range(10):
# spiGuzuntyPi.xfer2(sevenSegmentsListAllHigh)
# time.sleep(1)
# spiGuzuntyPi.xfer2(sevenSegmentsListAllLow)
# time.sleep(1)
#*****************************************************************************
#*****************************************************************************
#*****************************************************************************
#def TestLcdMcp23017(i2cRegisterBaseAddress):
# LcdGpioSetupMcp23017(i2cRegisterBaseAddress)
# dataControlByte = LcdConfigurationMcp23017(i2cRegisterBaseAddress)
# dataControlByte = LcdMoveCursorMcp23017(i2cRegisterBaseAddress, dataControlByte, 1, 1)
# dataControlByte = LcdWriteCharStringMcp23017(i2cRegisterBaseAddress, dataControlByte, ProgramTitle1)
# dataControlByte = LcdMoveCursorMcp23017(i2cRegisterBaseAddress, dataControlByte, 2, 1)
# dataControlByte = LcdWriteCharStringMcp23017(i2cRegisterBaseAddress, dataControlByte, ProgramTitle2)
#def LcdWriteCharStringMcp23017(registerBaseAddress, dataControlByte, string):
# for asciiChar in (string):
# LcdWriteCharFourBitModeMcp23017(registerBaseAddress, dataControlByte, asciiChar, DataRegister)
# return dataControlByte
#def LcdWriteCharFourBitModeMcp23017(registerBaseAddress, dataControlByte, asciiChar, registerType):
# charUpperNibble = ord(asciiChar) >> 4
# charLowerNibble = ord(asciiChar) & 0x0f
# LcdWriteCharTwoNibblesMcp23017(registerBaseAddress, dataControlByte, charUpperNibble, charLowerNibble, registerType)
# return dataControlByte
#def LcdWriteCharTwoNibblesMcp23017(registerBaseAddress, dataControlByte, upperNibble, lowerNibble, registerType):
# dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, upperNibble, registerType, ShortOperationDelay)
# # PrintEightBitPattern("dataControlByte01 = ", dataControlByte)
# dataControlByte = LcdWriteDataNibbleMcp23017(registerBaseAddress, dataControlByte, lowerNibble, registerType, ShortOperationDelay)
# # PrintEightBitPattern("dataControlByte02 = ", dataControlByte)
# return dataControlByte
#def LcdWriteDataNibbleMcp23017(registerBaseAddress, dataByte, dataNibble, registerType, operationDelay):
# dataNibble = dataNibble << 2
# dataByte = dataByte & 0b11000011
# dataByte = dataByte | dataNibble
# if (registerType == InstructionRegister):
# dataByte = LcdSelectInstructionRegisterMcp23017(registerBaseAddress, dataByte)
# elif (registerType == DataRegister):
# dataByte = LcdSelectDataRegisterMcp23017(registerBaseAddress, dataByte)
# LcdDisableWriteMcp23017(registerBaseAddress, dataByte)
# dataByte = LcdWriteDataByteMcp23017(registerBaseAddress, dataByte)
# LcdWritePulseMcp23017(registerBaseAddress, dataByte)
# time.sleep(operationDelay)
# return dataByte
# *** Old test functions ******************************************************
# RPi System A Tests *
# TestBuzzer() # beep buzzer 4 times
# TestLED() # blink LED 4 tmes
# TestButtonEchoBuzzer() # echo buton with buzzer 4 times
# TestButtonEchoLED() # echo button with LED 4 times
# TestToggleMcp23017GP() # toggle Mcp23017 #1 output ports (connected to only 1 LED)
# TestToggleMcp23008GP() # toggle Mcp23008 #1 output port (connected to stepping motors)
# TestMotor() # move two stepping motors
# TestPollingKeypad() # read 4 keys by polling IO Expander GPIO port of rows (Mcp23008 #2)
# TestInterruptKeypad() # read 4 keys by polling IO Expander INT pin # !!! not tested !!!
# TestLcd(LcdRegisterBaseAddress)
# TestDemux(DemuxRegisterBaseAddress, 4)
# TestDemuxLcd(DemuxRegisterBaseAddress, LcdRegisterBaseAddress, channelNumber1 = 0, channelNumber2 = 1)
# RPi System B Tests *
# TestBuzzer() # beep buzzer 4 times
# TestLED() # blink LED 4 tmes
# TestButtonEchoBuzzer() # echo buton with buzzer 4 times
# TestButtonEchoLED() # echo button with LED 4 times
# TestToggleMcp23017SystemB1() # toggle Mcp23017 System B1
# TestReadMcp23017SystemB1()
# * Rpi Mcp23017 tests *
# TestButtonEchoBuzzer()
# TestTxdPin()
# TestRxdPin() # if set as output
# TestTxdPin()
# TestTxdPinRxdPin1()
# TestTxdPinRxdPin2()
# TestButtonEchoTxD()
# TestButtonEchoRxD()
# TestRxdEchoTxD() !!! not working !!!
# TestToggleMcp23017SystemB1(count = 4)
# TestReadMcp23017SystemB1(count = 4)
# TestKeypad017(checkPressingKeyMode = NoPollJustGetKeyEverySecond, keyCount = 4)
# TestKeypad017(checkPressingKeyMode = PollMcp23017Interrupt, keyCount = 4)
# TestKeypad017(checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
#TestLED() # blink LED 4 tmes
#TestBuzzer() # beep buzzer 4 times
#TestButtonEchoBuzzer() # echo buton with buzzer 4 times
#TestButtonEchoLED() # echo button with LED 4 times
#TestToggleMcp23017SystemB1(count = 4)
#TestBlinkMcp23017SystemB1GPIObit(bitNumber = 3, onTime = 0.1, offTime = 0.3, count = 4)
#TestReadMcp23017SystemB1GPIObit(bitNumber = 4, count = 10)
#TestKeypad017(checkPressingKeyMode = PollRowStatusNibble, keyCount = 20)
#TestKeypad017(checkPressingKeyMode = PollMcp23017Interrupt, keyCount = 20)
#TestKeypad017(checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
#TestToggleMcp23017SystemB1(count = 4)
#TestBlinkMcp23017SystemB1GPIObit(bitNumber = 3, onTime = 0.1, offTime = 0.3, count = 4)
#TestMoveMotor()
#TestLcd(Mcp23017BaseAddressSystemB1)
#ToggleGpMcp23008(registerBaseAddress = 0x21, toggleTime = 0.25, toggleCount = 4)
#ReadGpMcp23008(registerBaseAddress = 0x22, count = 100)
#TestKeypadMcp23017(registerBaseAddress = 0x20, checkPressingKeyMode = NoPollJustGetKeyEverySecond, keyCount = 4)
#TestKeypadMcp23017(registerBaseAddress = 0x20, checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
#TestKeypadMcp23017(registerBaseAddress = 0x20, checkPressingKeyMode = PollMcp23017Interrupt, keyCount = 4)
#TestKeypadMcp23008(registerBaseAddress1 = 0x21, registerBaseAddress2 = 0x22, checkPressingKeyMode = NoPollJustGetKeyEverySecond, keyCount = 4)
#TestKeypadMcp23008(registerBaseAddress1 = 0x21, registerBaseAddress2 = 0x22, checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
#TestSpiSelectDevice(deviceNumber = 0, count = 4)
#TestSpiSelectDevice(deviceNumber = 1, count = 4)
#TestSpiClockPulse(count = 10)
#TestSpiWriteBit(count = 100)
#TestSpiClockPulse(count = 10)
#TestSpiWriteBit(count = 10)
#TestSpiSelectDevice(deviceNumber = 0, count = 10)
#TestSpiSelectDevice(deviceNumber = 1, count = 4)
#TestSpiReadBit(ButtonPin, count = 10) *** OK ***
#TestSpiReadBit(SpiMisoPin, count = 10) !!! Not working !!!
#TestSpiReadBit(RxdPin, count = 10) !!! Not working !!!
#TestSpiReadBit(ButtonPin, count = 4) # *** OK ***
#TestSpiReadBit(SpiMisoPin, count = 4) # !!! Not working !!!
#TestSpiReadBit(RxdPin, count = 4) # !!! Not working !!
#PrintDoubleSpaceLine("*** Start Test x ***")
#TestRfm12bSet2Mhz()
#WaitSeconds(2)
#TestRfm12bSet1Mhz()
#WaitSeconds(2)
#PrintDoubleSpaceLine("*** Stop Test x ***")
# Rfm12bTest2(spiChannelNumber = 0, spiDeviceNumber = 0)
# Rfm12bTest3b(spiChannelNumber = 0, spiDeviceNumber = 0)
# Rfm12bTest3d(spiChannelNumber = 0, spiDeviceNumber0 = 0, spiDeviceNumber1 = 1)
#TestLcdMcp23017(registerBaseAddress = 0x20)
#TestLcdMcp23008(registerBaseAddress = 0x21)
# TestToggleMcp23017PortAoutput(registerBaseAddress = 0x20, toggleTime = 0.5, toggleCount = 100)
# TestReadMcp23017PortBinput(registerBaseAddress = 0x20, readTime = 2, readCount = 100)
# TestKeypadMcp23017(registerBaseAddress = 0x20, checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
# TestLcdMcp23017(registerBaseAddress = 0x20)
# TestBuzzer() # beep system buzzer 4 times
# TestLED() # blink system LED 4 tmes
# TestButtonEchoBuzzer() # echo system buton with system buzzer 4 times
# TestButtonEchoLED() # echo system button with system LED 4 times
# TestGpioPin(oPin = TxdPin, toggleTime = 0.5, toggleCount = 10)
# TestLcdMcp23017(registerBaseAddress = 0x21)
# TestKeypadMcp23017(registerBaseAddress = 0x21, checkPressingKeyMode = PollRowStatusNibble, keyCount = 4)
# TestRfm12bExtMpuClock(spiChannelNumber = 0, Rfm12bSpiDeviceNumber0 = 0, Rfm12bSpiDeviceNumber1 = 1)
# TestJtagPins(toggleTime = 1, testCount = 2)
# TestLcdMcp23017(i2cRegisterBaseAddress = 0x21) #I2C1
# TestKeypadMcp23017PollingMode(i2cRegisterBaseAddress = 0x21) #I2C1
# TestDualRfm12bExtMpuClock(spiChannelNumber = 0) # SPI0
# TestRpioServo()
# SetClock(channelNumber = 0, frequency = 100, rpiPin = RPiGpclk00, timeSeconds = 4)
# SetClock(channelNumber = 0, frequency = 100, rpiPin = RPiPcm)
# SetRpiGpClk0Frequency64Hz()
# SetRpiGpClk0(frequencyHz = 100, waitTime = 60)
# TestLcdMcp23017(i2cRegisterBaseAddress = 0x21) #I2C1
# TestKeypadMcp23017PollingMode(i2cRegisterBaseAddress = 0x21) #I2C1
# TestDualRfm12bExtMpuClock(spiChannelNumber = 0) # SPI0
# TestRpioServo()
# TestKeypadMcp23017PollingMode(i2cRegisterBaseAddress = 0x21)
# TestGuzuntyPiSteppingMotor(windingTuple0 = (1,3), windingTuple1 = (2, 4), stepCount = 50, stepTime = 0.05)
# TestKeypadGuzuntyPi()
# TestLcdGuzuntyPi()
# TestRpioServo()
# TestRpioClock()
# ResetGuzuntyPiRobotArm()
# TestGuzuntyPiSteppingMotor(windingTuple0 = (1,3), windingTuple1 = (2, 4), stepCount = 500, stepTime = 0.05)
# TestMoveGuzuntyPiRobotArm()
#TestLcdMcp23017(i2cRegisterBaseAddress = 0x21)
#TestGuzuntyPiSteppingMotor(windingTuple0 = (1,3), windingTuple1 = (2, 4), stepCount = 50, stepTime = 0.05)
#TestKeypadGuzuntyPi()
#TestGuzuntyPiServo(2)
#TestGuzuntyPiRobotArm()
# TestSetGpClk0WiringPi1(480000) # not working
# TestSetGpClk0WiringPi2(480000) # not working
# TestSetGpClk0Subprocess(frequency = 9600000)
# TestFourDigitSevenSegmentLedModule()
# *** 2013apr16 ***
#TestBuzzer()
#TestLED()
#TestButtonEchoBuzzer()
#TestButtonEchoLED()
#TestDualRfm12bExtMpuClock(spiChannelNumber = 0) # SPI0
#TestRxdEchoTxD()
#TestKeypadMcp23017PollingMode(i2cRegisterBaseAddress = 0x21)
#TestLcdMcp23017(i2cRegisterBaseAddress = 0x21)
# *** Current test function ***************************************************
def SetRpiPin7GpClk0Frequency4688Hz():
returnCode = call(["gpio mode 7 clock"], shell = True)
returnCode = call("gpio clock 7 4688", shell=True)
def TestGuzuntyPiLedDriver(chipEnableNumber):
SetRpiPin7GpClk0Frequency4688Hz()
# *** Setup SPI channel ***
spiGuzuntyPi = spidev.SpiDev()
if (chipEnableNumber == 0):
spiGuzuntyPi.open(0, 0)
if (chipEnableNumber == 1):
spiGuzuntyPi.open(0, 1)
# *** 7 segment patterns ***
#PatternDigit0 = ~0x3f
#PatternDigit1 = ~0x06
#PatternDigit2 = ~0x5b
#PatternDigit3 = ~0x4f
#PatternSpace = 0xff
#PatternAllOn = 0x00
PatternBigG = 0x3d
PatternSmallG = 0x6f
PatternSmallO = 0x5c
PatternSmallD = 0x5e
PatternDigit0 = 0x3f
PatternDigit1 = 0x06
PatternDigit2 = 0x5b
PatternDigit3 = 0x4f
PatternSpace = ~0xff
PatternAllOn = ~0x00
PatternBigG = 0x3d
PatternSmallG = 0x6f
PatternSmallO = 0x5c
PatternSmallD = 0x5e
PatternListAllOff = [PatternSpace, PatternSpace, PatternSpace, PatternSpace]
PatternListAllOn = [PatternAllOn, PatternAllOn, PatternAllOn, PatternAllOn]
PatternList0123 = [PatternDigit0, PatternDigit1, PatternDigit2, PatternDigit3]
PatternListGood = [PatternBigG, PatternSmallO, PatternSmallO, PatternSmallD]
# *** time digits ***
timeString = time.asctime(time.localtime(time.time()))
print timeString
print "Hour digit 1 = ", timeString[11:12]
print "Hour digit 2 = ", timeString[12:13]
print "Minute digit 1 = ", timeString[14:15]
print "Minute digit 2 = ", timeString[15:16]
print "Second digit 1 = ", timeString[17:18]
print "Second digit 2 = ", timeString[18:19]
hourDoubleDigit = [timeString[11:12], timeString[12:13]]
print "hourDoubleDigit 0 = ", hourDoubleDigit[0]
print "hourDoubleDigit 1 = ", hourDoubleDigit[1]
minuteDoubleDigit = [timeString[14:15], timeString[15:16]]
print "minuteDoubleDigit 0 = ", minuteDoubleDigit[0]
print "minuteDoubleDigit 1 = ", minuteDoubleDigit[1]
secondDoubleDigit = [timeString[17:18], timeString[18:19]]
print "secondDoubleDigit 0 = ", secondDoubleDigit[0]
print "secondDoubleDigit 1 = ", secondDoubleDigit[1]
timeHexDigit = [hourDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "hour = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
timeHexDigit = [minuteDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "minute = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
timeHexDigit = [secondDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "second = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
# *** 4 digit 7-segment LED displays ***
spiGuzuntyPi.xfer2(PatternListAllOff)
time.sleep(1)
spiGuzuntyPi.xfer2(PatternListAllOn)
time.sleep(1)
spiGuzuntyPi.xfer2(PatternList0123)
time.sleep(2)
spiGuzuntyPi.xfer2(PatternListGood)
time.sleep(2)
# SevenSegmentPatternNumbers = [~0x3f, ~0x06, ~0x5b, ~0x4f, ~0x66, ~0x6d, ~0x7d, ~0x07, ~0x7f, ~0x6f]
SevenSegmentPatternNumbers = [0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f]
decimalPoint = 0
for i in range(2):
timeString = time.asctime(time.localtime(time.time()))
hourDoubleDigit = [timeString[11:12], timeString[12:13]]
minuteDoubleDigit = [timeString[14:15], timeString[15:16]]
secondDoubleDigit = [timeString[17:18], timeString[18:19]]
minuteDigit0 = SevenSegmentPatternNumbers[int(minuteDoubleDigit[0])]
minuteDigit1 = SevenSegmentPatternNumbers[int(minuteDoubleDigit[1])]
secondDigit0 = SevenSegmentPatternNumbers[int(secondDoubleDigit[0])]
secondDigit1 = SevenSegmentPatternNumbers[int(secondDoubleDigit[1])]
if (decimalPoint == 0):
#minuteDigit1 &= ~0x80
minuteDigit1 |= 0x80
decimalPoint = 1
else:
decimalPoint = 0
minuteSecondQuadDigitList = [minuteDigit0, minuteDigit1, secondDigit0, secondDigit1]
spiGuzuntyPi.xfer2(minuteSecondQuadDigitList)
time.sleep(1)
def TestGuzuntyPiLedDriver01(spiChannel, channelNumber, chipEnableNumber):
SetRpiPin7GpClk0Frequency4688Hz()
spiChannel.open(channelNumber, chipEnableNumber)
# *** 7 segment patterns ***
#PatternDigit0 = ~0x3f
#PatternDigit1 = ~0x06
#PatternDigit2 = ~0x5b
#PatternDigit3 = ~0x4f
#PatternSpace = 0xff
#PatternAllOn = 0x00
PatternBigG = 0x3d
PatternSmallG = 0x6f
PatternSmallO = 0x5c
PatternSmallD = 0x5e
PatternDigit0 = 0x3f
PatternDigit1 = 0x06
PatternDigit2 = 0x5b
PatternDigit3 = 0x4f
PatternSpace = ~0xff
PatternAllOn = ~0x00
PatternBigG = 0x3d
PatternSmallG = 0x6f
PatternSmallO = 0x5c
PatternSmallD = 0x5e
PatternListAllOff = [PatternSpace, PatternSpace, PatternSpace, PatternSpace]
PatternListAllOn = [PatternAllOn, PatternAllOn, PatternAllOn, PatternAllOn]
PatternList0123 = [PatternDigit0, PatternDigit1, PatternDigit2, PatternDigit3]
PatternListGood = [PatternBigG, PatternSmallO, PatternSmallO, PatternSmallD]
# *** time digits ***
timeString = time.asctime(time.localtime(time.time()))
print timeString
print "Hour digit 1 = ", timeString[11:12]
print "Hour digit 2 = ", timeString[12:13]
print "Minute digit 1 = ", timeString[14:15]
print "Minute digit 2 = ", timeString[15:16]
print "Second digit 1 = ", timeString[17:18]
print "Second digit 2 = ", timeString[18:19]
hourDoubleDigit = [timeString[11:12], timeString[12:13]]
print "hourDoubleDigit 0 = ", hourDoubleDigit[0]
print "hourDoubleDigit 1 = ", hourDoubleDigit[1]
minuteDoubleDigit = [timeString[14:15], timeString[15:16]]
print "minuteDoubleDigit 0 = ", minuteDoubleDigit[0]
print "minuteDoubleDigit 1 = ", minuteDoubleDigit[1]
secondDoubleDigit = [timeString[17:18], timeString[18:19]]
print "secondDoubleDigit 0 = ", secondDoubleDigit[0]
print "secondDoubleDigit 1 = ", secondDoubleDigit[1]
timeHexDigit = [hourDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "hour = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
timeHexDigit = [minuteDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "minute = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
timeHexDigit = [secondDoubleDigit, minuteDoubleDigit, secondDoubleDigit]
print "second = ", (timeHexDigit[0])[0], (timeHexDigit[0])[1]
# *** 4 digit 7-segment LED displays ***
spiGuzuntyPi.xfer2(PatternListAllOff)
time.sleep(1)
spiGuzuntyPi.xfer2(PatternListAllOn)
time.sleep(1)
spiGuzuntyPi.xfer2(PatternList0123)
time.sleep(2)
spiGuzuntyPi.xfer2(PatternListGood)
time.sleep(2)
# SevenSegmentPatternNumbers = [~0x3f, ~0x06, ~0x5b, ~0x4f, ~0x66, ~0x6d, ~0x7d, ~0x07, ~0x7f, ~0x6f]
SevenSegmentPatternNumbers = [0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f]
decimalPoint = 0
for i in range(2):
timeString = time.asctime(time.localtime(time.time()))
hourDoubleDigit = [timeString[11:12], timeString[12:13]]
minuteDoubleDigit = [timeString[14:15], timeString[15:16]]
secondDoubleDigit = [timeString[17:18], timeString[18:19]]
minuteDigit0 = SevenSegmentPatternNumbers[int(minuteDoubleDigit[0])]
minuteDigit1 = SevenSegmentPatternNumbers[int(minuteDoubleDigit[1])]
secondDigit0 = SevenSegmentPatternNumbers[int(secondDoubleDigit[0])]
secondDigit1 = SevenSegmentPatternNumbers[int(secondDoubleDigit[1])]
if (decimalPoint == 0):
#minuteDigit1 &= ~0x80
minuteDigit1 |= 0x80
decimalPoint = 1
else:
decimalPoint = 0
minuteSecondQuadDigitList = [minuteDigit0, minuteDigit1, secondDigit0, secondDigit1]
spiGuzuntyPi.xfer2(minuteSecondQuadDigitList)
time.sleep(1)
def TestMcp3201():
PrintDoubleSpaceLine("*** Start testing MCP3201 ADC ***")
spiGuzuntyPi = spidev.SpiDev()
spiGuzuntyPi.open(0, 0)
DummyDoubleByteList = [0x00, 0x00]
adcOutputDoubleByteList = [0x55, 0x55]
adcOutputDoubleByteList = spiGuzuntyPi.xfer2(DummyDoubleByteList)
PrintEightBitPattern("ADC output byte 1 = ", adcOutputDoubleByteList[0])
PrintEightBitPattern("ADC output byte 2 = ", adcOutputDoubleByteList[1])
adcDecimalValue = (adcOutputDoubleByteList[1] >> 1) + (adcOutputDoubleByteList[0] * (2 ** 7))
# adcAnalogVoltage = (float(adcDecimalValue) / 4096) * 4.10 # without half voltage divider
adcAnalogVoltage = ((float(adcDecimalValue) / 4096) * 4.10) * 2 # with half voltage divider
print "Analog voltage = ", adcAnalogVoltage
spiGuzuntyPi.close()
PrintDoubleSpaceLine("*** Stop testing MCP3201 ***")
def Test25Lc256():
PrintDoubleSpaceLine("*** Start testing 25LC256 ***")
# *** Set up SPI channel ***
# import spidev # WiringPi Python wrapper
# spidev.max_speed_hz = 10000 # seems no effect, clock always 2 MHz !!!
spiEeprom = spidev.SpiDev()
# spiEeprom.open(0, 0)
spiEeprom.open(0, 1)
# *** 25LC256 instructions ***
EepromCommandWriteStatusRegister = 0x01
EepromcCommandWrite = 0x02
EePromCommandRead = 0x03
EepromCommandWriteLatchDisable = 0x04
EepromCommandReadStatusRegister = 0x05
EePromCommandWriteLatchEnable = 0x06
# *** 25LC256 addresses ***
#EepromStartAddress0= 0x0000
#EepromStartAddressUpper0 = 0x00
#EepromStartAddressLower0 = 0x00
EepromStartAddress1= 0x0300
EepromStartAddressUpper1 = 0x03
EepromStartAddressLower1 = 0x00
# *** SPI variables and constants ***
writeSpiDataList = [0x00]
readSpiDataList = [0x00, 0x00, 0x00, 0x00, 0x00]
DummyDataByte = 0x00
TestDataByte55 = 0x55
TestDataByteAa = 0xaa
WriteProtectNone = 0x00 # -
WriteProtectUpperFourth = 0x04 # 0x6000 to 0x7fff
WriteProtectUpperHalf = 0x08 # 0x4000 to 0x7fff
WriteProtectAll = 0x0c # 0x0000 to 0x7fff
FiveMilliSeconds = 0.005
# *** Enable Write Enable Latch ***
# while True:
# ********************************************************
# spiEeprom.xfer2([EePromCommandWriteLatchEnable])
#SpiWrite(spiEeprom.xfer2, [EePromCommandWriteLatchEnable])
SpiWrite(spiEeprom, [EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
# *** Read Status Register ***
readSpiDataList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WEL bit after Write Enable ***")
PrintEightBitPattern("Read back byte 0 = ", readSpiDataList[0])
PrintEightBitPattern("Read back byte 1 = ", readSpiDataList[1])
time.sleep(FiveMilliSeconds)
# *** Disable Write Enable Latch ***
spiEeprom.xfer2([EepromCommandWriteLatchDisable])
time.sleep(FiveMilliSeconds)
# *** Check WEL (Write Enable Latch) bit (Bit 1) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WEL bit after Write Disable ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Write Enable ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(0.005)
# *** Check WEL (Write Enable Latch) bit (Bit 1) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WEL bit after Write Enable ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Write protect upper fourth ****
spiEeprom.xfer2([EepromCommandWriteStatusRegister, WriteProtectUpperFourth])
time.sleep(0.005)
# *** Check Status Register ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking Write Protect Bits ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Write Enable ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(0.005)
# *** Write protect none ****
spiEeprom.xfer2([EepromCommandWriteStatusRegister, WriteProtectNone])
time.sleep(0.005)
# *** Check Status Register ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking Write Protect Bits ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Write Enable ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(0.005)
# *** Write 2 data bytes at address 0x0300 ****
# while True:
spiEeprom.xfer2([EepromcCommandWrite, EepromStartAddressUpper1, EepromStartAddressLower1, TestDataByte55, TestDataByte55])
# *** Check WIP (Write In Progress) bit (Bit 0) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WIP bit immediately after writing 1 byte without waiting 5 mS ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Check WIP (Write In Progress) bit (Bit 0) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WIP bit again, after waiting 5 mS ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
# *** Enable Write Enable Latch ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
# *** Read back data at address 0x0000 ***
time.sleep(1)
#while True:
readSpiDataList = spiEeprom.xfer2([EePromCommandRead, EepromStartAddressUpper1, EepromStartAddressLower1, DummyDataByte, DummyDataByte])
PrintDoubleSpaceLine("*** Read back data byte written ***")
PrintEightBitPattern("Read back byte 0 = ", readSpiDataList[0])
PrintEightBitPattern("Read back byte 1 = ", readSpiDataList[1])
PrintEightBitPattern("Read back byte 2 = ", readSpiDataList[2])
PrintEightBitPattern("Read back byte 3 = ", readSpiDataList[3])
PrintEightBitPattern("Read back byte 4 = ", readSpiDataList[4])
# *** Write Enable ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(0.005)
# *** Write 2 data bytes at address 0x0000 ****
spiEeprom.xfer2([EepromcCommandWrite, EepromStartAddressUpper1, EepromStartAddressLower1, TestDataByteAa, TestDataByteAa])
# *** Check WIP (Write In Progress) bit (Bit 0) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WIP bit immediately after writing 1 byte without waiting 5 mS ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
# *** Check WIP (Write In Progress) bit (Bit 0) ***
readInByteList = spiEeprom.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WIP bit again, after waiting 5 mS ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
# *** Enable Write Enable Latch ***
spiEeprom.xfer2([EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
# *** Read back data at address 0x0000 ***
readSpiDataList = spiEeprom.xfer2([EePromCommandRead, EepromStartAddressUpper1, EepromStartAddressLower1, DummyDataByte, DummyDataByte])
PrintDoubleSpaceLine("*** Read back data byte written ***")
PrintEightBitPattern("Read back byte 0 = ", readSpiDataList[0])
PrintEightBitPattern("Read back byte 1 = ", readSpiDataList[1])
PrintEightBitPattern("Read back byte 2 = ", readSpiDataList[2])
PrintEightBitPattern("Read back byte 3 = ", readSpiDataList[3])
PrintEightBitPattern("Read back byte 4 = ", readSpiDataList[4])
# *** Close SPI channel ***
spiEeprom.close()
#while True:
# pass
PrintDoubleSpaceLine("*** Stop testing write/read 25LC256 ***")
def Write25Lc256(spiChannel, channelNumber, chipEnableNumber, dataByte):
spiChannel.open(channelNumber, chipEnableNumber)
PrintDoubleSpaceLine("*** Start writing 25LC256 ***")
# *** 25LC256 instructions ***
EepromCommandWriteStatusRegister = 0x01
EepromcCommandWrite = 0x02
EePromCommandRead = 0x03
EepromCommandWriteLatchDisable = 0x04
EepromCommandReadStatusRegister = 0x05
EePromCommandWriteLatchEnable = 0x06
# *** 25LC256 addresses ***
EepromStartAddress1= 0x0300
EepromStartAddressUpper1 = 0x03
EepromStartAddressLower1 = 0x00
# *** SPI variables and constants ***
writeSpiDataList = [dataByte]
readSpiDataList = [0x00, 0x00, 0x00, 0x00, 0x00]
DummyDataByte = 0x00
TestDataByte55 = 0x55
TestDataByteAa = 0xaa
WriteProtectNone = 0x00 # -
WriteProtectUpperFourth = 0x04 # 0x6000 to 0x7fff
WriteProtectUpperHalf = 0x08 # 0x4000 to 0x7fff
WriteProtectAll = 0x0c # 0x0000 to 0x7fff
FiveMilliSeconds = 0.005
SpiWrite(spiChannel, [EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
# *** Write 2 data bytes at address 0x0000 ****
spiChannel.xfer2([EepromcCommandWrite, EepromStartAddressUpper1, EepromStartAddressLower1, dataByte, dataByte])
# *** Read Status Register ***
readSpiDataList = spiChannel.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WEL bit after Write Enable ***")
PrintEightBitPattern("Read back byte 0 = ", readSpiDataList[0])
PrintEightBitPattern("Read back byte 1 = ", readSpiDataList[1])
time.sleep(FiveMilliSeconds)
# *** Disable Write Enable Latch ***
spiChannel.xfer2([EepromCommandWriteLatchDisable])
time.sleep(FiveMilliSeconds)
# *** Check WEL (Write Enable Latch) bit (Bit 1) ***
readInByteList = spiChannel.xfer2([EepromCommandReadStatusRegister, DummyDataByte])
PrintDoubleSpaceLine("*** Checking WEL bit after Write Disable ***")
PrintEightBitPattern("Read back byte 0 = ", readInByteList[0])
PrintEightBitPattern("Read back byte 1 = ", readInByteList[1])
time.sleep(0.005)
def Read25Lc256DataByte(spiChannel, channelNumber, chipEnableNumber, eepromStartAddress):
spiChannel.open(channelNumber, chipEnableNumber)
PrintDoubleSpaceLine("*** Start reading 25LC256 ***")
# *** 25LC256 instructions ***
EePromCommandRead = 0x03
eepromStartAddressUpper = eepromStartAddress >> 8
eepromStartAddressLower = eepromStartAddress & 0x00ff
# *** SPI variables and constants ***
readSpiDataList = [0x00, 0x00, 0x00, 0x00, 0x00]
DummyDataByte = 0x00
# *** Read back data at address 0x0000 ***
readSpiDataList = spiChannel.xfer2([EePromCommandRead, eepromStartAddressUpper, eepromStartAddressLower, DummyDataByte])
PrintDoubleSpaceLine("*** Read back data byte written ***")
PrintEightBitPattern("Read back byte 0 = ", readSpiDataList[0])
PrintEightBitPattern("Read back byte 1 = ", readSpiDataList[1])
PrintEightBitPattern("Read back byte 2 = ", readSpiDataList[2])
PrintEightBitPattern("Read back byte 3 = ", readSpiDataList[3])
dataByte = readSpiDataList[3]
return dataByte
# *** Mcp23x17 Functions v1.0 tlfong01 2013may14 ***
# *** Constants and variables ***
# * Port type *
PortA = 0
PortB = 1
# * Register address array index *
InputOutputDirectionIndex = 0
InputPolarityIndex = 1
InterruptEnableIndex = 2
DefaultValueIndex = 3
CompareModeIndex = 4
BankInterruptPinModeIndex = 5
PullUpIndex = 6
InterruptFlagIndex = 7
InterruptCaptureIndex = 8
PortStatusIndex = 9
OutputLatchIndex = 10
# * Data constant bytes *
All8pinOutput = 0x00
All8pinInput = 0xff
All8bitOne = 0xff
All8bitZero = 0x00
All8bitPullUp = 0xff
# * Direction setting bytes *
Upper8bitOneLower8bitZero = 0xff00
Upper8bitZeroLower8bitOne = 0x00ff
Upper4bitOneLower4bitZero = 0xf0
Upper4bitZeroLower4bitOne = 0x0f
Upper8pinInputLower8pinOutput = 0xff00
Upper8pinOutputLower8pinInput = 0x00ff
Upper4pinInputLower4pinOutput = 0xf0
Upper4pinOutputLower4pinInput = 0x0f
# * Data bytes
DataByte0x55 = 0x55
DataByte0xaa = 0xaa
DataByte0x00 = 0x00
DataByte0xff = 0xff
RegisterAddressArrayMcp23s17 = [0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14,
0x01, 0x03, 0x05, 0x07, 0x09, 0x0b, 0x1d, 0x0f, 0x11, 0x13, 0x15]
Mcp23s17WriteCommand = 0b01000000
Mcp23s17ChipSubAddress0 = 0b000
# *** SPI write/read functions ***
# def SpiWrite(spiChannel, spiWriteList):
# spiChannel.xfer2(spiWriteList)
# def SpiRead(spiChannelWriteFunction, writeList):
# readList = spiChannelWriteFunction(writeList)
# *** Mcp23s17 Functions ******************************************************
def GetRegisterAddress(registerAddressArray, registerIndex, portType):
if (portType == PortA):
registerAddress = registerAddressArray[registerIndex]
if (portType == PortB):
registerAddress = registerAddressArray[registerIndex + 11]
return registerAddress
def WriteDataByteMcp23s17(spiChannel, spiChipSubAddress3bit, registerAddressArray, registerIndex, portType, dataByte):
mcp23s17WriteCommand = Mcp23s17WriteCommand | (spiChipSubAddress3bit << 1)
mcp23s17RegisterAddress = GetRegisterAddress(registerAddressArray, registerIndex, portType)
mcp23s17WriteDataByte = dataByte
# PrintEightBitPattern("mcp23s17WriteCommand = ", mcp23s17WriteCommand)
# PrintEightBitPattern("mcp23s17RegisterAddress = ", mcp23s17RegisterAddress)
# PrintEightBitPattern("mcp23s17WriteDataByte = ", mcp23s17WriteDataByte)
spiWriteList = [mcp23s17WriteCommand, mcp23s17RegisterAddress, mcp23s17WriteDataByte]
SpiWrite(spiChannel, spiWriteList)
def SetupMcp23s17Ports(spiChannel, spiChipSubAddress3bit, portAsetupByte, portBsetupByte):
WriteDataByteMcp23s17(spiChannel, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, InputOutputDirectionIndex, PortA, portAsetupByte)
WriteDataByteMcp23s17(spiChannel, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, InputOutputDirectionIndex, PortB, portBsetupByte)
# *****************************************************************************
# Function - TestMcp23s1701
# Description -
# Open SPI channel for MCP23S17 at sub address 0b000
# Assign MCP23s17 Port A and Port B all 8 pins as output
# Write 0x55 to Port A and 0xaa to Port B
# *****************************************************************************
# *** Sample call to test MCP23S17 with SPI channel 0, CE0, chip address 0
# TestMcp23s17(spiChannelNumber = 0, spiChipEnableNumber1bit = 0, spiChipSubAddress3bit = 0)
def TestMcp23s17BlinkLed(spiChannelNumber, spiChipEnableNumber1bit, spiChipSubAddress3bit):
# *** Set up SPI channel ***
spiChannelMcp23s17 = spidev.SpiDev()
spiChannelMcp23s17.open(spiChannelNumber, spiChipEnableNumber1bit)
# *** Set up MCP23s17 ports ***
SetupMcp23s17Ports(spiChannelMcp23s17, spiChipSubAddress3bit, All8pinOutput, All8pinOutput)
# *** Write 0x55 to Port A and 0xaa to Port B ***
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, DataByte0x55)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, DataByte0x55)
# *** Blink Port A and Port B LEDs ***
for i in range (10):
# *** Write 0x55 to Port A and 0xaa to Port B ***
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, DataByte0x55)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, DataByte0xaa)
time.sleep(0.5)
# *** Write 0xaa to Port A and 0x55 to Port B ***
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, DataByte0xaa)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, DataByte0x55)
time.sleep(0.5)
for i in range (10):
# *** Write 0x00 to Port A and 0x00 to Port B ***
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, DataByte0x00)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, DataByte0x00)
time.sleep(0.5)
# *** Write 0xff to Port A and 0xff to Port B ***
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, DataByte0xff)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, DataByte0xff)
time.sleep(0.5)
# *** MCP23S17 Demultiplexing ***
def TestMcp23s17Demux(spiChannelNumber, spiChipEnableNumber1bit, spiChipSubAddress3bit):
# *** Set up SPI channel ***
spiChannelMcp23s17 = spidev.SpiDev()
spiChannelMcp23s17.open(spiChannelNumber, spiChipEnableNumber1bit)
# *** Set up MCP23s17 ports ***
SetupMcp23s17Ports(spiChannelMcp23s17, spiChipSubAddress3bit, All8pinOutput, All8pinOutput)
# *** For SPI 0, CE1, MCP23S17 (000) select 1 of 8 device (using GA0~2 for A2~A0, GA3 for ~LE)
# Hc137AddressLatchDisable = 0x00
# Hc137AddressLatchEnable = 0x08
Hc137AddressLatchDisable0d3 = 0x03
Hc137AddressLatchEnable0d3 = 0x0b
Hc137AddressLatchDisable0d5 = 0x05
Hc137AddressLatchEnable0d5 = 0x0d
Hc137AddressLatchDisable0 = 0x00
Hc137AddressLatchEnable0 = 0x08
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, Hc137AddressLatchDisable0d3)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, Hc137AddressLatchEnable0d3)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, Hc137AddressLatchDisable0d5)
WriteDataByteMcp23s17(spiChannelMcp23s17, spiChipSubAddress3bit, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortB, Hc137AddressLatchEnable0d5)
time.sleep(4)
# *** Close SPI channel ***
spiChannelMcp23s17.close()
# *** MCP23S17 Demux ***
def TestMcp23S17SpiSlaveSelector():
# *** Set up SPI channel ***
spiChannel = spidev.SpiDev()
spiChannel.open(0, 0)
spiCe1 = 1
# *** Set up MCP23s17 ports ***
SetupMcp23s17Ports(spiChannel, spiCe1, All8pinOutput, All8pinOutput)
# *** Select HC137 Output 0 (GPi 3 digit LED) ***
Hc137AddressLatchDisable0 = 0x00
Hc137AddressLatchEnable0 = 0x08
Hc137AddressLatchDisable1 = 0x01
Hc137AddressLatchEnable1 = 0x09
Hc137AddressLatchDisable7 = 0x07
Hc137AddressLatchEnable7 = 0x0f
Hc137AddressLatchDisable2 = 0x02
Hc137AddressLatchEnable2 = 0x0a
spiDeviceNumber = 3
spiDecoderAddressWriteByte = spiDeviceNumber
spiDecoderAddressLatchByte = spiDecoderAddressWriteByte | 0x80
# *** Write Eeprom ***
WriteDataByteMcp23s17(spiChannel, 0, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, spiDecoderAddressWriteByte)
WriteDataByteMcp23s17(spiChannel, 0, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, spiDecoderAddressLatchByte)
Write25Lc256(spiChannel, channelNumber = 0, chipEnableNumber = 1, dataByte = 0xab)
# *** Read Eeprom ***
WriteDataByteMcp23s17(spiChannel, 0, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, spiDecoderAddressWriteByte)
WriteDataByteMcp23s17(spiChannel, 0, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, spiDecoderAddressLatchByte)
readBackDataByte = Read25Lc256DataByte(spiChannel, channelNumber = 0, chipEnableNumber = 1, eepromStartAddress = 0x0300)
PrintEightBitPattern("Read back data byte = ", readBackDataByte)
# *** Close SPI channel ***
spiChannel.close()
# *****************************************************************************
# TestMCP23S17SpiSlaveSelector() v1.0 tlfong01 2013may20hkt1101
# Description
# Setup 2 SPI channels, one for MCP23S17 (sub address 0), one for 25LC256
# Setup MCP23S17 Port A and Port B all 8 pins output
# Select EEPROM 25LC256
# Write 1 byte to EEPROM
# Read 1 byte from EEPROM
# *****************************************************************************
def SpiWrite(spiChannel, spiWriteList):
spiReadList = spiChannel.xfer2(spiWriteList)
return spiReadList
def SelectSpiSlave(spiChannel, mcp23s17SubAddress, spiSlaveSubAddress):
loadDecoderDataControlByte = spiSlaveSubAddress | 0b00000000 # bit 4 = 0 loads HC137 decoder
latchDecoderDataControlByte = spiSlaveSubAddress | 0b00001000 # bit 4 = 1 latches HC137 decoder
WriteDataByteMcp23s17(spiChannel, mcp23s17SubAddress, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, loadDecoderDataControlByte)
WriteDataByteMcp23s17(spiChannel, mcp23s17SubAddress, RegisterAddressArrayMcp23s17, OutputLatchIndex, PortA, latchDecoderDataControlByte)
def WriteEepromDataByte(spiChannel, startAddress, dataByte):
# *** Constants and variables ***
EePromCommandWriteLatchEnable = 0x06
EepromCommandWrite = 0x02
FiveMilliSeconds = 0.005
startAddressUpper = startAddress >> 8
startAddressLower = startAddress & 0x00ff
# *** Write data byte ***
SpiWrite(spiChannel, [EePromCommandWriteLatchEnable])
time.sleep(FiveMilliSeconds)
SpiWrite(spiChannel, [EepromCommandWrite, startAddressUpper, startAddressLower, dataByte])
time.sleep(FiveMilliSeconds)
def ReadEepromDataByte(spiChannel, startAddress):
# *** Constants and variables ***
EepromCommandRead = 0x03
FiveMilliSeconds = 0.005
DummyDataByte = 0x00
readSpiDataList = [0x00, 0x00, 0x00, 0x00, 0x00]
startAddressUpper = startAddress >> 8
startAddressLower = startAddress & 0x00ff
# *** Read data byte ***
readSpiDataList = SpiWrite(spiChannel, [EepromCommandRead, startAddressUpper, startAddressLower, DummyDataByte])
dataByte = readSpiDataList[3]
return dataByte
def TestMcp23S17SpiSlaveSelector01(mcp23S17Address, eepromSubAddress, testStartAddress, testDataByte):
# *** Set up SPI channel 00 for MCP23S17, channel 01 for EEPROM 25LC256 ***
SpiChannel0 = 0
SpiChipEnable0 = 0
SpiChipEnable1 = 1
Mcp23s17SubAddress0 = 0
spiChannel00 = spidev.SpiDev()
spiChannel00.open(SpiChannel0, SpiChipEnable0)
spiChannel01 = spidev.SpiDev()
spiChannel01.open(SpiChannel0, SpiChipEnable1)
# *** Set up MCP23s17 Port A all out to drive HC137 #1, Port B to drive 2 74HC137 #2 ***
All8pinOutput = 0x00
SetupMcp23s17Ports(spiChannel00, Mcp23s17SubAddress0, All8pinOutput, All8pinOutput)
# *** Select EEPROM 25LC256 ***
SelectSpiSlave(spiChannel00, Mcp23s17SubAddress0, eepromSubAddress)
# *** Write Eeprom ***
WriteEepromDataByte(spiChannel01, startAddress = testStartAddress, dataByte = testDataByte)
print "Write data byte = ", hex(testDataByte)
# *** Read Eeprom ***
readBackDataByte = ReadEepromDataByte(spiChannel01, startAddress = testStartAddress)
print "Read data byte = ", hex(readBackDataByte)
# *** Close SPI channel ***
spiChannel00.close()
spiChannel01.close()
# *** Main program ***********************************************************
StartProgram()
# TestBuzzer()
# TestLED()
# TestButtonEchoBuzzer()
# TestButtonEchoLED()
# TestMcp3201()
# TestMcp23s17BlinkLed(spiChannelNumber = 0, spiChipEnableNumber1bit = 0, spiChipSubAddress3bit = 0)
# TestMcp23s17Demux(spiChannelNumber = 0, spiChipEnableNumber1bit = 0, spiChipSubAddress3bit = 0) # SPI CE0
# TestGuzuntyPiLedDriver(chipEnableNumber = 1) # SPI CE1
# Test25Lc256() # CE1
TestMcp23S17SpiSlaveSelector01(mcp23S17Address = 0, eepromSubAddress = 3, testStartAddress = 0x30, testDataByte = 0x18)
StopProgram()
# *****************************************************************************
# End of Program
# *****************************************************************************
# .END
# *** ft2096 sample output ***
# *** Start Program - MCP23S17 Slave Device Selector Test 01 - tlfong01 2013may20 ***
# Write data byte = 0x18
# Read data byte = 0x18
# *** Stop Program ***
No comments:
Post a Comment