533 lines
14 KiB
C++
533 lines
14 KiB
C++
/*
|
|
* sent.cpp
|
|
*
|
|
* Created on: 16 May 2022
|
|
* Author: alexv
|
|
*/
|
|
|
|
#include "ch.h"
|
|
#include "hal.h"
|
|
|
|
#include "sent.h"
|
|
|
|
// Sent SM status arr
|
|
SM_SENT_enum sentSMstate[SENT_CHANNELS_NUM] = {SM_SENT_INIT_STATE};
|
|
|
|
// Sensor status arr
|
|
uint8_t sentStat[SENT_CHANNELS_NUM] = {0};
|
|
|
|
// Error counters
|
|
uint32_t sentMaxIntervalErr = 0;
|
|
uint32_t sentSyncErr = 0;
|
|
uint32_t sentStatusErr = 0;
|
|
uint32_t sentRollErrCnt = 0;
|
|
uint32_t sentCrcErrCnt = 0;
|
|
|
|
#if SENT_ERR_PERCENT
|
|
// Received msg counter
|
|
uint32_t sentPulseCnt = 0;
|
|
|
|
int errorRate = 0;
|
|
#endif // SENT_ERR_PERCENT
|
|
|
|
#if SENT_DEV == SENT_GM_ETB
|
|
// Received nibbles arr
|
|
uint8_t sentTempNibblArr[SENT_CHANNELS_NUM][SENT_MSG_PAYLOAD_SIZE] = {0};
|
|
|
|
uint16_t sentOpenThrottleVal = 0;
|
|
uint16_t sentClosedThrottleVal = 0;
|
|
|
|
uint16_t sentOpenTempVal = 0;
|
|
uint16_t sentClosedTempVal = 0;
|
|
|
|
uint8_t sentRawData = 0;
|
|
|
|
uint32_t sentIntervalErr = 0;
|
|
|
|
#define UNEXPECTED_VALUE 0xFF
|
|
|
|
const uint8_t sentLookupTable[] =
|
|
{
|
|
UNEXPECTED_VALUE, // 0
|
|
UNEXPECTED_VALUE, // 1
|
|
UNEXPECTED_VALUE, // 2
|
|
UNEXPECTED_VALUE, // 3
|
|
UNEXPECTED_VALUE, // 4
|
|
UNEXPECTED_VALUE, // 5
|
|
UNEXPECTED_VALUE, // 6
|
|
UNEXPECTED_VALUE, // 7
|
|
UNEXPECTED_VALUE, // 8
|
|
UNEXPECTED_VALUE, // 9
|
|
UNEXPECTED_VALUE, // 10
|
|
UNEXPECTED_VALUE, // 11
|
|
UNEXPECTED_VALUE, // 12
|
|
UNEXPECTED_VALUE, // 13
|
|
UNEXPECTED_VALUE, // 14
|
|
UNEXPECTED_VALUE, // 15
|
|
UNEXPECTED_VALUE, // 16
|
|
UNEXPECTED_VALUE, // 17
|
|
UNEXPECTED_VALUE, // 18
|
|
UNEXPECTED_VALUE, // 19
|
|
UNEXPECTED_VALUE, // 20
|
|
UNEXPECTED_VALUE, // 21
|
|
UNEXPECTED_VALUE, // 22
|
|
UNEXPECTED_VALUE, // 23
|
|
UNEXPECTED_VALUE, // 24
|
|
UNEXPECTED_VALUE, // 25
|
|
UNEXPECTED_VALUE, // 26
|
|
UNEXPECTED_VALUE, // 27
|
|
UNEXPECTED_VALUE, // 28
|
|
UNEXPECTED_VALUE, // 29
|
|
UNEXPECTED_VALUE, // 30
|
|
UNEXPECTED_VALUE, // 31
|
|
UNEXPECTED_VALUE, // 32
|
|
UNEXPECTED_VALUE, // 33
|
|
UNEXPECTED_VALUE, // 34
|
|
UNEXPECTED_VALUE, // 35
|
|
UNEXPECTED_VALUE, // 36
|
|
UNEXPECTED_VALUE, // 37
|
|
0, // 38
|
|
0, // 39
|
|
0, // 40
|
|
1, // 41
|
|
1, // 42
|
|
1, // 43
|
|
2, // 44
|
|
2, // 45
|
|
2, // 46
|
|
3, // 47
|
|
3, // 48
|
|
3, // 49
|
|
4, // 50
|
|
4, // 51
|
|
4, // 52
|
|
UNEXPECTED_VALUE, // 53
|
|
5, // 54
|
|
5, // 55
|
|
5, // 56
|
|
6, // 57
|
|
6, // 58
|
|
6, // 59
|
|
7, // 60
|
|
7, // 61
|
|
7, // 62
|
|
8, // 63
|
|
8, // 64
|
|
8, // 65
|
|
UNEXPECTED_VALUE, // 66
|
|
9, // 67
|
|
9, // 68
|
|
9, // 69
|
|
10, // 70
|
|
10, // 71
|
|
10, // 72
|
|
11, // 73
|
|
11, // 74
|
|
11, // 75
|
|
12, // 76
|
|
12, // 77
|
|
12, // 78
|
|
UNEXPECTED_VALUE, // 79
|
|
13, // 80
|
|
13, // 81
|
|
13, // 82
|
|
14, // 83
|
|
14, // 84
|
|
14, // 85
|
|
15, // 86
|
|
15, // 87
|
|
15, // 88
|
|
UNEXPECTED_VALUE, // 89
|
|
UNEXPECTED_VALUE, // 90
|
|
UNEXPECTED_VALUE, // 91
|
|
UNEXPECTED_VALUE, // 92
|
|
UNEXPECTED_VALUE, // 93
|
|
UNEXPECTED_VALUE, // 94
|
|
UNEXPECTED_VALUE, // 95
|
|
UNEXPECTED_VALUE, // 96
|
|
UNEXPECTED_VALUE, // 97
|
|
UNEXPECTED_VALUE, // 98
|
|
UNEXPECTED_VALUE, // 99
|
|
UNEXPECTED_VALUE, // 100
|
|
UNEXPECTED_VALUE, // 101
|
|
UNEXPECTED_VALUE, // 102
|
|
UNEXPECTED_VALUE, // 103
|
|
UNEXPECTED_VALUE, // 104
|
|
UNEXPECTED_VALUE, // 105
|
|
UNEXPECTED_VALUE, // 106
|
|
UNEXPECTED_VALUE, // 107
|
|
UNEXPECTED_VALUE, // 108
|
|
UNEXPECTED_VALUE, // 109
|
|
UNEXPECTED_VALUE, // 110
|
|
UNEXPECTED_VALUE, // 111
|
|
UNEXPECTED_VALUE, // 112
|
|
UNEXPECTED_VALUE, // 113
|
|
UNEXPECTED_VALUE, // 114
|
|
UNEXPECTED_VALUE, // 115
|
|
UNEXPECTED_VALUE, // 116
|
|
UNEXPECTED_VALUE, // 117
|
|
UNEXPECTED_VALUE, // 118
|
|
UNEXPECTED_VALUE, // 119
|
|
UNEXPECTED_VALUE, // 120
|
|
UNEXPECTED_VALUE, // 121
|
|
UNEXPECTED_VALUE, // 122
|
|
UNEXPECTED_VALUE, // 123
|
|
UNEXPECTED_VALUE, // 124
|
|
UNEXPECTED_VALUE, // 125
|
|
UNEXPECTED_VALUE, // 126
|
|
UNEXPECTED_VALUE, // 127
|
|
UNEXPECTED_VALUE, // 128
|
|
UNEXPECTED_VALUE, // 129
|
|
UNEXPECTED_VALUE, // 130
|
|
UNEXPECTED_VALUE, // 131
|
|
UNEXPECTED_VALUE, // 132
|
|
UNEXPECTED_VALUE, // 133
|
|
UNEXPECTED_VALUE, // 134
|
|
UNEXPECTED_VALUE, // 135
|
|
UNEXPECTED_VALUE, // 136
|
|
UNEXPECTED_VALUE, // 137
|
|
UNEXPECTED_VALUE, // 138
|
|
UNEXPECTED_VALUE, // 139
|
|
UNEXPECTED_VALUE, // 140
|
|
UNEXPECTED_VALUE, // 141
|
|
UNEXPECTED_VALUE, // 142
|
|
UNEXPECTED_VALUE, // 143
|
|
UNEXPECTED_VALUE, // 144
|
|
UNEXPECTED_VALUE, // 145
|
|
UNEXPECTED_VALUE, // 146
|
|
UNEXPECTED_VALUE, // 147
|
|
UNEXPECTED_VALUE, // 148
|
|
UNEXPECTED_VALUE, // 149
|
|
UNEXPECTED_VALUE, // 150
|
|
UNEXPECTED_VALUE, // 151
|
|
UNEXPECTED_VALUE, // 152
|
|
UNEXPECTED_VALUE, // 153
|
|
UNEXPECTED_VALUE, // 154
|
|
UNEXPECTED_VALUE, // 155
|
|
UNEXPECTED_VALUE, // 156
|
|
UNEXPECTED_VALUE, // 157
|
|
UNEXPECTED_VALUE, // 158
|
|
UNEXPECTED_VALUE, // 159
|
|
UNEXPECTED_VALUE, // 160
|
|
UNEXPECTED_VALUE, // 161
|
|
UNEXPECTED_VALUE, // 162
|
|
UNEXPECTED_VALUE, // 163
|
|
UNEXPECTED_VALUE, // 164
|
|
UNEXPECTED_VALUE, // 165
|
|
UNEXPECTED_VALUE, // 166
|
|
UNEXPECTED_VALUE, // 167
|
|
UNEXPECTED_VALUE, // 168
|
|
UNEXPECTED_VALUE, // 169
|
|
UNEXPECTED_VALUE, // 170
|
|
UNEXPECTED_VALUE, // 171
|
|
UNEXPECTED_VALUE, // 172
|
|
UNEXPECTED_VALUE, // 173
|
|
UNEXPECTED_VALUE, // 174
|
|
UNEXPECTED_VALUE, // 175
|
|
UNEXPECTED_VALUE, // 176
|
|
UNEXPECTED_VALUE, // 177
|
|
UNEXPECTED_VALUE, // 178
|
|
UNEXPECTED_VALUE, // 179
|
|
SENT_SYNC_INTERVAL, // 180
|
|
SENT_SYNC_INTERVAL, // 181
|
|
SENT_SYNC_INTERVAL, // 182
|
|
};
|
|
|
|
uint8_t sent_crc4(uint8_t* pdata, uint16_t ndata);
|
|
|
|
#pragma GCC push_options
|
|
#pragma GCC optimize ("O2")
|
|
|
|
void SENT_ISR_Handler(uint8_t ch, uint16_t val_res)
|
|
{
|
|
val_res = sentLookupTable[val_res];
|
|
|
|
if(val_res == 0xFF)
|
|
{
|
|
sentIntervalErr++;
|
|
}
|
|
else
|
|
{
|
|
switch(sentSMstate[ch])
|
|
{
|
|
case SM_SENT_INIT_STATE:
|
|
#if SENT_ERR_PERCENT
|
|
sentPulseCnt++;
|
|
#endif
|
|
|
|
if(val_res == SENT_SYNC_INTERVAL)
|
|
{// sync interval - 56 ticks
|
|
sentSMstate[ch] = SM_SENT_STATUS_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SYNC_STATE:
|
|
#if SENT_ERR_PERCENT
|
|
sentPulseCnt++;
|
|
#endif
|
|
|
|
if(val_res == SENT_SYNC_INTERVAL)
|
|
{// sync interval - 56 ticks
|
|
sentSMstate[ch] = SM_SENT_STATUS_STATE;
|
|
}
|
|
else
|
|
{
|
|
// Increment sync interval err count
|
|
sentSyncErr++;
|
|
|
|
#if SENT_ERR_PERCENT
|
|
// Calc err percentage
|
|
errorRate = 100 * sentSyncErr / sentPulseCnt;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_STATUS_STATE:
|
|
// status interval
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentStat[ch] = val_res;
|
|
|
|
if(sentStat[ch])
|
|
{
|
|
sentStatusErr++;
|
|
}
|
|
|
|
sentTempNibblArr[ch][0] = val_res;
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG1_DATA1_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG1_DATA1_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][1] = val_res;
|
|
|
|
sentOpenTempVal = ((uint16_t)(val_res) << 8);
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG1_DATA2_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG1_DATA2_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][2] = val_res;
|
|
|
|
sentOpenTempVal |= ((uint16_t)(val_res) << 4);
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG1_DATA3_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG1_DATA3_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][3] = val_res;
|
|
|
|
sentOpenTempVal |= (val_res);
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG2_DATA1_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG2_DATA1_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][4] = val_res;
|
|
|
|
sentClosedTempVal = (val_res);
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG2_DATA2_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG2_DATA2_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][5] = val_res;
|
|
|
|
sentClosedTempVal |= ((uint16_t)(val_res) << 4);
|
|
|
|
sentSMstate[ch] = SM_SENT_SIG2_DATA3_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_SIG2_DATA3_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][6] = val_res;
|
|
|
|
sentClosedTempVal |= ((uint16_t)(val_res) << 8);
|
|
|
|
sentSMstate[ch] = SM_SENT_CRC_STATE;
|
|
}
|
|
break;
|
|
|
|
case SM_SENT_CRC_STATE:
|
|
if(val_res > SENT_MAX_INTERVAL)
|
|
{
|
|
sentMaxIntervalErr++;
|
|
}
|
|
else
|
|
{
|
|
sentTempNibblArr[ch][7] = val_res;
|
|
|
|
// Check crc
|
|
if((uint8_t)(val_res) == sent_crc4((uint8_t*)&sentTempNibblArr[ch][1], 6))
|
|
{
|
|
// if CRC is good commit packet value as official result
|
|
sentOpenThrottleVal = sentOpenTempVal;
|
|
sentClosedThrottleVal = sentClosedTempVal;
|
|
}
|
|
else
|
|
{
|
|
// Increment crc err count
|
|
sentCrcErrCnt++;
|
|
}
|
|
}
|
|
|
|
sentSMstate[ch] = SM_SENT_SYNC_STATE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const uint8_t CrcLookup[16] = {0, 13, 7, 10, 14, 3, 9, 4, 1, 12, 6, 11, 15, 2, 8, 5};
|
|
|
|
uint8_t sent_crc4(uint8_t* pdata, uint16_t ndata)
|
|
{
|
|
uint8_t calculatedCRC, i;
|
|
|
|
calculatedCRC = SENT_CRC_SEED; // initialize checksum with seed "0101"
|
|
|
|
for (i = 0; i < ndata; i++)
|
|
{
|
|
calculatedCRC = CrcLookup[calculatedCRC];
|
|
calculatedCRC = (calculatedCRC ^ pdata[i]) & 0x0F;
|
|
}
|
|
// One more round with 0 as input
|
|
//calculatedCRC = CrcLookup[calculatedCRC];
|
|
|
|
return calculatedCRC;
|
|
}
|
|
#pragma GCC pop_options
|
|
|
|
uint8_t SENT_IsRawData(void)
|
|
{
|
|
return sentRawData;
|
|
}
|
|
|
|
void SENT_SetRawDataProp(void)
|
|
{
|
|
sentRawData = 1;
|
|
}
|
|
|
|
void SENT_ResetRawDataProp(void)
|
|
{
|
|
sentRawData = 0;
|
|
}
|
|
|
|
uint16_t SENT_GetOpenThrottleVal(void)
|
|
{
|
|
return sentOpenThrottleVal;
|
|
}
|
|
|
|
uint16_t SENT_GetClosedThrottleVal(void)
|
|
{
|
|
return sentClosedThrottleVal;
|
|
}
|
|
|
|
uint32_t SENT_GetIntervalErr(void)
|
|
{
|
|
return sentIntervalErr;
|
|
}
|
|
|
|
void SENT_GetRawData(uint8_t* buf)
|
|
{
|
|
for(uint8_t i = 0; i < 8; i++)
|
|
{
|
|
buf[i] = sentTempNibblArr[1][i];
|
|
}
|
|
}
|
|
|
|
uint8_t SENT_GetThrottleValPrec(void)
|
|
{
|
|
return (100 - ((sentOpenThrottleVal - SENT_THROTTLE_OPEN_VAL) * 100)/(SENT_THROTTLE_CLOSE_VAL - SENT_THROTTLE_OPEN_VAL));
|
|
}
|
|
|
|
#endif
|
|
|
|
uint32_t SENT_GetRollErrCnt(void)
|
|
{
|
|
return sentRollErrCnt;
|
|
}
|
|
|
|
uint32_t SENT_GetCrcErrCnt(void)
|
|
{
|
|
return sentCrcErrCnt;
|
|
}
|
|
|
|
uint32_t SENT_GetMaxIntervalErrCnt(void)
|
|
{
|
|
return sentMaxIntervalErr;
|
|
}
|
|
|
|
uint32_t SENT_GetSyncErrCnt(void)
|
|
{
|
|
return sentSyncErr;
|
|
}
|
|
|
|
uint32_t SENT_GetSyncCnt(void)
|
|
{
|
|
return sentPulseCnt;
|
|
}
|
|
|
|
uint32_t SENT_GetErrPercent(void)
|
|
{
|
|
// cast float to int
|
|
return errorRate;
|
|
} |