This important statement empties the round robin task loop before building the task. Is executed before building and activating the task in the Setup_Task function in the example listing. The task is left ASLEEP meaning that the multitasking executive will not run the task yet that must wait until the task is activated. Note that while the initial values of user variables are derived from the parent task, the new task may modify its user variables at any time. With the exception of the user variables that set the memory map as discussed above, the initial values written into the Counter_Task user area are copied from the parent task (i.e., the task that is active when Counter_Task is built), which in this case is the default task that is running main. If the task does not need a private heap, the first two parameters passed to BUILD_C_TASK can be 0, as in this example. Multiple tasks should not share a common heap this can lead to difficult-to-diagnose multitasking failures. BUILD_C_TASK expects a heap specification (start and end 32-bit xaddresses). The programmer specifies where the heap resides. The task is appended to the round-robin task list and left ASLEEP running the default action routine Halt(). In the unlikely event that a task activation routine is not an infinite loop, then when it terminates the task will automatically execute the Halt() function which stops execution of the task, puts the task asleep, and calls Pause() to transfer control to an active task. In a more complex application with a variety of data structures, it is often convenient for each task activation routine to initialize its own task's variables and data structures before entering the infinite loop. This is an example of using Pause() to make the processor time allocation more efficient. Placing the Pause() function in the inner loop passes control to the next task after the variable is incremented, granting other tasks a higher percentage of the processor's time. It increments the counter variable up to the maximum specified value of 30,000, then rolls over to zero and continues incrementing. In the demonstration program, the Count_Forever() function is the task activation routine. The task activation routine is an infinite loop that is executed by a task. The next key you type wakes up 141: // the Counter_Task and resumes incrementing the counter. 139: // To put the Counter_Task asleep so that the counter is no longer incremented, 140: // type any key. 137: // In addition to the Counter_Task, the default task running 138: // main (and thus Main_Loop) is running. Type at the terminal 135: // main 136: // This starts the program running.
#How to write c code for rm scheduling how to#
(download) 1: // Mosaic Industries multitasking demo program 2: 3: #include 4: 5: #define MAX_COUNTER 30000 // used by Inc_Counter() 6: #define TWO_SECONDS 2000 // measured in milliseconds, default print interval 7: 8: static uint counter = 0 9: 10: 11: 12: void Inc_Counter ( void ) 13: 131: 132: // How to use this program: 133: // Compile the program and send the resulting *.dlf file to the board 134: // using the Mosaic terminal.
The multitasker switches between this task and another task (the main task running in the default task area) that periodically prints the value of counter to the Mosaic terminal, and accepts user keystrokes to wake up or put asleep the task that increments the counter. This example defines a task whose action program continually increments a variable named counter. The advantage of this standard approach is that the default task area, which has generous allocations of RAM for stacks, is used to run a task, rather than running the Forth monitor task which is not typically useful in a standard C program.Ī multitasking example is explained in detail below. Using the standard approach, the Forth monitor task is not active at runtime. The standard approach to coding a multitasking application is to make the main function itself an infinite loop that performs the actions of one of the required tasks, and then build and activate additional tasks to implement different functions required by the application. This configures the task to execute a specified action program and leaves the task awake so that it will be entered by the mulitasker on the next pass around the round robin task loop.
0 kommentar(er)
