RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-04-02 02:19:57 +08:00
Code Issues Projects Releases Packages Wiki Activity

CHG: data plot- the marking of clock, looks better without borders. It only connected to ASK. STT mark also looks better.

Browse source 
Still problem with finding the startindex...
This commit is contained in:
iceman1001 2017-03-02 21:00:51 +01:00
parent a47ded5b54
commit c6e5c7ea46
4 changed files with 103 additions and 93 deletions

74
client/graph.c
View file

@ -20,30 +20,27 @@ int GraphTraceLen;
/* write a manchester bit to the graph */ /* write a manchester bit to the graph */
void AppendGraph(int redraw, int clock, int bit) void AppendGraph(int redraw, int clock, int bit)
{ {
int i; int i;
//set first half the clock bit (all 1's or 0's for a 0 or 1 bit) //set first half the clock bit (all 1's or 0's for a 0 or 1 bit)
for (i = 0; i < (int)(clock / 2); ++i) for (i = 0; i < (int)(clock / 2); ++i)
GraphBuffer[GraphTraceLen++] = bit ; GraphBuffer[GraphTraceLen++] = bit ;
//set second half of the clock bit (all 0's or 1's for a 0 or 1 bit) //set second half of the clock bit (all 0's or 1's for a 0 or 1 bit)
for (i = (int)(clock / 2); i < clock; ++i) for (i = (int)(clock / 2); i < clock; ++i)
GraphBuffer[GraphTraceLen++] = bit ^ 1; GraphBuffer[GraphTraceLen++] = bit ^ 1;
if (redraw) if (redraw)
RepaintGraphWindow(); RepaintGraphWindow();
} }
// clear out our graph window // clear out our graph window
int ClearGraph(int redraw) int ClearGraph(int redraw)
{ {
int gtl = GraphTraceLen; int gtl = GraphTraceLen;
memset(GraphBuffer, 0x00, GraphTraceLen); memset(GraphBuffer, 0x00, GraphTraceLen);
GraphTraceLen = 0;
GraphTraceLen = 0; if (redraw)
RepaintGraphWindow();
if (redraw) return gtl;
RepaintGraphWindow();
return gtl;
} }
// option '1' to save GraphBuffer any other to restore // option '1' to save GraphBuffer any other to restore
void save_restoreGB(uint8_t saveOpt) void save_restoreGB(uint8_t saveOpt)
@ -70,14 +67,15 @@ void setGraphBuf(uint8_t *buff, size_t size)
{ {
if ( buff == NULL ) return; if ( buff == NULL ) return;
uint16_t i = 0; ClearGraph(0);
if ( size > MAX_GRAPH_TRACE_LEN ) if ( size > MAX_GRAPH_TRACE_LEN )
size = MAX_GRAPH_TRACE_LEN; size = MAX_GRAPH_TRACE_LEN;
ClearGraph(0);
for (; i < size; ++i){ for (uint16_t i = 0; i < size; ++i)
GraphBuffer[i]=buff[i]-128; GraphBuffer[i] = buff[i] - 128;
}
GraphTraceLen=size; GraphTraceLen = size;
RepaintGraphWindow(); RepaintGraphWindow();
return; return;
} }
@ -85,10 +83,10 @@ size_t getFromGraphBuf(uint8_t *buff)
{ {
if (buff == NULL ) return 0; if (buff == NULL ) return 0;
uint32_t i; uint32_t i;
for (i=0;i<GraphTraceLen;++i){ for (i=0; i < GraphTraceLen; ++i){
if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim if (GraphBuffer[i] > 127) GraphBuffer[i] = 127; //trim
if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim if (GraphBuffer[i] < -127) GraphBuffer[i] = -127; //trim
buff[i]=(uint8_t)(GraphBuffer[i]+128); buff[i] = (uint8_t)(GraphBuffer[i]+128);
} }
return i; return i;
} }
@ -133,8 +131,8 @@ int GetAskClock(const char str[], bool printAns, bool verbose)
if (!strcmp(str, "")) if (!strcmp(str, ""))
clock = 0; clock = 0;
if (clock != 0) if (clock != 0) return clock;
return clock;
// Auto-detect clock // Auto-detect clock
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
size_t size = getFromGraphBuf(grph); size_t size = getFromGraphBuf(grph);
@ -145,15 +143,12 @@ int GetAskClock(const char str[], bool printAns, bool verbose)
} }
bool st = DetectST(grph, &size, &clock); bool st = DetectST(grph, &size, &clock);
int start = 0; int start = 0;
if (st == false) { if (st == false)
start = DetectASKClock(grph, size, &clock, 20); start = DetectASKClock(grph, size, &clock, 20);
}
// Only print this message if we're not looping something // Only print this message if we're not looping something
if (printAns){ if (printAns)
PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start); PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start);
}
PlotClock = clock;
PlockClockStartIndex = start;
return clock; return clock;
} }
@ -193,9 +188,6 @@ int GetPskClock(const char str[], bool printAns, bool verbose)
clock = DetectPSKClock(grph, size, 0); clock = DetectPSKClock(grph, size, 0);
// Only print this message if we're not looping something // Only print this message if we're not looping something
if (printAns) PrintAndLog("Auto-detected clock rate: %d", clock); if (printAns) PrintAndLog("Auto-detected clock rate: %d", clock);
PlotClock = clock;
// PlockClockStartIndex = start;
return clock; return clock;
} }
@ -221,8 +213,6 @@ uint8_t GetNrzClock(const char str[], bool printAns, bool verbose)
if (printAns) if (printAns)
PrintAndLog("Auto-detected clock rate: %d", clock); PrintAndLog("Auto-detected clock rate: %d", clock);
PlotClock = clock;
//PlockClockStartIndex = start;
return clock; return clock;
} }
//by marshmellow //by marshmellow
@ -247,8 +237,6 @@ uint8_t GetFskClock(const char str[], bool printAns, bool verbose)
PrintAndLog("DEBUG: unknown fsk field clock detected"); PrintAndLog("DEBUG: unknown fsk field clock detected");
PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1); PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
} }
//PlotClock = clock;
//PlockClockStartIndex = start;
return 0; return 0;
} }
uint8_t fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, bool verbose) uint8_t fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, bool verbose)

14
client/proxguiqt.cpp
View file

@ -9,6 +9,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <iostream> #include <iostream>
#include <QT>
#include <QPainterPath> #include <QPainterPath>
#include <QBrush> #include <QBrush>
#include <QPen> #include <QPen>
@ -278,8 +279,10 @@ void ProxWidget::paintEvent(QPaintEvent *event)
int foo = 40 + (int)((CursorCPos - GraphStart) * GraphPixelsPerPoint); int foo = 40 + (int)((CursorCPos - GraphStart) * GraphPixelsPerPoint);
int bar = 40 + ((CursorDPos - GraphStart) * GraphPixelsPerPoint); int bar = 40 + ((CursorDPos - GraphStart) * GraphPixelsPerPoint);
QRect r_stt(foo, r.top(), bar-foo, r.bottom() ); QRect r_stt(foo, r.top(), bar-foo, r.bottom() );
painter.fillRect(r_stt, QBrush( QT_ORANGE_TS )); QBrush b_stt( QBrush( QT_ORANGE_TS ));
painter.drawRect(r_stt); b_stt.setStyle(Qt::Dense1Pattern);
painter.setPen(Qt::NoPen);
painter.fillRect(r_stt, b_stt);
} }
// Mark Clock pulse // Mark Clock pulse
@ -293,8 +296,11 @@ void ProxWidget::paintEvent(QPaintEvent *event)
int foo = 40 + (int)((i - GraphStart) * GraphPixelsPerPoint); int foo = 40 + (int)((i - GraphStart) * GraphPixelsPerPoint);
int bar = 40 + ((i + PlotClock - GraphStart) * GraphPixelsPerPoint); int bar = 40 + ((i + PlotClock - GraphStart) * GraphPixelsPerPoint);
QRect r_clock(foo, r.top(), bar-foo, r.bottom() ); QRect r_clock(foo, r.top(), bar-foo, r.bottom() );
painter.fillRect(r_clock, QBrush( QT_RED_TS ));
painter.drawRect(r_clock); QBrush b_clk( QBrush( QT_RED_TS ));
b_clk.setStyle(Qt::Dense1Pattern);
painter.setPen(Qt::NoPen);
painter.fillRect(r_clock, b_clk);
} }
} }

2
client/proxguiqt.h
View file

@ -23,6 +23,8 @@ class ProxWidget : public QWidget
double GraphPixelsPerPoint; double GraphPixelsPerPoint;
int CursorAPos; int CursorAPos;
int CursorBPos; int CursorBPos;
//int CursorCPos;
//int CursorDPos;
public: public:
ProxWidget(QWidget *parent = 0); ProxWidget(QWidget *parent = 0);

106
common/lfdemod.c
View file

@ -940,6 +940,10 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
} }
return 0; return 0;
} }
void SetGraphClock( int clock, int startidx){
PlotClock = clock;
PlockClockStartIndex = startidx;
}
// by marshmellow // by marshmellow
// not perfect especially with lower clocks or VERY good antennas (heavy wave clipping) // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
@ -947,15 +951,15 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
// return start index of best starting position for that clock and return clock (by reference) // return start index of best starting position for that clock and return clock (by reference)
int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
{ {
size_t i=1; size_t i = 1;
uint8_t clk[] = {255,8,16,32,40,50,64,100,128,255}; uint8_t clk[] = {255,8,16,32,40,50,64,100,128,255};
uint8_t clkEnd = 9; uint8_t clkEnd = 9;
uint8_t loopCnt = 255; //don't need to loop through entire array... uint8_t loopCnt = 255; //don't need to loop through entire array...
if (size <= loopCnt+60) return -1; //not enough samples if (size <= loopCnt + 60) return -1; //not enough samples
size -= 60; //sometimes there is a strange end wave - filter out this.... size -= 60; //sometimes there is a strange end wave - filter out this....
//if we already have a valid clock //if we already have a valid clock
uint8_t clockFnd=0; uint8_t clockFnd = 0;
for (;i<clkEnd;++i) for (; i < clkEnd; ++i)
if (clk[i] == *clock) clockFnd = i; if (clk[i] == *clock) clockFnd = i;
//clock found but continue to find best startpos //clock found but continue to find best startpos
@ -985,15 +989,15 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
size_t errCnt = 0; size_t errCnt = 0;
size_t arrLoc, loopEnd; size_t arrLoc, loopEnd;
if (clockFnd>0) { if (clockFnd > 0) {
clkCnt = clockFnd; clkCnt = clockFnd;
clkEnd = clockFnd+1; clkEnd = clockFnd+1;
} else { } else {
clkCnt=1; clkCnt = 1;
} }
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(; clkCnt < clkEnd; clkCnt++) { for (; clkCnt < clkEnd; clkCnt++) {
if (clk[clkCnt] <= 32) { if (clk[clkCnt] <= 32) {
tol=1; tol=1;
} else { } else {
@ -1026,6 +1030,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d", clk[clkCnt], errCnt, ii, i); if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d", clk[clkCnt], errCnt, ii, i);
if (errCnt==0 && clkCnt<7) { if (errCnt==0 && clkCnt<7) {
if (!clockFnd) *clock = clk[clkCnt]; if (!clockFnd) *clock = clk[clkCnt];
SetGraphClock(*clock, ii);
return ii; return ii;
} }
//if we found errors see if it is lowest so far and save it as best run //if we found errors see if it is lowest so far and save it as best run
@ -1048,6 +1054,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d", clk[k], bestErr[k], clk[best], bestStart[best]); if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d", clk[k], bestErr[k], clk[best], bestStart[best]);
} }
if (!clockFnd) *clock = clk[best]; if (!clockFnd) *clock = clk[best];
SetGraphClock(*clock, bestStart[best]);
return bestStart[best]; return bestStart[best];
} }
@ -1056,27 +1064,30 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
// a phase shift is determined by measuring the sample length of each wave // a phase shift is determined by measuring the sample length of each wave
int DetectPSKClock(uint8_t dest[], size_t size, int clock) int DetectPSKClock(uint8_t dest[], size_t size, int clock)
{ {
uint8_t clk[]={255,16,32,40,50,64,100,128,255}; //255 is not a valid clock uint8_t clk[] = {255,16,32,40,50,64,100,128,255}; //255 is not a valid clock
uint16_t loopCnt = 4096; //don't need to loop through entire array... uint16_t loopCnt = 4096; //don't need to loop through entire array...
if (size == 0) return 0;
if (size<loopCnt) loopCnt = size-20;
//if we already have a valid clock quit //if we already have a valid clock quit
size_t i=1; size_t i=1;
for (; i < 8; ++i) for (; i < 8; ++i)
if (clk[i] == clock) return clock; if (clk[i] == clock) return clock;
if (size < 160+20) return 0;
// size must be larger than 20 here, and 160 later on.
if (size < loopCnt) loopCnt = size-20;
size_t waveStart=0, waveEnd=0, firstFullWave=0, lastClkBit=0; size_t waveStart=0, waveEnd=0, firstFullWave=0, lastClkBit=0;
uint8_t clkCnt, fc=0, fullWaveLen=0, tol=1; uint8_t clkCnt, fc=0, fullWaveLen=0, tol=1;
uint16_t peakcnt=0, errCnt=0, waveLenCnt=0; uint16_t peakcnt=0, errCnt=0, waveLenCnt=0;
uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; uint16_t bestErr[] = {1000,1000,1000,1000,1000,1000,1000,1000,1000};
uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0}; uint16_t peaksdet[] = {0,0,0,0,0,0,0,0,0};
fc = countFC(dest, size, 0); fc = countFC(dest, size, 0);
if (fc!=2 && fc!=4 && fc!=8) return -1; if (fc!=2 && fc!=4 && fc!=8) return -1;
if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc); if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc);
//find first full wave //find first full wave
for (i=160; i<loopCnt; i++){ for (i=160; i < loopCnt; i++){
if (dest[i] < dest[i+1] && dest[i+1] >= dest[i+2]){ if (dest[i] < dest[i+1] && dest[i+1] >= dest[i+2]){
if (waveStart == 0) { if (waveStart == 0) {
waveStart = i+1; waveStart = i+1;
@ -1094,10 +1105,10 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
} }
} }
} }
if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); if (g_debugMode == 2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen);
//test each valid clock from greatest to smallest to see which lines up //test each valid clock from greatest to smallest to see which lines up
for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ for (clkCnt=7; clkCnt >= 1 ; clkCnt--){
lastClkBit = firstFullWave; //set end of wave as clock align lastClkBit = firstFullWave; //set end of wave as clock align
waveStart = 0; waveStart = 0;
errCnt=0; errCnt=0;
@ -1131,19 +1142,17 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
} }
} }
} }
if (errCnt == 0){ if (errCnt == 0) return clk[clkCnt];
return clk[clkCnt]; if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt] = errCnt;
} if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt] = peakcnt;
if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt]=errCnt;
if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt]=peakcnt;
} }
//all tested with errors //all tested with errors
//return the highest clk with the most peaks found //return the highest clk with the most peaks found
uint8_t best=7; uint8_t best = 7;
for (i=7; i>=1; i--){ for (i=7; i >= 1; i--){
if (peaksdet[i] > peaksdet[best]) { if (peaksdet[i] > peaksdet[best])
best = i; best = i;
}
if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]); if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]);
} }
return clk[best]; return clk[best];
@ -1180,17 +1189,21 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
//by marshmellow //by marshmellow
//detect nrz clock by reading #peaks vs no peaks(or errors) //detect nrz clock by reading #peaks vs no peaks(or errors)
//iceman: shouldn't param clock be reference? like DetectASKClock
int DetectNRZClock(uint8_t dest[], size_t size, int clock) int DetectNRZClock(uint8_t dest[], size_t size, int clock)
{ {
size_t i=0; size_t i = 0;
uint8_t clk[]={8,16,32,40,50,64,100,128,255}; uint8_t clk[] = {8,16,32,40,50,64,100,128,255};
size_t loopCnt = 4096; //don't need to loop through entire array... size_t loopCnt = 4096; //don't need to loop through entire array...
if (size == 0) return 0;
if (size<loopCnt) loopCnt = size-20;
//if we already have a valid clock quit //if we already have a valid clock quit
for (; i < 8; ++i) for (; i < 8; ++i)
if (clk[i] == clock) return clock; if (clk[i] == clock) return clock;
if (size < 20) return 0;
// size must be larger than 20 here
if (size < loopCnt) loopCnt = size-20;
//get high and low peak //get high and low peak
int peak, low; int peak, low;
if (getHiLo(dest, loopCnt, &peak, &low, 75, 75) < 1) return 0; if (getHiLo(dest, loopCnt, &peak, &low, 75, 75) < 1) return 0;
@ -1210,7 +1223,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
if (!firstpeak) continue; if (!firstpeak) continue;
smplCnt++; smplCnt++;
} else { } else {
firstpeak=true; firstpeak = true;
if (smplCnt > 6 ){ if (smplCnt > 6 ){
if (maxPeak > smplCnt){ if (maxPeak > smplCnt){
maxPeak = smplCnt; maxPeak = smplCnt;
@ -1218,7 +1231,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
} }
peakcnt++; peakcnt++;
//prnt("maxPk: %d, smplCnt: %d, peakcnt: %d",maxPeak,smplCnt,peakcnt); //prnt("maxPk: %d, smplCnt: %d, peakcnt: %d",maxPeak,smplCnt,peakcnt);
smplCnt=0; smplCnt = 0;
} }
} }
} }
@ -1228,7 +1241,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
uint8_t ignoreWindow = 4; uint8_t ignoreWindow = 4;
bool lastPeakHigh = 0; bool lastPeakHigh = 0;
int lastBit = 0; int lastBit = 0;
peakcnt=0; peakcnt = 0;
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt < 8; ++clkCnt){ for(clkCnt=0; clkCnt < 8; ++clkCnt){
//ignore clocks smaller than smallest peak //ignore clocks smaller than smallest peak
@ -1248,7 +1261,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
if (dest[i] >= peak || dest[i] <= low) { if (dest[i] >= peak || dest[i] <= low) {
//if same peak don't count it //if same peak don't count it
if ((dest[i] >= peak && !lastPeakHigh) || (dest[i] <= low && lastPeakHigh)) { if ((dest[i] >= peak && !lastPeakHigh) || (dest[i] <= low && lastPeakHigh)) {
peakcnt++; peakcnt++;
} }
lastPeakHigh = (dest[i] >= peak); lastPeakHigh = (dest[i] >= peak);
bitHigh = true; bitHigh = true;
@ -1260,9 +1273,10 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
} }
//else if not a clock bit and no peaks //else if not a clock bit and no peaks
} else if (dest[i] < peak && dest[i] > low){ } else if (dest[i] < peak && dest[i] > low){
if (ignoreCnt==0){ if (ignoreCnt == 0){
bitHigh=false; bitHigh=false;
if (errBitHigh==true) peakcnt--; if (errBitHigh==true)
peakcnt--;
errBitHigh=false; errBitHigh=false;
} else { } else {
ignoreCnt--; ignoreCnt--;
@ -1273,23 +1287,23 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
errBitHigh=true; errBitHigh=true;
} }
} }
if(peakcnt>peaksdet[clkCnt]) { if (peakcnt > peaksdet[clkCnt]) {
peaksdet[clkCnt]=peakcnt; peaksdet[clkCnt] = peakcnt;
} }
} }
} }
} }
int iii=7;
uint8_t best=0; uint8_t best = 0;
for (iii=7; iii > 0; iii--){ for (int m = 7; m > 0; m--){
if ((peaksdet[iii] >= (peaksdet[best]-1)) && (peaksdet[iii] <= peaksdet[best]+1) && lowestTransition) { if ((peaksdet[m] >= (peaksdet[best]-1)) && (peaksdet[m] <= peaksdet[best]+1) && lowestTransition) {
if (clk[iii] > (lowestTransition - (clk[iii]/8)) && clk[iii] < (lowestTransition + (clk[iii]/8))) { if (clk[m] > (lowestTransition - (clk[m]/8)) && clk[m] < (lowestTransition + (clk[m]/8))) {
best = iii; best = m;
}
} else if (peaksdet[m] > peaksdet[best]){
best = m;
} }
} else if (peaksdet[iii] > peaksdet[best]){ if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d", clk[m], peaksdet[m], maxPeak, clk[best], lowestTransition);
best = iii;
}
if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition);
} }
return clk[best]; return clk[best];