Видео

This lesson #13 uses the standard startup code generated by KEIL uVision. To get this code, you need to open the provided project in KEIL uVision. The act of opening the project will cause the generation of additional directories in your project folder. Among others, you will get the RTE folder (Run-Time Environment). Inside this directory, you need to go to RTE\Device\STM32C031C6Tx. Deep inside there, KEIL has generated the startup file startup_stm32c031xx.s, which is in assembly (not in C), but you can study this file. In the subsequent lessons (#14 and higher), you will use the customized startup code written in C. Please watch the subsequent lessons. --MMS

@@StateMachineCOM Thank you for the quick reply.

Your experience is very common during the transition from sequential (the "intuitive" way) to event-driven ("backward!"). I assure you that the transition *is* worth it. Regarding the repetitions in the state machine, they reflect the nature of the problem. It's not like your sequential problem is not repetitious (just at it!) But the traditional "flat" state machines have also another class of repetitions, which can be eliminated by using *hierarchical* state machines. This course has several lessons about all sorts of state machines. Here is the playlist: ruclips.net/p/PLPW8O6W-1chxym7TgIPV9k5E8YJtSBToI

You're approaching it wrong. The most important fact to remember is that "in embedded programming, nothing works until everything works" ( I discuss this in the video ruclips.net/video/kcpHuuEt1xs/видео.htmlsi=NuerVMfiTBsExGxg ). Therefore, if your system doesn't work, you cannot make it work by tweaking it aimlessly. Even less chance has an outsider, like me, to diagnose your problems. Instead, you should take advantage of something that already works (the provided project). Then, you can *compare* it to your version and the differences will show you the problem. A good free differencing tool is essential. I use the free WinMerge tool (google for it). Please note that you *can* compare the uVision project files also (they are in XML). In the end, the purpose of this course is not to give you a fish, but to teach you how to fish. I hope you see my point. --MMS

@@StateMachineCOM thank you for the inputs. I was essentially doing the comparison between my file and the course download manually (comparing 2 windows) - didn't know something like winMerge exists, it's a game changer!

If you wish to follow this course exactly as it was presented, TivaC LaunchPad is nice to have. However, the newer NUCLEO-C031C6 board should also be sufficient for this course. Regarding the schematics, a simplified version is available in the document "STM32 NUCLEO-C031C6 Board" available on the companion website: www.state-machine.com/video-course#STM32C031 . Also, the projects for the NUCLEO-C031C6 are available (such as for this lesson-04) so, you should be able to build and run them on your board: www.state-machine.com/course/lesson-04.zip . --MMS

IAR Systems had been offering the free, size-limited "KickStart" version of their IAR toolset for decades. Only recently, the management of the company has changed and the free licensing of any kind has disappeared. Things were different when this video course was starting, but frankly, I don't blame IAR. There is just too much piracy and disregard for licensing. Everybody suffers because of this: both vendors and developers. --MMS

Yes, the course uses embedded C. Just watch it. Here is the playlist: ruclips.net/p/PLPW8O6W-1chwyTzI3BHwBLbGQoPFxPAPM

@@StateMachineCOM Thank you sir As an embedded beginner this really helps me alot

The companion web-page to this video course has troubleshooting instructions for that. Please see www.state-machine.com/course/AN_Troubleshooting_TivaC.pdf --MMS

@@StateMachineCOM I'm also trying to find that under debug options and its not showing up even tho I tried several times. what exactly to troubleshoot?

@@Mion446 After you download the "TivaC Troubleshooting Guide", you need to actually open it :-) When you do, you will find in it Section 2 "Keil uVision Doesn't Support Stellaris ICDI". Please read it, download the "MDK_Stellaris_ICDI_AddOn.exe" software, and install it. --MMS

@@StateMachineCOM thanks, its just, I've downloaded that software and installed it at least 6 times, and the debug tab just doesnt have the stellaris option

Definitely, more information and videos are needed to explain the components and various real-time kernels for the QP framework. But just quickly: qep is useful if you want just the passive hierarchical state machines, qf adds active objects, qs is the software tracing system. The real-time kernels are as follows: qv is a simple non-preemptive kernel, qk is the preemptive non-blocking kernel (very efficient and fast!), qxk is a dual-mode kernel (with both non-blocking and blocking tasks). Finally, regarding FreeRTOS and CubeMX, it seems that ST is now much more invested in ThreadX. But perhaps a short video on integration with FreeRTOS won't hurt. --MMS

@@StateMachineCOM thank you for replay and for all your lessons

It's a known fact of life that "in embedded systems, nothing works until everything works." Therefore you must always start with a *working* project (the project provided in the downloads) and then gradually change it making sure that it keeps working every step of the way. You should also keep backup copies of the previous working versions so that you can always revert to a working version. I've devoted the whole lesson ruclips.net/video/kcpHuuEt1xs/видео.htmlsi=Blz2UPWMPZPh51ig to this process. I hope that my comments make sense to you. --MMS

It seems we have a similar issue with getting our project to work with the Keil debugger. See my comment for details, but the fix for me was setting CLOCK_SETUP macro to 0 in the system_TM4C123.c file (it's set to 1 by default). As pointed out by Miro, using WinMerge helps a ton. Good luck!

​@@StateMachineCOM

@@StateMachineCOM I'll be sure to follow your recommendation. I have watched your linked video and it's quite deep... need some time to re-watch and digest. I understand what you mean anyway. Thanks!

@@justinushartoyo2370 Thanks for reaching out. I tried it and it worked. Do I have to modify the system_TM4C123.c file for every program or have you found a way to change it once and for all?

The IAR licensing has changed since the first lessons of this course were made (back in 2013). AFAK, the free IAR "KickStart" version is no longer available. Therefore, this course also offers projects for the KEIL uVision IDE, which I would recommend at this point. --MMS

@@StateMachineCOM Thanks Miro for your quick reply. I will go with keil. thanks for the valuable course.

Thanks Miro, for your quick response. After getting into Keil MDK, I'm stuck at the simulation ICDI part. I got the licence with the User-Based License option.

The memory map (the .map "map file") is generated by the linker in the dbg directory of the project. For example, most projects are called "project", so the map file will be called "project.map". --MMS

@@StateMachineCOM Thank you, but I mean more like where we would find the memory addresses to let's say the GPIOA MODER register or other registers.

@@user-tw9oi7od9k The description of STM32C031 peripherals can be found in the "Reference Manual", which is available for download from the companion page to this video course at: www.state-machine.com/video-course#STM32C031

@@StateMachineCOM Thank you so much

Absolutely you can! Only not for this course.

Yes, I realize that the management of mutable events with parameters hasn't been explained in this presentation. And yes, you are right that this is very important and indeed, the most valuable feature of the QP framework. You can find more information about it here: www.state-machine.com/qpc/srs-qp_emm.html and www.state-machine.com/qpc/sas-qp_emm.html

​@@StateMachineCOM It would be great to see a video or have github repo where freeact and qp framework would be in the same project example. (or freeact lib could be extended) I see in your other video that for mutable object you control led blink frequency creating event parameters with q_new function.

At this point, FreeACT is a "minimal active object framework" that demonstrates the main principles of implementing the event-driven paradigm with a traditional RTOS. The FreeACT project ( github.com/QuantumLeaps/FreeACT ) could become more complete (e.g., by providing true management of mutable events), but this requires work. The project is licensed under the permissive MIT license (the same as the FreeRTOS kernel), but so far there have been no community contributions. In contrast, QP/C framework ( github.com/QuantumLeaps/qpc ) is a mature and full-featured active object framework that can work with many RTOS kernels (among others with FreeRTOS). QP is dually-licensed under the restrictive GPL license and commercial licenses. This different licensing model prevents combining QP and FreeACT in the same repository. --MMS

@@StateMachineCOM I will definitely check complete framework, thx

Maybe you can skip forward and watch a lesson that uses KEIL rVision? The first lesson to do so is lesson #21 "Foreground/Background Architecture" ruclips.net/video/AoLLKbvEY8Q/видео.htmlsi=MzaGjGY9y6j3DlSp

Yes, the preemptive, non-blocking QK kernel (see www.state-machine.com/qpc/srs-qp_qk.html ) briefly disables interrupts to protect its internal variables. But, QK also supports "kernel unaware" interrupts that are never disabled (see www.state-machine.com/qpc/arm-cm.html ). --MMS

Found it in the video #19, we can use __enable_irq(); Thanks for moving the course to GNU!

In GNU-ARM you can use __disable_irq()/__enable_irq() (see also stm32f4-discovery.net/2015/06/how-to-properly-enabledisable-interrupts-in-arm-cortex-m/ ) --MMS

This behavior of the KEIL uVision debugger is most likely caused by stepping one C-instruction at a time, whereas you apparently wish to step one assembly-instruction at a time. To do this, please click on the disassembly window first, and then single-step. I think that the F11 shortcut should work for this, but you might also try to click on the single-step button in the toolbar. --MMS

Your B instruction starts with 11100, so it uses the T2 encoding (see 5:05), so the immediate offset is 11-bit 0x7F7. But you're right that after sign-extending from 11 bits, it is -9. So, now 0x4DC - 9 == 0x4D3 -> 0x4D2 (after discarding the LS-Bit). But I think that this must be further corrected for the pipelining effect 0x4D2 - 4 == 0x4CE. --MMS

Please check your debugger settings. For the TivaC board, you should have the "Stellaris ICDI" debugger. For the STM32 NUCLEO board, you should have ST-LINK. --MMS

@@StateMachineCOM I have STM32F446RE MCU NUCLEO-F446RE board. When I change the debugger option to ST-link I get the error , failed to load flash loader. Do I have the wrong board or are my setting wrong? I am sorry if I am acting stupid but this is my first time trying to use this board

The NASA rules you're mentioning are known as "The Power of 10: Rules for Developing Safety-Critical Code" (interested people should google this up). The rules restrict recursion and recommend explicit loop bounds. They also recommend using assertions, and not just using them but reaching the right assertion *density*. I talk about assertions in the later lessons #47 (ruclips.net/video/cnEhFwo4u5g/видео.htmlsi=TQIG_igL9tZ8W9Yc ) and #48 (ruclips.net/video/yHBmzQQVVas/видео.htmlsi=UP2V2PtKCoynyHxE ). --MMS

@@StateMachineCOM Wow, thanks for the information. I'll go check them out!

Good observation, but it's perhaps worth pointing out that the TivaC GPIO design goes beyond bit-banding. In the traditional bit-banding each bit has its own unique address. In the TivaC GPIO each bit *combination* has its own unique address. --MMS

@@StateMachineCOM Great thanks for the information. Now I see this design is by Tiva-C. Your lectures are very helpful.

The LM4 microcontrollers have been renamed to TivaC. Please also see the other comments to this video, where some 100 of them are about this issue. Finally, please visit the companion web-page to this video at: www.state-machine.com/quickstart

The QP frameworks (QP/C and QP/C++) support both direct event posting and pub-sub. Regarding the runtime environment, QP frameworks can work with a variety of different kernels. I will make a video about the buit-in kernels. But QP have been also ported to traditional RTOSs, and also Linux and Windows.

The QP framework is a lightweight implementation of the Active Object design pattern (aka Actor model). Additionally, QP provides support for hierarchical state machines to implement the event driven behavior of the AOs.

@@StateMachineCOM Are the HSMs enabling a synchronization protocol for the AOs?

@@damiengates7581 The HSM in every AO is a general mechanism to specify the behavior of the AO. But among others, you can use HSMs to synchronize the behavior of multiple AOs to a given "protocol".