A Brief Discussion on the Application Program Architecture of Single Chip Microcomputer

       After some exploration and experimentation, I concluded that there are three general application architectures:

1. Simple foreground and background sequential execution of the program. This type of writing is the method used by most people. There is no need to think about the specific architecture of the program. You can directly write the application program through the execution sequence.

2. Time slice polling method, this method is between sequential execution and operating system.

3. Operating system, this method should be the highest level of application programming.

Let’s talk about the advantages, disadvantages and application scope of these three methods respectively. . . . . . . . . . . . .

1. Sequential execution method:

      This method is a good method when the application is relatively simple and the real-time and parallel requirements are not too high. The program design is simple and the ideas are relatively clear. However, when the application is more complex, if there is no complete flowchart, it may be difficult for others to understand the running status of the program. Moreover, as the program functions increase, the brains of the engineers who write the application programs also begin to be confused. This is not conducive to upgrade maintenance, nor is it conducive to code optimization. I wrote a few more complex applications and used this method at the beginning. Although I was able to realize the functions in the end, my thinking was always in a state of confusion. As a result, the program has never satisfied me.

      This method is adopted by most people, and the education we receive is basically based on this method. For us MCU engineers who have basically not learned data structure and program architecture, it is undoubtedly difficult to make a big improvement in application design, which also makes it difficult for applications written by different engineers to benefit and learn from each other.

      I suggest that if you like to use this method, if you want to write a more complex application, you must first clear your mind and design a complete flowchart before writing the program, otherwise the consequences will be serious. Of course, if the program itself is very simple, this method is still a very necessary choice.

Let's write a sequential execution program model to compare it with the following two methods:

Code:

3. Add in the timer interrupt service function:

Code explanation: The timer interrupt service function judges one by one in the interrupt. If the timer value is 0, it means that the timer is not used or the timer has completed the timing and no processing is required. Otherwise, the timer is reduced by one. When it reaches zero, the corresponding flag value is 1, indicating that the timer value of this task has expired.

4. In our application, add the following code where the application timing is required. Let’s take Task 1 as an example:

TaskCount[0] = 20;        // Delay 20ms

TaskMark[0]   = 0x00;     // Start the timer for this task

At this point, we only need to determine whether TaskMark[0] is 0x01 in the task  . Add other tasks in the same way, and the multiplexing problem of a timer has been solved. Friends who need it can try it, the effect is good. . . . . . . . . . . . .

Through the above multiplexing of a timer, we can see that while waiting for a timing to arrive, we can loop to judge the flag bit and execute other functions at the same time.

Loop judgment flag:

So we can think about it, if the loop judges the flag bit, is it the same as the sequential execution program introduced above? A large loop, but this delay is more accurate than the ordinary for loop, and can achieve precise delay.

Execute other functions:

So if we execute other functions when a function is delayed, making full use of CPU time, isn't it similar to the operating system? However, the task management and switching of the operating system is very complicated. Next, we will use this method to build a new application.

The architecture of the time slice polling method:

1. Design a structure:

The design of this structure is very important. It uses 4 parameters and the comments are very detailed, so I will not describe it here.

2. The task running mark is displayed. This function is equivalent to the interrupt service function. This function needs to be called in the interrupt service function of the timer. It is separated here for easy transplantation and understanding.

Please compare this function carefully to see if it is the same as the timed multiplexing function above.

3. Task processing

This function is used to determine when to execute a task and implement task management operations. The user only needs to call this function in the main() function and does not need to call and process task functions separately.

At this point, the architecture of a time-slice polling application has been built. Do you think it is very simple? This architecture only requires two functions and a structure. For application purposes, an enumeration variable will be created below.

Now I will talk about how to apply it. Suppose we have three tasks: clock display, key scanning, and working status display.

1. Define a structure variable like the one defined above

When defining variables, we have initialized the values. The initialization of these values ​​is very important and is related to the specific execution time priority, etc. You need to master this yourself.

① The general meaning is that we have three tasks, and the following clock display is executed every 1s. Because the minimum unit of our clock is 1s, it is enough to display it once after the second changes.

② Since the key will jitter when it is pressed, and we know that the jitter of a general key is about 20ms, then we usually extend it by 20ms in the sequential execution function. Here we scan once every 20ms, which is a very good result. It achieves the purpose of de-jittering and will not miss the key input.

③ In order to display other prompts and work interfaces after pressing the key, we design it to display once every 30ms. If you think the response is slow, you can make these values ​​smaller. The names behind are the corresponding function names. You must write these functions and the same three tasks in the application.

2. Task List

Take a closer look. The purpose of defining this task list here is actually the value of the parameter TASKS_MAX. Other values ​​have no specific meaning and are only for the purpose of clearly showing the relationship between the surface tasks.

3. Write task functions

Now you can write tasks according to your needs.

4. Main function

At this point, the architecture of our time slice polling application is complete. You only need to add your own task function where we prompt. Isn't it very simple? Does it have a bit of operating system feeling in it?

      Why not try it and see if the tasks do not interfere with each other? What about running in parallel? Of course, it is also important to note that when transferring data between tasks, global variables need to be used. In addition, it is also necessary to pay attention to the division of tasks and the execution time of tasks. When writing tasks, try to complete the tasks as soon as possible. . . . . . . . . .

3. Operating System

      The operating system itself is a relatively complex thing. We don't need to understand the management and execution of tasks. However, transplantation alone is very difficult. Although some people say "If you have used the system, you will not use the foreground and background programs again", there are not many people who can really use the operating system, not only because the use of the system itself is very complicated, but also because you need to buy a license (UCOS is no exception if it is used commercially).

      I don't want to introduce the operating system itself in detail here, because it cannot be explained in just one or two sentences. The following is a model for writing applications under UCOS. You can compare the advantages and disadvantages of these three methods.

It is not difficult to see that the time slice polling method has great advantages, that is, it has the advantages of the sequential execution method and the operating system. The structure is clear, simple, and very easy to understand. . . . . . . . . .