From 1e090a61a149a58a57e9d9acbf5e5532387867a4 Mon Sep 17 00:00:00 2001 From: marshmellow42 Date: Sun, 18 Jan 2015 18:13:32 -0500 Subject: [PATCH 1/5] lf demod additions data fskfcdetect (field clock and bit clock detect for FSK) data fskdemodawid -AWID demod/decode data fskdemodpyramid - AWID demod/decode --- client/cmddata.c | 264 ++++++++++++++++++++++- client/cmddata.h | 2 + client/cmdlf.c | 12 +- common/lfdemod.c | 544 +++++++++++++++++++++++++++++++++++------------ common/lfdemod.h | 13 +- 5 files changed, 690 insertions(+), 145 deletions(-) diff --git a/client/cmddata.c b/client/cmddata.c index a88fa4e1..60d0d875 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -327,7 +327,8 @@ int Cmdmandecoderaw(const char *Cmd) //by marshmellow //biphase decode //take 01 or 10 = 0 and 11 or 00 = 1 -//takes 1 argument "offset" default = 0 if 1 it will shift the decode by one bit +//takes 2 arguments "offset" default = 0 if 1 it will shift the decode by one bit +// and "invert" default = 0 if 1 it will invert output // since it is not like manchester and doesn't have an incorrect bit pattern we // cannot determine if our decode is correct or if it should be shifted by one bit // the argument offset allows us to manually shift if the output is incorrect @@ -339,8 +340,9 @@ int CmdBiphaseDecodeRaw(const char *Cmd) int errCnt=0; size_t size=0; int offset=0; + int invert=0; int high=0, low=0; - sscanf(Cmd, "%i", &offset); + sscanf(Cmd, "%i %i", &offset, &invert); uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; //get graphbuffer & high and low for (;i=20){ PrintAndLog("Too many errors attempting to decode: %d",errCnt); return 0; @@ -714,6 +716,228 @@ int CmdFSKdemodIO(const char *Cmd) DemodBufferLen=64; return 1; } + + +//by marshmellow +//AWID Prox demod - FSK RF/50 with preamble of 00000001 (always a 96 bit data stream) +//print full AWID Prox ID and some bit format details if found +int CmdFSKdemodAWID(const char *Cmd) +{ + + int verbose=1; + sscanf(Cmd, "%i", &verbose); + + //raw fsk demod no manchester decoding no start bit finding just get binary from wave + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; + size_t size = getFromGraphBuf(BitStream); + + //get binary from fsk wave + int idx = AWIDdemodFSK(BitStream, size); + if (idx<=0){ + if (verbose){ + if (idx == -1) + PrintAndLog("Error: not enough samples"); + else if (idx == -2) + PrintAndLog("Error: only noise found - no waves"); + else if (idx == -3) + PrintAndLog("Error: problem during FSK demod"); + // else if (idx == -3) + // PrintAndLog("Error: thought we had a tag but the parity failed"); + else if (idx == -4) + PrintAndLog("Error: AWID preamble not found"); + } + return 0; + } + + // Index map + // 0 10 20 30 40 50 60 + // | | | | | | | + // 01234567 890 1 234 5 678 9 012 3 456 7 890 1 234 5 678 9 012 3 456 7 890 1 234 5 678 9 012 3 - to 96 + // ----------------------------------------------------------------------------- + // 00000001 000 1 110 1 101 1 011 1 101 1 010 0 000 1 000 1 010 0 001 0 110 1 100 0 000 1 000 1 + // premable bbb o bbb o bbw o fff o fff o ffc o ccc o ccc o ccc o ccc o ccc o wxx o xxx o xxx o - to 96 + // |---26 bit---| |-----117----||-------------142-------------| + // b = format bit len, o = odd parity of last 3 bits + // f = facility code, c = card number + // w = wiegand parity + // (26 bit format shown) + + //get raw ID before removing parities + uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32); + uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32); + uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32); + size = removeParity(BitStream, idx+8, 4, 1, 88); + if (size != 66){ + if (verbose) PrintAndLog("Error: at parity check-tag size does not match AWID format"); + return 0; + } + // ok valid card found! + + // Index map + // 0 10 20 30 40 50 60 + // | | | | | | | + // 01234567 8 90123456 7890123456789012 3 456789012345678901234567890123456 + // ----------------------------------------------------------------------------- + // 00011010 1 01110101 0000000010001110 1 000000000000000000000000000000000 + // bbbbbbbb w ffffffff cccccccccccccccc w xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + // |26 bit| |-117--| |-----142------| + // b = format bit len, o = odd parity of last 3 bits + // f = facility code, c = card number + // w = wiegand parity + // (26 bit format shown) + + uint32_t fc = 0; + uint32_t cardnum = 0; + uint32_t code1 = 0; + uint32_t code2 = 0; + uint8_t fmtLen = bytebits_to_byte(BitStream,8); + if (fmtLen==26){ + fc = bytebits_to_byte(BitStream+9, 8); + cardnum = bytebits_to_byte(BitStream+17, 16); + code1 = bytebits_to_byte(BitStream+8,fmtLen); + PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x", fmtLen, fc, cardnum, code1, rawHi2, rawHi, rawLo); + } else { + cardnum = bytebits_to_byte(BitStream+8+(fmtLen-17), 16); + if (fmtLen>32){ + code1 = bytebits_to_byte(BitStream+8,fmtLen-32); + code2 = bytebits_to_byte(BitStream+8+(fmtLen-32),32); + PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x%08x, Raw: %x%08x%08x", fmtLen, cardnum, code1, code2, rawHi2, rawHi, rawLo); + } else{ + code1 = bytebits_to_byte(BitStream+8,fmtLen); + PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo); + } + } + + //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands + + return 1; +} + +//by marshmellow +//Pyramid Prox demod - FSK RF/50 with preamble of 0000000000000001 (always a 128 bit data stream) +//print full Farpointe Data/Pyramid Prox ID and some bit format details if found +int CmdFSKdemodPyramid(const char *Cmd) +{ + + int verbose=1; + sscanf(Cmd, "%i", &verbose); + + //raw fsk demod no manchester decoding no start bit finding just get binary from wave + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; + size_t size = getFromGraphBuf(BitStream); + + //get binary from fsk wave + int idx = PyramiddemodFSK(BitStream, size); + if (idx < 0){ + if (verbose){ + if (idx == -5) + PrintAndLog("Error: not enough samples"); + else if (idx == -1) + PrintAndLog("Error: only noise found - no waves"); + else if (idx == -2) + PrintAndLog("Error: problem during FSK demod"); + //else if (idx == -3) + // PrintAndLog("Error: thought we had a tag but the parity failed"); + else if (idx == -4) + PrintAndLog("Error: AWID preamble not found"); + } + PrintAndLog("idx: %d",idx); + return 0; + } + //PrintAndLog("DEBUG: idx: %d",idx); + + // Index map + // 0 10 20 30 40 50 60 + // | | | | | | | + // 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3 + // ----------------------------------------------------------------------------- + // 0000000 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 + // premable xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o + + // 64 70 80 90 100 110 120 + // | | | | | | | + // 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7 + // ----------------------------------------------------------------------------- + // 0000000 1 0000000 1 0000000 1 0110111 0 0011000 1 0000001 0 0001100 1 1001010 0 + // xxxxxxx o xxxxxxx o xxxxxxx o xswffff o ffffccc o ccccccc o ccccccw o ppppppp o + // |---115---||---------71---------| + // s = format start bit, o = odd parity of last 7 bits + // f = facility code, c = card number + // w = wiegand parity, x = extra space for other formats + // p = unknown checksum + // (26 bit format shown) + + //get raw ID before removing parities + uint32_t rawLo = bytebits_to_byte(BitStream+idx+96,32); + uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32); + uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32); + uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32); + size = removeParity(BitStream, idx+8, 8, 1, 120); + if (size != 105){ + if (verbose) PrintAndLog("Error: at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3); + return 0; + } + + // ok valid card found! + + // Index map + // 0 10 20 30 40 50 60 70 + // | | | | | | | | + // 01234567890123456789012345678901234567890123456789012345678901234567890 + // ----------------------------------------------------------------------- + // 00000000000000000000000000000000000000000000000000000000000000000000000 + // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + + // 71 80 90 100 + // | | | | + // 1 2 34567890 1234567890123456 7 8901234 + // --------------------------------------- + // 1 1 01110011 0000000001000110 0 1001010 + // s w ffffffff cccccccccccccccc w ppppppp + // |--115-| |------71------| + // s = format start bit, o = odd parity of last 7 bits + // f = facility code, c = card number + // w = wiegand parity, x = extra space for other formats + // p = unknown checksum + // (26 bit format shown) + + //find start bit to get fmtLen + idx = 0; + int j; + for (j=0; j32){ + //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32); + //code2 = bytebits_to_byte(BitStream+(size-32),32); + PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); + } else{ + //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen); + PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); + } + } + //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands + + return 1; +} + int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating { static const int LowTone[] = { @@ -833,6 +1057,21 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating return 0; } +int CmdFSKfcDetect(const char *Cmd) +{ + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; + size_t size = getFromGraphBuf(BitStream); + + + uint32_t ans = countFC(BitStream, size); + int fc1, fc2, rf1; + fc1 = (ans >> 8) & 0xFF; + fc2 = ans & 0xFF; + rf1 = (ans >>16) & 0xFF; + PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1); + return 1; +} + int CmdDetectNRZpskClockRate(const char *Cmd) { GetNRZpskClock("",0,0); @@ -1560,19 +1799,22 @@ static command_t CommandTable[] = {"help", CmdHelp, 1, "This help"}, {"amp", CmdAmp, 1, "Amplify peaks"}, {"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"}, - {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])"}, - {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"}, + {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional)"}, + {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output bin (args optional)"}, {"autocorr", CmdAutoCorr, 1, " -- Autocorrelation over window"}, - {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"}, + {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] [invert<0|1>] Biphase decode bin stream in demod buffer (offset = 0|1 bits to shift the decode start)"}, {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"}, {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"}, {"dec", CmdDec, 1, "Decimate samples"}, {"detectclock", CmdDetectClockRate, 1, "Detect ASK clock rate"}, {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"}, - {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"}, - {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox FSK using raw"}, - {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to binary (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"}, + {"fskawiddemod", CmdFSKdemodAWID, 1, "Demodulate graph window as an AWID FSK tag using raw"}, + {"fskfcdetect", CmdFSKfcDetect, 1, "Try to detect the Field Clock of an FSK wave"}, + {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK tag using raw"}, + {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox tag FSK using raw"}, + {"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"}, + {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"}, {"grid", CmdGrid, 1, " -- overlay grid on graph window, use zero value to turn off either"}, {"hexsamples", CmdHexsamples, 0, " [] -- Dump big buffer as hex bytes"}, {"hide", CmdHide, 1, "Hide graph window"}, @@ -1587,8 +1829,8 @@ static command_t CommandTable[] = {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, {"pskclean", CmdPskClean, 1, "Attempt to clean psk wave"}, {"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"}, - {"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk indala tags and output ID binary & hex (args optional[clock will try Auto-detect])"}, - {"psknrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk or nrz tags and output binary (args optional[clock will try Auto-detect])"}, + {"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk indala tags and output ID binary & hex (args optional)"}, + {"psknrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk or nrz tags and output binary (args optional)"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"save", CmdSave, 1, " -- Save trace (from graph window)"}, {"scale", CmdScale, 1, " -- Set cursor display scale"}, diff --git a/client/cmddata.h b/client/cmddata.h index 8723b847..ffd6b983 100644 --- a/client/cmddata.h +++ b/client/cmddata.h @@ -26,9 +26,11 @@ int CmdBitstream(const char *Cmd); int CmdBuffClear(const char *Cmd); int CmdDec(const char *Cmd); int CmdDetectClockRate(const char *Cmd); +int CmdFSKdemodAWID(const char *Cmd); int CmdFSKdemod(const char *Cmd); int CmdFSKdemodHID(const char *Cmd); int CmdFSKdemodIO(const char *Cmd); +int CmdFSKdemodPyramid(const char *Cmd); int CmdFSKrawdemod(const char *Cmd); int CmdDetectNRZpskClockRate(const char *Cmd); int CmdpskNRZrawDemod(const char *Cmd); diff --git a/client/cmdlf.c b/client/cmdlf.c index e3361cb5..945b4557 100644 --- a/client/cmdlf.c +++ b/client/cmdlf.c @@ -388,7 +388,7 @@ static void ChkBitstream(const char *str) } } } - +//appears to attempt to simulate manchester int CmdLFSim(const char *Cmd) { int i,j; @@ -581,6 +581,16 @@ int CmdLFfind(const char *Cmd) PrintAndLog("Valid IO Prox ID Found!"); return 1; } + ans=CmdFSKdemodPyramid("0"); + if (ans>0) { + PrintAndLog("Valid Pyramid ID Found!"); + return 1; + } + ans=CmdFSKdemodAWID("0"); + if (ans>0) { + PrintAndLog("Valid AWID ID Found!"); + return 1; + } ans=CmdFSKdemodHID(""); if (ans>0) { PrintAndLog("Valid HID Prox ID Found!"); diff --git a/common/lfdemod.c b/common/lfdemod.c index 062818ef..4a80a10c 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -5,13 +5,30 @@ // at your option, any later version. See the LICENSE.txt file for the text of // the license. //----------------------------------------------------------------------------- -// Low frequency commands +// Low frequency demod/decode commands //----------------------------------------------------------------------------- #include #include #include "lfdemod.h" +//by marshmellow +//get high and low with passed in fuzz factor. also return noise test = 1 for passed or 0 for only noise +int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo) +{ + *high=0; + *low=255; + // get high and low thresholds + for (int i=0; i < size; i++){ + if (BitStream[i] > *high) *high = BitStream[i]; + if (BitStream[i] < *low) *low = BitStream[i]; + } + if (*high < 123) return -1; // just noise + *high = (int)(((*high-128)*(((float)fuzzHi)/100))+128); + *low = (int)(((*low-128)*(((float)fuzzLo)/100))+128); + return 1; +} + //by marshmellow //takes 1s and 0s and searches for EM410x format - output EM ID uint64_t Em410xDecode(uint8_t *BitStream, size_t size) @@ -72,7 +89,6 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size) int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) { int i; - int high = 0, low = 255; *clk=DetectASKClock(BinStream, *size, *clk); //clock default if (*clk<8) *clk =64; @@ -81,22 +97,12 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) uint32_t initLoopMax = 200; if (initLoopMax > *size) initLoopMax=*size; // Detect high and lows - for (i = 0; i < initLoopMax; ++i) //200 samples should be enough to find high and low values - { - if (BinStream[i] > high) - high = BinStream[i]; - else if (BinStream[i] < low) - low = BinStream[i]; - } - if ((high < 129) ){ //throw away static (anything < 1 graph) - //PrintAndLog("no data found"); - return -2; - } - //25% fuzz in case highs and lows aren't clipped [marshmellow] - high=(int)(((high-128)*.75)+128); - low= (int)(((low-128)*.75)+128); + // 25% fuzz in case highs and lows aren't clipped [marshmellow] + int high, low, ans; + ans = getHiLo(BinStream, initLoopMax, &high, &low, 75, 75); + if (ans<1) return -2; //just noise - //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); + // PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); int lastBit = 0; //set first clock check uint32_t bitnum = 0; //output counter int tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave @@ -108,13 +114,13 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) uint32_t bestStart = *size; uint32_t bestErrCnt = (*size/1000); uint32_t maxErr = (*size/1000); - //PrintAndLog("DEBUG - lastbit - %d",lastBit); - //loop to find first wave that works + // PrintAndLog("DEBUG - lastbit - %d",lastBit); + // loop to find first wave that works for (iii=0; iii < gLen; ++iii){ if ((BinStream[iii] >= high) || (BinStream[iii] <= low)){ lastBit=iii-*clk; errCnt=0; - //loop through to see if this start location works + // loop through to see if this start location works for (i = iii; i < *size; ++i) { if ((BinStream[i] >= high) && ((i-lastBit) > (*clk-tol))){ lastBit+=*clk; @@ -242,17 +248,17 @@ int manrawdecode(uint8_t * BitStream, size_t *size) //by marshmellow //take 01 or 10 = 0 and 11 or 00 = 1 -int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset) +int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert) { uint8_t bitnum=0; uint32_t errCnt =0; - uint32_t i=1; + uint32_t i; i=offset; - for (;i<*size-2;i+=2){ + for (;i<*size-2; i+=2){ if((BitStream[i]==1 && BitStream[i+1]==0) || (BitStream[i]==0 && BitStream[i+1]==1)){ - BitStream[bitnum++]=1; + BitStream[bitnum++]=1^invert; } else if((BitStream[i]==0 && BitStream[i+1]==0) || (BitStream[i]==1 && BitStream[i+1]==1)){ - BitStream[bitnum++]=0; + BitStream[bitnum++]=invert; } else { BitStream[bitnum++]=77; errCnt++; @@ -271,31 +277,21 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) { uint32_t i; // int invert=0; //invert default - int high = 0, low = 255; + int clk2 = *clk; *clk=DetectASKClock(BinStream, *size, *clk); //clock default - uint8_t BitStream[502] = {0}; + //uint8_t BitStream[502] = {0}; + //HACK: if clock not detected correctly - default if (*clk<8) *clk =64; - if (*clk<32) *clk=32; + if (*clk<32 && clk2==0) *clk=32; if (*invert != 0 && *invert != 1) *invert =0; uint32_t initLoopMax = 200; if (initLoopMax > *size) initLoopMax=*size; // Detect high and lows - for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values - { - if (BinStream[i] > high) - high = BinStream[i]; - else if (BinStream[i] < low) - low = BinStream[i]; - } - if ((high < 129)){ //throw away static high has to be more than 0 on graph. - //noise <= -10 here - // PrintAndLog("no data found"); - return -2; - } //25% fuzz in case highs and lows aren't clipped [marshmellow] - high=(int)(((high-128)*.75)+128); - low= (int)(((low-128)*.75)+128); + int high, low, ans; + ans = getHiLo(BinStream, initLoopMax, &high, &low, 75, 75); + if (ans<1) return -2; //just noise //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); int lastBit = 0; //set first clock check @@ -310,6 +306,7 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) uint8_t errCnt =0; uint32_t bestStart = *size; uint32_t bestErrCnt = (*size/1000); + uint32_t maxErr = bestErrCnt; uint8_t midBit=0; //PrintAndLog("DEBUG - lastbit - %d",lastBit); //loop to find first wave that works @@ -320,30 +317,30 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) for (i = iii; i < *size; ++i) { if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){ lastBit+=*clk; - BitStream[bitnum] = *invert; - bitnum++; + //BitStream[bitnum] = *invert; + //bitnum++; midBit=0; } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){ //low found and we are expecting a bar lastBit+=*clk; - BitStream[bitnum] = 1- *invert; - bitnum++; + //BitStream[bitnum] = 1- *invert; + //bitnum++; midBit=0; } else if ((BinStream[i]<=low) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ //mid bar? midBit=1; - BitStream[bitnum]= 1- *invert; - bitnum++; + //BitStream[bitnum]= 1- *invert; + //bitnum++; } else if ((BinStream[i]>=high) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ //mid bar? midBit=1; - BitStream[bitnum]= *invert; - bitnum++; + //BitStream[bitnum]= *invert; + //bitnum++; } else if ((i-lastBit)>((*clk/2)+tol) && (midBit==0)){ //no mid bar found midBit=1; - BitStream[bitnum]= BitStream[bitnum-1]; - bitnum++; + //BitStream[bitnum]= BitStream[bitnum-1]; + //bitnum++; } else { //mid value found or no bar supposed to be here @@ -351,45 +348,94 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) //should have hit a high or low based on clock!! //debug //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit); - if (bitnum > 0){ - BitStream[bitnum]=77; - bitnum++; - } + //if (bitnum > 0){ + // BitStream[bitnum]=77; + // bitnum++; + //} errCnt++; lastBit+=*clk;//skip over until hit too many errors if (errCnt > ((*size/1000))){ //allow 1 error for every 1000 samples else start over errCnt=0; - bitnum=0;//start over + // bitnum=0;//start over break; } } } - if (bitnum>500) break; + if ((i-iii)>(500 * *clk)) break; //got enough bits } //we got more than 64 good bits and not all errors - if ((bitnum > (64+errCnt)) && (errCnt<(*size/1000))) { + if ((((i-iii)/ *clk) > (64+errCnt)) && (errCnt<(*size/1000))) { //possible good read - if (errCnt==0) break; //great read - finish - if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish + if (errCnt==0){ + bestStart=iii; + bestErrCnt=errCnt; + break; //great read - finish + } if (errCnt=gLen){ //exhausted test - //if there was a ok test go back to that one and re-run the best run (then dump after that run) - if (bestErrCnt < (*size/1000)) iii=bestStart; - } } - if (bitnum>16){ - for (i=0; i < bitnum; ++i){ - BinStream[i]=BitStream[i]; + if (bestErrCnt= high) && ((i-lastBit) > (*clk-tol))){ + lastBit += *clk; + BinStream[bitnum] = *invert; + bitnum++; + midBit=0; + } else if ((BinStream[i] <= low) && ((i-lastBit) > (*clk-tol))){ + //low found and we are expecting a bar + lastBit+=*clk; + BinStream[bitnum] = 1-*invert; + bitnum++; + midBit=0; + } else if ((BinStream[i]<=low) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ + //mid bar? + midBit=1; + BinStream[bitnum] = 1 - *invert; + bitnum++; + } else if ((BinStream[i]>=high) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ + //mid bar? + midBit=1; + BinStream[bitnum] = *invert; + bitnum++; + } else if ((i-lastBit)>((*clk/2)+tol) && (midBit==0)){ + //no mid bar found + midBit=1; + if (bitnum!=0) BinStream[bitnum] = BinStream[bitnum-1]; + bitnum++; + + } else { + //mid value found or no bar supposed to be here + if ((i-lastBit)>(*clk+tol)){ + //should have hit a high or low based on clock!! + + //debug + //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit); + if (bitnum > 0){ + BinStream[bitnum]=77; + bitnum++; + } + + lastBit+=*clk;//skip over error + } + } + if (bitnum >=400) break; } *size=bitnum; - } else return -1; - return errCnt; + } else{ + *invert=bestStart; + *clk=iii; + return -1; + } + return bestErrCnt; } //translate wave to 11111100000 (1 for each short wave 0 for each long wave) size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow) @@ -589,37 +635,128 @@ int IOdemodFSK(uint8_t *dest, size_t size) return 0; } +// by marshmellow +// pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType +// returns 1 if passed +int parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType) +{ + uint8_t ans = 0; + for (int i = 0; i < bitLen; i++){ + ans ^= ((bits >> i) & 1); + } + //PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType); + return (ans == pType); +} + +// by marshmellow +// takes a array of binary values, start position, length of bits per parity (includes parity bit), +// Parity Type (1 for odd 0 for even), and binary Length (length to run) +size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen) +{ + uint32_t parityWd = 0; + size_t j = 0, bitCnt = 0; + for (int word = 0; word < (bLen); word+=pLen){ + for (int bit=0; bit < pLen; bit++){ + parityWd = (parityWd << 1) | BitStream[startIdx+word+bit]; + BitStream[j++] = (BitStream[startIdx+word+bit]); + } + j--; + // if parity fails then return 0 + if (parityTest(parityWd, pLen, pType) == 0) return -1; + bitCnt+=(pLen-1); + parityWd = 0; + } + // if we got here then all the parities passed + //return ID start index and size + return bitCnt; +} + +// by marshmellow +// FSK Demod then try to locate an AWID ID +int AWIDdemodFSK(uint8_t *dest, size_t size) +{ + static const uint8_t THRESHOLD = 123; + uint32_t idx=0; + //make sure buffer has data + if (size < 96*50) return -1; + //test samples are not just noise + uint8_t justNoise = 1; + for(idx=0; idx < size && justNoise ;idx++){ + justNoise = dest[idx] < THRESHOLD; + } + if(justNoise) return -2; + + // FSK demodulator + size = fskdemod(dest, size, 50, 1, 10, 8); // RF/64 and invert + if (size < 96) return -3; //did we get a good demod? + + uint8_t mask[] = {0,0,0,0,0,0,0,1}; + for( idx=0; idx < (size - 96); idx++) { + if ( memcmp(dest + idx, mask, sizeof(mask))==0) { + // frame marker found + //return ID start index and size + return idx; + //size should always be 96 + } + } + //never found mask + return -4; +} + +// by marshmellow +// FSK Demod then try to locate an Farpointe Data (pyramid) ID +int PyramiddemodFSK(uint8_t *dest, size_t size) +{ + static const uint8_t THRESHOLD = 123; + uint32_t idx=0; + // size_t size2 = size; + //make sure buffer has data + if (size < 128*50) return -5; + //test samples are not just noise + uint8_t justNoise = 1; + for(idx=0; idx < size && justNoise ;idx++){ + justNoise = dest[idx] < THRESHOLD; + } + if(justNoise) return -1; + + // FSK demodulator + size = fskdemod(dest, size, 50, 1, 10, 8); // RF/64 and invert + if (size < 128) return -2; //did we get a good demod? + + uint8_t mask[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}; + for( idx=0; idx < (size - 128); idx++) { + if ( memcmp(dest + idx, mask, sizeof(mask))==0) { + // frame marker found + return idx; + } + } + //never found mask + return -4; +} + // 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? int DetectASKClock(uint8_t dest[], size_t size, int clock) { int i=0; - int peak=0; - int low=255; - int clk[]={16,32,40,50,64,100,128,256}; + int clk[]={8,16,32,40,50,64,100,128,256}; int loopCnt = 256; //don't need to loop through entire array... if (size peak){ - peak = dest[i]; - } - if(dest[i] < low){ - low = dest[i]; - } - } - peak=(int)(((peak-128)*.75)+128); - low= (int)(((low-128)*.75)+128); + int peak, low; + getHiLo(dest, loopCnt, &peak, &low, 75, 75); + int ii; int clkCnt; int tol = 0; - int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000}; + int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; int errCnt=0; //test each valid clock from smallest to greatest to see which lines up for(clkCnt=0; clkCnt < 6; ++clkCnt){ @@ -651,7 +788,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock) } int iii=0; int best=0; - for (iii=0; iii<7;++iii){ + for (iii=0; iii<8;++iii){ if (bestErr[iii] peak){ - peak = dest[i]; - } - if(dest[i] < low){ - low = dest[i]; - } - } - peak=(int)(((peak-128)*.75)+128); - low= (int)(((low-128)*.75)+128); + int peak, low; + getHiLo(dest, loopCnt, &peak, &low, 75, 75); + //PrintAndLog("DEBUG: peak: %d, low: %d",peak,low); int ii; uint8_t clkCnt; @@ -698,7 +826,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) int peaksdet[]={0,0,0,0,0,0,0,0,0}; //test each valid clock from smallest to greatest to see which lines up for(clkCnt=0; clkCnt < 6; ++clkCnt){ - if (clk[clkCnt] == 32){ + if (clk[clkCnt] >= 32){ tol=1; }else{ tol=0; @@ -749,40 +877,37 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) } //by marshmellow (attempt to get rid of high immediately after a low) -void pskCleanWave(uint8_t *bitStream, size_t size) +void pskCleanWave(uint8_t *BitStream, size_t size) { int i; - int low=255; - int high=0; int gap = 4; - // int loopMax = 2048; - int newLow=0; + int newLow=0; int newHigh=0; - for (i=0; i < size; ++i){ - if (bitStream[i] < low) low=bitStream[i]; - if (bitStream[i] > high) high=bitStream[i]; - } - high = (int)(((high-128)*.80)+128); - low = (int)(((low-128)*.90)+128); - //low = (uint8_t)(((int)(low)-128)*.80)+128; - for (i=0; i < size; ++i){ + int high, low; + getHiLo(BitStream, size, &high, &low, 80, 90); + + for (i=0; i < size; ++i){ if (newLow == 1){ - bitStream[i]=low+8; - gap--; + if (BitStream[i]>low){ + BitStream[i]=low+8; + gap--; + } if (gap == 0){ newLow=0; gap=4; } }else if (newHigh == 1){ - bitStream[i]=high-8; - gap--; + if (BitStream[i]= high) newHigh=1; + if (BitStream[i] <= low) newLow=1; + if (BitStream[i] >= high) newHigh=1; } return; } @@ -853,7 +978,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert) } -//by marshmellow - demodulate PSK wave or NRZ wave (both similar enough) +//by marshmellow - demodulate PSK1 wave or NRZ wave (both similar enough) //peaks switch bit (high=1 low=0) each clock cycle = 1 bit determined by last peak int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) { @@ -861,22 +986,14 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) int clk2 = DetectpskNRZClock(dest, *size, *clk); *clk=clk2; uint32_t i; - uint8_t high=0, low=255; + int high, low, ans; + ans = getHiLo(dest, 1260, &high, &low, 75, 80); //25% fuzz on high 20% fuzz on low + if (ans<1) return -2; //just noise uint32_t gLen = *size; - if (gLen > 1280) gLen=1280; - // get high - for (i=0; i < gLen; ++i){ - if (dest[i] > high) high = dest[i]; - if (dest[i] < low) low = dest[i]; - } - //fudge high/low bars by 25% - high = (uint8_t)((((int)(high)-128)*.75)+128); - low = (uint8_t)((((int)(low)-128)*.80)+128); - //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); int lastBit = 0; //set first clock check uint32_t bitnum = 0; //output counter - 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 + uint8_t tol = 1; //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 = 2; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely uint32_t iii = 0; uint8_t errCnt =0; @@ -931,7 +1048,6 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) bestErrCnt = errCnt; break; //great read - finish } - if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish if (errCnt < bestErrCnt){ //set this as new best run bestErrCnt = errCnt; bestStart = iii; @@ -995,3 +1111,169 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) return errCnt; } + +//by marshmellow +//countFC is to detect the field clock and bit clock rates. +//for fsk or ask not psk or nrz +uint32_t countFC(uint8_t *BitStream, size_t size) +{ + // get high/low thresholds + int high, low; + getHiLo(BitStream,10, &high, &low, 100, 100); + // get zero crossing + uint8_t zeroC = (high-low)/2+low; + uint8_t clk[]={8,16,32,40,50,64,100,128}; + uint8_t fcLens[] = {0,0,0,0,0,0,0,0,0,0}; + uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0}; + uint8_t rfLens[] = {0,0,0,0,0,0,0,0,0,0,0}; + // uint8_t rfCnts[] = {0,0,0,0,0,0,0,0,0,0}; + uint8_t fcLensFnd = 0; + uint8_t rfLensFnd = 0; + uint8_t lastBit=0; + uint8_t curBit=0; + uint8_t lastFCcnt=0; + uint32_t errCnt=0; + uint32_t fcCounter = 0; + uint32_t rfCounter = 0; + uint8_t firstBitFnd = 0; + int i; + + // prime i to first up transition + for (i = 1; i < size; i++) + if (BitStream[i]>=zeroC && BitStream[i-1]= zeroC){ + // new up transition + fcCounter++; + rfCounter++; + if (fcCounter > 3 && fcCounter < 256){ + //we've counted enough that it could be a valid field clock + + //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 odd and not rc/5 add one (for when we get a fc 9 instead of 10) + if ((fcCounter==9 && fcCounter & 1) || fcCounter==4) fcCounter++; + + //look for bit clock (rf/xx) + if ((fcCounterlastFCcnt)){ + //not the same size as the last wave - start of new bit sequence + + if (firstBitFnd>1){ //skip first wave change - probably not a complete bit + for (int ii=0; ii<10; ii++){ + if (rfLens[ii]==rfCounter){ + //rfCnts[ii]++; + rfCounter=0; + break; + } + } + if (rfCounter>0 && rfLensFnd<10){ + //PrintAndLog("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter); + //rfCnts[rfLensFnd]++; + rfLens[rfLensFnd++]=rfCounter; + } + } else { + //PrintAndLog("DEBUG i: %d",i); + firstBitFnd++; + } + rfCounter=0; + lastFCcnt=fcCounter; + } + + // save last field clock count (fc/xx) + // find which fcLens to save it to: + for (int ii=0; ii<10; ii++){ + if (fcLens[ii]==fcCounter){ + fcCnts[ii]++; + fcCounter=0; + break; + } + } + if (fcCounter>0 && fcLensFnd<10){ + //add new fc length + //PrintAndLog("FCCntr %d",fcCounter); + fcCnts[fcLensFnd]++; + fcLens[fcLensFnd++]=fcCounter; + } + } else{ + // hmmm this should not happen often - count them + errCnt++; + } + // reset counter + fcCounter=0; + } else { + // count sample + fcCounter++; + rfCounter++; + } + } + // if too many errors return errors as negative number (IS THIS NEEDED?) + if (errCnt>100) return -1*errCnt; + + uint8_t maxCnt1=0, best1=9, best2=9, best3=9, rfHighest=10, rfHighest2=10, rfHighest3=10; + + // go through fclens and find which ones are bigest 2 + for (i=0; i<10; i++){ + // PrintAndLog("DEBUG: FC %d, Cnt %d, Errs %d, RF %d",fcLens[i],fcCnts[i],errCnt,rfLens[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; + } + //get highest 2 RF values (might need to get more values to compare or compare all?) + if (rfLens[i]>rfLens[rfHighest]){ + rfHighest3=rfHighest2; + rfHighest2=rfHighest; + rfHighest=i; + } else if(rfLens[i]>rfLens[rfHighest2]){ + rfHighest3=rfHighest2; + rfHighest2=i; + } else if(rfLens[i]>rfLens[rfHighest3]){ + rfHighest3=i; + } + } + + // set allowed clock remainder tolerance to be 1 large field clock length + // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off + int tol1 = (fcLens[best1]>fcLens[best2]) ? fcLens[best1] : fcLens[best2]; + + // loop to find the highest clock that has a remainder less than the tolerance + // compare samples counted divided by + int ii=7; + for (; ii>=0; ii--){ + if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){ + if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){ + if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){ + break; + } + } + } + } + + if (ii<0) ii=7; // oops we went too far + + // TODO: take top 3 answers and compare to known Field clocks to get top 2 + + uint32_t fcs=0; + // PrintAndLog("DEBUG: Best %d best2 %d best3 %d, clk %d, clk2 %d",fcLens[best1],fcLens[best2],fcLens[best3],clk[i],clk[ii]); + // + + if (fcLens[best1]>fcLens[best2]){ + fcs = (((uint32_t)clk[ii])<<16) | (((uint32_t)fcLens[best1])<<8) | ((fcLens[best2])); + } else { + fcs = (((uint32_t)clk[ii])<<16) | (((uint32_t)fcLens[best2])<<8) | ((fcLens[best1])); + } + + return fcs; +} diff --git a/common/lfdemod.h b/common/lfdemod.h index b0feff04..ae04bc2f 100644 --- a/common/lfdemod.h +++ b/common/lfdemod.h @@ -4,7 +4,11 @@ // at your option, any later version. See the LICENSE.txt file for the text of // the license. //----------------------------------------------------------------------------- -// Low frequency commands +// Low frequency demod related commands +// marshmellow +// note that many of these demods are not the slickest code and they often rely +// on peaks and clock instead of converting to clean signal. +// //----------------------------------------------------------------------------- #ifndef LFDEMOD_H__ @@ -15,7 +19,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock); int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); uint64_t Em410xDecode(uint8_t *BitStream,size_t size); int manrawdecode(uint8_t *BitStream, size_t *size); -int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset); +int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert); int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); int IOdemodFSK(uint8_t *dest, size_t size); @@ -25,5 +29,10 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert); int DetectpskNRZClock(uint8_t dest[], size_t size, int clock); int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert); void pskCleanWave(uint8_t *bitStream, size_t size); +int PyramiddemodFSK(uint8_t *dest, size_t size); +int AWIDdemodFSK(uint8_t *dest, size_t size); +size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen); +uint32_t countFC(uint8_t *BitStream, size_t size); +int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo); #endif From ec75f5c10a91211e50b74af181b827fc93a6dcd5 Mon Sep 17 00:00:00 2001 From: marshmellow42 Date: Tue, 20 Jan 2015 17:28:51 -0500 Subject: [PATCH 2/5] lf Bug Fixes and lf demod additions added data fskparadoxdemod added data setdebugmode (for demods) added data shiftgraphzero (to help clean weak reads) fixed a few bugs with the data detectaskclock added data fskfcdetect to detect FSK clocks adjusted most of my demods to put raw tag binary to demod buffer for future sim and clone commands (psk still needs work) --- armsrc/lfops.c | 10 +- client/cmddata.c | 355 ++++++++++++++++++++++++++++++----------------- client/cmddata.h | 1 + client/cmdlf.c | 25 ++-- client/graph.c | 2 + common/lfdemod.c | 261 ++++++++++++++++++++++------------ common/lfdemod.h | 6 +- 7 files changed, 429 insertions(+), 231 deletions(-) diff --git a/armsrc/lfops.c b/armsrc/lfops.c index f5040850..8ea9b317 100644 --- a/armsrc/lfops.c +++ b/armsrc/lfops.c @@ -633,7 +633,7 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol) { uint8_t *dest = (uint8_t *)BigBuf; - size_t size=0; //, found=0; + size_t size=sizeof(BigBuf), idx=0; //, found=0; uint32_t hi2=0, hi=0, lo=0; // Configure to go in 125Khz listen mode @@ -646,11 +646,11 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol) DoAcquisition125k_internal(-1,true); // FSK demodulator - size = HIDdemodFSK(dest, sizeof(BigBuf), &hi2, &hi, &lo); + idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo); WDT_HIT(); - if (size>0 && lo>0){ + if (idx>0 && lo>0){ // final loop, go over previously decoded manchester data and decode into usable tag ID // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 if (hi2 != 0){ //extra large HID tags @@ -721,7 +721,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol) { uint8_t *dest = (uint8_t *)BigBuf; - size_t size=0; + size_t size=0, idx=0; int clk=0, invert=0, errCnt=0; uint64_t lo=0; // Configure to go in 125Khz listen mode @@ -741,7 +741,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol) WDT_HIT(); if (errCnt>=0){ - lo = Em410xDecode(dest,size); + lo = Em410xDecode(dest, &size, &idx); //Dbprintf("DEBUG: EM GOT"); if (lo>0){ Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)", diff --git a/client/cmddata.c b/client/cmddata.c index 60d0d875..578587bc 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -22,21 +22,30 @@ #include "cmddata.h" #include "lfdemod.h" uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN]; +uint8_t g_debugMode; int DemodBufferLen; static int CmdHelp(const char *Cmd); //set the demod buffer with given array of binary (one bit per byte) //by marshmellow -void setDemodBuf(uint8_t *buff,int size) +void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx) { - int i=0; - for (; i < size; ++i){ - DemodBuffer[i]=buff[i]; + size_t i = 0; + for (; i < size; i++){ + DemodBuffer[i]=buff[startIdx++]; } DemodBufferLen=size; return; } +int CmdSetDebugMode(const char *Cmd) +{ + int demod=0; + sscanf(Cmd, "%i", &demod); + g_debugMode=(uint8_t)demod; + return 1; +} + //by marshmellow void printDemodBuff() { @@ -206,7 +215,7 @@ void printEM410x(uint64_t id) { if (id !=0){ uint64_t iii=1; - uint64_t id2lo=0; //id2hi=0, + uint64_t id2lo=0; uint32_t ii=0; uint32_t i=0; for (ii=5; ii>0;ii--){ @@ -216,7 +225,7 @@ void printEM410x(uint64_t id) } //output em id PrintAndLog("EM TAG ID : %010llx", id); - PrintAndLog("Unique TAG ID: %010llx", id2lo); //id2hi, + PrintAndLog("Unique TAG ID: %010llx", id2lo); PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF); PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF); PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF)); @@ -233,12 +242,17 @@ void printEM410x(uint64_t id) int CmdEm410xDecode(const char *Cmd) { uint64_t id=0; - // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; - // uint32_t i=0; - // i=getFromGraphBuf(BitStream); - id = Em410xDecode(DemodBuffer,DemodBufferLen); - printEM410x(id); - if (id>0) return 1; + size_t size = DemodBufferLen, idx=0; + id = Em410xDecode(DemodBuffer, &size, &idx); + if (id>0){ + setDemodBuf(DemodBuffer, size, idx); + if (g_debugMode){ + PrintAndLog("DEBUG: Printing demod buffer:"); + printDemodBuff(); + } + printEM410x(id); + return 1; + } return 0; } @@ -249,7 +263,7 @@ int CmdEm410xDecode(const char *Cmd) //prints binary found and saves in graphbuffer for further commands int Cmdaskmandemod(const char *Cmd) { - int invert=0; + int invert=0; int clk=0; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; sscanf(Cmd, "%i %i", &clk, &invert); @@ -259,11 +273,11 @@ int Cmdaskmandemod(const char *Cmd) } size_t BitLen = getFromGraphBuf(BitStream); - // PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); + if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); int errCnt=0; errCnt = askmandemod(BitStream, &BitLen,&clk,&invert); if (errCnt<0||BitLen<16){ //if fatal error (or -1) - // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); + if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); return 0; } PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen); @@ -274,17 +288,22 @@ int Cmdaskmandemod(const char *Cmd) } PrintAndLog("ASK/Manchester decoded bitstream:"); // Now output the bitstream to the scrollback by line of 16 bits - setDemodBuf(BitStream,BitLen); + setDemodBuf(BitStream,BitLen,0); printDemodBuff(); uint64_t lo =0; - lo = Em410xDecode(BitStream,BitLen); + size_t idx=0; + lo = Em410xDecode(BitStream, &BitLen, &idx); if (lo>0){ //set GraphBuffer for clone or sim command + setDemodBuf(BitStream, BitLen, idx); + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen); + printDemodBuff(); + } PrintAndLog("EM410x pattern found: "); printEM410x(lo); return 1; } - //if (BitLen>16) return 1; return 0; } @@ -317,9 +336,14 @@ int Cmdmandecoderaw(const char *Cmd) printBitStream(BitStream, size); if (errCnt==0){ uint64_t id = 0; - id = Em410xDecode(BitStream, size); - if (id>0) setDemodBuf(BitStream, size); - printEM410x(id); + size_t idx=0; + id = Em410xDecode(BitStream, &size, &idx); + if (id>0){ + //need to adjust to set bitstream back to manchester encoded data + //setDemodBuf(BitStream, size, idx); + + printEM410x(id); + } } return 1; } @@ -366,7 +390,6 @@ int CmdBiphaseDecodeRaw(const char *Cmd) return 1; } - //by marshmellow //takes 2 arguments - clock and invert both as integers //attempts to demodulate ask only @@ -386,14 +409,15 @@ int Cmdaskrawdemod(const char *Cmd) errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert); if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) PrintAndLog("no data found"); + if (g_debugMode==1) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert); return 0; } PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); - //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum); - //move BitStream back to DemodBuffer - setDemodBuf(BitStream,BitLen); + + //move BitStream back to DemodBuffer + setDemodBuf(BitStream,BitLen,0); - //output + //output if (errCnt>0){ PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); } @@ -541,6 +565,27 @@ int CmdDec(const char *Cmd) return 0; } +//by marshmellow +//shift graph zero up or down based on input + or - +int CmdGraphShiftZero(const char *Cmd) +{ + + int shift=0; + //set options from parameters entered with the command + sscanf(Cmd, "%i", &shift); + int shiftedVal=0; + for(int i = 0; i127) + shiftedVal=127; + else if (shiftedVal<-127) + shiftedVal=-127; + GraphBuffer[i]= shiftedVal; + } + CmdNorm(""); + return 0; +} + /* Print our clock rate */ // uses data from graphbuffer int CmdDetectClockRate(const char *Cmd) @@ -567,7 +612,6 @@ int CmdFSKrawdemod(const char *Cmd) sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow); if (strlen(Cmd)>0 && strlen(Cmd)<=2) { - //rfLen=param_get8(Cmd, 0); //if rfLen option only is used if (rfLen==1){ invert=1; //if invert option only is used rfLen = 50; @@ -579,7 +623,7 @@ int CmdFSKrawdemod(const char *Cmd) int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); if (size>0){ PrintAndLog("FSK decoded bitstream:"); - setDemodBuf(BitStream,size); + setDemodBuf(BitStream,size,0); // Now output the bitstream to the scrollback by line of 16 bits if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size @@ -601,20 +645,20 @@ int CmdFSKdemodHID(const char *Cmd) uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; size_t BitLen = getFromGraphBuf(BitStream); //get binary from fsk wave - size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); - if (size<0){ - PrintAndLog("Error demoding fsk"); + size_t idx = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo); + if (idx<0){ + if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk"); + return 0; + } + if (hi2==0 && hi==0 && lo==0) { + if (g_debugMode) PrintAndLog("DEBUG: Error - no values found"); return 0; } - if (hi2==0 && hi==0 && lo==0) return 0; if (hi2 != 0){ //extra large HID tags PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)", (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); - setDemodBuf(BitStream,BitLen); - return 1; } else { //standard HID tags <38 bits - //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd uint8_t fmtLen = 0; uint32_t fc = 0; uint32_t cardnum = 0; @@ -654,12 +698,49 @@ int CmdFSKdemodHID(const char *Cmd) PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d", (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF, (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum); - setDemodBuf(BitStream,BitLen); - return 1; } - return 0; + setDemodBuf(BitStream,BitLen,idx); + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen); + printDemodBuff(); + } + return 1; } +//by marshmellow (based on existing demod + holiman's refactor) +//Paradox Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded) +//print full Paradox Prox ID and some bit format details if found +int CmdFSKdemodParadox(const char *Cmd) +{ + //raw fsk demod no manchester decoding no start bit finding just get binary from wave + uint32_t hi2=0, hi=0, lo=0; + + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; + size_t BitLen = getFromGraphBuf(BitStream); + //get binary from fsk wave + size_t idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo); + if (idx<0){ + if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk"); + return 0; + } + if (hi2==0 && hi==0 && lo==0){ + if (g_debugMode) PrintAndLog("DEBUG: Error - no value found"); + return 0; + } + uint32_t fc = ((hi & 0x3)<<6) | (lo>>26); + uint32_t cardnum = (lo>>10)&0xFFFF; + + PrintAndLog("Paradox TAG ID: %x%08x - FC: %d - Card: %d - Checksum: %02x", + hi>>10, (hi & 0x3)<<26 | (lo>>10), fc, cardnum, (lo>>2) & 0xFF ); + setDemodBuf(BitStream,BitLen,idx); + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, len: %d, Printing Demod Buffer:", idx, BitLen); + printDemodBuff(); + } + return 1; +} + + //by marshmellow //IO-Prox demod - FSK RF/64 with preamble of 000000001 //print ioprox ID and some format details @@ -668,21 +749,25 @@ int CmdFSKdemodIO(const char *Cmd) //raw fsk demod no manchester decoding no start bit finding just get binary from wave //set defaults int idx=0; - //something in graphbuffer - if (GraphTraceLen < 65) return 0; - uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; - size_t BitLen = getFromGraphBuf(BitStream); - //get binary from fsk wave - // PrintAndLog("DEBUG: got buff"); - idx = IOdemodFSK(BitStream,BitLen); - if (idx<0){ - //PrintAndLog("Error demoding fsk"); + //something in graphbuffer? + if (GraphTraceLen < 65) { + if (g_debugMode)PrintAndLog("DEBUG: not enough samples in GraphBuffer"); + return 0; + } + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; + size_t BitLen = getFromGraphBuf(BitStream); + + //get binary from fsk wave + idx = IOdemodFSK(BitStream,BitLen); + if (idx<0){ + if (g_debugMode==1) PrintAndLog("DEBUG: demoding fsk error: %d", idx); return 0; } - // PrintAndLog("DEBUG: Got IOdemodFSK"); if (idx==0){ - //PrintAndLog("IO Prox Data not found - FSK Data:"); - //if (BitLen > 92) printBitStream(BitStream,92); + if (g_debugMode==1){ + PrintAndLog("DEBUG: IO Prox Data not found - FSK Bits: %d",BitLen); + if (BitLen > 92) printBitStream(BitStream,92); + } return 0; } //Index map @@ -694,7 +779,10 @@ int CmdFSKdemodIO(const char *Cmd) // //XSF(version)facility:codeone+codetwo (raw) //Handle the data - if (idx+64>BitLen) return 0; + if (idx+64>BitLen) { + if (g_debugMode==1) PrintAndLog("not enough bits found - bitlen: %d",BitLen); + return 0; + } PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx], BitStream[idx+1], BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]); PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9], BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]); PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]); @@ -709,12 +797,12 @@ int CmdFSKdemodIO(const char *Cmd) uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ; uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9 PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2); - int i; - for (i=0;i<64;++i) - DemodBuffer[i]=BitStream[idx++]; - - DemodBufferLen=64; - return 1; + setDemodBuf(BitStream,64,idx); + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, Len: %d, Printing demod buffer:",idx,64); + printDemodBuff(); + } + return 1; } @@ -724,8 +812,8 @@ int CmdFSKdemodIO(const char *Cmd) int CmdFSKdemodAWID(const char *Cmd) { - int verbose=1; - sscanf(Cmd, "%i", &verbose); + //int verbose=1; + //sscanf(Cmd, "%i", &verbose); //raw fsk demod no manchester decoding no start bit finding just get binary from wave uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; @@ -734,17 +822,21 @@ int CmdFSKdemodAWID(const char *Cmd) //get binary from fsk wave int idx = AWIDdemodFSK(BitStream, size); if (idx<=0){ - if (verbose){ + if (g_debugMode==1){ if (idx == -1) - PrintAndLog("Error: not enough samples"); + PrintAndLog("DEBUG: Error - not enough samples"); else if (idx == -2) - PrintAndLog("Error: only noise found - no waves"); + PrintAndLog("DEBUG: Error - only noise found - no waves"); else if (idx == -3) - PrintAndLog("Error: problem during FSK demod"); + PrintAndLog("DEBUG: Error - problem during FSK demod"); // else if (idx == -3) // PrintAndLog("Error: thought we had a tag but the parity failed"); else if (idx == -4) - PrintAndLog("Error: AWID preamble not found"); + PrintAndLog("DEBUG: Error - AWID preamble not found"); + else if (idx == -5) + PrintAndLog("DEBUG: Error - Second AWID preamble not found"); + else + PrintAndLog("DEBUG: Error %d",idx); } return 0; } @@ -766,9 +858,11 @@ int CmdFSKdemodAWID(const char *Cmd) uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32); uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32); uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32); + setDemodBuf(BitStream,96,idx); + size = removeParity(BitStream, idx+8, 4, 1, 88); if (size != 66){ - if (verbose) PrintAndLog("Error: at parity check-tag size does not match AWID format"); + if (g_debugMode==1) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format"); return 0; } // ok valid card found! @@ -807,9 +901,11 @@ int CmdFSKdemodAWID(const char *Cmd) PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo); } } - + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, Len: %d Printing Demod Buffer:", idx, 96); + printDemodBuff(); + } //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands - return 1; } @@ -818,10 +914,6 @@ int CmdFSKdemodAWID(const char *Cmd) //print full Farpointe Data/Pyramid Prox ID and some bit format details if found int CmdFSKdemodPyramid(const char *Cmd) { - - int verbose=1; - sscanf(Cmd, "%i", &verbose); - //raw fsk demod no manchester decoding no start bit finding just get binary from wave uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; size_t size = getFromGraphBuf(BitStream); @@ -829,23 +921,22 @@ int CmdFSKdemodPyramid(const char *Cmd) //get binary from fsk wave int idx = PyramiddemodFSK(BitStream, size); if (idx < 0){ - if (verbose){ + if (g_debugMode==1){ if (idx == -5) - PrintAndLog("Error: not enough samples"); + PrintAndLog("DEBUG: Error - not enough samples"); else if (idx == -1) - PrintAndLog("Error: only noise found - no waves"); + PrintAndLog("DEBUG: Error - only noise found - no waves"); else if (idx == -2) - PrintAndLog("Error: problem during FSK demod"); - //else if (idx == -3) - // PrintAndLog("Error: thought we had a tag but the parity failed"); + PrintAndLog("DEBUG: Error - problem during FSK demod"); + else if (idx == -3) + PrintAndLog("DEBUG: Error - Second Pyramid preamble not found"); else if (idx == -4) - PrintAndLog("Error: AWID preamble not found"); + PrintAndLog("DEBUG: Error - Pyramid preamble not found"); + else + PrintAndLog("DEBUG: Error - idx: %d",idx); } - PrintAndLog("idx: %d",idx); return 0; } - //PrintAndLog("DEBUG: idx: %d",idx); - // Index map // 0 10 20 30 40 50 60 // | | | | | | | @@ -872,9 +963,11 @@ int CmdFSKdemodPyramid(const char *Cmd) uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32); uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32); uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32); + setDemodBuf(BitStream,128,idx); + size = removeParity(BitStream, idx+8, 8, 1, 120); if (size != 105){ - if (verbose) PrintAndLog("Error: at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3); + if (g_debugMode==1) PrintAndLog("DEBUG: Error at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3); return 0; } @@ -902,10 +995,9 @@ int CmdFSKdemodPyramid(const char *Cmd) // (26 bit format shown) //find start bit to get fmtLen - idx = 0; int j; for (j=0; j32){ //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32); //code2 = bytebits_to_byte(BitStream+(size-32),32); - PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); + PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); } else{ //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen); - PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); + PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); } } //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands - + if (g_debugMode){ + PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128); + printDemodBuff(); + } return 1; } @@ -1057,6 +1152,8 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating return 0; } +//by marshmellow +//attempt to detect the field clock and bit clock for FSK int CmdFSKfcDetect(const char *Cmd) { uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; @@ -1078,7 +1175,8 @@ int CmdDetectNRZpskClockRate(const char *Cmd) return 0; } -int PSKnrzDemod(const char *Cmd){ +int PSKnrzDemod(const char *Cmd) +{ int invert=0; int clk=0; sscanf(Cmd, "%i %i", &clk, &invert); @@ -1091,13 +1189,13 @@ int PSKnrzDemod(const char *Cmd){ int errCnt=0; errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert); if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) - //PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); + if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); return -1; } PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); //prime demod buffer for output - setDemodBuf(BitStream,BitLen); + setDemodBuf(BitStream,BitLen,0); return errCnt; } // Indala 26 bit decode @@ -1105,35 +1203,30 @@ int PSKnrzDemod(const char *Cmd){ // optional arguments - same as CmdpskNRZrawDemod (clock & invert) int CmdIndalaDecode(const char *Cmd) { - uint8_t verbose = 1; int ans; if (strlen(Cmd)>0){ - if (Cmd[0]=='0'){ - verbose=0; - ans = PSKnrzDemod("32"); - }else{ - ans = PSKnrzDemod(Cmd); - } + ans = PSKnrzDemod(Cmd); } else{ //default to RF/32 ans = PSKnrzDemod("32"); } if (ans < 0){ - if (verbose) + if (g_debugMode==1) PrintAndLog("Error1: %d",ans); return 0; } uint8_t invert=0; ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert); if (ans < 1) { - if (verbose) + if (g_debugMode==1) PrintAndLog("Error2: %d",ans); return -1; } char showbits[251]; if (invert) - if (verbose) + if (g_debugMode==1) PrintAndLog("Had to invert bits"); + //convert UID to HEX uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7; int idx; @@ -1197,25 +1290,28 @@ int CmdPskClean(const char *Cmd) //prints binary found and saves in graphbuffer for further commands int CmdpskNRZrawDemod(const char *Cmd) { - uint8_t verbose = 1; int errCnt; - if (strlen(Cmd)>0){ - if (Cmd[0]=='0') - verbose=0; - } - + errCnt = PSKnrzDemod(Cmd); //output - if (errCnt<0) return 0; + if (errCnt<0){ + if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt); + return 0; + } if (errCnt>0){ - if (verbose) + if (g_debugMode){ PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); - } - PrintAndLog("PSK or NRZ demoded bitstream:"); - // Now output the bitstream to the scrollback by line of 16 bits - printDemodBuff(); - - return 1; + PrintAndLog("PSK or NRZ demoded bitstream:"); + // Now output the bitstream to the scrollback by line of 16 bits + printDemodBuff(); + } + }else{ + PrintAndLog("PSK or NRZ demoded bitstream:"); + // Now output the bitstream to the scrollback by line of 16 bits + printDemodBuff(); + return 1; + } + return 0; } int CmdGrid(const char *Cmd) @@ -1367,14 +1463,14 @@ int CmdTuneSamples(const char *Cmd) int CmdLoad(const char *Cmd) { - char filename[FILE_PATH_SIZE] = {0x00}; - int len = 0; + char filename[FILE_PATH_SIZE] = {0x00}; + int len = 0; - len = strlen(Cmd); - if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; - memcpy(filename, Cmd, len); + len = strlen(Cmd); + if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; + memcpy(filename, Cmd, len); - FILE *f = fopen(filename, "r"); + FILE *f = fopen(filename, "r"); if (!f) { PrintAndLog("couldn't open '%s'", filename); return 0; @@ -1403,6 +1499,8 @@ int CmdLtrim(const char *Cmd) RepaintGraphWindow(); return 0; } + +// trim graph to input argument length int CmdRtrim(const char *Cmd) { int ds = atoi(Cmd); @@ -1683,12 +1781,12 @@ int CmdPlot(const char *Cmd) int CmdSave(const char *Cmd) { - char filename[FILE_PATH_SIZE] = {0x00}; - int len = 0; + char filename[FILE_PATH_SIZE] = {0x00}; + int len = 0; - len = strlen(Cmd); - if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; - memcpy(filename, Cmd, len); + len = strlen(Cmd); + if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; + memcpy(filename, Cmd, len); FILE *f = fopen(filename, "w"); @@ -1814,6 +1912,7 @@ static command_t CommandTable[] = {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK tag using raw"}, {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox tag FSK using raw"}, {"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"}, + {"fskparadoxdemod",CmdFSKdemodParadox,1, "Demodulate graph window as a Paradox FSK tag using raw"}, {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"}, {"grid", CmdGrid, 1, " -- overlay grid on graph window, use zero value to turn off either"}, {"hexsamples", CmdHexsamples, 0, " [] -- Dump big buffer as hex bytes"}, @@ -1834,6 +1933,8 @@ static command_t CommandTable[] = {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"save", CmdSave, 1, " -- Save trace (from graph window)"}, {"scale", CmdScale, 1, " -- Set cursor display scale"}, + {"setdebugmode", CmdSetDebugMode, 1, "<0|1> -- Turn on or off Debugging Mode for demods"}, + {"shiftgraphzero",CmdGraphShiftZero, 1, " -- Shift 0 for Graphed wave + or - shift value"}, {"threshold", CmdThreshold, 1, " -- Maximize/minimize every value in the graph window depending on threshold"}, {"dirthreshold", CmdDirectionalThreshold, 1, " -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, diff --git a/client/cmddata.h b/client/cmddata.h index ffd6b983..d87c8b82 100644 --- a/client/cmddata.h +++ b/client/cmddata.h @@ -30,6 +30,7 @@ int CmdFSKdemodAWID(const char *Cmd); int CmdFSKdemod(const char *Cmd); int CmdFSKdemodHID(const char *Cmd); int CmdFSKdemodIO(const char *Cmd); +int CmdFSKdemodParadox(const char *Cmd); int CmdFSKdemodPyramid(const char *Cmd); int CmdFSKrawdemod(const char *Cmd); int CmdDetectNRZpskClockRate(const char *Cmd); diff --git a/client/cmdlf.c b/client/cmdlf.c index 945b4557..9fc6b999 100644 --- a/client/cmdlf.c +++ b/client/cmdlf.c @@ -575,36 +575,41 @@ int CmdLFfind(const char *Cmd) } PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag"); - PrintAndLog("Checking for known tags:"); + PrintAndLog("\nChecking for known tags:\n"); ans=CmdFSKdemodIO(""); if (ans>0) { - PrintAndLog("Valid IO Prox ID Found!"); + PrintAndLog("\nValid IO Prox ID Found!"); return 1; } - ans=CmdFSKdemodPyramid("0"); + ans=CmdFSKdemodPyramid(""); if (ans>0) { - PrintAndLog("Valid Pyramid ID Found!"); + PrintAndLog("\nValid Pyramid ID Found!"); return 1; } - ans=CmdFSKdemodAWID("0"); + ans=CmdFSKdemodParadox(""); if (ans>0) { - PrintAndLog("Valid AWID ID Found!"); + PrintAndLog("\nValid Paradox ID Found!"); + return 1; + } + ans=CmdFSKdemodAWID(""); + if (ans>0) { + PrintAndLog("\nValid AWID ID Found!"); return 1; } ans=CmdFSKdemodHID(""); if (ans>0) { - PrintAndLog("Valid HID Prox ID Found!"); + PrintAndLog("\nValid HID Prox ID Found!"); return 1; } //add psk and indala - ans=CmdIndalaDecode("0"); + ans=CmdIndalaDecode(""); if (ans>0) { - PrintAndLog("Valid Indala ID Found!"); + PrintAndLog("\nValid Indala ID Found!"); return 1; } ans=Cmdaskmandemod(""); if (ans>0) { - PrintAndLog("Valid EM410x ID Found!"); + PrintAndLog("\nValid EM410x ID Found!"); return 1; } PrintAndLog("No Known Tags Found!\n"); diff --git a/client/graph.c b/client/graph.c index 6362c8fe..174e4a5f 100644 --- a/client/graph.c +++ b/client/graph.c @@ -69,6 +69,8 @@ size_t getFromGraphBuf(uint8_t *buff) } return i; } + + // Get or auto-detect clock rate int GetClock(const char *str, int peak, int verbose) { diff --git a/common/lfdemod.c b/common/lfdemod.c index 4a80a10c..8f1a3764 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -31,7 +31,7 @@ int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi //by marshmellow //takes 1s and 0s and searches for EM410x format - output EM ID -uint64_t Em410xDecode(uint8_t *BitStream, size_t size) +uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx) { //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future // otherwise could be a void with no arguments @@ -48,17 +48,18 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size) uint32_t idx = 0; uint32_t ii=0; uint8_t resetCnt = 0; - while( (idx + 64) < size) { + while( (idx + 64) < *size) { restart: // search for a start of frame marker if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) { // frame marker found + *startIdx=idx; idx+=9; for (i=0; i<10;i++){ for(ii=0; ii<5; ++ii){ parityTest ^= BitStream[(i*5)+ii+idx]; } - if (!parityTest){ + if (!parityTest){ //even parity parityTest=0; for (ii=0; ii<4;++ii){ lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]); @@ -74,6 +75,7 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size) } } //skip last 5 bit parity test for simplicity. + *size = 64; return lo; }else{ idx++; @@ -89,10 +91,12 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size) int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) { int i; + int clk2=*clk; *clk=DetectASKClock(BinStream, *size, *clk); //clock default - if (*clk<8) *clk =64; - if (*clk<32) *clk=32; + // if autodetected too low then adjust //MAY NEED ADJUSTMENT + if (clk2==0 && *clk<8) *clk =64; + if (clk2==0 && *clk<32) *clk=32; if (*invert != 0 && *invert != 1) *invert=0; uint32_t initLoopMax = 200; if (initLoopMax > *size) initLoopMax=*size; @@ -106,7 +110,7 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) int lastBit = 0; //set first clock check uint32_t bitnum = 0; //output counter int 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 + 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 int iii = 0; uint32_t gLen = *size; if (gLen > 3000) gLen=3000; @@ -198,6 +202,22 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) return bestErrCnt; } +//by marshmellow +//encode binary data into binary manchester +int ManchesterEncode(uint8_t *BitStream, size_t size) +{ + size_t modIdx=20000, 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]; + } + return i; +} + //by marshmellow //take 10 and 01 and manchester decode //run through 2 times and take least errCnt @@ -245,7 +265,6 @@ int manrawdecode(uint8_t * BitStream, size_t *size) return errCnt; } - //by marshmellow //take 01 or 10 = 0 and 11 or 00 = 1 int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert) @@ -282,8 +301,8 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) //uint8_t BitStream[502] = {0}; //HACK: if clock not detected correctly - default - if (*clk<8) *clk =64; - if (*clk<32 && clk2==0) *clk=32; + if (clk2==0 && *clk<8) *clk =64; + if (clk2==0 && *clk<32 && clk2==0) *clk=32; if (*invert != 0 && *invert != 1) *invert =0; uint32_t initLoopMax = 200; if (initLoopMax > *size) initLoopMax=*size; @@ -534,12 +553,13 @@ int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t return size; } // 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) +int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo) { - size_t idx=0; //, found=0; //size=0, + size_t idx=0, size2=*size, startIdx=0; // FSK demodulator - size = fskdemod(dest, size,50,0,10,8); + + *size = fskdemod(dest, size2,50,0,10,8); // final loop, go over previously decoded manchester data and decode into usable tag ID // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 @@ -547,12 +567,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_ int numshifts = 0; idx = 0; //one scan - while( idx + sizeof(frame_marker_mask) < size) { + while( idx + sizeof(frame_marker_mask) < *size) { // search for a start of frame marker if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) { // frame marker found + startIdx=idx; idx+=sizeof(frame_marker_mask); - while(dest[idx] != dest[idx+1] && idx < size-2) + while(dest[idx] != dest[idx+1] && idx < *size-2) { // Keep going until next frame marker (or error) // Shift in a bit. Start by shifting high registers @@ -567,12 +588,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_ idx += 2; } // Hopefully, we read a tag and hit upon the next frame marker - if(idx + sizeof(frame_marker_mask) < size) + if(idx + sizeof(frame_marker_mask) < *size) { if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) { //good return - return idx; + *size=idx-startIdx; + return startIdx; } } // reset @@ -585,6 +607,61 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_ return -1; } +// loop to get raw paradox waveform then FSK demodulate the TAG ID from it +size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo) +{ + + size_t idx=0, size2=*size; + // FSK demodulator + + *size = fskdemod(dest, size2,50,1,10,8); + + // final loop, go over previously decoded manchester data and decode into usable tag ID + // 00001111 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 + uint8_t frame_marker_mask[] = {0,0,0,0,1,1,1,1}; + uint16_t numshifts = 0; + idx = 0; + //one scan + while( idx + sizeof(frame_marker_mask) < *size) { + // search for a start of frame marker + if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) + { // frame marker found + size2=idx; + idx+=sizeof(frame_marker_mask); + while(dest[idx] != dest[idx+1] && idx < *size-2) + { + // Keep going until next frame marker (or error) + // Shift in a bit. Start by shifting high registers + *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; + numshifts++; + idx += 2; + } + // Hopefully, we read a tag and hit upon the next frame marker and got enough bits + if(idx + sizeof(frame_marker_mask) < *size && numshifts > 40) + { + if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) + { + //good return - return start grid position and bits found + *size = ((numshifts*2)+8); + return size2; + } + } + // reset + *hi2 = *hi = *lo = 0; + numshifts = 0; + }else { + idx++; + } + } + return 0; +} + uint32_t bytebits_to_byte(uint8_t* src, size_t numbits) { uint32_t num = 0; @@ -638,10 +715,10 @@ int IOdemodFSK(uint8_t *dest, size_t size) // by marshmellow // pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType // returns 1 if passed -int parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType) +uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType) { uint8_t ans = 0; - for (int i = 0; i < bitLen; i++){ + for (uint8_t i = 0; i < bitLen; i++){ ans ^= ((bits >> i) & 1); } //PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType); @@ -676,7 +753,7 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p int AWIDdemodFSK(uint8_t *dest, size_t size) { static const uint8_t THRESHOLD = 123; - uint32_t idx=0; + uint32_t idx=0, idx2=0; //make sure buffer has data if (size < 96*50) return -1; //test samples are not just noise @@ -694,9 +771,12 @@ int AWIDdemodFSK(uint8_t *dest, size_t size) for( idx=0; idx < (size - 96); idx++) { if ( memcmp(dest + idx, mask, sizeof(mask))==0) { // frame marker found - //return ID start index and size - return idx; - //size should always be 96 + //return ID start index + if (idx2 == 0) idx2=idx; + else if(idx-idx2==96) return idx2; + else return -5; + + // should always get 96 bits if it is awid } } //never found mask @@ -708,8 +788,8 @@ int AWIDdemodFSK(uint8_t *dest, size_t size) int PyramiddemodFSK(uint8_t *dest, size_t size) { static const uint8_t THRESHOLD = 123; - uint32_t idx=0; - // size_t size2 = size; + uint32_t idx=0, idx2=0; + // size_t size2 = size; //make sure buffer has data if (size < 128*50) return -5; //test samples are not just noise @@ -727,78 +807,85 @@ int PyramiddemodFSK(uint8_t *dest, size_t size) for( idx=0; idx < (size - 128); idx++) { if ( memcmp(dest + idx, mask, sizeof(mask))==0) { // frame marker found - return idx; + if (idx2==0) idx2=idx; + else if (idx-idx2==128) return idx2; + else return -3; } } //never found mask return -4; } + // 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? int DetectASKClock(uint8_t dest[], size_t size, int clock) { - int i=0; - int clk[]={8,16,32,40,50,64,100,128,256}; - int loopCnt = 256; //don't need to loop through entire array... - if (size= peak) || (dest[ii] <= low)){ - errCnt=0; - // now that we have the first one lined up test rest of wave array - for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){ - if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){ - }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){ - }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){ - }else{ //error no peak detected - errCnt++; - } - } - //if we found no errors this is correct one - return this clock - if(errCnt==0) return clk[clkCnt]; - //if we found errors see if it is lowest so far and save it as best run - if(errCnt= peak) || (dest[ii] <= low)){ + errCnt=0; + // now that we have the first one lined up test rest of wave array + for (i=0; i<((int)((size-ii-tol)/clk[clkCnt])-1); ++i){ + if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){ + }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){ + }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){ + }else{ //error no peak detected + errCnt++; + } + } + //if we found no errors then we can stop here + // this is correct one - return this clock + //PrintAndLog("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i); + if(errCnt==0 && clkCnt<6) return clk[clkCnt]; + //if we found errors see if it is lowest so far and save it as best run + if(errCnt= 32){ + for(clkCnt=0; clkCnt < 7; ++clkCnt){ + if (clk[clkCnt] <= 32){ tol=1; }else{ tol=0; @@ -837,7 +924,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) errCnt=0; peakcnt=0; // now that we have the first one lined up test rest of wave array - for (i=0; i < ((int)(size/clk[clkCnt])-1); ++i){ + for (i=0; i < ((int)((size-ii-tol)/clk[clkCnt])-1); ++i){ if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){ peakcnt++; }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){ diff --git a/common/lfdemod.h b/common/lfdemod.h index ae04bc2f..9698d8bd 100644 --- a/common/lfdemod.h +++ b/common/lfdemod.h @@ -17,11 +17,12 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock); int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); -uint64_t Em410xDecode(uint8_t *BitStream,size_t size); +uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx); +int ManchesterEncode(uint8_t *BitStream, size_t size); int manrawdecode(uint8_t *BitStream, size_t *size); int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert); int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); -int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); +int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); int IOdemodFSK(uint8_t *dest, size_t size); int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow); uint32_t bytebits_to_byte(uint8_t* src, size_t numbits); @@ -34,5 +35,6 @@ int AWIDdemodFSK(uint8_t *dest, size_t size); size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen); uint32_t countFC(uint8_t *BitStream, size_t size); int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo); +size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); #endif From 03e6bb4aed0ffd8e19897062071e18945c703d9d Mon Sep 17 00:00:00 2001 From: marshmellow42 Date: Thu, 22 Jan 2015 14:24:03 -0500 Subject: [PATCH 3/5] lf FSK demod tools/fixes added full ability to detect FSK clocks applied autodetect of fsk clock to data fskrawdemod this finished data fskfcdetect (now detects field clocks and bit clock) --- client/cmddata.c | 46 +++++++-- common/lfdemod.c | 261 ++++++++++++++++++++++++++--------------------- common/lfdemod.h | 3 +- 3 files changed, 180 insertions(+), 130 deletions(-) diff --git a/client/cmddata.c b/client/cmddata.c index 578587bc..998f5ebb 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -604,22 +604,40 @@ int CmdFSKrawdemod(const char *Cmd) { //raw fsk demod no manchester decoding no start bit finding just get binary from wave //set defaults - int rfLen = 50; + int rfLen = 0; int invert=0; - int fchigh=10; - int fclow=8; + int fchigh=0; + int fclow=0; //set options from parameters entered with the command sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow); if (strlen(Cmd)>0 && strlen(Cmd)<=2) { if (rfLen==1){ invert=1; //if invert option only is used - rfLen = 50; - } else if(rfLen==0) rfLen=50; + rfLen = 0; + } } - PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow); + uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; size_t BitLen = getFromGraphBuf(BitStream); + //get field clock lengths + uint16_t fcs=0; + if (fchigh==0 || fclow == 0){ + fcs=countFC(BitStream, BitLen); + if (fcs==0){ + fchigh=10; + fclow=8; + }else{ + fchigh = (fcs >> 8) & 0xFF; + fclow = fcs & 0xFF; + } + } + //get bit clock length + if (rfLen==0){ + rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow); + if (rfLen == 0) rfLen = 50; + } + PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow); int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); if (size>0){ PrintAndLog("FSK decoded bitstream:"); @@ -1159,12 +1177,20 @@ int CmdFSKfcDetect(const char *Cmd) uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; size_t size = getFromGraphBuf(BitStream); - - uint32_t ans = countFC(BitStream, size); - int fc1, fc2, rf1; + uint16_t ans = countFC(BitStream, size); + if (ans==0) { + if (g_debugMode) PrintAndLog("DEBUG: No data found"); + return 0; + } + uint8_t fc1, fc2; fc1 = (ans >> 8) & 0xFF; fc2 = ans & 0xFF; - rf1 = (ans >>16) & 0xFF; + + uint8_t rf1 = detectFSKClk(BitStream, size, fc1, fc2); + if (rf1==0) { + if (g_debugMode) PrintAndLog("DEBUG: Clock detect error"); + return 0; + } PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1); return 1; } diff --git a/common/lfdemod.c b/common/lfdemod.c index 8f1a3764..34194394 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -1200,96 +1200,64 @@ int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert) //by marshmellow -//countFC is to detect the field clock and bit clock rates. -//for fsk or ask not psk or nrz -uint32_t countFC(uint8_t *BitStream, size_t size) +//detects the bit clock for FSK given the high and low Field Clocks +uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) { - // get high/low thresholds - int high, low; - getHiLo(BitStream,10, &high, &low, 100, 100); - // get zero crossing - uint8_t zeroC = (high-low)/2+low; - uint8_t clk[]={8,16,32,40,50,64,100,128}; - uint8_t fcLens[] = {0,0,0,0,0,0,0,0,0,0}; - uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0}; - uint8_t rfLens[] = {0,0,0,0,0,0,0,0,0,0,0}; - // uint8_t rfCnts[] = {0,0,0,0,0,0,0,0,0,0}; - uint8_t fcLensFnd = 0; + uint8_t clk[] = {8,16,32,40,50,64,100,128,0}; + uint16_t rfLens[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + uint8_t rfCnts[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t rfLensFnd = 0; - uint8_t lastBit=0; - uint8_t curBit=0; uint8_t lastFCcnt=0; - uint32_t errCnt=0; uint32_t fcCounter = 0; - uint32_t rfCounter = 0; + uint16_t rfCounter = 0; uint8_t firstBitFnd = 0; - int i; - + size_t i; + + uint8_t fcTol = (uint8_t)(0.5+(float)(fcHigh-fcLow)/2); + rfLensFnd=0; + fcCounter=0; + rfCounter=0; + firstBitFnd=0; + //PrintAndLog("DEBUG: fcTol: %d",fcTol); // prime i to first up transition - for (i = 1; i < size; i++) - if (BitStream[i]>=zeroC && BitStream[i-1] BitStream[i-1] && BitStream[i]>=BitStream[i+1]) break; - for (; i < size; i++){ - curBit = BitStream[i]; - lastBit = BitStream[i-1]; - if (lastBit= zeroC){ - // new up transition + for (; i < size-1; i++){ + if (BitStream[i] > BitStream[i-1] && BitStream[i]>=BitStream[i+1]){ + // new peak fcCounter++; rfCounter++; - if (fcCounter > 3 && fcCounter < 256){ - //we've counted enough that it could be a valid field clock - - //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 odd and not rc/5 add one (for when we get a fc 9 instead of 10) - if ((fcCounter==9 && fcCounter & 1) || fcCounter==4) fcCounter++; + // if we got less than the small fc + tolerance then set it to the small fc + if (fcCounter < fcLow+fcTol) + fcCounter = fcLow; + else //set it to the large fc + fcCounter = fcHigh; - //look for bit clock (rf/xx) - if ((fcCounterlastFCcnt)){ - //not the same size as the last wave - start of new bit sequence + //look for bit clock (rf/xx) + if ((fcCounterlastFCcnt)){ + //not the same size as the last wave - start of new bit sequence - if (firstBitFnd>1){ //skip first wave change - probably not a complete bit - for (int ii=0; ii<10; ii++){ - if (rfLens[ii]==rfCounter){ - //rfCnts[ii]++; - rfCounter=0; - break; - } + if (firstBitFnd>1){ //skip first wave change - probably not a complete bit + for (int ii=0; ii<15; ii++){ + if (rfLens[ii]==rfCounter){ + rfCnts[ii]++; + rfCounter=0; + break; } - if (rfCounter>0 && rfLensFnd<10){ - //PrintAndLog("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter); - //rfCnts[rfLensFnd]++; - rfLens[rfLensFnd++]=rfCounter; - } - } else { - //PrintAndLog("DEBUG i: %d",i); - firstBitFnd++; } - rfCounter=0; - lastFCcnt=fcCounter; - } - - // save last field clock count (fc/xx) - // find which fcLens to save it to: - for (int ii=0; ii<10; ii++){ - if (fcLens[ii]==fcCounter){ - fcCnts[ii]++; - fcCounter=0; - break; + if (rfCounter>0 && rfLensFnd<15){ + //PrintAndLog("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter); + rfCnts[rfLensFnd]++; + rfLens[rfLensFnd++]=rfCounter; } + } else { + firstBitFnd++; } - if (fcCounter>0 && fcLensFnd<10){ - //add new fc length - //PrintAndLog("FCCntr %d",fcCounter); - fcCnts[fcLensFnd]++; - fcLens[fcLensFnd++]=fcCounter; - } - } else{ - // hmmm this should not happen often - count them - errCnt++; + rfCounter=0; + lastFCcnt=fcCounter; } - // reset counter fcCounter=0; } else { // count sample @@ -1297,15 +1265,99 @@ uint32_t countFC(uint8_t *BitStream, size_t size) rfCounter++; } } - // if too many errors return errors as negative number (IS THIS NEEDED?) - if (errCnt>100) return -1*errCnt; - - uint8_t maxCnt1=0, best1=9, best2=9, best3=9, rfHighest=10, rfHighest2=10, rfHighest3=10; + uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15; + for (i=0; i<15; i++){ + //PrintAndLog("DEBUG: RF %d, cnts %d",rfLens[i], rfCnts[i]); + //get highest 2 RF values (might need to get more values to compare or compare all?) + if (rfCnts[i]>rfCnts[rfHighest]){ + rfHighest3=rfHighest2; + rfHighest2=rfHighest; + rfHighest=i; + } else if(rfCnts[i]>rfCnts[rfHighest2]){ + rfHighest3=rfHighest2; + rfHighest2=i; + } else if(rfCnts[i]>rfCnts[rfHighest3]){ + rfHighest3=i; + } + } + // set allowed clock remainder tolerance to be 1 large field clock length+1 + // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off + uint8_t tol1 = fcHigh+1; + + //PrintAndLog("DEBUG: hightest: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]); + + // loop to find the highest clock that has a remainder less than the tolerance + // compare samples counted divided by + int ii=7; + for (; ii>=0; ii--){ + if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){ + if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){ + if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){ + break; + } + } + } + } + + if (ii<0) return 0; // oops we went too far + + return clk[ii]; +} + +//by marshmellow +//countFC is to detect the field clock lengths. +//counts and returns the 2 most common wave lengths +uint16_t countFC(uint8_t *BitStream, size_t size) +{ + uint8_t fcLens[] = {0,0,0,0,0,0,0,0,0,0}; + uint16_t fcCnts[] = {0,0,0,0,0,0,0,0,0,0}; + uint8_t fcLensFnd = 0; + uint8_t lastFCcnt=0; + uint32_t fcCounter = 0; + size_t i; + + // prime i to first up transition + for (i = 1; i < size-1; i++) + if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]) + break; + + for (; i < size-1; i++){ + if (BitStream[i] > BitStream[i-1] && BitStream[i] >= BitStream[i+1]){ + // new up transition + fcCounter++; + + //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 odd and not rc/5 add one (for when we get a fc 9 instead of 10) + if ((fcCounter==9 && fcCounter & 1) || fcCounter==4) fcCounter++; + + // save last field clock count (fc/xx) + // find which fcLens to save it to: + for (int ii=0; ii<10; ii++){ + if (fcLens[ii]==fcCounter){ + fcCnts[ii]++; + fcCounter=0; + break; + } + } + if (fcCounter>0 && fcLensFnd<10){ + //add new fc length + fcCnts[fcLensFnd]++; + fcLens[fcLensFnd++]=fcCounter; + } + fcCounter=0; + } else { + // count sample + fcCounter++; + } + } + + uint8_t best1=9, best2=9, best3=9; + uint16_t maxCnt1=0; // go through fclens and find which ones are bigest 2 for (i=0; i<10; i++){ - // PrintAndLog("DEBUG: FC %d, Cnt %d, Errs %d, RF %d",fcLens[i],fcCnts[i],errCnt,rfLens[i]); - + // PrintAndLog("DEBUG: FC %d, Cnt %d, Errs %d",fcLens[i],fcCnts[i],errCnt); // get the 3 best FC values if (fcCnts[i]>maxCnt1) { best3=best2; @@ -1318,49 +1370,20 @@ uint32_t countFC(uint8_t *BitStream, size_t size) } else if(fcCnts[i]>fcCnts[best3]){ best3=i; } - //get highest 2 RF values (might need to get more values to compare or compare all?) - if (rfLens[i]>rfLens[rfHighest]){ - rfHighest3=rfHighest2; - rfHighest2=rfHighest; - rfHighest=i; - } else if(rfLens[i]>rfLens[rfHighest2]){ - rfHighest3=rfHighest2; - rfHighest2=i; - } else if(rfLens[i]>rfLens[rfHighest3]){ - rfHighest3=i; - } } - - // set allowed clock remainder tolerance to be 1 large field clock length - // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off - int tol1 = (fcLens[best1]>fcLens[best2]) ? fcLens[best1] : fcLens[best2]; - - // loop to find the highest clock that has a remainder less than the tolerance - // compare samples counted divided by - int ii=7; - for (; ii>=0; ii--){ - if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){ - if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){ - if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){ - break; - } - } - } + 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 (ii<0) ii=7; // oops we went too far - + // TODO: take top 3 answers and compare to known Field clocks to get top 2 - uint32_t fcs=0; - // PrintAndLog("DEBUG: Best %d best2 %d best3 %d, clk %d, clk2 %d",fcLens[best1],fcLens[best2],fcLens[best3],clk[i],clk[ii]); - // - - if (fcLens[best1]>fcLens[best2]){ - fcs = (((uint32_t)clk[ii])<<16) | (((uint32_t)fcLens[best1])<<8) | ((fcLens[best2])); - } else { - fcs = (((uint32_t)clk[ii])<<16) | (((uint32_t)fcLens[best2])<<8) | ((fcLens[best1])); - } - + uint16_t fcs = (((uint16_t)fcH)<<8) | fcL; + // PrintAndLog("DEBUG: Best %d best2 %d best3 %d",fcLens[best1],fcLens[best2],fcLens[best3]); + return fcs; } diff --git a/common/lfdemod.h b/common/lfdemod.h index 9698d8bd..ca50d4f2 100644 --- a/common/lfdemod.h +++ b/common/lfdemod.h @@ -33,7 +33,8 @@ void pskCleanWave(uint8_t *bitStream, size_t size); int PyramiddemodFSK(uint8_t *dest, size_t size); int AWIDdemodFSK(uint8_t *dest, size_t size); size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen); -uint32_t countFC(uint8_t *BitStream, size_t size); +uint16_t countFC(uint8_t *BitStream, size_t size); +uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow); int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo); size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); From 04d2721b3c7c4113e627d3f953835bde932065db Mon Sep 17 00:00:00 2001 From: marshmellow42 Date: Mon, 26 Jan 2015 17:23:19 -0500 Subject: [PATCH 4/5] lf psk demods clarify existing as psk1 added psk2 demod --- client/cmddata.c | 53 ++++++++++++++++++++++++++++++++++++------------ common/lfdemod.c | 32 ++++++++++++++++++++--------- common/lfdemod.h | 1 + 3 files changed, 63 insertions(+), 23 deletions(-) diff --git a/client/cmddata.c b/client/cmddata.c index 0a1841bf..0c6cd72c 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -721,8 +721,8 @@ int CmdFSKdemodHID(const char *Cmd) return 1; } -//by marshmellow (based on existing demod + holiman's refactor) -//Paradox Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded) +//by marshmellow +//Paradox Prox demod - FSK RF/50 with preamble of 00001111 (then manchester encoded) //print full Paradox Prox ID and some bit format details if found int CmdFSKdemodParadox(const char *Cmd) { @@ -1196,7 +1196,7 @@ int CmdDetectNRZpskClockRate(const char *Cmd) return 0; } -int PSKnrzDemod(const char *Cmd) +int PSKnrzDemod(const char *Cmd, uint8_t verbose) { int invert=0; int clk=0; @@ -1213,7 +1213,7 @@ int PSKnrzDemod(const char *Cmd) if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); return -1; } - PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); + if (verbose) PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); //prime demod buffer for output setDemodBuf(BitStream,BitLen,0); @@ -1226,9 +1226,9 @@ int CmdIndalaDecode(const char *Cmd) { int ans; if (strlen(Cmd)>0){ - ans = PSKnrzDemod(Cmd); + ans = PSKnrzDemod(Cmd, 0); } else{ //default to RF/32 - ans = PSKnrzDemod("32"); + ans = PSKnrzDemod("32", 0); } if (ans < 0){ @@ -1305,15 +1305,15 @@ int CmdPskClean(const char *Cmd) return 0; } -//by marshmellow -//takes 2 arguments - clock and invert both as integers -//attempts to demodulate ask only -//prints binary found and saves in graphbuffer for further commands +// by marshmellow +// takes 2 arguments - clock and invert both as integers +// attempts to demodulate psk only +// prints binary found and saves in demodbuffer for further commands int CmdpskNRZrawDemod(const char *Cmd) { int errCnt; - errCnt = PSKnrzDemod(Cmd); + errCnt = PSKnrzDemod(Cmd, 1); //output if (errCnt<0){ if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt); @@ -1335,6 +1335,32 @@ int CmdpskNRZrawDemod(const char *Cmd) return 0; } +// by marshmellow +// takes same args as cmdpsknrzrawdemod +int CmdPSK2rawDemod(const char *Cmd) +{ + int errCnt=0; + errCnt=PSKnrzDemod(Cmd, 1); + if (errCnt<0){ + if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt); + return 0; + } + psk1TOpsk2(DemodBuffer, DemodBufferLen); + if (errCnt>0){ + if (g_debugMode){ + PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); + PrintAndLog("PSK2 demoded bitstream:"); + // Now output the bitstream to the scrollback by line of 16 bits + printDemodBuff(); + } + }else{ + PrintAndLog("PSK2 demoded bitstream:"); + // Now output the bitstream to the scrollback by line of 16 bits + printDemodBuff(); + } + return 1; +} + int CmdGrid(const char *Cmd) { sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY); @@ -1949,8 +1975,9 @@ static command_t CommandTable[] = {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, {"pskclean", CmdPskClean, 1, "Attempt to clean psk wave"}, {"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"}, - {"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk indala tags and output ID binary & hex (args optional)"}, - {"psknrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk or nrz tags and output binary (args optional)"}, + {"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 indala tags and output ID binary & hex (args optional)"}, + {"psk1nrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 or nrz tags and output binary (args optional)"}, + {"psk2rawdemod", CmdPSK2rawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk2 tags and output binary (args optional)"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"save", CmdSave, 1, " -- Save trace (from graph window)"}, {"scale", CmdScale, 1, " -- Set cursor display scale"}, diff --git a/common/lfdemod.c b/common/lfdemod.c index 34194394..810e0357 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -816,7 +816,6 @@ int PyramiddemodFSK(uint8_t *dest, size_t size) return -4; } - // 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? @@ -885,7 +884,6 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock) return clk[best]; } - //by marshmellow //detect psk clock by reading #peaks vs no peaks(or errors) int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) @@ -963,7 +961,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) return clk[best]; } -//by marshmellow (attempt to get rid of high immediately after a low) +// by marshmellow (attempt to get rid of high immediately after a low) void pskCleanWave(uint8_t *BitStream, size_t size) { int i; @@ -999,9 +997,26 @@ void pskCleanWave(uint8_t *BitStream, size_t size) return; } +// 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 Date: Mon, 26 Jan 2015 17:49:30 -0500 Subject: [PATCH 5/5] clean up some comments --- client/cmddata.c | 8 ++++++++ common/lfdemod.c | 15 --------------- 2 files changed, 8 insertions(+), 15 deletions(-) diff --git a/client/cmddata.c b/client/cmddata.c index 0c6cd72c..9ed228a4 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -1190,12 +1190,17 @@ int CmdFSKfcDetect(const char *Cmd) return 1; } +//by marshmellow +//attempt to detect the bit clock for PSK or NRZ modulations int CmdDetectNRZpskClockRate(const char *Cmd) { GetNRZpskClock("",0,0); return 0; } +//by marshmellow +//attempt to psk1 or nrz demod graph buffer +//NOTE CURRENTLY RELIES ON PEAKS :( int PSKnrzDemod(const char *Cmd, uint8_t verbose) { int invert=0; @@ -1296,6 +1301,9 @@ int CmdIndalaDecode(const char *Cmd) return 1; } +//by marshmellow +//attempt to clean psk wave noise after a peak +//NOTE RELIES ON PEAKS :( int CmdPskClean(const char *Cmd) { uint8_t bitStream[MAX_GRAPH_TRACE_LEN]={0}; diff --git a/common/lfdemod.c b/common/lfdemod.c index 810e0357..1b499158 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -336,30 +336,20 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) for (i = iii; i < *size; ++i) { if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){ lastBit+=*clk; - //BitStream[bitnum] = *invert; - //bitnum++; midBit=0; } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){ //low found and we are expecting a bar lastBit+=*clk; - //BitStream[bitnum] = 1- *invert; - //bitnum++; midBit=0; } else if ((BinStream[i]<=low) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ //mid bar? midBit=1; - //BitStream[bitnum]= 1- *invert; - //bitnum++; } else if ((BinStream[i]>=high) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){ //mid bar? midBit=1; - //BitStream[bitnum]= *invert; - //bitnum++; } else if ((i-lastBit)>((*clk/2)+tol) && (midBit==0)){ //no mid bar found midBit=1; - //BitStream[bitnum]= BitStream[bitnum-1]; - //bitnum++; } else { //mid value found or no bar supposed to be here @@ -367,16 +357,11 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) //should have hit a high or low based on clock!! //debug //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit); - //if (bitnum > 0){ - // BitStream[bitnum]=77; - // bitnum++; - //} errCnt++; lastBit+=*clk;//skip over until hit too many errors if (errCnt > ((*size/1000))){ //allow 1 error for every 1000 samples else start over errCnt=0; - // bitnum=0;//start over break; } }