From 4d3c1796696414280bd9759babd339a5667f2061 Mon Sep 17 00:00:00 2001 From: marshmellow42 Date: Sun, 12 Mar 2017 22:47:50 -0400 Subject: [PATCH] re-organize lfdemod.c sorry but it was ugly (still is... but i can get to things easier) --- common/lfdemod.c | 2111 +++++++++++++++++++++++----------------------- 1 file changed, 1061 insertions(+), 1050 deletions(-) diff --git a/common/lfdemod.c b/common/lfdemod.c index 660b5427..a6e215c9 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -6,6 +6,26 @@ // the license. //----------------------------------------------------------------------------- // Low frequency demod/decode commands +// +// NOTES: +// LF Demod functions are placed here to allow the flexability to use client or +// device side. Most BUT NOT ALL of these functions are currenlty safe for +// device side use currently. (DetectST for example...) +// +// There are likely many improvements to the code that could be made, please +// make suggestions... +// +// There are 4 main sections of code below: +// Utilities Section: +// for general utilities used by multiple other functions +// Modulation Demods &/or Decoding Section: +// for main general modulation demodulating and encoding decoding code. +// Clock / Bitrate Detection Section: +// for clock detection functions for each modulation +// Tag format detection section: +// for detection of specific tag formats within demodulated data +// +// marshmellow //----------------------------------------------------------------------------- #include @@ -25,6 +45,8 @@ void dummy(char *fmt, ...){} #define prnt dummy #endif +//---------------------------------Utilities Section-------------------------------------------------- + uint8_t justNoise(uint8_t *BitStream, size_t size) { static const uint8_t THRESHOLD = 123; @@ -204,92 +226,8 @@ size_t findModStart(uint8_t dest[], size_t size, uint8_t threshold_value, uint8_ } //by marshmellow -//takes 1s and 0s and searches for EM410x format - output EM ID -uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) -{ - //sanity checks - if (*size < 64) return 0; - if (BitStream[1]>1) return 0; //allow only 1s and 0s - - // 111111111 bit pattern represent start of frame - // include 0 in front to help get start pos - uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1}; - uint8_t errChk = 0; - uint8_t FmtLen = 10; // sets of 4 bits = end data - *startIdx = 0; - errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx); - if ( errChk == 0 || (*size != 64 && *size != 128) ) return 0; - if (*size == 128) FmtLen = 22; // 22 sets of 4 bits - - //skip last 4bit parity row for simplicity - *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, FmtLen * 5); - if (*size == 40) { // std em410x format - *hi = 0; - *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32)); - } else if (*size == 88) { // long em format - *hi = (bytebits_to_byte(BitStream, 24)); - *lo = ((uint64_t)(bytebits_to_byte(BitStream + 24, 32)) << 32) | (bytebits_to_byte(BitStream + 24 + 32, 32)); - } else { - return 0; - } - return 1; -} - -//by marshmellow -//demodulates strong heavily clipped samples -int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low, int *startIdx) -{ - *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){ - smplCnt++; - } else { //transition - if ((BinStream[i] >= high && !waveHigh) || (BinStream[i] <= low && waveHigh)){ - if (smplCnt > clk-(clk/4)-1) { //full clock - 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; - } else if (waveHigh) { - BinStream[bitCnt++] = invert; - BinStream[bitCnt++] = invert; - } else if (!waveHigh) { - BinStream[bitCnt++] = invert ^ 1; - BinStream[bitCnt++] = invert ^ 1; - } - if (*startIdx==0) *startIdx = i-clk; - waveHigh = !waveHigh; - smplCnt = 0; - } else if (smplCnt > (clk/2) - (clk/4)-1) { //half clock - if (waveHigh) { - BinStream[bitCnt++] = invert; - } else if (!waveHigh) { - BinStream[bitCnt++] = invert ^ 1; - } - if (*startIdx==0) *startIdx = i-(clk/2); - waveHigh = !waveHigh; - smplCnt = 0; - } else { - smplCnt++; - //transition bit oops - } - } else { //haven't hit new high or new low yet - smplCnt++; - } - } - } - *size = bitCnt; - return errCnt; -} - -//by marshmellow -//amplify based on ask edge detection -void askAmp(uint8_t *BitStream, size_t size) -{ +//amplify based on ask edge detection - not accurate enough to use all the time +void askAmp(uint8_t *BitStream, size_t size) { uint8_t Last = 128; for(size_t i = 1; i=30) //large jump up @@ -301,130 +239,6 @@ void askAmp(uint8_t *BitStream, size_t size) } return; } - -//by marshmellow -//attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester -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; - if (*invert != 1) *invert = 0; - 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 - //25% clip in case highs and lows aren't clipped [marshmellow] - int high, low; - if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) - return -2; //just noise - - size_t errCnt = 0; - // 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, 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 - size_t i, bitnum = 0; //output counter - uint8_t midBit = 0; - uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave - if (*clk <= 32) tol = 1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely - size_t MaxBits = 3072; //max bits to collect - lastBit = start - *clk; - - for (i = start; i < *size; ++i) { - if (i-lastBit >= *clk-tol){ - if (BinStream[i] >= high) { - BinStream[bitnum++] = *invert; - } else if (BinStream[i] <= low) { - BinStream[bitnum++] = *invert ^ 1; - } else if (i-lastBit >= *clk+tol) { - if (bitnum > 0) { - if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i); - BinStream[bitnum++]=7; - errCnt++; - } - } else { //in tolerance - looking for peak - continue; - } - midBit = 0; - lastBit += *clk; - } else if (i-lastBit >= (*clk/2-tol) && !midBit && !askType){ - if (BinStream[i] >= high) { - BinStream[bitnum++] = *invert; - } else if (BinStream[i] <= low) { - BinStream[bitnum++] = *invert ^ 1; - } else if (i-lastBit >= *clk/2+tol) { - BinStream[bitnum] = BinStream[bitnum-1]; - bitnum++; - } else { //in tolerance - looking for peak - continue; - } - midBit = 1; - } - if (bitnum >= MaxBits) break; - } - *size = bitnum; - 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, uint8_t *alignPos) -{ - uint16_t bitnum=0, MaxBits = 512, errCnt = 0; - size_t i, ii; - uint16_t bestErr = 1000, bestRun = 0; - if (*size < 16) return -1; - //find correct start position [alignment] - for (ii=0;ii<2;++ii){ - for (i=ii; i<*size-3; i+=2) - if (BitStream[i]==BitStream[i+1]) - errCnt++; - - if (bestErr>errCnt){ - bestErr=errCnt; - bestRun=ii; - } - errCnt=0; - } - *alignPos=bestRun; - //decode - for (i=bestRun; i < *size-3; i+=2){ - if(BitStream[i] == 1 && (BitStream[i+1] == 0)){ - BitStream[bitnum++]=invert; - } else if((BitStream[i] == 0) && BitStream[i+1] == 1){ - BitStream[bitnum++]=invert^1; - } else { - BitStream[bitnum++]=7; - } - if(bitnum>MaxBits) break; - } - *size=bitnum; - return bestErr; -} uint32_t manchesterEncode2Bytes(uint16_t datain) { uint32_t output = 0; @@ -438,47 +252,242 @@ uint32_t manchesterEncode2Bytes(uint16_t datain) { //by marshmellow //encode binary data into binary manchester -int ManchesterEncode(uint8_t *BitStream, size_t size) -{ - size_t modIdx=20000, i=0; +//NOTE: BitStream must have double the size available in memory to do the swap +int ManchesterEncode(uint8_t *BitStream, size_t size) { + size_t modIdx=size, i=0; if (size>modIdx) return -1; for (size_t idx=0; idx < size; idx++){ BitStream[idx+modIdx++] = BitStream[idx]; BitStream[idx+modIdx++] = BitStream[idx]^1; } for (; i<(size*2); i++){ - BitStream[i] = BitStream[i+20000]; + BitStream[i] = BitStream[i+size]; } return i; } +//------------------------------Modulation Demods &/or Decoding Section------------------------------------------------------ + //by marshmellow -//take 01 or 10 = 1 and 11 or 00 = 0 -//check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010 -//decodes biphase or if inverted it is AKA conditional dephase encoding AKA differential manchester encoding -int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert) -{ - uint16_t bitnum = 0; - uint16_t errCnt = 0; - size_t i = offset; - uint16_t MaxBits=512; - //if not enough samples - error - if (*size < 51) return -1; - //check for phase change faults - skip one sample if faulty - uint8_t offsetA = 1, offsetB = 1; - for (; i<48; i+=2){ - if (BitStream[i+1]==BitStream[i+2]) offsetA=0; - if (BitStream[i+2]==BitStream[i+3]) offsetB=0; +//attempt to identify a Sequence Terminator in ASK modulated raw wave +bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststart, size_t *stend) { + size_t bufsize = *size; + //need to loop through all samples and identify our clock, look for the ST pattern + uint8_t fndClk[] = {8,16,32,40,50,64,128}; + int clk = 0; + int tol = 0; + int i, j, skip, start, end, low, high, minClk, waveStart; + bool complete = false; + int tmpbuff[bufsize / 32]; //guess rf/32 clock, if click is smaller we will only have room for a fraction of the samples captured + int waveLen[bufsize / 32]; // if clock is larger then we waste memory in array size that is not needed... + size_t testsize = (bufsize < 512) ? bufsize : 512; + int phaseoff = 0; + high = low = 128; + memset(tmpbuff, 0, sizeof(tmpbuff)); + + if ( getHiLo(buffer, testsize, &high, &low, 80, 80) == -1 ) { + if (g_debugMode==2) prnt("DEBUG STT: just noise detected - quitting"); + return false; //just noise } - if (!offsetA && offsetB) offset++; - for (i=offset; i<*size-3; i+=2){ - //check for phase error - if (BitStream[i+1]==BitStream[i+2]) { - BitStream[bitnum++]=7; - errCnt++; - } - if((BitStream[i]==1 && BitStream[i+1]==0) || (BitStream[i]==0 && BitStream[i+1]==1)){ - BitStream[bitnum++]=1^invert; + i = 0; + j = 0; + minClk = 255; + // get to first full low to prime loop and skip incomplete first pulse + while ((buffer[i] < high) && (i < bufsize)) + ++i; + while ((buffer[i] > low) && (i < bufsize)) + ++i; + skip = i; + + // populate tmpbuff buffer with pulse lengths + while (i < bufsize) { + // measure from low to low + while ((buffer[i] > low) && (i < bufsize)) + ++i; + start= i; + while ((buffer[i] < high) && (i < bufsize)) + ++i; + //first high point for this wave + waveStart = i; + while ((buffer[i] > low) && (i < bufsize)) + ++i; + if (j >= (bufsize/32)) { + break; + } + waveLen[j] = i - waveStart; //first high to first low + tmpbuff[j++] = i - start; + if (i-start < minClk && i < bufsize) { + minClk = i - start; + } + } + // set clock - might be able to get this externally and remove this work... + if (!clk) { + for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { + tol = fndClk[clkCnt]/8; + if (minClk >= fndClk[clkCnt]-tol && minClk <= fndClk[clkCnt]+1) { + clk=fndClk[clkCnt]; + break; + } + } + // clock not found - ERROR + if (!clk) { + if (g_debugMode==2) prnt("DEBUG STT: clock not found - quitting"); + return false; + } + } else tol = clk/8; + + *foundclock = clk; + + // look for Sequence Terminator - should be pulses of clk*(1 or 1.5), clk*2, clk*(1.5 or 2) + start = -1; + for (i = 0; i < j - 4; ++i) { + skip += tmpbuff[i]; + if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol && waveLen[i] < clk+tol) { //1 to 2 clocks depending on 2 bits prior + if (tmpbuff[i+1] >= clk*2-tol && tmpbuff[i+1] <= clk*2+tol && waveLen[i+1] > clk*3/2-tol) { //2 clocks and wave size is 1 1/2 + if (tmpbuff[i+2] >= (clk*3)/2-tol && tmpbuff[i+2] <= clk*2+tol && waveLen[i+2] > clk-tol) { //1 1/2 to 2 clocks and at least one full clock wave + if (tmpbuff[i+3] >= clk*1-tol && tmpbuff[i+3] <= clk*2+tol) { //1 to 2 clocks for end of ST + first bit + start = i + 3; + break; + } + } + } + } + } + // first ST not found - ERROR + if (start < 0) { + if (g_debugMode==2) prnt("DEBUG STT: first STT not found - quitting"); + return false; + } else { + if (g_debugMode==2) prnt("DEBUG STT: first STT found at: %d, j=%d",start, j); + } + if (waveLen[i+2] > clk*1+tol) + phaseoff = 0; + else + phaseoff = clk/2; + + // skip over the remainder of ST + skip += clk*7/2; //3.5 clocks from tmpbuff[i] = end of st - also aligns for ending point + + // now do it again to find the end + end = skip; + for (i += 3; i < j - 4; ++i) { + end += tmpbuff[i]; + if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol && waveLen[i] < clk+tol) { //1 to 2 clocks depending on 2 bits prior + if (tmpbuff[i+1] >= clk*2-tol && tmpbuff[i+1] <= clk*2+tol && waveLen[i+1] > clk*3/2-tol) { //2 clocks and wave size is 1 1/2 + if (tmpbuff[i+2] >= (clk*3)/2-tol && tmpbuff[i+2] <= clk*2+tol && waveLen[i+2] > clk-tol) { //1 1/2 to 2 clocks and at least one full clock wave + if (tmpbuff[i+3] >= clk*1-tol && tmpbuff[i+3] <= clk*2+tol) { //1 to 2 clocks for end of ST + first bit + complete = true; + break; + } + } + } + } + } + end -= phaseoff; + //didn't find second ST - ERROR + if (!complete) { + if (g_debugMode==2) prnt("DEBUG STT: second STT not found - quitting"); + return false; + } + if (g_debugMode==2) prnt("DEBUG STT: start of data: %d end of data: %d, datalen: %d, clk: %d, bits: %d, phaseoff: %d", skip, end, end-skip, clk, (end-skip)/clk, phaseoff); + //now begin to trim out ST so we can use normal demod cmds + start = skip; + size_t datalen = end - start; + // check validity of datalen (should be even clock increments) - use a tolerance of up to 1/8th a clock + if ( clk - (datalen % clk) <= clk/8) { + // padd the amount off - could be problematic... but shouldn't happen often + datalen += clk - (datalen % clk); + } else if ( (datalen % clk) <= clk/8 ) { + // padd the amount off - could be problematic... but shouldn't happen often + datalen -= datalen % clk; + } else { + if (g_debugMode==2) prnt("DEBUG STT: datalen not divisible by clk: %u %% %d = %d - quitting", datalen, clk, datalen % clk); + return false; + } + // if datalen is less than one t55xx block - ERROR + if (datalen/clk < 8*4) { + if (g_debugMode==2) prnt("DEBUG STT: datalen is less than 1 full t55xx block - quitting"); + return false; + } + size_t dataloc = start; + if (buffer[dataloc-(clk*4)-(clk/8)] <= low && buffer[dataloc] <= low && buffer[dataloc-(clk*4)] >= high) { + //we have low drift (and a low just before the ST and a low just after the ST) - compensate by backing up the start + for ( i=0; i <= (clk/8); ++i ) { + if ( buffer[dataloc - (clk*4) - i] <= low ) { + dataloc -= i; + break; + } + } + } + + size_t newloc = 0; + i=0; + if (g_debugMode==2) prnt("DEBUG STT: Starting STT trim - start: %d, datalen: %d ",dataloc, datalen); + bool firstrun = true; + // warning - overwriting buffer given with raw wave data with ST removed... + while ( dataloc < bufsize-(clk/2) ) { + //compensate for long high at end of ST not being high due to signal loss... (and we cut out the start of wave high part) + if (buffer[dataloc]low && buffer[dataloc+3]low) { + for(i=0; i < clk/2-tol; ++i) { + buffer[dataloc+i] = high+5; + } + } //test for single sample outlier (high between two lows) in the case of very strong waves + if (buffer[dataloc] >= high && buffer[dataloc+2] <= low) { + buffer[dataloc] = buffer[dataloc+2]; + buffer[dataloc+1] = buffer[dataloc+2]; + } + if (firstrun) { + *stend = dataloc; + *ststart = dataloc-(clk*4); + firstrun=false; + } + for (i=0; ierrCnt){ + bestErr=errCnt; + bestRun=ii; + } + errCnt=0; } - return -5; //spacer bits not found - not a valid gproxII + *alignPos=bestRun; + //decode + for (i=bestRun; i < *size-3; i+=2){ + if(BitStream[i] == 1 && (BitStream[i+1] == 0)){ + BitStream[bitnum++]=invert; + } else if((BitStream[i] == 0) && BitStream[i+1] == 1){ + BitStream[bitnum++]=invert^1; + } else { + BitStream[bitnum++]=7; + } + if(bitnum>MaxBits) break; + } + *size=bitnum; + return bestErr; } -//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, int *startIdx) -{ - size_t last_transition = 0; - size_t idx = 1; - if (fchigh==0) fchigh=10; - if (fclow==0) fclow=8; - //set the threshold close to 0 (graph) or 128 std to avoid static - uint8_t threshold_value = 123; - size_t preLastSample = 0; - size_t LastSample = 0; +// by marshmellow +// to detect a wave that has heavily clipped (clean) samples +uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low) { + bool allArePeaks = true; + uint16_t cntPeaks=0; + size_t loopEnd = 512+160; + if (loopEnd > size) loopEnd = size; + for (size_t i=160; ilow && dest[i] 300) return true; + } + return allArePeaks; +} + +//by marshmellow +//demodulates strong heavily clipped samples +int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low, int *startIdx) +{ + *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){ + smplCnt++; + } else { //transition + if ((BinStream[i] >= high && !waveHigh) || (BinStream[i] <= low && waveHigh)){ + if (smplCnt > clk-(clk/4)-1) { //full clock + 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; + } else if (waveHigh) { + BinStream[bitCnt++] = invert; + BinStream[bitCnt++] = invert; + } else if (!waveHigh) { + BinStream[bitCnt++] = invert ^ 1; + BinStream[bitCnt++] = invert ^ 1; + } + if (*startIdx==0) *startIdx = i-clk; + waveHigh = !waveHigh; + smplCnt = 0; + } else if (smplCnt > (clk/2) - (clk/4)-1) { //half clock + if (waveHigh) { + BinStream[bitCnt++] = invert; + } else if (!waveHigh) { + BinStream[bitCnt++] = invert ^ 1; + } + if (*startIdx==0) *startIdx = i-(clk/2); + waveHigh = !waveHigh; + smplCnt = 0; + } else { + smplCnt++; + //transition bit oops + } + } else { //haven't hit new high or new low yet + smplCnt++; + } + } + } + *size = bitCnt; + return errCnt; +} + +//by marshmellow +//attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester +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; + if (*invert != 1) *invert = 0; + 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 + //25% clip in case highs and lows aren't clipped [marshmellow] + int high, low; + if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) + return -2; //just noise + + size_t errCnt = 0; + // 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, 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 + size_t i, bitnum = 0; //output counter + uint8_t midBit = 0; + uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave + if (*clk <= 32) tol = 1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely + size_t MaxBits = 3072; //max bits to collect + lastBit = start - *clk; + + for (i = start; i < *size; ++i) { + if (i-lastBit >= *clk-tol){ + if (BinStream[i] >= high) { + BinStream[bitnum++] = *invert; + } else if (BinStream[i] <= low) { + BinStream[bitnum++] = *invert ^ 1; + } else if (i-lastBit >= *clk+tol) { + if (bitnum > 0) { + if (g_debugMode==2) prnt("DEBUG ASK: Modulation Error at: %u", i); + BinStream[bitnum++]=7; + errCnt++; + } + } else { //in tolerance - looking for peak + continue; + } + midBit = 0; + lastBit += *clk; + } else if (i-lastBit >= (*clk/2-tol) && !midBit && !askType){ + if (BinStream[i] >= high) { + BinStream[bitnum++] = *invert; + } else if (BinStream[i] <= low) { + BinStream[bitnum++] = *invert ^ 1; + } else if (i-lastBit >= *clk/2+tol) { + BinStream[bitnum] = BinStream[bitnum-1]; + bitnum++; + } else { //in tolerance - looking for peak + continue; + } + midBit = 1; + } + if (bitnum >= MaxBits) break; + } + *size = bitnum; + 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 - 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_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; + size_t i, gLen = 4096; + if (gLen>*size) gLen = *size-20; + int high, low; + if (getHiLo(dest, gLen, &high, &low, 75, 75) < 1) return -3; //25% fuzz on high 25% fuzz on low + + uint8_t bit=0; + //convert wave samples to 1's and 0's + for(i=20; i < *size-20; i++){ + if (dest[i] >= high) bit = 1; + if (dest[i] <= low) bit = 0; + dest[i] = bit; + } + //now demod based on clock (rf/32 = 32 1's for one 1 bit, 32 0's for one 0 bit) + size_t lastBit = 0; + size_t numBits = 0; + for(i=21; i < *size-20; i++) { + //if transition detected or large number of same bits - store the passed bits + 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; +} +int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) { + int startIdx = 0; + return nrzRawDemod_ext(dest, size, clk, invert, &startIdx); +} + +//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, int *startIdx) { + size_t last_transition = 0; + size_t idx = 1; + if (fchigh==0) fchigh=10; + if (fclow==0) fclow=8; + //set the threshold close to 0 (graph) or 128 std to avoid static + uint8_t threshold_value = 123; + size_t preLastSample = 0; + size_t LastSample = 0; size_t currSample = 0; if ( size < 1024 ) return 0; // not enough samples @@ -577,9 +798,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, int *startIdx) -{ +size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow, int *startIdx) { uint8_t lastval=dest[0]; size_t idx=0; size_t numBits=0; @@ -641,257 +860,200 @@ int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t 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) -{ - if (justNoise(dest, *size)) return -1; - - size_t numStart=0, size2=*size, startIdx=0; - // FSK demodulator - *size = fskdemod(dest, size2,50,1,10,8); //fsk2a - if (*size < 96*2) return -2; - // 00011101 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1 - uint8_t preamble[] = {0,0,0,1,1,1,0,1}; - // find bitstring in array - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -3; //preamble not found - - numStart = startIdx + sizeof(preamble); - // final loop, go over previously decoded FSK data and manchester decode into usable tag ID - for (size_t idx = numStart; (idx-numStart) < *size - sizeof(preamble); idx+=2){ - if (dest[idx] == dest[idx+1]){ - return -4; //not manchester data +// by marshmellow +// convert psk1 demod to psk2 demod +// only transition waves are 1s +void psk1TOpsk2(uint8_t *BitStream, size_t size) { + size_t i=1; + uint8_t lastBit=BitStream[0]; + for (; i>31); - *hi = (*hi<<1)|(*lo>>31); - //Then, shift in a 0 or one into low - if (dest[idx] && !dest[idx+1]) // 1 0 - *lo=(*lo<<1)|1; - else // 0 1 - *lo=(*lo<<1)|0; } - return (int)startIdx; + return; } -// loop to get raw paradox waveform then FSK demodulate the TAG ID from it -int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo) -{ - if (justNoise(dest, *size)) return -1; - - size_t numStart=0, size2=*size, startIdx=0; - // FSK demodulator - *size = fskdemod(dest, size2,50,1,10,8); //fsk2a - if (*size < 96) return -2; - - // 00001111 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1 - uint8_t preamble[] = {0,0,0,0,1,1,1,1}; - - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -3; //preamble not found - - numStart = startIdx + sizeof(preamble); - // final loop, go over previously decoded FSK data and manchester decode into usable tag ID - for (size_t idx = numStart; (idx-numStart) < *size - sizeof(preamble); idx+=2){ - if (dest[idx] == dest[idx+1]) - return -4; //not manchester data - *hi2 = (*hi2<<1)|(*hi>>31); - *hi = (*hi<<1)|(*lo>>31); - //Then, shift in a 0 or one into low - if (dest[idx] && !dest[idx+1]) // 1 0 - *lo=(*lo<<1)|1; - else // 0 1 - *lo=(*lo<<1)|0; +// by marshmellow +// convert psk2 demod to psk1 demod +// from only transition waves are 1s to phase shifts change bit +void psk2TOpsk1(uint8_t *BitStream, size_t size) { + uint8_t phase=0; + for (size_t i=0; i> 8; + if (fc2 == 10) return -1; //fsk found - quit + fc = fc & 0xFF; + if (fc!=2 && fc!=4 && fc!=8) return -1; + //PrintAndLog("DEBUG: FC: %d",fc); + *clock = DetectPSKClock(dest, *size, *clock); + if (*clock == 0) return -1; -// by marshmellow -// find viking preamble 0xF200 in already demoded data -int VikingDemod_AM(uint8_t *dest, size_t *size) { - //make sure buffer has data - if (*size < 64*2) return -2; + //find start of modulating data in trace + uint8_t threshold_value = 123; //-5 + i = findModStart(dest, *size, threshold_value, fc); - size_t startIdx = 0; - uint8_t preamble[] = {1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found - uint32_t checkCalc = bytebits_to_byte(dest+startIdx,8) ^ bytebits_to_byte(dest+startIdx+8,8) ^ bytebits_to_byte(dest+startIdx+16,8) - ^ bytebits_to_byte(dest+startIdx+24,8) ^ bytebits_to_byte(dest+startIdx+32,8) ^ bytebits_to_byte(dest+startIdx+40,8) - ^ bytebits_to_byte(dest+startIdx+48,8) ^ bytebits_to_byte(dest+startIdx+56,8); - if ( checkCalc != 0xA8 ) return -5; - if (*size != 64) return -6; - //return start position - return (int) startIdx; -} + //find first phase shift + int avgWaveVal=0, lastAvgWaveVal=0; + waveStart = i; + for (; i= dest[i+2]){ + waveEnd = i+1; + if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart); + waveLenCnt = waveEnd-waveStart; + if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+3)){ //not first peak and is a large wave but not out of whack + lastAvgWaveVal = avgWaveVal/(waveLenCnt); + firstFullWave = waveStart; + fullWaveLen=waveLenCnt; + //if average wave value is > graph 0 then it is an up wave or a 1 (could cause inverting) + if (lastAvgWaveVal > threshold_value) curPhase ^= 1; + break; + } -// find presco preamble 0x10D in already demoded data -int PrescoDemod(uint8_t *dest, size_t *size) { - //make sure buffer has data - if (*size < 64*2) return -2; + waveStart = i+1; + avgWaveVal = 0; + } + avgWaveVal += dest[i+2]; + } + if (firstFullWave == 0) { + // no phase shift detected - could be all 1's or 0's - doesn't matter where we start + // so skip a little to ensure we are past any Start Signal + firstFullWave = 160; + memset(dest, curPhase, firstFullWave / *clock); + } else { + memset(dest, curPhase^1, firstFullWave / *clock); + } + //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, 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 + for (i = firstFullWave + fullWaveLen - 1; i < *size-3; i++){ + //top edge of wave = start of new wave + if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){ + if (waveStart == 0) { + waveStart = i+1; + waveLenCnt = 0; + avgWaveVal = dest[i+1]; + } else { //waveEnd + waveEnd = i+1; + waveLenCnt = waveEnd-waveStart; + lastAvgWaveVal = avgWaveVal/waveLenCnt; + if (waveLenCnt > fc){ + //PrintAndLog("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal); + //this wave is a phase shift + //PrintAndLog("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc); + if (i+1 >= lastClkBit + *clock - tol){ //should be a clock bit + curPhase ^= 1; + dest[numBits++] = curPhase; + lastClkBit += *clock; + } else if (i < lastClkBit+10+fc){ + //noise after a phase shift - ignore + } else { //phase shift before supposed to based on clock + errCnt++; + dest[numBits++] = 7; + } + } else if (i+1 > lastClkBit + *clock + tol + fc){ + lastClkBit += *clock; //no phase shift but clock bit + dest[numBits++] = curPhase; + } else if (waveLenCnt < fc - 1) { //wave is smaller than field clock (shouldn't happen often) + errCnt2++; + if(errCnt2 > 101) return errCnt2; + } + avgWaveVal = 0; + waveStart = i+1; + } + } + avgWaveVal += dest[i+1]; + } + *size = numBits; + return errCnt; +} - size_t startIdx = 0; - uint8_t preamble[] = {1,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0}; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found - //return start position - return (int) startIdx; +int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) { + int startIdx = 0; + return pskRawDemod_ext(dest, size, clock, invert, &startIdx); } -// Ask/Biphase Demod then try to locate an ISO 11784/85 ID -// BitStream must contain previously askrawdemod and biphasedemoded data -int FDXBdemodBI(uint8_t *dest, size_t *size) -{ - //make sure buffer has enough data - if (*size < 128) return -1; +//-------------------Clock / Bitrate Detection Section------------------------------------------------------------------------------------ - size_t startIdx = 0; - uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,1}; +// by marshmellow +// to help detect clocks on heavily clipped samples +// based on count of low to low +int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low, int *clock) { + uint8_t fndClk[] = {8,16,32,40,50,64,128}; + size_t startwave; + size_t i = 100; + size_t minClk = 255; + int shortestWaveIdx = 0; + // get to first full low to prime loop and skip incomplete first pulse + while ((dest[i] < high) && (i < size)) + ++i; + while ((dest[i] > low) && (i < size)) + ++i; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -2; //preamble not found - return (int)startIdx; -} - -// by marshmellow -// FSK Demod then try to locate an AWID ID -int AWIDdemodFSK(uint8_t *dest, size_t *size) -{ - //make sure buffer has enough data - if (*size < 96*50) return -1; - - if (justNoise(dest, *size)) return -2; - - // FSK demodulator - *size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50 - if (*size < 96) return -3; //did we get a good demod? - - uint8_t preamble[] = {0,0,0,0,0,0,0,1}; - size_t startIdx = 0; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found - if (*size != 96) return -5; - return (int)startIdx; -} - -// by marshmellow -// FSK Demod then try to locate a Farpointe Data (pyramid) ID -int PyramiddemodFSK(uint8_t *dest, size_t *size) -{ - //make sure buffer has data - if (*size < 128*50) return -5; - - //test samples are not just noise - if (justNoise(dest, *size)) return -1; - - // FSK demodulator - *size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50 - if (*size < 128) return -2; //did we get a good demod? - - uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; - size_t startIdx = 0; - uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); - if (errChk == 0) return -4; //preamble not found - if (*size != 128) return -3; - return (int)startIdx; -} - -// by marshmellow -// to detect a wave that has heavily clipped (clean) samples -uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low) -{ - bool allArePeaks = true; - uint16_t cntPeaks=0; - size_t loopEnd = 512+160; - if (loopEnd > size) loopEnd = size; - for (size_t i=160; ilow && dest[i] 300) return true; - } - return allArePeaks; -} -// by marshmellow -// to help detect clocks on heavily clipped samples -// based on count of low to low -int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low, int *clock) { - uint8_t fndClk[] = {8,16,32,40,50,64,128}; - size_t startwave; - size_t i = 100; - size_t minClk = 255; - int shortestWaveIdx = 0; - // get to first full low to prime loop and skip incomplete first pulse - while ((dest[i] < high) && (i < size)) - ++i; - while ((dest[i] > low) && (i < size)) - ++i; - - // loop through all samples - while (i < size) { - // measure from low to low - while ((dest[i] > low) && (i < size)) - ++i; - startwave = i; - while ((dest[i] < high) && (i < size)) - ++i; - while ((dest[i] > low) && (i < size)) - ++i; - //get minimum measured distance - if (i-startwave < minClk && i < size) { - minClk = i - startwave; - shortestWaveIdx = startwave; - } - } - // set clock - if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk); - for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { - if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) { - *clock = fndClk[clkCnt]; - return shortestWaveIdx; - } - } - return 0; + // loop through all samples + while (i < size) { + // measure from low to low + while ((dest[i] > low) && (i < size)) + ++i; + startwave = i; + while ((dest[i] < high) && (i < size)) + ++i; + while ((dest[i] > low) && (i < size)) + ++i; + //get minimum measured distance + if (i-startwave < minClk && i < size) { + minClk = i - startwave; + shortestWaveIdx = startwave; + } + } + // set clock + if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk); + for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { + if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) { + *clock = fndClk[clkCnt]; + return shortestWaveIdx; + } + } + return 0; } // by marshmellow // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping) // maybe somehow adjust peak trimming value based on samples to fix? // 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; uint8_t clk[] = {255,8,16,32,40,50,64,100,128,255}; uint8_t clkEnd = 9; @@ -987,108 +1149,6 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) return bestStart[best]; } -//by marshmellow -//detect psk clock by reading each phase shift -// a phase shift is determined by measuring the sample length of each wave -int DetectPSKClock_ext(uint8_t dest[], size_t size, int clock, int *firstPhaseShift) { - 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... - if (size == 0) return 0; - if (size= dest[i+2]){ - if (waveStart == 0) { - waveStart = i+1; - //prnt("DEBUG: waveStart: %d",waveStart); - } else { - waveEnd = i+1; - //prnt("DEBUG: waveEnd: %d",waveEnd); - waveLenCnt = waveEnd-waveStart; - if (waveLenCnt > fc){ - firstFullWave = waveStart; - fullWaveLen=waveLenCnt; - break; - } - waveStart=0; - } - } - } - *firstPhaseShift = firstFullWave; - 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 - for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ - lastClkBit = firstFullWave; //set end of wave as clock align - waveStart = 0; - errCnt=0; - peakcnt=0; - if (g_debugMode == 2) prnt("DEBUG PSK: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit); - - for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){ - //top edge of wave = start of new wave - if (dest[i] < dest[i+1] && dest[i+1] >= dest[i+2]){ - if (waveStart == 0) { - waveStart = i+1; - waveLenCnt=0; - } else { //waveEnd - waveEnd = i+1; - waveLenCnt = waveEnd-waveStart; - if (waveLenCnt > fc){ - //if this wave is a phase shift - if (g_debugMode == 2) prnt("DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,i+1,fc); - if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit - peakcnt++; - lastClkBit+=clk[clkCnt]; - } else if (i lastClkBit + clk[clkCnt] + tol + fc){ - lastClkBit+=clk[clkCnt]; //no phase shift but clock bit - } - waveStart=i+1; - } - } - } - if (errCnt == 0){ - return clk[clkCnt]; - } - if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt]=errCnt; - if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt]=peakcnt; - } - //all tested with errors - //return the highest clk with the most peaks found - uint8_t best=7; - for (i=7; i>=1; i--){ - if (peaksdet[i] > peaksdet[best]) { - 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]); - } - 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; @@ -1241,101 +1301,194 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) { return DetectNRZClock_ext(dest, size, clock, &bestStart); } -// by marshmellow -// convert psk1 demod to psk2 demod -// only transition waves are 1s -void psk1TOpsk2(uint8_t *BitStream, size_t size) -{ - size_t i=1; - uint8_t lastBit=BitStream[0]; - for (; i BitStream[i-1] && BitStream[i] >= BitStream[i+1]) + break; + + for (; i < size-20; i++){ + if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]){ + // new up transition + fcCounter++; + if (fskAdj){ + //if we had 5 and now have 9 then go back to 8 (for when we get a fc 9 instead of an 8) + if (lastFCcnt==5 && fcCounter==9) fcCounter--; + //if fc=9 or 4 add one (for when we get a fc 9 instead of 10 or a 4 instead of a 5) + if ((fcCounter==9) || fcCounter==4) fcCounter++; + // save last field clock count (fc/xx) + lastFCcnt = fcCounter; + } + // find which fcLens to save it to: + for (int ii=0; ii<15; ii++){ + if (fcLens[ii]==fcCounter){ + fcCnts[ii]++; + fcCounter=0; + break; + } + } + if (fcCounter>0 && fcLensFnd<15){ + //add new fc length + fcCnts[fcLensFnd]++; + fcLens[fcLensFnd++]=fcCounter; + } + fcCounter=0; } else { - BitStream[i]=0; + // count sample + fcCounter++; } } - return; -} - -// by marshmellow -// convert psk2 demod to psk1 demod -// from only transition waves are 1s to phase shifts change bit -void psk2TOpsk1(uint8_t *BitStream, size_t size) -{ - uint8_t phase=0; - for (size_t i=0; imaxCnt1) { + best3=best2; + best2=best1; + maxCnt1=fcCnts[i]; + best1=i; + } else if(fcCnts[i]>fcCnts[best2]){ + best3=best2; + best2=i; + } else if(fcCnts[i]>fcCnts[best3]){ + best3=i; } - BitStream[i]=phase; + if (g_debugMode==2) prnt("DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u",fcLens[i],fcCnts[i],fcLens[best1],fcLens[best2]); } - return; + if (fcLens[best1]==0) return 0; + uint8_t fcH=0, fcL=0; + if (fcLens[best1]>fcLens[best2]){ + fcH=fcLens[best1]; + fcL=fcLens[best2]; + } else{ + fcH=fcLens[best2]; + fcL=fcLens[best1]; + } + if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) { + if (g_debugMode==2) prnt("DEBUG countfc: fc is too large: %u > %u. Not psk or fsk",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]); + return 0; //lots of waves not psk or fsk + } + // TODO: take top 3 answers and compare to known Field clocks to get top 2 + + uint16_t fcs = (((uint16_t)fcH)<<8) | fcL; + if (fskAdj) return fcs; + return fcLens[best1]; } -// redesigned by marshmellow adjusted from existing decode functions -// indala id decoding - only tested on 26 bit tags, but attempted to make it work for more -int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert) -{ - //26 bit 40134 format (don't know other formats) - uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; - uint8_t preamble_i[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0}; - size_t startidx = 0; - if (!preambleSearch(bitStream, preamble, sizeof(preamble), size, &startidx)){ - // if didn't find preamble try again inverting - if (!preambleSearch(bitStream, preamble_i, sizeof(preamble_i), size, &startidx)) return -1; - *invert ^= 1; - } - if (*size != 64 && *size != 224) return -2; - if (*invert==1) - for (size_t i = startidx; i < *size; i++) - bitStream[i] ^= 1; +//by marshmellow +//detect psk clock by reading each phase shift +// a phase shift is determined by measuring the sample length of each wave +int DetectPSKClock_ext(uint8_t dest[], size_t size, int clock, int *firstPhaseShift) { + 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... + if (size == 0) return 0; + if (size*size) gLen = *size-20; - int high, low; - if (getHiLo(dest, gLen, &high, &low, 75, 75) < 1) return -3; //25% fuzz on high 25% fuzz on low - - uint8_t bit=0; - //convert wave samples to 1's and 0's - for(i=20; i < *size-20; i++){ - if (dest[i] >= high) bit = 1; - if (dest[i] <= low) bit = 0; - dest[i] = bit; + size_t waveStart=0, waveEnd=0, firstFullWave=0, lastClkBit=0; + uint8_t clkCnt, fc=0, fullWaveLen=0, tol=1; + uint16_t peakcnt=0, errCnt=0, waveLenCnt=0; + uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; + uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0}; + fc = countFC(dest, size, 0); + if (fc!=2 && fc!=4 && fc!=8) return -1; + if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc); + + //find first full wave + for (i=160; i= dest[i+2]){ + if (waveStart == 0) { + waveStart = i+1; + //prnt("DEBUG: waveStart: %d",waveStart); + } else { + waveEnd = i+1; + //prnt("DEBUG: waveEnd: %d",waveEnd); + waveLenCnt = waveEnd-waveStart; + if (waveLenCnt > fc){ + firstFullWave = waveStart; + fullWaveLen=waveLenCnt; + break; + } + waveStart=0; + } + } } - //now demod based on clock (rf/32 = 32 1's for one 1 bit, 32 0's for one 0 bit) - size_t lastBit = 0; - size_t numBits = 0; - for(i=21; i < *size-20; i++) { - //if transition detected or large number of same bits - store the passed bits - 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); + *firstPhaseShift = firstFullWave; + 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 + for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ + lastClkBit = firstFullWave; //set end of wave as clock align + waveStart = 0; + errCnt=0; + peakcnt=0; + if (g_debugMode == 2) prnt("DEBUG PSK: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit); + + for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){ + //top edge of wave = start of new wave + if (dest[i] < dest[i+1] && dest[i+1] >= dest[i+2]){ + if (waveStart == 0) { + waveStart = i+1; + waveLenCnt=0; + } else { //waveEnd + waveEnd = i+1; + waveLenCnt = waveEnd-waveStart; + if (waveLenCnt > fc){ + //if this wave is a phase shift + if (g_debugMode == 2) prnt("DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,i+1,fc); + if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit + peakcnt++; + lastClkBit+=clk[clkCnt]; + } else if (i lastClkBit + clk[clkCnt] + tol + fc){ + lastClkBit+=clk[clkCnt]; //no phase shift but clock bit + } + waveStart=i+1; + } } - lastBit = i-1; } + if (errCnt == 0){ + return clk[clkCnt]; + } + if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt]=errCnt; + if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt]=peakcnt; + } + //all tested with errors + //return the highest clk with the most peaks found + uint8_t best=7; + for (i=7; i>=1; i--){ + if (peaksdet[i] > peaksdet[best]) { + 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]); } - *size = numBits; - return 0; + return clk[best]; } -int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) { - int startIdx = 0; - return nrzRawDemod_ext(dest, size, clk, invert, &startIdx); + +int DetectPSKClock(uint8_t dest[], size_t size, int clock) { + int firstPhaseShift = 0; + return DetectPSKClock_ext(dest, size, clock, &firstPhaseShift); } //by marshmellow @@ -1451,402 +1604,260 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc return detectFSKClk_ext(BitStream, size, fcHigh, fcLow, &firstClockEdge); } +//-----------------Tag format detection section-------------------------------------------------------------- + +// by marshmellow +// FSK Demod then try to locate an AWID ID +int AWIDdemodFSK(uint8_t *dest, size_t *size) { + //make sure buffer has enough data + if (*size < 96*50) return -1; + + if (justNoise(dest, *size)) return -2; + + // FSK demodulator + *size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50 + if (*size < 96) return -3; //did we get a good demod? + + uint8_t preamble[] = {0,0,0,0,0,0,0,1}; + size_t startIdx = 0; + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -4; //preamble not found + if (*size != 96) return -5; + return (int)startIdx; +} + //by marshmellow -//countFC is to detect the field clock lengths. -//counts and returns the 2 most common wave lengths -//mainly used for FSK field clock detection -uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj) +//takes 1s and 0s and searches for EM410x format - output EM ID +uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) { - uint8_t fcLens[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - uint8_t fcLensFnd = 0; - uint8_t lastFCcnt = 0; - uint8_t fcCounter = 0; - size_t i; - if (size < 180) return 0; + //sanity checks + if (*size < 64) return 0; + if (BitStream[1]>1) return 0; //allow only 1s and 0s - // prime i to first up transition - for (i = 160; i < size-20; i++) - if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]) - break; + // 111111111 bit pattern represent start of frame + // include 0 in front to help get start pos + uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1}; + uint8_t errChk = 0; + uint8_t FmtLen = 10; // sets of 4 bits = end data + *startIdx = 0; + errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx); + if ( errChk == 0 || (*size != 64 && *size != 128) ) return 0; + if (*size == 128) FmtLen = 22; // 22 sets of 4 bits - for (; i < size-20; i++){ - if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]){ - // new up transition - fcCounter++; - if (fskAdj){ - //if we had 5 and now have 9 then go back to 8 (for when we get a fc 9 instead of an 8) - if (lastFCcnt==5 && fcCounter==9) fcCounter--; - //if fc=9 or 4 add one (for when we get a fc 9 instead of 10 or a 4 instead of a 5) - if ((fcCounter==9) || fcCounter==4) fcCounter++; - // save last field clock count (fc/xx) - lastFCcnt = fcCounter; - } - // find which fcLens to save it to: - for (int ii=0; ii<15; ii++){ - if (fcLens[ii]==fcCounter){ - fcCnts[ii]++; - fcCounter=0; - break; - } - } - if (fcCounter>0 && fcLensFnd<15){ - //add new fc length - fcCnts[fcLensFnd]++; - fcLens[fcLensFnd++]=fcCounter; - } - fcCounter=0; - } else { - // count sample - fcCounter++; - } - } - - uint8_t best1=14, best2=14, best3=14; - uint16_t maxCnt1=0; - // go through fclens and find which ones are bigest 2 - for (i=0; i<15; i++){ - // get the 3 best FC values - if (fcCnts[i]>maxCnt1) { - best3=best2; - best2=best1; - maxCnt1=fcCnts[i]; - best1=i; - } else if(fcCnts[i]>fcCnts[best2]){ - best3=best2; - best2=i; - } else if(fcCnts[i]>fcCnts[best3]){ - best3=i; - } - if (g_debugMode==2) prnt("DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u",fcLens[i],fcCnts[i],fcLens[best1],fcLens[best2]); - } - if (fcLens[best1]==0) return 0; - uint8_t fcH=0, fcL=0; - if (fcLens[best1]>fcLens[best2]){ - fcH=fcLens[best1]; - fcL=fcLens[best2]; - } else{ - fcH=fcLens[best2]; - fcL=fcLens[best1]; - } - if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) { - if (g_debugMode==2) prnt("DEBUG countfc: fc is too large: %u > %u. Not psk or fsk",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]); - return 0; //lots of waves not psk or fsk + //skip last 4bit parity row for simplicity + *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, FmtLen * 5); + if (*size == 40) { // std em410x format + *hi = 0; + *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32)); + } else if (*size == 88) { // long em format + *hi = (bytebits_to_byte(BitStream, 24)); + *lo = ((uint64_t)(bytebits_to_byte(BitStream + 24, 32)) << 32) | (bytebits_to_byte(BitStream + 24 + 32, 32)); + } else { + return 0; } - // TODO: take top 3 answers and compare to known Field clocks to get top 2 - - uint16_t fcs = (((uint16_t)fcH)<<8) | fcL; - if (fskAdj) return fcs; - return fcLens[best1]; + return 1; } -//by marshmellow - demodulate PSK1 wave -//uses wave lengths (# Samples) -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> 8; - if (fc2 == 10) return -1; //fsk found - quit - fc = fc & 0xFF; - if (fc!=2 && fc!=4 && fc!=8) return -1; - //PrintAndLog("DEBUG: FC: %d",fc); - *clock = DetectPSKClock(dest, *size, *clock); - if (*clock == 0) return -1; + size_t startIdx = 0; + uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,1}; - //find start of modulating data in trace - uint8_t threshold_value = 123; //-5 - i = findModStart(dest, *size, threshold_value, fc); + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -2; //preamble not found + return (int)startIdx; +} - //find first phase shift - int avgWaveVal=0, lastAvgWaveVal=0; - waveStart = i; - for (; i= dest[i+2]){ - waveEnd = i+1; - if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart); - waveLenCnt = waveEnd-waveStart; - if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+3)){ //not first peak and is a large wave but not out of whack - lastAvgWaveVal = avgWaveVal/(waveLenCnt); - firstFullWave = waveStart; - fullWaveLen=waveLenCnt; - //if average wave value is > graph 0 then it is an up wave or a 1 (could cause inverting) - if (lastAvgWaveVal > threshold_value) curPhase ^= 1; - break; - } +// by marshmellow +// demod gProxIIDemod +// error returns as -x +// success returns start position in BitStream +// BitStream must contain previously askrawdemod and biphasedemoded data +int gProxII_Demod(uint8_t BitStream[], size_t *size) { + size_t startIdx=0; + uint8_t preamble[] = {1,1,1,1,1,0}; - waveStart = i+1; - avgWaveVal = 0; - } - avgWaveVal += dest[i+2]; - } - if (firstFullWave == 0) { - // no phase shift detected - could be all 1's or 0's - doesn't matter where we start - // so skip a little to ensure we are past any Start Signal - firstFullWave = 160; - memset(dest, curPhase, firstFullWave / *clock); - } else { - memset(dest, curPhase^1, firstFullWave / *clock); - } - //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, 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 - for (i = firstFullWave + fullWaveLen - 1; i < *size-3; i++){ - //top edge of wave = start of new wave - if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){ - if (waveStart == 0) { - waveStart = i+1; - waveLenCnt = 0; - avgWaveVal = dest[i+1]; - } else { //waveEnd - waveEnd = i+1; - waveLenCnt = waveEnd-waveStart; - lastAvgWaveVal = avgWaveVal/waveLenCnt; - if (waveLenCnt > fc){ - //PrintAndLog("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal); - //this wave is a phase shift - //PrintAndLog("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc); - if (i+1 >= lastClkBit + *clock - tol){ //should be a clock bit - curPhase ^= 1; - dest[numBits++] = curPhase; - lastClkBit += *clock; - } else if (i < lastClkBit+10+fc){ - //noise after a phase shift - ignore - } else { //phase shift before supposed to based on clock - errCnt++; - dest[numBits++] = 7; - } - } else if (i+1 > lastClkBit + *clock + tol + fc){ - lastClkBit += *clock; //no phase shift but clock bit - dest[numBits++] = curPhase; - } else if (waveLenCnt < fc - 1) { //wave is smaller than field clock (shouldn't happen often) - errCnt2++; - if(errCnt2 > 101) return errCnt2; - } - avgWaveVal = 0; - waveStart = i+1; - } - } - avgWaveVal += dest[i+1]; + uint8_t errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -3; //preamble not found + if (*size != 96) return -2; //should have found 96 bits + //check first 6 spacer bits to verify format + if (!BitStream[startIdx+5] && !BitStream[startIdx+10] && !BitStream[startIdx+15] && !BitStream[startIdx+20] && !BitStream[startIdx+25] && !BitStream[startIdx+30]){ + //confirmed proper separator bits found + //return start position + return (int) startIdx; } - *size = numBits; - return errCnt; -} - -int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) { - int startIdx = 0; - return pskRawDemod_ext(dest, size, clock, invert, &startIdx); + return -5; //spacer bits not found - not a valid gproxII } -//by marshmellow -//attempt to identify a Sequence Terminator in ASK modulated raw wave -bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststart, size_t *stend) { - size_t bufsize = *size; - //need to loop through all samples and identify our clock, look for the ST pattern - uint8_t fndClk[] = {8,16,32,40,50,64,128}; - int clk = 0; - int tol = 0; - int i, j, skip, start, end, low, high, minClk, waveStart; - bool complete = false; - int tmpbuff[bufsize / 32]; //guess rf/32 clock, if click is smaller we will only have room for a fraction of the samples captured - int waveLen[bufsize / 32]; // if clock is larger then we waste memory in array size that is not needed... - size_t testsize = (bufsize < 512) ? bufsize : 512; - int phaseoff = 0; - high = low = 128; - memset(tmpbuff, 0, sizeof(tmpbuff)); +// 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) { + if (justNoise(dest, *size)) return -1; - if ( getHiLo(buffer, testsize, &high, &low, 80, 80) == -1 ) { - if (g_debugMode==2) prnt("DEBUG STT: just noise detected - quitting"); - return false; //just noise - } - i = 0; - j = 0; - minClk = 255; - // get to first full low to prime loop and skip incomplete first pulse - while ((buffer[i] < high) && (i < bufsize)) - ++i; - while ((buffer[i] > low) && (i < bufsize)) - ++i; - skip = i; + size_t numStart=0, size2=*size, startIdx=0; + // FSK demodulator + *size = fskdemod(dest, size2,50,1,10,8); //fsk2a + if (*size < 96*2) return -2; + // 00011101 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1 + uint8_t preamble[] = {0,0,0,1,1,1,0,1}; + // find bitstring in array + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -3; //preamble not found - // populate tmpbuff buffer with pulse lengths - while (i < bufsize) { - // measure from low to low - while ((buffer[i] > low) && (i < bufsize)) - ++i; - start= i; - while ((buffer[i] < high) && (i < bufsize)) - ++i; - //first high point for this wave - waveStart = i; - while ((buffer[i] > low) && (i < bufsize)) - ++i; - if (j >= (bufsize/32)) { - break; - } - waveLen[j] = i - waveStart; //first high to first low - tmpbuff[j++] = i - start; - if (i-start < minClk && i < bufsize) { - minClk = i - start; + numStart = startIdx + sizeof(preamble); + // final loop, go over previously decoded FSK data and manchester decode into usable tag ID + for (size_t idx = numStart; (idx-numStart) < *size - sizeof(preamble); idx+=2){ + if (dest[idx] == dest[idx+1]){ + return -4; //not manchester data } + *hi2 = (*hi2<<1)|(*hi>>31); + *hi = (*hi<<1)|(*lo>>31); + //Then, shift in a 0 or one into low + if (dest[idx] && !dest[idx+1]) // 1 0 + *lo=(*lo<<1)|1; + else // 0 1 + *lo=(*lo<<1)|0; } - // set clock - might be able to get this externally and remove this work... - if (!clk) { - for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { - tol = fndClk[clkCnt]/8; - if (minClk >= fndClk[clkCnt]-tol && minClk <= fndClk[clkCnt]+1) { - clk=fndClk[clkCnt]; - break; - } - } - // clock not found - ERROR - if (!clk) { - if (g_debugMode==2) prnt("DEBUG STT: clock not found - quitting"); - return false; - } - } else tol = clk/8; + return (int)startIdx; +} - *foundclock = clk; +int IOdemodFSK(uint8_t *dest, size_t size) { + if (justNoise(dest, size)) return -1; + //make sure buffer has data + if (size < 66*64) return -2; + // FSK demodulator + size = fskdemod(dest, size, 64, 1, 10, 8); // FSK2a RF/64 + if (size < 65) return -3; //did we get a good demod? + //Index map + //0 10 20 30 40 50 60 + //| | | | | | | + //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23 + //----------------------------------------------------------------------------- + //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11 + // + //XSF(version)facility:codeone+codetwo + //Handle the data + size_t startIdx = 0; + uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,1}; + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), &size, &startIdx); + if (errChk == 0) return -4; //preamble not found - // look for Sequence Terminator - should be pulses of clk*(1 or 1.5), clk*2, clk*(1.5 or 2) - start = -1; - for (i = 0; i < j - 4; ++i) { - skip += tmpbuff[i]; - if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol && waveLen[i] < clk+tol) { //1 to 2 clocks depending on 2 bits prior - if (tmpbuff[i+1] >= clk*2-tol && tmpbuff[i+1] <= clk*2+tol && waveLen[i+1] > clk*3/2-tol) { //2 clocks and wave size is 1 1/2 - if (tmpbuff[i+2] >= (clk*3)/2-tol && tmpbuff[i+2] <= clk*2+tol && waveLen[i+2] > clk-tol) { //1 1/2 to 2 clocks and at least one full clock wave - if (tmpbuff[i+3] >= clk*1-tol && tmpbuff[i+3] <= clk*2+tol) { //1 to 2 clocks for end of ST + first bit - start = i + 3; - break; - } - } - } - } - } - // first ST not found - ERROR - if (start < 0) { - if (g_debugMode==2) prnt("DEBUG STT: first STT not found - quitting"); - return false; - } else { - if (g_debugMode==2) prnt("DEBUG STT: first STT found at: %d, j=%d",start, j); + if (!dest[startIdx+8] && dest[startIdx+17]==1 && dest[startIdx+26]==1 && dest[startIdx+35]==1 && dest[startIdx+44]==1 && dest[startIdx+53]==1){ + //confirmed proper separator bits found + //return start position + return (int) startIdx; } - if (waveLen[i+2] > clk*1+tol) - phaseoff = 0; - else - phaseoff = clk/2; - - // skip over the remainder of ST - skip += clk*7/2; //3.5 clocks from tmpbuff[i] = end of st - also aligns for ending point + return -5; +} - // now do it again to find the end - end = skip; - for (i += 3; i < j - 4; ++i) { - end += tmpbuff[i]; - if (tmpbuff[i] >= clk*1-tol && tmpbuff[i] <= (clk*2)+tol && waveLen[i] < clk+tol) { //1 to 2 clocks depending on 2 bits prior - if (tmpbuff[i+1] >= clk*2-tol && tmpbuff[i+1] <= clk*2+tol && waveLen[i+1] > clk*3/2-tol) { //2 clocks and wave size is 1 1/2 - if (tmpbuff[i+2] >= (clk*3)/2-tol && tmpbuff[i+2] <= clk*2+tol && waveLen[i+2] > clk-tol) { //1 1/2 to 2 clocks and at least one full clock wave - if (tmpbuff[i+3] >= clk*1-tol && tmpbuff[i+3] <= clk*2+tol) { //1 to 2 clocks for end of ST + first bit - complete = true; - break; - } - } - } - } - } - end -= phaseoff; - //didn't find second ST - ERROR - if (!complete) { - if (g_debugMode==2) prnt("DEBUG STT: second STT not found - quitting"); - return false; - } - if (g_debugMode==2) prnt("DEBUG STT: start of data: %d end of data: %d, datalen: %d, clk: %d, bits: %d, phaseoff: %d", skip, end, end-skip, clk, (end-skip)/clk, phaseoff); - //now begin to trim out ST so we can use normal demod cmds - start = skip; - size_t datalen = end - start; - // check validity of datalen (should be even clock increments) - use a tolerance of up to 1/8th a clock - if ( clk - (datalen % clk) <= clk/8) { - // padd the amount off - could be problematic... but shouldn't happen often - datalen += clk - (datalen % clk); - } else if ( (datalen % clk) <= clk/8 ) { - // padd the amount off - could be problematic... but shouldn't happen often - datalen -= datalen % clk; - } else { - if (g_debugMode==2) prnt("DEBUG STT: datalen not divisible by clk: %u %% %d = %d - quitting", datalen, clk, datalen % clk); - return false; - } - // if datalen is less than one t55xx block - ERROR - if (datalen/clk < 8*4) { - if (g_debugMode==2) prnt("DEBUG STT: datalen is less than 1 full t55xx block - quitting"); - return false; - } - size_t dataloc = start; - if (buffer[dataloc-(clk*4)-(clk/8)] <= low && buffer[dataloc] <= low && buffer[dataloc-(clk*4)] >= high) { - //we have low drift (and a low just before the ST and a low just after the ST) - compensate by backing up the start - for ( i=0; i <= (clk/8); ++i ) { - if ( buffer[dataloc - (clk*4) - i] <= low ) { - dataloc -= i; - break; - } - } - } +// redesigned by marshmellow adjusted from existing decode functions +// indala id decoding - only tested on 26 bit tags, but attempted to make it work for more +int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert) { + //26 bit 40134 format (don't know other formats) + uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; + uint8_t preamble_i[] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0}; + size_t startidx = 0; + if (!preambleSearch(bitStream, preamble, sizeof(preamble), size, &startidx)){ + // if didn't find preamble try again inverting + if (!preambleSearch(bitStream, preamble_i, sizeof(preamble_i), size, &startidx)) return -1; + *invert ^= 1; + } + if (*size != 64 && *size != 224) return -2; + if (*invert==1) + for (size_t i = startidx; i < *size; i++) + bitStream[i] ^= 1; + + return (int) startidx; +} + +// loop to get raw paradox waveform then FSK demodulate the TAG ID from it +int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo) { + if (justNoise(dest, *size)) return -1; - size_t newloc = 0; - i=0; - if (g_debugMode==2) prnt("DEBUG STT: Starting STT trim - start: %d, datalen: %d ",dataloc, datalen); - bool firstrun = true; - // warning - overwriting buffer given with raw wave data with ST removed... - while ( dataloc < bufsize-(clk/2) ) { - //compensate for long high at end of ST not being high due to signal loss... (and we cut out the start of wave high part) - if (buffer[dataloc]low && buffer[dataloc+3]low) { - for(i=0; i < clk/2-tol; ++i) { - buffer[dataloc+i] = high+5; - } - } //test for single sample outlier (high between two lows) in the case of very strong waves - if (buffer[dataloc] >= high && buffer[dataloc+2] <= low) { - buffer[dataloc] = buffer[dataloc+2]; - buffer[dataloc+1] = buffer[dataloc+2]; - } - if (firstrun) { - *stend = dataloc; - *ststart = dataloc-(clk*4); - firstrun=false; - } - for (i=0; i>31); + *hi = (*hi<<1)|(*lo>>31); + //Then, shift in a 0 or one into low + if (dest[idx] && !dest[idx+1]) // 1 0 + *lo=(*lo<<1)|1; + else // 0 1 + *lo=(*lo<<1)|0; } - *size = newloc; - return true; + return (int)startIdx; } -bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { - size_t ststart = 0, stend = 0; - return DetectST_ext(buffer, size, foundclock, &ststart, &stend); +// find presco preamble 0x10D in already demoded data +int PrescoDemod(uint8_t *dest, size_t *size) { + //make sure buffer has data + if (*size < 64*2) return -2; + + size_t startIdx = 0; + uint8_t preamble[] = {1,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0}; + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -4; //preamble not found + //return start position + return (int) startIdx; } +// by marshmellow +// FSK Demod then try to locate a Farpointe Data (pyramid) ID +int PyramiddemodFSK(uint8_t *dest, size_t *size) { + //make sure buffer has data + if (*size < 128*50) return -5; + + //test samples are not just noise + if (justNoise(dest, *size)) return -1; + + // FSK demodulator + *size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50 + if (*size < 128) return -2; //did we get a good demod? + + uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; + size_t startIdx = 0; + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -4; //preamble not found + if (*size != 128) return -3; + return (int)startIdx; +} + +// by marshmellow +// find viking preamble 0xF200 in already demoded data +int VikingDemod_AM(uint8_t *dest, size_t *size) { + //make sure buffer has data + if (*size < 64*2) return -2; + + size_t startIdx = 0; + uint8_t preamble[] = {1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx); + if (errChk == 0) return -4; //preamble not found + uint32_t checkCalc = bytebits_to_byte(dest+startIdx,8) ^ bytebits_to_byte(dest+startIdx+8,8) ^ bytebits_to_byte(dest+startIdx+16,8) + ^ bytebits_to_byte(dest+startIdx+24,8) ^ bytebits_to_byte(dest+startIdx+32,8) ^ bytebits_to_byte(dest+startIdx+40,8) + ^ bytebits_to_byte(dest+startIdx+48,8) ^ bytebits_to_byte(dest+startIdx+56,8); + if ( checkCalc != 0xA8 ) return -5; + if (*size != 64) return -6; + //return start position + return (int) startIdx; +} + + // by iceman // find Visa2000 preamble in already demoded data int Visa2kDemod_AM(uint8_t *dest, size_t *size) { -- 2.39.5