FAQs
cancel
Turn on suggestions
Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.
Showing results for 
Search instead for 
Did you mean: 

Learning Path suggestion

Lucky_Dev
Associate II

‎2025-08-25 12:55 AM - edited ‎2025-09-18 4:43 AM

Hello everyone, I'm currently exploring the STM32MP257F-DK. 

As recommended in the "MOOC - STM32MP2 demo workshop", I'm diving deep into the wiki. I have also watched the "MOOC - STM32MP1 workshop". Of course, I have reviewed the getting started guide before doing anything. However, I want to know how this amazing community tackles the challenges of developing a new application on this platform. Do you recommend any specific development flow (Start with the examples, port STM32MP1 lab examples to the new platform, start with the template, use STMCubeMX and generate a new device tree, etc.)? Is there any tutorial that helped you a lot?   

I will also try to update the post with any resources I highlight. 

Thank you in advance. 

Note: I'm new to this community, if this post is not what should be here let me know. Of course, any feedback is well received. 

---

ROUDMAP [LIVE]

For anyone interested, I'm following the current roadmap:

 A good first start but not the best. Therefore, I jumped to the STM32MP wiki.

At the point of finishing the guide, I had the Developer Package (Yocto-based) installed. Thus, I have a basic development environment for developing applications for the Arm Cortex A-35 and Arm Cortex M-33. (If I have understood everything well). The following logic step was expanding the available examples that come with the Starter Package. Thus, I deepened into the STM32CubeMP2 Package.

This guide highlights the different components for developing firmware for the Arm Cortex-M33. However, the resources provided couldn't satisfactorily be used without developing an overview of the software packages in which it integrates. For this reason, I continue exploring the STM32MPU Embedded Software Packages available (Starter, Developer and Distribution). 

NOTE: I put the focus of my research on the Yocto-based OpenSTLinux embedded software.  For understanding this decision, I recommend reading the book "Mastering Embedded Linux Development" from Packt, one of the recommended learning resources of Bootlin course.  

This wiki entry explained to me the typical use cases of every Embedded Software Package. Therefore, I continue to work on the Developer Package. Furthermore, I highlight the "Example of production cycle for the Yocto-based OpenSTLinux embedded software" section which gives me the necessary context to understand the Package and their role. Once the concepts are understood, I return to the question of how developing an application.  

  • Template from the STM32CubeMP2 Package [File]

Reviewing the material provided by the STM32CubeMP2 Package I came up with the Template example. I build the example and load it into the board (giving me the expected results - An amazing blinking orange led). However, I was working on the files presented on the repository I had downloaded with STMCubeIDE. Thus, I try to copy the folder and then open the project in my STMCubeIDE workspace. As expected, and warned by a few, the building process was not straightforward, but it gave me the opportunity to learn to modify the relative paths and the Makefile, all using the STMCubeIDE (the Makefile is created in every building, so you need to change project parameters). With the template build and load, I tried to modify I few parameters, as the blinking led. With the schematics in front of me I identify the green led as my next victim. However, I faced the cold truth that the platform is a little bit more complex (failing in my try), so I jumped to the following wiki entry.

In this wiki entry I could identify the problem. The other LEDs are assigned to other usages, and something (I think context assignment and RIF) is preventing me from using it through the coprocessor. At this point, I understood that I needed a little more guidance, thus I explored the Training Zone (because I was a little bit overwhelmed by the wiki). 

NOTE: You could also check the User Manual of the board. Based on what I read I proposed developing a simple project which consists of reassign the LD8 to the Arm Cortex-M33 (acting as a coprocessor). This decision was taken to set the scope of the research and focus it.

Despite not being listed in the STM32MOOC, it helps me refresh what I had learned from the Getting started guide and gave me more context from the platform I was using and the development flow. It also indicates to me that the changes from the previous version (STM32MP1) in the development flow are not big (If I understood well). Therefore, I jumped to the following MOOC.

From this MOOC I highlight the very helpful labs and lectures previously the labs. The most important thing was understanding the boot chain, how the assignment of peripherals works, etc. 

Despite the MOOC provide useful information, I notice I couldn't translate the labs to the STM32MP257F-DK as easy as I expected. Thus, I checked how I set the Developer Package in the Getting Started guide. From the review I observed that the device tree loaded was not the version I expected. Furthermore, the software that comes with the Developer Package is more complex. In consequence, I checked the corresponding wiki entry. 

The wiki entry consists mainly in a step-by-step guide of how to set up the Developer Package and examples of how to use it. It presents some common points with the Getting Started Guide but with more emphasis in the details. However, I recommend reviewing the "Platform boot" wiki entry in detail to understand all the software components presented. 

With the Developer Package set up, I proceeded to modify the proposed components (TF-A, U-BOOT, OPTEE and Kernel). The most satisfactory part was initializing the LED8 through loading a customized devicetree (without STM32CubeMX). 

From the customization I understood that I need to create a custom device tree and then loaded it to the board. For this purpose, I proposed the following development flow (which I think it is the same as the proposed by STMicroelectronics):

  1. Create devicetree and project structure with STM32CubeMX (in which I assign peripherals to execution contexts)
  2. Modify devicetree (if needed) through STM32CubeIDE.
  3. Load the devicetree (after processing it with the scripts provided in sdk_info folder of the Developer Package) with dd (following what is described in "How to populate the SD card with dd command" wiki entry).
  4. Develop firmware to load to the Arm Cortex-M33 coprocessor or for the Arm Cortex-A35 through STM32CubeIDE. (Development for the Arm Cortex-A35 through STM32CubeIDE could be done as described in "MOOC - STM32MP1 Tips and tricks") 
  • FAQ: STM32MPUs: How to create a device tree adapted to your design with STM32CubeMX [forum entry]

This "Knowledge based" Forum entry descried how to set the device tree and presents additional learning material, which I'm currently reviewing.

Currently reviewing.

Currently reviewing.

---

Note: If you know anything that could help me with the assignment of peripherals, or anything I have forgotten, and I must review, I will be very thankful to any feedback or guidance. 

Moreover, I expect this post will help anyone to learn the usage of the platform.

What do you think about the path I'm following? Did you follow a different path?

0 REPLIES 0
Top