#include <sent_logic.h>

Collaboration diagram for sent_channel:

[legend]

Public Member Functions
int	Decoder (uint32_t clocks, uint8_t flags=0)

int	GetMsg (uint32_t *rx)

int	GetSignals (uint8_t pStat, uint16_t pSig0, uint16_t *pSig1)

int	GetSlowChannelValue (uint8_t id)

float	getTickTime ()

void	Info ()

Data Fields
struct {
uint16_t data

uint8_t id

}	scMsg [SENT_SLOW_CHANNELS_MAX]

sent_channel_stat	statistic

Private Member Functions
int	StoreSlowChannelValue (uint8_t id, uint16_t data)

int	FastChannelDecoder (uint32_t clocks)

int	SlowChannelDecoder ()

void	SlowChannelDecoderReset ()

uint8_t	crc4 (uint32_t data)

uint8_t	crc4_gm (uint32_t data)

uint8_t	crc4_gm_v2 (uint32_t data)

uint8_t	crc6 (uint32_t data)

void	calcTickPerUnit (uint32_t clocks)

bool	isSyncPulse (uint32_t clocks)

void	restart ()

Private Attributes
SENT_STATE_enum	state = SENT_STATE_CALIB

uint32_t	tickPerUnit = 0

uint32_t	pulseCounter = 0

uint32_t	currentStatePulseCounter = 0

bool	pausePulseReceived = false

uint32_t	rxReg

bool	hasValidFast = false

uint32_t	rxLast

uint16_t	scMsgFlags

uint32_t	scShift2

uint32_t	scShift3

uint32_t	scCrcShift

Detailed Description

Definition at line 56 of file sent_logic.h.

Member Function Documentation

◆ calcTickPerUnit()

void sent_channel::calcTickPerUnit ( uint32_t clocks )

private

Definition at line 88 of file sent.cpp.

                                                   {
     /* int division with rounding */
     tickPerUnit =  (clocks + (SENT_SYNC_INTERVAL + SENT_OFFSET_INTERVAL) / 2) /
             (SENT_SYNC_INTERVAL + SENT_OFFSET_INTERVAL);
 }

Referenced by FastChannelDecoder().

Here is the caller graph for this function:

◆ crc4()

uint8_t sent_channel::crc4 ( uint32_t data )

private

Definition at line 479 of file sent.cpp.

 {
     size_t i;
     uint8_t crc = SENT_CRC_SEED; // initialize checksum with seed "0101"
     const uint8_t CrcLookup[16] = {0, 13, 7, 10, 14, 3, 9, 4, 1, 12, 6, 11, 15, 2, 8, 5};
  
     for (i = 0; i < 7; i++) {
         crc = crc ^ MsgGetNibble(data, i);
         crc = CrcLookup[crc];
     }
  
     return crc;
 }

Referenced by FastChannelDecoder().

Here is the caller graph for this function:

◆ crc4_gm()

uint8_t sent_channel::crc4_gm ( uint32_t data )

private

Definition at line 497 of file sent.cpp.

 {
     size_t i;
     uint8_t crc = SENT_CRC_SEED; // initialize checksum with seed "0101"
     const uint8_t CrcLookup[16] = {0, 13, 7, 10, 14, 3, 9, 4, 1, 12, 6, 11, 15, 2, 8, 5};
  
     for (i = 1; i < 7; i++) {
         crc = CrcLookup[crc];
         crc = (crc ^ MsgGetNibble(data, i)) & 0xf;
     }
  
     return crc;
 }

Referenced by FastChannelDecoder().

Here is the caller graph for this function:

◆ crc4_gm_v2()

uint8_t sent_channel::crc4_gm_v2 ( uint32_t data )

private

Definition at line 513 of file sent.cpp.

 {
     size_t i;
     uint8_t crc = SENT_CRC_SEED; // initialize checksum with seed "0101"
     const uint8_t CrcLookup[16] = {0, 13, 7, 10, 14, 3, 9, 4, 1, 12, 6, 11, 15, 2, 8, 5};
  
     for (i = 1; i < 7; i++) {
         crc = CrcLookup[crc];
         crc = (crc ^ MsgGetNibble(data, i)) & 0xf;
     }
     // One more round with 0 as input
     crc = CrcLookup[crc];
  
     return crc;
 }

Referenced by FastChannelDecoder().

Here is the caller graph for this function:

◆ crc6()

uint8_t sent_channel::crc6 ( uint32_t data )

private

Definition at line 529 of file sent.cpp.

 {
     size_t i;
     /* Seed 0x15 (21) */
     uint8_t crc = 0x15;
     /* CRC table for poly = 0x59 (x^6 + x^4 + x^3 + 1) */
     const uint8_t crc6_table[64] = {
          0, 25, 50, 43, 61, 36, 15, 22, 35, 58, 17,  8, 30,  7, 44, 53,
         31,  6, 45, 52, 34, 59, 16,  9, 60, 37, 14, 23,  1, 24, 51, 42,
         62, 39, 12, 21,  3, 26, 49, 40, 29,  4, 47, 54, 32, 57, 18, 11,
         33, 56, 19, 10, 28,  5, 46, 55,  2, 27, 48, 41, 63, 38, 13, 20 };
  
     for (i = 0; i < 4; i++) {
         uint8_t tmp = (data >> (24 - 6 * (i + 1))) & 0x3f;
         crc = tmp ^ crc6_table[crc];
     }
     // Extra round with 0 input
     crc = 0 ^ crc6_table[crc];
  
     return crc;
 }

Referenced by SlowChannelDecoder().

Here is the caller graph for this function:

◆ Decoder()

int sent_channel::Decoder	(	uint32_t	clocks,
		uint8_t	flags = `0`
	)

Definition at line 294 of file sent.cpp.

                                                         {
     int ret;
  
     #if SENT_STATISTIC_COUNTERS
         if (flags & SENT_FLAG_HW_OVERFLOW) {
             statistic.hwOverflowCnt++;
         }
     #endif
  
     /* TODO: handle flags */
     (void)flags;
  
     ret = FastChannelDecoder(clocks);
     if (ret > 0) {
         /* valid packet received, can process slow channels */
         SlowChannelDecoder();
     } else if (ret < 0) {
         /* packet is incorrect, reset slow channel state machine */
         SlowChannelDecoderReset();
     }
  
     return ret;
 }

Here is the call graph for this function:

◆ FastChannelDecoder()

int sent_channel::FastChannelDecoder ( uint32_t clocks )

private

Definition at line 110 of file sent.cpp.

                                                     {
     pulseCounter++;
  
     /* special case - tick time calculation */
     if (state == SENT_STATE_CALIB) {
         if ((tickPerUnit == 0) || (currentStatePulseCounter == 0)) {
             /* invalid or not yet calculated tickPerUnit */
             calcTickPerUnit(clocks);
             /* lets assume this is sync pulse... */
             currentStatePulseCounter = 1;
         } else {
             /* some tickPerUnit calculated...
              * Check next 1 + 6 + 1 pulses if they are valid with current tickPerUnit */
             criticalAssert(tickPerUnit != 0, "zero tickPerUnit", 0);
             int checkInterval = (clocks + tickPerUnit / 2) / tickPerUnit - SENT_OFFSET_INTERVAL;
             if ((checkInterval >= 0) && (checkInterval <= SENT_MAX_INTERVAL)) {
                 currentStatePulseCounter++;
                 /* Should end up with CRC pulse */
                 if (currentStatePulseCounter == (1 + SENT_MSG_PAYLOAD_SIZE)) {
                     pulseCounter = 0;
                     currentStatePulseCounter = 0;
                     state = SENT_STATE_INIT;
                 }
             } else {
                 currentStatePulseCounter = 1;
                 calcTickPerUnit(clocks);
             }
         }
         if (pulseCounter >= SENT_CALIBRATION_PULSES) {
             /* failed to calculate valid tickPerUnit, restart */
             restart();
         }
         return 0;
     }
  
     /* special case for out-of-sync state */
     if (state == SENT_STATE_INIT) {
         if (isSyncPulse(clocks)) {
             /* adjust unit time */
             calcTickPerUnit(clocks);
             /* we get here from calibration phase. calibration phase end with CRC nibble
              * if we had to skip ONE pulse before we get sync - that means device may send pause
              * pulse in between of messages */
             pausePulseReceived = false;
             if (currentStatePulseCounter == 1) {
                 pausePulseReceived = true;
             }
             /* next state */
             currentStatePulseCounter = 0;
             state = SENT_STATE_STATUS;
         } else {
             currentStatePulseCounter++;
             /* 3 frames skipped, no SYNC detected - recalibrate */
             if (currentStatePulseCounter >= (SENT_MSG_TOTAL * 3)) {
                 restart();
             }
         }
         /* done for this pulse */
         return 0;
     }
  
     int interval = (clocks + tickPerUnit / 2) / tickPerUnit - SENT_OFFSET_INTERVAL;
  
     if (interval < 0) {
         #if SENT_STATISTIC_COUNTERS
             statistic.ShortIntervalErr++;
         #endif //SENT_STATISTIC_COUNTERS
         state = SENT_STATE_INIT;
         return -1;
     }
  
     switch(state)
     {
         case SENT_STATE_CALIB:
         case SENT_STATE_INIT:
             /* handled above, should not get in here */
             return -1;
  
         case SENT_STATE_SYNC:
             if (isSyncPulse(clocks))
             {
                 /* measured tick interval will be used until next sync pulse */
                 calcTickPerUnit(clocks);
                 rxReg = 0;
                 state = SENT_STATE_STATUS;
             }
             else
             {
                 if (pausePulseReceived) {
                     #if SENT_STATISTIC_COUNTERS
                         // Increment sync interval err count
                         statistic.SyncErr++;
                         if (interval > SENT_SYNC_INTERVAL)
                         {
                             statistic.LongIntervalErr++;
                         }
                         else
                         {
                             statistic.ShortIntervalErr++;
                         }
                     #endif // SENT_STATISTIC_COUNTERS
                     /* wait for next sync and recalibrate tickPerUnit */
                     state = SENT_STATE_INIT;
                     return -1;
                 } else {
                     /* This is possibly pause pulse */
                     /* TODO: check:
                      * Minimum Length 12 ticks (equivalent to a nibble with 0 value) - this is already checked
                      * Maximum Length 768 ticks (3 * 256) */
                     #if SENT_STATISTIC_COUNTERS
                         statistic.PauseCnt++;
                     #endif // SENT_STATISTIC_COUNTERS
                     pausePulseReceived = true;
                 }
             }
             return 0;
  
         case SENT_STATE_STATUS:
             /* it is possible that pause pulse was threaded as sync and we are here with sync pulse */
             if ((pausePulseReceived == false) && isSyncPulse(clocks)) {
                 #if SENT_STATISTIC_COUNTERS
                     statistic.PauseCnt++;
                 #endif // SENT_STATISTIC_COUNTERS
                 /* measured tick interval will be used until next sync pulse */
                 calcTickPerUnit(clocks);
                 return 0;
             }
             // fallthrough
         case SENT_STATE_SIG1_DATA1:
         case SENT_STATE_SIG1_DATA2:
         case SENT_STATE_SIG1_DATA3:
         case SENT_STATE_SIG2_DATA1:
         case SENT_STATE_SIG2_DATA2:
         case SENT_STATE_SIG2_DATA3:
         case SENT_STATE_CRC:
             if (interval > SENT_MAX_INTERVAL)
             {
                 #if SENT_STATISTIC_COUNTERS
                     statistic.LongIntervalErr++;
                 #endif
  
                 state = SENT_STATE_INIT;
                 return -1;
             }
  
             rxReg = (rxReg << 4) | (uint32_t)interval;
  
             if (state != SENT_STATE_CRC)
             {
                 /* TODO: refactor */
                 state = (SENT_STATE_enum)((int)state + 1);
                 return 0;
             }
  
             #if SENT_STATISTIC_COUNTERS
                 statistic.FrameCnt++;
             #endif // SENT_STATISTIC_COUNTERS
             pausePulseReceived = false;
             state = SENT_STATE_SYNC;
             /* CRC check */
             /* TODO: find correct way to calculate CRC */
             if ((MsgGetCrc(rxReg) == crc4(rxReg)) ||
                 (MsgGetCrc(rxReg) == crc4_gm(rxReg)) ||
                 (MsgGetCrc(rxReg) == crc4_gm_v2(rxReg)))
             {
                 /* Full packet with correct CRC has been received */
                 rxLast = rxReg;
                 hasValidFast = true;
                 /* TODO: add timestamp? */
                 return 1;
             }
             else
             {
                 #if SENT_STATISTIC_COUNTERS
                     statistic.CrcErrCnt++;
                 #endif // SENT_STATISTIC_COUNTERS
                 return -1;
             }
             return 0;
     }
  
     return 0;
 }

Referenced by Decoder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetMsg()

int sent_channel::GetMsg ( uint32_t * rx )

Definition at line 318 of file sent.cpp.

                                      {
     if (rx) {
         *rx = rxLast;
     }
  
     if (!hasValidFast) {
         return -1;
     }
     /* TODO: add check for time since last message received */
     return 0;
 }

Referenced by GetSignals().

Here is the caller graph for this function:

◆ GetSignals()

int sent_channel::GetSignals	(	uint8_t *	pStat,
		uint16_t *	pSig0,
		uint16_t *	pSig1
	)

Definition at line 330 of file sent.cpp.

                                                                              {
     uint32_t rx;
     int ret = GetMsg(&rx);
  
     if (ret < 0) {
         return ret;
     }
  
     /* NOTE different MSB packing for sig0 and sig1
      * is it protocol-defined or device-specific?
      * Also looks like some devices send 16 + 8 bit, not 12 + 12 */
     if (pStat) {
         *pStat = MsgGetStat(rx);
     }
  
     if (pSig0) {
         uint16_t tmp = MsgGetSig0(rx);
         *pSig0 = tmp;
     }
  
     if (pSig1) {
         uint16_t tmp = MsgGetSig1(rx);
         /* swap */
         tmp =   ((tmp >> 8) & 0x00f) |
                 ((tmp << 8) & 0xf00) |
                 (tmp & 0x0f0);
         *pSig1 = tmp;
     }
  
     return 0;
 }

Referenced by Info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSlowChannelValue()

int sent_channel::GetSlowChannelValue ( uint8_t id )

Definition at line 389 of file sent.cpp.

 {
     size_t i;
  
     for (i = 0; i < SENT_SLOW_CHANNELS_MAX; i++) {
         if ((scMsgFlags & BIT(i)) && (scMsg[i].id == id)) {
             return scMsg[i].data;
         }
     }
  
     /* not found */
     return -1;
 }

◆ getTickTime()

float sent_channel::getTickTime ( )

Definition at line 94 of file sent.cpp.

                                 {
     return tickPerUnit;
 }

Referenced by Info().

Here is the caller graph for this function:

◆ Info()

void sent_channel::Info ( )

Definition at line 559 of file sent.cpp.

                         {
     uint8_t stat;
     uint16_t sig0, sig1;
  
     efiPrintf("Unit time %lu CPU ticks %f uS", tickPerUnit, TicksToUs(getTickTime()));
     efiPrintf("Pause pulse detected %s", pausePulseReceived ? "Yes" : "No");
     efiPrintf("Total pulses %lu", pulseCounter);
  
     if (GetSignals(&stat, &sig0, &sig1) == 0) {
         efiPrintf("Last valid fast msg Status 0x%01x Sig0 0x%03x Sig1 0x%03x", stat, sig0, sig1);
     }
  
     if (scMsgFlags) {
         efiPrintf("Slow channels:");
         for (int i = 0; i < SENT_SLOW_CHANNELS_MAX; i++) {
             if (scMsgFlags & BIT(i)) {
                 efiPrintf(" ID %d: %d", scMsg[i].id, scMsg[i].data);
             }
         }
     }
  
     #if SENT_STATISTIC_COUNTERS
         efiPrintf("HW overflows %lu\n", statistic.hwOverflowCnt);
  
         efiPrintf("Pause pulses %lu\n", statistic.PauseCnt);
         efiPrintf("Restarts %lu", statistic.RestartCnt);
         efiPrintf("Interval errors %lu short, %lu long", statistic.ShortIntervalErr, statistic.LongIntervalErr);
         efiPrintf("Total frames %lu with CRC error %lu (%f%%)", statistic.FrameCnt, statistic.CrcErrCnt, statistic.CrcErrCnt * 100.0 / statistic.FrameCnt);
         efiPrintf("Total slow channel messages %lu with crc6 errors %lu (%f%%)", statistic.sc, statistic.scCrcErr, statistic.scCrcErr * 100.0 / statistic.sc);
         efiPrintf("Sync errors %lu", statistic.SyncErr);
     #endif
 }

Here is the call graph for this function:

◆ isSyncPulse()

bool sent_channel::isSyncPulse ( uint32_t clocks )

private

Definition at line 98 of file sent.cpp.

 {
     /* check if pulse looks like sync with allowed +/-20% deviation */
     uint32_t syncClocks = (SENT_SYNC_INTERVAL + SENT_OFFSET_INTERVAL) * tickPerUnit;
  
     if (((100 * clocks) >= (syncClocks * 80)) &&
         ((100 * clocks) <= (syncClocks * 120)))
         return 1;
  
     return 0;
 }

Referenced by FastChannelDecoder().

Here is the caller graph for this function:

◆ restart()

void sent_channel::restart ( )

private

Definition at line 64 of file sent.cpp.

                            {
     state = SENT_STATE_CALIB;
     pulseCounter = 0;
     currentStatePulseCounter = 0;
     pausePulseReceived = false;
     tickPerUnit = 0;
  
     /* reset slow channels */
     SlowChannelDecoderReset();
     scMsgFlags = 0;
  
     #if SENT_STATISTIC_COUNTERS
         statistic.ShortIntervalErr = 0;
         statistic.LongIntervalErr = 0;
         statistic.SyncErr = 0;
         statistic.CrcErrCnt = 0;
         statistic.FrameCnt = 0;
         statistic.PauseCnt = 0;
         statistic.sc = 0;
         statistic.scCrcErr = 0;
         statistic.RestartCnt++;
     #endif
 }

Referenced by FastChannelDecoder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SlowChannelDecoder()

int sent_channel::SlowChannelDecoder ( )

private

Definition at line 403 of file sent.cpp.

 {
     /* bit 2 and bit 3 from status nibble are used to transfer short messages */
     bool b2 = !!(MsgGetStat(rxLast) & BIT(2));
     bool b3 = !!(MsgGetStat(rxLast) & BIT(3));
  
     /* shift in new data */
     scShift2 = (scShift2 << 1) | b2;
     scShift3 = (scShift3 << 1) | b3;
     scCrcShift = (scCrcShift << 2) | ((uint32_t)b2 << 1) | b3;
  
     if (1) {
         /* Short Serial Message format */
  
         /* 0b1000.0000.0000.0000? */
         if ((scShift3 & 0xffff) == 0x8000) {
             /* Done receiving */
  
             /* TODO: add crc check */
  
             uint8_t id = (scShift2 >> 12) & 0x0f;
             uint16_t data = (scShift2 >> 4) & 0xff;
  
             return StoreSlowChannelValue(id, data);
         }
     }
     if (1) {
         /* Enhanced Serial Message format */
  
         /* 0b11.1111.0xxx.xx0x.xxx0 ? */
         if ((scShift3 & 0x3f821) == 0x3f000) {
             uint8_t id;
  
             uint8_t crc = (scShift2 >> 12) & 0x3f;
             #if SENT_STATISTIC_COUNTERS
                 statistic.sc++;
             #endif
             if (crc == crc6(scCrcShift)) {
                 /* C-flag: configuration bit is used to indicate 16 bit format */
                 bool sc16Bit = !!(scShift3 & (1 << 10));
                 if (!sc16Bit) {
                     /* 12 bit message, 8 bit ID */
                     id = ((scShift3 >> 1) & 0x0f) |
                          ((scShift3 >> 2) & 0xf0);
                     uint16_t data = scShift2 & 0x0fff; /* 12 bit */
  
                     /* TODO: add crc check */
                     return StoreSlowChannelValue(id, data);
                 } else {
                     /* 16 bit message, 4 bit ID */
                     id = (scShift3 >> 6) & 0x0f;
                     uint16_t data = (scShift2 & 0x0fff) |
                            (((scShift3 >> 1) & 0x0f) << 12);
  
                     return StoreSlowChannelValue(id, data);
                 }
             } else {
                 #if SENT_STATISTIC_COUNTERS
                     statistic.scCrcErr++;
                 #endif
             }
         }
     }
  
     return 0;
 }

Referenced by Decoder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SlowChannelDecoderReset()

void sent_channel::SlowChannelDecoderReset ( )

private

Definition at line 470 of file sent.cpp.

 {
     /* packet is incorrect, reset slow channel state machine */
     scShift2 = 0;
     scShift3 = 0;
 }

Referenced by Decoder(), and restart().

Here is the caller graph for this function:

◆ StoreSlowChannelValue()

int sent_channel::StoreSlowChannelValue	(	uint8_t	id,
		uint16_t	data
	)

private

Definition at line 362 of file sent.cpp.

 {
     size_t i;
  
     /* Update already allocated messagebox? */
     for (i = 0; i < SENT_SLOW_CHANNELS_MAX; i++) {
         if ((scMsgFlags & BIT(i)) && (scMsg[i].id == id)) {
             scMsg[i].data = data;
             return 0;
         }
     }
  
     /* New message? Allocate messagebox */
     for (i = 0; i < SENT_SLOW_CHANNELS_MAX; i++) {
         if (!(scMsgFlags & BIT(i)))
          {
             scMsg[i].data = data;
             scMsg[i].id = id;
             scMsgFlags |= (1 << i);
             return 0;
         }
     }
  
     /* No free mailboxes for new ID */
     return -1;
 }