comtest.s43

MSP430 IAR project with FreeRTOS port.

        PUSH.W  #0x40
        CFI CFA SP+26
        MOV.W   #`?<Constant "COMRx">`, R14
        MOV.W   #vComRxTask, R12
        CALL    #xTaskCreate
//  147 }
        ADD.W   #0x10, SP
        CFI CFA SP+10
        BR      #?Epilogue4
        CFI EndBlock cfiBlock0
//  148 /*-----------------------------------------------------------*/
//  149 

        RSEG CODE:CODE:REORDER:NOROOT(1)
//  150 static portTASK_FUNCTION( vComTxTask, pvParameters )
vComTxTask:
        CFI Block cfiBlock1 Using cfiCommon0
        CFI Function vComTxTask
//  151 {
        FUNCALL vComTxTask, xSerialPutChar
        LOCFRAME CSTACK, 10, STACK
        FUNCALL vComTxTask, xTaskGetTickCount
        LOCFRAME CSTACK, 8, STACK
        FUNCALL vComTxTask, vTaskDelay
        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
//  152 signed portCHAR cByteToSend;
//  153 portTickType xTimeToWait;
//  154 
//  155 	/* Just to stop compiler warnings. */
//  156 	( void ) pvParameters;
//  157 
//  158 	for( ;; )
//  159 	{
//  160 		/* Simply transmit a sequence of characters from comFIRST_BYTE to
//  161 		comLAST_BYTE. */
//  162 		for( cByteToSend = comFIRST_BYTE; cByteToSend <= comLAST_BYTE; cByteToSend++ )
??vComTxTask_1:
        MOV.B   #0x41, R11
??vComTxTask_0:
        CMP.B   #0x7b, R11
        JGE     ??vComTxTask_2
//  163 		{
//  164 			if( xSerialPutChar( xPort, cByteToSend, comNO_BLOCK ) == pdPASS )
        PUSH.W  #0x0
        CFI CFA SP+10
        MOV.B   R11, R14
        MOV.W   &xPort, R12
        CALL    #xSerialPutChar
//  165 			{
//  166 //				vParTestToggleLED( uxBaseLED + comTX_LED_OFFSET );
//  167 			}
//  168 		}
        ADD.B   #0x1, R11
        ADD.W   #0x2, SP
        CFI CFA SP+8
        JMP     ??vComTxTask_0
//  169 
//  170 		/* Turn the LED off while we are not doing anything. */
//  171 //		vParTestSetLED( uxBaseLED + comTX_LED_OFFSET, pdFALSE );
//  172 
//  173 		/* We have posted all the characters in the string - wait before
//  174 		re-sending.  Wait a pseudo-random time as this will provide a better
//  175 		test. */
//  176 		xTimeToWait = xTaskGetTickCount() + comOFFSET_TIME;
??vComTxTask_2:
        CALL    #xTaskGetTickCount
        ADD.W   #0x3, R12
        MOV.W   R12, R8
//  177 
//  178 		/* Make sure we don't wait too long... */
//  179 		xTimeToWait %= comTX_MAX_BLOCK_TIME;
        MOV.W   R8, R12
        MOV.W   #0x96, R14
        CALL    #?DivMod16u
        MOV.W   R14, R8
//  180 
//  181 		/* ...but we do want to wait. */
//  182 		if( xTimeToWait < comTX_MIN_BLOCK_TIME )
        CMP.W   #0x32, R8
        JC      ??vComTxTask_3
//  183 		{
//  184 			xTimeToWait = comTX_MIN_BLOCK_TIME;
        MOV.W   #0x32, R8
//  185 		}
//  186 
//  187 		vTaskDelay( xTimeToWait );
??vComTxTask_3:
        MOV.W   R8, R12
        CALL    #vTaskDelay
        JMP     ??vComTxTask_1
        CFI EndBlock cfiBlock1
//  188 	}
//  189 } /*lint !e715 !e818 pvParameters is required for a task function even if it is not referenced. */
//  190 /*-----------------------------------------------------------*/
//  191 

        RSEG CODE:CODE:REORDER:NOROOT(1)
//  192 static portTASK_FUNCTION( vComRxTask, pvParameters )
vComRxTask:
        CFI Block cfiBlock2 Using cfiCommon0
        CFI Function vComRxTask
//  193 {
        FUNCALL vComRxTask, xSerialGetChar
        LOCFRAME CSTACK, 14, STACK
        FUNCALL vComRxTask, xSerialGetChar
        LOCFRAME CSTACK, 14, 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
        SUB.W   #0x2, SP
        CFI CFA SP+12
        MOV.W   R12, R10
//  194 signed portCHAR cExpectedByte, cByteRxed;
//  195 portBASE_TYPE xResyncRequired = pdFALSE, xErrorOccurred = pdFALSE;
        MOV.W   #0x0, R8
        MOV.W   #0x0, R9
//  196 
//  197 	/* Just to stop compiler warnings. */
//  198 	( void ) pvParameters;
//  199 
//  200 	for( ;; )
//  201 	{
//  202 		/* We expect to receive the characters from comFIRST_BYTE to
//  203 		comLAST_BYTE in an incrementing order.  Loop to receive each byte. */
//  204 		for( cExpectedByte = comFIRST_BYTE; cExpectedByte <= comLAST_BYTE; cExpectedByte++ )
??vComRxTask_2:
        MOV.B   #0x41, R11
??vComRxTask_0:
        CMP.B   #0x7b, R11
        JGE     ??vComRxTask_3
//  205 		{
//  206 			/* Block on the queue that contains received bytes until a byte is
//  207 			available. */
//  208 			if( xSerialGetChar( xPort, &cByteRxed, comRX_BLOCK_TIME ) )
        PUSH.W  #0xffff
        CFI CFA SP+14
        MOV.W   SP, R14
        ADD.W   #0x2, R14
        MOV.W   &xPort, R12
        CALL    #xSerialGetChar
        ADD.W   #0x2, SP
        CFI CFA SP+12
        CMP.W   #0x0, R12
        JEQ     ??vComRxTask_4
//  209 			{
//  210 				/* Was this the byte we were expecting?  If so, toggle the LED,
//  211 				otherwise we are out on sync and should break out of the loop
//  212 				until the expected character sequence is about to restart. */
//  213 				if( cByteRxed == cExpectedByte )
        CMP.B   R11, 0x0(SP)
        JEQ     ??vComRxTask_4
//  214 				{
//  215 //					vParTestToggleLED( uxBaseLED + comRX_LED_OFFSET );
//  216 				}
//  217 				else
//  218 				{
//  219 					xResyncRequired = pdTRUE;
        MOV.W   #0x1, R8
//  220 					break; /*lint !e960 Non-switch break allowed. */
        JMP     ??vComRxTask_3
//  221 				}
//  222 			}
//  223 		}
??vComRxTask_4:
        ADD.B   #0x1, R11
        JMP     ??vComRxTask_0
//  224 
//  225 		/* Turn the LED off while we are not doing anything. */
//  226 //		vParTestSetLED( uxBaseLED + comRX_LED_OFFSET, pdFALSE );
//  227 
//  228 		/* Did we break out of the loop because the characters were received in
//  229 		an unexpected order?  If so wait here until the character sequence is
//  230 		about to restart. */
//  231 		if( xResyncRequired == pdTRUE )
??vComRxTask_3:
        CMP.W   #0x1, R8
        JNE     ??vComRxTask_5
//  232 		{
//  233 			while( cByteRxed != comLAST_BYTE )
??vComRxTask_1:
        CMP.B   #0x7a, 0x0(SP)
        JEQ     ??vComRxTask_6
//  234 			{
//  235 				/* Block until the next char is available. */
//  236 				xSerialGetChar( xPort, &cByteRxed, comRX_BLOCK_TIME );
        PUSH.W  #0xffff
        CFI CFA SP+14
        MOV.W   SP, R14
        ADD.W   #0x2, R14
        MOV.W   &xPort, R12
        CALL    #xSerialGetChar
        ADD.W   #0x2, SP
        CFI CFA SP+12
        JMP     ??vComRxTask_1
//  237 			}
//  238 
//  239 			/* Note that an error occurred which caused us to have to resync.
//  240 			We use this to stop incrementing the loop counter so
//  241 			sAreComTestTasksStillRunning() will return false - indicating an
//  242 			error. */
//  243 			xErrorOccurred++;
??vComRxTask_6:
        ADD.W   #0x1, R9
//  244 
//  245 			/* We have now resynced with the Tx task and can continue. */
//  246 			xResyncRequired = pdFALSE;
        MOV.W   #0x0, R8
        JMP     ??vComRxTask_2
//  247 		}
//  248 		else
//  249 		{
//  250 			if( xErrorOccurred < comTOTAL_PERMISSIBLE_ERRORS )
??vComRxTask_5:
        CMP.W   #0x2, R9
        JGE     ??vComRxTask_2
//  251 			{
//  252 				/* Increment the count of successful loops.  As error
//  253 				occurring (i.e. an unexpected character being received) will
//  254 				prevent this counter being incremented for the rest of the
//  255 				execution.   Don't worry about mutual exclusion on this
//  256 				variable - it doesn't really matter as we just want it
//  257 				to change. */
//  258 				uxRxLoops++;
        ADD.W   #0x1, &uxRxLoops
        JMP     ??vComRxTask_2
        CFI EndBlock cfiBlock2
//  259 			}
//  260 		}
//  261 	}
//  262 } /*lint !e715 !e818 pvParameters is required for a task function even if it is not referenced. */
//  263 /*-----------------------------------------------------------*/
//  264 

        RSEG CODE:CODE:REORDER:NOROOT(1)
//  265 portBASE_TYPE xAreComTestTasksStillRunning( void )
xAreComTestTasksStillRunning:
        CFI Block cfiBlock3 Using cfiCommon0
        CFI Function xAreComTestTasksStillRunning
//  266 {
//  267 portBASE_TYPE xReturn;
//  268 
//  269 	/* If the count of successful reception loops has not changed than at
//  270 	some time an error occurred (i.e. a character was received out of sequence)
//  271 	and we will return false. */
//  272 	if( uxRxLoops == comINITIAL_RX_COUNT_VALUE )
        CMP.W   #0x0, &uxRxLoops
        JNE     ??xAreComTestTasksStillRunning_0
//  273 	{
//  274 		xReturn = pdFALSE;
        MOV.W   #0x0, R12
        JMP     ??xAreComTestTasksStillRunning_1
//  275 	}
//  276 	else
//  277 	{
//  278 		xReturn = pdTRUE;
??xAreComTestTasksStillRunning_0:
        MOV.W   #0x1, R12
//  279 	}
//  280 
//  281 	/* Reset the count of successful Rx loops.  When this function is called
//  282 	again we expect this to have been incremented. */
//  283 	uxRxLoops = comINITIAL_RX_COUNT_VALUE;
??xAreComTestTasksStillRunning_1:
        MOV.W   #0x0, &uxRxLoops
//  284 
//  285 	return xReturn;
        RET
        CFI EndBlock cfiBlock3
//  286 }

        RSEG CODE:CODE:REORDER:NOROOT(1)
?setjmp_save_r4:
        REQUIRE ?setjmp_r4
        REQUIRE ?longjmp_r4

        RSEG CODE:CODE:REORDER:NOROOT(1)
?setjmp_save_r5:
        REQUIRE ?setjmp_r5
        REQUIRE ?longjmp_r5

        RSEG DATA16_C:CONST:SORT:NOROOT(0)
`?<Constant "COMTx">`:
        DC8 "COMTx"

        RSEG DATA16_C:CONST:SORT:NOROOT(0)
`?<Constant "COMRx">`:
        DC8 "COMRx"

        END
//  287 
// 
// 290 bytes in segment CODE
//  12 bytes in segment DATA16_C
//   6 bytes in segment DATA16_Z
// 
// 290 bytes of CODE  memory
//  12 bytes of CONST memory
//   6 bytes of DATA  memory
//
//Errors: none
//Warnings: 3