TMS320F280025: 使用SPRUHS1C文件内642页提供CRC例程输出结果不正确。

; -------------------
; Calculate the CRC of a block of data
; This function assumes the block is a multiple of 2 16-bit words
;
		.if __TI_EABI__
	  	.asg getCRC16P1_vcu, _getCRC16P1_vcu
	  	.asg CRC16P1 , _CRC16P1
	  	.asg getCRC16P2_vcu, _getCRC16P2_vcu
	  	.endif

;	  	.def _getCRC16P1_vcu
;		.def    CRC16P1
		.global _CRC16P1
		.global _getCRC16P2_vcu
		.global	_getCRC16P1_vcu

;		.text

_CRC16P1
		VCRCCLR 					; Clear the result register
		MOV		AL, 	*+XAR4[4] 	; AL = CRCLen
		ASR 	AL, 	2 			; AL = CRCLen/4
		SUBB 	AL, 	#1 			; AL = CRCLen/4 - 1
		MOVL 	XAR7, 	*+XAR4[2]	; XAR7 = &CRCData
		.align 2
		NOP 						; Align RPTB to an odd address
		RPTB _CRC16P1_done, AL 		; Execute block of code AL + 1 times
		VCRC16P1L_1 *XAR7 			; Calculate CRC for 4 bytes
		VCRC16P1H_1 *XAR7++ 		; ...
		VCRC16P1L_1 *XAR7 			; ...
		VCRC16P1H_1 *XAR7++ 		; ...

_CRC16P1_done
		MOVL 	XAR7, 	*+XAR4[0] 	; XAR7 = &CRCResult
		VMOV32 	*+XAR7[0], VCRC 	; Store the result
		LRETR						; return to caller





_getCRC16P2_vcu:
	  PUSH		  XAR0
	  PUSH        XAR1

	  MOVZ        AR0, *-SP[7]        ; load rxLen
      ADDB        SP, #4              ; allocate 4 words for local
      VMOV32      *-SP[2], VCRC       ; Store current CRC
      VCRCCLR
      MOVL        *-SP[4], ACC
      VMOV32      VCRC,*-SP[4]        ; VCRC = Inital value
      MOV         AL,AR5              ; check the parity
      SBF         _CRC16p2_loop_prep, EQ
      VCRC16P2H_1 *XAR4++             ; if parity=1, calculate high byte first
      DEC         AR0
      SBF         _CRC16p2done, EQ
_CRC16p2_loop_prep:
      MOV         AL, AR0
      MOV         AH, AR0
      AND         AL, #0xFFF8         ; check to see if the length is greater than 8 bytes
      BF          _CRC16p2_LSB,EQ
      LSR         AL, #3              ; loop in 8 bytes
      MOV         AR1, AL
      SUB         AR1, #1

      .align     (2)                  ; align at 32-bit boundary to remove penalty
      RPTB        _CRC16p2_post, AR1  ; loop for the middle part of the packet
      VCRC16P2L_1 *XAR4
      VCRC16P2H_1 *XAR4++
      VCRC16P2L_1 *XAR4
      VCRC16P2H_1 *XAR4++
      VCRC16P2L_1 *XAR4
      VCRC16P2H_1 *XAR4++
      VCRC16P2L_1 *XAR4
      VCRC16P2H_1 *XAR4++
_CRC16p2_post
      LSL         AL, #3              ; calculating remaining number of bytes
      SUB         AH, AL
      SBF         _CRC16p2done, EQ	  ;branch to end on 0 remainder
      MOV         AR0, AH
_CRC16p2_LSB
      VCRC16P2L_1 *XAR4               ; if parity=0, calculate the low byte
      DEC         AR0
      SBF         _CRC16p2done, EQ
      VCRC16P2H_1 *XAR4++
      DEC         AR0
      SBF         _CRC16p2_LSB, NEQ
_CRC16p2done
      VMOV32       *-SP[4], VCRC        ; Store CRC
      MOV          AL, *-SP[4]          ; return AL
      VMOV32       VCRC, *-SP[2]        ; Restore VCRC
      SUBB         SP, #4               ; restore stack pointer
      POP          XAR1
      POP		   XAR0
      LRETR


_getCRC16P1_vcu:
	  PUSH 		  XAR0
	  PUSH        XAR1

	  MOVZ        AR0, *-SP[7]        ; load rxLen
      ADDB        SP, #4              ; allocate 4 words for local
      VMOV32      *-SP[2], VCRC       ; Store current CRC
      VCRCCLR
      MOVL        *-SP[4], ACC
      VMOV32      VCRC,*-SP[4]        ; VCRC = Inital value
      MOV         AL, AR5             ; check the parity
      SBF         _CRC16p1_loop_prep, EQ
      VCRC16P1H_1 *XAR4++             ; if parity=1, calculate high byte first
      DEC         AR0
      SBF         _CRC16p1done, EQ
_CRC16p1_loop_prep:
      MOV         AL, AR0
      MOV         AH, AR0
      AND         AL, #0xFFF8         ; check to see if the length is greater than 8 bytes
      BF          _CRC16p1_LSB,EQ
      LSR         AL, #3              ; loop in 8 bytes
      MOV         AR1, AL
      SUB         AR1, #1

      .align     (2)                  ; align at 32-bit boundary to remove penalty
      RPTB        _CRC16p1_post, AR1  ; loop for the middle part of the packet
      VCRC16P1L_1 *XAR4
      VCRC16P1H_1 *XAR4++
      VCRC16P1L_1 *XAR4
      VCRC16P1H_1 *XAR4++
      VCRC16P1L_1 *XAR4
      VCRC16P1H_1 *XAR4++
      VCRC16P1L_1 *XAR4
      VCRC16P1H_1 *XAR4++
_CRC16p1_post
      LSL         AL, #3              ; calculating remaining number of bytes
      SUB         AH, AL
      SBF         _CRC16p1done, EQ	  ;branch to end on 0 remainder
	  MOV         AR0, AH
_CRC16p1_LSB
      VCRC16P1L_1 *XAR4               ; if parity=0, calculate the low byte
      DEC         AR0
      SBF         _CRC16p1done, EQ
      VCRC16P1H_1 *XAR4++
      DEC         AR0
      SBF         _CRC16p1_LSB, NEQ
_CRC16p1done
      VMOV32       *-SP[4], VCRC        ; Store CRC
      MOV          AL, *-SP[4]          ; return AL
      VMOV32       VCRC, *-SP[2]        ; Restore VCRC
      SUBB         SP, #4               ; restore stack pointer
      POP          XAR1
      POP		   XAR0
      LRETR

typedef enum{
    CRC_parity_even = 0,
    CRC_parity_odd = 1
}CRC_parity_e;

typedef struct {
    Uint32 *CRCResult;      // Address where result should be stored
    Uint16 *CRCData;        // Start of data
    Uint16 CRCLen ;          // Length of data in bytes
}CRC_CALC;
CRC_CALC mycrc;

extern Uint32 CRC16P1(CRC_CALC *mycrc);
extern Uint16 getCRC16P1_vcu(Uint32 input_crc16_accum, Uint16 *msg, CRC_parity_e parity, Uint16 rxLen);
extern Uint16 getCRC16P2_vcu(Uint32 input_crc16_accum, Uint16 *msg, CRC_parity_e parity, Uint16 rxLen);

Uint32 CRC16resultP1;
Uint32 CRC16resultP2;
Uint16 inputdata[6]= {0x01,0x02,0x03,0x04,0x05,0x06};
static const Uint16 CRC16inputdata[6] = {0x01,0x02,0x03,0x04,0x05,0x06};
void main(void)
{
    //mycrc.CRCResult = TESTresult;
    mycrc.CRCData = inputdata;
    mycrc.CRCLen = 6;

    while(1)
    {
        CRC16P1(&mycrc);
        CRC16resultP1 = getCRC16P1_vcu(0xFFFF, (Uint16*)CRC16inputdata, (CRC_parity_e)CRC_parity_even, 6);
        CRC16resultP2 = getCRC16P2_vcu(0xFFFF, (Uint16*)CRC16inputdata, (CRC_parity_e)CRC_parity_even, 6);
     }