📄 dynamic.s43
字号:
FUNCALL vStartDynamicPriorityTasks, xTaskCreate
LOCFRAME CSTACK, 42, STACK
MOV.W #0x4, R14
MOV.W #0x1, R12
CALL #xQueueCreate
MOV.W R12, &xSuspendedTestQueue
// 149 xTaskCreate( vContinuousIncrementTask, ( signed portCHAR * ) "CNT_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY, &xContinousIncrementHandle );
PUSH.W #xContinousIncrementHandle
CFI CFA SP+4
PUSH.W #0x0
CFI CFA SP+6
PUSH.W #ulCounter
CFI CFA SP+8
PUSH.W #0x80
CFI CFA SP+10
MOV.W #`?<Constant "CNT_INC">`, R14
MOV.W #vContinuousIncrementTask, R12
CALL #xTaskCreate
// 150 xTaskCreate( vLimitedIncrementTask, ( signed portCHAR * ) "LIM_INC", priSTACK_SIZE, ( void * ) &ulCounter, tskIDLE_PRIORITY + 1, &xLimitedIncrementHandle );
PUSH.W #xLimitedIncrementHandle
CFI CFA SP+12
PUSH.W #0x1
CFI CFA SP+14
PUSH.W #ulCounter
CFI CFA SP+16
PUSH.W #0x80
CFI CFA SP+18
MOV.W #`?<Constant "LIM_INC">`, R14
MOV.W #vLimitedIncrementTask, R12
CALL #xTaskCreate
// 151 xTaskCreate( vCounterControlTask, ( signed portCHAR * ) "C_CTRL", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
PUSH.W #0x0
CFI CFA SP+20
PUSH.W #0x0
CFI CFA SP+22
PUSH.W #0x0
CFI CFA SP+24
PUSH.W #0x80
CFI CFA SP+26
MOV.W #`?<Constant "C_CTRL">`, R14
MOV.W #vCounterControlTask, R12
CALL #xTaskCreate
// 152 xTaskCreate( vQueueSendWhenSuspendedTask, ( signed portCHAR * ) "SUSP_TX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
PUSH.W #0x0
CFI CFA SP+28
PUSH.W #0x0
CFI CFA SP+30
PUSH.W #0x0
CFI CFA SP+32
PUSH.W #0x80
CFI CFA SP+34
MOV.W #`?<Constant "SUSP_TX">`, R14
MOV.W #vQueueSendWhenSuspendedTask, R12
CALL #xTaskCreate
// 153 xTaskCreate( vQueueReceiveWhenSuspendedTask, ( signed portCHAR * ) "SUSP_RX", priSTACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
PUSH.W #0x0
CFI CFA SP+36
PUSH.W #0x0
CFI CFA SP+38
PUSH.W #0x0
CFI CFA SP+40
PUSH.W #0x80
CFI CFA SP+42
MOV.W #`?<Constant "SUSP_RX">`, R14
MOV.W #vQueueReceiveWhenSuspendedTask, R12
CALL #xTaskCreate
// 154 }
ADD.W #0x28, SP
CFI CFA SP+2
RET
CFI EndBlock cfiBlock0
// 155 /*-----------------------------------------------------------*/
// 156
// 157 /*
// 158 * Just loops around incrementing the shared variable until the limit has been
// 159 * reached. Once the limit has been reached it suspends itself.
// 160 */
RSEG CODE:CODE:REORDER:NOROOT(1)
// 161 static portTASK_FUNCTION( vLimitedIncrementTask, pvParameters )
vLimitedIncrementTask:
CFI Block cfiBlock1 Using cfiCommon0
CFI Function vLimitedIncrementTask
// 162 {
FUNCALL vLimitedIncrementTask, vTaskSuspend
LOCFRAME CSTACK, 6, STACK
FUNCALL vLimitedIncrementTask, vTaskSuspend
LOCFRAME CSTACK, 6, STACK
PUSH.W R10
CFI R10 Frame(CFA, -4)
CFI CFA SP+4
PUSH.W R11
CFI R11 Frame(CFA, -6)
CFI CFA SP+6
MOV.W R12, R10
// 163 unsigned portLONG *pulCounter;
// 164
// 165 /* Take a pointer to the shared variable from the parameters passed into
// 166 the task. */
// 167 pulCounter = ( unsigned portLONG * ) pvParameters;
MOV.W R10, R11
// 168
// 169 /* This will run before the control task, so the first thing it does is
// 170 suspend - the control task will resume it when ready. */
// 171 vTaskSuspend( NULL );
MOV.W #0x0, R12
CALL #vTaskSuspend
// 172
// 173 for( ;; )
// 174 {
// 175 /* Just count up to a value then suspend. */
// 176 ( *pulCounter )++;
??vLimitedIncrementTask_0:
MOV.W R11, R15
ADD.W #0x1, 0(R15)
ADDC.W #0x0, 0x2(R15)
// 177
// 178 if( *pulCounter >= priMAX_COUNT )
CMP.W #0x0, 0x2(R11)
JNC ??vLimitedIncrementTask_0
JNE ??vLimitedIncrementTask_1
CMP.W #0xff, 0x0(R11)
JNC ??vLimitedIncrementTask_0
// 179 {
// 180 vTaskSuspend( NULL );
??vLimitedIncrementTask_1:
MOV.W #0x0, R12
CALL #vTaskSuspend
JMP ??vLimitedIncrementTask_0
CFI EndBlock cfiBlock1
// 181 }
// 182 }
// 183 }
// 184 /*-----------------------------------------------------------*/
// 185
// 186 /*
// 187 * Just keep counting the shared variable up. The control task will suspend
// 188 * this task when it wants.
// 189 */
RSEG CODE:CODE:REORDER:NOROOT(1)
// 190 static portTASK_FUNCTION( vContinuousIncrementTask, pvParameters )
vContinuousIncrementTask:
CFI Block cfiBlock2 Using cfiCommon0
CFI Function vContinuousIncrementTask
// 191 {
FUNCALL vContinuousIncrementTask, uxTaskPriorityGet
LOCFRAME CSTACK, 8, STACK
FUNCALL vContinuousIncrementTask, vTaskPrioritySet
LOCFRAME CSTACK, 8, STACK
FUNCALL vContinuousIncrementTask, vTaskPrioritySet
LOCFRAME CSTACK, 8, STACK
PUSH.W R10
CFI R10 Frame(CFA, -4)
CFI CFA SP+4
PUSH.W R11
CFI R11 Frame(CFA, -6)
CFI CFA SP+6
PUSH.W R8
CFI R8 Frame(CFA, -8)
CFI CFA SP+8
MOV.W R12, R10
// 192 unsigned portLONG *pulCounter;
// 193 unsigned portBASE_TYPE uxOurPriority;
// 194
// 195 /* Take a pointer to the shared variable from the parameters passed into
// 196 the task. */
// 197 pulCounter = ( unsigned portLONG * ) pvParameters;
MOV.W R10, R11
// 198
// 199 /* Query our priority so we can raise it when exclusive access to the
// 200 shared variable is required. */
// 201 uxOurPriority = uxTaskPriorityGet( NULL );
MOV.W #0x0, R12
CALL #uxTaskPriorityGet
MOV.W R12, R8
// 202
// 203 for( ;; )
// 204 {
// 205 /* Raise our priority above the controller task to ensure a context
// 206 switch does not occur while we are accessing this variable. */
// 207 vTaskPrioritySet( NULL, uxOurPriority + 1 );
??vContinuousIncrementTask_0:
MOV.W R8, R14
ADD.W #0x1, R14
MOV.W #0x0, R12
CALL #vTaskPrioritySet
// 208 ( *pulCounter )++;
MOV.W R11, R15
ADD.W #0x1, 0(R15)
ADDC.W #0x0, 0x2(R15)
// 209 vTaskPrioritySet( NULL, uxOurPriority );
MOV.W R8, R14
MOV.W #0x0, R12
CALL #vTaskPrioritySet
JMP ??vContinuousIncrementTask_0
CFI EndBlock cfiBlock2
// 210 }
// 211 }
// 212 /*-----------------------------------------------------------*/
// 213
// 214 /*
// 215 * Controller task as described above.
// 216 */
RSEG CODE:CODE:REORDER:NOROOT(1)
// 217 static portTASK_FUNCTION( vCounterControlTask, pvParameters )
vCounterControlTask:
CFI Block cfiBlock3 Using cfiCommon0
CFI Function vCounterControlTask
// 218 {
FUNCALL vCounterControlTask, vTaskSuspend
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskResume
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskDelay
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskSuspendAll
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, xTaskResumeAll
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskSuspend
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskResume
LOCFRAME CSTACK, 12, STACK
FUNCALL vCounterControlTask, vTaskResume
LOCFRAME CSTACK, 12, STACK
PUSH.W R10
CFI R10 Frame(CFA, -4)
CFI CFA SP+4
PUSH.W R11
CFI R11 Frame(CFA, -6)
CFI CFA SP+6
PUSH.W R8
CFI R8 Frame(CFA, -8)
CFI CFA SP+8
PUSH.W R9
CFI R9 Frame(CFA, -10)
CFI CFA SP+10
PUSH.W R6
CFI R6 Frame(CFA, -12)
CFI CFA SP+12
MOV.W R12, R8
// 219 unsigned portLONG ulLastCounter;
// 220 portSHORT sLoops;
// 221 portSHORT sError = pdFALSE;
MOV.W #0x0, R6
// 222
// 223 /* Just to stop warning messages. */
// 224 ( void ) pvParameters;
// 225
// 226 for( ;; )
// 227 {
// 228 /* Start with the counter at zero. */
// 229 ulCounter = ( unsigned portLONG ) 0;
??vCounterControlTask_1:
MOV.W #0x0, &ulCounter
MOV.W #0x0, &ulCounter + 2
// 230
// 231 /* First section : */
// 232
// 233 /* Check the continuous count task is running. */
// 234 for( sLoops = 0; sLoops < priLOOPS; sLoops++ )
MOV.W #0x0, R9
??vCounterControlTask_0:
CMP.W #0x5, R9
JGE ??vCounterControlTask_2
// 235 {
// 236 /* Suspend the continuous count task so we can take a mirror of the
// 237 shared variable without risk of corruption. */
// 238 vTaskSuspend( xContinousIncrementHandle );
MOV.W &xContinousIncrementHandle, R12
CALL #vTaskSuspend
// 239 ulLastCounter = ulCounter;
MOV.W &ulCounter, R10
MOV.W &ulCounter + 2, R11
// 240 vTaskResume( xContinousIncrementHandle );
MOV.W &xContinousIncrementHandle, R12
CALL #vTaskResume
// 241
// 242 /* Now delay to ensure the other task has processor time. */
// 243 vTaskDelay( priSLEEP_TIME );
MOV.W #0x32, R12
CALL #vTaskDelay
// 244
// 245 /* Check the shared variable again. This time to ensure mutual
// 246 exclusion the whole scheduler will be locked. This is just for
// 247 demo purposes! */
// 248 vTaskSuspendAll();
CALL #vTaskSuspendAll
// 249 {
// 250 if( ulLastCounter == ulCounter )
CMP.W &ulCounter, R10
JNE ??vCounterControlTask_3
CMP.W &ulCounter + 2, R11
JNE ??vCounterControlTask_3
// 251 {
// 252 /* The shared variable has not changed. There is a problem
// 253 with the continuous count task so flag an error. */
// 254 sError = pdTRUE;
MOV.W #0x1, R6
// 255 }
// 256 }
// 257 xTaskResumeAll();
??vCounterControlTask_3:
CALL #xTaskResumeAll
// 258 }
ADD.W #0x1, R9
JMP ??vCounterControlTask_0
// 259
// 260
// 261 /* Second section: */
// 262
// 263 /* Suspend the continuous counter task so it stops accessing the shared variable. */
// 264 vTaskSuspend( xContinousIncrementHandle );
??vCounterControlTask_2:
MOV.W &xContinousIncrementHandle, R12
CALL #vTaskSuspend
// 265
// 266 /* Reset the variable. */
// 267 ulCounter = ( unsigned portLONG ) 0;
MOV.W #0x0, &ulCounter
MOV.W #0x0, &ulCounter + 2
// 268
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -