I am relatively new to PlatformIO (have successfully flashed some STM32s with mbed and arduino through the IDE) and some of the internal workings are a bit nebulous to me despite reading a bunch of documentation and searching through github.
I would like to use the excellent Arduino boards defined at GitHub - GrumpyOldPizza/arduino-STM32L4 from within PlatformIO (my goal is to create a PR for those boards for the community). The boards are:
thanks for the pointers. It sounds like you are suggesting to add a new arduino core as well as board definitions for the 4 boards?
If I start modifying those github repos you linked to how do I test my local branches? Check it all out locally and compile myself? Just modify my local install in ~/.platformio and then submit the changes as a diff? How do you work on this?
Well it’s hard to convey multiple years of development experience in a single post; there’s a lot of background knowledge in play here, but let me try anyways by showing how I developed it…
I’m assuming you have completely read the linked documentation and know what a platform, framework, package, board definition etc. is and how e.g. a platform and package is described and configured by its JSON files.
holds all board definitions ( *.json), the platform.json definition (used packages, …) and builders
for now knows two Arduino cores: stm32 (STM32Duino) and maple
which core is built is either set in the "core": "<core>" section of the board JSON or in the platformio.ini with board_build.core = ..
needs modification, since this code must call the correct underlying build script for the new STM32L4 core
fork repo → add new code path for core == stm32l4 (as I did here)
redirects execution for build into the platformio-build.py of the newly created Arduino core package
Understand build logic
first understand how the Arduino IDE uses the platform.txt and boards.txt to built the firmware. (Redirecting and more).
these two criticial files dictate what flags ( -D .. -m .. -f ..) the compiler gets, how all available boards / variants are defined (with their name, configuration options which feed into compiler options, variant-specific source code folder, …) and how the code is uploaded (here: either openocd or dfu)
can also run Arduino IDE in verbose mode to see all compiler invocations if unsure
Replicate board JSON definitions (mostly templated from existing board definition, plus boards.txt, plus what options you need in there accessible from the build script, here e.g. I put hwids, usb_product etc)
Redirect platform to the forked version of ststm32 by pointing it to the new git as shown per docs
Add new Arduino core package. I chose the simpler platform_packages way here to make PIO download and “know” the package. The proper way would be to modify the platform.json. Since PIO 5.0.0 has introduced a new package repository system, and I don’t yet know how to reference my own published packages in there…
As you can see one needs a quite good understanding of PlatformIO internals, terminology and python scripting to integrate it here. Usually the core team adds integration for new cores, platforms etc.
The way I develop is to clone all my forked repos but modify my local files in e.g. C:\Users\.platformio\packages and C:\Users\.platformio\platforms, then copy them back and commit. Only at the last stage I redirect the packages / platforms of the project to the forked sources, remove my previous packages and platforms and see if it correctly uses the redirected packages.