andy/tinyUSB
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge branch 'master' into remove-tud_network_link_state_cb

Browse Source
This commit is contained in:
HiFiPhile
2024-05-07 12:32:28 +02:00
committed by GitHub
parent 798ff807b3 e5b6f93df3
commit 4abdfc10f5
1015 changed files with 63791 additions and 20196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
test/hil/hil_hfp.json
View File

@@ -3,16 +3,23 @@
{
"name": "stm32l412nucleo",
"uid": "41003B000E504E5457323020",
"debugger": "jlink",
"debugger_sn": "774470029",
"cpu": "STM32L412KB"
"flasher": "jlink",
"flasher_sn": "774470029",
"flasher_args": "-device STM32L412KB"
},
{
"name": "stm32f746disco",
"uid": "210041000C51343237303334",
"debugger": "jlink",
"debugger_sn": "770935966",
"cpu": "STM32F746NG"
"flasher": "jlink",
"flasher_sn": "770935966",
"flasher_args": "-device STM32F746NG"
},
{
"name": "lpcxpresso43s67",
"uid": "08F000044528BAAA8D858F58C50700F5",
"flasher": "jlink",
"flasher_sn": "728973776",
"flasher_args": "-device LPC43S67_M4"
}
]
}

37
test/hil/hil_pi4.json Normal file
View File

@@ -0,0 +1,37 @@
{
"boards": [
{
"name": "raspberry_pi_pico",
"uid": "E6614C311B764A37",
"flasher": "openocd",
"flasher_sn": "E6614103E72C1D2F",
"flasher_args": "-f interface/cmsis-dap.cfg -f target/rp2040.cfg -c \"adapter speed 5000\""
},
{
"name": "espressif_s3_devkitm",
"uid": "84F703C084E4",
"tests": [
"cdc_msc_freertos", "hid_composite_freertos"
],
"flasher": "esptool",
"flasher_sn": "3ea619acd1cdeb11a0a0b806e93fd3f1",
"flasher_args": "-b 1500000"
},
{
"name": "feather_nrf52840_express",
"uid": "1F0479CD0F764471",
"flasher": "jlink",
"flasher_sn": "000682804350",
"flasher_args": "-device nrf52840_xxaa"
},
{
"name": "itsybitsy_m4",
"uid": "D784B28C5338533335202020FF044726",
"flasher": "bossac",
"flashser_vendor": "Adafruit Industries",
"flasher_product": "ItsyBitsy M4 Express",
"flasher_reset_pin": "2",
"flasher_args": "--offset 0x4000"
}
]
}

337
test/hil/hil_test.py
View File

@@ -28,62 +28,167 @@
import os
import sys
import time
import click
import serial
import subprocess
import json
import glob
def get_serial_dev(id, product, ifnum):
# get usb serial by id
return f'/dev/serial/by-id/usb-TinyUSB_{product}_{id}-if{ifnum:02d}'
def get_disk_dev(id, lun):
# get usb disk by id
return f'/dev/disk/by-id/usb-TinyUSB_Mass_Storage_{id}-0:{lun}'
def get_hid_dev(id, product, event):
return f'/dev/input/by-id/usb-TinyUSB_{product}_{id}-{event}'
def flash_jlink(sn, dev, firmware):
script = ['halt', 'r', f'loadfile {firmware}', 'r', 'go', 'exit']
f = open('flash.jlink', 'w')
f.writelines(f'{s}\n' for s in script)
f.close()
ret = subprocess.run(f'JLinkExe -USB {sn} -device {dev} -if swd -JTAGConf -1,-1 -speed auto -NoGui 1 -ExitOnError 1 -CommandFile flash.jlink',
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout = ret.stdout.decode()
os.remove('flash.jlink')
assert ret.returncode == 0, 'Flash failed\n' + stdout
def test_board_test(id):
# Dummy test
# for RPI double reset
try:
import gpiozero
except ImportError:
pass
def test_cdc_dual_ports(id):
port1 = get_serial_dev(id, "TinyUSB_Device", 0)
port2 = get_serial_dev(id, "TinyUSB_Device", 2)
# Wait device enum
timeout = 10
ENUM_TIMEOUT = 10
# get usb serial by id
def get_serial_dev(id, vendor_str, product_str, ifnum):
if vendor_str and product_str:
# known vendor and product
vendor_str = vendor_str.replace(' ', '_')
product_str = product_str.replace(' ', '_')
return f'/dev/serial/by-id/usb-{vendor_str}_{product_str}_{id}-if{ifnum:02d}'
else:
# just use id: mostly for cp210x/ftdi flasher
pattern = f'/dev/serial/by-id/usb-*_{id}-if{ifnum:02d}*'
port_list = glob.glob(pattern)
return port_list[0]
# Currently not used, left as reference
def get_disk_dev(id, vendor_str, lun):
# get usb disk by id
return f'/dev/disk/by-id/usb-{vendor_str}_Mass_Storage_{id}-0:{lun}'
def get_hid_dev(id, vendor_str, product_str, event):
return f'/dev/input/by-id/usb-{vendor_str}_{product_str}_{id}-{event}'
def open_serial_dev(port):
timeout = ENUM_TIMEOUT
ser = None
while timeout:
if os.path.exists(port1) and os.path.exists(port2):
break
if os.path.exists(port):
try:
# slight delay since kernel may occupy the port briefly
time.sleep(0.5)
timeout = timeout - 0.5
ser = serial.Serial(port, timeout=1)
break
except serial.SerialException:
pass
time.sleep(0.5)
timeout = timeout - 0.5
assert timeout, 'Device not available or Cannot open port'
return ser
def read_disk_file(id, fname):
# on different self-hosted, the mount point is different
file_list = [
f'/media/blkUSB_{id[-8:]}.02/{fname}',
f'/media/{os.getenv("USER")}/TinyUSB MSC/{fname}'
]
timeout = ENUM_TIMEOUT
while timeout:
for file in file_list:
if os.path.isfile(file):
with open(file, 'rb') as f:
data = f.read()
return data
time.sleep(1)
timeout = timeout - 1
assert timeout, 'Device not available'
return None
# -------------------------------------------------------------
# Flashing firmware
# -------------------------------------------------------------
def flash_jlink(board, firmware):
script = ['halt', 'r', f'loadfile {firmware}', 'r', 'go', 'exit']
with open('flash.jlink', 'w') as f:
f.writelines(f'{s}\n' for s in script)
ret = subprocess.run(
f'JLinkExe -USB {board["flasher_sn"]} {board["flasher_args"]} -if swd -JTAGConf -1,-1 -speed auto -NoGui 1 -ExitOnError 1 -CommandFile flash.jlink',
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
os.remove('flash.jlink')
return ret
def flash_openocd(board, firmware):
ret = subprocess.run(
f'openocd -c "adapter serial {board["flasher_sn"]}" {board["flasher_args"]} -c "program {firmware} reset exit"',
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
return ret
def flash_esptool(board, firmware):
port = get_serial_dev(board["flasher_sn"], None, None, 0)
dir = os.path.dirname(firmware)
with open(f'{dir}/config.env') as f:
IDF_TARGET = json.load(f)['IDF_TARGET']
with open(f'{dir}/flash_args') as f:
flash_args = f.read().strip().replace('\n', ' ')
command = (f'esptool.py --chip {IDF_TARGET} -p {port} {board["flasher_args"]} '
f'--before=default_reset --after=hard_reset write_flash {flash_args}')
ret = subprocess.run(command, shell=True, cwd=dir, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
return ret
def doublereset_with_rpi_gpio(board):
# Off = 0 = Reset
led = gpiozero.LED(board["flasher_reset_pin"])
led.off()
time.sleep(0.1)
led.on()
time.sleep(0.1)
led.off()
time.sleep(0.1)
led.on()
def flash_bossac(board, firmware):
# double reset to enter bootloader
doublereset_with_rpi_gpio(board)
port = get_serial_dev(board["uid"], board["flashser_vendor"], board["flasher_product"], 0)
timeout = ENUM_TIMEOUT
while timeout:
if os.path.exists(port):
break
else:
time.sleep(0.5)
timeout = timeout - 0.5
assert timeout, 'bossac bootloader is not available'
# sleep a bit more for bootloader to be ready
time.sleep(0.5)
ret = subprocess.run(f'bossac --port {port} {board["flasher_args"]} -U -i -R -e -w {firmware}', shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
return ret
# -------------------------------------------------------------
# Tests
# -------------------------------------------------------------
def test_board_test(id):
# Dummy test
pass
def test_cdc_dual_ports(id):
port1 = get_serial_dev(id, 'TinyUSB', "TinyUSB_Device", 0)
port2 = get_serial_dev(id, 'TinyUSB', "TinyUSB_Device", 2)
ser1 = open_serial_dev(port1)
ser2 = open_serial_dev(port2)
# Echo test
ser1 = serial.Serial(port1)
ser2 = serial.Serial(port2)
ser1.timeout = 1
ser2.timeout = 1
str1 = b"test_no1"
ser1.write(str1)
ser1.flush()
@@ -98,32 +203,17 @@ def test_cdc_dual_ports(id):
def test_cdc_msc(id):
port = get_serial_dev(id, "TinyUSB_Device", 0)
file = f'/media/blkUSB_{id[-8:]}.02/README.TXT'
# Wait device enum
timeout = 10
while timeout:
if os.path.exists(port) and os.path.isfile(file):
break
time.sleep(1)
timeout = timeout - 1
assert timeout, 'Device not available'
# Echo test
ser1 = serial.Serial(port)
ser1.timeout = 1
port = get_serial_dev(id, 'TinyUSB', "TinyUSB_Device", 0)
ser = open_serial_dev(port)
str = b"test_str"
ser1.write(str)
ser1.flush()
assert ser1.read(100) == str, 'CDC wrong data'
ser.write(str)
ser.flush()
assert ser.read(100) == str, 'CDC wrong data'
# Block test
f = open(file, 'rb')
data = f.read()
data = read_disk_file(id, 'README.TXT')
readme = \
b"This is tinyusb's MassStorage Class demo.\r\n\r\n\
If you find any bugs or get any questions, feel free to file an\r\n\
@@ -131,12 +221,17 @@ issue at github.com/hathach/tinyusb"
assert data == readme, 'MSC wrong data'
def test_cdc_msc_freertos(id):
test_cdc_msc(id)
def test_dfu(id):
# Wait device enum
timeout = 10
timeout = ENUM_TIMEOUT
while timeout:
ret = subprocess.run(f'dfu-util -l',
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout = ret.stdout.decode()
if f'serial="{id}"' in stdout and 'Found DFU: [cafe:4000]' in stdout:
break
@@ -161,10 +256,10 @@ def test_dfu(id):
assert ret.returncode == 0, 'Upload failed'
with open('dfu0') as f:
assert 'Hello world from TinyUSB DFU! - Partition 0' in f.read(), 'Wrong uploaded data'
assert 'Hello world from TinyUSB DFU! - Partition 0' in f.read(), 'Wrong uploaded data'
with open('dfu1') as f:
assert 'Hello world from TinyUSB DFU! - Partition 1' in f.read(), 'Wrong uploaded data'
assert 'Hello world from TinyUSB DFU! - Partition 1' in f.read(), 'Wrong uploaded data'
os.remove('dfu0')
os.remove('dfu1')
@@ -172,10 +267,10 @@ def test_dfu(id):
def test_dfu_runtime(id):
# Wait device enum
timeout = 10
timeout = ENUM_TIMEOUT
while timeout:
ret = subprocess.run(f'dfu-util -l',
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout = ret.stdout.decode()
if f'serial="{id}"' in stdout and 'Found Runtime: [cafe:4000]' in stdout:
break
@@ -186,11 +281,11 @@ def test_dfu_runtime(id):
def test_hid_boot_interface(id):
kbd = get_hid_dev(id, 'TinyUSB_Device', 'event-kbd')
mouse1 = get_hid_dev(id, 'TinyUSB_Device', 'if01-event-mouse')
mouse2 = get_hid_dev(id, 'TinyUSB_Device', 'if01-mouse')
kbd = get_hid_dev(id, 'TinyUSB', 'TinyUSB_Device', 'event-kbd')
mouse1 = get_hid_dev(id, 'TinyUSB', 'TinyUSB_Device', 'if01-event-mouse')
mouse2 = get_hid_dev(id, 'TinyUSB', 'TinyUSB_Device', 'if01-mouse')
# Wait device enum
timeout = 10
timeout = ENUM_TIMEOUT
while timeout:
if os.path.exists(kbd) and os.path.exists(mouse1) and os.path.exists(mouse2):
break
@@ -200,51 +295,91 @@ def test_hid_boot_interface(id):
assert timeout, 'Device not available'
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Usage:')
print('python hitl_test.py config.json')
sys.exit(-1)
def test_hid_composite_freertos(id):
# TODO implement later
pass
with open(f'{os.path.dirname(__file__)}/{sys.argv[1]}') as f:
# -------------------------------------------------------------
# Main
# -------------------------------------------------------------
@click.command()
@click.argument('config_file')
@click.option('-b', '--board', multiple=True, default=None, help='Boards to test, all if not specified')
def main(config_file, board):
"""
Hardware test on specified boards
"""
config_file = os.path.join(os.path.dirname(__file__), config_file)
with open(config_file) as f:
config = json.load(f)
# all possible tests, board_test is last to disable board's usb
# all possible tests
all_tests = [
'cdc_dual_ports', 'cdc_msc', 'dfu', 'dfu_runtime', 'hid_boot_interface', 'board_test'
'cdc_dual_ports', 'cdc_msc', 'dfu', 'dfu_runtime', 'hid_boot_interface',
]
for board in config['boards']:
print(f'Testing board:{board["name"]}')
if len(board) == 0:
config_boards = config['boards']
else:
config_boards = [e for e in config['boards'] if e['name'] in board]
for item in config_boards:
print(f'Testing board:{item["name"]}')
flasher = item['flasher'].lower()
# default to all tests
if 'tests' in board:
test_list = board['tests']
if 'tests' in item:
test_list = item['tests']
else:
test_list = all_tests
# board_test is added last to disable board's usb
test_list.append('board_test')
# remove skip_tests
if 'tests_skip' in board:
for skip in board['tests_skip']:
if 'tests_skip' in item:
for skip in item['tests_skip']:
if skip in test_list:
test_list.remove(skip)
for test in test_list:
mk_elf = f'examples/device/{test}/_build/{board["name"]}/{test}.elf'
cmake_elf = f'cmake-build/cmake-build-{board["name"]}/device/{test}/{test}.elf'
if os.path.isfile(cmake_elf):
elf = cmake_elf
elif os.path.isfile(mk_elf):
elf = mk_elf
else:
print(f'Cannot find firmware file for {test}')
fw_list = [
# cmake: esp32 & samd51 use .bin file
f'cmake-build/cmake-build-{item["name"]}/device/{test}/{test}.elf',
f'cmake-build/cmake-build-{item["name"]}/device/{test}/{test}.bin',
# make
f'examples/device/{test}/_build/{item["name"]}/{test}.elf'
]
fw = None
for f in fw_list:
if os.path.isfile(f):
fw = f
break
if fw is None:
print(f'Cannot find binary file for {test}')
sys.exit(-1)
if board['debugger'].lower() == 'jlink':
flash_jlink(board['debugger_sn'], board['cpu'], elf)
else:
# ToDo
pass
print(f' {test} ...', end='')
locals()[f'test_{test}'](board['uid'])
# flash firmware. It may fail randomly, retry a few times
for i in range(3):
ret = globals()[f'flash_{flasher}'](item, fw)
if ret.returncode == 0:
break
else:
print(f'Flashing failed, retry {i+1}')
time.sleep(1)
assert ret.returncode == 0, 'Flash failed\n' + ret.stdout.decode()
# run test
globals()[f'test_{test}'](item['uid'])
print('OK')
if __name__ == '__main__':
main()

25
test/unit-test/project.yml
View File

@@ -44,12 +44,13 @@
# in order to add common defines:
# 1) remove the trailing [] from the :common: section
# 2) add entries to the :common: section (e.g. :test: has TEST defined)
:common: &common_defines
- _UNITY_TEST_
:common: &common_defines []
:test:
- *common_defines
- _UNITY_TEST_
#- *common_defines
:test_preprocess:
- *common_defines
- _UNITY_TEST_
#- *common_defines
:cmock:
:mock_prefix: mock_
@@ -80,20 +81,20 @@
:tools:
:test_compiler:
:executable: clang
:name: 'clang compiler'
:executable: gcc
:name: 'gcc compiler'
:arguments:
- -I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE #expands to -I search paths
- -I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR #expands to -I search paths
- -D$: COLLECTION_DEFINES_TEST_AND_VENDOR #expands to all -D defined symbols
- -fsanitize=address
#- -fsanitize=address
- -c ${1} #source code input file (Ruby method call param list sub)
- -o ${2} #object file output (Ruby method call param list sub)
:test_linker:
:executable: clang
:name: 'clang linker'
:executable: gcc
:name: 'gcc linker'
:arguments:
- -fsanitize=address
#- -fsanitize=address
- ${1} #list of object files to link (Ruby method call param list sub)
- -o ${2} #executable file output (Ruby method call param list sub)
@@ -106,9 +107,9 @@
:flag: "${1}" # or "-L ${1}" for example
:common: &common_libraries []
:test:
- *common_libraries
#- *common_libraries
:release:
- *common_libraries
#- *common_libraries
:plugins:
:load_paths: