├── .gitignore ├── .idea ├── .gitignore ├── misc.xml ├── vcs.xml ├── inspectionProfiles │ ├── profiles_settings.xml │ └── Project_Default.xml ├── modules.xml └── CubeProgrammer_API.iml ├── CppExample ├── .gitignore ├── Example2.cpp ├── DisplayManager.h ├── Example.sln ├── Example1.cpp ├── DisplayManager.cpp ├── Example2.vcxproj └── Example1.vcxproj ├── api ├── came-from.lnk ├── CubeProgrammer_API.dll ├── lib │ └── CubeProgrammer_API.lib └── include │ ├── DeviceDataStructure.h │ └── CubeProgrammer_API.h ├── CubeProgrammer_API.cp310-win_amd64.pyd ├── run_setup.py ├── Start-Python-IDE.py ├── setup.py ├── TestHotPlug.py ├── runme.py ├── README.md ├── CubeProgrammer_API.pyx └── LICENSE /.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | /CubeProgrammer_API.cpp 3 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /CppExample/.gitignore: -------------------------------------------------------------------------------- 1 | /*.vcxproj.filters 2 | /*.vcxproj.user 3 | /x64 4 | /.vs 5 | -------------------------------------------------------------------------------- /api/came-from.lnk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jimfred/PyCubeProgrammer_API/HEAD/api/came-from.lnk -------------------------------------------------------------------------------- /api/CubeProgrammer_API.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jimfred/PyCubeProgrammer_API/HEAD/api/CubeProgrammer_API.dll -------------------------------------------------------------------------------- /api/lib/CubeProgrammer_API.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jimfred/PyCubeProgrammer_API/HEAD/api/lib/CubeProgrammer_API.lib -------------------------------------------------------------------------------- /CubeProgrammer_API.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jimfred/PyCubeProgrammer_API/HEAD/CubeProgrammer_API.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/profiles_settings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | -------------------------------------------------------------------------------- /run_setup.py: -------------------------------------------------------------------------------- 1 | # Executes 'python setup.py build_ext --inplace' 2 | 3 | import subprocess 4 | cmd = 'python setup.py build_ext --inplace' 5 | x = subprocess.run(cmd.split()) 6 | print('ok' if 0 == x.returncode else 'fail') 7 | # input("Press Enter to continue...") # pause to see result when launched from FileExplorer. 8 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/CubeProgrammer_API.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/Project_Default.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 12 | -------------------------------------------------------------------------------- /Start-Python-IDE.py: -------------------------------------------------------------------------------- 1 | #!"python.exe" 2 | ''' 3 | Start app asynchronously and briefly display a message. 4 | 'duration_sec' will linger so that CMD window can be read for debug purposes. 5 | ''' 6 | 7 | import subprocess 8 | import time 9 | import glob 10 | import os 11 | 12 | def find_app(app_path_name_pattern: str): 13 | apps = glob.glob(app_path_name_pattern) 14 | qty = len(apps) 15 | if 1 == qty: 16 | return apps[0] 17 | raise NameError(f'Found {qty}, {apps} but expected just 1') 18 | 19 | 20 | app = find_app('C:/Program Files/JetBrains/**/bin/pycharm64.exe') 21 | duration_sec=9 22 | 23 | print(f'Start {app}\nhere {os.getcwd()}') 24 | subprocess.Popen([app, "./"]) 25 | 26 | for i in range(duration_sec, 0, -1): 27 | print(f'{i}', end='\r'); 28 | time.sleep(1) 29 | 30 | 31 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | from distutils.core import setup 2 | from distutils.extension import Extension 3 | from Cython.Build import cythonize 4 | 5 | extensions = [ 6 | Extension( 7 | "CubeProgrammer_API", 8 | ["CubeProgrammer_API.pyx"], 9 | libraries=["CubeProgrammer_API"], language="c++", 10 | library_dirs=['./api/lib/'], 11 | ) 12 | ] 13 | setup( 14 | name="CubeProgrammer_API", 15 | version='0.1', 16 | description='CubeProgrammer_API.py', 17 | author='Jim Fred', 18 | author_email='jimfred@jimfred.org', 19 | ext_modules=cythonize( 20 | extensions, 21 | compiler_directives={ 22 | 'language_level': "3", 23 | 'always_allow_keywords': True # https://github.com/cython/cython/issues/2881 24 | }), 25 | requires=['Cython'] 26 | ) -------------------------------------------------------------------------------- /TestHotPlug.py: -------------------------------------------------------------------------------- 1 | 2 | import time 3 | 4 | api_dll_and_loader_path = 'C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer/api/lib/' # Directory containing DLLs, ExternalLoader and FlashLoader. 5 | import os # noqa: E402 6 | os.add_dll_directory(api_dll_and_loader_path) # Path to DLLs before importing CubeProgrammer_API. https://stackoverflow.com/a/67437837/101252 7 | # noinspection PyUnresolvedReferences 8 | import CubeProgrammer_API # noqa: E402 9 | 10 | api = CubeProgrammer_API.CubeProgrammer_API() 11 | 12 | api.setLoadersPath(api_dll_and_loader_path) 13 | api.set_default_log_message_verbosity(0) 14 | 15 | while True: 16 | time.sleep(1) 17 | 18 | api.connection_update() 19 | 20 | print(f'stlink qty={len(api.stlink_list)}, stlink_connected={api.stlink_connected}, device_connected={api.device_connected}') 21 | 22 | 23 | -------------------------------------------------------------------------------- /CppExample/Example2.cpp: -------------------------------------------------------------------------------- 1 | // Example2.cpp : This file contains the 'main' function. Program execution begins and ends there. 2 | // 3 | 4 | #include 5 | 6 | int main() 7 | { 8 | std::cout << "Hello World!\n"; 9 | } 10 | 11 | // Run program: Ctrl + F5 or Debug > Start Without Debugging menu 12 | // Debug program: F5 or Debug > Start Debugging menu 13 | 14 | // Tips for Getting Started: 15 | // 1. Use the Solution Explorer window to add/manage files 16 | // 2. Use the Team Explorer window to connect to source control 17 | // 3. Use the Output window to see build output and other messages 18 | // 4. Use the Error List window to view errors 19 | // 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project 20 | // 6. In the future, to open this project again, go to File > Open > Project and select the .sln file 21 | -------------------------------------------------------------------------------- /CppExample/DisplayManager.h: -------------------------------------------------------------------------------- 1 | 2 | #define BLACK 0 3 | #define BLUE 1 4 | #define GREEN 2 5 | #define CYAN 3 6 | #define RED 4 7 | #define MAGENTA 5 8 | #define BROWN 6 9 | #define LIGHTGREY 7 10 | #define DARKGREY 8 11 | #define LIGHTBLUE 9 12 | #define LIGHTGREEN 10 13 | #define LIGHTCYAN 11 14 | #define LIGHTRED 12 15 | #define LIGHTMAGENTA 13 16 | #define YELLOW 14 17 | #define WHITE 15 18 | #define BLINK 128 19 | 20 | 21 | typedef enum verbosity 22 | { 23 | VERBOSITY_LEVEL_0 = 0, 24 | VERBOSITY_LEVEL_1 = 1, 25 | VERBOSITY_LEVEL_2 = 2, 26 | VERBOSITY_LEVEL_3 = 3 27 | }verbosity; 28 | 29 | enum MSGTYPE 30 | { 31 | Normal, 32 | Info, 33 | GreenInfo, 34 | Title, 35 | Warning, 36 | Error, 37 | Verbosity_1, 38 | Verbosity_2, 39 | Verbosity_3, 40 | GreenInfoNoPopup, 41 | WarningNoPopup, 42 | ErrorNoPopup 43 | }; 44 | 45 | void InitPBar(); 46 | void lBar(int x, int n); 47 | void DisplayMessage(int msgType, const wchar_t* str); 48 | void logMessage(int msgType, const char* str,...); -------------------------------------------------------------------------------- /CppExample/Example.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.31424.327 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example2", "Example2.vcxproj", "{67946BF0-0CDE-4E99-A380-AB92924FEE74}" 7 | EndProject 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Example1", "Example1.vcxproj", "{AF2B6C20-3080-43F3-92FD-AF3879C6F23B}" 9 | EndProject 10 | Global 11 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 12 | Debug|x64 = Debug|x64 13 | Debug|x86 = Debug|x86 14 | Release|x64 = Release|x64 15 | Release|x86 = Release|x86 16 | EndGlobalSection 17 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 18 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Debug|x64.ActiveCfg = Debug|x64 19 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Debug|x64.Build.0 = Debug|x64 20 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Debug|x86.ActiveCfg = Debug|Win32 21 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Release|x64.ActiveCfg = Release|x64 22 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Release|x64.Build.0 = Release|x64 23 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Release|x86.ActiveCfg = Release|Win32 24 | {67946BF0-0CDE-4E99-A380-AB92924FEE74}.Release|x86.Build.0 = Release|Win32 25 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Debug|x64.ActiveCfg = Debug|x64 26 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Debug|x64.Build.0 = Debug|x64 27 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Debug|x86.ActiveCfg = Debug|Win32 28 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Debug|x86.Build.0 = Debug|Win32 29 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Release|x64.ActiveCfg = Release|x64 30 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Release|x64.Build.0 = Release|x64 31 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Release|x86.ActiveCfg = Release|Win32 32 | {AF2B6C20-3080-43F3-92FD-AF3879C6F23B}.Release|x86.Build.0 = Release|Win32 33 | EndGlobalSection 34 | GlobalSection(SolutionProperties) = preSolution 35 | HideSolutionNode = FALSE 36 | EndGlobalSection 37 | GlobalSection(ExtensibilityGlobals) = postSolution 38 | SolutionGuid = {265B0C23-9A69-4C82-8331-7A617E877954} 39 | EndGlobalSection 40 | EndGlobal 41 | -------------------------------------------------------------------------------- /runme.py: -------------------------------------------------------------------------------- 1 | 2 | api_dll_and_loader_path = 'C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer/api/lib/' # Directory containing DLLs, ExternalLoader and FlashLoader. 3 | import os # noqa: E402 4 | os.add_dll_directory(api_dll_and_loader_path) # Path to DLLs before importing CubeProgrammer_API. https://stackoverflow.com/a/67437837/101252 5 | # noinspection PyUnresolvedReferences 6 | import CubeProgrammer_API # noqa: E402 7 | 8 | 9 | def init_progress_bar(): 10 | print(f'InitProgressBar') 11 | 12 | 13 | def log_message(msgType : int, str): 14 | if msgType < 22: 15 | # print(f'{msgType}, {str}') 16 | print(f'{str}') 17 | 18 | 19 | def load_bar(curr_progress: int, total: int): 20 | print(f'{100 * curr_progress / total}%') 21 | 22 | 23 | api = CubeProgrammer_API.CubeProgrammer_API() 24 | 25 | api.setDisplayCallbacks( 26 | initProgressBar=init_progress_bar, 27 | logMessage=log_message, 28 | loadBar=load_bar) 29 | 30 | api.setLoadersPath(api_dll_and_loader_path) 31 | 32 | 33 | def check_connection(): 34 | x = api.checkDeviceConnection() 35 | str = 'Connected' if 1==x else 'Not connected' 36 | print(f'checkDeviceConnection: {str}') 37 | 38 | 39 | check_connection() 40 | 41 | list = api.getStLinkList() 42 | print(f'list: {list}') 43 | 44 | if len(list) == 1: 45 | x = api.connectStLink() 46 | if x < 0: 47 | api.disconnect() 48 | quit() 49 | 50 | check_connection() 51 | 52 | genInfo = api.getDeviceGeneralInf() 53 | print(f'genInfo: {genInfo}') 54 | 55 | resetFlag = api.reset(0) 56 | 57 | if resetFlag != 0: 58 | api.disconnect() 59 | quit() 60 | 61 | if False: # switch to enable downloads. 62 | isVerify = 1 # add verification step 63 | isSkipErase = 0 # no skip erase 64 | filePath = r'C:\Users\james.frederick\src\uctq_Sandbox\E102878-Qx\QuadRfDriverFirmware\Debug\QuadRfDriverFirmware.elf' 65 | downloadFileFlag = api.downloadFile(filePath) #, 0x08000000, isSkipErase, isVerify, "") 66 | if downloadFileFlag != 0: 67 | api.disconnect() 68 | quit() 69 | 70 | size = 64 71 | startAddress = 0x08000000 72 | data = api.readMemory(address=startAddress, byte_qty=size) 73 | 74 | print(f'data: {data}') 75 | 76 | print(f'\nReading 32-bit memory content') 77 | print(f' Size : {size} Bytes') 78 | print(f' Address: : 0x{startAddress:08X}') 79 | 80 | i = 0 81 | 82 | while i < size: 83 | col = 0 84 | print(f'\n@0x{startAddress + i:08X}:', end="") 85 | while (col < 4) and (i < size): 86 | # print(f' {data[i+3]:02X}{data[i+2]:02X}{data[i+1]:02X}{data[i]:02X} ', end="") 87 | u32 = int.from_bytes(data[i:i + 4], byteorder='little', signed=False) 88 | print(f' {u32:08X} ', end="") 89 | 90 | col += 1 91 | i += 4 92 | print() 93 | 94 | # Run application 95 | executeFlag = api.execute() 96 | if executeFlag != 0: 97 | api.disconnect() 98 | quit() 99 | 100 | api.disconnect() 101 | 102 | 103 | # input("Press Enter to continue...") # pause to see result -------------------------------------------------------------------------------- /api/include/DeviceDataStructure.h: -------------------------------------------------------------------------------- 1 | #ifndef DEVICEDATASTRUCTURE 2 | #define DEVICEDATASTRUCTURE 3 | 4 | 5 | #ifdef __cplusplus 6 | extern "C" { 7 | #endif 8 | 9 | #define R_ACCESS 0x0 10 | #define W_ACCESS 0x1 11 | #define RW_ACCESS 0x2 12 | #define RWE_ACCESS 0x3 13 | 14 | 15 | /* -------------------------------------------------------------------------------------------- */ 16 | /* OB Data Structures */ 17 | /* -------------------------------------------------------------------------------------------- */ 18 | 19 | 20 | /** 21 | * \struct bankSector. 22 | * \brief This stucture indicates the sectors parameters. 23 | */ 24 | typedef struct bankSector 25 | { 26 | unsigned int index ; /**< Index of the sector. */ 27 | unsigned int size ; /**< Sector size. */ 28 | unsigned int address ; /**< Sector starting address. */ 29 | }bankSector; 30 | 31 | 32 | /** 33 | * \struct deviceBank. 34 | * \brief This stucture defines the memory sectors for each bank. 35 | */ 36 | typedef struct deviceBank 37 | { 38 | unsigned int sectorsNumber; /**< Number of sectors of the considered bank. */ 39 | bankSector* sectors; /**< Sectors specifications #Bank_Sector. */ 40 | }deviceBank; 41 | 42 | 43 | /** 44 | * \struct storageStructure. 45 | * \brief This stucture describes sotrage characterization. 46 | */ 47 | typedef struct storageStructure 48 | { 49 | unsigned int banksNumber; /**< Number of exsisted banks. */ 50 | deviceBank* banks; /**< Banks sectors definition #Device_Bank. */ 51 | }storageStructure; 52 | 53 | 54 | /** 55 | * \struct bitCoefficient_C. 56 | * \brief This stucture indicates the coefficients to access to the adequate option bit. 57 | */ 58 | typedef struct bitCoefficient_C 59 | { 60 | unsigned int multiplier; /**< Bit multiplier. */ 61 | unsigned int offset; /**< Bit offset. */ 62 | }bitCoefficient_C; 63 | 64 | 65 | /** 66 | * \struct bitValue_C. 67 | * \brief This stucture describes the option Bit value. 68 | */ 69 | typedef struct bitValue_C 70 | { 71 | unsigned int value; /**< Option bit value. */ 72 | char description[200]; /**< Option bit description. */ 73 | }bitValue_C; 74 | 75 | 76 | /** 77 | * \struct bit_C. 78 | * \brief This stucture will be filled by values which characterize the device's option bytes. 79 | * \note See product reference manual for more details. 80 | */ 81 | typedef struct bit_C 82 | { 83 | char name[32]; /**< Bit name such as RDP, BOR_LEV, nBOOT0... */ 84 | char description[300]; /**< Config description. */ 85 | unsigned int wordOffset; /**< Word offset. */ 86 | unsigned int bitOffset; /**< Bit offset. */ 87 | unsigned int bitWidth; /**< Number of bits build the option. */ 88 | unsigned char access; /**< Access Read/Write. */ 89 | unsigned int valuesNbr; /**< Number of possible values. */ 90 | bitValue_C** values; /**< Bits value, #BitValue_C. */ 91 | bitCoefficient_C equation; /**< Bits equation, #BitCoefficient_C. */ 92 | unsigned char* reference; 93 | unsigned int bitValue; 94 | }bit_C; 95 | 96 | 97 | /** 98 | * \struct category_C 99 | * \brief Get option bytes banks categories descriptions. 100 | */ 101 | typedef struct category_C 102 | { 103 | char name[100]; /**< Get category name such as Read Out Protection, BOR Level... */ 104 | unsigned int bitsNbr; /**< Get bits number of the considered category. */ 105 | bit_C** bits; /**< Get internal bits descriptions. */ 106 | }category_C; 107 | 108 | 109 | /** 110 | * \struct bank_C 111 | * \brief Get option bytes banks internal descriptions. 112 | * \note STLINK and Bootloader interfaces have different addresses to access to option bytes registres. 113 | */ 114 | typedef struct bank_C 115 | { 116 | unsigned int size; /**< Bank size. */ 117 | unsigned int address; /**< Bank starting address. */ 118 | unsigned char access; /**< Bank access Read/Write. */ 119 | unsigned int categoriesNbr; /**< Number of option bytes categories. */ 120 | category_C** categories; /**< Get bank categories descriptions #Category_C. */ 121 | }bank_C; 122 | 123 | 124 | /** 125 | * \struct peripheral_C 126 | * \brief Get peripheral option bytes general informations. 127 | */ 128 | typedef struct peripheral_C 129 | { 130 | char name[32]; /**< Peripheral name. */ 131 | char description[200]; /**< Peripheral description. */ 132 | unsigned int banksNbr; /**< Number of existed banks. */ 133 | bank_C** banks; /**< Get banks descriptions #Bank_C. */ 134 | }peripheral_C; 135 | 136 | 137 | 138 | #ifdef __cplusplus 139 | } 140 | #endif 141 | 142 | 143 | #endif // DEVICEDATASTRUCTURE 144 | 145 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # PyCubeProgrammer_API 2 | 3 | Use your Python app to create a customized live-watch window for your firmware by talking over SWD. 4 | 5 | This is a Python wrapper for STM32 CubeProgrammer_API. It uses Cython, resulting in a .pyd python-DLL file that is imported by a user's Python program. 6 | 7 | [![](https://mermaid.ink/img/eyJjb2RlIjoiZ3JhcGggVEQ7XG5cdFx0Y2xhc3NEZWYgR3JlZW5GaWxsIGZpbGw6IzdmNztcbiAgICBzdWJncmFwaCBXaW5kb3dzXG5cdFx0XHR1c2VyUHl0aG9uW3VzZXIgUHl0aG9uXSAtLT4gUHlDdWJlUHJvZ3JhbW1lcl9BUElbQ3ViZVByb2dyYW1tZXJfQVBJLnB5ZDxicj50aGluIFB5dGhvbiB3cmFwcGVyXTo6OkdyZWVuRmlsbDtcbiAgICAgIFB5Q3ViZVByb2dyYW1tZXJfQVBJIC0tPiBDdWJlUHJvZ3JhbW1lcl9BUEk7XG4gICAgICBDdWJlUHJvZ3JhbW1lcl9BUElbQ3ViZVByb2dyYW1tZXJfQVBJPGJyPkRMTHMgYW5kIGRyaXZlcnNdXG5cdFx0ZW5kXG5cbiAgICBDdWJlUHJvZ3JhbW1lcl9BUEkgLS0-fFVTQnwgU1RMaW5rW1NULUxpbmsgZG9uZ2xlXVxuXHQgIFNUTGluayAtLT58U1dEIG9yIEpUQUd8IFNUTTMyW1NUTTMyIE1pY3JvQ29udHJvbGxlcl1cbiAgICBodHRwczovL3d3dy5zdC5jb20vZW4vZGV2ZWxvcG1lbnQtdG9vbHMvc3RtMzJjdWJlcHJvZy5odG1sIC0tLS0-fGRvd25sb2FkL2luc3RhbGx8IEN1YmVQcm9ncmFtbWVyX0FQSVxuICAgIGh0dHBzOi8vZ2l0aHViLmNvbS9qaW1mcmVkL1B5Q3ViZVByb2dyYW1tZXJfQVBJIC0tLS0-fGRvd25sb2FkL2NvcHl8IFB5Q3ViZVByb2dyYW1tZXJfQVBJIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRlZmF1bHQifSwidXBkYXRlRWRpdG9yIjpmYWxzZSwiYXV0b1N5bmMiOnRydWUsInVwZGF0ZURpYWdyYW0iOmZhbHNlfQ)](https://mermaid-js.github.io/mermaid-live-editor/edit/#eyJjb2RlIjoiZ3JhcGggVEQ7XG5cdFx0Y2xhc3NEZWYgR3JlZW5GaWxsIGZpbGw6IzdmNztcbiAgICBzdWJncmFwaCBXaW5kb3dzXG5cdFx0XHR1c2VyUHl0aG9uW3VzZXIgUHl0aG9uXSAtLT4gUHlDdWJlUHJvZ3JhbW1lcl9BUElbQ3ViZVByb2dyYW1tZXJfQVBJLnB5ZDxicj50aGluIFB5dGhvbiB3cmFwcGVyXTo6OkdyZWVuRmlsbDtcbiAgICAgIFB5Q3ViZVByb2dyYW1tZXJfQVBJIC0tPiBDdWJlUHJvZ3JhbW1lcl9BUEk7XG4gICAgICBDdWJlUHJvZ3JhbW1lcl9BUElbQ3ViZVByb2dyYW1tZXJfQVBJPGJyPkRMTHMgYW5kIGRyaXZlcnNdXG5cdFx0ZW5kXG5cbiAgICBDdWJlUHJvZ3JhbW1lcl9BUEkgLS0-fFVTQnwgU1RMaW5rW1NULUxpbmsgZG9uZ2xlXVxuXHQgIFNUTGluayAtLT58U1dEIG9yIEpUQUd8IFNUTTMyW1NUTTMyIE1pY3JvQ29udHJvbGxlcl1cbiAgICBodHRwczovL3d3dy5zdC5jb20vZW4vZGV2ZWxvcG1lbnQtdG9vbHMvc3RtMzJjdWJlcHJvZy5odG1sIC0tLS0-fGRvd25sb2FkL2luc3RhbGx8IEN1YmVQcm9ncmFtbWVyX0FQSVxuICAgIGh0dHBzOi8vZ2l0aHViLmNvbS9qaW1mcmVkL1B5Q3ViZVByb2dyYW1tZXJfQVBJIC0tLS0-fGRvd25sb2FkL2NvcHl8IFB5Q3ViZVByb2dyYW1tZXJfQVBJIiwibWVybWFpZCI6IntcbiAgXCJ0aGVtZVwiOiBcImRlZmF1bHRcIlxufSIsInVwZGF0ZUVkaXRvciI6ZmFsc2UsImF1dG9TeW5jIjp0cnVlLCJ1cGRhdGVEaWFncmFtIjpmYWxzZX0) 8 | 9 | The STM32 CubeProgrammer_API is a C-library, created by ST for ST-Link access to micro-controllers for the purpose of flash downloads or general memory access. The CubeProgrammer is required, including its drivers, and can be downloaded from st.com and installed. 10 | 11 | This has been tested on Windows and although CubeProgrammer is available for other OS's. The main focus so far is USB-to-SWD access. 12 | 13 | Two examples are included: 14 | - TestHotPlug.py - a console app that gracefully recovers from a hot-plug of either end of an ST-Link (USB end or the SWD end). 15 | - runme.py - based loosely on C examples included in the CubeProgrammer_API. 16 | 17 | ## Why would anybody want this? 18 | Firmware rarely remains isolated in it's own little CPU. It needs to interact with people and processes, at least during testing and development. That's what communication protocols are for, right? Yes, but with SWD (or JTAG), the firmware needs no communication protocols. SWD is used anyway for firmware download. While it's there, plugged in, it's available for things like reading and writing of data. It's like a live-watch debug window to read and write data except it can be orchestrated by Python and leverage Python's GUI capabilities. And how does Python know how to access data? The same way a debugger does - by interrogating the .elf file to determine data structures and their locations. This capability is useful for R&D development, production testing and beyond. All the necessary drivers for various OS's are handled by others and the firmware doesn't need to implement any communications protocols to open a huge window to the outside world for human interaction. 19 | 20 | ## Installation 21 | copy CubeProgrammer_API.cp39-win_amd64.pyd locally. It's assumed that CubeProgrammer has been installed (`C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer/api/lib/`) and has all the necessary DLLs required by the CubeProgrammer_API .pyd file. See the top of the examples for code to reference the location of those DLLs. 22 | 23 | ## Usage 24 | In a Python application, reference the API's DLLs with a statement like...
25 | ```os.add_dll_directory('C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer/api/lib/')``` 26 |
The `os` will, of course need an `import os` 27 | 28 | Then import the .PYD extension like this... 29 | `import CubeProgrammer_API` 30 | The import needs to be done after the `add_dll_directory()`. 31 | 32 | This Cython/Python wrapper performs default initialization that the C-API omitted such as initialization of callbacks. This default initialization will prevent faults/exceptions that halt/crash the application without diagnostic information. 33 | 34 | 35 | ## Development 36 | - setup.py and run_setup.py are used to compile the Cython .pyx file to a .dll with the .pyd extension. 37 | - CppExample is a Visual Studio project that uses the CubeProgrammer_API, used only to isolate C-vs-Python issues. 38 | - CubeProgrammer_API.cpp is a temporary intermediate file used by Cython to generate the .pyd file. 39 | 40 | ## Other similar projects: 41 | - pyOCD 42 | - PyStLink 43 | - OpenOcd 44 | 45 | Although there are several other libraries that provide debug interfaces to ARM micro-controllers, some with Python bindings, this PyCubeProgrammer_API is intended to leverage ST's support for driver installation and support for new chip variants. 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /CppExample/Example1.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * \file Example1.cpp 3 | * This example allows to execute some operations to the internal STM32 Flash memory. \n 4 | * 1. Detect connected ST-LINK and display them. \n 5 | * 2. Loop on each ST-LINK probes and execute the following operations: \n 6 | * - Mass erase. 7 | * - Single word edition (-w32). 8 | * - Read 64 bytes from 0x08000000. 9 | * - Sector erase. 10 | * - Read 64 bytes from 0x08000000 . 11 | * - System Reset. \n 12 | *. 13 | *Go to the source code : \ref STLINK_Example1 14 | * \example STLINK_Example1 15 | * This example allows to execute some operations to the internal STM32 Flash memory. \n 16 | * 1. Detect connected ST-LINK and display them. \n 17 | * 2. Loop on each St-LINK probes and execute the following operations: \n 18 | * - Mass erase. 19 | * - Single word edition (-w32). 20 | * - Read 64 bytes from 0x08000000. 21 | * - Sector erase. 22 | * - Read 64 bytes from 0x08000000 . 23 | * - System Reset. \n 24 | * \code{.cpp} 25 | **/ 26 | 27 | #include 28 | #include 29 | #include "DisplayManager.h" 30 | 31 | #include 32 | #pragma comment(lib, "CubeProgrammer_API.lib") 33 | // Prerequisites for CubeProgrammer_API compile & link: 34 | // - Include path needs $(ProjectDir)..\api\include or 35 | // - Lib path needs $(ProjectDir)..\api\lib 36 | // Prerequisites for CubeProgrammer_API debug/execution: 37 | // - debuger environment needs: PATH=C:\Program Files\STMicroelectronics\STM32Cube\STM32CubeProgrammer\api\lib;%PATH% 38 | 39 | extern unsigned int verbosityLevel; 40 | 41 | int Example1(void) { 42 | 43 | logMessage(Title, "\n+++ Example 1 +++\n\n"); 44 | 45 | debugConnectParameters* stLinkList; 46 | debugConnectParameters debugParameters; 47 | generalInf* genInfo; 48 | 49 | int getStlinkListNb = getStLinkList(&stLinkList, 0); 50 | 51 | if (getStlinkListNb == 0) 52 | { 53 | logMessage(Error, "No STLINK available\n"); 54 | return 0; 55 | } 56 | else { 57 | logMessage(Title, "\n-------- Connected ST-LINK Probes List --------"); 58 | for (int i = 0; i < getStlinkListNb; i++) 59 | { 60 | logMessage(Normal, "\nST-LINK Probe %d :\n", i); 61 | logMessage(Info, " ST-LINK SN : %s \n", stLinkList[i].serialNumber); 62 | logMessage(Info, " ST-LINK FW : %s \n", stLinkList[i].firmwareVersion); 63 | } 64 | logMessage(Title, "-----------------------------------------------\n\n"); 65 | } 66 | 67 | for (int index = 0; index < getStlinkListNb; index++) { 68 | 69 | logMessage(Title, "\n--------------------- "); 70 | logMessage(Title, "\n ST-LINK Probe : %d ", index); 71 | logMessage(Title, "\n--------------------- \n\n"); 72 | 73 | debugParameters = stLinkList[index]; 74 | debugParameters.connectionMode = HOTPLUG_MODE; // UNDER_RESET_MODE; 75 | debugParameters.shared = 0; 76 | 77 | /* Target connect */ 78 | int connectStlinkFlag = connectStLink(debugParameters); 79 | if (connectStlinkFlag != 0) { 80 | logMessage(Error, "Establishing connection with the device failed\n"); 81 | disconnect(); 82 | continue; 83 | } 84 | else { 85 | logMessage(GreenInfo, "\n--- Device %d Connected --- \n", index); 86 | } 87 | 88 | /* Display device informations */ 89 | genInfo = getDeviceGeneralInf(); 90 | logMessage(Normal, "\nDevice name : %s ", genInfo->name); 91 | logMessage(Normal, "\nDevice type : %s ", genInfo->type); 92 | logMessage(Normal, "\nDevice CPU : %s \n", genInfo->cpu); 93 | 94 | /* Reading 64 bytes from 0x08000000 */ 95 | unsigned char* dataStruct = 0; 96 | int size = 64; 97 | int startAddress = 0x08000000; 98 | 99 | int readMemoryFlag = readMemory(startAddress, &dataStruct, size); 100 | if (readMemoryFlag != 0) 101 | { 102 | disconnect(); 103 | continue; 104 | } 105 | 106 | logMessage(Normal, "\nReading 32-bit memory content\n"); 107 | logMessage(Normal, " Size : %d Bytes\n", size); 108 | logMessage(Normal, " Address: : 0x%08X\n", startAddress); 109 | 110 | int i = 0, col = 0; 111 | 112 | while ((i < size)) 113 | { 114 | col = 0; 115 | logMessage(Normal, "\n0x%08X :", startAddress + i); 116 | while ((col < 4) && (i < size)) 117 | { 118 | logMessage(Info, " %08X ", *(unsigned int*)(dataStruct + i)); 119 | col++; 120 | i += 4; 121 | } 122 | 123 | } 124 | logMessage(Normal, "\n"); 125 | 126 | /* Process successfully Done */ 127 | disconnect(); 128 | } 129 | 130 | deleteInterfaceList(); 131 | return 1; 132 | 133 | } 134 | 135 | int main() 136 | { 137 | int x = checkDeviceConnection(); 138 | 139 | int ret = 0; 140 | const char* loaderPath = "C:/Program Files/STMicroelectronics/STM32Cube/STM32CubeProgrammer/api/lib/"; // reference directory that has ExternalLoader and FlashLoader. 141 | displayCallBacks vsLogMsg; 142 | 143 | /* Set device loaders path that contains FlashLoader and ExternalLoader folders*/ 144 | setLoadersPath(loaderPath); 145 | 146 | /* Set the progress bar and message display functions callbacks */ 147 | vsLogMsg.logMessage = DisplayMessage; 148 | vsLogMsg.initProgressBar = InitPBar; 149 | vsLogMsg.loadBar = lBar; 150 | setDisplayCallbacks(vsLogMsg); 151 | 152 | /* Set DLL verbosity level */ 153 | //setVerbosityLevel(verbosityLevel = VERBOSITY_LEVEL_1); 154 | 155 | ret = Example1(); 156 | //ret = Example2(); 157 | //ret = Example3(); 158 | //ret = Example_WB(); 159 | //ret = I2C_Example(); 160 | //ret = CAN_Example(); 161 | //ret = SPI_Example(); 162 | //ret = UART_Example(); 163 | //ret = USB_Example(); 164 | //ret = USB_Example_WB(); 165 | //ret = TSV_Flashing(); 166 | 167 | std::cout << "\n" << "Press enter to continue..."; 168 | std::cin.get(); 169 | return ret; 170 | } 171 | 172 | 173 | /** \endcode **/ 174 | -------------------------------------------------------------------------------- /CppExample/DisplayManager.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * \file DisplayManager.cpp 3 | * This example of functions allows to personalize the display messages. \n 4 | * - Implement Init Progress Bar function to add a progress bar. 5 | * - Implement load Bar function to animate the loading process 0% to 100%. 6 | * - Implement DisplayMessage function to ensure the display of internal DLL messages. 7 | * - Implement logMessage function to personalize the display (user messages). 8 | *. 9 | * Go to the source code : \ref DisplayManager 10 | \example DisplayManager 11 | * This example of functions allows to personalize the display messages. \n 12 | * - Implement Init Progress Bar function to add a progress bar. 13 | * - Implement load Bar function to animate the loading process 0% to 100%. 14 | * - Implement DisplayMessage function to ensure the display of internal DLL messages. 15 | * - Implement logMessage function to personalize the display (user messages). 16 | * \code{.cpp} 17 | **/ 18 | 19 | #define _CRT_SECURE_NO_WARNINGS // will disable warnings to use vsprintf instead vsprintf_s 20 | 21 | #include 22 | #include "DisplayManager.h" 23 | #include 24 | #include 25 | #include 26 | 27 | #ifdef _WIN32 28 | #include 29 | HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);; 30 | CONSOLE_SCREEN_BUFFER_INFO SBInfo, CurSBInfo; 31 | #endif 32 | 33 | #define WIDH 50 34 | using namespace std; 35 | 36 | unsigned int verbosityLevel; 37 | unsigned int Progress = 0; 38 | 39 | 40 | void InitPBar() 41 | { 42 | #ifdef _WIN32 43 | if (verbosityLevel == VERBOSITY_LEVEL_1) 44 | { 45 | for (int idx = 0; idx < WIDH; idx++) 46 | { 47 | console = GetStdHandle(STD_OUTPUT_HANDLE); 48 | SetConsoleTextAttribute(console, LIGHTGREY); 49 | putc(177, stdout); 50 | } 51 | GetConsoleScreenBufferInfo(console, &SBInfo); 52 | printf(" %d%c", Progress,'%'); 53 | SetConsoleTextAttribute(console, LIGHTCYAN); 54 | putc('\r', stdout); 55 | Progress = 0; 56 | } 57 | #endif 58 | } 59 | 60 | void lBar(int currProgress, int total) 61 | { 62 | unsigned int alreadyLoaded = 0; 63 | if (total == 0) return; 64 | if (currProgress > total) 65 | currProgress = total; 66 | 67 | /*Calculuate the ratio of complete-to-incomplete.*/ 68 | float ratio = currProgress / (float)total; 69 | unsigned int counter = (unsigned int)ratio * WIDH; 70 | 71 | if ((counter > alreadyLoaded) && (verbosityLevel == VERBOSITY_LEVEL_1)) 72 | { 73 | #ifdef _WIN32 74 | SetConsoleTextAttribute(console, FOREGROUND_GREEN); 75 | 76 | for (DWORD Idx = Progress; Idx < (counter - alreadyLoaded); Idx++) 77 | { 78 | putc(219, stdout); 79 | } 80 | Progress = counter; 81 | GetConsoleScreenBufferInfo(console, &CurSBInfo); 82 | SetConsoleCursorPosition(console, SBInfo.dwCursorPosition); 83 | 84 | printf(" %d%%", (int)(ratio * 100)); 85 | SetConsoleCursorPosition(console, CurSBInfo.dwCursorPosition); 86 | #else 87 | 88 | printf("\033[00;32m"); 89 | printf("["); 90 | for (int i = 0; i < counter; i++) 91 | { 92 | printf("="); 93 | } 94 | for (int i = counter; i < WIDH; i++) 95 | { 96 | printf(" "); 97 | } 98 | // draw the percentage progress 99 | 100 | printf("] %3d%% \r", (int)(ratio * 100)); /* Move to the first column*/ 101 | printf("\033[39;49m"); 102 | #endif 103 | } 104 | alreadyLoaded = counter; 105 | } 106 | 107 | 108 | void DisplayMessage(int msgType, const wchar_t* str) 109 | { 110 | 111 | #ifdef _WIN32 112 | switch (msgType) 113 | { 114 | default: 115 | case Normal: 116 | SetConsoleTextAttribute(console, WHITE); 117 | break; 118 | case GreenInfo: 119 | SetConsoleTextAttribute(console, GREEN); 120 | break; 121 | case Info: 122 | SetConsoleTextAttribute(console, LIGHTGREY); 123 | break; 124 | case Title: 125 | SetConsoleTextAttribute(console, LIGHTCYAN); 126 | break; 127 | case Error: 128 | SetConsoleTextAttribute(console, RED); 129 | break; 130 | case Warning: 131 | SetConsoleTextAttribute(console, YELLOW); 132 | break; 133 | case ErrorNoPopup: 134 | SetConsoleTextAttribute(console, RED); 135 | break; 136 | case WarningNoPopup: 137 | SetConsoleTextAttribute(console, YELLOW); 138 | break; 139 | case Verbosity_1: 140 | SetConsoleTextAttribute(console, CYAN); 141 | break; 142 | case Verbosity_2: 143 | SetConsoleTextAttribute(console, CYAN); 144 | break; 145 | case Verbosity_3: 146 | SetConsoleTextAttribute(console, CYAN); 147 | break; 148 | } 149 | 150 | if ((msgType != Verbosity_1 && msgType != Verbosity_2 && msgType != Verbosity_3) || ((msgType == Verbosity_1 && verbosityLevel >= VERBOSITY_LEVEL_1) || (msgType == Verbosity_2 && verbosityLevel >= VERBOSITY_LEVEL_2) || (msgType == Verbosity_3 && verbosityLevel == VERBOSITY_LEVEL_3))) { 151 | 152 | wprintf(L"%s\n", str); 153 | } 154 | SetConsoleTextAttribute(console, WHITE); 155 | #else 156 | if (verbosityLevel == VERBOSITY_LEVEL_1) 157 | { 158 | if ((msgType == Verbosity_1 && verbosityLevel >= 1)) 159 | printf("\033[39;36m"); 160 | if ((msgType == Verbosity_2 && verbosityLevel >= 2)) 161 | printf("\033[39;36m"); 162 | if ((msgType == Verbosity_3 && verbosityLevel >= 3)) 163 | printf("\033[39;36m"); 164 | 165 | switch (msgType) 166 | { 167 | case GreenInfo: 168 | printf("\033[00;32m"); 169 | break; 170 | case Info: 171 | printf("\e[90m"); 172 | break; 173 | case Normal: 174 | printf("\033[39;49m"); 175 | break; 176 | case Warning: 177 | printf("\033[00;33m"); 178 | break; 179 | case Error: 180 | printf("\033[00;31m"); 181 | break; 182 | case Title: 183 | printf("\e[36m\033[01m"); 184 | break; 185 | } 186 | } 187 | if ((msgType != Verbosity_1 && msgType != Verbosity_2 && msgType != Verbosity_3) || ((msgType == Verbosity_1 && verbosityLevel >= 1) || (msgType == Verbosity_2 && verbosityLevel >= 2) || (msgType == Verbosity_3 && verbosityLevel == 3))) 188 | { 189 | std::wcout << str << std::endl; 190 | } 191 | printf("\033[39;49m"); 192 | #endif 193 | } 194 | 195 | void logMessage(int msgType, const char* str, ...) 196 | { 197 | #ifdef _WIN32 198 | switch (msgType) 199 | { 200 | default: 201 | case Normal: 202 | SetConsoleTextAttribute(console, WHITE); 203 | break; 204 | case GreenInfo: 205 | SetConsoleTextAttribute(console, GREEN); 206 | break; 207 | case Info: 208 | SetConsoleTextAttribute(console, LIGHTGREY); 209 | break; 210 | case Title: 211 | SetConsoleTextAttribute(console, LIGHTCYAN); 212 | break; 213 | case Error: 214 | SetConsoleTextAttribute(console, RED); 215 | break; 216 | case Warning: 217 | SetConsoleTextAttribute(console, YELLOW); 218 | break; 219 | case ErrorNoPopup: 220 | SetConsoleTextAttribute(console, RED); 221 | break; 222 | case WarningNoPopup: 223 | SetConsoleTextAttribute(console, YELLOW); 224 | break; 225 | case Verbosity_1: 226 | SetConsoleTextAttribute(console, CYAN); 227 | break; 228 | case Verbosity_2: 229 | SetConsoleTextAttribute(console, CYAN); 230 | break; 231 | case Verbosity_3: 232 | SetConsoleTextAttribute(console, CYAN); 233 | break; 234 | } 235 | #else 236 | switch (msgType) 237 | { 238 | case GreenInfo: 239 | printf("\033[00;32m"); 240 | break; 241 | case Info: 242 | printf("\e[90m"); 243 | break; 244 | case Normal: 245 | printf("\033[39;49m"); 246 | break; 247 | case Warning: 248 | printf("\033[00;33m"); 249 | break; 250 | case Error: 251 | printf("\033[00;31m"); 252 | break; 253 | case Title: 254 | printf("\e[36m\033[01m"); 255 | break; 256 | } 257 | #endif 258 | va_list args; 259 | va_start(args, str); 260 | char buffer[256]; 261 | vsprintf(buffer, str, args); 262 | printf("%s", buffer); 263 | va_end(args); 264 | 265 | #ifdef _WIN32 266 | SetConsoleTextAttribute(console, WHITE); 267 | #else 268 | printf("\033[39;49m"); 269 | #endif 270 | } 271 | 272 | /** \endcode **/ 273 | -------------------------------------------------------------------------------- /CppExample/Example2.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | Win32Proj 24 | {67946bf0-0cde-4e99-a380-ab92924fee74} 25 | Example2 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v142 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v142 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v142 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v142 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | 76 | 77 | false 78 | 79 | 80 | true 81 | 82 | 83 | false 84 | ..\api\include;$(IncludePath) 85 | ..\api\lib\x64;$(LibraryPath) 86 | 87 | 88 | 89 | Level3 90 | true 91 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 92 | true 93 | 94 | 95 | Console 96 | true 97 | 98 | 99 | 100 | 101 | Level3 102 | true 103 | true 104 | true 105 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 106 | true 107 | 108 | 109 | Console 110 | true 111 | true 112 | true 113 | 114 | 115 | 116 | 117 | Level3 118 | true 119 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 120 | true 121 | 122 | 123 | Console 124 | true 125 | 126 | 127 | 128 | 129 | Level3 130 | true 131 | true 132 | true 133 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 134 | true 135 | 136 | 137 | Console 138 | true 139 | true 140 | true 141 | %(AdditionalLibraryDirectories) 142 | CubeProgrammer_API.lib;%(AdditionalDependencies) 143 | $(ProjectDir)..\$(TargetName)$(TargetExt) 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | -------------------------------------------------------------------------------- /CppExample/Example1.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | Win32Proj 24 | {af2b6c20-3080-43f3-92fd-af3879c6f23b} 25 | Example1 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v142 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v142 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v142 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v142 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | 76 | 77 | false 78 | 79 | 80 | true 81 | $(ProjectDir)..\api\include;$(IncludePath) 82 | $(ProjectDir)..\api\lib;$(IncludePath);$(LibraryPath) 83 | $(ExecutablePath) 84 | 85 | 86 | false 87 | ..\api\include;$(IncludePath) 88 | ..\api\lib\x64;$(LibraryPath) 89 | 90 | 91 | 92 | Level3 93 | true 94 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 95 | true 96 | 97 | 98 | Console 99 | true 100 | 101 | 102 | 103 | 104 | Level3 105 | true 106 | true 107 | true 108 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 109 | true 110 | 111 | 112 | Console 113 | true 114 | true 115 | true 116 | 117 | 118 | 119 | 120 | Level3 121 | true 122 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 123 | true 124 | 125 | 126 | Console 127 | true 128 | 129 | 130 | 131 | 132 | Level3 133 | true 134 | true 135 | true 136 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 137 | true 138 | 139 | 140 | Console 141 | true 142 | true 143 | true 144 | %(AdditionalLibraryDirectories) 145 | CubeProgrammer_API.lib;%(AdditionalDependencies) 146 | $(ProjectDir)..\$(TargetName)$(TargetExt) 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /CubeProgrammer_API.pyx: -------------------------------------------------------------------------------- 1 | """ 2 | Define thin Python wrapper for CubeProgrammer_API using Cython. 3 | This generates a .PYD python extension. 4 | Members added to read and write symbols e.g., floats etc. 5 | """ 6 | 7 | import struct 8 | 9 | cdef extern from "stddef.h": 10 | ctypedef void wchar_t 11 | 12 | from cpython.ref cimport PyObject 13 | cdef extern from "Python.h": 14 | PyObject* PyUnicode_FromWideChar(wchar_t *w, Py_ssize_t size) 15 | wchar_t* PyUnicode_AsWideCharString(object, Py_ssize_t*) except NULL 16 | 17 | 18 | # Tell Cython what C constructs we wish to use from this C header file 19 | cdef extern from "./api/include/CubeProgrammer_API.h": 20 | 21 | cdef enum cubeProgrammerError: 22 | CUBEPROGRAMMER_NO_ERROR = 0, # Success (no error) 23 | CUBEPROGRAMMER_ERROR_NOT_CONNECTED = -1, # Device not connected 24 | CUBEPROGRAMMER_ERROR_NO_DEVICE = -2, # Device not found 25 | CUBEPROGRAMMER_ERROR_CONNECTION = -3, # Device connection error 26 | CUBEPROGRAMMER_ERROR_NO_FILE = -4, # No such file 27 | CUBEPROGRAMMER_ERROR_NOT_SUPPORTED = -5, # Operation not supported or unimplemented on this interface 28 | CUBEPROGRAMMER_ERROR_INTERFACE_NOT_SUPPORTED = -6, # Interface not supported or unimplemented on this plateform 29 | CUBEPROGRAMMER_ERROR_NO_MEM = -7, # Insufficient memory 30 | CUBEPROGRAMMER_ERROR_WRONG_PARAM = -8, # Wrong parameters 31 | CUBEPROGRAMMER_ERROR_READ_MEM = -9, # Memory read failure 32 | CUBEPROGRAMMER_ERROR_WRITE_MEM = -10, # Memory write failure 33 | CUBEPROGRAMMER_ERROR_ERASE_MEM = -11, # Memory erase failure 34 | CUBEPROGRAMMER_ERROR_UNSUPPORTED_FILE_FORMAT = -12, # File format not supported for this kind of device 35 | CUBEPROGRAMMER_ERROR_REFRESH_REQUIRED = -13, # Refresh required 36 | CUBEPROGRAMMER_ERROR_NO_SECURITY = -14, # Refresh required 37 | CUBEPROGRAMMER_ERROR_CHANGE_FREQ = -15, # Changing frequency problem 38 | CUBEPROGRAMMER_ERROR_RDP_ENABLED = -16, # RDP Enabled error 39 | CUBEPROGRAMMER_ERROR_OTHER = -99, # Other error 40 | 41 | cdef enum debugConnectMode: 42 | NORMAL_MODE = 0, # Connect with normal mode, the target is reset then halted while the type of reset is selected using the [debugResetMode]. 43 | HOTPLUG_MODE, # Connect with hotplug mode, this option allows the user to connect to the target without halt or reset. 44 | UNDER_RESET_MODE, # Connect with under reset mode, option allows the user to connect to the target using a reset vector catch before executing any instruction. 45 | POWER_DOWN_MODE, # Connect with power down mode. 46 | PRE_RESET_MODE # Connect with pre reset mode. 47 | 48 | cdef enum debugPort: 49 | JTAG = 0, 50 | SWD = 1, 51 | 52 | cdef enum debugResetMode: 53 | SOFTWARE_RESET, # Apply a reset by the software. 54 | HARDWARE_RESET, # Apply a reset by the hardware. 55 | CORE_RESET # Apply a reset by the internal core peripheral. 56 | 57 | cdef struct frequencies: 58 | unsigned int jtagFreq[12] # JTAG frequency. 59 | unsigned int jtagFreqNumber # Get JTAG supported frequencies. 60 | unsigned int swdFreq[12] # SWD frequency. 61 | unsigned int swdFreqNumber # Get SWD supported frequencies. 62 | 63 | # https://cython.readthedocs.io/en/latest/src/userguide/external_C_code.html#styles-of-struct-union-and-enum-declaration 64 | cdef struct debugConnectParameters: 65 | debugPort dbgPort # Select the type of debug interface #debugPort. 66 | int index # Select one of the debug ports connected. 67 | char serialNumber[33] # ST-LINK serial number. 68 | char firmwareVersion[20] # Firmware version. 69 | char targetVoltage[5] # Operate voltage. 70 | int accessPortNumber # Number of available access port. 71 | int accessPort # Select access port controller. 72 | debugConnectMode connectionMode # Select the debug CONNECT mode #debugConnectMode. 73 | debugResetMode resetMode # Select the debug RESET mode #debugResetMode. 74 | int isOldFirmware # Check Old ST-LINK firmware version. 75 | frequencies freq # Supported frequencies #frequencies. 76 | int frequency # Select specific frequency. 77 | int isBridge # Indicates if it's Bridge device or not. 78 | int shared # Select connection type, if it's shared, use ST-LINK Server. 79 | char board[100] # board Name 80 | int DBG_Sleep 81 | 82 | # define C typedefs for 3 callback functions. 83 | ctypedef void (*PCCbInitProgressBar)() 84 | ctypedef void (*PCCbLogMessage)(int msgType, const wchar_t* str) 85 | ctypedef void (*PCCbLoadBar)(int x, int n) 86 | 87 | cdef struct displayCallBacks: 88 | PCCbInitProgressBar initProgressBar # Add a progress bar. 89 | PCCbLogMessage logMessage # Display internal messages according to verbosity level. 90 | PCCbLoadBar loadBar # Display the loading of read/write process. 91 | 92 | cdef struct generalInf: 93 | unsigned short deviceId; # Device ID. 94 | int flashSize; # Flash memory size. 95 | int bootloaderVersion; # Bootloader version 96 | char type[4]; # Device MCU or MPU. 97 | char cpu[20]; # Cortex CPU. 98 | char name[100]; # Device name. 99 | char series[100]; # Device serie. 100 | char description[150]; # Take notice. 101 | char revisionId[100]; # Revision ID. 102 | char board[100]; # Board Rpn. 103 | 104 | int api_checkDeviceConnection "checkDeviceConnection" () 105 | int api_getStLinkList "getStLinkList" (debugConnectParameters** stLinkList, int shared) 106 | int api_connectStLink "connectStLink" (debugConnectParameters debugParameters) 107 | int api_readMemory "readMemory" (unsigned int address, unsigned char** data, unsigned int byte_qty) 108 | int api_writeMemory "writeMemory" (unsigned int address, char* data, unsigned int byte_qty) 109 | void api_disconnect "disconnect" () 110 | generalInf * api_getDeviceGeneralInf "getDeviceGeneralInf" () 111 | int api_downloadFile "downloadFile" (const wchar_t* filePath, unsigned int address, unsigned int skipErase, unsigned int verify, const wchar_t* binPath) 112 | int api_execute "execute" (unsigned int address) 113 | int api_reset "reset" (debugResetMode rstMode) 114 | 115 | void api_setDisplayCallbacks "setDisplayCallbacks" (displayCallBacks c) 116 | void api_setLoadersPath "setLoadersPath" (const char* path) 117 | 118 | 119 | cdef class CubeProgrammer_API: 120 | cdef int c_stlink_connected 121 | cdef int c_device_connected 122 | py_stlink_list: [] 123 | 124 | @property 125 | def stlink_list(self): 126 | return self.py_stlink_list 127 | 128 | @property 129 | def stlink_connected(self): 130 | return self.c_stlink_connected != 0 131 | 132 | @property 133 | def device_connected(self): 134 | return self.c_device_connected != 0 135 | 136 | def __init__(self): 137 | cdef const char* path = "./" 138 | api_setLoadersPath(path) 139 | 140 | global display_cb_struct 141 | api_setDisplayCallbacks(display_cb_struct) 142 | 143 | self.c_stlink_connected = False 144 | self.c_device_connected = False 145 | self.py_stlink_list = None 146 | 147 | def setDisplayCallbacks(self, initProgressBar, logMessage, loadBar): 148 | global py_cb_InitProgressBar, py_cb_LogMessage, py_cb_LoadBar 149 | 150 | py_cb_InitProgressBar = initProgressBar 151 | py_cb_LogMessage = logMessage 152 | py_cb_LoadBar = loadBar 153 | 154 | def setLoadersPath(self, path): 155 | str = f'setLoadersPath({path})' 156 | c_cb_LogMessage(4, PyUnicode_AsWideCharString(str, NULL)) 157 | cdef bytes x = path.encode() 158 | api_setLoadersPath(x) 159 | 160 | def checkDeviceConnection(self): 161 | return api_checkDeviceConnection() 162 | 163 | def getStLinkList(self): 164 | global stLinkList 165 | stLinkListLen = api_getStLinkList(&stLinkList, 0) 166 | self.py_stlink_list = [stLinkList[i] for i in range(stLinkListLen)] 167 | return self.py_stlink_list 168 | 169 | def connectStLink(self, int index=0) -> int : 170 | if index >= len(self.py_stlink_list): 171 | return -1 172 | # print(stLinkList[index]) 173 | if 0 == stLinkList[index].accessPortNumber: # assume this is an indication that the ST-Link is disconnected from the target. 174 | return -1 175 | cdef int err = api_connectStLink(stLinkList[index]) 176 | # print(f'connectStLink: {err}') 177 | return err 178 | 179 | def readMemory(self, unsigned int address, unsigned int byte_qty) -> bytearray: 180 | cdef unsigned char * data 181 | cdef int err = api_readMemory(address, &data, byte_qty) 182 | if err: 183 | return None 184 | bytes = bytearray() 185 | for i in range(byte_qty): 186 | bytes.append(data[i]) 187 | return bytes 188 | 189 | def disconnect(self): 190 | api_disconnect() 191 | 192 | def getDeviceGeneralInf(self): 193 | cdef generalInf * p_general_inf = 0 194 | p_general_inf = api_getDeviceGeneralInf() 195 | return p_general_inf[0] 196 | 197 | def downloadFile(self, filePath, unsigned int address=0x08000000, unsigned int skipErase=0, unsigned int verify=1, binPath=''): 198 | cdef wchar_t* wfilePath = PyUnicode_AsWideCharString(filePath, NULL) 199 | cdef wchar_t* wbinPath = PyUnicode_AsWideCharString(binPath, NULL) 200 | # print(f'downloadFile, filePath: {filePath}, address: {address}, skipErase: {skipErase}, verify: {verify}') 201 | return api_downloadFile(wfilePath, address, skipErase, verify, wbinPath) 202 | 203 | def reset(self, debugResetMode rstMode): 204 | return api_reset(rstMode) 205 | 206 | def execute(self, unsigned int address=0x08000000): 207 | return api_execute(address) 208 | 209 | def set_default_log_message_verbosity(self, val): 210 | global default_log_message_verbosity 211 | default_log_message_verbosity = val 212 | 213 | ''' 214 | Check connection, USB and SWD, to microcontroller. 215 | Updates device_connected and stlink_connected 216 | ''' 217 | def connection_update(self): 218 | 219 | self.c_device_connected = 1 == self.checkDeviceConnection() 220 | 221 | if not self.c_device_connected: 222 | self.disconnect() 223 | self.py_stlink_list = None 224 | self.c_stlink_connected = False 225 | 226 | if self.py_stlink_list is None: 227 | self.getStLinkList() 228 | self.c_stlink_connected = len(self.py_stlink_list) > 0 229 | 230 | if len(self.py_stlink_list) == 1 and not self.c_device_connected: 231 | self.connectStLink() 232 | 233 | self.c_device_connected = 1 == self.checkDeviceConnection() 234 | 235 | def read_u8(self, adr_arg): 236 | cdef unsigned char * bytes 237 | cdef int err = api_readMemory(adr_arg, &bytes, 1) 238 | return None if err else int(bytes[0]) 239 | 240 | def read_u16(self, adr_arg): 241 | cdef unsigned char * bytes 242 | cdef int err = api_readMemory(adr_arg, &bytes, 2) 243 | return None if err else int.from_bytes(bytes[0:2], byteorder='little', signed=False) 244 | 245 | def read_u32(self, adr_arg): 246 | cdef unsigned char * bytes 247 | cdef int err = api_readMemory(adr_arg, &bytes, 4) 248 | return None if err else int.from_bytes(bytes[0:4], byteorder='little', signed=False) 249 | 250 | def write_u8(self, adr_arg, val_arg: int): 251 | cdef unsigned char[4] bytes = int.to_bytes(val_arg, length=4, byteorder='little', signed=False) 252 | # cast required because writeMemory takes a char which is inconsistent with readMemory that takes unsigned char. 253 | cdef int err = api_writeMemory(adr_arg, &bytes[0], 1) 254 | 255 | def write_u16(self, adr_arg, val_arg: int): 256 | cdef unsigned char[4] bytes = int.to_bytes(val_arg, length=4, byteorder='little', signed=False) 257 | # cast required because writeMemory takes a char which is inconsistent with readMemory that takes unsigned char. 258 | cdef int err = api_writeMemory(adr_arg, &bytes[0], 2) 259 | 260 | def write_u32(self, adr_arg, val_arg): 261 | cdef unsigned char[4] bytes = int.to_bytes(val_arg, length=4, byteorder='little', signed=False) 262 | cdef int err = api_writeMemory(adr_arg, &bytes[0], 4) 263 | 264 | def read_str(self, adr_arg, char_qty): 265 | cdef unsigned char * bytes 266 | cdef int err = api_readMemory(adr_arg, &bytes, char_qty) 267 | return None if err else bytes.decode('iso-8859-1') # 'utf-8') 268 | 269 | def read_f32(self, adr_arg): 270 | """ 271 | Read float, single-precision, 4-bytes. 272 | """ 273 | cdef unsigned char * bytes 274 | cdef int err = api_readMemory(adr_arg, &bytes, 4) 275 | return None if err else struct.unpack('py_cb_InitProgressBar)() 283 | else: 284 | str = f'InitProgressBar' 285 | size = len(str) 286 | c_cb_LogMessage(4, PyUnicode_AsWideCharString(str, &size)) 287 | 288 | # C variant of LogMessage will call the Python variant if it's been set. 289 | @staticmethod 290 | cdef void c_cb_LogMessage(int msgType, const wchar_t* str): 291 | s =

File	Description 28 \| *
CubeProgrammer_API.h	header file contains functions declarations and macro definitions to be used by the CubeProgrammer_API.dll. 29 \| *
DeviceDataStructure.h	header file contains macro definitions to be shared between several functions. 30 \| *
CubeProgrammer_API.dll/.so/.dylib	Dynamic Link Library file contains a library of functions and other informations that can be accessed by windows, linux and MacOs programs. 31 \| *
CubeProgrammer_API.lib	import library for use with MSVC compiler. 32 \| *

CubeProgrammer_API.dll	FileManager.dll	STLinkUSBDriver.dll 65 \| *
HSM_P11_Lib.dll	libeay32.dll	libgcc_s_dw2-1.dll 66 \| *
stlibp11_SAM.dll	libstdc++-6.dll	libwinpthread-1.dll 67 \| *
mfc120.dll	msvcp120.dll	msvcr120.dll 68 \| *
Qt5Core.dll	Qt5SerialPort.dll	Qt5Xml.dll 69 \| *

libCubeProgrammer_API.so	libCubeProgrammer_API.so.1	libSTLinkUSBDriver.so	libFileManager.so.1 82 \| *
libhsmp11.so	libQt5SerialPort.so.5	libQtXml.so.5	libQt5Core.so.5 83 \| *
libicudata.so.56	libicui18n.so.56	libicuuc.so.56	- 84 \| *

libCubeProgrammer_API.dylib	libCubeProgrammer_API.1.dylib	libCubeProgrammer_API.1.0.dylib	libCubeProgrammer_API.1.0.0.dylib 92 \| *
libFileManager.dylib	libFileManager.1.dylib	libFileManager.1.0.dylib	libFileManager.1.0.0.dylib 93 \| *
libSTLinkUSBDriver.dylib	libhsmp11.dylib	libstP11_SAM.dylib	libusb-1.0.0.dylib 94 \| *
QtSerialPort.framework	QtXml.framework	QtCore.framework	- 95 \| *