mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-08-14 18:48:13 -07:00
Merge branch 'master' of https://github.com/Proxmark/proxmark3
Conflicts: armsrc/lfops.c client/cmddata.c client/cmdlf.c client/cmdlft55xx.c client/cmdlft55xx.h client/scripts/test_t55x7_bi.lua
This commit is contained in:
iceman1001
commit
0ec548dc21
30 changed files with 1261 additions and 806 deletions
|
|
@ -71,8 +71,6 @@ LDFLAGS = -nostartfiles -nodefaultlibs -Wl,-gc-sections -n
|
|||
|
||||
LIBS = -lgcc
|
||||
|
||||
LIBS = -lgcc
|
||||
|
||||
THUMBOBJ = $(patsubst %.c,$(OBJDIR)/%.o,$(THUMBSRC))
|
||||
ARMOBJ = $(ARMSRC:%.c=$(OBJDIR)/%.o)
|
||||
ASMOBJ = $(patsubst %.s,$(OBJDIR)/%.o,$(ASMSRC))
|
||||
|
|
|
|||
267
common/lfdemod.c
267
common/lfdemod.c
|
|
@ -75,51 +75,6 @@ uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//by marshmellow
|
||||
//takes 1s and 0s and searches for EM410x format - output EM ID
|
||||
uint64_t Em410xDecodeOld(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[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;
|
||||
}
|
||||
//set uint64 with ID from BitStream
|
||||
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
|
||||
//takes 1s and 0s and searches for EM410x format - output EM ID
|
||||
uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo)
|
||||
|
|
@ -144,6 +99,7 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
|
|||
if (errChk == 0) return 0;
|
||||
if (*size<64) return 0;
|
||||
if (*size>64) FmtLen = 22;
|
||||
if (*size<64) return 0;
|
||||
idx = *startIdx + 9;
|
||||
for (i=0; i<FmtLen; i++){ //loop through 10 or 22 sets of 5 bits (50-10p = 40 bits or 88 bits)
|
||||
parityBits = bytebits_to_byte(BitStream+(i*5)+idx,5);
|
||||
|
|
@ -309,16 +265,12 @@ int ManchesterEncode(uint8_t *BitStream, size_t size)
|
|||
//run through 2 times and take least errCnt
|
||||
int manrawdecode(uint8_t * BitStream, size_t *size)
|
||||
{
|
||||
uint16_t bitnum=0;
|
||||
uint16_t MaxBits = 500;
|
||||
uint16_t errCnt = 0;
|
||||
size_t i=1;
|
||||
uint16_t bestErr = 1000;
|
||||
uint16_t bestRun = 0;
|
||||
size_t ii=1;
|
||||
uint16_t bitnum=0, MaxBits = 512, errCnt = 0;
|
||||
size_t i, ii;
|
||||
uint16_t bestErr = 1000, bestRun = 0;
|
||||
if (size == 0) return -1;
|
||||
for (ii=1;ii<3;++ii){
|
||||
i=1;
|
||||
for (ii=0;ii<2;++ii){
|
||||
i=0;
|
||||
for (i=i+ii;i<*size-2;i+=2){
|
||||
if(BitStream[i]==1 && (BitStream[i+1]==0)){
|
||||
} else if((BitStream[i]==0)&& BitStream[i+1]==1){
|
||||
|
|
@ -336,7 +288,7 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
|
|||
errCnt=bestErr;
|
||||
if (errCnt<20){
|
||||
ii=bestRun;
|
||||
i=1;
|
||||
i=0;
|
||||
for (i=i+ii; i < *size-2; i+=2){
|
||||
if(BitStream[i] == 1 && (BitStream[i+1] == 0)){
|
||||
BitStream[bitnum++]=0;
|
||||
|
|
@ -356,6 +308,7 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
|
|||
//by marshmellow
|
||||
//take 01 or 10 = 1 and 11 or 00 = 0
|
||||
//check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010
|
||||
//decodes biphase or if inverted it is AKA conditional dephase encoding AKA differential manchester encoding
|
||||
int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
|
||||
{
|
||||
uint16_t bitnum=0;
|
||||
|
|
@ -373,7 +326,7 @@ int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
|
|||
if (!offsetA && offsetB) offset++;
|
||||
for (i=offset; i<*size-3; i+=2){
|
||||
//check for phase error
|
||||
if (i<*size-3 && BitStream[i+1]==BitStream[i+2]) {
|
||||
if (BitStream[i+1]==BitStream[i+2]) {
|
||||
BitStream[bitnum++]=77;
|
||||
errCnt++;
|
||||
}
|
||||
|
|
@ -413,6 +366,56 @@ void askAmp(uint8_t *BitStream, size_t size)
|
|||
return;
|
||||
}
|
||||
|
||||
int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low)
|
||||
{
|
||||
size_t bitCnt=0, smplCnt=0, errCnt=0;
|
||||
uint8_t waveHigh = 0;
|
||||
//PrintAndLog("clk: %d", clk);
|
||||
for (size_t i=0; i < *size; i++){
|
||||
if (BinStream[i] >= high && waveHigh){
|
||||
smplCnt++;
|
||||
} else if (BinStream[i] <= low && !waveHigh){
|
||||
smplCnt++;
|
||||
} else { //transition
|
||||
if ((BinStream[i] >= high && !waveHigh) || (BinStream[i] <= low && waveHigh)){
|
||||
if (smplCnt > clk-(clk/4)-1) { //full clock
|
||||
if (smplCnt > clk + (clk/4)+1) { //too many samples
|
||||
errCnt++;
|
||||
BinStream[bitCnt++]=77;
|
||||
} else if (waveHigh) {
|
||||
BinStream[bitCnt++] = invert;
|
||||
BinStream[bitCnt++] = invert;
|
||||
} else if (!waveHigh) {
|
||||
BinStream[bitCnt++] = invert ^ 1;
|
||||
BinStream[bitCnt++] = invert ^ 1;
|
||||
}
|
||||
waveHigh ^= 1;
|
||||
smplCnt = 0;
|
||||
} else if (smplCnt > (clk/2) - (clk/4)-1) {
|
||||
if (waveHigh) {
|
||||
BinStream[bitCnt++] = invert;
|
||||
} else if (!waveHigh) {
|
||||
BinStream[bitCnt++] = invert ^ 1;
|
||||
}
|
||||
waveHigh ^= 1;
|
||||
smplCnt = 0;
|
||||
} else if (!bitCnt) {
|
||||
//first bit
|
||||
waveHigh = (BinStream[i] >= high);
|
||||
smplCnt = 1;
|
||||
} else {
|
||||
smplCnt++;
|
||||
//transition bit oops
|
||||
}
|
||||
} else { //haven't hit new high or new low yet
|
||||
smplCnt++;
|
||||
}
|
||||
}
|
||||
}
|
||||
*size = bitCnt;
|
||||
return errCnt;
|
||||
}
|
||||
|
||||
//by marshmellow
|
||||
//takes 3 arguments - clock, invert and maxErr as integers
|
||||
//attempts to demodulate ask only
|
||||
|
|
@ -424,15 +427,22 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int max
|
|||
if (*clk==0) return -1;
|
||||
if (start<0) return -1;
|
||||
if (*invert != 0 && *invert != 1) *invert =0;
|
||||
if (amp==1) askAmp(BinStream, *size);
|
||||
|
||||
uint32_t initLoopMax = 200;
|
||||
if (initLoopMax > *size) initLoopMax=*size;
|
||||
// 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]
|
||||
uint8_t clip = 75;
|
||||
int high, low, ans;
|
||||
if (amp==1) askAmp(BinStream, *size);
|
||||
ans = getHiLo(BinStream, initLoopMax, &high, &low, 75, 75);
|
||||
ans = getHiLo(BinStream, initLoopMax, &high, &low, clip, clip);
|
||||
if (ans<1) return -1; //just noise
|
||||
|
||||
if (DetectCleanAskWave(BinStream, *size, high, low)) {
|
||||
//PrintAndLog("Clean");
|
||||
return cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
|
||||
}
|
||||
|
||||
//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
|
||||
int lastBit = 0; //set first clock check
|
||||
uint32_t bitnum = 0; //output counter
|
||||
|
|
@ -444,12 +454,13 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int max
|
|||
uint32_t gLen = *size;
|
||||
if (gLen > 500) gLen=500;
|
||||
//if 0 errors allowed then only try first 2 clock cycles as we want a low tolerance
|
||||
if (!maxErr) gLen=*clk*2;
|
||||
if (!maxErr) gLen = *clk * 2;
|
||||
uint8_t errCnt =0;
|
||||
uint32_t bestStart = *size;
|
||||
uint32_t bestErrCnt = maxErr; //(*size/1000);
|
||||
uint8_t midBit=0;
|
||||
uint16_t MaxBits=1000;
|
||||
|
||||
//PrintAndLog("DEBUG - lastbit - %d",lastBit);
|
||||
//loop to find first wave that works
|
||||
for (iii=start; iii < gLen; ++iii){
|
||||
|
|
@ -620,7 +631,9 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
//do nothing with extra garbage
|
||||
} else if ((idx-last_transition) < (fchigh-1)) { //6-8 = 8 waves
|
||||
dest[numBits]=1;
|
||||
} else { //9+ = 10 waves
|
||||
} else if ((idx-last_transition) > (fchigh+1) && !numBits) { //12 + and first bit = garbage
|
||||
//do nothing with beginning garbage
|
||||
} else { //9+ = 10 waves
|
||||
dest[numBits]=0;
|
||||
}
|
||||
last_transition = idx;
|
||||
|
|
@ -644,18 +657,31 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t maxCons
|
|||
uint32_t idx=0;
|
||||
size_t numBits=0;
|
||||
uint32_t n=1;
|
||||
|
||||
float lowWaves = (((float)(rfLen))/((float)fclow));
|
||||
float highWaves = (((float)(rfLen))/((float)fchigh));
|
||||
for( idx=1; idx < size; idx++) {
|
||||
|
||||
if (dest[idx]==lastval) {
|
||||
n++;
|
||||
continue;
|
||||
}
|
||||
n++;
|
||||
//if lastval was 1, we have a 1->0 crossing
|
||||
if ( dest[idx-1]==1 ) {
|
||||
n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));
|
||||
} else {// 0->1 crossing
|
||||
n=myround2((float)(n+1)/((float)(rfLen-1)/(float)fchigh)); //-1 for fudge factor
|
||||
if (dest[idx-1]==1) {
|
||||
if (!numBits && n < (uint8_t)lowWaves) {
|
||||
n=0;
|
||||
lastval = dest[idx];
|
||||
continue;
|
||||
}
|
||||
n=myround2(((float)n)/lowWaves);
|
||||
} else {// 0->1 crossing
|
||||
//test first bitsample too small
|
||||
if (!numBits && n < (uint8_t)highWaves) {
|
||||
n=0;
|
||||
lastval = dest[idx];
|
||||
continue;
|
||||
}
|
||||
n = myround2(((float)n)/highWaves); //-1 for fudge factor
|
||||
}
|
||||
if (n == 0) n = 1;
|
||||
|
||||
|
|
@ -671,6 +697,17 @@ size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t maxCons
|
|||
n=0;
|
||||
lastval=dest[idx];
|
||||
}//end for
|
||||
|
||||
// if valid extra bits at the end were all the same frequency - add them in
|
||||
if (n > lowWaves && n > highWaves) {
|
||||
if (dest[idx-2]==1) {
|
||||
n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));
|
||||
} else {
|
||||
n=myround2((float)(n+1)/((float)(rfLen-1)/(float)fchigh)); //-1 for fudge factor
|
||||
}
|
||||
memset(dest, dest[idx-1]^invert , n);
|
||||
numBits += n;
|
||||
}
|
||||
return numBits;
|
||||
}
|
||||
//by marshmellow (from holiman's base)
|
||||
|
|
@ -857,20 +894,70 @@ int PyramiddemodFSK(uint8_t *dest, size_t *size)
|
|||
|
||||
uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, int high, int low)
|
||||
{
|
||||
uint8_t allPeaks=1;
|
||||
uint16_t allPeaks=1;
|
||||
uint16_t cntPeaks=0;
|
||||
for (size_t i=20; i<255; i++){
|
||||
size_t loopEnd = 572;
|
||||
if (loopEnd > size) loopEnd = size;
|
||||
for (size_t i=60; i<loopEnd; i++){
|
||||
if (dest[i]>low && dest[i]<high)
|
||||
allPeaks=0;
|
||||
else
|
||||
cntPeaks++;
|
||||
}
|
||||
if (allPeaks==0){
|
||||
if (cntPeaks>190) return 1;
|
||||
if (allPeaks == 0){
|
||||
if (cntPeaks > 300) return 1;
|
||||
}
|
||||
return allPeaks;
|
||||
}
|
||||
|
||||
int DetectStrongAskClock(uint8_t dest[], size_t size)
|
||||
{
|
||||
int clk[]={0,8,16,32,40,50,64,100,128,256};
|
||||
size_t idx = 40;
|
||||
uint8_t high=0;
|
||||
size_t cnt = 0;
|
||||
size_t highCnt = 0;
|
||||
size_t highCnt2 = 0;
|
||||
for (;idx < size; idx++){
|
||||
if (dest[idx]>128) {
|
||||
if (!high){
|
||||
high=1;
|
||||
if (cnt > highCnt){
|
||||
if (highCnt != 0) highCnt2 = highCnt;
|
||||
highCnt = cnt;
|
||||
} else if (cnt > highCnt2) {
|
||||
highCnt2 = cnt;
|
||||
}
|
||||
cnt=1;
|
||||
} else {
|
||||
cnt++;
|
||||
}
|
||||
} else if (dest[idx] <= 128){
|
||||
if (high) {
|
||||
high=0;
|
||||
if (cnt > highCnt) {
|
||||
if (highCnt != 0) highCnt2 = highCnt;
|
||||
highCnt = cnt;
|
||||
} else if (cnt > highCnt2) {
|
||||
highCnt2 = cnt;
|
||||
}
|
||||
cnt=1;
|
||||
} else {
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
}
|
||||
uint8_t tol;
|
||||
for (idx=8; idx>0; idx--){
|
||||
tol = clk[idx]/8;
|
||||
if (clk[idx] >= highCnt - tol && clk[idx] <= highCnt + tol)
|
||||
return clk[idx];
|
||||
if (clk[idx] >= highCnt2 - tol && clk[idx] <= highCnt2 + tol)
|
||||
return clk[idx];
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 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?
|
||||
|
|
@ -893,24 +980,14 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
|
|||
|
||||
//test for large clean peaks
|
||||
if (DetectCleanAskWave(dest, size, peak, low)==1){
|
||||
uint16_t fcTest=0;
|
||||
uint8_t mostFC=0;
|
||||
fcTest=countFC(dest, size, &mostFC);
|
||||
uint8_t fc1 = fcTest >> 8;
|
||||
uint8_t fc2 = fcTest & 0xFF;
|
||||
|
||||
for (i=0; i<8; i++){
|
||||
if (clk[i] == fc1) {
|
||||
*clock=fc1;
|
||||
return 0;
|
||||
}
|
||||
if (clk[i] == fc2) {
|
||||
*clock=fc2;
|
||||
int ans = DetectStrongAskClock(dest, size);
|
||||
for (i=7; i>0; i--){
|
||||
if (clk[i] == ans) {
|
||||
*clock=ans;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int ii;
|
||||
int clkCnt;
|
||||
int tol = 0;
|
||||
|
|
@ -924,6 +1001,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
|
|||
}else{
|
||||
tol=0;
|
||||
}
|
||||
if (!maxErr) loopCnt=clk[clkCnt]*2;
|
||||
bestErr[clkCnt]=1000;
|
||||
//try lining up the peaks by moving starting point (try first 256)
|
||||
for (ii=0; ii < loopCnt; ii++){
|
||||
|
|
@ -1243,11 +1321,10 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
*clk = DetectNRZClock(dest, *size, *clk);
|
||||
if (*clk==0) return -2;
|
||||
uint32_t i;
|
||||
int high, low, ans;
|
||||
ans = getHiLo(dest, 1260, &high, &low, 75, 75); //25% fuzz on high 25% fuzz on low
|
||||
if (ans<1) return -2; //just noise
|
||||
uint32_t gLen = 256;
|
||||
uint32_t gLen = 4096;
|
||||
if (gLen>*size) gLen = *size;
|
||||
int high, low;
|
||||
if (getHiLo(dest, gLen, &high, &low, 75, 75) < 1) return -3; //25% fuzz on high 25% fuzz on low
|
||||
int lastBit = 0; //set first clock check
|
||||
uint32_t bitnum = 0; //output counter
|
||||
uint8_t tol = 1; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
|
||||
|
|
@ -1257,6 +1334,8 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
uint32_t bestErrCnt = maxErr+1;
|
||||
uint32_t bestPeakCnt = 0;
|
||||
uint32_t bestPeakStart=0;
|
||||
uint8_t bestFirstPeakHigh=0;
|
||||
uint8_t firstPeakHigh=0;
|
||||
uint8_t curBit=0;
|
||||
uint8_t bitHigh=0;
|
||||
uint8_t errBitHigh=0;
|
||||
|
|
@ -1266,6 +1345,8 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
//loop to find first wave that works - align to clock
|
||||
for (iii=0; iii < gLen; ++iii){
|
||||
if ((dest[iii]>=high) || (dest[iii]<=low)){
|
||||
if (dest[iii]>=high) firstPeakHigh=1;
|
||||
else firstPeakHigh=0;
|
||||
lastBit=iii-*clk;
|
||||
peakCnt=0;
|
||||
errCnt=0;
|
||||
|
|
@ -1316,6 +1397,7 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
//possible good read
|
||||
if (errCnt == 0){
|
||||
//bestStart = iii;
|
||||
bestFirstPeakHigh=firstPeakHigh;
|
||||
bestErrCnt = errCnt;
|
||||
bestPeakCnt = peakCnt;
|
||||
bestPeakStart = iii;
|
||||
|
|
@ -1326,6 +1408,7 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
//bestStart = iii;
|
||||
}
|
||||
if (peakCnt > bestPeakCnt){
|
||||
bestFirstPeakHigh=firstPeakHigh;
|
||||
bestPeakCnt=peakCnt;
|
||||
bestPeakStart=iii;
|
||||
}
|
||||
|
|
@ -1338,6 +1421,8 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
iii=bestPeakStart;
|
||||
lastBit=bestPeakStart-*clk;
|
||||
bitnum=0;
|
||||
memset(dest, bestFirstPeakHigh^1, bestPeakStart / *clk);
|
||||
bitnum += (bestPeakStart / *clk);
|
||||
for (i = iii; i < *size; ++i) {
|
||||
//if we found a high bar and we are at a clock bit
|
||||
if ((dest[i] >= high ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){
|
||||
|
|
@ -1387,12 +1472,12 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert, int maxErr)
|
|||
*size=bitnum;
|
||||
} else{
|
||||
*size=bitnum;
|
||||
return -1;
|
||||
return bestErrCnt;
|
||||
}
|
||||
|
||||
if (bitnum>16){
|
||||
*size=bitnum;
|
||||
} else return -1;
|
||||
} else return -5;
|
||||
return errCnt;
|
||||
}
|
||||
|
||||
|
|
@ -1690,7 +1775,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
errCnt=0;
|
||||
size_t numBits=0;
|
||||
//set skipped bits
|
||||
memset(dest+numBits,curPhase^1,firstFullWave / *clock);
|
||||
memset(dest,curPhase^1,firstFullWave / *clock);
|
||||
numBits += (firstFullWave / *clock);
|
||||
dest[numBits++] = curPhase; //set first read bit
|
||||
for (i = firstFullWave+fullWaveLen-1; i < *size-3; i++){
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
#include <stdint.h>
|
||||
|
||||
int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr);
|
||||
uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, int high, int 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);
|
||||
//uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx);
|
||||
|
|
@ -47,5 +48,6 @@ uint8_t justNoise(uint8_t *BitStream, size_t size);
|
|||
uint8_t countPSK_FC(uint8_t *BitStream, size_t size);
|
||||
int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert);
|
||||
int DetectPSKClock(uint8_t dest[], size_t size, int clock);
|
||||
void askAmp(uint8_t *BitStream, size_t size);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -168,9 +168,25 @@ NXP/Philips CUSTOM COMMANDS
|
|||
#define ISO15693_READ_MULTI_SECSTATUS 0x2C
|
||||
|
||||
|
||||
// Topaz command set:
|
||||
#define TOPAZ_REQA 0x26 // Request
|
||||
#define TOPAZ_WUPA 0x52 // WakeUp
|
||||
#define TOPAZ_RID 0x78 // Read ID
|
||||
#define TOPAZ_RALL 0x00 // Read All (all bytes)
|
||||
#define TOPAZ_READ 0x01 // Read (a single byte)
|
||||
#define TOPAZ_WRITE_E 0x53 // Write-with-erase (a single byte)
|
||||
#define TOPAZ_WRITE_NE 0x1a // Write-no-erase (a single byte)
|
||||
// additional commands for Dynamic Memory Model
|
||||
#define TOPAZ_RSEG 0x10 // Read segment
|
||||
#define TOPAZ_READ8 0x02 // Read (eight bytes)
|
||||
#define TOPAZ_WRITE_E8 0x54 // Write-with-erase (eight bytes)
|
||||
#define TOPAZ_WRITE_NE8 0x1B // Write-no-erase (eight bytes)
|
||||
|
||||
|
||||
#define ISO_14443A 0
|
||||
#define ICLASS 1
|
||||
#define ISO_14443B 2
|
||||
#define TOPAZ 3
|
||||
|
||||
//-- Picopass fuses
|
||||
#define FUSE_FPERS 0x80
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue