Hi and thanks for your interest!
First, you need a patched version of the Axoloti firmware which adds support for the P6, mainly when it comes to differing clock crystal rates, UART assignment, and the different DAC used in the P6, but also removes support for things like the ADC since the STM32 analog inputs are not used in the P6.
The firmware is available in my Github repository, at github.com/polluxsynth/axoloti, on the p6 branch. Basically, you check out that branch (which is just a fork of the official Axoloti firmware), and build just as you would the standard Axoloti firmware.
To flash the P6, first start the Axoloti UI as usual, connect it to the P6 using a USB cable, and then set the P6 to DFU boot mode by holding the BOOT button inside the P6 and switching it on. Go into the Board -> Firmware -> Flash (rescue) menu in the Axoloti UI to flash the P6; the progress will be indicated in the main Axoloti log window. (For some reason which I haven't been able to figure out, upgrading to a newer version must be done in the same way, rather than use Board -> Firmware -> Flash .)
After that, it basically works the same as with the standard Axoloti, taking into consideration the limitations of the P6 hardware. MIDI input and output, also over USB, works directly in the platform, using the corresponding Axoloti objects. The LCD and other user interface elements require the special objects described above to access them. There's no audio input of course, since the P6 has no ADC, and there is no SD card, and no DRAM. So objects which use these elements won't work. Apart from the, there's the same DSP and RAM capacity as on the Axoloti hardware. In particular, the Patch -> Upload to internal flash function works, which is really nice on a box with its own user interface.
I just uploaded my test patch, patches/ricard/p6/p6test.axp which basically implements a complete P6 UI, with three embedded objects implementing user interface menus, parameter management, and a state machine for menu navigation. There's also an object which implements rudimentary patch storage in the P6 on-board 24C512 EEPROM. Mind you, these are patches in the UI sense of the embedded objects in the patch, not storage of true Axoloti patches. The reason for this is that my end goal was to implement a synth where only a subset parameters are user controllable, in order to make the user interface more managable, as on any pre-configured synth (such as the P6).
In order for the UI to have something to control, there's a very rudimentary synth implemented as a subpatch, a far cry from a real P6, basically just something to test the user interface on.
Just to be clear, neither the p6 branch of the firmware nor the p6test patch can load original P6 patches or anything, I'm just aiming for something with the same look and feel, as I really like the P6 UI approach.
I haven't done a lot of work on this lately, partly because I'm not fully convinced like things like the LCD and encoder control should be patcher objects, because I feel the Axoloti patcher environment is not ideal for things like state machines and things that are triggered from user buttons, as opposed to DSP code which does something useful all the time, The EEPROM support for instance is implemented partly in the firmware on the p6 branch, and then has a (currently embedded) object for the actual patcher interface, and a similar approach might be more viable for the LCD for instance. At the same time, the current approach means that the objects can be used for other, custom, hardware as well, which is a plus from a community perspective.