]> cvs.zerfleddert.de Git - proxmark3-svn/blob - common/lfdemod.c
144783198e1684a8be432a5abdcc5f5d296c5147
[proxmark3-svn] / common / lfdemod.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2014
3 //
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
6 // the license.
7 //-----------------------------------------------------------------------------
8 // Low frequency commands
9 //-----------------------------------------------------------------------------
10
11 #include <stdlib.h>
12 #include <string.h>
13 #include "lfdemod.h"
14
15 //by marshmellow
16 //takes 1s and 0s and searches for EM410x format - output EM ID
17 uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
18 {
19 //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
20 // otherwise could be a void with no arguments
21 //set defaults
22 int high=0, low=128;
23 uint64_t lo=0; //hi=0,
24
25 uint32_t i = 0;
26 uint32_t initLoopMax = 65;
27 if (initLoopMax>BitLen) initLoopMax=BitLen;
28
29 for (;i < initLoopMax; ++i) //65 samples should be plenty to find high and low values
30 {
31 if (BitStream[i] > high)
32 high = BitStream[i];
33 else if (BitStream[i] < low)
34 low = BitStream[i];
35 }
36 if (((high !=1)||(low !=0))){ //allow only 1s and 0s
37 // PrintAndLog("no data found");
38 return 0;
39 }
40 uint8_t parityTest=0;
41 // 111111111 bit pattern represent start of frame
42 uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
43 uint32_t idx = 0;
44 uint32_t ii=0;
45 uint8_t resetCnt = 0;
46 while( (idx + 64) < BitLen) {
47 restart:
48 // search for a start of frame marker
49 if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
50 { // frame marker found
51 idx+=9;//sizeof(frame_marker_mask);
52 for (i=0; i<10;i++){
53 for(ii=0; ii<5; ++ii){
54 parityTest += BitStream[(i*5)+ii+idx];
55 }
56 if (parityTest== ((parityTest>>1)<<1)){
57 parityTest=0;
58 for (ii=0; ii<4;++ii){
59 //hi = (hi<<1)|(lo>>31);
60 lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
61 }
62 //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);
63 }else {//parity failed
64 //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]);
65 parityTest=0;
66 idx-=8;
67 if (resetCnt>5)return 0;
68 resetCnt++;
69 goto restart;//continue;
70 }
71 }
72 //skip last 5 bit parity test for simplicity.
73 return lo;
74 }else{
75 idx++;
76 }
77 }
78 return 0;
79 }
80
81 //by marshmellow
82 //takes 2 arguments - clock and invert both as integers
83 //attempts to demodulate ask while decoding manchester
84 //prints binary found and saves in graphbuffer for further commands
85 int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
86 {
87 int i;
88 int high = 0, low = 128;
89 *clk=DetectASKClock(BinStream,(size_t)*BitLen,*clk); //clock default
90
91 if (*clk<8) *clk =64;
92 if (*clk<32) *clk=32;
93 if (*invert != 0 && *invert != 1) *invert=0;
94 uint32_t initLoopMax = 200;
95 if (initLoopMax>*BitLen) initLoopMax=*BitLen;
96 // Detect high and lows
97 for (i = 0; i < initLoopMax; ++i) //200 samples should be enough to find high and low values
98 {
99 if (BinStream[i] > high)
100 high = BinStream[i];
101 else if (BinStream[i] < low)
102 low = BinStream[i];
103 }
104 if ((high < 158) ){ //throw away static
105 //PrintAndLog("no data found");
106 return -2;
107 }
108 //25% fuzz in case highs and lows aren't clipped [marshmellow]
109 high=(int)((high-128)*.75)+128;
110 low= (int)((low-128)*.75)+128;
111
112 //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
113 int lastBit = 0; //set first clock check
114 uint32_t bitnum = 0; //output counter
115 int tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
116 if (*clk==32)tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely
117 int iii = 0;
118 uint32_t gLen = *BitLen;
119 if (gLen > 3000) gLen=3000;
120 uint8_t errCnt =0;
121 uint32_t bestStart = *BitLen;
122 uint32_t bestErrCnt = (*BitLen/1000);
123 uint32_t maxErr = (*BitLen/1000);
124 //PrintAndLog("DEBUG - lastbit - %d",lastBit);
125 //loop to find first wave that works
126 for (iii=0; iii < gLen; ++iii){
127 if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
128 lastBit=iii-*clk;
129 errCnt=0;
130 //loop through to see if this start location works
131 for (i = iii; i < *BitLen; ++i) {
132 if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
133 lastBit+=*clk;
134 } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
135 //low found and we are expecting a bar
136 lastBit+=*clk;
137 } else {
138 //mid value found or no bar supposed to be here
139 if ((i-lastBit)>(*clk+tol)){
140 //should have hit a high or low based on clock!!
141
142 //debug
143 //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit);
144
145 errCnt++;
146 lastBit+=*clk;//skip over until hit too many errors
147 if (errCnt>(maxErr)) break; //allow 1 error for every 1000 samples else start over
148 }
149 }
150 if ((i-iii) >(400 * *clk)) break; //got plenty of bits
151 }
152 //we got more than 64 good bits and not all errors
153 if ((((i-iii)/ *clk) > (64+errCnt)) && (errCnt<maxErr)) {
154 //possible good read
155 if (errCnt==0){
156 bestStart=iii;
157 bestErrCnt=errCnt;
158 break; //great read - finish
159 }
160 if (errCnt<bestErrCnt){ //set this as new best run
161 bestErrCnt=errCnt;
162 bestStart = iii;
163 }
164 }
165 }
166 }
167 if (bestErrCnt<maxErr){
168 //best run is good enough set to best run and set overwrite BinStream
169 iii=bestStart;
170 lastBit=bestStart-*clk;
171 bitnum=0;
172 for (i = iii; i < *BitLen; ++i) {
173 if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
174 lastBit+=*clk;
175 BinStream[bitnum] = *invert;
176 bitnum++;
177 } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
178 //low found and we are expecting a bar
179 lastBit+=*clk;
180 BinStream[bitnum] = 1-*invert;
181 bitnum++;
182 } else {
183 //mid value found or no bar supposed to be here
184 if ((i-lastBit)>(*clk+tol)){
185 //should have hit a high or low based on clock!!
186
187 //debug
188 //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit);
189 if (bitnum > 0){
190 BinStream[bitnum]=77;
191 bitnum++;
192 }
193
194 lastBit+=*clk;//skip over error
195 }
196 }
197 if (bitnum >=400) break;
198 }
199 *BitLen=bitnum;
200 } else{
201 *invert=bestStart;
202 *clk=iii;
203 return -1;
204 }
205 return bestErrCnt;
206 }
207
208 //by marshmellow
209 //take 10 and 01 and manchester decode
210 //run through 2 times and take least errCnt
211 int manrawdecode(uint8_t * BitStream, int *bitLen)
212 {
213 int bitnum=0;
214 int errCnt =0;
215 int i=1;
216 int bestErr = 1000;
217 int bestRun = 0;
218 int ii=1;
219 for (ii=1;ii<3;++ii){
220 i=1;
221 for (i=i+ii;i<*bitLen-2;i+=2){
222 if(BitStream[i]==1 && (BitStream[i+1]==0)){
223 } else if((BitStream[i]==0)&& BitStream[i+1]==1){
224 } else {
225 errCnt++;
226 }
227 if(bitnum>300) break;
228 }
229 if (bestErr>errCnt){
230 bestErr=errCnt;
231 bestRun=ii;
232 }
233 errCnt=0;
234 }
235 errCnt=bestErr;
236 if (errCnt<20){
237 ii=bestRun;
238 i=1;
239 for (i=i+ii;i<*bitLen-2;i+=2){
240 if(BitStream[i]==1 && (BitStream[i+1]==0)){
241 BitStream[bitnum++]=0;
242 } else if((BitStream[i]==0)&& BitStream[i+1]==1){
243 BitStream[bitnum++]=1;
244 } else {
245 BitStream[bitnum++]=77;
246 //errCnt++;
247 }
248 if(bitnum>300) break;
249 }
250 *bitLen=bitnum;
251 }
252 return errCnt;
253 }
254
255
256 //by marshmellow
257 //take 01 or 10 = 0 and 11 or 00 = 1
258 int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset)
259 {
260 uint8_t bitnum=0;
261 uint32_t errCnt =0;
262 uint32_t i=1;
263 i=offset;
264 for (;i<*bitLen-2;i+=2){
265 if((BitStream[i]==1 && BitStream[i+1]==0)||(BitStream[i]==0 && BitStream[i+1]==1)){
266 BitStream[bitnum++]=1;
267 } else if((BitStream[i]==0 && BitStream[i+1]==0)||(BitStream[i]==1 && BitStream[i+1]==1)){
268 BitStream[bitnum++]=0;
269 } else {
270 BitStream[bitnum++]=77;
271 errCnt++;
272 }
273 if(bitnum>250) break;
274 }
275 *bitLen=bitnum;
276 return errCnt;
277 }
278
279 //by marshmellow
280 //takes 2 arguments - clock and invert both as integers
281 //attempts to demodulate ask only
282 //prints binary found and saves in graphbuffer for further commands
283 int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
284 {
285 uint32_t i;
286 // int invert=0; //invert default
287 int high = 0, low = 128;
288 *clk=DetectASKClock(BinStream,*bitLen,*clk); //clock default
289 uint8_t BitStream[502] = {0};
290
291 if (*clk<8) *clk =64;
292 if (*clk<32) *clk=32;
293 if (*invert != 0 && *invert != 1) *invert =0;
294 uint32_t initLoopMax = 200;
295 if (initLoopMax>*bitLen) initLoopMax=*bitLen;
296 // Detect high and lows
297 for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values
298 {
299 if (BinStream[i] > high)
300 high = BinStream[i];
301 else if (BinStream[i] < low)
302 low = BinStream[i];
303 }
304 if ((high < 158)){ //throw away static
305 // PrintAndLog("no data found");
306 return -2;
307 }
308 //25% fuzz in case highs and lows aren't clipped [marshmellow]
309 high=(int)((high-128)*.75)+128;
310 low= (int)((low-128)*.75)+128;
311
312 //PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
313 int lastBit = 0; //set first clock check
314 uint32_t bitnum = 0; //output counter
315 uint8_t tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
316 if (*clk==32)tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely
317 uint32_t iii = 0;
318 uint32_t gLen = *bitLen;
319 if (gLen > 500) gLen=500;
320 uint8_t errCnt =0;
321 uint32_t bestStart = *bitLen;
322 uint32_t bestErrCnt = (*bitLen/1000);
323 uint8_t midBit=0;
324 //PrintAndLog("DEBUG - lastbit - %d",lastBit);
325 //loop to find first wave that works
326 for (iii=0; iii < gLen; ++iii){
327 if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
328 lastBit=iii-*clk;
329 //loop through to see if this start location works
330 for (i = iii; i < *bitLen; ++i) {
331 if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
332 lastBit+=*clk;
333 BitStream[bitnum] = *invert;
334 bitnum++;
335 midBit=0;
336 } else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
337 //low found and we are expecting a bar
338 lastBit+=*clk;
339 BitStream[bitnum] = 1-*invert;
340 bitnum++;
341 midBit=0;
342 } else if ((BinStream[i]<=low) && (midBit==0) && ((i-lastBit)>((*clk/2)-tol))){
343 //mid bar?
344 midBit=1;
345 BitStream[bitnum]= 1-*invert;
346 bitnum++;
347 } else if ((BinStream[i]>=high)&&(midBit==0) && ((i-lastBit)>((*clk/2)-tol))){
348 //mid bar?
349 midBit=1;
350 BitStream[bitnum]= *invert;
351 bitnum++;
352 } else if ((i-lastBit)>((*clk/2)+tol)&&(midBit==0)){
353 //no mid bar found
354 midBit=1;
355 BitStream[bitnum]= BitStream[bitnum-1];
356 bitnum++;
357 } else {
358 //mid value found or no bar supposed to be here
359
360 if ((i-lastBit)>(*clk+tol)){
361 //should have hit a high or low based on clock!!
362 //debug
363 //PrintAndLog("DEBUG - no wave in expected area - location: %d, expected: %d-%d, lastBit: %d - resetting search",i,(lastBit+(clk-((int)(tol)))),(lastBit+(clk+((int)(tol)))),lastBit);
364 if (bitnum > 0){
365 BitStream[bitnum]=77;
366 bitnum++;
367 }
368
369
370 errCnt++;
371 lastBit+=*clk;//skip over until hit too many errors
372 if (errCnt>((*bitLen/1000))){ //allow 1 error for every 1000 samples else start over
373 errCnt=0;
374 bitnum=0;//start over
375 break;
376 }
377 }
378 }
379 if (bitnum>500) break;
380 }
381 //we got more than 64 good bits and not all errors
382 if ((bitnum > (64+errCnt)) && (errCnt<(*bitLen/1000))) {
383 //possible good read
384 if (errCnt==0) break; //great read - finish
385 if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish
386 if (errCnt<bestErrCnt){ //set this as new best run
387 bestErrCnt=errCnt;
388 bestStart = iii;
389 }
390 }
391 }
392 if (iii>=gLen){ //exhausted test
393 //if there was a ok test go back to that one and re-run the best run (then dump after that run)
394 if (bestErrCnt < (*bitLen/1000)) iii=bestStart;
395 }
396 }
397 if (bitnum>16){
398
399 // PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
400 //move BitStream back to BinStream
401 // ClearGraph(0);
402 for (i=0; i < bitnum; ++i){
403 BinStream[i]=BitStream[i];
404 }
405 *bitLen=bitnum;
406 // RepaintGraphWindow();
407 //output
408 // if (errCnt>0){
409 // PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
410 // }
411 // PrintAndLog("ASK decoded bitstream:");
412 // Now output the bitstream to the scrollback by line of 16 bits
413 // printBitStream2(BitStream,bitnum);
414 //int errCnt=0;
415 //errCnt=manrawdemod(BitStream,bitnum);
416
417 // Em410xDecode(Cmd);
418 } else return -1;
419 return errCnt;
420 }
421 //translate wave to 11111100000 (1 for each short wave 0 for each long wave)
422 size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow)
423 {
424 uint32_t last_transition = 0;
425 uint32_t idx = 1;
426 uint32_t maxVal=0;
427 if (fchigh==0) fchigh=10;
428 if (fclow==0) fclow=8;
429 // we do care about the actual theshold value as sometimes near the center of the
430 // wave we may get static that changes direction of wave for one value
431 // if our value is too low it might affect the read. and if our tag or
432 // antenna is weak a setting too high might not see anything. [marshmellow]
433 if (size<100) return 0;
434 for(idx=1; idx<100; idx++){
435 if(maxVal<dest[idx]) maxVal = dest[idx];
436 }
437 // set close to the top of the wave threshold with 25% margin for error
438 // less likely to get a false transition up there.
439 // (but have to be careful not to go too high and miss some short waves)
440 uint8_t threshold_value = (uint8_t)(((maxVal-128)*.75)+128);
441 // idx=1;
442 //uint8_t threshold_value = 127;
443
444 // sync to first lo-hi transition, and threshold
445
446 // Need to threshold first sample
447
448 if(dest[0] < threshold_value) dest[0] = 0;
449 else dest[0] = 1;
450
451 size_t numBits = 0;
452 // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
453 // or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
454 // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
455 for(idx = 1; idx < size; idx++) {
456 // threshold current value
457
458 if (dest[idx] < threshold_value) dest[idx] = 0;
459 else dest[idx] = 1;
460
461 // Check for 0->1 transition
462 if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
463 if ((idx-last_transition)<(fclow-2)){ //0-5 = garbage noise
464 //do nothing with extra garbage
465 } else if ((idx-last_transition) < (fchigh-1)) { //6-8 = 8 waves
466 dest[numBits]=1;
467 } else { //9+ = 10 waves
468 dest[numBits]=0;
469 }
470 last_transition = idx;
471 numBits++;
472 }
473 }
474 return numBits; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
475 }
476
477 uint32_t myround2(float f)
478 {
479 if (f >= 2000) return 2000;//something bad happened
480 return (uint32_t) (f + (float)0.5);
481 }
482
483 //translate 11111100000 to 10
484 size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert,uint8_t fchigh,uint8_t fclow )// uint8_t h2l_crossing_value,uint8_t l2h_crossing_value,
485 {
486 uint8_t lastval=dest[0];
487 uint32_t idx=0;
488 size_t numBits=0;
489 uint32_t n=1;
490
491 for( idx=1; idx < size; idx++) {
492
493 if (dest[idx]==lastval) {
494 n++;
495 continue;
496 }
497 //if lastval was 1, we have a 1->0 crossing
498 if ( dest[idx-1]==1 ) {
499 n=myround2((float)(n+1)/((float)(rfLen)/(float)fclow));
500 //n=(n+1) / h2l_crossing_value;
501 } else {// 0->1 crossing
502 n=myround2((float)(n+1)/((float)(rfLen-2)/(float)fchigh)); //-2 for fudge factor
503 //n=(n+1) / l2h_crossing_value;
504 }
505 if (n == 0) n = 1;
506
507 if(n < maxConsequtiveBits) //Consecutive
508 {
509 if(invert==0){ //invert bits
510 memset(dest+numBits, dest[idx-1] , n);
511 }else{
512 memset(dest+numBits, dest[idx-1]^1 , n);
513 }
514 numBits += n;
515 }
516 n=0;
517 lastval=dest[idx];
518 }//end for
519 return numBits;
520 }
521 //by marshmellow (from holiman's base)
522 // full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
523 int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow)
524 {
525 // FSK demodulator
526 size = fsk_wave_demod(dest, size, fchigh, fclow);
527 size = aggregate_bits(dest, size,rfLen,192,invert,fchigh,fclow);
528 return size;
529 }
530 // loop to get raw HID waveform then FSK demodulate the TAG ID from it
531 int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
532 {
533
534 size_t idx=0; //, found=0; //size=0,
535 // FSK demodulator
536 size = fskdemod(dest, size,50,0,10,8);
537
538 // final loop, go over previously decoded manchester data and decode into usable tag ID
539 // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
540 uint8_t frame_marker_mask[] = {1,1,1,0,0,0};
541 int numshifts = 0;
542 idx = 0;
543 //one scan
544 while( idx + sizeof(frame_marker_mask) < size) {
545 // search for a start of frame marker
546 if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
547 { // frame marker found
548 idx+=sizeof(frame_marker_mask);
549 while(dest[idx] != dest[idx+1] && idx < size-2)
550 {
551 // Keep going until next frame marker (or error)
552 // Shift in a bit. Start by shifting high registers
553 *hi2 = (*hi2<<1)|(*hi>>31);
554 *hi = (*hi<<1)|(*lo>>31);
555 //Then, shift in a 0 or one into low
556 if (dest[idx] && !dest[idx+1]) // 1 0
557 *lo=(*lo<<1)|0;
558 else // 0 1
559 *lo=(*lo<<1)|1;
560 numshifts++;
561 idx += 2;
562 }
563 // Hopefully, we read a tag and hit upon the next frame marker
564 if(idx + sizeof(frame_marker_mask) < size)
565 {
566 if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
567 {
568 //good return
569 return idx;
570 }
571 }
572 // reset
573 *hi2 = *hi = *lo = 0;
574 numshifts = 0;
575 }else {
576 idx++;
577 }
578 }
579 return -1;
580 }
581
582 uint32_t bytebits_to_byte(uint8_t* src, int numbits)
583 {
584 uint32_t num = 0;
585 for(int i = 0 ; i < numbits ; i++)
586 {
587 num = (num << 1) | (*src);
588 src++;
589 }
590 return num;
591 }
592
593 int IOdemodFSK(uint8_t *dest, size_t size)
594 {
595 static const uint8_t THRESHOLD = 140;
596 uint32_t idx=0;
597 //make sure buffer has data
598 if (size < 66) return -1;
599 //test samples are not just noise
600 uint8_t justNoise = 1;
601 for(idx=0;idx< size && justNoise ;idx++){
602 justNoise = dest[idx] < THRESHOLD;
603 }
604 if(justNoise) return 0;
605
606 // FSK demodulator
607 size = fskdemod(dest, size,64,1,10,8); // RF/64 and invert
608 if (size < 65) return -1; //did we get a good demod?
609 //Index map
610 //0 10 20 30 40 50 60
611 //| | | | | | |
612 //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
613 //-----------------------------------------------------------------------------
614 //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
615 //
616 //XSF(version)facility:codeone+codetwo
617 //Handle the data
618 uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
619 for( idx=0; idx < (size - 65); idx++) {
620 if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
621 //frame marker found
622 if (!dest[idx+8] && dest[idx+17]==1 && dest[idx+26]==1 && dest[idx+35]==1 && dest[idx+44]==1 && dest[idx+53]==1){
623 //confirmed proper separator bits found
624 //return start position
625 return (int) idx;
626 }
627 }
628 }
629 return 0;
630 }
631
632 // by marshmellow
633 // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
634 // maybe somehow adjust peak trimming value based on samples to fix?
635 int DetectASKClock(uint8_t dest[], size_t size, int clock)
636 {
637 int i=0;
638 int peak=0;
639 int low=128;
640 int clk[]={16,32,40,50,64,100,128,256};
641 int loopCnt = 256; //don't need to loop through entire array...
642 if (size<loopCnt) loopCnt = size;
643
644 //if we already have a valid clock quit
645 for (;i<8;++i)
646 if (clk[i]==clock) return clock;
647
648 //get high and low peak
649 for (i=0;i<loopCnt;++i){
650 if(dest[i]>peak){
651 peak = dest[i];
652 }
653 if(dest[i]<low){
654 low = dest[i];
655 }
656 }
657 peak=(int)((peak-128)*.75)+128;
658 low= (int)((low-128)*.75)+128;
659 int ii;
660 int clkCnt;
661 int tol = 0;
662 int bestErr=1000;
663 int errCnt[]={0,0,0,0,0,0,0,0};
664 //test each valid clock from smallest to greatest to see which lines up
665 for(clkCnt=0; clkCnt<6;++clkCnt){
666 if (clk[clkCnt]==32){
667 tol=1;
668 }else{
669 tol=0;
670 }
671 bestErr=1000;
672 //try lining up the peaks by moving starting point (try first 256)
673 for (ii=0; ii<loopCnt; ++ii){
674 if ((dest[ii]>=peak) || (dest[ii]<=low)){
675 errCnt[clkCnt]=0;
676 // now that we have the first one lined up test rest of wave array
677 for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){
678 if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
679 }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
680 }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
681 }else{ //error no peak detected
682 errCnt[clkCnt]++;
683 }
684 }
685 //if we found no errors this is correct one - return this clock
686 if(errCnt[clkCnt]==0) return clk[clkCnt];
687 //if we found errors see if it is lowest so far and save it as best run
688 if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
689 }
690 }
691 }
692 int iii=0;
693 int best=0;
694 for (iii=0; iii<6;++iii){
695 if (errCnt[iii]<errCnt[best]){
696 best = iii;
697 }
698 }
699 return clk[best];
700 }
Impressum, Datenschutz