# Program = fuart98_2019oct1401.py tlfong01 2019oct14hkt2116
# Function = Test Rpi on board’s 5 UARTs and 4 USB to UART adapter/cable loop back and repeat send data
# Config = Rpi4B, raspbian 10 buster release 2019sep26, python 3.7.3 Thonny 3.2
# Ref = pyserial.readthedocs.io/en/latest/shortintro.html
# Setup = rpi-config > (1) Enable serial interface, (2) Disable serial console

# *** $ sudo nano /boot/config.txt to config 5 on board UARTs ***
# dtoverlay=uart5
# dtoverlay=uart4
# droverlay=uart3
# dtoverlay=uart2
# dtoverlay=uart1
# dtoverlay=uart0

# *** $ ls/ttyA*, ls /dev/ttyS* to confirm the there are 5 /dev/ttyAMAx serial devices ***
# /dev/ttyAMA0
# /dev/ttyAMA1
# /dev/ttyAMA2
# /dev/ttyAMA3
# /dev/ttyS0

# Contents
# 1. Tests brief description
# 2. Imports
# 3. Print functions
# 4. Menu functions
# 5. Serial functions
# 6. Test functions

# *** 1. Tests Brief Description ***

# Test 1 – Python string and byteArray datatype print demo
# Function – Print string and databyte variables
# Setup – None

# Test 2 – Repeat send bytes in databyte array, using scope to display TxD signal waveform
# Function – Repeat sending bytes, pause between bytes
# Setup – TxD (BCM GPIO #14, Rpi PCB 40 pin connector Pin #8)

# Test 3 – Loop back TxD output to Rxd.
# Function – Send bytes to TXD, wait (Note 1), receive bytes from RXD.
# Setup – Connet TxD, GPIO 14, Brd Pin 8, to RxD, GPIO 15, Brd Pin 10, to form a loopback.

# Test 4 – Send IR code ‘\xa1\xf1\x00\xff\x16’ (Mini Remote ontroller Digit 1 Button
# Function – Send IR code b’/bytes to TXD, wait (Note 1), receive bytes from RXD.
# Setup – Connet Rpi’s TxD pin to UART Interface IR emitter/receiver module’s RxD pin,
# Connect Another IR Emitter/Receiver’s TxD pin to Win10 RealTerm USB to UART TTL’s
# RxD pin. RealTerm configures to 9600, 8N1 and display to Hex.

# Results – (1) Rpi sends ‘\xa1\xf1\x00\xff\x16’,
# (2) UART Interface IR Emitter/Receiver red status LED blinks once.
# (3) RealTerm displays “00FF16″

# Test 5 – Repeat send bytes and loop back tests of TtyAMA 0, 1,2, 3, S0, 4 USB to Serial Ports

# Test 6 – Two Port port to port echo

# Note 1
# Bolutek BlueTooth BC04 needs at least 10mS to respond, will time out if not waiting.

# *** 2. Imports ***

from time import sleep
from datetime import datetime
import inspect
import serial
import serial.tools.list_ports

# *** 3. Print functions ***

format480 = [4, 80]
format630 = [6, 30]
format640 = [6, 40]

# ** Print Functions ***

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 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 printTitleOneByteNum(title, indentFormat, oneByteNum):
printTitleNoNewLine(title, indentFormat)
print(‘=’, convertOneByteNumToFourCharStr(oneByteNum))
return

def printStarLine():
print(”)
printTitle((‘*’ * 80), format480)
print(”)
return

def printBeginExecFunction(format1, format2):
printStarLine()
functionName = inspect.stack()[1][3]
printTitle(‘Begin Execute Function’, format1)
print(”)
printTitleString(‘Function name’, format2, functionName)
printTitleString(‘Time’, format2, str(datetime.now())[0:16])
return

def printEndExecFunction(format1):
print(”)
printTitle(‘End Execute Function’, format1)
printStarLine()
return

# *** 4. Menu Functions ***

def genMenu(menuList):
menuDict = {}
menuDict[‘Title’] = menuList[0]
menuDict[‘Dict’] = {}
for i in range(len(menuList[1])):
key = menuList[1][i][0]
menuDict[‘Dict’].update({menuList[1][i][0]: [menuList[1][i][1][0], menuList[1][i][1][1]]})
return menuDict

def printMenu(menuDict):
print(‘\n ***’, menuDict[‘Title’] + ‘ ***’)
print(”)
for key in (sorted(menuDict[‘Dict’].keys())):
print(key, ‘ =’, menuDict[‘Dict’][key][0])
print(‘x = exit’)
return

def execMenu(menuList):
menuDict = genMenu(menuList)
while (True):
printMenu(menuDict)
print(‘\nYour selection =’, ‘? ‘, end = ”)
keyStr = input()
if keyStr not in menuDict[‘Dict’].keys() and (not (keyStr == ‘x’ or keyStr == ‘m’ or keyStr == ‘w’)):
print(‘\nSelection = ERROR!!! Invalid selection. Try Again !!!’)
continue
if (keyStr == ‘x’):
print(‘\nFunction output =’, ‘Exit’)
break
print(”)
sleep(0.1)
menuDict[‘Dict’][keyStr][1]()
sleep(0.1)
return

def printHelloWorld():
printBeginExecFunction(format480, format640)
printTitleString(‘Function output’, format640, ‘Hello World!’)
printEndExecFunction(format480)
return

def printAbc123():
printBeginExecFunction(format480, format640)
printTitleString(‘Function output’, format640, ‘Abc123.’)
printEndExecFunction(format480)
return

exampleMenu = [‘Example Menu’,
[[‘0’, [‘printHelloWorld()’, printHelloWorld]],
[‘1’, [‘printAbc123()’, printAbc123]],
]
]

# *** 5. Serial Functions ***

def setupSerialPort(serialPortDeviceName, baudRate):
serialPort = serial.Serial(port = serialPortDeviceName,
baudrate = baudRate,
parity = serial.PARITY_NONE,
stopbits = serial.STOPBITS_ONE,
bytesize = serial.EIGHTBITS,
timeout= 1)
return serialPort

def setSerialPortBaudRate(serialPort, baudrate):
#print(‘ setting baudrate’)
print(‘ baudRate =’, baudrate)
serialPort.baudrate = baudrate
return

# *** Write bytes and repeat write bytes ***

def serialPortWriteBytes(serialPort, writeBytes):
serialPort.write(writeBytes)
return

def testSerailPortRepeatWriteBytes(serialPort, writeBytes, betweenBytePauseSeconds, repeatCount):
#print(‘ Begin repeatWriteOneByte(), …’)
for i in range(repeatCount):
serialPortWriteBytes(serialPort, writeBytes)
sleep(betweenBytePauseSeconds)
#print(‘ End repeatWriteOneByte().’)
return

# *** Read bytes ***

def serialPortReadBytes(serialPort, maxBytesLength):
readBytes = serialPort.read(maxBytesLength)
return readBytes

# *** Write-Wait-Read Bytes and Loopback ***

def serialPortWriteWaitReadBytes(serialPort, writeBytes, maxBytesLength, waitTime):
#print(‘\n*** Testing LoopBack ***’)
serialPort.flushInput()
serialPort.flushOutput()
serialPort.write(writeBytes)
sleep(waitTime)
readBytes = serialPortReadBytes(serialPort, maxBytesLength)
print(‘ bytes written = ‘, writeBytes)
print(‘ bytes read = ‘, readBytes)
return readBytes

def serialPortLoopBack(serialPort, writeBytes, maxBytesLength, waitTime):
#print(‘\n*** Begin serialPortLoopBack() [Remember to connect Tx to Rx!] ***’)
print(‘ Begin serialPortLoopBack(), …’)
serialPortWriteWaitReadBytes(serialPort, writeBytes, maxBytesLength, waitTime)
print(‘ End serialPortLoopBack(), …’)
return

# *** Serial Port Lists ***

def setupSerialPortList(serialPortDevNameList, baudrate):

serialPortList = [None for i in range(len(serialPortDevNameList))]

for i in range(len(serialPortList)):
#print(‘Name of Serial Port #’, i, ‘=’, serialPortDevNameList[i])
print(‘Now setting up serial port for ‘, serialPortDevNameList[i])
serialPortList[i] = setupSerialPort(serialPortDevNameList[i], baudrate)

#portList = serial.tools.list_ports.comports()
#print([port.name for port in portList])

return serialPortList

def setupSerialPort(serialPortDeviceName, baudrate):
serialPort = serial.Serial(port = serialPortDeviceName,
baudrate = baudrate,
parity = serial.PARITY_NONE,
stopbits = serial.STOPBITS_ONE,
bytesize = serial.EIGHTBITS,
timeout= 1)
return serialPort
def closeSerialPortList(serialPortList): # *** buggy ***
for serialPort in serialPortList:
pass
#serialPort.close()
#close(serialPort)
return

# *** 6. Test Functions ***

# *** Testing print python string and byteArray (Just printing, not using serial) ***

def testPrintString01():
print(‘\n*** Begin Testing Print String ***’)
testString1 = ‘abc’
print(‘ testString1 =’, testString1)
testCharArray2 = [‘x’, ‘y’, ‘z’]
print(‘ testStringArray2 =’, testCharArray2)
testString3 = testCharArray2[0] + testCharArray2[1] + testCharArray2[2]
print(‘ testString3 =’, testString3)
print(‘*** End Testing Print String ***’)
return

# *** Testing bytearray ***

def testPrintByteArray01():
print(‘\n*** Begin Testing Print ByteArray ***’)
testByteArray4 = b’AT\r\n’
print(‘ testByteArray4 =’, testByteArray4)
testString5 = testByteArray4.decode(‘utf-8’)
print(‘ testString5 =’, testString5)
print(‘*** End Testing Print ByteArray ***’)
return

def testSerialRepeatSendBytes01():
print(‘\n*** Begin Test Repeat Write Bytes ***’)

serialPort = serialPort0
baudrate = 9600
pauseSeconds = 0.01
repeatCount = 100

writeBytes = b’\x00\xff\x55\xff\x00′

#print(‘ Begin repeatWriteOneByte(), …’)
print(‘ Write byte =’, writeBytes)
print(‘ Pause second between writes =’, pauseSeconds)
print(‘ Repeat count =’, repeatCount)

setSerialPortBaudRate(serialPort, baudrate)
testSerailPortRepeatWriteBytes(serialPort, writeBytes, pauseSeconds, repeatCount)
print(‘*** End Test Repeat Write Bytes. ***’)
return

def testSerialLoopbackBytes01(): # ‘/dev/serial0’, (Using Rpi UART GPIO pins TsD, RxD)
print(‘\n*** Begin Test Serial Port Loopback = /dev/serial0 ***’)
serialPort = serialPort0
writeBytes = b’abcxyz’
maxBytesLength = 32
waitTime = 0.01
serialPortLoopBack(serialPort, writeBytes, maxBytesLength, waitTime)
print(‘*** End Test Serial Port Loopback ***’)
return

def testSerialLoopbackBytes02(): # ‘/dev/ttyUSB0’, Using USB to UART/TTL adapter/cable
print(‘\n*** Begin Test Serial Port Loopback = /dev/ttyUSB0 ***’)
serialPort = serialPort1
writeBytes = b’abcxyz’
maxBytesLength = 32
waitTime = 0.01
serialPortLoopBack(serialPort, writeBytes, maxBytesLength, waitTime)
print(‘*** End Test Serial Port Loopback ***’)
return

def testSerialLoopbackBytes03(): # ‘/dev/ttyUSB1’, Using USB to UART/TTL adapter/cable
print(‘\n*** Begin Test Serial Port Loopback /dev/ttyUSB1 ***’)
serialPort = serialPort2
writeBytes = b’abcxyz’
maxBytesLength = 32
waitTime = 0.01
serialPortLoopBack(serialPort, writeBytes, maxBytesLength, waitTime)
print(‘*** End Test Serial Port Loopback ***’)
return

# *** LIRC Test Functions ***

def testSendIrCode01():
print(‘\n*** Begin Test Send IR Code ***’)
serialPort = serialPort0
serialPort.flushInput()
serialPort.flushOutput()
writeBytes = b’\xa1\xf1\x00\xff\x16′ # Mini Remote Controller #1 Digit 1 Button code
serialPort.write(writeBytes)
print(‘ bytes written = ‘, writeBytes)
print(‘*** End Test Send IR Code ***’)
return

def serialTwoPortEcho(serialPortX, serialPortY):
print(‘\n*** Begin Test Two Port Echo ***’)

maxBytesLength = 32
waitTime = 0.01

serialPortX.flushInput()
serialPortX.flushOutput()

serialPortY.flushInput()
serialPortY.flushOutput()

writeBytes = b’123abc’
serialPortX.write(writeBytes)
print(‘ SerialPortX bytes written = ‘, writeBytes)

readBytes = serialPortY.read(maxBytesLength)
print(‘ SerialPortY bytes read = ‘, readBytes)

writeBytes = b’456xyz’
serialPortY.write(writeBytes)
print(‘ SerialPortY bytes written = ‘, writeBytes)

readBytes = serialPortX.read(maxBytesLength)
print(‘ SerialPortX bytes read = ‘, readBytes)

print(‘*** End Test Two Port Echo ***’)
return

# *** 5 On board UART tests ***

# *** Main Tests ***

# *** Individual Tests ***

def individualTests01(): # Individual Tests
#print(‘\n*** firc71_2019sep2201.py tlfong01 2019sep22hkt1206 ***\n’)

# *** Preliminary UART Test ***
#testPrintString01()
# testPrintByteArray01()
# testSerialRepeatSendBytes01()
# testSerialLoopbackBytes01()

# *** IR Signal Send/Receiver Test ***
# testSendIrCode01()

# *** Loop back test of three serial ports ***

# testSerialLoopbackBytes01() # loopback ‘/dev/serial0’
# testSerialLoopbackBytes02() # loopback ‘/dev/ttyUSB0’
# testSerialLoopbackBytes03() # loopback ‘/dev/ttyUSB1’

# *** Serial Port 2 Echos Serial Port 1 ***

#serialPort0Port1EchoTest01()
#serialPort1Port2EchoTest01()

# serialTwoPortEcho(serialPort0, serialPort1)
#serialTwoPortEcho(serialPort1, serialPort2)

return

# *** Menu Tests ***

# *** Menu Functons ***

def execMainMenu():
execMenu(mainMenu)
return

def execExampleMenu():
execMenu(exampleMenu)
return

def execStringByteArrayMenu():
execMenu(stringByteArrayMenu)
return

def execSerialMenu():
execMenu(serialMenu)
return

def execSerialLoopbackMenu():
execMenu(serialLoopbackMenu)
return

# *** Menmus ***

mainMenu = [‘Main Menu’,
[[‘0’, [‘Example menu’, execExampleMenu]],
[‘1’, [‘String byteArray menu’, execStringByteArrayMenu]],
[‘2’, [‘Serial menu’, execSerialMenu]],
]]

stringByteArrayMenu = [‘Print String ByteArray Menu’,
[[‘0’, [‘Print string’, testPrintString01]],
[‘1’, [‘Print byteArray’, testPrintByteArray01]],
]]

serialMenu = [‘Serial Menu’,
[[‘0’, [‘Serial loopback’, execSerialLoopbackMenu]],
#[‘1’, [‘Repeat write bytes’, execRepeatWriteBytesMenu]],
]]

serialLoopbackMenu = [‘Serial Loopback Menu’,
[[‘0’, [‘Loopback serialPort 1 (/dev/serial0)’, testSerialLoopbackBytes01]],
[‘1’, [‘Loopback serialPort 2 (/dev/ttyUSB0)’, testSerialLoopbackBytes02]],
[‘2’, [‘Loopback serialPort 3 (/dev/ttyUSB1)’, testSerialLoopbackBytes03]],
]]

# *** Main Tests ***

#individualTest01()
#testExampleMenu()
#menuTestPrintString01()
#execMainMenu()

#serialPortDevNameList = [‘/dev/serial0’, ‘/dev/ttyUSB0’, ‘/dev/ttyUSB1’]

serialPortDevNameList = [‘/dev/ttyAMA0’]
serialPortList = setupSerialPortList(serialPortDevNameList, baudrate = 9600)

#serialPort = setupSerialPort(‘/dev/ttyS0’, baudrate = 9600)
#serialPort = setupSerialPort(‘/dev/ttyAMA0′, baudrate = 9600)

#closeSerialPortList(serialPortList)

# *** End of Program ***

# ****************************************************************************
# ****************************************************************************
# ****************************************************************************
# *** Sample output tlfong01 2019oct03 ***

”’
Python 3.7.3 (/usr/bin/python3)
>>> %Run fuart78.py

*** Begin Test Two Port Echo ***
SerialPortX bytes written = b’123abc’
SerialPortY bytes read = b’123abc’
SerialPortY bytes written = b’456xyz’
SerialPortX bytes read = b’456xyz’
*** End Test Two Port Echo ***
>>>
”’

# *** Sample output tlfong01 2019apr0801 ***

”’
>>> %Run fuart71.py

*** Begin Testing Print String ***
testString1 = abc
testStringArray2 = [‘x’, ‘y’, ‘z’]
testString3 = xyz
*** End Testing Print String ***

*** Begin Testing Print ByteArray ***
testByteArray4 = b’AT\r\n’
testString5 = AT

*** End Testing Print ByteArray ***

*** Begin Test Repeat Write Bytes ***
Write byte = b’\x00\xffU\xff\x00′
Pause second between writes = 0.01
Repeat count = 100
baudRate = 9600
*** End Test Repeat Write Bytes. ***

*** Begin Test Serial Port Loopback ***
Begin serialPortLoopBack(), …
bytes written = b’abcxyz’
bytes read = b’abcxyz’
End serialPortLoopBack(), …
*** End Test Serial Port Loopback ***

”’

”’
>>> %Run fuart71.py

*** Begin Test Send IR Code ***
bytes written = b’\xa1\xf1\x00\xff\x16′
*** End Test Send IR Code ***

”’

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

# *** End of Sample Outputs ***

# *** End ***