mirror of
https://github.com/Proxmark/proxmark3.git
synced 2024-09-21 15:26:35 +08:00
started to enable demod graphing
first step: find graph start position from each rawdemod -now complete. todo: apply to each individual demod todo: graph it
This commit is contained in:
marshmellow42
parent
8b6abef506
commit
669959bc5c
|
|
@ -43,7 +43,8 @@ int CmdCOTAGDemod(const char *Cmd) {
|
|||
size_t bitlen = COTAG_BITS;
|
||||
memcpy(bits, DemodBuffer, COTAG_BITS);
|
||||
|
||||
int err = manrawdecode(bits, &bitlen, 1);
|
||||
uint8_t alignPos = 0;
|
||||
int err = manrawdecode(bits, &bitlen, 1, &alignPos);
|
||||
if (err){
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - COTAG too many errors: %d", err);
|
||||
return -1;
|
||||
|
|
|
|||
150
common/lfdemod.c
150
common/lfdemod.c
|
|
@ -237,11 +237,12 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
|
|||
|
||||
//by marshmellow
|
||||
//demodulates strong heavily clipped samples
|
||||
int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low)
|
||||
int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low, int *startIdx)
|
||||
{
|
||||
size_t bitCnt=0, smplCnt=0, errCnt=0;
|
||||
uint8_t waveHigh = 0;
|
||||
for (size_t i=0; i < *size; i++){
|
||||
*startIdx=0;
|
||||
size_t bitCnt=0, smplCnt=1, errCnt=0;
|
||||
bool waveHigh = (BinStream[0] >= high);
|
||||
for (size_t i=1; i < *size; i++){
|
||||
if (BinStream[i] >= high && waveHigh){
|
||||
smplCnt++;
|
||||
} else if (BinStream[i] <= low && !waveHigh){
|
||||
|
|
@ -252,7 +253,7 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
|
|||
if (smplCnt > clk + (clk/4)+1) { //too many samples
|
||||
errCnt++;
|
||||
if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i);
|
||||
BinStream[bitCnt++]=7;
|
||||
BinStream[bitCnt++] = 7;
|
||||
} else if (waveHigh) {
|
||||
BinStream[bitCnt++] = invert;
|
||||
BinStream[bitCnt++] = invert;
|
||||
|
|
@ -260,20 +261,18 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
|
|||
BinStream[bitCnt++] = invert ^ 1;
|
||||
BinStream[bitCnt++] = invert ^ 1;
|
||||
}
|
||||
waveHigh ^= 1;
|
||||
if (*startIdx==0) *startIdx = i-clk;
|
||||
waveHigh = !waveHigh;
|
||||
smplCnt = 0;
|
||||
} else if (smplCnt > (clk/2) - (clk/4)-1) {
|
||||
} else if (smplCnt > (clk/2) - (clk/4)-1) { //half clock
|
||||
if (waveHigh) {
|
||||
BinStream[bitCnt++] = invert;
|
||||
} else if (!waveHigh) {
|
||||
BinStream[bitCnt++] = invert ^ 1;
|
||||
}
|
||||
waveHigh ^= 1;
|
||||
if (*startIdx==0) *startIdx = i-(clk/2);
|
||||
waveHigh = !waveHigh;
|
||||
smplCnt = 0;
|
||||
} else if (!bitCnt) {
|
||||
//first bit
|
||||
waveHigh = (BinStream[i] >= high);
|
||||
smplCnt = 1;
|
||||
} else {
|
||||
smplCnt++;
|
||||
//transition bit oops
|
||||
|
|
@ -305,8 +304,7 @@ void askAmp(uint8_t *BitStream, size_t size)
|
|||
|
||||
//by marshmellow
|
||||
//attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester
|
||||
int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType)
|
||||
{
|
||||
int askdemod_ext(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType, int *startIdx) {
|
||||
if (*size==0) return -1;
|
||||
int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default
|
||||
if (*clk==0 || start < 0) return -3;
|
||||
|
|
@ -314,6 +312,9 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
|
|||
if (amp==1) askAmp(BinStream, *size);
|
||||
if (g_debugMode==2) prnt("DEBUG ASK: clk %d, beststart %d, amp %d", *clk, start, amp);
|
||||
|
||||
//start pos from detect ask clock is 1/2 clock offset
|
||||
// NOTE: can be negative (demod assumes rest of wave was there)
|
||||
*startIdx = start - (*clk/2);
|
||||
uint8_t initLoopMax = 255;
|
||||
if (initLoopMax > *size) initLoopMax = *size;
|
||||
// Detect high and lows
|
||||
|
|
@ -326,12 +327,18 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
|
|||
// if clean clipped waves detected run alternate demod
|
||||
if (DetectCleanAskWave(BinStream, *size, high, low)) {
|
||||
if (g_debugMode==2) prnt("DEBUG ASK: Clean Wave Detected - using clean wave demod");
|
||||
errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
|
||||
if (askType) //askman
|
||||
return manrawdecode(BinStream, size, 0);
|
||||
else //askraw
|
||||
errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low, startIdx);
|
||||
if (askType) { //askman
|
||||
uint8_t alignPos = 0;
|
||||
errCnt = manrawdecode(BinStream, size, 0, &alignPos);
|
||||
*startIdx += *clk/2 * alignPos;
|
||||
if (g_debugMode) prnt("DEBUG ASK CLEAN: startIdx %i, alignPos %u", *startIdx, alignPos);
|
||||
return errCnt;
|
||||
} else { //askraw
|
||||
return errCnt;
|
||||
}
|
||||
}
|
||||
if (g_debugMode) prnt("DEBUG ASK WEAK: startIdx %i", *startIdx);
|
||||
if (g_debugMode==2) prnt("DEBUG ASK: Weak Wave Detected - using weak wave demod");
|
||||
|
||||
int lastBit; //set first clock check - can go negative
|
||||
|
|
@ -378,10 +385,14 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
|
|||
return errCnt;
|
||||
}
|
||||
|
||||
int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType) {
|
||||
int start = 0;
|
||||
return askdemod_ext(BinStream, size, clk, invert, maxErr, amp, askType, &start);
|
||||
}
|
||||
//by marshmellow
|
||||
//take 10 and 01 and manchester decode
|
||||
//run through 2 times and take least errCnt
|
||||
int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert)
|
||||
int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert, uint8_t *alignPos)
|
||||
{
|
||||
uint16_t bitnum=0, MaxBits = 512, errCnt = 0;
|
||||
size_t i, ii;
|
||||
|
|
@ -399,6 +410,7 @@ int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert)
|
|||
}
|
||||
errCnt=0;
|
||||
}
|
||||
*alignPos=bestRun;
|
||||
//decode
|
||||
for (i=bestRun; i < *size-3; i+=2){
|
||||
if(BitStream[i] == 1 && (BitStream[i+1] == 0)){
|
||||
|
|
@ -502,7 +514,7 @@ int gProxII_Demod(uint8_t BitStream[], size_t *size)
|
|||
}
|
||||
|
||||
//translate wave to 11111100000 (1 for each short wave [higher freq] 0 for each long wave [lower freq])
|
||||
size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow)
|
||||
size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow, int *startIdx)
|
||||
{
|
||||
size_t last_transition = 0;
|
||||
size_t idx = 1;
|
||||
|
|
@ -517,20 +529,19 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
|
||||
//find start of modulating data in trace
|
||||
idx = findModStart(dest, size, threshold_value, fchigh);
|
||||
|
||||
// Need to threshold first sample
|
||||
if(dest[idx] < threshold_value) dest[0] = 0;
|
||||
else dest[0] = 1;
|
||||
idx++;
|
||||
|
||||
last_transition = idx;
|
||||
idx++;
|
||||
size_t numBits = 0;
|
||||
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
|
||||
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere
|
||||
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
|
||||
// (could also be fc/5 && fc/7 for fsk1 = 4-9)
|
||||
for(; idx < size-20; idx++) {
|
||||
for(; idx < size; idx++) {
|
||||
// threshold current value
|
||||
|
||||
if (dest[idx] < threshold_value) dest[idx] = 0;
|
||||
else dest[idx] = 1;
|
||||
|
||||
|
|
@ -543,18 +554,20 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
//do nothing with extra garbage
|
||||
} else if (currSample < (fchigh-1)) { //6-8 = 8 sample waves (or 3-6 = 5)
|
||||
//correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5)
|
||||
if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1))){
|
||||
if (numBits > 1 && LastSample > (fchigh-2) && (preLastSample < (fchigh-1))){
|
||||
dest[numBits-1]=1;
|
||||
}
|
||||
dest[numBits++]=1;
|
||||
|
||||
if (numBits > 0 && *startIdx==0) *startIdx = idx - fclow;
|
||||
} else if (currSample > (fchigh+1) && numBits < 3) { //12 + and first two bit = unusable garbage
|
||||
//do nothing with beginning garbage and reset.. should be rare..
|
||||
numBits = 0;
|
||||
} else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's)
|
||||
dest[numBits++]=1;
|
||||
if (numBits > 0 && *startIdx==0) *startIdx = idx - fclow;
|
||||
} else { //9+ = 10 sample waves (or 6+ = 7)
|
||||
dest[numBits++]=0;
|
||||
if (numBits > 0 && *startIdx==0) *startIdx = idx - fchigh;
|
||||
}
|
||||
last_transition = idx;
|
||||
}
|
||||
|
|
@ -565,7 +578,7 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
//translate 11111100000 to 10
|
||||
//rfLen = clock, fchigh = larger field clock, fclow = smaller field clock
|
||||
size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen,
|
||||
uint8_t invert, uint8_t fchigh, uint8_t fclow)
|
||||
uint8_t invert, uint8_t fchigh, uint8_t fclow, int *startIdx)
|
||||
{
|
||||
uint8_t lastval=dest[0];
|
||||
size_t idx=0;
|
||||
|
|
@ -575,7 +588,7 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen,
|
|||
n++;
|
||||
if (dest[idx]==lastval) continue; //skip until we hit a transition
|
||||
|
||||
//find out how many bits (n) we collected
|
||||
//find out how many bits (n) we collected (use 1/2 clk tolerance)
|
||||
//if lastval was 1, we have a 1->0 crossing
|
||||
if (dest[idx-1]==1) {
|
||||
n = (n * fclow + rfLen/2) / rfLen;
|
||||
|
|
@ -584,6 +597,17 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen,
|
|||
}
|
||||
if (n == 0) n = 1;
|
||||
|
||||
//first transition - save startidx
|
||||
if (numBits == 0) {
|
||||
if (lastval == 1) { //high to low
|
||||
*startIdx += (fclow * idx) - (n*rfLen);
|
||||
if (g_debugMode==2) prnt("DEBUG FSK: startIdx %i, fclow*idx %i, n*rflen %u", *startIdx, fclow*(idx), n*rfLen);
|
||||
} else {
|
||||
*startIdx += (fchigh * idx) - (n*rfLen);
|
||||
if (g_debugMode==2) prnt("DEBUG FSK: startIdx %i, fchigh*idx %i, n*rflen %u", *startIdx, fchigh*(idx), n*rfLen);
|
||||
}
|
||||
}
|
||||
|
||||
//add to our destination the bits we collected
|
||||
memset(dest+numBits, dest[idx-1]^invert , n);
|
||||
numBits += n;
|
||||
|
|
@ -605,14 +629,18 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen,
|
|||
|
||||
//by marshmellow (from holiman's base)
|
||||
// full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
|
||||
int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow)
|
||||
{
|
||||
int fskdemod_ext(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow, int *startIdx) {
|
||||
// FSK demodulator
|
||||
size = fsk_wave_demod(dest, size, fchigh, fclow);
|
||||
size = aggregate_bits(dest, size, rfLen, invert, fchigh, fclow);
|
||||
size = fsk_wave_demod(dest, size, fchigh, fclow, startIdx);
|
||||
size = aggregate_bits(dest, size, rfLen, invert, fchigh, fclow, startIdx);
|
||||
return size;
|
||||
}
|
||||
|
||||
int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow) {
|
||||
int startIdx=0;
|
||||
return fskdemod_ext(dest, size, rfLen, invert, fchigh, fclow, &startIdx);
|
||||
}
|
||||
|
||||
// loop to get raw HID waveform then FSK demodulate the TAG ID from it
|
||||
int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
|
||||
{
|
||||
|
|
@ -959,12 +987,6 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
|
|||
return bestStart[best];
|
||||
}
|
||||
|
||||
|
||||
int DetectPSKClock(uint8_t dest[], size_t size, int clock) {
|
||||
int firstPhaseShift = 0;
|
||||
return DetectPSKClock_ext(dest, size, clock, &firstPhaseShift);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//detect psk clock by reading each phase shift
|
||||
// a phase shift is determined by measuring the sample length of each wave
|
||||
|
|
@ -1062,6 +1084,11 @@ int DetectPSKClock_ext(uint8_t dest[], size_t size, int clock, int *firstPhaseSh
|
|||
return clk[best];
|
||||
}
|
||||
|
||||
int DetectPSKClock(uint8_t dest[], size_t size, int clock) {
|
||||
int firstPhaseShift = 0;
|
||||
return DetectPSKClock_ext(dest, size, clock, &firstPhaseShift);
|
||||
}
|
||||
|
||||
int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
|
||||
//find shortest transition from high to low
|
||||
size_t i = 0;
|
||||
|
|
@ -1091,12 +1118,6 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
|
|||
return lowestTransition;
|
||||
}
|
||||
|
||||
int DetectNRZClock(uint8_t dest[], size_t size, int clock) {
|
||||
size_t bestStart=0;
|
||||
return DetectNRZClock_ext(dest, size, clock, &bestStart);
|
||||
}
|
||||
|
||||
|
||||
//by marshmellow
|
||||
//detect nrz clock by reading #peaks vs no peaks(or errors)
|
||||
int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, size_t *clockStartIdx) {
|
||||
|
|
@ -1215,6 +1236,11 @@ int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, size_t *clockStar
|
|||
return clk[best];
|
||||
}
|
||||
|
||||
int DetectNRZClock(uint8_t dest[], size_t size, int clock) {
|
||||
size_t bestStart=0;
|
||||
return DetectNRZClock_ext(dest, size, clock, &bestStart);
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
// convert psk1 demod to psk2 demod
|
||||
// only transition waves are 1s
|
||||
|
|
@ -1273,7 +1299,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert)
|
|||
|
||||
// by marshmellow - demodulate NRZ wave - requires a read with strong signal
|
||||
// peaks invert bit (high=1 low=0) each clock cycle = 1 bit determined by last peak
|
||||
int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert){
|
||||
int nrzRawDemod_ext(uint8_t *dest, size_t *size, int *clk, int *invert, int *startIdx) {
|
||||
if (justNoise(dest, *size)) return -1;
|
||||
*clk = DetectNRZClock(dest, *size, *clk);
|
||||
if (*clk==0) return -2;
|
||||
|
|
@ -1297,16 +1323,19 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert){
|
|||
if (dest[i] != dest[i-1] || (i-lastBit) == (10 * *clk)) {
|
||||
memset(dest+numBits, dest[i-1] ^ *invert, (i - lastBit + (*clk/4)) / *clk);
|
||||
numBits += (i - lastBit + (*clk/4)) / *clk;
|
||||
if (lastBit == 0) {
|
||||
*startIdx = i - (numBits * *clk);
|
||||
if (g_debugMode==2) prnt("DEBUG NRZ: startIdx %i", *startIdx);
|
||||
}
|
||||
lastBit = i-1;
|
||||
}
|
||||
}
|
||||
*size = numBits;
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) {
|
||||
int firstClockEdge = 0;
|
||||
return detectFSKClk_ext(BitStream, size, fcHigh, fcLow, &firstClockEdge);
|
||||
int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) {
|
||||
int startIdx = 0;
|
||||
return nrzRawDemod_ext(dest, size, clk, invert, &startIdx);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
|
|
@ -1417,6 +1446,11 @@ uint8_t detectFSKClk_ext(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_
|
|||
return clk[ii];
|
||||
}
|
||||
|
||||
uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) {
|
||||
int firstClockEdge = 0;
|
||||
return detectFSKClk_ext(BitStream, size, fcHigh, fcLow, &firstClockEdge);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//countFC is to detect the field clock lengths.
|
||||
//counts and returns the 2 most common wave lengths
|
||||
|
|
@ -1508,8 +1542,7 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
|
|||
|
||||
//by marshmellow - demodulate PSK1 wave
|
||||
//uses wave lengths (# Samples)
|
||||
int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
||||
{
|
||||
int pskRawDemod_ext(uint8_t dest[], size_t *size, int *clock, int *invert, int *startIdx) {
|
||||
if (size == 0) return -1;
|
||||
uint16_t loopCnt = 4096; //don't need to loop through entire array...
|
||||
if (*size<loopCnt) loopCnt = *size;
|
||||
|
|
@ -1549,6 +1582,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
if (lastAvgWaveVal > threshold_value) curPhase ^= 1;
|
||||
break;
|
||||
}
|
||||
|
||||
waveStart = i+1;
|
||||
avgWaveVal = 0;
|
||||
}
|
||||
|
|
@ -1564,9 +1598,10 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
}
|
||||
//advance bits
|
||||
numBits += (firstFullWave / *clock);
|
||||
*startIdx = firstFullWave - (*clock * numBits)+2;
|
||||
//set start of wave as clock align
|
||||
lastClkBit = firstFullWave;
|
||||
if (g_debugMode==2) prnt("DEBUG PSK: firstFullWave: %u, waveLen: %u",firstFullWave,fullWaveLen);
|
||||
if (g_debugMode==2) prnt("DEBUG PSK: firstFullWave: %u, waveLen: %u, startIdx %i",firstFullWave,fullWaveLen, *startIdx);
|
||||
if (g_debugMode==2) prnt("DEBUG PSK: clk: %d, lastClkBit: %u, fc: %u", *clock, lastClkBit,(unsigned int) fc);
|
||||
waveStart = 0;
|
||||
dest[numBits++] = curPhase; //set first read bit
|
||||
|
|
@ -1612,9 +1647,9 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
return errCnt;
|
||||
}
|
||||
|
||||
bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
|
||||
size_t ststart = 0, stend = 0;
|
||||
return DetectST_ext(buffer, size, foundclock, &ststart, &stend);
|
||||
int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) {
|
||||
int startIdx = 0;
|
||||
return pskRawDemod_ext(dest, size, clock, invert, &startIdx);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
|
|
@ -1807,6 +1842,11 @@ bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststa
|
|||
return true;
|
||||
}
|
||||
|
||||
bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
|
||||
size_t ststart = 0, stend = 0;
|
||||
return DetectST_ext(buffer, size, foundclock, &ststart, &stend);
|
||||
}
|
||||
|
||||
// by iceman
|
||||
// find Visa2000 preamble in already demoded data
|
||||
int Visa2kDemod_AM(uint8_t *dest, size_t *size) {
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@
|
|||
//generic
|
||||
extern size_t addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType);
|
||||
extern int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType);
|
||||
extern int askdemod_ext(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType, int *startIdx);
|
||||
extern void askAmp(uint8_t *BitStream, size_t size);
|
||||
extern int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
|
||||
extern uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
|
||||
|
|
@ -36,15 +37,18 @@ extern int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high,
|
|||
extern bool DetectST(uint8_t buffer[], size_t *size, int *foundclock);
|
||||
extern bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststart, size_t *stend);
|
||||
extern int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow);
|
||||
extern int fskdemod_ext(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow, int *startIdx);
|
||||
extern int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo);
|
||||
extern uint32_t manchesterEncode2Bytes(uint16_t datain);
|
||||
extern int ManchesterEncode(uint8_t *BitStream, size_t size);
|
||||
extern int manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert);
|
||||
extern int manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert, uint8_t *alignPos);
|
||||
extern int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert);
|
||||
extern int nrzRawDemod_ext(uint8_t *dest, size_t *size, int *clk, int *invert, int *startIdx);
|
||||
extern uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType);
|
||||
extern uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx);
|
||||
extern bool preambleSearchEx(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx, bool findone);
|
||||
extern int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert);
|
||||
extern int pskRawDemod_ext(uint8_t dest[], size_t *size, int *clock, int *invert, int *startIdx);
|
||||
extern void psk2TOpsk1(uint8_t *BitStream, size_t size);
|
||||
extern void psk1TOpsk2(uint8_t *BitStream, size_t size);
|
||||
extern size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen);
|
||||
|
|
|
|||
Loading…
Reference in a new issue