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

Merge branch 'master' of https://github.com/iceman1001/ForPm3

Browse source
This commit is contained in:
Martin Holst Swende 2015-01-09 21:50:36 +01:00
parent 31d1caa526 952a8bb59b
commit f44a01235c
11 changed files with 17346 additions and 848 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
armsrc/lfops.c
View file

@ -18,8 +18,8 @@
/** /**
* Does the sample acquisition. If threshold is specified, the actual sampling * Does the sample acquisition. If threshold is specified, the actual sampling
* is not commenced until the threshold has been reached. * is not commenced until the threshold has been reached.
* @param trigger_threshold - the threshold * @param trigger_threshold - the threshold
* @param silent - is true, now outputs are made. If false, dbprints the status * @param silent - is true, now outputs are made. If false, dbprints the status
*/ */
@ -54,7 +54,7 @@ void DoAcquisition125k_internal(int trigger_threshold,bool silent)
} }
} }
/** /**
* Perform sample aquisition. * Perform sample aquisition.
*/ */
void DoAcquisition125k(int trigger_threshold) void DoAcquisition125k(int trigger_threshold)
{ {
@ -62,11 +62,11 @@ void DoAcquisition125k(int trigger_threshold)
} }
/** /**
* Setup the FPGA to listen for samples. This method downloads the FPGA bitstream * Setup the FPGA to listen for samples. This method downloads the FPGA bitstream
* if not already loaded, sets divisor and starts up the antenna. * if not already loaded, sets divisor and starts up the antenna.
* @param divisor : 1, 88> 255 or negative ==> 134.8 KHz * @param divisor : 1, 88> 255 or negative ==> 134.8 KHz
* 0 or 95 ==> 125 KHz * 0 or 95 ==> 125 KHz
* *
**/ **/
void LFSetupFPGAForADC(int divisor, bool lf_field) void LFSetupFPGAForADC(int divisor, bool lf_field)
{ {
@ -88,7 +88,7 @@ void LFSetupFPGAForADC(int divisor, bool lf_field)
FpgaSetupSsc(); FpgaSetupSsc();
} }
/** /**
* Initializes the FPGA, and acquires the samples. * Initializes the FPGA, and acquires the samples.
**/ **/
void AcquireRawAdcSamples125k(int divisor) void AcquireRawAdcSamples125k(int divisor)
{ {
@ -97,7 +97,7 @@ void AcquireRawAdcSamples125k(int divisor)
DoAcquisition125k_internal(-1,false); DoAcquisition125k_internal(-1,false);
} }
/** /**
* Initializes the FPGA for snoop-mode, and acquires the samples. * Initializes the FPGA for snoop-mode, and acquires the samples.
**/ **/
void SnoopLFRawAdcSamples(int divisor, int trigger_threshold) void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
@ -173,13 +173,12 @@ void ReadTItag(void)
// when we read a TI tag we sample the zerocross line at 2Mhz // when we read a TI tag we sample the zerocross line at 2Mhz
// TI tags modulate a 1 as 16 cycles of 123.2Khz // TI tags modulate a 1 as 16 cycles of 123.2Khz
// TI tags modulate a 0 as 16 cycles of 134.2Khz // TI tags modulate a 0 as 16 cycles of 134.2Khz
#define FSAMPLE 2000000 #define FSAMPLE 2000000
#define FREQLO 123200 #define FREQLO 123200
#define FREQHI 134200 #define FREQHI 134200
signed char *dest = (signed char *)BigBuf; signed char *dest = (signed char *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
// 128 bit shift register [shift3:shift2:shift1:shift0] // 128 bit shift register [shift3:shift2:shift1:shift0]
uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0; uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
@ -261,10 +260,10 @@ void ReadTItag(void)
shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff; shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;
// if r/w tag, check ident match // if r/w tag, check ident match
if ( shift3&(1<<15) ) { if (shift3 & (1<<15) ) {
DbpString("Info: TI tag is rewriteable"); DbpString("Info: TI tag is rewriteable");
// only 15 bits compare, last bit of ident is not valid // only 15 bits compare, last bit of ident is not valid
if ( ((shift3>>16)^shift0)&0x7fff ) { if (((shift3 >> 16) ^ shift0) & 0x7fff ) {
DbpString("Error: Ident mismatch!"); DbpString("Error: Ident mismatch!");
} else { } else {
DbpString("Info: TI tag ident is valid"); DbpString("Info: TI tag ident is valid");
@ -328,7 +327,7 @@ void AcquireTiType(void)
int i, j, n; int i, j, n;
// tag transmission is <20ms, sampling at 2M gives us 40K samples max // tag transmission is <20ms, sampling at 2M gives us 40K samples max
// each sample is 1 bit stuffed into a uint32_t so we need 1250 uint32_t // each sample is 1 bit stuffed into a uint32_t so we need 1250 uint32_t
#define TIBUFLEN 1250 #define TIBUFLEN 1250
// clear buffer // clear buffer
memset(BigBuf,0,sizeof(BigBuf)); memset(BigBuf,0,sizeof(BigBuf));
@ -469,18 +468,18 @@ void SimulateTagLowFrequency(int period, int gap, int ledcontrol)
{ {
int i; int i;
uint8_t *tab = (uint8_t *)BigBuf; uint8_t *tab = (uint8_t *)BigBuf;
FpgaDownloadAndGo(FPGA_BITSTREAM_LF); FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT);
AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT | GPIO_SSC_CLK; AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT | GPIO_SSC_CLK;
AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT; AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_CLK; AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_CLK;
#define SHORT_COIL() LOW(GPIO_SSC_DOUT) #define SHORT_COIL() LOW(GPIO_SSC_DOUT)
#define OPEN_COIL() HIGH(GPIO_SSC_DOUT) #define OPEN_COIL() HIGH(GPIO_SSC_DOUT)
i = 0; i = 0;
for(;;) { for(;;) {
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)) { while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK)) {
@ -490,18 +489,18 @@ void SimulateTagLowFrequency(int period, int gap, int ledcontrol)
} }
WDT_HIT(); WDT_HIT();
} }
if (ledcontrol) if (ledcontrol)
LED_D_ON(); LED_D_ON();
if(tab[i]) if(tab[i])
OPEN_COIL(); OPEN_COIL();
else else
SHORT_COIL(); SHORT_COIL();
if (ledcontrol) if (ledcontrol)
LED_D_OFF(); LED_D_OFF();
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK) { while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_CLK) {
if(BUTTON_PRESS()) { if(BUTTON_PRESS()) {
DbpString("Stopped"); DbpString("Stopped");
@ -509,7 +508,7 @@ void SimulateTagLowFrequency(int period, int gap, int ledcontrol)
} }
WDT_HIT(); WDT_HIT();
} }
i++; i++;
if(i == period) { if(i == period) {
i = 0; i = 0;
@ -623,7 +622,6 @@ void CmdHIDsimTAG(int hi, int lo, int ledcontrol)
if (ledcontrol) if (ledcontrol)
LED_A_ON(); LED_A_ON();
SimulateTagLowFrequency(n, 0, ledcontrol); SimulateTagLowFrequency(n, 0, ledcontrol);
if (ledcontrol) if (ledcontrol)
@ -663,30 +661,30 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
uint8_t bitlen = 0; uint8_t bitlen = 0;
uint32_t fc = 0; uint32_t fc = 0;
uint32_t cardnum = 0; uint32_t cardnum = 0;
if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used if (((hi>>5)&1) == 1){//if bit 38 is set then < 37 bit format is used
uint32_t lo2=0; uint32_t lo2=0;
lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
uint8_t idx3 = 1; uint8_t idx3 = 1;
while(lo2>1){ //find last bit set to 1 (format len bit) while(lo2 > 1){ //find last bit set to 1 (format len bit)
lo2=lo2>>1; lo2=lo2 >> 1;
idx3++; idx3++;
} }
bitlen =idx3+19; bitlen = idx3+19;
fc =0; fc =0;
cardnum=0; cardnum=0;
if(bitlen==26){ if(bitlen == 26){
cardnum = (lo>>1)&0xFFFF; cardnum = (lo>>1)&0xFFFF;
fc = (lo>>17)&0xFF; fc = (lo>>17)&0xFF;
} }
if(bitlen==37){ if(bitlen == 37){
cardnum = (lo>>1)&0x7FFFF; cardnum = (lo>>1)&0x7FFFF;
fc = ((hi&0xF)<<12)|(lo>>20); fc = ((hi&0xF)<<12)|(lo>>20);
} }
if(bitlen==34){ if(bitlen == 34){
cardnum = (lo>>1)&0xFFFF; cardnum = (lo>>1)&0xFFFF;
fc= ((hi&1)<<15)|(lo>>17); fc= ((hi&1)<<15)|(lo>>17);
} }
if(bitlen==35){ if(bitlen == 35){
cardnum = (lo>>1)&0xFFFFF; cardnum = (lo>>1)&0xFFFFF;
fc = ((hi&1)<<11)|(lo>>21); fc = ((hi&1)<<11)|(lo>>21);
} }
@ -1204,7 +1202,7 @@ void CopyIOtoT55x7(uint32_t hi, uint32_t lo, uint8_t longFMT)
data1 = hi; // load preamble data1 = hi; // load preamble
data2 = lo; data2 = lo;
LED_D_ON(); LED_D_ON();
// Program the data blocks for supplied ID // Program the data blocks for supplied ID
// and the block 0 for HID format // and the block 0 for HID format
@ -1331,6 +1329,7 @@ void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo)
// Clone Indala 64-bit tag by UID to T55x7 // Clone Indala 64-bit tag by UID to T55x7
void CopyIndala64toT55x7(int hi, int lo) void CopyIndala64toT55x7(int hi, int lo)
{ {
//Program the 2 data blocks for supplied 64bit UID //Program the 2 data blocks for supplied 64bit UID
// and the block 0 for Indala64 format // and the block 0 for Indala64 format
T55xxWriteBlock(hi,1,0,0); T55xxWriteBlock(hi,1,0,0);
@ -1344,10 +1343,12 @@ void CopyIndala64toT55x7(int hi, int lo)
// T5567WriteBlock(0x603E1042,0); // T5567WriteBlock(0x603E1042,0);
DbpString("DONE!"); DbpString("DONE!");
}
}
void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int uid6, int uid7) void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int uid6, int uid7)
{ {
//Program the 7 data blocks for supplied 224bit UID //Program the 7 data blocks for supplied 224bit UID
// and the block 0 for Indala224 format // and the block 0 for Indala224 format
T55xxWriteBlock(uid1,1,0,0); T55xxWriteBlock(uid1,1,0,0);
@ -1366,6 +1367,7 @@ void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int
// T5567WriteBlock(0x603E10E2,0); // T5567WriteBlock(0x603E10E2,0);
DbpString("DONE!"); DbpString("DONE!");
} }

416
client/cmddata.c
View file

@ -21,9 +21,55 @@
#include "cmdmain.h" #include "cmdmain.h"
#include "cmddata.h" #include "cmddata.h"
#include "lfdemod.h" #include "lfdemod.h"
uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
int DemodBufferLen;
static int CmdHelp(const char *Cmd); 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)
{
int i=0;
for (; i < size; ++i){
DemodBuffer[i]=buff[i];
}
DemodBufferLen=size;
return;
}
//by marshmellow
void printDemodBuff()
{
uint32_t i = 0;
int bitLen = DemodBufferLen;
if (bitLen<16) {
PrintAndLog("no bits found in demod buffer");
return;
}
if (bitLen>512) bitLen=512; //max output to 512 bits if we have more - should be plenty
for (i = 0; i <= (bitLen-16); i+=16) {
PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
DemodBuffer[i],
DemodBuffer[i+1],
DemodBuffer[i+2],
DemodBuffer[i+3],
DemodBuffer[i+4],
DemodBuffer[i+5],
DemodBuffer[i+6],
DemodBuffer[i+7],
DemodBuffer[i+8],
DemodBuffer[i+9],
DemodBuffer[i+10],
DemodBuffer[i+11],
DemodBuffer[i+12],
DemodBuffer[i+13],
DemodBuffer[i+14],
DemodBuffer[i+15]);
}
return;
}
int CmdAmp(const char *Cmd) int CmdAmp(const char *Cmd)
{ {
int i, rising, falling; int i, rising, falling;
@ -81,7 +127,7 @@ int Cmdaskdemod(const char *Cmd)
sscanf(Cmd, "%i", &c); sscanf(Cmd, "%i", &c);
/* Detect high and lows and clock */ /* Detect high and lows and clock */
// (AL - clock???) // (AL - clock???)
for (i = 0; i < GraphTraceLen; ++i) for (i = 0; i < GraphTraceLen; ++i)
{ {
if (GraphBuffer[i] > high) if (GraphBuffer[i] > high)
@ -152,9 +198,10 @@ void printBitStream(uint8_t BitStream[], uint32_t bitLen)
BitStream[i+14], BitStream[i+14],
BitStream[i+15]); BitStream[i+15]);
} }
return; return;
} }
//by marshmellow //by marshmellow
//print EM410x ID in multiple formats
void printEM410x(uint64_t id) void printEM410x(uint64_t id)
{ {
if (id !=0){ if (id !=0){
@ -164,7 +211,7 @@ void printEM410x(uint64_t id)
uint32_t i=0; uint32_t i=0;
for (ii=5; ii>0;ii--){ for (ii=5; ii>0;ii--){
for (i=0;i<8;i++){ for (i=0;i<8;i++){
id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8))); id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8)));
} }
} }
//output em id //output em id
@ -177,18 +224,19 @@ void printEM410x(uint64_t id)
PrintAndLog("DEZ 14/IK2 : %014lld",id); PrintAndLog("DEZ 14/IK2 : %014lld",id);
PrintAndLog("DEZ 15/IK3 : %015lld",id2lo); PrintAndLog("DEZ 15/IK3 : %015lld",id2lo);
PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF)); PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
} }
return; return;
} }
//by marshmellow //by marshmellow
//take binary from demod buffer and see if we can find an EM410x ID
int CmdEm410xDecode(const char *Cmd) int CmdEm410xDecode(const char *Cmd)
{ {
uint64_t id=0; uint64_t id=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t i=0; // uint32_t i=0;
i=getFromGraphBuf(BitStream); // i=getFromGraphBuf(BitStream);
id = Em410xDecode(BitStream,i); id = Em410xDecode(DemodBuffer,DemodBufferLen);
printEM410x(id); printEM410x(id);
if (id>0) return 1; if (id>0) return 1;
return 0; return 0;
@ -197,41 +245,41 @@ int CmdEm410xDecode(const char *Cmd)
//by marshmellow //by marshmellow
//takes 2 arguments - clock and invert both as integers //takes 2 arguments - clock and invert both as integers
//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)
{ {
int invert=0; int invert=0;
int clk=0; int clk=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) { if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
uint32_t BitLen = getFromGraphBuf(BitStream);
size_t BitLen = getFromGraphBuf(BitStream);
// PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); // PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
int errCnt=0; int errCnt=0;
errCnt = askmandemod(BitStream, &BitLen,&clk,&invert); errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
if (errCnt<0){ //if fatal error (or -1) 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); // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0; return 0;
} }
if (BitLen<16) return 0;
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen); PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
//output //output
if (errCnt>0){ if (errCnt>0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} }
PrintAndLog("ASK/Manchester decoded bitstream:"); PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
printDemodBuff();
uint64_t lo =0; uint64_t lo =0;
lo = Em410xDecode(BitStream,BitLen); lo = Em410xDecode(BitStream,BitLen);
if (lo>0){ if (lo>0){
//set GraphBuffer for clone or sim command //set GraphBuffer for clone or sim command
setGraphBuf(BitStream,BitLen);
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
printEM410x(lo); printEM410x(lo);
return 1; return 1;
@ -247,37 +295,31 @@ int Cmdmandecoderaw(const char *Cmd)
{ {
int i =0; int i =0;
int errCnt=0; int errCnt=0;
int bitnum=0; size_t size=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
int high=0,low=0; int high=0,low=0;
for (;i<GraphTraceLen;++i){ for (;i<DemodBufferLen;++i){
if (GraphBuffer[i]>high) high=GraphBuffer[i]; if (DemodBuffer[i]>high) high=DemodBuffer[i];
else if(GraphBuffer[i]<low) low=GraphBuffer[i]; else if(DemodBuffer[i]<low) low=DemodBuffer[i];
BitStream[i]=GraphBuffer[i]; BitStream[i]=DemodBuffer[i];
} }
if (high>1 || low <0 ){ if (high>1 || low <0 ){
PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode"); PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
return 0; return 0;
} }
bitnum=i; size=i;
errCnt=manrawdecode(BitStream,&bitnum); errCnt=manrawdecode(BitStream, &size);
if (errCnt>=20){ if (errCnt>=20){
PrintAndLog("Too many errors: %d",errCnt); PrintAndLog("Too many errors: %d",errCnt);
return 0; return 0;
} }
PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt); PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
printBitStream(BitStream,bitnum); printBitStream(BitStream, size);
if (errCnt==0){ if (errCnt==0){
//put back in graphbuffer uint64_t id = 0;
ClearGraph(0); id = Em410xDecode(BitStream, size);
for (i=0; i<bitnum;++i){ if (id>0) setDemodBuf(BitStream, size);
GraphBuffer[i]=BitStream[i]; printEM410x(id);
}
GraphTraceLen=bitnum;
RepaintGraphWindow();
uint64_t id = 0;
id = Em410xDecode(BitStream,i);
printEM410x(id);
} }
return 1; return 1;
} }
@ -286,7 +328,7 @@ int Cmdmandecoderaw(const char *Cmd)
//biphase decode //biphase decode
//take 01 or 10 = 0 and 11 or 00 = 1 //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 1 argument "offset" default = 0 if 1 it will shift the decode by one bit
// since it is not like manchester and doesn't have an incorrect bit pattern we // 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 // 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 // the argument offset allows us to manually shift if the output is incorrect
// (better would be to demod and decode at the same time so we can distinguish large // (better would be to demod and decode at the same time so we can distinguish large
@ -295,29 +337,29 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
{ {
int i = 0; int i = 0;
int errCnt=0; int errCnt=0;
int bitnum=0; size_t size=0;
int offset=0; int offset=0;
int high=0, low=0; int high=0, low=0;
sscanf(Cmd, "%i", &offset); sscanf(Cmd, "%i", &offset);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
//get graphbuffer & high and low //get graphbuffer & high and low
for (;i<GraphTraceLen;++i){ for (;i<DemodBufferLen;++i){
if(GraphBuffer[i]>high)high=GraphBuffer[i]; if(DemodBuffer[i]>high)high=DemodBuffer[i];
else if(GraphBuffer[i]<low)low=GraphBuffer[i]; else if(DemodBuffer[i]<low)low=DemodBuffer[i];
BitStream[i]=GraphBuffer[i]; BitStream[i]=DemodBuffer[i];
} }
if (high>1 || low <0){ if (high>1 || low <0){
PrintAndLog("Error: please raw demod the wave first then decode"); PrintAndLog("Error: please raw demod the wave first then decode");
return 0; return 0;
} }
bitnum=i; size=i;
errCnt=BiphaseRawDecode(BitStream,&bitnum, offset); errCnt=BiphaseRawDecode(BitStream, &size, offset);
if (errCnt>=20){ if (errCnt>=20){
PrintAndLog("Too many errors attempting to decode: %d",errCnt); PrintAndLog("Too many errors attempting to decode: %d",errCnt);
return 0; return 0;
} }
PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt); PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
printBitStream(BitStream,bitnum); printBitStream(BitStream, size);
PrintAndLog("\nif bitstream does not look right try offset=1"); PrintAndLog("\nif bitstream does not look right try offset=1");
return 1; return 1;
} }
@ -329,37 +371,34 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int Cmdaskrawdemod(const char *Cmd) int Cmdaskrawdemod(const char *Cmd)
{ {
int invert=0;
int invert=0; int clk=0;
int clk=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) { if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
int BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
int errCnt=0; int errCnt=0;
errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert); errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
if (errCnt==-1){ //throw away static - allow 1 and -1 (in case of threshold command first) if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
PrintAndLog("no data found"); PrintAndLog("no data found");
return 0; return 0;
} }
if (BitLen<16) return 0;
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); 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); //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
//move BitStream back to GraphBuffer //move BitStream back to DemodBuffer
setGraphBuf(BitStream, BitLen); setDemodBuf(BitStream,BitLen);
//output
if (errCnt>0){ if (errCnt>0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} }
PrintAndLog("ASK demoded bitstream:"); PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen); printBitStream(BitStream,BitLen);
return 1; return 1;
} }
@ -399,7 +438,7 @@ int CmdBitsamples(const char *Cmd)
{ {
int cnt = 0; int cnt = 0;
uint8_t got[12288]; uint8_t got[12288];
GetFromBigBuf(got,sizeof(got),0); GetFromBigBuf(got,sizeof(got),0);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
@ -472,6 +511,10 @@ int CmdBitstream(const char *Cmd)
bit ^= 1; bit ^= 1;
AppendGraph(0, clock, bit); AppendGraph(0, clock, bit);
// for (j = 0; j < (int)(clock/2); j++)
// GraphBuffer[(i * clock) + j] = bit ^ 1;
// for (j = (int)(clock/2); j < clock; j++)
// GraphBuffer[(i * clock) + j] = bit;
} }
RepaintGraphWindow(); RepaintGraphWindow();
@ -497,10 +540,12 @@ int CmdDec(const char *Cmd)
} }
/* Print our clock rate */ /* Print our clock rate */
// uses data from graphbuffer // uses data from graphbuffer
int CmdDetectClockRate(const char *Cmd) int CmdDetectClockRate(const char *Cmd)
{ {
GetClock("",0,0); GetClock("",0,0);
//int clock = DetectASKClock(0);
//PrintAndLog("Auto-detected clock rate: %d", clock);
return 0; return 0;
} }
@ -517,29 +562,23 @@ int CmdFSKrawdemod(const char *Cmd)
int fchigh=10; int fchigh=10;
int fclow=8; int fclow=8;
//set options from parameters entered with the command //set options from parameters entered with the command
sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow); sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
if (strlen(Cmd)>0 && strlen(Cmd)<=2) { if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
//rfLen=param_get8(Cmd, 0); //if rfLen option only is used //rfLen=param_get8(Cmd, 0); //if rfLen option only is used
if (rfLen==1){ if (rfLen==1){
invert=1; //if invert option only is used invert=1; //if invert option only is used
rfLen = 50; rfLen = 50;
} else if(rfLen==0) rfLen=50; } else if(rfLen==0) rfLen=50;
} }
PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow); PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
uint32_t i=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
if (size>0){ if (size>0){
PrintAndLog("FSK decoded bitstream:"); PrintAndLog("FSK decoded bitstream:");
ClearGraph(0); setDemodBuf(BitStream,size);
for (i=0;i<size;++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=size;
RepaintGraphWindow();
// Now output the bitstream to the scrollback by line of 16 bits // 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 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
printBitStream(BitStream,size); printBitStream(BitStream,size);
@ -558,18 +597,18 @@ int CmdFSKdemodHID(const char *Cmd)
uint32_t hi2=0, hi=0, lo=0; uint32_t hi2=0, hi=0, lo=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
//get binary from fsk wave //get binary from fsk wave
size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
if (size<0){ if (size<0){
PrintAndLog("Error demoding fsk"); PrintAndLog("Error demoding fsk");
return 0; return 0;
} }
if (hi2==0 && hi==0 && lo==0) return 0; if (hi2==0 && hi==0 && lo==0) return 0;
if (hi2 != 0){ //extra large HID tags if (hi2 != 0){ //extra large HID tags
PrintAndLog("TAG ID: %x%08x%08x (%d)", PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
setGraphBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
return 1; return 1;
} }
else { //standard HID tags <38 bits else { //standard HID tags <38 bits
@ -585,7 +624,7 @@ int CmdFSKdemodHID(const char *Cmd)
lo2=lo2>>1; lo2=lo2>>1;
idx3++; idx3++;
} }
fmtLen =idx3+19; fmtLen =idx3+19;
fc =0; fc =0;
cardnum=0; cardnum=0;
if(fmtLen==26){ if(fmtLen==26){
@ -613,11 +652,11 @@ int CmdFSKdemodHID(const char *Cmd)
cardnum = (lo>>1)&0x7FFFF; cardnum = (lo>>1)&0x7FFFF;
fc = ((hi&0xF)<<12)|(lo>>20); fc = ((hi&0xF)<<12)|(lo>>20);
} }
} }
PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d", 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) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
(unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum); (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
setGraphBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
return 1; return 1;
} }
return 0; return 0;
@ -630,14 +669,14 @@ int CmdFSKdemodIO(const char *Cmd)
{ {
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults //set defaults
int idx=0; int idx=0;
//something in graphbuffer //something in graphbuffer
if (GraphTraceLen < 65) return 0; if (GraphTraceLen < 65) return 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
//get binary from fsk wave //get binary from fsk wave
// PrintAndLog("DEBUG: got buff"); // PrintAndLog("DEBUG: got buff");
idx = IOdemodFSK(BitStream,BitLen); idx = IOdemodFSK(BitStream,BitLen);
if (idx<0){ if (idx<0){
//PrintAndLog("Error demoding fsk"); //PrintAndLog("Error demoding fsk");
return 0; return 0;
@ -659,7 +698,7 @@ int CmdFSKdemodIO(const char *Cmd)
//Handle the data //Handle the data
if (idx+64>BitLen) return 0; if (idx+64>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], 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",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]); 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]);
PrintAndLog("%d%d%d%d%d%d%d%d %d version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]); PrintAndLog("%d%d%d%d%d%d%d%d %d version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]); PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
@ -667,13 +706,16 @@ int CmdFSKdemodIO(const char *Cmd)
PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]); PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
uint32_t code = bytebits_to_byte(BitStream+idx,32); uint32_t code = bytebits_to_byte(BitStream+idx,32);
uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32); uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32);
uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4 uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ; 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 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);
PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2); int i;
setGraphBuf(BitStream,BitLen); for (i=0;i<64;++i)
DemodBuffer[i]=BitStream[idx++];
DemodBufferLen=64;
return 1; return 1;
} }
int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
@ -701,7 +743,7 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
int i, j; int i, j;
int minMark = 0, maxMark = 0; int minMark = 0, maxMark = 0;
for (i = 0; i < GraphTraceLen - convLen; ++i) { for (i = 0; i < GraphTraceLen - convLen; ++i) {
int lowSum = 0, highSum = 0; int lowSum = 0, highSum = 0;
@ -762,7 +804,8 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
PrintAndLog("actual data bits start at sample %d", maxPos); PrintAndLog("actual data bits start at sample %d", maxPos);
PrintAndLog("length %d/%d", highLen, lowLen); PrintAndLog("length %d/%d", highLen, lowLen);
uint8_t bits[46] = {0x00}; uint8_t bits[46];
bits[sizeof(bits)-1] = '\0';
// find bit pairs and manchester decode them // find bit pairs and manchester decode them
for (i = 0; i < arraylen(bits) - 1; ++i) { for (i = 0; i < arraylen(bits) - 1; ++i) {
@ -794,6 +837,129 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
return 0; return 0;
} }
int CmdDetectNRZpskClockRate(const char *Cmd)
{
GetNRZpskClock("",0,0);
return 0;
}
int PSKnrzDemod(const char *Cmd){
int invert=0;
int clk=0;
sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd);
return -1;
}
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t BitLen = getFromGraphBuf(BitStream);
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);
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);
return errCnt;
}
// Indala 26 bit decode
// by marshmellow
// optional arguments - same as CmdpskNRZrawDemod (clock & invert)
int CmdIndalaDecode(const char *Cmd)
{
int ans=PSKnrzDemod(Cmd);
if (ans < 0){
PrintAndLog("Error1: %d",ans);
return 0;
}
uint8_t invert=0;
ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert);
if (ans < 1) {
PrintAndLog("Error2: %d",ans);
return -1;
}
char showbits[251];
if(invert==1) PrintAndLog("Had to invert bits");
//convert UID to HEX
uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
int idx;
uid1=0;
uid2=0;
PrintAndLog("BitLen: %d",DemodBufferLen);
if (DemodBufferLen==64){
for( idx=0; idx<64; idx++) {
uid1=(uid1<<1)|(uid2>>31);
if (DemodBuffer[idx] == 0) {
uid2=(uid2<<1)|0;
showbits[idx]='0';
} else {
uid2=(uid2<<1)|1;
showbits[idx]='1';
}
}
showbits[idx]='\0';
PrintAndLog("Indala UID=%s (%x%08x)", showbits, uid1, uid2);
}
else {
uid3=0;
uid4=0;
uid5=0;
uid6=0;
uid7=0;
for( idx=0; idx<DemodBufferLen; idx++) {
uid1=(uid1<<1)|(uid2>>31);
uid2=(uid2<<1)|(uid3>>31);
uid3=(uid3<<1)|(uid4>>31);
uid4=(uid4<<1)|(uid5>>31);
uid5=(uid5<<1)|(uid6>>31);
uid6=(uid6<<1)|(uid7>>31);
if (DemodBuffer[idx] == 0) {
uid7=(uid7<<1)|0;
showbits[idx]='0';
}
else {
uid7=(uid7<<1)|1;
showbits[idx]='1';
}
}
showbits[idx]='\0';
PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
}
return 1;
}
int CmdPskClean(const char *Cmd)
{
uint8_t bitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t bitLen = getFromGraphBuf(bitStream);
pskCleanWave(bitStream, bitLen);
setGraphBuf(bitStream, bitLen);
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
int CmdpskNRZrawDemod(const char *Cmd)
{
int errCnt= PSKnrzDemod(Cmd);
//output
if (errCnt<0) return 0;
if (errCnt>0){
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;
}
int CmdGrid(const char *Cmd) int CmdGrid(const char *Cmd)
{ {
sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY); sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
@ -811,7 +977,7 @@ int CmdHexsamples(const char *Cmd)
char string_buf[25]; char string_buf[25];
char* string_ptr = string_buf; char* string_ptr = string_buf;
uint8_t got[40000]; uint8_t got[40000];
sscanf(Cmd, "%i %i", &requested, &offset); sscanf(Cmd, "%i %i", &requested, &offset);
/* if no args send something */ /* if no args send something */
@ -821,7 +987,7 @@ int CmdHexsamples(const char *Cmd)
if (offset + requested > sizeof(got)) { if (offset + requested > sizeof(got)) {
PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000"); PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > 40000");
return 0; return 0;
} }
GetFromBigBuf(got,requested,offset); GetFromBigBuf(got,requested,offset);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
@ -841,8 +1007,8 @@ int CmdHexsamples(const char *Cmd)
*(string_ptr - 1) = '\0'; *(string_ptr - 1) = '\0';
PrintAndLog("%s", string_buf); PrintAndLog("%s", string_buf);
string_buf[0] = '\0'; string_buf[0] = '\0';
}
} }
}
return 0; return 0;
} }
@ -869,19 +1035,19 @@ int CmdHpf(const char *Cmd)
int CmdSamples(const char *Cmd) int CmdSamples(const char *Cmd)
{ {
uint8_t got[40000] = {0x00}; uint8_t got[40000];
int n = strtol(Cmd, NULL, 0); int n = strtol(Cmd, NULL, 0);
if (n == 0) if (n == 0)
n = 20000; n = 20000;
if (n > sizeof(got)) if (n > sizeof(got))
n = sizeof(got); n = sizeof(got);
PrintAndLog("Reading %d samples from device memory\n", n); PrintAndLog("Reading %d samples from device memory\n", n);
GetFromBigBuf(got,n,0); GetFromBigBuf(got,n,0);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
for (int j = 0; j < n; ++j) { for (int j = 0; j < n; j++) {
GraphBuffer[j] = ((int)got[j]) - 128; GraphBuffer[j] = ((int)got[j]) - 128;
} }
GraphTraceLen = n; GraphTraceLen = n;
@ -930,8 +1096,8 @@ int CmdTuneSamples(const char *Cmd)
for (int i = 0; i < 256; i++) { for (int i = 0; i < 256; i++) {
GraphBuffer[i] = resp.d.asBytes[i] - 128; GraphBuffer[i] = resp.d.asBytes[i] - 128;
} }
PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n"); PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
PrintAndLog("\n"); PrintAndLog("\n");
GraphTraceLen = 256; GraphTraceLen = 256;
@ -940,6 +1106,7 @@ int CmdTuneSamples(const char *Cmd)
return 0; return 0;
} }
int CmdLoad(const char *Cmd) int CmdLoad(const char *Cmd)
{ {
char filename[FILE_PATH_SIZE] = {0x00}; char filename[FILE_PATH_SIZE] = {0x00};
@ -1241,8 +1408,9 @@ int CmdNorm(const char *Cmd)
if (max != min) { if (max != min) {
for (i = 0; i < GraphTraceLen; ++i) { for (i = 0; i < GraphTraceLen; ++i) {
GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 / GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 256 /
(max - min); (max - min);
//marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work
} }
} }
RepaintGraphWindow(); RepaintGraphWindow();
@ -1308,12 +1476,12 @@ int CmdDirectionalThreshold(const char *Cmd)
{ {
int8_t upThres = param_get8(Cmd, 0); int8_t upThres = param_get8(Cmd, 0);
int8_t downThres = param_get8(Cmd, 1); int8_t downThres = param_get8(Cmd, 1);
printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres); printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
int lastValue = GraphBuffer[0]; int lastValue = GraphBuffer[0];
GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in. GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
for (int i = 1; i < GraphTraceLen; ++i) { for (int i = 1; i < GraphTraceLen; ++i) {
// Apply first threshold to samples heading up // Apply first threshold to samples heading up
if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue) if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
@ -1368,26 +1536,26 @@ int CmdZerocrossings(const char *Cmd)
return 0; return 0;
} }
static command_t CommandTable[] = static command_t CommandTable[] =
{ {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"amp", CmdAmp, 1, "Amplify peaks"}, {"amp", CmdAmp, 1, "Amplify peaks"},
{"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"}, {"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"}, {"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"}, {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
{"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"}, {"autocorr", CmdAutoCorr, 1, "<window length> -- 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] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
{"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
{"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"}, {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},
{"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"},
{"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"}, {"detectclock", CmdDetectClockRate, 1, "Detect ASK clock rate"},
{"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"}, {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
{"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"}, {"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"}, {"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 or 0)(rchigh = 10)(rclow=8)"}, {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to binary (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"},
{"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"}, {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"}, {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
{"hide", CmdHide, 1, "Hide graph window"}, {"hide", CmdHide, 1, "Hide graph window"},
{"hpf", CmdHpf, 1, "Remove DC offset from trace"}, {"hpf", CmdHpf, 1, "Remove DC offset from trace"},
{"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"}, {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
@ -1396,15 +1564,19 @@ static command_t CommandTable[] =
{"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"}, {"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
{"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"}, {"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"},
{"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"}, {"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"},
{"norm", CmdNorm, 1, "Normalize max/min to +/-500"}, {"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)"},
{"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])"},
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
{"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"}, {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"}, {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
{"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"}, {"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},
{"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"}, {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

9
client/cmddata.h
View file

@ -14,7 +14,7 @@
command_t * CmdDataCommands(); command_t * CmdDataCommands();
int CmdData(const char *Cmd); int CmdData(const char *Cmd);
void printDemodBuff();
int CmdAmp(const char *Cmd); int CmdAmp(const char *Cmd);
int Cmdaskdemod(const char *Cmd); int Cmdaskdemod(const char *Cmd);
int Cmdaskrawdemod(const char *Cmd); int Cmdaskrawdemod(const char *Cmd);
@ -30,6 +30,8 @@ int CmdFSKdemod(const char *Cmd);
int CmdFSKdemodHID(const char *Cmd); int CmdFSKdemodHID(const char *Cmd);
int CmdFSKdemodIO(const char *Cmd); int CmdFSKdemodIO(const char *Cmd);
int CmdFSKrawdemod(const char *Cmd); int CmdFSKrawdemod(const char *Cmd);
int CmdDetectNRZpskClockRate(const char *Cmd);
int CmdpskNRZrawDemod(const char *Cmd);
int CmdGrid(const char *Cmd); int CmdGrid(const char *Cmd);
int CmdHexsamples(const char *Cmd); int CmdHexsamples(const char *Cmd);
int CmdHide(const char *Cmd); int CmdHide(const char *Cmd);
@ -49,5 +51,10 @@ int CmdScale(const char *Cmd);
int CmdThreshold(const char *Cmd); int CmdThreshold(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);
#define MAX_DEMOD_BUF_LEN (1024*128)
extern uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
extern int DemodBufferLen;
#endif #endif

2
client/cmdlfem4x.c
View file

@ -617,7 +617,7 @@ int CmdWriteWordPWD(const char *Cmd)
static command_t CommandTable[] = static command_t CommandTable[] =
{ {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"em410xdemod", CmdEMdemodASK, 0, "[clock rate] -- Extract ID from EM410x tag"}, {"em410xdemod", CmdEMdemodASK, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
{"em410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag"}, {"em410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag"},
{"em410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"}, {"em410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"},
{"em410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"}, {"em410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},

139
client/graph.c
View file

@ -24,7 +24,7 @@ void AppendGraph(int redraw, int clock, int bit)
for (i = 0; i < (int)(clock / 2); ++i) for (i = 0; i < (int)(clock / 2); ++i)
GraphBuffer[GraphTraceLen++] = bit ^ 1; GraphBuffer[GraphTraceLen++] = bit ^ 1;
for (i = (int)(clock / 2); i < clock; ++i) for (i = (int)(clock / 2); i < clock; ++i)
GraphBuffer[GraphTraceLen++] = bit; GraphBuffer[GraphTraceLen++] = bit;
@ -32,7 +32,7 @@ void AppendGraph(int redraw, int clock, int bit)
RepaintGraphWindow(); RepaintGraphWindow();
} }
/* clear out our graph window */ // clear out our graph window
int ClearGraph(int redraw) int ClearGraph(int redraw)
{ {
int gtl = GraphTraceLen; int gtl = GraphTraceLen;
@ -46,115 +46,20 @@ int ClearGraph(int redraw)
return gtl; return gtl;
} }
/* // DETECT CLOCK NOW IN LFDEMOD.C
* Detect clock rate
*/
//decommissioned - has difficulty detecting rf/32
/*
int DetectClockOld(int peak)
{
int i;
int clock = 0xFFFF;
int lastpeak = 0;
// Detect peak if we don't have one void setGraphBuf(uint8_t *buff, size_t size)
if (!peak)
for (i = 0; i < GraphTraceLen; ++i)
if (GraphBuffer[i] > peak)
peak = GraphBuffer[i];
// peak=(int)(peak*.75);
for (i = 1; i < GraphTraceLen; ++i)
{
// If this is the beginning of a peak
if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak)
{
// Find lowest difference between peaks
if (lastpeak && i - lastpeak < clock)
clock = i - lastpeak;
lastpeak = i;
}
}
return clock;
}
*/
/*
NOW IN LFDEMOD.C
// 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(int peak)
{
int i=0;
int low=0;
int clk[]={16,32,40,50,64,100,128,256};
int loopCnt = 256;
if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
if (!peak){
for (i=0;i<loopCnt;++i){
if(GraphBuffer[i]>peak){
peak = GraphBuffer[i];
}
if(GraphBuffer[i]<low){
low = GraphBuffer[i];
}
}
peak=(int)(peak*.75);
low= (int)(low*.75);
}
int ii;
int clkCnt;
int tol = 0;
int bestErr=1000;
int errCnt[]={0,0,0,0,0,0,0,0};
for(clkCnt=0; clkCnt<6;++clkCnt){
if (clk[clkCnt]==32){
tol=1;
}else{
tol=0;
}
bestErr=1000;
for (ii=0; ii<loopCnt; ++ii){
if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
errCnt[clkCnt]=0;
for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
}else{ //error no peak detected
errCnt[clkCnt]++;
}
}
if(errCnt[clkCnt]==0) return clk[clkCnt];
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
}
}
}
int iii=0;
int best=0;
for (iii=0; iii<6;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
}
// PrintAndLog("DEBUG: clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
return clk[best];
}
*/
void setGraphBuf(uint8_t *buff,int size)
{ {
int i=0; int i=0;
ClearGraph(0); ClearGraph(0);
for (; i < size; ++i){ for (; i < size; ++i){
GraphBuffer[i]=buff[i]; GraphBuffer[i]=buff[i]-128;
} }
GraphTraceLen=size; GraphTraceLen=size;
RepaintGraphWindow(); RepaintGraphWindow();
return; return;
} }
int getFromGraphBuf(uint8_t *buff) size_t getFromGraphBuf(uint8_t *buff)
{ {
uint32_t i; uint32_t i;
for (i=0;i<GraphTraceLen;++i){ for (i=0;i<GraphTraceLen;++i){
@ -164,28 +69,46 @@ int getFromGraphBuf(uint8_t *buff)
} }
return i; return i;
} }
/* Get or auto-detect clock rate */ // Get or auto-detect clock rate
int GetClock(const char *str, int peak, int verbose) int GetClock(const char *str, int peak, int verbose)
{ {
int clock; int clock;
// int clock2;
sscanf(str, "%i", &clock); sscanf(str, "%i", &clock);
if (!strcmp(str, "")) if (!strcmp(str, ""))
clock = 0; clock = 0;
/* Auto-detect clock */ // Auto-detect clock
if (!clock) if (!clock)
{ {
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
int size = getFromGraphBuf(grph); size_t size = getFromGraphBuf(grph);
clock = DetectASKClock(grph,size,0); clock = DetectASKClock(grph,size,0);
//clock2 = DetectClock2(peak); // Only print this message if we're not looping something
/* Only print this message if we're not looping something */
if (!verbose){ if (!verbose){
PrintAndLog("Auto-detected clock rate: %d", clock); PrintAndLog("Auto-detected clock rate: %d", clock);
//PrintAndLog("clock2: %d",clock2);
} }
} }
return clock; return clock;
} }
int GetNRZpskClock(const char *str, int peak, int verbose)
{
int clock;
sscanf(str, "%i", &clock);
if (!strcmp(str, ""))
clock = 0;
// Auto-detect clock
if (!clock)
{
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
size_t size = getFromGraphBuf(grph);
clock = DetectpskNRZClock(grph,size,0);
// Only print this message if we're not looping something
if (!verbose){
PrintAndLog("Auto-detected clock rate: %d", clock);
}
}
return clock;
}

5
client/graph.h
View file

@ -15,9 +15,10 @@
void AppendGraph(int redraw, int clock, int bit); void AppendGraph(int redraw, int clock, int bit);
int ClearGraph(int redraw); int ClearGraph(int redraw);
//int DetectClock(int peak); //int DetectClock(int peak);
int getFromGraphBuf(uint8_t *buff); size_t getFromGraphBuf(uint8_t *buff);
int GetClock(const char *str, int peak, int verbose); int GetClock(const char *str, int peak, int verbose);
void setGraphBuf(uint8_t *buff,int size); int GetNRZpskClock(const char *str, int peak, int verbose);
void setGraphBuf(uint8_t *buff, size_t size);
#define MAX_GRAPH_TRACE_LEN (1024*128) #define MAX_GRAPH_TRACE_LEN (1024*128)
extern int GraphBuffer[MAX_GRAPH_TRACE_LEN]; extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];

63
client/lualibs/default_toys.lua Normal file
View file

@ -0,0 +1,63 @@
local _names = {
--[[
--]]
["0400"]="BASH",
["1600"]="BOOMER" ,
["1800"]="CAMO",
["3000"]="CHOPCHOP" ,
["2000"]="CYNDER",
["6400"]="JET-VAC",
["6700"]="FLASHWING",
["7000"]="TREE REX",
["7100"]="LIGHTCORE SHROOMBOOM",
["1C00"]="DARK SPYRO",
["0600"]="DINORANG" ,
["1200"]="DOUBLE TROUBLE" ,
["1500"]="DRILLSERGEANT" ,
["1400"]="DROBOT",
["0900"]="LIGHTCORE ERUPTOR" ,
["0B00"]="FLAMESLINGER" ,
["1F00"]="GHOST ROASTER",
["0E00"]="GILL GRUNT" ,
["1D00"]="HEX",
["0A00"]="IGNITOR",
["0300"]="LIGHTNINGROD",
["0700"]="LIGHTCORE PRISM BREAK",
["1500"]="SLAMBAM",
["0100"]="SONIC BOOM",
["1000"]="SPYRO",
["1A00"]="STEALTH ELF",
["1B00"]="STUMP SMASH",
["0800"]="SUNBURN",
["0500"]="TERRAFIN",
["1300"]="TRIGGER HAPPY",
["1100"]="VOODOOD",
["0200"]="WARNADO",
["0D00"]="WHAM SHELL",
["0000"]="WHIRLWIND",
["1700"]="WRECKING BALL",
["0C00"]="ZAP",
["1900"]="ZOOK",
["0300"]="DRAGON",
["012D"]="ICE",
["012E"]="PIRATE",
["0130"]="PVPUNLOCK",
["012F"]="UNDEAD",
["0200"]="ANVIL" ,
["CB00"]="CROSSED SWORDS",
["CC00"]="HOURGLASS",
["CA00"]="REGENERATION",
["C900"]="SECRET STASH",
["CD00"]="SHIELD",
["CF00"]="SPARX",
["CE00"]="SPEED BOOTS",
["0194"]="LEGENDARY BASH",
["0430"]="LEGENDARY CHOPCHOP",
["01A0"]="LEGENDARY SPYRO",
["01A3"]="LEGENDARY TRIGGER HAPPY",
["0202"]="PET GILL GRUNT",
["020E"]="PET STEALTH ELF",
["01F9"]="PET TERRAFIN",
["0207"]="PET TRIGGER HAPPY",
}
return _names

1461
common/lfdemod.c
View file

File diff suppressed because it is too large Load diff

18
common/lfdemod.h
View file

@ -1,4 +1,4 @@
// Copyright (C) 2014 // Copyright (C) 2014
// //
// This code is licensed to you under the terms of the GNU GPL, version 2 or, // This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of // at your option, any later version. See the LICENSE.txt file for the text of
@ -12,14 +12,18 @@
#include <stdint.h> #include <stdint.h>
int DetectASKClock(uint8_t dest[], size_t size, int clock); int DetectASKClock(uint8_t dest[], size_t size, int clock);
int askmandemod(uint8_t *BinStream,uint32_t *BitLen,int *clk, int *invert); int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert);
uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen); uint64_t Em410xDecode(uint8_t *BitStream,size_t size);
int manrawdecode(uint8_t *BitStream, int *bitLen); int manrawdecode(uint8_t *BitStream, size_t *size);
int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset); int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset);
int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, 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 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); 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, int numbits); uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
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);
#endif #endif

16000
traces/ATA5577-HIDemu-FC1-C9.pm3 Normal file
View file

File diff suppressed because it is too large Load diff

7
traces/README.txt
View file

@ -15,3 +15,10 @@ Transit999-best.pm3: Transit 999 format (UID 99531670)
The files 'modulation-'... are all encoded with identical data (hex 00 01 02 03 04 05 06 07 08 09 0A 0B) The files 'modulation-'... are all encoded with identical data (hex 00 01 02 03 04 05 06 07 08 09 0A 0B)
for the purpose of recognition and testing of demodulation schemes. They were created by writing Q5 tags for the purpose of recognition and testing of demodulation schemes. They were created by writing Q5 tags
appropriately configured. The raw data is in 'modulation-data.dat'. appropriately configured. The raw data is in 'modulation-data.dat'.
ata5577-HIDemu-FC1-C9.pm3: ata5577 in hid prox 26 bit emulation facility code:1 card#:9
casi-12ed825c29.pm3: casi rusco 40 bit (EM410x ID: 12ed825c29)
EM4102-Fob.pm3: (ID: 0400193cbe)
ioprox-XSF-01-3B-44725.pm3: IO Prox FSK RF/64 ID in name
ioprox-XSF-01-BE-03011.pm3: IO Prox FSK RF/64 ID in name
indala-504278295.pm3: PSK 26 bit indala