Autosar BSW层CAN通讯开发------08（Autosar的E2E开发-----以E2E Profile01为例）

1
2
3
4
5
6
7
8
9
10
typedef enum {
        E2E_P01STATUS_OK = 0x00,
        E2E_P01STATUS_NONEWDATA = 0x1,
        E2E_P01STATUS_WRONGCRC = 0x2,
        E2E_P01STATUS_SYNC = 0x03,
        E2E_P01STATUS_INITIAL = 0x4,
        E2E_P01STATUS_REPEATED = 0x8,
        E2E_P01STATUS_OKSOMELOST = 0x20,
        E2E_P01STATUS_WRONGSEQUENCE = 0x40
} E2E_P01CheckStatusType;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
#include "typedef_datatype.h"
#include "E2E_Config.h"




uint16 DataID = 0x00AD;//DataID_Low = 0xAD    DataID_High = 0x00    
uint8 Test_Data_Array[8] = { 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x73, 0x20 }; //Byte0-Byte7   Test Data
E2E_P01ConfigType E2E_Profile01_Test_Config = {
	56,						//CounterOffset
	0,						//CRCOffset
	177,					//DataID
	0,					//DataIDNibbleOffset
	E2E_P01_DATAID_BOTH,	//DataIDMode
	64,						//DataLength
	0,					//MaxDeltaCounterInit
	0,					//MaxNoNewOrRepeatedData
	0					//SyncCounterInit
};


void main(void)
{
	for (uint8 counter = 0; counter < 15; counter++)
	{
		Test_Data_Array[7] = (Test_Data_Array[7] & 0xF0) | counter;
		Test_Data_Array[0] = E2E_P01ComputeCRC(Test_Data_Array, &E2E_Profile01_Test_Config, 0xFF);
		for (uint8 i = 0; i < 8; i++)
		{
			printf("%x ", Test_Data_Array[i]);
		}
		printf("n");
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#ifndef E2E_Config_H_
#define E2E_Config_H_

#include <stdio.h>
#include "typedef_datatype.h"

/* For CRC 8*/
#define CRC8_START_VALUE        0xFFU
#define CRC8_XOR                0xFFU
/* CRC 8 Configuration
 * Possible values and the mode decides what method to be used
 */
#define CRC_8_HARDWARE (0x01) /* Not supported */
#define CRC_8_RUNTIME  (0x02)
#define CRC_8_TABLE    (0x04) /* Default value */


#define CRC_8_MODE      CRC_8_RUNTIME



 /* E2E Profile01 */
#define CRC8_POLYNOMIAL			0x1DU

typedef enum {
	E2E_P01_DATAID_BOTH = 0x0,
	E2E_P01_DATAID_ALT = 0x1,
	E2E_P01_DATAID_LOW = 0x2,
	E2E_P01_DATAID_NIBBLE = 0x3
} E2E_P01DataIDMode;

typedef struct {
	uint16 CounterOffset;
	uint16 CRCOffset;
	uint16 DataID;
	uint16 DataIDNibbleOffset;
	E2E_P01DataIDMode DataIDMode;
	uint16 DataLength;
	uint8 MaxDeltaCounterInit;
	uint8 MaxNoNewOrRepeatedData;
	uint8 SyncCounterInit;
} E2E_P01ConfigType;



uint8 Crc_CalculateCRC8(const uint8* Crc_DataPtr, uint32 Crc_Length, uint8 Crc_StartValue8, boolean Crc_IsFirstCall);
uint8 E2E_P01ComputeCRC(const uint8* Crc_DataPtr, const E2E_P01ConfigType* ConfigPtr, uint8 Counter);

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include "E2E_Config.h"



static uint8 CalculateCRC8(const uint8* message, uint32 nBytes, uint8 start, uint8 poly)
{
	uint8  remainder = start;
	uint8  bit;
	uint8  topbit = 0x80;

	/* Perform modulo-2 division, a byte at a time. */
	for (uint32 byte = 0; byte < nBytes; byte++) {
		/* Bring the next byte into the remainder. */
		remainder ^= *message;
		message++;

		/* Perform modulo-2 division, a bit at a time. */
		for (bit = 8; bit > 0; bit--) {

			/* Try to divide the current data bit. */
			if ((remainder & topbit) != 0u) {
				remainder = (uint8)(remainder << 1) ^ poly;
			}
			else {
				remainder = (remainder << 1u); /*lint !e734 Lint exception: Intentional */
			}
		}
	}

	return remainder;
}



uint8 Crc_CalculateCRC8(const uint8* Crc_DataPtr, uint32 Crc_Length, uint8 Crc_StartValue8, boolean Crc_IsFirstCall)
{
	uint8 crc = 0;    /* Default return value if NULL pointer */

	if (Crc_DataPtr != NULL)
	{

		crc = (TRUE == Crc_IsFirstCall) ? CRC8_START_VALUE : (Crc_StartValue8 ^ CRC8_XOR);

#if CRC_8_MODE == CRC_8_RUNTIME
		crc = CalculateCRC8(Crc_DataPtr, Crc_Length, crc, CRC8_POLYNOMIAL);
#elif CRC_8_MODE == CRC_8_TABLE
		for (uint32 byte = 0; byte < Crc_Length; byte++)
		{
			crc = crc8_tab[crc ^ *Crc_DataPtr];
			Crc_DataPtr++;
		}
#endif

		/* Only XOR value if any calculation was done */
		crc = crc ^ CRC8_XOR;

	}

	return crc;

}


uint8 E2E_P01ComputeCRC(const uint8* DataPtr, const E2E_P01ConfigType* ConfigPtr, uint8 Counter)
{
	uint8 crc;
	uint8 CrcLength;
	uint8 LocalDataID[2];
	uint16 CalculatedOffset;
	uint16 CalculatedLength;

	switch (ConfigPtr->DataIDMode)
	{
	case E2E_P01_DATAID_BOTH:
	{
		LocalDataID[0] = (uint8)(ConfigPtr->DataID);
		LocalDataID[1] = (uint8)(ConfigPtr->DataID >> 8u);
		CrcLength = 2;
		break;
	}
	case E2E_P01_DATAID_LOW:
	{
		LocalDataID[0] = (uint8)ConfigPtr->DataID;
		CrcLength = 1;
		break;
	}
	case E2E_P01_DATAID_NIBBLE:
	{
		LocalDataID[0] = (uint8)ConfigPtr->DataID;
		LocalDataID[1] = 0;
		CrcLength = 2;
		break;
	}
	case E2E_P01_DATAID_ALT:
	{
		CrcLength = 1;
		if ((Counter & 0x01u) == 0u)
		{
			LocalDataID[0] = (uint8)ConfigPtr->DataID;
		}
		else
		{
			LocalDataID[0] = (uint8)(ConfigPtr->DataID >> 8u);
		}
		break;
	}
	default:
		LocalDataID[0] = 0u;
		CrcLength = 0u;
		break;

	}

	crc = Crc_CalculateCRC8(LocalDataID, CrcLength, 0xFF, FALSE);

	CalculatedOffset = ConfigPtr->CRCOffset >> 3u;
	if ((CalculatedOffset) > 0u)
	{
		crc = Crc_CalculateCRC8(DataPtr
			, CalculatedOffset
			, crc
			, FALSE
		);
	}

	CalculatedLength = ConfigPtr->DataLength >> 3u;
	if (CalculatedOffset < (CalculatedLength - 1u))
	{
		crc = Crc_CalculateCRC8(&DataPtr[CalculatedOffset + 1u]
			, (uint32)CalculatedLength - CalculatedOffset - 1u
			, crc
			, FALSE
		);
	}

	return crc ^ 0xFFu;

}