Skip to content

Commit 575275a

Browse files
pierremolinaropierremolinaro
committed
better ack error reporting
1 parent b328b98 commit 575275a

File tree

1 file changed

+67
-66
lines changed

1 file changed

+67
-66
lines changed

‎src/CANMolinaroAnalyzer.cpp

Lines changed: 67 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -56,15 +56,15 @@ void CANMolinaroAnalyzer::WorkerThread () {
5656
mFrameFieldEngineState = IDLE ;
5757
mUnstuffingActive = false ;
5858
//--- Loop util the end of the frame (11 consecutive high bits)
59-
bool currentBitState = true ;
59+
bool currentBitValue = true ;
6060
do{
6161
mSerial->AdvanceToNextEdge () ;
62-
currentBitState ^= true ;
62+
currentBitValue ^= true ;
6363
const U64 start = mSerial->GetSampleNumber () ;
6464
const U64 nextEdge = mSerial->GetSampleOfNextEdge () ;
6565
const U64 bitCount = (nextEdge - start + samplesPerBit / 2) / samplesPerBit ;
6666
for (U64 i=0 ; i<bitCount ; i++) {
67-
enterBit (currentBitState, start + samplesPerBit / 2 + i * samplesPerBit) ;
67+
enterBit (currentBitValue, start + i * samplesPerBit + samplesPerBit / 2) ;
6868
}
6969
}while (mFrameFieldEngineState != IDLE) ;
7070
//---
@@ -126,80 +126,80 @@ void DestroyAnalyzer (Analyzer* analyzer) {
126126
// CAN FRAME DECODER
127127
//--------------------------------------------------------------------------------------------------
128128

129-
void CANMolinaroAnalyzer::enterBit (const bool inBit, const U64 inSampleNumber) {
129+
void CANMolinaroAnalyzer::enterBit (const bool inBitValue, const U64 inSampleNumber) {
130130
if (!mUnstuffingActive) {
131-
decodeFrameBit (inBit, inSampleNumber) ;
132-
}else if ((mConsecutiveBitCountOfSamePolarity == 5) && (inBit != mPreviousBit)) {
131+
decodeFrameBit (inBitValue, inSampleNumber) ;
132+
}else if ((mConsecutiveBitCountOfSamePolarity == 5) && (inBitValue != mPreviousBit)) {
133133
// Stuff bit - discarded
134134
addMark (inSampleNumber, AnalyzerResults::X);
135135
mConsecutiveBitCountOfSamePolarity = 1 ;
136-
mPreviousBit = inBit ;
136+
mPreviousBit = inBitValue ;
137137
mStuffBitCount += 1 ;
138-
}else if ((mConsecutiveBitCountOfSamePolarity == 5) && (mPreviousBit == inBit)) { // Stuff Error
138+
}else if ((mConsecutiveBitCountOfSamePolarity == 5) && (mPreviousBit == inBitValue)) { // Stuff Error
139139
addMark (inSampleNumber, AnalyzerResults::ErrorX);
140140
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
141141
enterInErrorMode (inSampleNumber + samplesPerBit / 2) ;
142142
mConsecutiveBitCountOfSamePolarity += 1 ;
143-
}else if (mPreviousBit == inBit) {
143+
}else if (mPreviousBit == inBitValue) {
144144
mConsecutiveBitCountOfSamePolarity += 1 ;
145-
decodeFrameBit (inBit, inSampleNumber) ;
145+
decodeFrameBit (inBitValue, inSampleNumber) ;
146146
}else{
147147
mConsecutiveBitCountOfSamePolarity = 1 ;
148-
mPreviousBit = inBit ;
149-
decodeFrameBit (inBit, inSampleNumber) ;
148+
mPreviousBit = inBitValue ;
149+
decodeFrameBit (inBitValue, inSampleNumber) ;
150150
}
151151
}
152152

153153
//--------------------------------------------------------------------------------------------------
154154

155-
void CANMolinaroAnalyzer::decodeFrameBit (const bool inBit, const U64 inSampleNumber) {
155+
void CANMolinaroAnalyzer::decodeFrameBit (const bool inBitValue, const U64 inSampleNumber) {
156156
switch (mFrameFieldEngineState) {
157157
case IDLE :
158-
handle_IDLE_state (inBit, inSampleNumber) ;
158+
handle_IDLE_state (inBitValue, inSampleNumber) ;
159159
break ;
160160
case IDENTIFIER :
161-
handle_IDENTIFIER_state (inBit, inSampleNumber) ;
161+
handle_IDENTIFIER_state (inBitValue, inSampleNumber) ;
162162
break ;
163163
case EXTENDED_IDF :
164-
handle_EXTENDED_IDF_state (inBit, inSampleNumber) ;
164+
handle_EXTENDED_IDF_state (inBitValue, inSampleNumber) ;
165165
break ;
166166
case CONTROL :
167-
handle_CONTROL_state (inBit, inSampleNumber) ;
167+
handle_CONTROL_state (inBitValue, inSampleNumber) ;
168168
break ;
169169
case DATA :
170-
handle_DATA_state (inBit, inSampleNumber) ;
170+
handle_DATA_state (inBitValue, inSampleNumber) ;
171171
break ;
172172
case CRC15 :
173-
handle_CRC15_state (inBit, inSampleNumber) ;
173+
handle_CRC15_state (inBitValue, inSampleNumber) ;
174174
break ;
175175
case CRC_DEL :
176-
handle_CRCDEL_state (inBit, inSampleNumber) ;
176+
handle_CRCDEL_state (inBitValue, inSampleNumber) ;
177177
break ;
178178
case ACK :
179-
handle_ACK_state (inBit, inSampleNumber) ;
179+
handle_ACK_state (inBitValue, inSampleNumber) ;
180180
break ;
181181
case END_OF_FRAME :
182-
handle_ENDOFFRAME_state (inBit, inSampleNumber) ;
182+
handle_ENDOFFRAME_state (inBitValue, inSampleNumber) ;
183183
break ;
184184
case INTERMISSION :
185-
handle_INTERMISSION_state (inBit, inSampleNumber) ;
185+
handle_INTERMISSION_state (inBitValue, inSampleNumber) ;
186186
break ;
187187
case DECODER_ERROR :
188-
handle_DECODER_ERROR_state (inBit, inSampleNumber) ;
188+
handle_DECODER_ERROR_state (inBitValue, inSampleNumber) ;
189189
break ;
190190
}
191191
}
192192

193193
//--------------------------------------------------------------------------------------------------
194194

195-
void CANMolinaroAnalyzer::handle_IDLE_state (const bool inBit, const U64 inSampleNumber) {
195+
void CANMolinaroAnalyzer::handle_IDLE_state (const bool inBitValue, const U64 inSampleNumber) {
196196
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
197-
if (!inBit) {
197+
if (!inBitValue) {
198198
mUnstuffingActive = true ;
199199
mCRC15Accumulator = 0 ;
200200
mConsecutiveBitCountOfSamePolarity = 1 ;
201201
mPreviousBit = false ;
202-
enterBitInCRC15 (inBit) ;
202+
enterBitInCRC15 (inBitValue) ;
203203
addMark (inSampleNumber, AnalyzerResults::Start) ;
204204
mFieldBitIndex = 0 ;
205205
mIdentifier = 0 ;
@@ -212,20 +212,20 @@ void CANMolinaroAnalyzer::handle_IDLE_state (const bool inBit, const U64 inSampl
212212

213213
//--------------------------------------------------------------------------------------------------
214214

215-
void CANMolinaroAnalyzer::handle_IDENTIFIER_state (const bool inBit, const U64 inSampleNumber) {
215+
void CANMolinaroAnalyzer::handle_IDENTIFIER_state (const bool inBitValue, const U64 inSampleNumber) {
216216
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
217-
enterBitInCRC15 (inBit) ;
217+
enterBitInCRC15 (inBitValue) ;
218218
mFieldBitIndex ++ ;
219219
if (mFieldBitIndex <= 11) { // Standard identifier
220220
addMark (inSampleNumber, AnalyzerResults::Dot);
221221
mIdentifier <<= 1 ;
222-
mIdentifier |= inBit ;
222+
mIdentifier |= inBitValue ;
223223
}else if (mFieldBitIndex == 12) { // RTR bit
224-
addMark (inSampleNumber, inBit ? AnalyzerResults::UpArrow : AnalyzerResults::DownArrow) ;
225-
mFrameType = inBit ? remoteFrame : dataFrame ;
224+
addMark (inSampleNumber, inBitValue ? AnalyzerResults::UpArrow : AnalyzerResults::DownArrow) ;
225+
mFrameType = inBitValue ? remoteFrame : dataFrame ;
226226
}else{ // IDE
227227
addMark (inSampleNumber, AnalyzerResults::Dot);
228-
if (inBit) {
228+
if (inBitValue) {
229229
mFrameFieldEngineState = EXTENDED_IDF ;
230230
mFieldBitIndex = 0 ;
231231
}else{
@@ -242,24 +242,24 @@ void CANMolinaroAnalyzer::handle_IDENTIFIER_state (const bool inBit, const U64 i
242242

243243
//--------------------------------------------------------------------------------------------------
244244

245-
void CANMolinaroAnalyzer::handle_EXTENDED_IDF_state (const bool inBit, const U64 inSampleNumber) {
245+
void CANMolinaroAnalyzer::handle_EXTENDED_IDF_state (const bool inBitValue, const U64 inSampleNumber) {
246246
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
247-
enterBitInCRC15 (inBit) ;
247+
enterBitInCRC15 (inBitValue) ;
248248
mFieldBitIndex ++ ;
249249
if (mFieldBitIndex <= 18) { // Extended identifier
250250
addMark (inSampleNumber, AnalyzerResults::Dot);
251251
mIdentifier <<= 1 ;
252-
mIdentifier |= inBit ;
252+
mIdentifier |= inBitValue ;
253253
}else if (mFieldBitIndex == 19) { // RTR bit
254-
addMark (inSampleNumber, inBit ? AnalyzerResults::UpArrow : AnalyzerResults::DownArrow) ;
255-
mFrameType = inBit ? remoteFrame : dataFrame ;
254+
addMark (inSampleNumber, inBitValue ? AnalyzerResults::UpArrow : AnalyzerResults::DownArrow) ;
255+
mFrameType = inBitValue ? remoteFrame : dataFrame ;
256256
}else{ // R1: should be dominant
257-
addMark (inSampleNumber, inBit ? AnalyzerResults::ErrorX : AnalyzerResults::Zero) ;
257+
addMark (inSampleNumber, inBitValue ? AnalyzerResults::ErrorX : AnalyzerResults::Zero) ;
258258
addBubble (EXTENDED_IDENTIFIER_FIELD_RESULT,
259259
mIdentifier,
260260
mFrameType == dataFrame, // 0 -> remote, 1 -> data
261261
inSampleNumber - samplesPerBit / 2) ;
262-
if (inBit) {
262+
if (inBitValue) {
263263
enterInErrorMode (inSampleNumber + samplesPerBit / 2) ;
264264
}else{
265265
mFrameFieldEngineState = CONTROL ;
@@ -271,19 +271,19 @@ void CANMolinaroAnalyzer::handle_EXTENDED_IDF_state (const bool inBit, const U64
271271

272272
//--------------------------------------------------------------------------------------------------
273273

274-
void CANMolinaroAnalyzer::handle_CONTROL_state (const bool inBit, const U64 inSampleNumber) {
274+
void CANMolinaroAnalyzer::handle_CONTROL_state (const bool inBitValue, const U64 inSampleNumber) {
275275
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
276-
enterBitInCRC15 (inBit) ;
276+
enterBitInCRC15 (inBitValue) ;
277277
mFieldBitIndex ++ ;
278278
if (mFieldBitIndex == 2) { // R0
279-
addMark (inSampleNumber, inBit ? AnalyzerResults::ErrorX : AnalyzerResults::Zero) ;
280-
if (inBit) {
279+
addMark (inSampleNumber, inBitValue ? AnalyzerResults::ErrorX : AnalyzerResults::Zero) ;
280+
if (inBitValue) {
281281
enterInErrorMode (inSampleNumber + samplesPerBit / 2) ;
282282
}
283283
}else{
284284
addMark (inSampleNumber, AnalyzerResults::Dot);
285285
mDataCodeLength <<= 1 ;
286-
mDataCodeLength |= inBit ;
286+
mDataCodeLength |= inBitValue ;
287287
if (mFieldBitIndex == 6) {
288288
addBubble (CONTROL_FIELD_RESULT, mDataCodeLength, 0, inSampleNumber + samplesPerBit / 2) ;
289289
mFieldBitIndex = 0 ;
@@ -301,12 +301,12 @@ void CANMolinaroAnalyzer::handle_CONTROL_state (const bool inBit, const U64 inSa
301301

302302
//--------------------------------------------------------------------------------------------------
303303

304-
void CANMolinaroAnalyzer::handle_DATA_state (const bool inBit, const U64 inSampleNumber) {
304+
void CANMolinaroAnalyzer::handle_DATA_state (const bool inBitValue, const U64 inSampleNumber) {
305305
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
306-
enterBitInCRC15 (inBit) ;
306+
enterBitInCRC15 (inBitValue) ;
307307
addMark (inSampleNumber, AnalyzerResults::Dot);
308308
mData [mFieldBitIndex / 8] <<= 1 ;
309-
mData [mFieldBitIndex / 8] |= inBit ;
309+
mData [mFieldBitIndex / 8] |= inBitValue ;
310310
mFieldBitIndex ++ ;
311311
if ((mFieldBitIndex % 8) == 0) {
312312
const U32 dataIndex = (mFieldBitIndex - 1) / 8 ;
@@ -321,9 +321,9 @@ void CANMolinaroAnalyzer::handle_DATA_state (const bool inBit, const U64 inSampl
321321

322322
//--------------------------------------------------------------------------------------------------
323323

324-
void CANMolinaroAnalyzer::handle_CRC15_state (const bool inBit, const U64 inSampleNumber) {
324+
void CANMolinaroAnalyzer::handle_CRC15_state (const bool inBitValue, const U64 inSampleNumber) {
325325
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
326-
enterBitInCRC15 (inBit) ;
326+
enterBitInCRC15 (inBitValue) ;
327327
addMark (inSampleNumber, AnalyzerResults::Dot);
328328
mFieldBitIndex ++ ;
329329
if (mFieldBitIndex == 15) {
@@ -338,10 +338,10 @@ void CANMolinaroAnalyzer::handle_CRC15_state (const bool inBit, const U64 inSamp
338338

339339
//--------------------------------------------------------------------------------------------------
340340

341-
void CANMolinaroAnalyzer::handle_CRCDEL_state (const bool inBit, const U64 inSampleNumber) {
341+
void CANMolinaroAnalyzer::handle_CRCDEL_state (const bool inBitValue, const U64 inSampleNumber) {
342342
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
343343
mUnstuffingActive = false ;
344-
if (inBit) {
344+
if (inBitValue) {
345345
addMark (inSampleNumber, AnalyzerResults::One) ;
346346
}else{
347347
enterInErrorMode (inSampleNumber) ;
@@ -352,28 +352,29 @@ void CANMolinaroAnalyzer::handle_CRCDEL_state (const bool inBit, const U64 inSam
352352

353353
//--------------------------------------------------------------------------------------------------
354354

355-
void CANMolinaroAnalyzer::handle_ACK_state (const bool inBit, const U64 inSampleNumber) {
355+
void CANMolinaroAnalyzer::handle_ACK_state (const bool inBitValue, const U64 inSampleNumber) {
356356
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
357357
mFieldBitIndex ++ ;
358358
if (mFieldBitIndex == 1) { // ACK SLOT
359-
addMark (inSampleNumber, inBit ? AnalyzerResults::ErrorSquare : AnalyzerResults::DownArrow);
359+
addMark (inSampleNumber, inBitValue ? AnalyzerResults::ErrorSquare : AnalyzerResults::DownArrow);
360360
}else{ // ACK DELIMITER
361361
addBubble (ACK_FIELD_RESULT, 0, 0, inSampleNumber + samplesPerBit / 2) ;
362-
if (inBit) {
362+
mFrameFieldEngineState = END_OF_FRAME ;
363+
if (inBitValue) {
363364
addMark (inSampleNumber, AnalyzerResults::One) ;
364365
}else{
366+
addMark (inSampleNumber, AnalyzerResults::ErrorDot) ;
365367
enterInErrorMode (inSampleNumber) ;
366368
}
367369
mFieldBitIndex = 0 ;
368-
mFrameFieldEngineState = END_OF_FRAME ;
369370
}
370371
}
371372

372373
//--------------------------------------------------------------------------------------------------
373374

374-
void CANMolinaroAnalyzer::handle_ENDOFFRAME_state (const bool inBit, const U64 inSampleNumber) {
375+
void CANMolinaroAnalyzer::handle_ENDOFFRAME_state (const bool inBitValue, const U64 inSampleNumber) {
375376
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
376-
if (inBit) {
377+
if (inBitValue) {
377378
addMark (inSampleNumber, AnalyzerResults::One) ;
378379
}else{
379380
enterInErrorMode (inSampleNumber) ;
@@ -388,9 +389,9 @@ void CANMolinaroAnalyzer::handle_ENDOFFRAME_state (const bool inBit, const U64 i
388389

389390
//--------------------------------------------------------------------------------------------------
390391

391-
void CANMolinaroAnalyzer::handle_INTERMISSION_state (const bool inBit, const U64 inSampleNumber) {
392+
void CANMolinaroAnalyzer::handle_INTERMISSION_state (const bool inBitValue, const U64 inSampleNumber) {
392393
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
393-
if (inBit) {
394+
if (inBitValue) {
394395
addMark (inSampleNumber, AnalyzerResults::One) ;
395396
}else{
396397
enterInErrorMode (inSampleNumber) ;
@@ -409,14 +410,14 @@ void CANMolinaroAnalyzer::handle_INTERMISSION_state (const bool inBit, const U64
409410

410411
//--------------------------------------------------------------------------------------------------
411412

412-
void CANMolinaroAnalyzer::handle_DECODER_ERROR_state (const bool inBit, const U64 inSampleNumber) {
413+
void CANMolinaroAnalyzer::handle_DECODER_ERROR_state (const bool inBitValue, const U64 inSampleNumber) {
413414
const U32 samplesPerBit = mSampleRateHz / mSettings->mBitRate ;
414415
mUnstuffingActive = false ;
415416
addMark (inSampleNumber, AnalyzerResults::ErrorDot);
416-
if (mPreviousBit != inBit) {
417+
if (mPreviousBit != inBitValue) {
417418
mConsecutiveBitCountOfSamePolarity = 1 ;
418-
mPreviousBit = inBit ;
419-
}else if (inBit) {
419+
mPreviousBit = inBitValue ;
420+
}else if (inBitValue) {
420421
mConsecutiveBitCountOfSamePolarity += 1 ;
421422
if (mConsecutiveBitCountOfSamePolarity == 11) {
422423
addBubble (CAN_ERROR_RESULT, 0, 0, inSampleNumber + samplesPerBit / 2) ;
@@ -427,9 +428,9 @@ void CANMolinaroAnalyzer::handle_DECODER_ERROR_state (const bool inBit, const U6
427428

428429
//--------------------------------------------------------------------------------------------------
429430

430-
void CANMolinaroAnalyzer::enterBitInCRC15 (const bool inBit) {
431+
void CANMolinaroAnalyzer::enterBitInCRC15 (const bool inBitValue) {
431432
const bool bit14 = (mCRC15Accumulator & (1 << 14)) != 0 ;
432-
const bool crc_nxt = inBit ^ bit14 ;
433+
const bool crc_nxt = inBitValue ^ bit14 ;
433434
mCRC15Accumulator <<= 1 ;
434435
mCRC15Accumulator &= 0x7FFF ;
435436
if (crc_nxt) {

0 commit comments

Comments
 (0)