Proxmark/proxmark3
1
1
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2024-09-21 15:26:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

lf ask consolidation

Browse source 
backend:
askman and askraw demods merged into askdemod (args adjusted
accordingly)
re-arranged lfdemod.h in alphabetical order and by category

front end:
data detectclock a (ask) now also reports the selected best start
position for demod
data manrawdecode takes an invert arg now
This commit is contained in:
marshmellow42 2015-04-08 01:07:39 -04:00
parent 49bbc60af3
commit fef74fdce4
9 changed files with 289 additions and 375 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
armsrc/lfops.c
View file

@ -861,7 +861,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
size = BigBuf_max_traceLen(); size = BigBuf_max_traceLen();
//askdemod and manchester decode //askdemod and manchester decode
if (size > 16385) size = 16385; //big enough to catch 2 sequences of largest format if (size > 16385) size = 16385; //big enough to catch 2 sequences of largest format
errCnt = askmandemod(dest, &size, &clk, &invert, maxErr); errCnt = askdemod(dest, &size, &clk, &invert, maxErr, 0, 1);
WDT_HIT(); WDT_HIT();
if (errCnt<0) continue; if (errCnt<0) continue;

212
client/cmddata.c
View file

@ -208,22 +208,34 @@ void printEM410x(uint32_t hi, uint64_t id)
return; return;
} }
int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo)
{ {
int ans = ASKmanDemod(Cmd, FALSE, FALSE); size_t idx = 0;
if (!ans) return 0; size_t BitLen = DemodBufferLen;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t idx=0; memcpy(BitStream, DemodBuffer, BitLen);
if (Em410xDecode(DemodBuffer,(size_t *) &DemodBufferLen, &idx, hi, lo)){ if (Em410xDecode(BitStream, &BitLen, &idx, hi, lo)){
//set GraphBuffer for clone or sim command
setDemodBuf(BitStream, BitLen, idx);
if (g_debugMode){ if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, DemodBufferLen); PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
printDemodBuff(); printDemodBuff();
} }
if (verbose){
PrintAndLog("EM410x pattern found: ");
printEM410x(*hi, *lo);
}
return 1; return 1;
} }
return 0; return 0;
} }
int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose)
{
if (!ASKDemod(Cmd, FALSE, FALSE, 1)) return 0;
return AskEm410xDecode(verbose, hi, lo);
}
//by marshmellow //by marshmellow
//takes 3 arguments - clock, invert and maxErr as integers //takes 3 arguments - clock, invert and maxErr as integers
//attempts to demodulate ask while decoding manchester //attempts to demodulate ask while decoding manchester
@ -244,28 +256,28 @@ int CmdAskEM410xDemod(const char *Cmd)
PrintAndLog(" : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors"); PrintAndLog(" : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
return 0; return 0;
} }
uint32_t hi = 0;
uint64_t lo = 0; uint64_t lo = 0;
if (AskEm410xDemod(Cmd, &hi, &lo)) { uint32_t hi = 0;
PrintAndLog("EM410x pattern found: "); return AskEm410xDemod(Cmd, &hi, &lo, true);
printEM410x(hi, lo);
return 1;
}
return 0;
} }
int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch) //by marshmellow
//Cmd Args: Clock, invert, maxErr, maxLen as integers and amplify as char == 'a'
// (amp may not be needed anymore)
//verbose will print results and demoding messages
//emSearch will auto search for EM410x format in bitstream
//askType switches decode: ask/raw = 0, ask/manchester = 1
int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
{ {
int invert=0; int invert=0;
int clk=0; int clk=0;
int maxErr=100; int maxErr=100;
int maxLen=512*64; int maxLen=0;
//param_getdec(Cmd, 0, &clk); uint8_t askAmp = 0;
//param_getdec(Cmd, 1, &invert); char amp = param_getchar(Cmd, 0);
//maxErr = param_get32ex(Cmd, 2, 0xFFFFFFFF, 10);
//if (maxErr == 0xFFFFFFFF) maxErr=100;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i %i %i", &clk, &invert, &maxErr, &maxLen); sscanf(Cmd, "%i %i %i %i %c", &clk, &invert, &maxErr, &maxLen, &amp);
if (!maxLen) maxLen = 512*64;
if (invert != 0 && invert != 1) { if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
@ -274,12 +286,14 @@ int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch)
invert=1; invert=1;
clk=0; clk=0;
} }
if (amp == 'a' || amp == 'A') askAmp=1;
size_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
if (!BitLen) return 0; if (BitLen<255) return 0;
if (maxLen<BitLen && maxLen != 0) BitLen = maxLen; if (maxLen<BitLen && maxLen != 0) BitLen = maxLen;
int errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);
if (errCnt<0||BitLen<16){ //if fatal error (or -1) int errCnt = askdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp, askType);
if (errCnt<0 || BitLen<16){ //if fatal error (or -1)
if (g_debugMode) PrintAndLog("DEBUG: no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); if (g_debugMode) PrintAndLog("DEBUG: no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0; return 0;
} }
@ -290,45 +304,37 @@ int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch)
if (verbose || g_debugMode) PrintAndLog("\nUsing Clock:%d, Invert:%d, Bits Found:%d",clk,invert,BitLen); if (verbose || g_debugMode) PrintAndLog("\nUsing Clock:%d, Invert:%d, Bits Found:%d",clk,invert,BitLen);
//output //output
if (errCnt>0){
if (verbose || g_debugMode) PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d",errCnt);
}
if (verbose || g_debugMode) PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
setDemodBuf(BitStream,BitLen,0); setDemodBuf(BitStream,BitLen,0);
if (verbose || g_debugMode) printDemodBuff(); if (verbose || g_debugMode){
uint64_t lo =0; if (errCnt>0) PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d",errCnt);
uint32_t hi =0; if (askType) PrintAndLog("ASK/Manchester decoded bitstream:");
size_t idx=0; else PrintAndLog("ASK/Raw decoded bitstream:");
if (emSearch){ // Now output the bitstream to the scrollback by line of 16 bits
if (Em410xDecode(BitStream, &BitLen, &idx, &hi, &lo)){
//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(); printDemodBuff();
} }
if (verbose) PrintAndLog("EM410x pattern found: "); uint64_t lo = 0;
if (verbose) printEM410x(hi, lo); uint32_t hi = 0;
return 1; if (emSearch){
} AskEm410xDecode(true, &hi, &lo);
} }
return 1; return 1;
} }
//by marshmellow //by marshmellow
//takes 3 arguments - clock, invert, maxErr as integers //takes 5 arguments - clock, invert, maxErr, maxLen as integers and amplify as char == 'a'
//attempts to demodulate ask while decoding manchester //attempts to demodulate ask while decoding manchester
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int Cmdaskmandemod(const char *Cmd) int Cmdaskmandemod(const char *Cmd)
{ {
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 20 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data rawdemod am [clock] <0|1> [maxError] [setSmplLen]"); PrintAndLog("Usage: data rawdemod am [clock] <invert> [maxError] [maxLen] [amplify]");
PrintAndLog(" [set clock as integer] optional, if not set, autodetect."); PrintAndLog(" [set clock as integer] optional, if not set, autodetect");
PrintAndLog(" <invert>, 1 for invert output"); PrintAndLog(" <invert>, 1 to invert output");
PrintAndLog(" [set maximum allowed errors], default = 100."); PrintAndLog(" [set maximum allowed errors], default = 100");
PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)."); PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data rawdemod am = demod an ask/manchester tag from GraphBuffer"); PrintAndLog(" sample: data rawdemod am = demod an ask/manchester tag from GraphBuffer");
PrintAndLog(" : data rawdemod am 32 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32"); PrintAndLog(" : data rawdemod am 32 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32");
@ -337,7 +343,7 @@ int Cmdaskmandemod(const char *Cmd)
PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
return 0; return 0;
} }
return ASKmanDemod(Cmd, TRUE, TRUE); return ASKDemod(Cmd, TRUE, TRUE, 1);
} }
//by marshmellow //by marshmellow
@ -348,12 +354,14 @@ int Cmdmandecoderaw(const char *Cmd)
int i =0; int i =0;
int errCnt=0; int errCnt=0;
size_t size=0; size_t size=0;
int invert=0;
size_t maxErr = 20; size_t maxErr = 20;
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 5 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 5 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data manrawdecode [maxErr]"); PrintAndLog("Usage: data manrawdecode [invert] [maxErr]");
PrintAndLog(" Takes 10 and 01 and converts to 0 and 1 respectively"); PrintAndLog(" Takes 10 and 01 and converts to 0 and 1 respectively");
PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)"); PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)");
PrintAndLog(" [invert] invert output");
PrintAndLog(" [maxErr] set number of errors allowed (default = 20)"); PrintAndLog(" [maxErr] set number of errors allowed (default = 20)");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data manrawdecode = decode manchester bitstream from the demodbuffer"); PrintAndLog(" sample: data manrawdecode = decode manchester bitstream from the demodbuffer");
@ -372,9 +380,9 @@ int Cmdmandecoderaw(const char *Cmd)
return 0; return 0;
} }
sscanf(Cmd, "%i", &maxErr); sscanf(Cmd, "%i %i", &invert, &maxErr);
size=i; size=i;
errCnt=manrawdecode(BitStream, &size); errCnt=manrawdecode(BitStream, &size, invert);
if (errCnt>=maxErr){ if (errCnt>=maxErr){
PrintAndLog("Too many errors: %d",errCnt); PrintAndLog("Too many errors: %d",errCnt);
return 0; return 0;
@ -448,59 +456,6 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
return 1; return 1;
} }
//by marshmellow
//takes 4 arguments - clock, invert, maxErr as integers and amplify as char
//attempts to demodulate ask only
//prints binary found and saves in graphbuffer for further commands
int ASKrawDemod(const char *Cmd, bool verbose)
{
int invert=0;
int clk=0;
int maxErr=100;
uint8_t askAmp = 0;
char amp = param_getchar(Cmd, 0);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i %i %c", &clk, &invert, &maxErr, &amp);
if (invert != 0 && invert != 1) {
if (verbose || g_debugMode) PrintAndLog("Invalid argument: %s", Cmd);
return 0;
}
if (clk==1){
invert=1;
clk=0;
}
if (amp == 'a' || amp == 'A') askAmp=1;
size_t BitLen = getFromGraphBuf(BitStream);
if (BitLen==0) return 0;
int errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp);
if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
if (verbose || g_debugMode) PrintAndLog("no data found");
if (g_debugMode) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
return 0;
}
if (errCnt>maxErr) {
if (g_debugMode)
PrintAndLog("Too many errors found, errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
return 0;
}
if (verbose || g_debugMode)
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen);
//move BitStream back to DemodBuffer
setDemodBuf(BitStream,BitLen,0);
//output
if (errCnt>0 && (verbose || g_debugMode)){
PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d", errCnt);
}
if (verbose || g_debugMode){
PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printDemodBuff();
}
return 1;
}
//by marshmellow //by marshmellow
// - ASK Demod then Biphase decode GraphBuffer samples // - ASK Demod then Biphase decode GraphBuffer samples
int ASKbiphaseDemod(const char *Cmd, bool verbose) int ASKbiphaseDemod(const char *Cmd, bool verbose)
@ -509,11 +464,11 @@ int ASKbiphaseDemod(const char *Cmd, bool verbose)
int offset=0, clk=0, invert=0, maxErr=0, ans=0; int offset=0, clk=0, invert=0, maxErr=0, ans=0;
ans = sscanf(Cmd, "%i %i %i %i", &offset, &clk, &invert, &maxErr); ans = sscanf(Cmd, "%i %i %i %i", &offset, &clk, &invert, &maxErr);
if (ans>0) if (ans>0)
ans = ASKrawDemod(Cmd+1, FALSE); ans = ASKDemod(Cmd+1, FALSE, FALSE, 0);
else else
ans = ASKrawDemod(Cmd, FALSE); ans = ASKDemod(Cmd, FALSE, FALSE, 0);
if (!ans) { if (!ans) {
if (g_debugMode || verbose) PrintAndLog("Error AskrawDemod: %d", ans); if (g_debugMode || verbose) PrintAndLog("Error AskDemod: %d", ans);
return 0; return 0;
} }
@ -521,8 +476,7 @@ int ASKbiphaseDemod(const char *Cmd, bool verbose)
size_t size = DemodBufferLen; size_t size = DemodBufferLen;
uint8_t BitStream[MAX_DEMOD_BUF_LEN]; uint8_t BitStream[MAX_DEMOD_BUF_LEN];
memcpy(BitStream, DemodBuffer, DemodBufferLen); memcpy(BitStream, DemodBuffer, DemodBufferLen);
int errCnt = BiphaseRawDecode(BitStream, &size, offset, 0);
int errCnt = BiphaseRawDecode(BitStream, &size, offset, invert);
if (errCnt < 0){ if (errCnt < 0){
if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode: %d", errCnt); if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode: %d", errCnt);
return 0; return 0;
@ -543,12 +497,13 @@ int ASKbiphaseDemod(const char *Cmd, bool verbose)
int Cmdaskbiphdemod(const char *Cmd) int Cmdaskbiphdemod(const char *Cmd)
{ {
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 12 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data rawdemod ab [offset] [clock] <invert> [maxError] <amplify>"); PrintAndLog("Usage: data rawdemod ab [offset] [clock] <invert> [maxError] [maxLen] <amplify>");
PrintAndLog(" [offset], offset to begin biphase, default=0"); PrintAndLog(" [offset], offset to begin biphase, default=0");
PrintAndLog(" [set clock as integer] optional, if not set, autodetect"); PrintAndLog(" [set clock as integer] optional, if not set, autodetect");
PrintAndLog(" <invert>, 1 to invert output"); PrintAndLog(" <invert>, 1 to invert output");
PrintAndLog(" [set maximum allowed errors], default = 100"); PrintAndLog(" [set maximum allowed errors], default = 100");
PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp"); PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog(" NOTE: <invert> can be entered as second or third argument"); PrintAndLog(" NOTE: <invert> can be entered as second or third argument");
PrintAndLog(" NOTE: <amplify> can be entered as first, second or last argument"); PrintAndLog(" NOTE: <amplify> can be entered as first, second or last argument");
@ -557,12 +512,12 @@ int Cmdaskbiphdemod(const char *Cmd)
PrintAndLog(" NOTE: --invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester"); PrintAndLog(" NOTE: --invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data rawdemod ab = demod an ask/biph tag from GraphBuffer"); PrintAndLog(" sample: data rawdemod ab = demod an ask/biph tag from GraphBuffer");
PrintAndLog(" : data rawdemod ab a = demod an ask/biph tag from GraphBuffer, amplified"); PrintAndLog(" : data rawdemod ab 0 a = demod an ask/biph tag from GraphBuffer, amplified");
PrintAndLog(" : data rawdemod ab 1 32 = demod an ask/biph tag from GraphBuffer using an offset of 1 and a clock of RF/32"); PrintAndLog(" : data rawdemod ab 1 32 = demod an ask/biph tag from GraphBuffer using an offset of 1 and a clock of RF/32");
PrintAndLog(" : data rawdemod ab 0 32 1 = demod an ask/biph tag from GraphBuffer using a clock of RF/32 and inverting data"); PrintAndLog(" : data rawdemod ab 0 32 1 = demod an ask/biph tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod ab 0 1 = demod an ask/biph tag from GraphBuffer while inverting data"); PrintAndLog(" : data rawdemod ab 0 1 = demod an ask/biph tag from GraphBuffer while inverting data");
PrintAndLog(" : data rawdemod ab 0 64 1 0 = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod ab 0 64 1 0 = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
PrintAndLog(" : data rawdemod ab 0 64 1 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); PrintAndLog(" : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
return 0; return 0;
} }
return ASKbiphaseDemod(Cmd, TRUE); return ASKbiphaseDemod(Cmd, TRUE);
@ -646,15 +601,16 @@ int CmdG_Prox_II_Demod(const char *Cmd)
return 1; return 1;
} }
//by marshmellow - see ASKrawDemod //by marshmellow - see ASKDemod
int Cmdaskrawdemod(const char *Cmd) int Cmdaskrawdemod(const char *Cmd)
{ {
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 12 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data rawdemod ar [clock] <invert> [maxError] [amplify]"); PrintAndLog("Usage: data rawdemod ar [clock] <invert> [maxError] [maxLen] [amplify]");
PrintAndLog(" [set clock as integer] optional, if not set, autodetect"); PrintAndLog(" [set clock as integer] optional, if not set, autodetect");
PrintAndLog(" <invert>, 1 to invert output"); PrintAndLog(" <invert>, 1 to invert output");
PrintAndLog(" [set maximum allowed errors], default = 100"); PrintAndLog(" [set maximum allowed errors], default = 100");
PrintAndLog(" [set maximum Samples to read], default = 32768 (1024 bits at rf/64)");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp"); PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data rawdemod ar = demod an ask tag from GraphBuffer"); PrintAndLog(" sample: data rawdemod ar = demod an ask tag from GraphBuffer");
@ -663,10 +619,10 @@ int Cmdaskrawdemod(const char *Cmd)
PrintAndLog(" : data rawdemod ar 32 1 = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data"); PrintAndLog(" : data rawdemod ar 32 1 = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod ar 1 = demod an ask tag from GraphBuffer while inverting data"); PrintAndLog(" : data rawdemod ar 1 = demod an ask tag from GraphBuffer while inverting data");
PrintAndLog(" : data rawdemod ar 64 1 0 = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod ar 64 1 0 = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
PrintAndLog(" : data rawdemod ar 64 1 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); PrintAndLog(" : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
return 0; return 0;
} }
return ASKrawDemod(Cmd, TRUE); return ASKDemod(Cmd, TRUE, FALSE, 0);
} }
int AutoCorrelate(int window, bool SaveGrph, bool verbose) int AutoCorrelate(int window, bool SaveGrph, bool verbose)
@ -849,7 +805,6 @@ int CmdAskEdgeDetect(const char *Cmd)
{ {
int thresLen = 25; int thresLen = 25;
sscanf(Cmd, "%i", &thresLen); sscanf(Cmd, "%i", &thresLen);
int shift = 127;
for(int i = 1; i<GraphTraceLen; i++){ for(int i = 1; i<GraphTraceLen; i++){
if (GraphBuffer[i]-GraphBuffer[i-1]>=thresLen) //large jump up if (GraphBuffer[i]-GraphBuffer[i-1]>=thresLen) //large jump up
@ -867,9 +822,10 @@ int CmdAskEdgeDetect(const char *Cmd)
int CmdDetectClockRate(const char *Cmd) int CmdDetectClockRate(const char *Cmd)
{ {
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 3 || strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 6 || strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data detectclock [modulation]"); PrintAndLog("Usage: data detectclock [modulation] <clock>");
PrintAndLog(" [modulation as char], specify the modulation type you want to detect the clock of"); PrintAndLog(" [modulation as char], specify the modulation type you want to detect the clock of");
PrintAndLog(" <clock> , specify the clock (optional - to get best start position only)");
PrintAndLog(" 'a' = ask, 'f' = fsk, 'n' = nrz/direct, 'p' = psk"); PrintAndLog(" 'a' = ask, 'f' = fsk, 'n' = nrz/direct, 'p' = psk");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data detectclock a = detect the clock of an ask modulated wave in the GraphBuffer"); PrintAndLog(" sample: data detectclock a = detect the clock of an ask modulated wave in the GraphBuffer");
@ -879,7 +835,7 @@ int CmdDetectClockRate(const char *Cmd)
} }
int ans=0; int ans=0;
if (cmdp == 'a'){ if (cmdp == 'a'){
ans = GetAskClock("", true, false); ans = GetAskClock(Cmd+1, true, false);
} else if (cmdp == 'f'){ } else if (cmdp == 'f'){
ans = GetFskClock("", true, false); ans = GetFskClock("", true, false);
} else if (cmdp == 'n'){ } else if (cmdp == 'n'){
@ -2166,7 +2122,7 @@ static command_t CommandTable[] =
{"askem410xdemod", CmdAskEM410xDemod, 1, "[clock] [invert<0|1>] [maxErr] -- Demodulate an EM410x tag from GraphBuffer (args optional)"}, {"askem410xdemod", CmdAskEM410xDemod, 1, "[clock] [invert<0|1>] [maxErr] -- Demodulate an EM410x tag from GraphBuffer (args optional)"},
{"askgproxiidemod", CmdG_Prox_II_Demod, 1, "Demodulate a G Prox II tag from GraphBuffer"}, {"askgproxiidemod", CmdG_Prox_II_Demod, 1, "Demodulate a G Prox II tag from GraphBuffer"},
{"autocorr", CmdAutoCorr, 1, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"}, {"autocorr", CmdAutoCorr, 1, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"},
{"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] [invert<0|1>] [maxErr] -- Biphase decode bin stream in DemodBuffer (offset = 0|1 bits to shift the decode start)"}, {"biphaserawdecode",CmdBiphaseDecodeRaw,1, "[offset] [invert<0|1>] [maxErr] -- Biphase decode bin stream in DemodBuffer (offset = 0|1 bits to shift the decode start)"},
{"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
{"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"}, {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
{"dec", CmdDec, 1, "Decimate samples"}, {"dec", CmdDec, 1, "Decimate samples"},
@ -2185,7 +2141,7 @@ static command_t CommandTable[] =
{"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"}, {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
{"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"}, {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},
{"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"}, {"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"},
{"manrawdecode", Cmdmandecoderaw, 1, "[maxErr] -- Manchester decode binary stream in DemodBuffer"}, {"manrawdecode", Cmdmandecoderaw, 1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"},
{"norm", CmdNorm, 1, "Normalize max/min to +/-128"}, {"norm", CmdNorm, 1, "Normalize max/min to +/-128"},
{"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"},
{"printdemodbuffer",CmdPrintDemodBuff, 1, "[x] -- print the data in the DemodBuffer - 'x' for hex output"}, {"printdemodbuffer",CmdPrintDemodBuff, 1, "[x] -- print the data in the DemodBuffer - 'x' for hex output"},

6
client/cmddata.h
View file

@ -56,10 +56,10 @@ int CmdScale(const char *Cmd);
int CmdDirectionalThreshold(const char *Cmd); int CmdDirectionalThreshold(const char *Cmd);
int CmdZerocrossings(const char *Cmd); int CmdZerocrossings(const char *Cmd);
int CmdIndalaDecode(const char *Cmd); int CmdIndalaDecode(const char *Cmd);
int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo); int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo );
int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose);
int ASKbiphaseDemod(const char *Cmd, bool verbose); int ASKbiphaseDemod(const char *Cmd, bool verbose);
int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch); int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType);
int ASKrawDemod(const char *Cmd, bool verbose);
int FSKrawDemod(const char *Cmd, bool verbose); int FSKrawDemod(const char *Cmd, bool verbose);
int PSKDemod(const char *Cmd, bool verbose); int PSKDemod(const char *Cmd, bool verbose);
int NRZrawDemod(const char *Cmd, bool verbose); int NRZrawDemod(const char *Cmd, bool verbose);

2
client/cmdlf.c
View file

@ -1091,7 +1091,7 @@ int CmdLFfind(const char *Cmd)
return 1; return 1;
} }
} }
ans=ASKmanDemod("0 0 0",TRUE,FALSE); ans=ASKDemod("0 0 0",TRUE,FALSE,1);
if (ans>0) { if (ans>0) {
PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!"); PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'"); PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'");

4
client/cmdlfem4x.c
View file

@ -47,7 +47,7 @@ int CmdEM410xRead(const char *Cmd)
uint32_t hi=0; uint32_t hi=0;
uint64_t lo=0; uint64_t lo=0;
if(!AskEm410xDemod("", &hi, &lo)) return 0; if(!AskEm410xDemod("", &hi, &lo, false)) return 0;
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
printEM410x(hi, lo); printEM410x(hi, lo);
if (hi){ if (hi){
@ -455,7 +455,7 @@ int EM4x50Read(const char *Cmd, bool verbose)
else else
phaseoff = 0; phaseoff = 0;
i += 2; i += 2;
if (ASKmanDemod(tmp2, false, false) < 1) { if (ASKDemod(tmp2, false, false, 1) < 1) {
save_restoreGB(0); save_restoreGB(0);
return 0; return 0;
} }

78
client/cmdlft55xx.c
View file

@ -262,11 +262,10 @@ int CmdT55xxReadBlock(const char *Cmd) {
bool DecodeT55xxBlock(){ bool DecodeT55xxBlock(){
char buf[10] = {0x00}; char buf[30] = {0x00};
char *cmdStr = buf; char *cmdStr = buf;
int ans = 0; int ans = 0;
uint8_t bitRate[8] = {8,16,32,40,50,64,100,128}; uint8_t bitRate[8] = {8,16,32,40,50,64,100,128};
DemodBufferLen = 0x00; DemodBufferLen = 0x00;
//trim 1/2 a clock from beginning //trim 1/2 a clock from beginning
@ -290,7 +289,7 @@ bool DecodeT55xxBlock(){
break; break;
case DEMOD_ASK: case DEMOD_ASK:
snprintf(cmdStr, sizeof(buf),"%d %d 0", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 0", bitRate[config.bitrate], config.inverted );
ans = ASKmanDemod(cmdStr, FALSE, FALSE); ans = ASKDemod(cmdStr, FALSE, FALSE, 1);
break; break;
case DEMOD_PSK1: case DEMOD_PSK1:
snprintf(cmdStr, sizeof(buf),"%d %d 0", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 0", bitRate[config.bitrate], config.inverted );
@ -337,72 +336,79 @@ bool tryDetectModulation(){
char cmdStr[8] = {0}; char cmdStr[8] = {0};
uint8_t hits = 0; uint8_t hits = 0;
t55xx_conf_block_t tests[15]; t55xx_conf_block_t tests[15];
int bitRate=0;
if (GetFskClock("", FALSE, FALSE)){ if (GetFskClock("", FALSE, FALSE)){
uint8_t fc1 = 0, fc2 = 0, clk=0; uint8_t fc1 = 0, fc2 = 0, clk=0;
fskClocks(&fc1, &fc2, &clk, FALSE); fskClocks(&fc1, &fc2, &clk, FALSE);
sprintf(cmdStr,"%d", clk/2); sprintf(cmdStr,"%d", clk/2);
CmdLtrim(cmdStr); CmdLtrim(cmdStr);
if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset)){ if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate)){
tests[hits].modulation = DEMOD_FSK; tests[hits].modulation = DEMOD_FSK;
if (fc1==8 && fc2 == 5) if (fc1==8 && fc2 == 5)
tests[hits].modulation = DEMOD_FSK1a; tests[hits].modulation = DEMOD_FSK1a;
else if (fc1==10 && fc2 == 8) else if (fc1==10 && fc2 == 8)
tests[hits].modulation = DEMOD_FSK2; tests[hits].modulation = DEMOD_FSK2;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( FSKrawDemod("0 1", FALSE) && test(DEMOD_FSK, &tests[hits].offset)) { if ( FSKrawDemod("0 1", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_FSK; tests[hits].modulation = DEMOD_FSK;
if (fc1==8 && fc2 == 5) if (fc1 == 8 && fc2 == 5)
tests[hits].modulation = DEMOD_FSK1; tests[hits].modulation = DEMOD_FSK1;
else if (fc1==10 && fc2 == 8) else if (fc1 == 10 && fc2 == 8)
tests[hits].modulation = DEMOD_FSK2a; tests[hits].modulation = DEMOD_FSK2a;
tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
} else { } else {
if ( ASKmanDemod("0 0 1", FALSE, FALSE) && test(DEMOD_ASK, &tests[hits].offset)) { if ( ASKDemod("0 0 1", FALSE, FALSE, 1) && test(DEMOD_ASK, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_ASK; tests[hits].modulation = DEMOD_ASK;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( ASKmanDemod("0 1 1", FALSE, FALSE) && test(DEMOD_ASK, &tests[hits].offset)) { if ( ASKDemod("0 1 1", FALSE, FALSE, 1) && test(DEMOD_ASK, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_ASK; tests[hits].modulation = DEMOD_ASK;
tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( NRZrawDemod("0 0 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset)) { if ( NRZrawDemod("0 0 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_NRZ; tests[hits].modulation = DEMOD_NRZ;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( NRZrawDemod("0 1 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset)) { if ( NRZrawDemod("0 1 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_NRZ; tests[hits].modulation = DEMOD_NRZ;
tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( PSKDemod("0 0 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset)) { if ( PSKDemod("0 0 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_PSK1; tests[hits].modulation = DEMOD_PSK1;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( PSKDemod("0 1 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset)) { if ( PSKDemod("0 1 1", FALSE) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate)) {
tests[hits].modulation = DEMOD_PSK1; tests[hits].modulation = DEMOD_PSK1;
tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
@ -411,8 +417,9 @@ bool tryDetectModulation(){
// PSK2 - needs a call to psk1TOpsk2. // PSK2 - needs a call to psk1TOpsk2.
if ( PSKDemod("0 0 1", FALSE)) { if ( PSKDemod("0 0 1", FALSE)) {
psk1TOpsk2(DemodBuffer, DemodBufferLen); psk1TOpsk2(DemodBuffer, DemodBufferLen);
if (test(DEMOD_PSK2, &tests[hits].offset)){ if (test(DEMOD_PSK2, &tests[hits].offset, &bitRate)){
tests[hits].modulation = DEMOD_PSK2; tests[hits].modulation = DEMOD_PSK2;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
@ -422,22 +429,25 @@ bool tryDetectModulation(){
// PSK3 - needs a call to psk1TOpsk2. // PSK3 - needs a call to psk1TOpsk2.
if ( PSKDemod("0 0 1", FALSE)) { if ( PSKDemod("0 0 1", FALSE)) {
psk1TOpsk2(DemodBuffer, DemodBufferLen); psk1TOpsk2(DemodBuffer, DemodBufferLen);
if (test(DEMOD_PSK3, &tests[hits].offset)){ if (test(DEMOD_PSK3, &tests[hits].offset, &bitRate)){
tests[hits].modulation = DEMOD_PSK3; tests[hits].modulation = DEMOD_PSK3;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
} // inverse waves does not affect this demod } // inverse waves does not affect this demod
if ( ASKbiphaseDemod("0 0 0 1", FALSE) && test(DEMOD_BI, &tests[hits].offset) ) { if ( ASKbiphaseDemod("0 0 0 1", FALSE) && test(DEMOD_BI, &tests[hits].offset, &bitRate) ) {
tests[hits].modulation = DEMOD_BI; tests[hits].modulation = DEMOD_BI;
tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = FALSE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( ASKbiphaseDemod("0 0 1 1", FALSE) && test(DEMOD_BIa, &tests[hits].offset) ) { if ( ASKbiphaseDemod("0 0 1 1", FALSE) && test(DEMOD_BIa, &tests[hits].offset, &bitRate) ) {
tests[hits].modulation = DEMOD_BIa; tests[hits].modulation = DEMOD_BIa;
tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = TRUE;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
@ -445,6 +455,7 @@ bool tryDetectModulation(){
} }
if ( hits == 1) { if ( hits == 1) {
config.modulation = tests[0].modulation; config.modulation = tests[0].modulation;
config.bitrate = tests[0].bitrate;
config.inverted = tests[0].inverted; config.inverted = tests[0].inverted;
config.offset = tests[0].offset; config.offset = tests[0].offset;
config.block0 = tests[0].block0; config.block0 = tests[0].block0;
@ -504,35 +515,27 @@ bool testBitRate(uint8_t readRate, uint8_t mod){
case DEMOD_FSK2: case DEMOD_FSK2:
case DEMOD_FSK2a: case DEMOD_FSK2a:
detRate = GetFskClock("",FALSE, FALSE); detRate = GetFskClock("",FALSE, FALSE);
if (expected[readRate] == detRate) { if (expected[readRate] == detRate)
config.bitrate = readRate;
return TRUE; return TRUE;
}
break; break;
case DEMOD_ASK: case DEMOD_ASK:
case DEMOD_BI: case DEMOD_BI:
case DEMOD_BIa: case DEMOD_BIa:
detRate = GetAskClock("",FALSE, FALSE); detRate = GetAskClock("",FALSE, FALSE);
if (expected[readRate] == detRate) { if (expected[readRate] == detRate)
config.bitrate = readRate;
return TRUE; return TRUE;
}
break; break;
case DEMOD_PSK1: case DEMOD_PSK1:
case DEMOD_PSK2: case DEMOD_PSK2:
case DEMOD_PSK3: case DEMOD_PSK3:
detRate = GetPskClock("",FALSE, FALSE); detRate = GetPskClock("",FALSE, FALSE);
if (expected[readRate] == detRate) { if (expected[readRate] == detRate)
config.bitrate = readRate;
return TRUE; return TRUE;
}
break; break;
case DEMOD_NRZ: case DEMOD_NRZ:
detRate = GetNrzClock("",FALSE, FALSE); detRate = GetNrzClock("",FALSE, FALSE);
if (expected[readRate] == detRate) { if (expected[readRate] == detRate)
config.bitrate = readRate;
return TRUE; return TRUE;
}
break; break;
default: default:
return FALSE; return FALSE;
@ -540,9 +543,9 @@ bool testBitRate(uint8_t readRate, uint8_t mod){
return FALSE; return FALSE;
} }
bool test(uint8_t mode, uint8_t *offset){ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate){
if ( !DemodBufferLen) return FALSE; if ( DemodBufferLen < 64 ) return FALSE;
uint8_t si = 0; uint8_t si = 0;
for (uint8_t idx = 0; idx < 64; idx++){ for (uint8_t idx = 0; idx < 64; idx++){
si = idx; si = idx;
@ -555,7 +558,8 @@ bool test(uint8_t mode, uint8_t *offset){
if ( resv > 0x00) continue; if ( resv > 0x00) continue;
uint8_t xtRate = PackBits(si, 3, DemodBuffer); si += 3; //extended mode part of rate uint8_t xtRate = PackBits(si, 3, DemodBuffer); si += 3; //extended mode part of rate
uint8_t bitRate = PackBits(si, 3, DemodBuffer); si += 3; //bit rate int bitRate = PackBits(si, 3, DemodBuffer); si += 3; //bit rate
if (bitRate > 7) continue;
uint8_t extend = PackBits(si, 1, DemodBuffer); si += 1; //bit 15 extended mode uint8_t extend = PackBits(si, 1, DemodBuffer); si += 1; //bit 15 extended mode
uint8_t modread = PackBits(si, 5, DemodBuffer); si += 5+2+1; uint8_t modread = PackBits(si, 5, DemodBuffer); si += 5+2+1;
//uint8_t pskcr = PackBits(si, 2, DemodBuffer); si += 2+1; //could check psk cr //uint8_t pskcr = PackBits(si, 2, DemodBuffer); si += 2+1; //could check psk cr
@ -571,6 +575,7 @@ bool test(uint8_t mode, uint8_t *offset){
//test modulation //test modulation
if (!testModulation(mode, modread)) continue; if (!testModulation(mode, modread)) continue;
if (!testBitRate(bitRate, mode)) continue; if (!testBitRate(bitRate, mode)) continue;
*fndBitRate = bitRate;
*offset = idx; *offset = idx;
return TRUE; return TRUE;
} }
@ -763,7 +768,7 @@ int CmdT55xxInfo(const char *Cmd){
if (!DecodeT55xxBlock()) return 1; if (!DecodeT55xxBlock()) return 1;
if ( !DemodBufferLen) return 1; if ( DemodBufferLen < 32) return 1;
uint8_t si = config.offset; uint8_t si = config.offset;
uint32_t bl0 = PackBits(si, 32, DemodBuffer); uint32_t bl0 = PackBits(si, 32, DemodBuffer);
@ -873,7 +878,8 @@ int AquireData( uint8_t block ){
} }
char * GetBitRateStr(uint32_t id){ char * GetBitRateStr(uint32_t id){
static char buf[20]; static char buf[25];
char *retStr = buf; char *retStr = buf;
switch (id){ switch (id){
case 0: case 0:

4
client/graph.c
View file

@ -143,10 +143,10 @@ int GetAskClock(const char str[], bool printAns, bool verbose)
PrintAndLog("Failed to copy from graphbuffer"); PrintAndLog("Failed to copy from graphbuffer");
return -1; return -1;
} }
DetectASKClock(grph, size, &clock, 20); int start = DetectASKClock(grph, size, &clock, 20);
// Only print this message if we're not looping something // Only print this message if we're not looping something
if (printAns){ if (printAns){
PrintAndLog("Auto-detected clock rate: %d", clock); PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start);
} }
return clock; return clock;
} }

244
common/lfdemod.c
View file

@ -112,7 +112,8 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
return 0; return 0;
} }
// demodulates strong heavily clipped samples //by marshmellow
//demodulates strong heavily clipped samples
int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low) int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low)
{ {
size_t bitCnt=0, smplCnt=0, errCnt=0; size_t bitCnt=0, smplCnt=0, errCnt=0;
@ -163,52 +164,81 @@ int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int
} }
//by marshmellow //by marshmellow
//takes 3 arguments - clock, invert, maxErr as integers void askAmp(uint8_t *BitStream, size_t size)
//attempts to demodulate ask while decoding manchester
//prints binary found and saves in graphbuffer for further commands
int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr)
{ {
size_t i; for(size_t i = 1; i<size; i++){
if (BitStream[i]-BitStream[i-1]>=30) //large jump up
BitStream[i]=127;
else if(BitStream[i]-BitStream[i-1]<=-20) //large jump down
BitStream[i]=-127;
}
return;
}
//by marshmellow
//attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester
int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType)
{
if (*size==0) return -1;
int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default
if (*clk==0 || start < 0) return -3; if (*clk==0 || start < 0) return -3;
if (*invert != 1) *invert=0; if (*invert != 1) *invert = 0;
if (amp==1) askAmp(BinStream, *size);
uint8_t initLoopMax = 255; uint8_t initLoopMax = 255;
if (initLoopMax > *size) initLoopMax = *size; if (initLoopMax > *size) initLoopMax = *size;
// Detect high and lows // Detect high and lows
// 25% fuzz in case highs and lows aren't clipped [marshmellow] //25% clip in case highs and lows aren't clipped [marshmellow]
int high, low; int high, low;
if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1) return -2; //just noise if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1)
return -2; //just noise
size_t errCnt = 0;
// if clean clipped waves detected run alternate demod // if clean clipped waves detected run alternate demod
if (DetectCleanAskWave(BinStream, *size, high, low)) { if (DetectCleanAskWave(BinStream, *size, high, low)) {
cleanAskRawDemod(BinStream, size, *clk, *invert, high, low); errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
return manrawdecode(BinStream, size); if (askType) //askman
return manrawdecode(BinStream, size, 0);
else //askraw
return errCnt;
} }
// PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low); int lastBit; //set first clock check - can go negative
int lastBit; //set first clock check size_t i, bitnum = 0; //output counter
uint16_t bitnum = 0; //output counter uint8_t midBit = 0;
uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
if (*clk <= 32) tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely 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
uint16_t errCnt = 0, MaxBits = 512; size_t MaxBits = 1024;
lastBit = start - *clk; lastBit = start - *clk;
for (i = start; i < *size; ++i) { for (i = start; i < *size; ++i) {
if ((BinStream[i] >= high) && ((i-lastBit) > (*clk-tol))){ if (i-lastBit >= *clk-tol){
//high found and we are expecting a bar if (BinStream[i] >= high) {
lastBit += *clk;
BinStream[bitnum++] = *invert; BinStream[bitnum++] = *invert;
} else if ((BinStream[i] <= low) && ((i-lastBit) > (*clk-tol))){ } else if (BinStream[i] <= low) {
//low found and we are expecting a bar
lastBit += *clk;
BinStream[bitnum++] = *invert ^ 1; BinStream[bitnum++] = *invert ^ 1;
} else if ((i-lastBit)>(*clk+tol)){ } else if (i-lastBit >= *clk+tol) {
//should have hit a high or low based on clock!!
//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) { if (bitnum > 0) {
BinStream[bitnum++] = 7; BinStream[bitnum++]=7;
errCnt++; errCnt++;
} }
lastBit += *clk;//skip over error } else { //in tolerance - looking for peak
continue;
}
midBit = 0;
lastBit += *clk;
} else if (i-lastBit >= (*clk/2-tol) && !midBit && !askType){
if (BinStream[i] >= high) {
BinStream[bitnum++] = *invert;
} else if (BinStream[i] <= low) {
BinStream[bitnum++] = *invert ^ 1;
} else if (i-lastBit >= *clk/2+tol) {
BinStream[bitnum] = BinStream[bitnum-1];
bitnum++;
} else { //in tolerance - looking for peak
continue;
}
midBit = 1;
} }
if (bitnum >= MaxBits) break; if (bitnum >= MaxBits) break;
} }
@ -216,6 +246,42 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int max
return errCnt; return errCnt;
} }
//by marshmellow
//take 10 and 01 and manchester decode
//run through 2 times and take least errCnt
int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert)
{
uint16_t bitnum=0, MaxBits = 512, errCnt = 0;
size_t i, ii;
uint16_t bestErr = 1000, bestRun = 0;
if (*size < 16) return -1;
//find correct start position [alignment]
for (ii=0;ii<2;++ii){
for (i=ii; i<*size-3; i+=2)
if (BitStream[i]==BitStream[i+1])
errCnt++;
if (bestErr>errCnt){
bestErr=errCnt;
bestRun=ii;
}
errCnt=0;
}
//decode
for (i=bestRun; i < *size-3; i+=2){
if(BitStream[i] == 1 && (BitStream[i+1] == 0)){
BitStream[bitnum++]=invert;
} else if((BitStream[i] == 0) && BitStream[i+1] == 1){
BitStream[bitnum++]=invert^1;
} else {
BitStream[bitnum++]=7;
}
if(bitnum>MaxBits) break;
}
*size=bitnum;
return bestErr;
}
//by marshmellow //by marshmellow
//encode binary data into binary manchester //encode binary data into binary manchester
int ManchesterEncode(uint8_t *BitStream, size_t size) int ManchesterEncode(uint8_t *BitStream, size_t size)
@ -232,42 +298,6 @@ int ManchesterEncode(uint8_t *BitStream, size_t size)
return i; return i;
} }
//by marshmellow
//take 10 and 01 and manchester decode
//run through 2 times and take least errCnt
int manrawdecode(uint8_t * BitStream, size_t *size)
{
uint16_t bitnum=0, MaxBits = 512, errCnt = 0;
size_t i, ii;
uint16_t bestErr = 1000, bestRun = 0;
if (size == 0) return -1;
//find correct start position [alignment]
for (ii=0;ii<2;++ii){
for (i=ii; i<*size-2; i+=2)
if (BitStream[i]==BitStream[i+1])
errCnt++;
if (bestErr>errCnt){
bestErr=errCnt;
bestRun=ii;
}
errCnt=0;
}
//decode
for (i=bestRun; i < *size-2; i+=2){
if(BitStream[i] == 1 && (BitStream[i+1] == 0)){
BitStream[bitnum++]=0;
} else if((BitStream[i] == 0) && BitStream[i+1] == 1){
BitStream[bitnum++]=1;
} else {
BitStream[bitnum++]=7;
}
if(bitnum>MaxBits) break;
}
*size=bitnum;
return bestErr;
}
//by marshmellow //by marshmellow
//take 01 or 10 = 1 and 11 or 00 = 0 //take 01 or 10 = 1 and 11 or 00 = 0
//check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010 //check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010
@ -307,88 +337,7 @@ int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
return errCnt; return errCnt;
} }
//by marshmellow // by marshmellow
void askAmp(uint8_t *BitStream, size_t size)
{
int shift = 127;
int shiftedVal=0;
for(size_t i = 1; i<size; i++){
if (BitStream[i]-BitStream[i-1]>=30) //large jump up
shift=127;
else if(BitStream[i]-BitStream[i-1]<=-20) //large jump down
shift=-127;
shiftedVal=BitStream[i]+shift;
if (shiftedVal>255)
shiftedVal=255;
else if (shiftedVal<0)
shiftedVal=0;
BitStream[i-1] = shiftedVal;
}
return;
}
//by marshmellow
//takes 3 arguments - clock, invert and maxErr as integers
//attempts to demodulate ask only
int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp)
{
if (*size==0) return -1;
int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default
if (*clk==0 || start < 0) return -1;
if (*invert != 1) *invert = 0;
if (amp==1) askAmp(BinStream, *size);
uint8_t initLoopMax = 255;
if (initLoopMax > *size) initLoopMax = *size;
// Detect high and lows
//25% clip in case highs and lows aren't clipped [marshmellow]
int high, low;
if (getHiLo(BinStream, initLoopMax, &high, &low, 75, 75) < 1)
return -1; //just noise
// if clean clipped waves detected run alternate demod
if (DetectCleanAskWave(BinStream, *size, high, low))
return cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
int lastBit; //set first clock check - can go negative
size_t i, errCnt = 0, bitnum = 0; //output counter
uint8_t midBit = 0;
size_t MaxBits = 1024;
lastBit = start - *clk;
for (i = start; i < *size; ++i) {
if (i - lastBit == *clk){
if (BinStream[i] >= high) {
BinStream[bitnum++] = *invert;
} else if (BinStream[i] <= low) {
BinStream[bitnum++] = *invert ^ 1;
} else {
if (bitnum > 0) {
BinStream[bitnum++]=7;
errCnt++;
}
}
midBit = 0;
lastBit += *clk;
} else if (i-lastBit == (*clk/2) && midBit == 0){
if (BinStream[i] >= high) {
BinStream[bitnum++] = *invert;
} else if (BinStream[i] <= low) {
BinStream[bitnum++] = *invert ^ 1;
} else {
BinStream[bitnum] = BinStream[bitnum-1];
bitnum++;
}
midBit = 1;
}
if (bitnum >= MaxBits) break;
}
*size = bitnum;
return errCnt;
}
// demod gProxIIDemod // demod gProxIIDemod
// error returns as -x // error returns as -x
// success returns start position in BitStream // success returns start position in BitStream
@ -684,7 +633,8 @@ int PyramiddemodFSK(uint8_t *dest, size_t *size)
return (int)startIdx; return (int)startIdx;
} }
// by marshmellow
// to detect a wave that has heavily clipped (clean) samples
uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low) uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
{ {
uint16_t allPeaks=1; uint16_t allPeaks=1;
@ -792,7 +742,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(; clkCnt < clkEnd; clkCnt++){ for(; clkCnt < clkEnd; clkCnt++){
if (clk[clkCnt] == 32){ if (clk[clkCnt] <= 32){
tol=1; tol=1;
}else{ }else{
tol=0; tol=0;

40
common/lfdemod.h
View file

@ -15,35 +15,37 @@
#define LFDEMOD_H__ #define LFDEMOD_H__
#include <stdint.h> #include <stdint.h>
//generic
int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType);
int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj);
int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr); int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr);
uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low); uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t low);
uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow);
int DetectNRZClock(uint8_t dest[], size_t size, int clock);
int DetectPSKClock(uint8_t dest[], size_t size, int clock);
int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low); int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low);
int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr);
uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo); uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo);
int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow);
int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo);
int ManchesterEncode(uint8_t *BitStream, size_t size); int ManchesterEncode(uint8_t *BitStream, size_t size);
int manrawdecode(uint8_t *BitStream, size_t *size); int manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert);
int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert); int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr);
int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp); uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType);
uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx);
int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert);
void psk2TOpsk1(uint8_t *BitStream, size_t size);
void psk1TOpsk2(uint8_t *BitStream, size_t size);
size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen);
//tag specific
int AWIDdemodFSK(uint8_t *dest, size_t *size);
int gProxII_Demod(uint8_t BitStream[], size_t *size); int gProxII_Demod(uint8_t BitStream[], size_t *size);
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 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);
int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr);
void psk1TOpsk2(uint8_t *BitStream, size_t size);
void psk2TOpsk1(uint8_t *BitStream, size_t size);
int DetectNRZClock(uint8_t dest[], size_t size, int clock);
int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert); int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert);
int PyramiddemodFSK(uint8_t *dest, 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);
uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj);
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);
int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx);
uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType);
int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert);
int DetectPSKClock(uint8_t dest[], size_t size, int clock);
#endif #endif