Uncategorized

fspi210.py

# fspi210.py  tlfong01 2019dec17hkt1452

# ******************************************************************************************************
# *** Import ***
# ******************************************************************************************************

from    time import sleep
import  spidev
import  os
import  sys
from    datetime      import datetime
from    signal        import pause
import  fprint171     as fprint
import  fmnu205       as fmnu

# ******************************************************************************************************
# *** SPI Bus Config for ADXL345 Only ***
# ******************************************************************************************************

#initBusMode  = 0b00  # default, for adxl355
initBusMode  = 0b11   # for adxl345 only
    
initBusSpeed = 100000
    
spiBus00              = spidev.SpiDev()
spiBus00.open(0,0)
spiBus00.mode         = initBusMode 
spiBus00.max_speed_hz = initBusSpeed

spiBus01              = spidev.SpiDev()
spiBus01.open(0,1)
spiBus01.mode         = initBusMode 
spiBus01.max_speed_hz = initBusSpeed

spiBus10              = spidev.SpiDev()
spiBus10.open(1,0)
spiBus10.mode         = initBusMode 
spiBus10.max_speed_hz = initBusSpeed
    
#spiBus11              = spidev.SpiDev()
#spiBus11.open(1,1)
#spiBus11.mode         = initBusMode 
#spiBus11.max_speed_hz = initBusSpeed
    
#spiBus12              = spidev.SpiDev()
#spiBus12.open(1,2)
#spiBus12.mode         = initBusMode 
#spiBus12.max_speed_hz = initBusSpeed
    
spiBusDict = {
                'SpiBus00': spiBus00,
                'SpiBus01': spiBus01,
                'SpiBus10': spiBus10,
                #'SpiBus11': spiBus11,
                #'SpiBus12': spiBus12,
             }

spiControlByteDict = {
    'TestByte0x5a'            :     0x5a,
    'TestByte0x5b'            :     0x5b,
    'TestByte0x5c'            :     0x5c,
    'TestByte0x5d'            :     0x5d,
    'TestByte0x5e'            :     0x5e,
    'TestByte0x55'            :     0x55,
    'TestByte0x66'            :     0x66,
    'RepeatTimes100'          :      100,
    'RepeatTimes1000'         :     1000,
    'RepeatTimes10000'        :    10000,
    'RepeatTimes1000000'      :  1000000,
    'RepeatTimes10000000'     : 10000000,
    'PauseMilliSeconds10'     :     0.01,
    }
    
# ******************************************************************************************************
# *** System Functions ***
# ******************************************************************************************************

def getSystemConfigInfo():
    # *** General ***
    print('*** General System Config ***')
    os.system('date')
    os.system('cat /etc/issue.net')
    os.system('uname -a')
    os.system('grep Model /proc/cpuinfo')
    os.system('grep MemTotal /proc/meminfo')

    # *** SPI ***
    print('*** grep /boot/config.txt ***')
    os.system('grep dtparam=spi /boot/config.txt')  
    os.system('grep dtoverlay=spi1-3cs /boot/config.txt')    
    print('*** $ ls /dev/spi* ***') 
    os.system('ls /dev/spi*')
    
    # *** I2C***
    print('*** grep I2c /boot/config.txt) ***')
    os.system('grep dtparam=i2c /boot/config.txt')
    print('*** I2C dtoverlay ***')
    os.system('grep dtoverlay=i2c /boot/config.txt')
    print('*** $ ls /dev/i2c* ***')
    os.system('ls /dev/i2c*')
    print('*** i2cdetect -y 1 ***')
    os.system('i2cdetect -y 1')
    print('*** i2cdetect -y 3 ***')
    os.system('i2cdetect -y 3')
    #os.system('i2cdetect -y 4') # Clashes with SPI1 CE1 !!!
    #os.system('i2cdetect -y 5') # Not working !!!
    #os.system('i2cdetect -y 6') # Not working !!!
    print('*** End of System, SPI, and I2C Config Summary ***')
    return

def setSpiPortSpeed(spiBus, busSpeed):
    spiBus.max_speed_hz = busSpeed
    return

def closeSpi(spi):
    spiBus.close()
    return

# ******************************************************************************************************
# *** SPI Send/Recv Functions ***
# ******************************************************************************************************

# *** SPI Send/Receive 1/2/3 Bytes ***

def spiSendRecvOneByte(spiBus, sendByte):
    sendByteArray = [sendByte]
    recvByteArray = spiBus.xfer2(sendByteArray)    
    return recvByteArray

def spiSendRecvTwoBytes(spiBus, sendByte1, sendByte2):
    sendByteArray = [sendByte1, sendByte2]
    recvByteArray = spiBus.xfer2(sendByteArray)    
    return recvByteArray

def spiSendRecvThreeBytes(spiBus, sendByte1, sendByte2, sendByte3):
    sendByteArray = [sendByte1, sendByte2, sendByte3]
    recvByteArray = spiBus.xfer2(sendByteArray)    
    return recvByteArray

# ******************************************************************************************************
# *** SPI Loopback Functions ***
# ******************************************************************************************************

def loopbackOneByte(spiBus, sendByte):
    fprint.printBeginExecFunction()
    recvByteArray     = spiSendRecvOneByte(spiBus, sendByte)
    recvByte          = recvByteArray[0]
    fprint.printTitleOneByteNum('sendByte', fprint.indentFormat640, sendByte)
    fprint.printTitleOneByteNum('recvByte', fprint.indentFormat640, recvByte)
    fprint.printEndExecFunction()
    return

def loopbackTwoBytes(spiBus, sendByte1, sendByte2):
    fprint.printBeginExecFunction()
    recvByteArray     = spiSendRecvTwoBytes(spiBus, sendByte1, sendByte2)
    recvByte1          = recvByteArray[0]
    recvByte2          = recvByteArray[1]
    sendBytes = fprint.convertOneByteNumToFourCharStr(sendByte1) + ' ' + fprint.convertOneByteNumToFourCharStr(sendByte2)
    fprint.printTitleString('sendBytes', fprint.indentFormat640, sendBytes)  
    recvBytes = fprint.convertOneByteNumToFourCharStr(recvByte1) + ' ' + fprint.convertOneByteNumToFourCharStr(recvByte2)
    fprint.printTitleString('sendBytes', fprint.indentFormat640, recvBytes)
    fprint.printEndExecFunction()
    return

def loopbackThreeBytes(spiBus, sendByte1, sendByte2, sendByte3):
    fprint.printBeginExecFunction()    
    recvByteArray      = spiSendRecvThreeBytes(spiBus, sendByte1, sendByte2, sendByte3)
    recvByte1          = recvByteArray[0]
    recvByte2          = recvByteArray[1]
    recvByte3          = recvByteArray[2]
    sendBytes = fprint.convertOneByteNumToFourCharStr(sendByte1) + ' ' + fprint.convertOneByteNumToFourCharStr(sendByte2) + ' ' + \
                fprint.convertOneByteNumToFourCharStr(sendByte3)
    fprint.printTitleString('sendBytes', fprint.indentFormat640, sendBytes)
    
    recvBytes = fprint.convertOneByteNumToFourCharStr(recvByte1) + ' ' + fprint.convertOneByteNumToFourCharStr(recvByte2) + ' ' + \
                fprint.convertOneByteNumToFourCharStr(recvByte3)
    fprint.printTitleString('sendBytes', fprint.indentFormat640, recvBytes)
    fprint.printEndExecFunction()
    return

# ******************************************************************************************************
# *** Test SPI Loopback 1/2/3 bytes ***
# ******************************************************************************************************

def testLoopBackOneByte(spiBusName, testByteName):
    spiBus = spiBusDict[spiBusName]
    testByte = spiControlByteDict[testByteName]
    loopbackOneByte(spiBus, testByte)
    return

def testLoopbackTwoBytes(spiBusName, testByteName1, testByteName2):
    spiBus = spiBusDict[spiBusName]
    testByte1 = spiControlByteDict[testByteName1]
    testByte2 = spiControlByteDict[testByteName1]
    loopbackTwoBytes(spiBus, testByte1, testByte2)
    return

def testLoopbackThreeBytes(spiBusName, testByteName1, testByteName2, testByteName3):
    spiBus = spiBusDict[spiBusName]
    testByte1 = spiControlByteDict[testByteName1]
    testByte2 = spiControlByteDict[testByteName2]
    testByte3 = spiControlByteDict[testByteName3]
    loopbackThreeBytes(spiBus, testByte1, testByte2, testByte3)
    return

# ******************************************************************************************************
# *** Test SPI Loopback 1/2/3 bytes ***
# ******************************************************************************************************

def testRepeatSendOneByte(spiBusName, testByteName, repeatTimesName, pauseMilliSecondsName):
    fprint.printBeginExecFunction()
    spiBus = spiBusDict[spiBusName]
    testByte = spiControlByteDict[testByteName]
    repeatTimes = spiControlByteDict[repeatTimesName]
    pauseMilliSeconds = spiControlByteDict[pauseMilliSecondsName]
    for count in range(repeatTimes):
        spiSendRecvOneByte(spiBus, testByte)
        sleep(pauseMilliSeconds)
    fprint.printEndExecFunction()
    return

def testRepeatSendTwoBytes(spiBusName, testByteName1, testByteName2, repeatTimesName, pauseMilliSecondsName):
    fprint.printBeginExecFunction()
    spiBus = spiBusDict[spiBusName]
    testByte1 = spiControlByteDict[testByteName1]
    testByte2 = spiControlByteDict[testByteName2]
    repeatTimes = spiControlByteDict[repeatTimesName]
    pauseMilliSeconds = spiControlByteDict[pauseMilliSecondsName]
    for count in range(repeatTimes):
        spiSendRecvTwoBytes(spiBus, testByte1, testByte2)
        sleep(pauseMilliSeconds)
    fprint.printEndExecFunction()
    return

def testRepeatSendThreeBytes(spiBusName, testByteName1, testByteName2, testByteName3, repeatTimesName, pauseMilliSecondsName):
    fprint.printBeginExecFunction()
    spiBus = spiBusDict[spiBusName]
    testByte1 = spiControlByteDict[testByteName1]
    testByte2 = spiControlByteDict[testByteName2]
    testByte3 = spiControlByteDict[testByteName3]
    repeatTimes = spiControlByteDict[repeatTimesName]
    pauseMilliSeconds = spiControlByteDict[pauseMilliSecondsName]
    for count in range(repeatTimes):
        spiSendRecvThreeBytes(spiBus, testByte1, testByte2, testByte3)
        sleep(pauseMilliSeconds)
    fprint.printEndExecFunction()
    return

# *** Read Device Reg ***

def writedDevRegOneByte(spiBusName, devRegAddrDict, devRegName, controlByteDict, writeByteName):
    spiBus         = spiBusDict[spiBusName]
    devRegAddr     = devRegAddrDict[devRegName]
    writeDevRegAddr = devRegAddr | 0x00 # for Adxl345 only. For default = devRegaddr << 1
    writeByte = controlByteDict[writeByteName]
    spiSendRecvTwoBytes(spiBus, writeDevRegAddr, writeByte)
    return 

def readDevRegOneByte(spiBusName, devRegAddrDict, devRegName):
    spiBus         = spiBusDict[spiBusName]
    devRegAddr     = devRegAddrDict[devRegName]
    readDevRegAddr = devRegAddr | 0x80  # for Adxl345 only. For default = (devRegaddr << 1) | 0x01  
    dummyByte      = 0x00
    recvByteArray  = spiSendRecvTwoBytes(spiBus, readDevRegAddr, dummyByte)
    readByte       = recvByteArray[1]
    return readByte

# ******************************************************************************************************
# *** Adxl345 Functions ***
# ******************************************************************************************************

adxl345RegAddrDict = {
    'DevIdReg'                   : 0x00,
    'DataFormatReg'              : 0x31,
    'PowerControlReg'            : 0x2d,
    'InterruptConfigReg'         : 0x2e,
    'DataX0'                     : 0x32,
    'DataX1'                     : 0x33,
    'DataY0'                     : 0x34,
    'DataY1'                     : 0x35,
    'DataZ0'                     : 0x36,
    'DataZ1'                     : 0x37,
    }

adxl345ControlByteDict = {
    'DevIdByte'                              : 0xe5,
    'Format16G13Bit'                         : 0x0B,
    'StartMeasurement'                       : 0x08,
    'InterruptDataReadyEnable'               : 0x80,
    'InterruptDataReadyDisable'              : 0x00,                          
    }
                         
adxl345ModuleDict = {
    'ModuleType'        : 'ADXL345',
    'ModuleHelp'        : 'Adxl345AccelerometerHelp',
    'RegAddrDict'       : 'Adxl345RegAddrDict',
    'ControlByteDict'   : 'Adxl345ControlByteDict',
    'DevIdRegName'      : 'DevIdReg',
    'DevIdByteName'     : 'DevIdByte',                        
    
    'Jacky'             : {'SpiBusName'  : 'SpiBus00',
                          },
    'Katie'             : {'SpiBusName'  : 'SpiBus00',
                          },    
    'Lucy'              : {'SpiBusName'  : 'SpiBus10',
                          },
    'Maggi'             : {'SpiBusName'  : 'SpiBus11',
                          },
    'Nancy'             : {'SpiBusName'  : 'SpiBus12',
                          },   
    }

# *** Module Dict Dict ***

moduleDictDict = {
    'Adxl345'  : adxl345ModuleDict,
    }

# *** Test ADXL345 Accelerometer ***

def adxl345ReadRegOneByte(deviceNickName, devRegName):
    fprint.printBeginExecFunction()    

    moduleTypeName     = 'Adxl345'
    moduleDict         = moduleDictDict['Adxl345']
    spiBusName         = moduleDict[deviceNickName]['SpiBusName']
    devRegAddrDict     = adxl345RegAddrDict
    
    spiBus         = spiBusDict[spiBusName]
    devRegAddr     = devRegAddrDict[devRegName]    
    
    readByte       = readDevRegOneByte(spiBusName, devRegAddrDict, devRegName)
    
    fprint.printTitleString('BusName',            fprint.indentFormat640, spiBusName) # For debugging
    fprint.printTitleString('DevIdRegName',       fprint.indentFormat640, devRegName) # For debugging
    fprint.printTitleOneByteNum('DevRegAddr',     fprint.indentFormat640, devRegAddr) # For debugging 
    fprint.printTitleOneByteNum('DevReg Contents',fprint.indentFormat640, readByte)   # For debugging

    fprint.printEndExecFunction()
    return readByte
    
def adxl345WriteReadRegOneByte(deviceNickName, devRegName, writeByteName):
    fprint.printBeginExecFunction()

    moduleTypeName  = 'Adxl345'
    moduleDict      = moduleDictDict['Adxl345']
    spiBusName      = moduleDict[deviceNickName]['SpiBusName']
    devRegAddrDict  = adxl345RegAddrDict
    controlByteDict = adxl345ControlByteDict    
    spiBus          = spiBusDict[spiBusName]
    devRegAddr      = devRegAddrDict[devRegName]
    writeByte       = controlByteDict[writeByteName]
    
    writedDevRegOneByte(spiBusName, devRegAddrDict, devRegName, controlByteDict, writeByteName)
    readByte        = readDevRegOneByte(spiBusName, devRegAddrDict, devRegName)
    
    fprint.printTitleString('BusName',            fprint.indentFormat640, spiBusName)    # For debugging
    fprint.printTitleString('DevIdRegName',       fprint.indentFormat640, devRegName)    # For debugging
    fprint.printTitleOneByteNum('DevRegAddr',     fprint.indentFormat640, devRegAddr)    # For debugging
    fprint.printTitleString('WriteByteName',      fprint.indentFormat640, writeByteName) # For debugging
    fprint.printTitleOneByteNum('WriteByte',      fprint.indentFormat640, writeByte)     # For debugging
    fprint.printTitleOneByteNum('Read Back Byte', fprint.indentFormat640, readByte)      # For debugging

    fprint.printEndExecFunction()
    return 


# ******************************************************************************************************
# *** Adxl345 Test Functions ***
# ******************************************************************************************************

def checkDeviceId(deviceName):
    readByte = adxl345ReadRegOneByte(deviceName, 'DevIdReg')    
    fprint.printTitleOneByteNum('DevIdRegister Contests =', fprint.indentFormat640, readByte)        
    return

def configDevice(deviceInckName):
    # *** Config Adxl345 ***
    adxl345WriteReadRegOneByte(deviceInckName, 'DataFormatReg',      'Format16G13Bit')
    adxl345WriteReadRegOneByte(deviceInckName, 'InterruptConfigReg', 'InterruptDataReadyDisable')
    return 

def convertTwoCompNumToDecNum(twoCompNum, numBytes):
    twoCompNumStr = bin(twoCompNum)
    val = int(twoCompNumStr, numBytes)
    b = val.to_bytes(numBytes, byteorder=sys.byteorder, signed = False)
    decNum = int.from_bytes(b, byteorder = sys.byteorder, signed = True)
    return decNum

def getXyzDecimalValuesList(deviceNickName):
    # *** Read Two's Compliment Raw Results ***
    x0 = adxl345ReadRegOneByte(deviceNickName, 'DataX0')
    x1 = adxl345ReadRegOneByte(deviceNickName, 'DataX1')
    y0 = adxl345ReadRegOneByte(deviceNickName, 'DataY0')
    y1 = adxl345ReadRegOneByte(deviceNickName, 'DataY1')
    z0 = adxl345ReadRegOneByte(deviceNickName, 'DataZ0')
    z1 = adxl345ReadRegOneByte(deviceNickName, 'DataZ1')
    
    # *** Convert To Decimal Results List ***
    xTwoComp  = (x1 << 8) | x0
    yTwoComp  = (y1 << 8) | y0
    zTwoComp  = (z1 << 8) | z0
    
    xDecNum = convertTwoCompNumToDecNum(xTwoComp, 2)
    yDecNum = convertTwoCompNumToDecNum(yTwoComp, 2)
    zDecNum = convertTwoCompNumToDecNum(zTwoComp, 2)       
       
    xyzDecimalValuesList = (xDecNum, yDecNum, zDecNum)
    return xyzDecimalValuesList

def getRepeatMeasurementResultsList(deviceNickName, repeatTimes, pauseSeconds):
    outputListStrList = ['dummy', 'dummy', 'dummy', 'dummy']
    count = 0
    for count in range(repeatTimes):          
        # *** Start Measurement ***            
        adxl345WriteReadRegOneByte(deviceNickName, 'PowerControlReg',    'StartMeasurement')       
        # *** Get Decimal Values List ***
        xyzDecimalValuesList = getXyzDecimalValuesList(deviceNickName)
        outputListStr = '       ' + str(count).ljust(4) + str(datetime.now()).ljust(20) + '          = ' + \
                        str(xyzDecimalValuesList[0]).rjust(8)     + '  ' + \
                        str(xyzDecimalValuesList[1]).rjust(8)     + '  ' + \
                        str(xyzDecimalValuesList[2]).rjust(8)  
        outputListStrList[count] = outputListStr
        sleep(pauseSeconds)
    return outputListStrList

def printMeasurementResults(deviceNickname, measurementResultsList):
    # *** Print Title ***
    
    fprint.printTitleString ('ADXL345 Device Name', fprint.indentFormat640, deviceNickname)
    print(' ')
    print('       ----------------------------------------------------------------------')
    fprint.printTitleString('          Time', fprint.indentFormat640, ' X value   Y Value   Z Value')
    print('       ----------------------------------------------------------------------')
        
    # *** Repeat Print Measurement Results ***
    for measurementResults in measurementResultsList:
        print(measurementResults)

    print('       ----------------------------------------------------------------------')   
    return

def adxl345Test(deviceNickName):
    fprint.printBeginExecFunction()    
    checkDeviceId('Jacky') 
    configDevice('Jacky')  
    measurementResultsList = getRepeatMeasurementResultsList(deviceNickName, 4, 0.01) 
    printMeasurementResults(deviceNickName, measurementResultsList)
    fprint.printEndExecFunction()
    return    
    
# ******************************************************************************************************
# *** Main Test Functions ***
# ******************************************************************************************************

# *** SPI Tests ***

def spiBus00LoopbackOneByte():
    testLoopBackOneByte('SpiBus00', 'TestByte0x5a')
    return

def spiBus00LoopbackTwoBytes():
    testLoopbackTwoBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b')
    return

def spiBus00LoopbackThreeBytes():
    testLoopbackThreeBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b', 'TestByte0x5c')
    return

# *********************************************************

def spiLoopbackTest():
   
    #testLoopBackOneByte('SpiBus01', 'TestByte0x5b')
    #testLoopBackOneByte('SpiBus10', 'TestByte0x5c')
    #testLoopBackOneByte('SpiBus11', 'TestByte0x5d')
    #testLoopBackOneByte('SpiBus12', 'TestByte0x5e')

    # *** Test loopbcak 1/2/3 Bytes for spiBus00 ***
    #testLoopBackOneByte('SpiBus00', 'TestByte0x5a')
    #testLoopbackTwoBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b')
    #testLoopbackThreeBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b', 'TestByte0x5c')
   
    # *** Test repeat send on byte for spiBus00 ***
    #testRepeatSendOneByte('SpiBus00', 'TestByte0x5a', 'RepeatTimes100', 'PauseMilliSeconds10')
    #testRepeatSendTwoBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b', 'RepeatTimes100', 'PauseMilliSeconds10')
    #testRepeatSendThreeBytes('SpiBus00', 'TestByte0x5a', 'TestByte0x5b', 'TestByte0x5c', 'RepeatTimes100', 'PauseMilliSeconds10')
    return

# *** adxl345 Tests ***

# *** dummy function ***

def exit():
    pass
    return

# *** Menu Config ***

def readMainMenu():
    fprint.printBeginExecFunction() 
    fmnu.execMenuList(mainMenu)
    fprint.printEndExecFunction()
    return

def readSpiMenu():
    fprint.printBeginExecFunction() 
    fmnu.execMenuList(spiMenu)
    fprint.printEndExecFunction()
    return

def readAdxl345Menu():
    fprint.printBeginExecFunction() 
    fmnu.execMenuList(adxl345Menu)
    fprint.printEndExecFunction()
    return

def readMoreMenu():
    fprint.printBeginExecFunction()
    print('Not yet ready!!!')
    fprint.printEndExecFunction()
    return

# *** Menu Config ***

mainMenu = ['########## Main Menu ##############################################################',
            [['0',  ['SPI Bus Tests',  readSpiMenu]],
             ['1',  ['ADXL345 Tests',  readAdxl345Menu]],
             ['2',  ['More Tests',     readMoreMenu]],
             ['x',  ['exitMenu()',     exit]],
            ]
            ]


spiMenu = ['########## SPI Tests Menu ##########################################################',
            [['0',  ['spiBus00LoopxbackOneByte()', spiBus00LoopbackOneByte]],
             ['1',  ['spiBus00LoopbackTwoBytes()', spiBus00LoopbackTwoBytes]],
             ['2',  ['spiBus00LoopbackThreeBytes()', spiBus00LoopbackThreeBytes]],
             ['x',  ['exitMenu()',    exit]],
            ]
            ]

adxl345Menu = ['########## ADXL345 Tests Menu ##################################################',
            [['0',  ['adxl345Test()', adxl345Test]],
             ['1',  ['adxl345Test()', adxl345Test]],
             ['2',  ['adxl345Test()', adxl345Test]],
             ['x',  ['exitMenu()',    exit]],
            ]
            ]

# *** Main Tests ***

def main01():    
    #readMainMenu()
    #spiBus00LoopbackOneByte()
    adxl345Test('Jacky')   
    return

def main():
    main01()
    return

# ******************************************************************************************************
# *** Main ***
# ******************************************************************************************************

# main()

if __name__ == '__main__':
    main()

# .END


# fprint171.py tlfong01 2019dec09hkt1241

import inspect
from datetime import datetime

# ********************************************************************************
# ********************************************************************************

# *** Print Config ***

indentFormat480 = [4, 80]
indentFormat608 = [6, 8]
indentFormat610 = [6, 10]
indentFormat615 = [6, 15]
indentFormat630 = [6, 30]
indentFormat640 = [6, 40]

# ** Print Functions ***

#def hexNumStrToFourCharStr(hexNumStr):
# hexNumStr = (hexNumStr[2:])
# if (len(hexNumStr) != 2):
# hexNumStr = '0' + hexNumStr
# hexNumStr = '0x' + hexNumStr
# return hexNumStr

def convertOneByteNumToFourCharStr(oneByteNum): # new <<<<<<<<<<
tempStr = ((hex(oneByteNum))[2:])
if (len(tempStr) != 2):
tempStr = '0' + tempStr
fourCharStr = '0x' + tempStr
return fourCharStr

def convertFourByteNumToTenCharStr(fourByteNum): # new <<<<<<<<<<
tempStr = ((hex(fourByteNum))[2:])
tempStr = '0' * (8 - len(tempStr)) + tempStr
tenCharStr = '0x' + tempStr
return tenCharStr

def convertOneByetNumToEightBitString(oneByteNum):
tempStr = ((bin(oneByteNum))[2:])
eightBitString = '0' * (8 - len(tempStr)) + tempStr
return eightBitString

#def convertTwoOneByteNumToEighteenBitStr(oneByteNum1, oneByteNum2):
# eighteenBitStr = '0b' + convertOneByetNumToEightBitString(oneByteNum1) + convertOneByetNumToEightBitString(oneByteNum2)
# return eighteenBitStr

def convert16BitTwoComplementToSignDecimal(twoComplementNum):
print(twoComplementNum)
return 

def printTitle(title, indentFormat):
print((' ' * (indentFormat[0])), title.ljust(indentFormat[1])) 
return

def printTitleNoNewLine(title, indentFormat):
print((' ' * (indentFormat[0])), title.ljust(indentFormat[1]), end = '') 
return

def printTitleString(title, indentFormat, string):
printTitleNoNewLine(title, indentFormat)
print('=', string)
return

#def printTitleHexNum(title, indentFormat, hexNum):
# printTitleNoNewLine(title, indentFormat)
# print('=', hexNumStrToFourCharStr(hex(hexNum)))
# return

def printTitleOneByteNum(title, indentFormat, oneByteNum):
printTitleNoNewLine(title, indentFormat)
print('=', convertOneByteNumToFourCharStr(oneByteNum))
return

def printTitleOneByteNumToInteger(title, indentFormat, oneByteNum):
printTitleNoNewLine(title, indentFormat)
print('=', int(hex(oneByteNum), 16))
return

def printStarLine():
print('')
printTitle(('*' * 80), indentFormat480)
print('')
return

def printBeginExecFunction():
functionName = inspect.stack()[1][3] 
title = 'Begin Execute Function ' + functionName + ' ' + str(datetime.now())[0:16]
printStarLine()
printTitle(title, indentFormat480)
print('')
printTitleString('Function Name', indentFormat640, functionName)
return

def printEndExecFunction():
title = 'End Execute Function ' + inspect.stack()[1][3] + ' ' + str(datetime.now())[0:16]
print('')
printTitle(title, indentFormat480)
printStarLine()
return

# ********************************************************************************
# ********************************************************************************

# *** Main Test Function ***

def testPrintFunctionExecutionName():
printBeginExecFunction()
print(' fourCharStr of 0x3 = ', convertOneByteNumToFourCharStr(0x3))
print(' tenCharStr of 0x0ffc3 = ', convertFourByteNumToTenCharStr(0x0ffc3))
printEndExecFunction() 
return

# ********************************************************************************
# ********************************************************************************

# *** Main Tests ***

def mainTests():
#testPrintFunctionExecutionName()
#eightBitString = convertOneByetNumToEightBitString(0x06)
#print(eightBitString)
#eighteenBitString = convertTwoOneByteNumToEighteenBitStr(0x12, 0x45)
#print(eighteenBitString)
convert16BitTwoComplementToSignDecimal(0b0000000000000011)
convert16BitTwoComplementToSignDecimal(0b1111111111111100)
return

# ********************************************************************************
# ********************************************************************************

# *** Init/Main Functions ***

# *** Init Function ***

def init():
pass
return

#*** Main Function ***

def main():
init()
mainTests() 
return

# ********************************************************************************
# ********************************************************************************

# *** Main ***

if __name__ == '__main__':
main()

# *** End of Program ***

# ********************************************************************************
# ********************************************************************************

# fi2c177.py tlfong01 2019dec10hkt1105

from time import sleep
from datetime import datetime
from signal import pause
import smbus
import fprint171 as fprint
import ftime73 as ftime
import os
import sys

# *** Contents ***

# 00. References
# 01. I2C Bus Config
# 02. Raspbian System Config Functions
# 03. I2C General Read/Write/Print Device/Register Functions
# 04. I2C Device Config
# 05. I2C Device Functions
# 06. I2C Device Test Functions
# 07. Reserved
# 08. Reserved
# 09. Reserved
# 10. I2C Init/Main Functions
# 11. Sample Outputs

# *** 0. Programming Notes and References ***

# 0.1 Set spi.mode = 3
# 0.2 Try self test (Datasheet Page 31)
# 0.3 Power sequencing (Datasheet Page 13)
# 0.3 Power supply decoupling note - (Datasheet Page 28)
# 0.4 ADXL355 Ouput Stuck At Zero - ADI Engineering Zone 2017dec05

# *** 1. I2c Bus Config ***

i2cBus1 = smbus.SMBus(1) 
i2cBus3 = smbus.SMBus(3)
i2cBus4 = smbus.SMBus(4)
i2cBus6 = smbus.SMBus(6)

i2cBusDict = {'I2cBus1': i2cBus1,
'I2cBus3': i2cBus3,
'I2cBus4': i2cBus4,
'I2cBus6': i2cBus6,
}

# *** To Debug ***
# i2cBus5 = smbus.SMBus(5) # <<< not working *** !!!
#'I2cBus5': i2cBus5, # <<<<< Not working !!!

# *** System Functions ***

def pause(pauseTimeName):
sleep(i2cControlByteDict[pauseTimeName])
return

def convertTwoCompNumToDecNum(twoCompNum):
twoCompNumStr = bin(twoCompNum)
numBytes = 2
val = int(twoCompNumStr, numBytes)
b = val.to_bytes(numBytes, byteorder=sys.byteorder, signed = False)
return int.from_bytes(b, byteorder = sys.byteorder, signed = True)

i2cControlByteDict = {
'TenMilliSeconds' : 0.01,
'FourTimes' : 4,
'OneMillionTimes' : 1000000,
'TwentyMilliSeconds' : 0.02,
}

timeNowLong = str(datetime.now())
timeNowShort = str(datetime.now())[0:16]

# *** 2. System Config Functions ***

def getSystemInfo():
print('\n# *** System Info *****************************************************')

print('\n>>>>> ', 'Date', '<<<<<')
os.system('date')

print('\n>>>>> ', 'linux version', 'buster version, Rpi4B model, Rpi4B memory', '<<<<<')
os.system('cat /etc/issue.net')
os.system('uname -a')
os.system('grep Model /proc/cpuinfo')
os.system('grep MemTotal /proc/meminfo')

print('\n>>>>> ', 'i2c baudrate', '<<<<<')
os.system('grep dtparam=i2c /boot/config.txt')

print('\n>>>>> ', 'i2c dtoverlay', '<<<<<')
os.system('grep dtoverlay=i2c /boot/config.txt')
print('\n>>>>> ', 'ls /dev/i2c*', '<<<<<') 
os.system('ls /dev/i2c*')
i2cdetectCommand = 'i2cdetect -y 1'
print('\n>>>>> ', i2cdetectCommand, '<<<<<')
os.system(i2cdetectCommand)
i2cdetectCommand = 'i2cdetect -y 3'
print('\n>>>>> ', i2cdetectCommand, '<<<<<')
os.system(i2cdetectCommand)
i2cdetectCommand = 'i2cdetect -y 4'
print('\n>>>>> ', i2cdetectCommand, '<<<<<')
os.system(i2cdetectCommand) 
return

def getUartConfigInfo():
print('\n# *** UART BaudRate *****************************************************') 
os.system('grep dtparam=i2c /boot/config.txt')
return

# *** 3. I2C Read Write Print Device/Register Functions ***

# *** Contents ***
# 3.1 quickWriteDevOneByte()
# 3.2 quickReadDevOneByte()
# 3.3 writeDevTwoBytes()
# 3.4 writeRegOneByte()
# 3.4 readDevOneByte
# 3.4 readDevReadByteAddrByteOneByte
# 3.4 readDevControlByteOneByte
# 3.4 readRegOneByte
# 3.4 printRegOneByte
# 3.4 writeDevThreeBytes

# *** Write/Read Device One Byte ***

# *** 3.1 ***
def quickWriteDevOneByte(i2cBus, devAddr, writeByte):
i2cBus.write_byte(devAddr, writeByte)
return

# *** 3.3 ***
def quickReadDevOneByte(i2cBus, devAddr):
readByte = i2cBus.read_byte(devAddr)
return readByte

# *** Write/Read/Print Device Two Bytes / Device Register One Byte ***

# *** 3.3 ***
def writeDevTwoBytes(i2cBus, devAddr, writeByte1, writeByte2):
i2cBus.write_byte_data(devAddr, writeByte1, writeByte2)
return

# *** 3.4 ***
def writeRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regName, writeByte):
devAddr = devAddrDict[devAddrName]
regAddr = regAddrDict[regName]
writeDevTwoBytes(i2cBus, devAddr, regAddr, writeByte)
return

def readDevOneByte(i2cBus, devAddrAddr, readByteAddr):
readByte = i2cBus.read_byte_data(devAddr, readByteAddr)
return readByte

def readDevReadByteAddrByteOneByte(i2cBus, devAddrAddr, readByteAddr): # !!! Not Tested !!!
readByte = readDevOneByte(i2cBus, devAddrAddr, readByteAddr)
return readByte

def readDevControlByteOneByte(i2cBus, devAddr, controlByte):
readByte = i2cBus.read_byte_data(devAddr, controlByte)
return readByte

def readRegOneByte(i2cBus, devAddrDict, devName, regAddrDict, regName):
devAddr = devAddrDict[devName]
regAddr = regAddrDict[regName]
readByte = i2cBus.read_byte_data(devAddr, regAddr)
return readByte

def printRegOneByte(i2cBus, devAddrDict, devName, regAddrDict, regName):
readByte = readRegOneByte(i2cBusName, devAddrDict, devName, regAddrDict, regName)
print(printTitle, hex(readByte))
return

# *** Write Device Three Bytes ***

def writeDevThreeBytes(i2cBus, devAddr, WriteByte1, writeByte2, writByte3): # <<<<<<<<<< Not yet tested <<<<<<<<<<
i2cBus.write_block_data(devAddr, writeByte1, [writeByte2, writeByte3])
return

# *** 4. Device Write / Read / Print Register Functions ***

# *** Contents ***
# 4.1 readRegister()
# 4.2 writeVerifyRegister()
# 4.3 pingModule()

def readRegister(busName, devAddrDict, devAddrName, regAddrDict, regAddrName):
#fprint.printBeginExecFunction()

i2cBus = i2cBusDict[busName]
readByte = readRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName)

#fprint.printEndExecFunction()
return readByte

def readVerifyRegister(moduleType, moduleNickName, busName, devAddrDict, devAddrName, regAddrDict, regAddrName, controlByteDict, verifyByteName):
#fprint.printBeginExecFunction()

i2cBus = i2cBusDict[busName]
verifyByte = controlByteDict[verifyByteName]

readByte = readRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName) 

if readByte == verifyByte:
verifyResultsString = 'Success'
else:
verifyResultsString = 'Failure'

devAddr = devAddrDict[devAddrName]

fprint.printTitleString('Date Time', fprint.indentFormat640, str(datetime.now())[0:16])
fprint.printTitleString('ModuleType', fprint.indentFormat640, moduleType)
fprint.printTitleString('ModuleNickName', fprint.indentFormat640, moduleNickName)
fprint.printTitleString('I2C Bus Name', fprint.indentFormat640, busName)
fprint.printTitleString('Device Addr Name', fprint.indentFormat640, devAddrName)
fprint.printTitleOneByteNum('Device Address', fprint.indentFormat640, devAddr)
fprint.printTitleString('Register Name', fprint.indentFormat640, regAddrName)
fprint.printTitleOneByteNum('VerifyByte', fprint.indentFormat640, verifyByte) 
fprint.printTitleOneByteNum('Byte Read from Register', fprint.indentFormat640, readByte) 
fprint.printTitleString('Verify Results', fprint.indentFormat640, verifyResultsString)

#fprint.printEndExecFunction()
return verifyResultsString

def writeVerifyRegister(moduleType, moduleNickName, busName, devAddrDict, devAddrName, regAddrDict, regAddrName, controlByteDict, writeByteName):
#fprint.printBeginExecFunction()

i2cBus = i2cBusDict[busName]
writeByte = controlByteDict[writeByteName]

writeRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName, writeByte) 
readByte = readRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName) 

if readByte == writeByte:
resultsString = 'Success'
else:
resultsString = 'Failure'

devAddr = devAddrDict[devAddrName]

fprint.printTitleString('Date Time', fprint.indentFormat640, str(datetime.now())[0:16])
fprint.printTitleString('ModuleType', fprint.indentFormat640, moduleType)
fprint.printTitleString('ModuleNickName', fprint.indentFormat640, moduleNickName)
fprint.printTitleString('I2C Bus Name', fprint.indentFormat640, busName)
fprint.printTitleString('Device Addr Name', fprint.indentFormat640, devAddrName)
fprint.printTitleOneByteNum('Device Address', fprint.indentFormat640, devAddr)
fprint.printTitleString('Register Name', fprint.indentFormat640, regAddrName)
fprint.printTitleOneByteNum('Byte Written to Register', fprint.indentFormat640, writeByte) 
fprint.printTitleOneByteNum('Byte Read back from Register', fprint.indentFormat640, readByte) 
fprint.printTitleString('Verify Results', fprint.indentFormat640, resultsString)

#fprint.printEndExecFunction()
return

def writeVerifyModuleRegister(moduleTypeName, moduleNickName, regAddrName, writeByteName):
#fprint.printBeginExecFunction()

moduleDict = moduleDictDict[moduleTypeName]

moduleType = moduleDict['ModuleType'] 
busName = moduleDict[moduleNickName]['I2cBusName']
controlByteDict = moduleDict['ControlByteDict']

devAddrDict = moduleDict['DevAddrDict']
devAddrName = moduleDict[moduleNickName]['DevAddrName']

regAddrDict = moduleDict['RegAddrDict']
regAddr = regAddrDict[regAddrName] 

i2cBus = i2cBusDict[busName]
writeByte = controlByteDict[writeByteName]

writeRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName, writeByte) 
readByte = readRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName) 

if readByte == writeByte:
writeVerifyResultsString = 'Success'
else:
writeVerifyResultsString = 'Failure'

devAddr = devAddrDict[devAddrName]

fprint.printTitleString('Date Time', fprint.indentFormat640, str(datetime.now())[0:16])
fprint.printTitleString('ModuleType', fprint.indentFormat640, moduleType)
fprint.printTitleString('ModuleNickName', fprint.indentFormat640, moduleNickName)
fprint.printTitleString('I2C Bus Name', fprint.indentFormat640, busName)
fprint.printTitleString('Device Addr Name', fprint.indentFormat640, devAddrName)
fprint.printTitleOneByteNum('Device Address Byte', fprint.indentFormat640, devAddr)
fprint.printTitleString('Register Name', fprint.indentFormat640, regAddrName)
fprint.printTitleOneByteNum('Register Address Byte', fprint.indentFormat640, regAddr) 
fprint.printTitleString('WriteByteName', fprint.indentFormat640, writeByteName) 
fprint.printTitleOneByteNum('WriteByte (Written to Register)', fprint.indentFormat640, writeByte) 
fprint.printTitleOneByteNum('ReadByte (Read from Register)', fprint.indentFormat640, readByte) 
fprint.printTitleString('Write Verify Results', fprint.indentFormat640, writeVerifyResultsString)

#fprint.printEndExecFunction()
return writeVerifyResultsString

# Notes
# For Mode1 register, Test byte 0x88, 0x77 returns 0x58, 0x77. In other words, some bits are hardwired.

def pingModule(moduleTypeName, moduleNickName):
#fprint.printBeginExecFunction()

moduleDict = moduleDictDict[moduleTypeName]

moduleType = moduleDict['ModuleType'] 
busName = moduleDict[moduleNickName]['I2cBusName']
controlByteDict = moduleDict['ControlByteDict']

devAddrDict = moduleDict['DevAddrDict']
devAddrName = moduleDict[moduleNickName]['DevAddrName']

regAddrDict = moduleDict['RegAddrDict']
regAddrName = moduleDict['PingRegAddrName']

writeByteName = moduleDict['PingWriteByteName'] 

writeVerifyRegister(moduleType, moduleNickName, busName, devAddrDict, devAddrName, regAddrDict, regAddrName,
controlByteDict, writeByteName)

#fprint.printEndExecFunction() 
return

def pingModuleList(moduleType, moduleNickNameList):
for moduleNickName in moduleNickNameList:
pingModule(moduleType, moduleNickName)
return

def readModuleRegister(moduleTypeName, moduleNickName, regAddrName):
#fprint.printBeginExecFunction()

moduleDict = moduleDictDict[moduleTypeName]

moduleType = moduleDict['ModuleType'] 
busName = moduleDict[moduleNickName]['I2cBusName']
controlByteDict = moduleDict['ControlByteDict']

devAddrDict = moduleDict['DevAddrDict']
devAddrName = moduleDict[moduleNickName]['DevAddrName']

regAddrDict = moduleDict['RegAddrDict']

readByte = readRegister(busName, devAddrDict, devAddrName, regAddrDict, regAddrName)

#fprint.printEndExecFunction() 
return readByte

def readRegister(busName, devAddrDict, devAddrName, regAddrDict, regAddrName):
#fprint.printBeginExecFunction()

i2cBus = i2cBusDict[busName] 

readByte = readRegOneByte(i2cBus, devAddrDict, devAddrName, regAddrDict, regAddrName)

#fprint.printEndExecFunction()
return readByte

def readVerifyModuleRegister(moduleTypeName, moduleNickName, registerName, verifyByteName):
#fprint.printBeginExecFunction()

moduleDict = moduleDictDict[moduleTypeName]

moduleType = moduleDict['ModuleType'] 
busName = moduleDict[moduleNickName]['I2cBusName']
controlByteDict = moduleDict['ControlByteDict']

devAddrDict = moduleDict['DevAddrDict']
devAddrName = moduleDict[moduleNickName]['DevAddrName']

regAddrDict = moduleDict['RegAddrDict']
regAddrName = moduleDict['PingRegAddrName']

readVerifyResult = readVerifyRegister(moduleType, moduleNickName, busName, devAddrDict, devAddrName,
regAddrDict, regAddrName, controlByteDict, verifyByteName) 
#fprint.printEndExecFunction() 
return


# *** 5. Device Config ***

# Contents
# 5.1 PCF8591 ADC/DAC Config
# 5.2 PCA9685 PWM Controller Config
# 5.3. MCP23017 IOX Config
# 5.4 ADXL345 Accelero Sensor Config

# *** 5.1 PCF8591 ADC/DAC Config ***

pcf8591DevAddrDict = {
'DevAddr0': 0x48,
'DevAddr1': 0x49,
'DevAddr2': 0x4a,
'DevAddr3': 0x4b,
'DevAddr4': 0x4c,
'DevAddr5': 0x4d,
'DevAddr6': 0x4e,
'DevAddr7': 0x4f,
}

pcf8591ControlByteDict = {
'ChannelNum0': 0x00,
'ChannelNum1': 0x01,
}
pcf8591ModuleDict = {
'ModuleType' : 'PCA9685',
#'ModuleHelp' : 'PwmControllerHelp',
#'DevAddrDict' : pca9685DevAddrDict,
#'RegAddrDict' : pca9685RegAddrDict,
#'ControlByteDict': pca9685ControlByteDict,
#'PingRegAddrName': 'Mode1',

'GreenTea': {'SignalName' : 'GreenTea',
'I2cBusName' : 'I2cBus4',
'DevAddrName' : 'DevAddr0',
'ChannelNumName' : 'ChannelNum0',
},

'Milk' : {'SignalName' : 'Yvalue',
'I2cBusName' : 'I2cBus4',
'DevAddrName' : 'DevAddr1',
'ChannelNumName': 'ChannelNum0',
},
'Water' : {'SignalName' : 'Yvalue',
'I2cBusName' : 'I2cBus4',
'DevAddrName' : 'DevAddr0',
'ChannelNumName': 'ChannelNum0',
},

'Oil' : {'SignalName' : 'Yvalue', 
'I2cBusName' : 'I2cBus4',
'DevAddrName' : 'DevAddr1',
'ChannelNumName': 'ChannelNum0',
},

}

# *** 5.2 PCA9685 PWM Controller Config ***

pca9685DevAddrDict = {
'DevAddr0': 0x40,
'DevAddr1': 0x41,
'DevAddr2': 0x40,
'DevAddr3': 0x43,
'DevAddr4': 0x44,
'DevAddr5': 0x45,
'DevAddr6': 0x46,
'DevAddr7': 0x47,
}

pca9685RegAddrDict = { 'Mode1': 0x00,
'Mode2': 0x01,
}

pca9685ControlByteDict = {
'DataByte0x75' : 0x75,
'PingWriteByte' : 0x75,
}

pca9685ModuleDict = {
'ModuleType' : 'PCA9685',
'ModuleHelp' : 'PwmControllerHelp',
'DevAddrDict' : pca9685DevAddrDict,
'RegAddrDict' : pca9685RegAddrDict,
'ControlByteDict' : pca9685ControlByteDict,
'PingRegAddrName' : 'Mode1',
'PingWriteByteName' : 'PingWriteByte',

'Amy' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr0',
},
'Betty' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr1',
},
'Cindy' : {'I2cBusName' : 'I2cBus3',
'DevAddrName' : 'DevAddr0',
},
'Daisy' : {'I2cBusName' : 'I2cBus3',
'DevAddrName' : 'DevAddr2',
},
}

# *** 5.3 MCP23017 Iox Config ***

mcp23017DevAddrDict = {
'DevAddr0': 0x20,
'DevAddr1': 0x21,
'DevAddr2': 0x20,
'DevAddr3': 0x23,
'DevAddr4': 0x24,
'DevAddr5': 0x25,
'DevAddr6': 0x26,
'DevAddr7': 0x27,
}

mcp23017RegAddrDict = { 'IoDirRegAddrByteA': 0x00, }

mcp23017ControlByteDict = {
'DataByte0x55' : 0x55,
'DataByte0xaa' : 0xaa,
'PingWriteByte' : 0x55,
}

mcp23017ModuleDict = {
'ModuleType' : 'MCP23017',
'ModuleHelp' : 'Mcp23017IoxHelp',
'DevAddrDict' : mcp23017DevAddrDict,
'RegAddrDict' : mcp23017RegAddrDict,
'ControlByteDict' : mcp23017ControlByteDict,
'PingRegAddrName' : 'IoDirRegAddrByteA',
'PingWriteByteName' : 'PingWriteByte',

'Emily' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr0',
},
'Fanny' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr1',
},
'Gracie' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr2',
},
'Heidi' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr3',
},
'Ivy' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr4',
},
}

# *** 5.4 ADXL345 Accelero Sensor Config ***

adxl345DevAddrDict = {
'DevAddr0': 0x1d,
}

adxl345RegAddrDict = {
'DevIdReg' : 0x00,
'DataFormatReg' : 0x31,
'PowerControlReg' : 0x2d,
'InterruptConfigReg' : 0x2e,
'DataX0' : 0x32,
'DataX1' : 0x33,
'DataY0' : 0x34,
'DataY1' : 0x35,
'DataZ0' : 0x36,
'DataZ1' : 0x37,
}

adxl345ControlByteDict = {
'DevIdByte' : 0xe5,
'Format16G13Bit' : 0x0B,
'StartMeasurement' : 0x08,
'InterruptDataReadyEnable' : 0x80,
'InterruptDataRedayDisable' : 0x00, 
}

adxl345ModuleDict = {
'ModuleType' : 'ADXL345',
'ModuleHelp' : 'Adxl345AccelerometerHelp',
'DevAddrDict' : adxl345DevAddrDict,
'RegAddrDict' : adxl345RegAddrDict,
'ControlByteDict' : adxl345ControlByteDict,
'PingRegAddrName' : 'DevIdReg',
'PingWriteByteName' : 'DevIdByte', 
'Jenny' : {'I2cBusName' : 'I2cBus1',
'DevAddrName' : 'DevAddr0',
},
}

# *** Module Dict Dict ***

moduleDictDict = {
'Pcf8591' : pcf8591ModuleDict,
'Pca9685' : pca9685ModuleDict,
'Mcp23017' : mcp23017ModuleDict,
'Adxl345' : adxl345ModuleDict,
}

# *** 6. Device Functions

# *** 6.1 PCF8591 ADC/DAC PhMeter ADC And Test Functions ***

# *** Read PCF8591 Single Ended Input Channel 0 ***

#def readAdcResults(i2cBus, devAddr, controlByte):
# adcResults = i2cBus.read_byte_data(devAddr, controlByte)
# adcResults = i2cBus.read_byte_data(devAddr, controlByte)
# return adcResults

# *** Device Functions ***

def pcf8591ConvertModule(moduleNickName):
# fprint.printBeginExecFunction()

moduleType = pcf8591ModuleDict['ModuleType']
i2cBusName = pcf8591ModuleDict[moduleNickName]['I2cBusName']
devAddrName = pcf8591ModuleDict[moduleNickName]['DevAddrName']
channelNumName = pcf8591ModuleDict[moduleNickName]['ChannelNumName']

i2cBus = i2cBusDict[i2cBusName]
devAddr = pcf8591DevAddrDict[devAddrName]
controlByte = pcf8591ControlByteDict[channelNumName]

# adcResults = readAdcResults(i2cBus, devAddr, controlByte)
adcResults = readDevControlByteOneByte(i2cBus, devAddr, controlByte)
adcResults = readDevControlByteOneByte(i2cBus, devAddr, controlByte)

print('\n# *** PCF8591 ADC Testing *****************************************************\n')
fprint.printTitleString('Module Type', fprint.indentFormat640, moduleType)
fprint.printTitleString('Module Nick Name', fprint.indentFormat640, moduleNickName)

fprint.printTitleString('I2C Bus Name', fprint.indentFormat640, i2cBusName)
fprint.printTitleOneByteNum('PCF8591 I2C Device Addr', fprint.indentFormat640, devAddr)
fprint.printTitleOneByteNum('Channel Number', fprint.indentFormat640, pcf8591ControlByteDict[channelNumName])

print(' ADC Results =', fprint.convertOneByteNumToFourCharStr(adcResults), ' (hex)')
print(' =', (str(adcResults)).ljust(4, ' '), ' (dec)')
print(' =', (str(int((float((adcResults)/255) * 100)))).ljust(4, ' '), ' (%)')

# fprint.printEndExecFunction()
return

def pcf8591ConvertModuleList(moduleNickNameList):
for moduleNickName in moduleNickNameList:
pcf8591ConvertModule(moduleNickName)
return

# *** PCF8591 ADC Test Functions ***

def testPcf8591ConvertDefaultModule(): 
pcf8591ConvertModule('GreenTea')
return

def testPcf8591ConvertModules(): 
pcf8591ConvertModule('GreenTea')
pcf8591ConvertModule('Milk')
pcf8591ConvertModule('Water')
pcf8591ConvertModule('Oil')
return

def testPcf8591ConvertModuleList():
pcf8591ConvertModuleList(['GreenTea', 'Milk', 'Water', 'Oil'])
return

# *** 6.2 PCA9865 PWM Controller Functions***

# *** Device Functions ***

# *** PCA9685 PWM Controller Functions ***

# *** Test Functions ***

# *** Test Repeat Write Register ***

# *** Test Repeat Write to PCA9685 PWM Controller ***

def testRepeatWriteRegister(): # <<<<<<<<<< Not tested!!!
getSystemConfig()
testRepeatWriteReadRegisterNoPrintResults('PCA9685', 'I2cBus1', 'Dev0', 'Mode1', '0x75', 'TenMilliSeconds', 'FourTimes')
testRepeatWriteReadRegisterNoPrintResults('PCA9685', 'I2cBus1', 'Dev0', 'Mode1', '0x75', 'TenMilliSeconds', 'OneMillionTimes')
return

# *** Test PCA9685 ***

def testPca9685PingDefaultModule():
pingModule('Pca9685', 'Amy')
return

def testPca9685PingModules():
pingModule('Pca9685', 'Amy')
pingModule('Pca9685', 'Betty')
pingModule('Pca9685', 'Cindy')
pingModule('Pca9685', 'Daisy')
return

def testPca9685PingModuleList():
pingModuleList('Pca9685', ['Amy', 'Betty', 'Cindy', 'Daisy'])
return

# *** Test MCP23017 ***

def testMcp23017PingDefaultModule():
pingModule('Mcp23017', 'Emily')
return

def testMcp23017PingModules():
pingModule('Mcp23017', 'Emily')
pingModule('Mcp23017', 'Fanny')
pingModule('Mcp23017', 'Gracie')
pingModule('Mcp23017', 'Heidi')
pingModule('Mcp23017', 'Ivy')
return

def testMcp23017PingModuleList():
pingModuleList('Mcp23017', ['Emily', 'Fanny', 'Gracie', 'Heidi', 'Ivy'])
return

# *** Test ADXL345 Accelerometer ***

def adxl345CheckDeviceId(moduleNickName): 
#fprint.printBeginExecFunction()

# *** Ping Module ***
#pingModule('Adxl345', 'Jenny')

# *** Verify Mdoule Device Id ***
moduleTypeName = 'Adxl345'
print(' ----------------------------------------------------------------------')
readVerifyModuleRegister(moduleTypeName, moduleNickName, 'DevIdReg', 'DevIdByte')

#fprint.printEndExecFunction()
return

def testAdxl345PingDefaultModule(): 
fprint.printBeginExecFunction()

# *** Ping Module ***
#pingModule('Adxl345', 'Jenny')

# *** Verify Mdoule Device Id ***
readVerifyModuleRegister('Adxl345', 'Jenny', 'DevIdReg', 'DevIdByte')

fprint.printEndExecFunction()
return

# To delete 2019dec08hkt1456
#testWriteReadRegister('ADXL345', 'I2cBus1',
# adxl345DevAddrDict, 'DevAddr0',
# adxl345RegAddrDict, 'DeviceId',
# adxl345ControlByteDict, 'DataByte0x55') 
#readByte = ReadRegister('I2cBus1', adxl345DevAddrDict, 'DevAddr0', adxl345RegAddrDict, 'DeviceId')
#print('Adxl345 DeviceId Reg =', hex(readByte))

def adxl345Init(moduleNickName):
moduleTypeName = 'Adxl345'
print(' ----------------------------------------------------------------------')
writeVerifyModuleRegister(moduleTypeName, moduleNickName, 'DataFormatReg', 'Format16G13Bit')
print(' ----------------------------------------------------------------------')
writeVerifyModuleRegister(moduleTypeName, moduleNickName, 'PowerControlReg', 'StartMeasurement')
print(' ----------------------------------------------------------------------')
writeVerifyModuleRegister(moduleTypeName, moduleNickName, 'InterruptConfigReg', 'InterruptDataReadyEnable')
print(' ----------------------------------------------------------------------')
pause('TwentyMilliSeconds') 
return

def adxl345ReadOutput(moduleNickName):
moduleTypeName = 'Adxl345'
x0 = readModuleRegister(moduleTypeName, moduleNickName, 'DataX0')
x1 = readModuleRegister(moduleTypeName, moduleNickName, 'DataX0')
y0 = readModuleRegister(moduleTypeName, moduleNickName, 'DataY0')
y1 = readModuleRegister(moduleTypeName, moduleNickName, 'DataY1')
z0 = readModuleRegister(moduleTypeName, moduleNickName, 'DataZ0')
z1 = readModuleRegister(moduleTypeName, moduleNickName, 'DataZ1')

xTwoComp = (x1 << 8) | x0
yTwoComp = (y1 << 8) | y0
zTwoComp = (z1 << 8) | z0

xDecNum = convertTwoCompNumToDecNum(xTwoComp)
yDecNum = convertTwoCompNumToDecNum(yTwoComp)
zDecNum = convertTwoCompNumToDecNum(zTwoComp)

adxl345OutputList = [xDecNum, yDecNum, zDecNum]

#print(' x1, x0, y1, y0, z1, z0 =', hex(x1), hex(x0), ' ', hex(y1), hex(y0), ' ', hex(z1), hex(z0)) 
#print(x, ' ', y, ' ', z)
#print(hex(x), ' ', hex(y), ' ', hex(z))
#fprint.printTitleString('x, y, z', fprint.indentFormat640, (hex(x) + ' ' + hex(y) + ' ' + hex(z)))
#fprint.printTitleString('x, y, z', fprint.indentFormat640, (bin(x) + ' ' + bin(y) + ' ' + bin(z)))
#x18BitStr = fprint.convertTwoOneByteNumToEighteenBitStr(x0, x1)
#y18BitStr = fprint.convertTwoOneByteNumToEighteenBitStr(y0, y1)
#z18BitStr = fprint.convertTwoOneByteNumToEighteenBitStr(z0, z1)
#fprint.printTitleString('x', fprint.indentFormat608, x18BitStr)
#fprint.printTitleString('y', fprint.indentFormat608, y18BitStr)
#fprint.printTitleString('z', fprint.indentFormat608, z18BitStr)

return adxl345OutputList

def testAdxl345DefaultModule():
#os.system('i2cdetect -y 1')
adxl345CheckDeviceId('Jenny')
adxl345Init('Jenny')
print('')
print(' ----------------------------------------------------------------------')
fprint.printTitleString(' Time', fprint.indentFormat640, ' X value Y Value Z Value')
print(' ----------------------------------------------------------------------')

totalCount = 4
for count in range(totalCount):
adxl345OutputList = adxl345ReadOutput('Jenny')
outputListStr = str(adxl345OutputList[0]).rjust(8) + ' ' + str(adxl345OutputList[1]).rjust(8) + ' ' + str(adxl345OutputList[2]).rjust(8)
fprint.printTitleString(str(count).rjust(4) + ' ' + str(datetime.now()), fprint.indentFormat640, outputListStr)
sleep(0.5)
print(' ----------------------------------------------------------------------')
return

# *** Test All In One ***

def testAllInOne():
# *** Get System Info***
# getSystemInfo()

# *** Test Pcf8591 ADC/DAC ***
#testPcf8591ConvertDefaultModule()
#testPcf8591ConvertModules()
#testPcf8591ConvertModuleList()

# *** Test Pca9685 PWM Controller ***
#testPca9685PingDefaultModule()
#testPca9685PingModules()
#testPca9685PingModuleList()

# *** Test Mcp23017 GPIO Expander ***
#testMcp23017PingDefaultModule()
#testMcp23017PingModules()
#testMcp23017PingModuleList()

# *** Test Adxl345 Accelerometer ***
testAdxl345DefaultModule()
return

# *** 10. Init/Main Function ***

def init():
pass
return

def main():
init()
testAllInOne()
return

if __name__ == '__main__':
main()

# *** End of Program ********************************************************************

# *** 11. Sample Outputs ***

# *** End of Sample Output ***

Categories: Uncategorized

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s