mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-08-14 02:26:59 -07:00
lf demod bug fix & refactor
fixed bug in lfops.c in hid fskdemod refactored data fskXXXDemods for specific tags to use more common code.
This commit is contained in:
marshmellow42
parent
8c65b650e8
commit
a1d17964a2
4 changed files with 238 additions and 249 deletions
|
|
@ -633,9 +633,9 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
|
|||
{
|
||||
uint8_t *dest = (uint8_t *)BigBuf;
|
||||
|
||||
size_t size=sizeof(BigBuf), idx=0; //, found=0;
|
||||
size_t size=sizeof(BigBuf);
|
||||
uint32_t hi2=0, hi=0, lo=0;
|
||||
|
||||
int idx=0;
|
||||
// Configure to go in 125Khz listen mode
|
||||
LFSetupFPGAForADC(95, true);
|
||||
|
||||
|
|
@ -646,10 +646,11 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
|
|||
|
||||
DoAcquisition125k_internal(-1,true);
|
||||
// FSK demodulator
|
||||
idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo);
|
||||
|
||||
WDT_HIT();
|
||||
size = sizeof(BigBuf);
|
||||
|
||||
idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo);
|
||||
|
||||
if (idx>0 && lo>0){
|
||||
// final loop, go over previously decoded manchester data and decode into usable tag ID
|
||||
// 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
|
||||
|
|
|
|||
|
|
@ -659,9 +659,21 @@ int CmdFSKdemodHID(const char *Cmd)
|
|||
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
|
||||
size_t BitLen = getFromGraphBuf(BitStream);
|
||||
//get binary from fsk wave
|
||||
size_t idx = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
|
||||
int idx = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
|
||||
if (idx<0){
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
|
||||
if (g_debugMode){
|
||||
if (idx==-1){
|
||||
PrintAndLog("DEBUG: Just Noise Detected");
|
||||
} else if (idx == -2) {
|
||||
PrintAndLog("DEBUG: Error demoding fsk");
|
||||
} else if (idx == -3) {
|
||||
PrintAndLog("DEBUG: Preamble not found");
|
||||
} else if (idx == -4) {
|
||||
PrintAndLog("DEBUG: Error in Manchester data, SIZE: %d", BitLen);
|
||||
} else {
|
||||
PrintAndLog("DEBUG: Error demoding fsk %d", idx);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (hi2==0 && hi==0 && lo==0) {
|
||||
|
|
@ -732,9 +744,21 @@ int CmdFSKdemodParadox(const char *Cmd)
|
|||
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
|
||||
size_t BitLen = getFromGraphBuf(BitStream);
|
||||
//get binary from fsk wave
|
||||
size_t idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
|
||||
int idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
|
||||
if (idx<0){
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
|
||||
if (g_debugMode){
|
||||
if (idx==-1){
|
||||
PrintAndLog("DEBUG: Just Noise Detected");
|
||||
} else if (idx == -2) {
|
||||
PrintAndLog("DEBUG: Error demoding fsk");
|
||||
} else if (idx == -3) {
|
||||
PrintAndLog("DEBUG: Preamble not found");
|
||||
} else if (idx == -4) {
|
||||
PrintAndLog("DEBUG: Error in Manchester data");
|
||||
} else {
|
||||
PrintAndLog("DEBUG: Error demoding fsk %d", idx);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (hi2==0 && hi==0 && lo==0){
|
||||
|
|
@ -774,7 +798,21 @@ int CmdFSKdemodIO(const char *Cmd)
|
|||
//get binary from fsk wave
|
||||
idx = IOdemodFSK(BitStream,BitLen);
|
||||
if (idx<0){
|
||||
if (g_debugMode==1) PrintAndLog("DEBUG: demoding fsk error: %d", idx);
|
||||
if (g_debugMode){
|
||||
if (idx==-1){
|
||||
PrintAndLog("DEBUG: Just Noise Detected");
|
||||
} else if (idx == -2) {
|
||||
PrintAndLog("DEBUG: not enough samples");
|
||||
} else if (idx == -3) {
|
||||
PrintAndLog("DEBUG: error during fskdemod");
|
||||
} else if (idx == -4) {
|
||||
PrintAndLog("DEBUG: Preamble not found");
|
||||
} else if (idx == -5) {
|
||||
PrintAndLog("DEBUG: Separator bits not found");
|
||||
} else {
|
||||
PrintAndLog("DEBUG: Error demoding fsk %d", idx);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
if (idx==0){
|
||||
|
|
@ -834,13 +872,13 @@ int CmdFSKdemodAWID(const char *Cmd)
|
|||
size_t size = getFromGraphBuf(BitStream);
|
||||
|
||||
//get binary from fsk wave
|
||||
int idx = AWIDdemodFSK(BitStream, size);
|
||||
int idx = AWIDdemodFSK(BitStream, &size);
|
||||
if (idx<=0){
|
||||
if (g_debugMode==1){
|
||||
if (idx == -1)
|
||||
PrintAndLog("DEBUG: Error - not enough samples");
|
||||
else if (idx == -2)
|
||||
PrintAndLog("DEBUG: Error - only noise found - no waves");
|
||||
PrintAndLog("DEBUG: Error - only noise found");
|
||||
else if (idx == -3)
|
||||
PrintAndLog("DEBUG: Error - problem during FSK demod");
|
||||
// else if (idx == -3)
|
||||
|
|
@ -848,7 +886,7 @@ int CmdFSKdemodAWID(const char *Cmd)
|
|||
else if (idx == -4)
|
||||
PrintAndLog("DEBUG: Error - AWID preamble not found");
|
||||
else if (idx == -5)
|
||||
PrintAndLog("DEBUG: Error - Second AWID preamble not found");
|
||||
PrintAndLog("DEBUG: Error - Size not correct: %d", size);
|
||||
else
|
||||
PrintAndLog("DEBUG: Error %d",idx);
|
||||
}
|
||||
|
|
@ -933,17 +971,17 @@ int CmdFSKdemodPyramid(const char *Cmd)
|
|||
size_t size = getFromGraphBuf(BitStream);
|
||||
|
||||
//get binary from fsk wave
|
||||
int idx = PyramiddemodFSK(BitStream, size);
|
||||
int idx = PyramiddemodFSK(BitStream, &size);
|
||||
if (idx < 0){
|
||||
if (g_debugMode==1){
|
||||
if (idx == -5)
|
||||
PrintAndLog("DEBUG: Error - not enough samples");
|
||||
else if (idx == -1)
|
||||
PrintAndLog("DEBUG: Error - only noise found - no waves");
|
||||
PrintAndLog("DEBUG: Error - only noise found");
|
||||
else if (idx == -2)
|
||||
PrintAndLog("DEBUG: Error - problem during FSK demod");
|
||||
else if (idx == -3)
|
||||
PrintAndLog("DEBUG: Error - Second Pyramid preamble not found");
|
||||
PrintAndLog("DEBUG: Error - Size not correct: %d", size);
|
||||
else if (idx == -4)
|
||||
PrintAndLog("DEBUG: Error - Pyramid preamble not found");
|
||||
else
|
||||
|
|
@ -1039,7 +1077,6 @@ int CmdFSKdemodPyramid(const char *Cmd)
|
|||
PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
|
||||
}
|
||||
}
|
||||
//todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
|
||||
if (g_debugMode){
|
||||
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
|
||||
printDemodBuff();
|
||||
|
|
@ -1248,7 +1285,7 @@ int CmdIndalaDecode(const char *Cmd)
|
|||
PrintAndLog("Error2: %d",ans);
|
||||
return -1;
|
||||
}
|
||||
char showbits[251];
|
||||
char showbits[251]={0x00};
|
||||
if (invert)
|
||||
if (g_debugMode==1)
|
||||
PrintAndLog("Had to invert bits");
|
||||
|
|
@ -1298,6 +1335,10 @@ int CmdIndalaDecode(const char *Cmd)
|
|||
showbits[idx]='\0';
|
||||
PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
|
||||
}
|
||||
if (g_debugMode){
|
||||
PrintAndLog("DEBUG: printing demodbuffer:");
|
||||
printDemodBuff();
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
402
common/lfdemod.c
402
common/lfdemod.c
|
|
@ -12,6 +12,18 @@
|
|||
#include <string.h>
|
||||
#include "lfdemod.h"
|
||||
|
||||
|
||||
uint8_t justNoise(uint8_t *BitStream, size_t size)
|
||||
{
|
||||
static const uint8_t THRESHOLD = 123;
|
||||
//test samples are not just noise
|
||||
uint8_t justNoise1 = 1;
|
||||
for(size_t idx=0; idx < size && justNoise1 ;idx++){
|
||||
justNoise1 = BitStream[idx] < THRESHOLD;
|
||||
}
|
||||
return justNoise1;
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//get high and low with passed in fuzz factor. also return noise test = 1 for passed or 0 for only noise
|
||||
int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo)
|
||||
|
|
@ -29,59 +41,82 @@ int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi
|
|||
return 1;
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
// pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType
|
||||
// returns 1 if passed
|
||||
uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
|
||||
{
|
||||
uint8_t ans = 0;
|
||||
for (uint8_t i = 0; i < bitLen; i++){
|
||||
ans ^= ((bits >> i) & 1);
|
||||
}
|
||||
//PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType);
|
||||
return (ans == pType);
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//search for given preamble in given BitStream and return startIndex and length
|
||||
uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx)
|
||||
{
|
||||
uint8_t foundCnt=0;
|
||||
for (int idx=0; idx < *size - pLen; idx++){
|
||||
if (memcmp(BitStream+idx, preamble, pLen) == 0){
|
||||
//first index found
|
||||
foundCnt++;
|
||||
if (foundCnt == 1){
|
||||
*startIdx = idx;
|
||||
}
|
||||
if (foundCnt == 2){
|
||||
*size = idx - *startIdx;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//by marshmellow
|
||||
//takes 1s and 0s and searches for EM410x format - output EM ID
|
||||
uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx)
|
||||
{
|
||||
//no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
|
||||
// otherwise could be a void with no arguments
|
||||
//set defaults
|
||||
uint64_t lo=0;
|
||||
uint32_t i = 0;
|
||||
if (BitStream[10]>1){ //allow only 1s and 0s
|
||||
// PrintAndLog("no data found");
|
||||
return 0;
|
||||
}
|
||||
uint8_t parityTest=0;
|
||||
// 111111111 bit pattern represent start of frame
|
||||
uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
|
||||
uint32_t idx = 0;
|
||||
uint32_t ii=0;
|
||||
uint8_t resetCnt = 0;
|
||||
while( (idx + 64) < *size) {
|
||||
restart:
|
||||
// search for a start of frame marker
|
||||
if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
|
||||
{ // frame marker found
|
||||
*startIdx=idx;
|
||||
idx+=9;
|
||||
for (i=0; i<10;i++){
|
||||
for(ii=0; ii<5; ++ii){
|
||||
parityTest ^= BitStream[(i*5)+ii+idx];
|
||||
}
|
||||
if (!parityTest){ //even parity
|
||||
parityTest=0;
|
||||
for (ii=0; ii<4;++ii){
|
||||
lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
|
||||
}
|
||||
//PrintAndLog("DEBUG: EM parity passed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d,lo: %d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1],lo);
|
||||
}else {//parity failed
|
||||
//PrintAndLog("DEBUG: EM parity failed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1]);
|
||||
parityTest=0;
|
||||
idx-=8;
|
||||
if (resetCnt>5)return 0; //try 5 times
|
||||
resetCnt++;
|
||||
goto restart;//continue;
|
||||
}
|
||||
}
|
||||
//skip last 5 bit parity test for simplicity.
|
||||
*size = 64;
|
||||
return lo;
|
||||
}else{
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
//no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
|
||||
// otherwise could be a void with no arguments
|
||||
//set defaults
|
||||
uint64_t lo=0;
|
||||
uint32_t i = 0;
|
||||
if (BitStream[1]>1){ //allow only 1s and 0s
|
||||
// PrintAndLog("no data found");
|
||||
return 0;
|
||||
}
|
||||
// 111111111 bit pattern represent start of frame
|
||||
uint8_t preamble[] = {1,1,1,1,1,1,1,1,1};
|
||||
uint32_t idx = 0;
|
||||
uint32_t parityBits = 0;
|
||||
uint8_t errChk = 0;
|
||||
*startIdx = 0;
|
||||
for (uint8_t extraBitChk=0; extraBitChk<5; extraBitChk++){
|
||||
errChk = preambleSearch(BitStream+extraBitChk+*startIdx, preamble, sizeof(preamble), size, startIdx);
|
||||
if (errChk == 0) return 0;
|
||||
idx = *startIdx + 9;
|
||||
for (i=0; i<10;i++){ //loop through 10 sets of 5 bits (50-10p = 40 bits)
|
||||
parityBits = bytebits_to_byte(BitStream+(i*5)+idx,5);
|
||||
//check even parity
|
||||
if (parityTest(parityBits, 5, 0) == 0){
|
||||
//parity failed try next bit (in the case of 1111111111) but last 9 = preamble
|
||||
startIdx++;
|
||||
errChk = 0;
|
||||
break;
|
||||
}
|
||||
for (uint8_t ii=0; ii<4; ii++){
|
||||
lo = (lo << 1LL) | (BitStream[(i*5)+ii+idx]);
|
||||
}
|
||||
}
|
||||
if (errChk != 0) return lo;
|
||||
//skip last 5 bit parity test for simplicity.
|
||||
// *size = 64;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
|
|
@ -537,114 +572,69 @@ int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t
|
|||
size = aggregate_bits(dest, size, rfLen, 192, invert, fchigh, fclow);
|
||||
return size;
|
||||
}
|
||||
|
||||
// loop to get raw HID waveform then FSK demodulate the TAG ID from it
|
||||
int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
|
||||
{
|
||||
if (justNoise(dest, *size)) return -1;
|
||||
|
||||
size_t idx=0, size2=*size, startIdx=0;
|
||||
// FSK demodulator
|
||||
size_t numStart=0, size2=*size, startIdx=0;
|
||||
// FSK demodulator
|
||||
*size = fskdemod(dest, size2,50,1,10,8); //fsk2a
|
||||
if (*size < 96) return -2;
|
||||
// 00011101 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1
|
||||
uint8_t preamble[] = {0,0,0,1,1,1,0,1};
|
||||
// find bitstring in array
|
||||
uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx);
|
||||
if (errChk == 0) return -3; //preamble not found
|
||||
|
||||
*size = fskdemod(dest, size2,50,0,10,8);
|
||||
|
||||
// final loop, go over previously decoded manchester data and decode into usable tag ID
|
||||
// 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
|
||||
uint8_t frame_marker_mask[] = {1,1,1,0,0,0};
|
||||
int numshifts = 0;
|
||||
idx = 0;
|
||||
//one scan
|
||||
while( idx + sizeof(frame_marker_mask) < *size) {
|
||||
// search for a start of frame marker
|
||||
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
|
||||
{ // frame marker found
|
||||
startIdx=idx;
|
||||
idx+=sizeof(frame_marker_mask);
|
||||
while(dest[idx] != dest[idx+1] && idx < *size-2)
|
||||
{
|
||||
// Keep going until next frame marker (or error)
|
||||
// Shift in a bit. Start by shifting high registers
|
||||
*hi2 = (*hi2<<1)|(*hi>>31);
|
||||
*hi = (*hi<<1)|(*lo>>31);
|
||||
//Then, shift in a 0 or one into low
|
||||
if (dest[idx] && !dest[idx+1]) // 1 0
|
||||
*lo=(*lo<<1)|0;
|
||||
else // 0 1
|
||||
*lo=(*lo<<1)|1;
|
||||
numshifts++;
|
||||
idx += 2;
|
||||
}
|
||||
// Hopefully, we read a tag and hit upon the next frame marker
|
||||
if(idx + sizeof(frame_marker_mask) < *size)
|
||||
{
|
||||
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
|
||||
{
|
||||
//good return
|
||||
*size=idx-startIdx;
|
||||
return startIdx;
|
||||
}
|
||||
}
|
||||
// reset
|
||||
*hi2 = *hi = *lo = 0;
|
||||
numshifts = 0;
|
||||
}else {
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
numStart = startIdx + sizeof(preamble);
|
||||
// final loop, go over previously decoded FSK data and manchester decode into usable tag ID
|
||||
for (size_t idx = numStart; (idx-numStart) < *size - sizeof(preamble); idx+=2){
|
||||
if (dest[idx] == dest[idx+1]){
|
||||
return -4; //not manchester data
|
||||
}
|
||||
*hi2 = (*hi2<<1)|(*hi>>31);
|
||||
*hi = (*hi<<1)|(*lo>>31);
|
||||
//Then, shift in a 0 or one into low
|
||||
if (dest[idx] && !dest[idx+1]) // 1 0
|
||||
*lo=(*lo<<1)|1;
|
||||
else // 0 1
|
||||
*lo=(*lo<<1)|0;
|
||||
}
|
||||
return (int)startIdx;
|
||||
}
|
||||
|
||||
// loop to get raw paradox waveform then FSK demodulate the TAG ID from it
|
||||
size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
|
||||
int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
|
||||
{
|
||||
|
||||
size_t idx=0, size2=*size;
|
||||
if (justNoise(dest, *size)) return -1;
|
||||
|
||||
size_t numStart=0, size2=*size, startIdx=0;
|
||||
// FSK demodulator
|
||||
*size = fskdemod(dest, size2,50,1,10,8); //fsk2a
|
||||
if (*size < 96) return -2;
|
||||
|
||||
*size = fskdemod(dest, size2,50,1,10,8);
|
||||
// 00001111 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1
|
||||
uint8_t preamble[] = {0,0,0,0,1,1,1,1};
|
||||
|
||||
// final loop, go over previously decoded manchester data and decode into usable tag ID
|
||||
// 00001111 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
|
||||
uint8_t frame_marker_mask[] = {0,0,0,0,1,1,1,1};
|
||||
uint16_t numshifts = 0;
|
||||
idx = 0;
|
||||
//one scan
|
||||
while( idx + sizeof(frame_marker_mask) < *size) {
|
||||
// search for a start of frame marker
|
||||
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
|
||||
{ // frame marker found
|
||||
size2=idx;
|
||||
idx+=sizeof(frame_marker_mask);
|
||||
while(dest[idx] != dest[idx+1] && idx < *size-2)
|
||||
{
|
||||
// Keep going until next frame marker (or error)
|
||||
// Shift in a bit. Start by shifting high registers
|
||||
*hi2 = (*hi2<<1)|(*hi>>31);
|
||||
*hi = (*hi<<1)|(*lo>>31);
|
||||
//Then, shift in a 0 or one into low
|
||||
if (dest[idx] && !dest[idx+1]) // 1 0
|
||||
*lo=(*lo<<1)|1;
|
||||
else // 0 1
|
||||
*lo=(*lo<<1)|0;
|
||||
numshifts++;
|
||||
idx += 2;
|
||||
}
|
||||
// Hopefully, we read a tag and hit upon the next frame marker and got enough bits
|
||||
if(idx + sizeof(frame_marker_mask) < *size && numshifts > 40)
|
||||
{
|
||||
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
|
||||
{
|
||||
//good return - return start grid position and bits found
|
||||
*size = ((numshifts*2)+8);
|
||||
return size2;
|
||||
}
|
||||
}
|
||||
// reset
|
||||
*hi2 = *hi = *lo = 0;
|
||||
numshifts = 0;
|
||||
}else {
|
||||
idx++;
|
||||
}
|
||||
uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx);
|
||||
if (errChk == 0) return -3; //preamble not found
|
||||
|
||||
numStart = startIdx + sizeof(preamble);
|
||||
// final loop, go over previously decoded FSK data and manchester decode into usable tag ID
|
||||
for (size_t idx = numStart; (idx-numStart) < *size - sizeof(preamble); idx+=2){
|
||||
if (dest[idx] == dest[idx+1])
|
||||
return -4; //not manchester data
|
||||
*hi2 = (*hi2<<1)|(*hi>>31);
|
||||
*hi = (*hi<<1)|(*lo>>31);
|
||||
//Then, shift in a 0 or one into low
|
||||
if (dest[idx] && !dest[idx+1]) // 1 0
|
||||
*lo=(*lo<<1)|1;
|
||||
else // 0 1
|
||||
*lo=(*lo<<1)|0;
|
||||
}
|
||||
return 0;
|
||||
return (int)startIdx;
|
||||
}
|
||||
|
||||
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
|
||||
|
|
@ -660,20 +650,12 @@ uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
|
|||
|
||||
int IOdemodFSK(uint8_t *dest, size_t size)
|
||||
{
|
||||
static const uint8_t THRESHOLD = 129;
|
||||
uint32_t idx=0;
|
||||
if (justNoise(dest, size)) return -1;
|
||||
//make sure buffer has data
|
||||
if (size < 66) return -1;
|
||||
//test samples are not just noise
|
||||
uint8_t justNoise = 1;
|
||||
for(idx=0;idx< size && justNoise ;idx++){
|
||||
justNoise = dest[idx] < THRESHOLD;
|
||||
}
|
||||
if(justNoise) return 0;
|
||||
|
||||
if (size < 66*64) return -2;
|
||||
// FSK demodulator
|
||||
size = fskdemod(dest, size, 64, 1, 10, 8); // RF/64 and invert
|
||||
if (size < 65) return -1; //did we get a good demod?
|
||||
size = fskdemod(dest, size, 64, 1, 10, 8); // FSK2a RF/64
|
||||
if (size < 65) return -3; //did we get a good demod?
|
||||
//Index map
|
||||
//0 10 20 30 40 50 60
|
||||
//| | | | | | |
|
||||
|
|
@ -683,31 +665,17 @@ int IOdemodFSK(uint8_t *dest, size_t size)
|
|||
//
|
||||
//XSF(version)facility:codeone+codetwo
|
||||
//Handle the data
|
||||
uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
|
||||
for( idx=0; idx < (size - 65); idx++) {
|
||||
if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
|
||||
//frame marker found
|
||||
if (!dest[idx+8] && dest[idx+17]==1 && dest[idx+26]==1 && dest[idx+35]==1 && dest[idx+44]==1 && dest[idx+53]==1){
|
||||
//confirmed proper separator bits found
|
||||
//return start position
|
||||
return (int) idx;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
size_t startIdx = 0;
|
||||
uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,1};
|
||||
uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), &size, &startIdx);
|
||||
if (errChk == 0) return -4; //preamble not found
|
||||
|
||||
// by marshmellow
|
||||
// pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType
|
||||
// returns 1 if passed
|
||||
uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
|
||||
{
|
||||
uint8_t ans = 0;
|
||||
for (uint8_t i = 0; i < bitLen; i++){
|
||||
ans ^= ((bits >> i) & 1);
|
||||
if (!dest[startIdx+8] && dest[startIdx+17]==1 && dest[startIdx+26]==1 && dest[startIdx+35]==1 && dest[startIdx+44]==1 && dest[startIdx+53]==1){
|
||||
//confirmed proper separator bits found
|
||||
//return start position
|
||||
return (int) startIdx;
|
||||
}
|
||||
//PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType);
|
||||
return (ans == pType);
|
||||
return -5;
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
|
|
@ -735,70 +703,45 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
|
|||
|
||||
// by marshmellow
|
||||
// FSK Demod then try to locate an AWID ID
|
||||
int AWIDdemodFSK(uint8_t *dest, size_t size)
|
||||
int AWIDdemodFSK(uint8_t *dest, size_t *size)
|
||||
{
|
||||
static const uint8_t THRESHOLD = 123;
|
||||
uint32_t idx=0, idx2=0;
|
||||
//make sure buffer has data
|
||||
if (size < 96*50) return -1;
|
||||
//test samples are not just noise
|
||||
uint8_t justNoise = 1;
|
||||
for(idx=0; idx < size && justNoise ;idx++){
|
||||
justNoise = dest[idx] < THRESHOLD;
|
||||
}
|
||||
if(justNoise) return -2;
|
||||
//make sure buffer has enough data
|
||||
if (*size < 96*50) return -1;
|
||||
|
||||
if (justNoise(dest, *size)) return -2;
|
||||
|
||||
// FSK demodulator
|
||||
size = fskdemod(dest, size, 50, 1, 10, 8); // RF/64 and invert
|
||||
if (size < 96) return -3; //did we get a good demod?
|
||||
*size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50
|
||||
if (*size < 96) return -3; //did we get a good demod?
|
||||
|
||||
uint8_t mask[] = {0,0,0,0,0,0,0,1};
|
||||
for( idx=0; idx < (size - 96); idx++) {
|
||||
if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
|
||||
// frame marker found
|
||||
//return ID start index
|
||||
if (idx2 == 0) idx2=idx;
|
||||
else if(idx-idx2==96) return idx2;
|
||||
else return -5;
|
||||
|
||||
// should always get 96 bits if it is awid
|
||||
}
|
||||
}
|
||||
//never found mask
|
||||
return -4;
|
||||
uint8_t preamble[] = {0,0,0,0,0,0,0,1};
|
||||
size_t startIdx = 0;
|
||||
uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx);
|
||||
if (errChk == 0) return -4; //preamble not found
|
||||
if (*size != 96) return -5;
|
||||
return (int)startIdx;
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
// FSK Demod then try to locate an Farpointe Data (pyramid) ID
|
||||
int PyramiddemodFSK(uint8_t *dest, size_t size)
|
||||
int PyramiddemodFSK(uint8_t *dest, size_t *size)
|
||||
{
|
||||
static const uint8_t THRESHOLD = 123;
|
||||
uint32_t idx=0, idx2=0;
|
||||
// size_t size2 = size;
|
||||
//make sure buffer has data
|
||||
if (size < 128*50) return -5;
|
||||
if (*size < 128*50) return -5;
|
||||
|
||||
//test samples are not just noise
|
||||
uint8_t justNoise = 1;
|
||||
for(idx=0; idx < size && justNoise ;idx++){
|
||||
justNoise = dest[idx] < THRESHOLD;
|
||||
}
|
||||
if(justNoise) return -1;
|
||||
if (justNoise(dest, *size)) return -1;
|
||||
|
||||
// FSK demodulator
|
||||
size = fskdemod(dest, size, 50, 1, 10, 8); // RF/64 and invert
|
||||
if (size < 128) return -2; //did we get a good demod?
|
||||
*size = fskdemod(dest, *size, 50, 1, 10, 8); // fsk2a RF/50
|
||||
if (*size < 128) return -2; //did we get a good demod?
|
||||
|
||||
uint8_t mask[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
|
||||
for( idx=0; idx < (size - 128); idx++) {
|
||||
if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
|
||||
// frame marker found
|
||||
if (idx2==0) idx2=idx;
|
||||
else if (idx-idx2==128) return idx2;
|
||||
else return -3;
|
||||
}
|
||||
}
|
||||
//never found mask
|
||||
return -4;
|
||||
uint8_t preamble[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
|
||||
size_t startIdx = 0;
|
||||
uint8_t errChk = preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx);
|
||||
if (errChk == 0) return -4; //preamble not found
|
||||
if (*size != 128) return -3;
|
||||
return (int)startIdx;
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
|
|
@ -1068,6 +1011,7 @@ int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert)
|
|||
// peaks invert bit (high=1 low=0) each clock cycle = 1 bit determined by last peak
|
||||
int pskNRZrawDemod(uint8_t *dest, size_t *size, int *clk, int *invert)
|
||||
{
|
||||
if (justNoise(dest, *size)) return -1;
|
||||
pskCleanWave(dest,*size);
|
||||
int clk2 = DetectpskNRZClock(dest, *size, *clk);
|
||||
*clk=clk2;
|
||||
|
|
|
|||
|
|
@ -31,12 +31,15 @@ void psk1TOpsk2(uint8_t *BitStream, size_t size);
|
|||
int DetectpskNRZClock(uint8_t dest[], size_t size, int clock);
|
||||
int indala26decode(uint8_t *bitStream, size_t *size, uint8_t *invert);
|
||||
void pskCleanWave(uint8_t *bitStream, size_t size);
|
||||
int PyramiddemodFSK(uint8_t *dest, size_t size);
|
||||
int AWIDdemodFSK(uint8_t *dest, size_t size);
|
||||
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 detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow);
|
||||
int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo);
|
||||
size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
|
||||
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);
|
||||
uint8_t justNoise(uint8_t *BitStream, size_t size);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue