]>
cvs.zerfleddert.de Git - proxmark3-svn/blob - common/lfdemod.c
552411434717c9cd3fcbc410909f7a928a680a5b
1 //-----------------------------------------------------------------------------
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
7 //-----------------------------------------------------------------------------
8 // Low frequency demod/decode commands
9 //-----------------------------------------------------------------------------
12 //un_comment to allow debug print calls when used not on device
13 void dummy ( char * fmt
, ...){}
18 # include "cmdparser.h"
20 # define prnt PrintAndLog
22 uint8_t g_debugMode
= 0 ;
26 //test samples are not just noise
27 uint8_t justNoise ( uint8_t * bits
, size_t size
) {
30 for ( size_t idx
= 0 ; idx
< size
&& val
; idx
++)
31 val
= bits
[ idx
] < THRESHOLD
;
36 //get high and low values of a wave with passed in fuzz factor. also return noise test = 1 for passed or 0 for only noise
37 int getHiLo ( uint8_t * BitStream
, size_t size
, int * high
, int * low
, uint8_t fuzzHi
, uint8_t fuzzLo
)
41 // get high and low thresholds
42 for ( size_t i
= 0 ; i
< size
; i
++){
43 if ( BitStream
[ i
] > * high
) * high
= BitStream
[ i
];
44 if ( BitStream
[ i
] < * low
) * low
= BitStream
[ i
];
46 if (* high
< 123 ) return - 1 ; // just noise
47 * high
= ((* high
- 128 )* fuzzHi
+ 12800 )/ 100 ;
48 * low
= ((* low
- 128 )* fuzzLo
+ 12800 )/ 100 ;
53 // pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType
54 // returns 1 if passed
55 uint8_t parityTest ( uint32_t bits
, uint8_t bitLen
, uint8_t pType
)
58 for ( uint8_t i
= 0 ; i
< bitLen
; i
++){
59 ans
^= (( bits
>> i
) & 1 );
61 //prnt("DEBUG: ans: %d, ptype: %d",ans,pType);
62 return ( ans
== pType
);
66 // takes a array of binary values, start position, length of bits per parity (includes parity bit),
67 // Parity Type (1 for odd; 0 for even; 2 for Always 1's; 3 for Always 0's), and binary Length (length to run)
68 size_t removeParity ( uint8_t * BitStream
, size_t startIdx
, uint8_t pLen
, uint8_t pType
, size_t bLen
)
70 uint32_t parityWd
= 0 ;
71 size_t j
= 0 , bitCnt
= 0 ;
72 for ( int word
= 0 ; word
< ( bLen
); word
+= pLen
){
73 for ( int bit
= 0 ; bit
< pLen
; bit
++){
74 parityWd
= ( parityWd
<< 1 ) | BitStream
[ startIdx
+ word
+ bit
];
75 BitStream
[ j
++] = ( BitStream
[ startIdx
+ word
+ bit
]);
77 j
--; // overwrite parity with next data
78 // if parity fails then return 0
80 case 3 : if ( BitStream
[ j
]== 1 ) { return 0 ; } break ; //should be 0 spacer bit
81 case 2 : if ( BitStream
[ j
]== 0 ) { return 0 ; } break ; //should be 1 spacer bit
82 default : if ( parityTest ( parityWd
, pLen
, pType
) == 0 ) { return 0 ; } break ; //test parity
87 // if we got here then all the parities passed
88 //return ID start index and size
93 // takes a array of binary values, length of bits per parity (includes parity bit),
94 // Parity Type (1 for odd; 0 for even; 2 Always 1's; 3 Always 0's), and binary Length (length to run)
95 // Make sure *dest is long enough to store original sourceLen + #_of_parities_to_be_added
96 size_t addParity ( uint8_t * BitSource
, uint8_t * dest
, uint8_t sourceLen
, uint8_t pLen
, uint8_t pType
)
98 uint32_t parityWd
= 0 ;
99 size_t j
= 0 , bitCnt
= 0 ;
100 for ( int word
= 0 ; word
< sourceLen
; word
+= pLen
- 1 ) {
101 for ( int bit
= 0 ; bit
< pLen
- 1 ; bit
++){
102 parityWd
= ( parityWd
<< 1 ) | BitSource
[ word
+ bit
];
103 dest
[ j
++] = ( BitSource
[ word
+ bit
]);
106 // if parity fails then return 0
108 case 3 : dest
[ j
++]= 0 ; break ; // marker bit which should be a 0
109 case 2 : dest
[ j
++]= 1 ; break ; // marker bit which should be a 1
111 dest
[ j
++] = parityTest ( parityWd
, pLen
- 1 , pType
) ^ 1 ;
117 // if we got here then all the parities passed
118 //return ID start index and size
122 uint32_t bytebits_to_byte ( uint8_t * src
, size_t numbits
)
125 for ( int i
= 0 ; i
< numbits
; i
++) {
126 num
= ( num
<< 1 ) | (* src
);
132 //least significant bit first
133 uint32_t bytebits_to_byteLSBF ( uint8_t * src
, size_t numbits
)
136 for ( int i
= 0 ; i
< numbits
; i
++) {
137 num
= ( num
<< 1 ) | *( src
+ ( numbits
-( i
+ 1 )));
143 //search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length
144 uint8_t preambleSearch ( uint8_t * BitStream
, uint8_t * preamble
, size_t pLen
, size_t * size
, size_t * startIdx
)
146 // Sanity check. If preamble length is bigger than bitstream length.
147 if ( * size
<= pLen
) return 0 ;
149 uint8_t foundCnt
= 0 ;
150 for ( int idx
= 0 ; idx
< * size
- pLen
; idx
++){
151 if ( memcmp ( BitStream
+ idx
, preamble
, pLen
) == 0 ){
158 * size
= idx
- * startIdx
;
167 //takes 1s and 0s and searches for EM410x format - output EM ID
168 int Em410xDecode ( uint8_t * BitStream
, size_t * size
, size_t * startIdx
, uint32_t * hi
, uint64_t * lo
)
170 //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
171 // otherwise could be a void with no arguments
174 if ( BitStream
[ 1 ]> 1 ) return - 1 ; //allow only 1s and 0s
176 // 111111111 bit pattern represent start of frame
177 // include 0 in front to help get start pos
178 uint8_t preamble
[] = { 0 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 };
180 uint32_t parityBits
= 0 ;
184 errChk
= preambleSearch ( BitStream
, preamble
, sizeof ( preamble
), size
, startIdx
);
185 if ( errChk
== 0 ) return - 4 ;
186 if (* size
< 64 ) return - 3 ;
187 if (* size
> 64 ) FmtLen
= 22 ;
188 * startIdx
+= 1 ; //get rid of 0 from preamble
190 for ( i
= 0 ; i
< FmtLen
; i
++){ //loop through 10 or 22 sets of 5 bits (50-10p = 40 bits or 88 bits)
191 parityBits
= bytebits_to_byte ( BitStream
+( i
* 5 )+ idx
, 5 );
192 //check even parity - quit if failed
193 if ( parityTest ( parityBits
, 5 , 0 ) == 0 ) return - 5 ;
194 //set uint64 with ID from BitStream
195 for ( uint8_t ii
= 0 ; ii
< 4 ; ii
++){
196 * hi
= (* hi
<< 1 ) | (* lo
>> 63 );
197 * lo
= (* lo
<< 1 ) | ( BitStream
[( i
* 5 )+ ii
+ idx
]);
200 if ( errChk
!= 0 ) return 1 ;
201 //skip last 5 bit parity test for simplicity.
207 //demodulates strong heavily clipped samples
208 int cleanAskRawDemod ( uint8_t * BinStream
, size_t * size
, int clk
, int invert
, int high
, int low
)
210 size_t bitCnt
= 0 , smplCnt
= 0 , errCnt
= 0 ;
211 uint8_t waveHigh
= 0 ;
212 for ( size_t i
= 0 ; i
< * size
; i
++){
213 if ( BinStream
[ i
] >= high
&& waveHigh
){
215 } else if ( BinStream
[ i
] <= low
&& ! waveHigh
){
217 } else { //transition
218 if (( BinStream
[ i
] >= high
&& ! waveHigh
) || ( BinStream
[ i
] <= low
&& waveHigh
)){
220 if ( smplCnt
> clk
-( clk
/ 4 )- 1 ) { //full clock
221 if ( smplCnt
> clk
+ ( clk
/ 4 )+ 1 ) { //too many samples
223 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: Modulation Error at: %u" , i
);
224 BinStream
[ bitCnt
++] = 7 ;
225 } else if ( waveHigh
) {
226 BinStream
[ bitCnt
++] = invert
;
227 BinStream
[ bitCnt
++] = invert
;
228 } else if (! waveHigh
) {
229 BinStream
[ bitCnt
++] = invert
^ 1 ;
230 BinStream
[ bitCnt
++] = invert
^ 1 ;
234 } else if ( smplCnt
> ( clk
/ 2 ) - ( clk
/ 4 )- 1 ) {
236 BinStream
[ bitCnt
++] = invert
;
237 } else if (! waveHigh
) {
238 BinStream
[ bitCnt
++] = invert
^ 1 ;
242 } else if (! bitCnt
) {
244 waveHigh
= ( BinStream
[ i
] >= high
);
248 //transition bit oops
250 } else { //haven't hit new high or new low yet
260 void askAmp ( uint8_t * BitStream
, size_t size
)
263 for ( size_t i
= 1 ; i
< size
; ++ i
){
264 if ( BitStream
[ i
]- BitStream
[ i
- 1 ] >= 30 ) //large jump up
266 else if ( BitStream
[ i
- 1 ] - BitStream
[ i
] >= 20 ) //large jump down
274 //attempts to demodulate ask modulations, askType == 0 for ask/raw, askType==1 for ask/manchester
275 int askdemod ( uint8_t * BinStream
, size_t * size
, int * clk
, int * invert
, int maxErr
, uint8_t amp
, uint8_t askType
)
277 if (* size
== 0 ) return - 1 ;
278 int start
= DetectASKClock ( BinStream
, * size
, clk
, maxErr
); //clock default
280 if (* clk
== 0 || start
< 0 ) return - 3 ;
281 if (* invert
!= 1 ) * invert
= 0 ;
282 if ( amp
== 1 ) askAmp ( BinStream
, * size
);
283 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: clk %d, beststart %d, amp %d" , * clk
, start
, amp
);
285 uint8_t initLoopMax
= 255 ;
286 if ( initLoopMax
> * size
) initLoopMax
= * size
;
287 // Detect high and lows
288 //25% clip in case highs and lows aren't clipped [marshmellow]
290 if ( getHiLo ( BinStream
, initLoopMax
, & high
, & low
, 75 , 75 ) < 1 )
291 return - 2 ; //just noise
294 // if clean clipped waves detected run alternate demod
295 if ( DetectCleanAskWave ( BinStream
, * size
, high
, low
)) {
296 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: Clean Wave Detected - using clean wave demod" );
297 errCnt
= cleanAskRawDemod ( BinStream
, size
, * clk
, * invert
, high
, low
);
298 if ( askType
) //askman
299 return manrawdecode ( BinStream
, size
, 0 );
303 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: Weak Wave Detected - using weak wave demod" );
305 int lastBit
; //set first clock check - can go negative
306 size_t i
, bitnum
= 0 ; //output counter
308 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
309 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
310 size_t MaxBits
= 3072 ; //max bits to collect
311 lastBit
= start
- * clk
;
313 for ( i
= start
; i
< * size
; ++ i
) {
314 if ( i
- lastBit
>= * clk
- tol
){
315 if ( BinStream
[ i
] >= high
) {
316 BinStream
[ bitnum
++] = * invert
;
317 } else if ( BinStream
[ i
] <= low
) {
318 BinStream
[ bitnum
++] = * invert
^ 1 ;
319 } else if ( i
- lastBit
>= * clk
+ tol
) {
321 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: Modulation Error at: %u" , i
);
322 BinStream
[ bitnum
++]= 7 ;
325 } else { //in tolerance - looking for peak
330 } else if ( i
- lastBit
>= (* clk
/ 2 - tol
) && ! midBit
&& ! askType
){
331 if ( BinStream
[ i
] >= high
) {
332 BinStream
[ bitnum
++] = * invert
;
333 } else if ( BinStream
[ i
] <= low
) {
334 BinStream
[ bitnum
++] = * invert
^ 1 ;
335 } else if ( i
- lastBit
>= * clk
/ 2 + tol
) {
336 BinStream
[ bitnum
] = BinStream
[ bitnum
- 1 ];
338 } else { //in tolerance - looking for peak
343 if ( bitnum
>= MaxBits
) break ;
349 //take 10 and 01 and manchester decode
350 //run through 2 times and take least errCnt
351 int manrawdecode ( uint8_t * BitStream
, size_t * size
, uint8_t invert
){
352 int errCnt
= 0 , bestErr
= 1000 ;
353 uint16_t bitnum
= 0 , MaxBits
= 512 , bestRun
= 0 ;
355 if (* size
< 16 ) return - 1 ;
356 //find correct start position [alignment]
357 for ( k
= 0 ; k
< 2 ; ++ k
){
358 for ( i
= k
; i
<* size
- 3 ; i
+= 2 )
359 if ( BitStream
[ i
] == BitStream
[ i
+ 1 ])
362 if ( bestErr
> errCnt
){
369 for ( i
= bestRun
; i
< * size
- 3 ; i
+= 2 ){
370 if ( BitStream
[ i
] == 1 && ( BitStream
[ i
+ 1 ] == 0 )){
371 BitStream
[ bitnum
++] = invert
;
372 } else if (( BitStream
[ i
] == 0 ) && BitStream
[ i
+ 1 ] == 1 ){
373 BitStream
[ bitnum
++] = invert
^ 1 ;
375 BitStream
[ bitnum
++] = 7 ;
377 if ( bitnum
> MaxBits
) break ;
383 uint32_t manchesterEncode2Bytes ( uint16_t datain
) {
386 for ( uint8_t i
= 0 ; i
< 16 ; i
++) {
387 curBit
= ( datain
>> ( 15 - i
) & 1 );
388 output
|= ( 1 <<((( 15 - i
)* 2 )+ curBit
));
394 //encode binary data into binary manchester
395 int ManchesterEncode ( uint8_t * BitStream
, size_t size
)
397 size_t modIdx
= 20000 , i
= 0 ;
398 if ( size
> modIdx
) return - 1 ;
399 for ( size_t idx
= 0 ; idx
< size
; idx
++){
400 BitStream
[ idx
+ modIdx
++] = BitStream
[ idx
];
401 BitStream
[ idx
+ modIdx
++] = BitStream
[ idx
]^ 1 ;
403 for (; i
<( size
* 2 ); i
++){
404 BitStream
[ i
] = BitStream
[ i
+ 20000 ];
410 //take 01 or 10 = 1 and 11 or 00 = 0
411 //check for phase errors - should never have 111 or 000 should be 01001011 or 10110100 for 1010
412 //decodes biphase or if inverted it is AKA conditional dephase encoding AKA differential manchester encoding
413 int BiphaseRawDecode ( uint8_t * BitStream
, size_t * size
, int offset
, int invert
)
418 uint16_t MaxBits
= 512 ;
419 //if not enough samples - error
420 if (* size
< 51 ) return - 1 ;
421 //check for phase change faults - skip one sample if faulty
422 uint8_t offsetA
= 1 , offsetB
= 1 ;
424 if ( BitStream
[ i
+ 1 ]== BitStream
[ i
+ 2 ]) offsetA
= 0 ;
425 if ( BitStream
[ i
+ 2 ]== BitStream
[ i
+ 3 ]) offsetB
= 0 ;
427 if (! offsetA
&& offsetB
) offset
++;
428 for ( i
= offset
; i
<* size
- 3 ; i
+= 2 ){
429 //check for phase error
430 if ( BitStream
[ i
+ 1 ]== BitStream
[ i
+ 2 ]) {
431 BitStream
[ bitnum
++]= 7 ;
434 if (( BitStream
[ i
]== 1 && BitStream
[ i
+ 1 ]== 0 ) || ( BitStream
[ i
]== 0 && BitStream
[ i
+ 1 ]== 1 )){
435 BitStream
[ bitnum
++]= 1 ^ invert
;
436 } else if (( BitStream
[ i
]== 0 && BitStream
[ i
+ 1 ]== 0 ) || ( BitStream
[ i
]== 1 && BitStream
[ i
+ 1 ]== 1 )){
437 BitStream
[ bitnum
++]= invert
;
439 BitStream
[ bitnum
++]= 7 ;
442 if ( bitnum
> MaxBits
) break ;
449 // demod gProxIIDemod
450 // error returns as -x
451 // success returns start position in BitStream
452 // BitStream must contain previously askrawdemod and biphasedemoded data
453 int gProxII_Demod ( uint8_t BitStream
[], size_t * size
)
456 uint8_t preamble
[] = { 1 , 1 , 1 , 1 , 1 , 0 };
458 uint8_t errChk
= preambleSearch ( BitStream
, preamble
, sizeof ( preamble
), size
, & startIdx
);
459 if ( errChk
== 0 ) return - 3 ; //preamble not found
460 if (* size
!= 96 ) return - 2 ; //should have found 96 bits
461 //check first 6 spacer bits to verify format
462 if (! BitStream
[ startIdx
+ 5 ] && ! BitStream
[ startIdx
+ 10 ] && ! BitStream
[ startIdx
+ 15 ] && ! BitStream
[ startIdx
+ 20 ] && ! BitStream
[ startIdx
+ 25 ] && ! BitStream
[ startIdx
+ 30 ]){
463 //confirmed proper separator bits found
464 //return start position
465 return ( int ) startIdx
;
467 return - 5 ; //spacer bits not found - not a valid gproxII
470 //translate wave to 11111100000 (1 for each short wave [higher freq] 0 for each long wave [lower freq])
471 size_t fsk_wave_demod ( uint8_t * dest
, size_t size
, uint8_t fchigh
, uint8_t fclow
)
473 size_t last_transition
= 0 ;
476 if ( fchigh
== 0 ) fchigh
= 10 ;
477 if ( fclow
== 0 ) fclow
= 8 ;
478 //set the threshold close to 0 (graph) or 128 std to avoid static
479 uint8_t threshold_value
= 123 ;
480 size_t preLastSample
= 0 ;
481 size_t LastSample
= 0 ;
482 size_t currSample
= 0 ;
483 // sync to first lo-hi transition, and threshold
485 // Need to threshold first sample
486 // skip 160 samples to allow antenna/samples to settle
487 if ( dest
[ 160 ] < threshold_value
) dest
[ 0 ] = 0 ;
491 // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
492 // or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere
493 // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
494 // (could also be fc/5 && fc/7 for fsk1 = 4-9)
495 for ( idx
= 161 ; idx
< size
- 20 ; idx
++) {
496 // threshold current value
498 if ( dest
[ idx
] < threshold_value
) dest
[ idx
] = 0 ;
501 // Check for 0->1 transition
502 if ( dest
[ idx
- 1 ] < dest
[ idx
]) {
503 preLastSample
= LastSample
;
504 LastSample
= currSample
;
505 currSample
= idx
- last_transition
;
506 if ( currSample
< ( fclow
- 2 )){ //0-5 = garbage noise (or 0-3)
507 //do nothing with extra garbage
508 } else if ( currSample
< ( fchigh
- 1 )) { //6-8 = 8 sample waves (or 3-6 = 5)
509 //correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5)
510 if ( LastSample
> ( fchigh
- 2 ) && ( preLastSample
< ( fchigh
- 1 ) || preLastSample
== 0 )){
515 } else if ( currSample
> ( fchigh
) && ! numBits
) { //12 + and first bit = unusable garbage
516 //do nothing with beginning garbage
517 } else if ( currSample
== ( fclow
+ 1 ) && LastSample
== ( fclow
- 1 )) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's)
519 } else { //9+ = 10 sample waves (or 6+ = 7)
522 last_transition
= idx
;
525 return numBits
; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
528 //translate 11111100000 to 10
529 //rfLen = clock, fchigh = larger field clock, fclow = smaller field clock
530 size_t aggregate_bits ( uint8_t * dest
, size_t size
, uint8_t rfLen
,
531 uint8_t invert
, uint8_t fchigh
, uint8_t fclow
)
533 uint8_t lastval
= dest
[ 0 ];
537 for ( idx
= 1 ; idx
< size
; idx
++) {
539 if ( dest
[ idx
]== lastval
) continue ; //skip until we hit a transition
541 //find out how many bits (n) we collected
542 //if lastval was 1, we have a 1->0 crossing
543 if ( dest
[ idx
- 1 ]== 1 ) {
544 n
= ( n
* fclow
+ rfLen
/ 2 ) / rfLen
;
545 } else { // 0->1 crossing
546 n
= ( n
* fchigh
+ rfLen
/ 2 ) / rfLen
;
550 //add to our destination the bits we collected
551 memset ( dest
+ numBits
, dest
[ idx
- 1 ]^ invert
, n
);
556 // if valid extra bits at the end were all the same frequency - add them in
557 if ( n
> rfLen
/ fchigh
) {
558 if ( dest
[ idx
- 2 ]== 1 ) {
559 n
= ( n
* fclow
+ rfLen
/ 2 ) / rfLen
;
561 n
= ( n
* fchigh
+ rfLen
/ 2 ) / rfLen
;
563 memset ( dest
+ numBits
, dest
[ idx
- 1 ]^ invert
, n
);
569 //by marshmellow (from holiman's base)
570 // full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
571 int fskdemod ( uint8_t * dest
, size_t size
, uint8_t rfLen
, uint8_t invert
, uint8_t fchigh
, uint8_t fclow
)
574 size
= fsk_wave_demod ( dest
, size
, fchigh
, fclow
);
575 size
= aggregate_bits ( dest
, size
, rfLen
, invert
, fchigh
, fclow
);
579 // loop to get raw HID waveform then FSK demodulate the TAG ID from it
580 int HIDdemodFSK ( uint8_t * dest
, size_t * size
, uint32_t * hi2
, uint32_t * hi
, uint32_t * lo
)
582 if ( justNoise ( dest
, * size
)) return - 1 ;
584 size_t numStart
= 0 , size2
= * size
, startIdx
= 0 ;
586 * size
= fskdemod ( dest
, size2
, 50 , 1 , 10 , 8 ); //fsk2a
587 if (* size
< 96 * 2 ) return - 2 ;
588 // 00011101 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1
589 uint8_t preamble
[] = { 0 , 0 , 0 , 1 , 1 , 1 , 0 , 1 };
590 // find bitstring in array
591 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
592 if ( errChk
== 0 ) return - 3 ; //preamble not found
594 numStart
= startIdx
+ sizeof ( preamble
);
595 // final loop, go over previously decoded FSK data and manchester decode into usable tag ID
596 for ( size_t idx
= numStart
; ( idx
- numStart
) < * size
- sizeof ( preamble
); idx
+= 2 ){
597 if ( dest
[ idx
] == dest
[ idx
+ 1 ]){
598 return - 4 ; //not manchester data
600 * hi2
= (* hi2
<< 1 )|(* hi
>> 31 );
601 * hi
= (* hi
<< 1 )|(* lo
>> 31 );
602 //Then, shift in a 0 or one into low
604 if ( dest
[ idx
] && ! dest
[ idx
+ 1 ]) // 1 0
609 return ( int ) startIdx
;
612 // loop to get raw paradox waveform then FSK demodulate the TAG ID from it
613 int ParadoxdemodFSK ( uint8_t * dest
, size_t * size
, uint32_t * hi2
, uint32_t * hi
, uint32_t * lo
)
615 if ( justNoise ( dest
, * size
)) return - 1 ;
617 size_t numStart
= 0 , size2
= * size
, startIdx
= 0 ;
619 * size
= fskdemod ( dest
, size2
, 50 , 1 , 10 , 8 ); //fsk2a
620 if (* size
< 96 ) return - 2 ;
622 // 00001111 bit pattern represent start of frame, 01 pattern represents a 0 and 10 represents a 1
623 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 };
625 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
626 if ( errChk
== 0 ) return - 3 ; //preamble not found
628 numStart
= startIdx
+ sizeof ( preamble
);
629 // final loop, go over previously decoded FSK data and manchester decode into usable tag ID
630 for ( size_t idx
= numStart
; ( idx
- numStart
) < * size
- sizeof ( preamble
); idx
+= 2 ){
631 if ( dest
[ idx
] == dest
[ idx
+ 1 ])
632 return - 4 ; //not manchester data
633 * hi2
= (* hi2
<< 1 )|(* hi
>> 31 );
634 * hi
= (* hi
<< 1 )|(* lo
>> 31 );
635 //Then, shift in a 0 or one into low
636 if ( dest
[ idx
] && ! dest
[ idx
+ 1 ]) // 1 0
641 return ( int ) startIdx
;
644 int IOdemodFSK ( uint8_t * dest
, size_t size
)
646 if ( justNoise ( dest
, size
)) return - 1 ;
647 //make sure buffer has data
648 if ( size
< 66 * 64 ) return - 2 ;
650 size
= fskdemod ( dest
, size
, 64 , 1 , 10 , 8 ); // FSK2a RF/64
651 if ( size
< 65 ) return - 3 ; //did we get a good demod?
653 //0 10 20 30 40 50 60
655 //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
656 //-----------------------------------------------------------------------------
657 //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
659 //XSF(version)facility:codeone+codetwo
662 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 };
663 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), & size
, & startIdx
);
664 if ( errChk
== 0 ) return - 4 ; //preamble not found
666 if (! dest
[ startIdx
+ 8 ] && dest
[ startIdx
+ 17 ]== 1 && dest
[ startIdx
+ 26 ]== 1 && dest
[ startIdx
+ 35 ]== 1 && dest
[ startIdx
+ 44 ]== 1 && dest
[ startIdx
+ 53 ]== 1 ){
667 //confirmed proper separator bits found
668 //return start position
669 return ( int ) startIdx
;
675 // find viking preamble 0xF200 in already demoded data
676 int VikingDemod_AM ( uint8_t * dest
, size_t * size
) {
677 //make sure buffer has data
678 if (* size
< 64 * 2 ) return - 2 ;
680 uint8_t preamble
[] = { 1 , 1 , 1 , 1 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
681 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
682 if ( errChk
== 0 ) return - 4 ; //preamble not found
683 uint32_t checkCalc
= bytebits_to_byte ( dest
+ startIdx
, 8 ) ^
684 bytebits_to_byte ( dest
+ startIdx
+ 8 , 8 ) ^
685 bytebits_to_byte ( dest
+ startIdx
+ 16 , 8 ) ^
686 bytebits_to_byte ( dest
+ startIdx
+ 24 , 8 ) ^
687 bytebits_to_byte ( dest
+ startIdx
+ 32 , 8 ) ^
688 bytebits_to_byte ( dest
+ startIdx
+ 40 , 8 ) ^
689 bytebits_to_byte ( dest
+ startIdx
+ 48 , 8 ) ^
690 bytebits_to_byte ( dest
+ startIdx
+ 56 , 8 );
691 if ( checkCalc
!= 0xA8 ) return - 5 ;
692 if (* size
!= 64 ) return - 6 ;
693 //return start position
694 return ( int ) startIdx
;
698 // find Visa2000 preamble in already demoded data
699 int Visa2kDemod_AM ( uint8_t * dest
, size_t * size
) {
700 if (* size
< 96 ) return - 1 ; //make sure buffer has data
702 uint8_t preamble
[] = { 0 , 1 , 0 , 1 , 0 , 1 , 1 , 0 , 0 , 1 , 0 , 0 , 1 , 0 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 0 };
703 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
704 if ( errChk
== 0 ) return - 2 ; //preamble not found
705 if (* size
!= 96 ) return - 3 ; //wrong demoded size
706 //return start position
707 return ( int ) startIdx
;
710 // find Noralsy preamble in already demoded data
711 int NoralsyDemod_AM ( uint8_t * dest
, size_t * size
) {
712 if (* size
< 96 ) return - 1 ; //make sure buffer has data
714 uint8_t preamble
[] = { 1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 0 , 0 , 0 , 0 };
715 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
716 if ( errChk
== 0 ) return - 2 ; //preamble not found
717 if (* size
!= 96 ) return - 3 ; //wrong demoded size
718 //return start position
719 return ( int ) startIdx
;
721 // find presco preamble 0x10D in already demoded data
722 int PrescoDemod ( uint8_t * dest
, size_t * size
) {
723 if (* size
< 128 * 2 ) return - 1 ; //make sure buffer has data
725 uint8_t preamble
[] = { 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
726 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
727 if ( errChk
== 0 ) return - 2 ; //preamble not found
728 if (* size
!= 128 ) return - 3 ; //wrong demoded size
729 //return start position
730 return ( int ) startIdx
;
733 // Ask/Biphase Demod then try to locate an ISO 11784/85 ID
734 // BitStream must contain previously askrawdemod and biphasedemoded data
735 int FDXBdemodBI ( uint8_t * dest
, size_t * size
) {
736 if (* size
< 128 * 2 ) return - 1 ; //make sure buffer has enough data
738 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 };
739 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
740 if ( errChk
== 0 ) return - 2 ; //preamble not found
741 if (* size
!= 128 ) return - 3 ; //wrong demoded size
742 //return start position
743 return ( int ) startIdx
;
746 // ASK/Diphase fc/64 (inverted Biphase)
747 // Note: this i s not a demod, this is only a detection
748 // the parameter *dest needs to be demoded before call
749 // 0xFFFF preamble, 64bits
750 int JablotronDemod ( uint8_t * dest
, size_t * size
){
751 if (* size
< 64 * 2 ) return - 1 ; //make sure buffer has enough data
753 uint8_t preamble
[] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 };
754 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
755 if ( errChk
== 0 ) return - 2 ; //preamble not found
756 if (* size
!= 64 ) return - 3 ; // wrong demoded size
758 uint8_t checkchksum
= 0 ;
759 for ( int i
= 16 ; i
< 56 ; i
+= 8 ) {
760 checkchksum
+= bytebits_to_byte ( dest
+ startIdx
+ i
, 8 );
763 uint8_t crc
= bytebits_to_byte ( dest
+ startIdx
+ 56 , 8 );
764 if ( checkchksum
!= crc
) return - 5 ;
765 return ( int ) startIdx
;
769 // FSK Demod then try to locate an AWID ID
770 int AWIDdemodFSK ( uint8_t * dest
, size_t * size
)
772 //make sure buffer has enough data
773 if (* size
< 96 * 50 ) return - 1 ;
775 if ( justNoise ( dest
, * size
)) return - 2 ;
778 * size
= fskdemod ( dest
, * size
, 50 , 1 , 10 , 8 ); // fsk2a RF/50
779 if (* size
< 96 ) return - 3 ; //did we get a good demod?
781 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 };
783 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
784 if ( errChk
== 0 ) return - 4 ; //preamble not found
785 if (* size
!= 96 ) return - 5 ;
786 return ( int ) startIdx
;
790 // FSK Demod then try to locate a Farpointe Data (pyramid) ID
791 int PyramiddemodFSK ( uint8_t * dest
, size_t * size
)
793 //make sure buffer has data
794 if (* size
< 128 * 50 ) return - 5 ;
796 //test samples are not just noise
797 if ( justNoise ( dest
, * size
)) return - 1 ;
800 * size
= fskdemod ( dest
, * size
, 50 , 1 , 10 , 8 ); // fsk2a RF/50
801 if (* size
< 128 ) return - 2 ; //did we get a good demod?
803 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 };
805 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
806 if ( errChk
== 0 ) return - 4 ; //preamble not found
807 if (* size
!= 128 ) return - 3 ;
808 return ( int ) startIdx
;
811 // find nedap preamble in already demoded data
812 int NedapDemod ( uint8_t * dest
, size_t * size
) {
813 //make sure buffer has data
814 if (* size
< 128 ) return - 3 ;
817 //uint8_t preamble[] = {1,1,1,1,1,1,1,1,1,0,0,0,1};
818 uint8_t preamble
[] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 };
819 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
820 if ( errChk
== 0 ) return - 4 ; //preamble not found
821 return ( int ) startIdx
;
824 // Find IDTEC PSK1, RF Preamble == 0x4944544B, Demodsize 64bits
826 int IdteckDemodPSK ( uint8_t * dest
, size_t * size
) {
827 //make sure buffer has data
828 if (* size
< 64 * 2 ) return - 1 ;
830 uint8_t preamble
[] = { 0 , 1 , 0 , 0 , 1 , 0 , 0 , 1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 1 , 0 , 1 , 1 };
831 uint8_t errChk
= preambleSearch ( dest
, preamble
, sizeof ( preamble
), size
, & startIdx
);
832 if ( errChk
== 0 ) return - 2 ; //preamble not found
833 if (* size
!= 64 ) return - 3 ; // wrong demoded size
834 return ( int ) startIdx
;
838 // to detect a wave that has heavily clipped (clean) samples
839 uint8_t DetectCleanAskWave ( uint8_t dest
[], size_t size
, uint8_t high
, uint8_t low
)
841 bool allArePeaks
= true ;
843 size_t loopEnd
= 512 + 160 ;
844 if ( loopEnd
> size
) loopEnd
= size
;
845 for ( size_t i
= 160 ; i
< loopEnd
; i
++){
846 if ( dest
[ i
]> low
&& dest
[ i
]< high
)
852 if ( cntPeaks
> 300 ) return true ;
857 // to help detect clocks on heavily clipped samples
858 // based on count of low to low
859 int DetectStrongAskClock ( uint8_t dest
[], size_t size
, uint8_t high
, uint8_t low
)
861 uint8_t fndClk
[] = { 8 , 16 , 32 , 40 , 50 , 64 , 128 };
865 // get to first full low to prime loop and skip incomplete first pulse
866 while (( dest
[ i
] < high
) && ( i
< size
))
868 while (( dest
[ i
] > low
) && ( i
< size
))
871 // loop through all samples
873 // measure from low to low
874 while (( dest
[ i
] > low
) && ( i
< size
))
877 while (( dest
[ i
] < high
) && ( i
< size
))
879 while (( dest
[ i
] > low
) && ( i
< size
))
881 //get minimum measured distance
882 if ( i
- startwave
< minClk
&& i
< size
)
883 minClk
= i
- startwave
;
886 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: detectstrongASKclk smallest wave: %d" , minClk
);
887 for ( uint8_t clkCnt
= 0 ; clkCnt
< 7 ; clkCnt
++) {
888 if ( minClk
>= fndClk
[ clkCnt
]-( fndClk
[ clkCnt
]/ 8 ) && minClk
<= fndClk
[ clkCnt
]+ 1 )
889 return fndClk
[ clkCnt
];
895 // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
896 // maybe somehow adjust peak trimming value based on samples to fix?
897 // return start index of best starting position for that clock and return clock (by reference)
898 int DetectASKClock ( uint8_t dest
[], size_t size
, int * clock
, int maxErr
)
901 uint8_t clk
[] = { 255 , 8 , 16 , 32 , 40 , 50 , 64 , 100 , 128 , 255 };
903 uint8_t loopCnt
= 255 ; //don't need to loop through entire array...
904 if ( size
<= loopCnt
+ 60 ) return - 1 ; //not enough samples
905 size
-= 60 ; //sometimes there is a strange end wave - filter out this....
906 //if we already have a valid clock
909 if ( clk
[ i
] == * clock
) clockFnd
= i
;
910 //clock found but continue to find best startpos
912 //get high and low peak
914 if ( getHiLo ( dest
, loopCnt
, & peak
, & low
, 75 , 75 ) < 1 ) return - 1 ;
916 //test for large clean peaks
918 if ( DetectCleanAskWave ( dest
, size
, peak
, low
)== 1 ){
919 int ans
= DetectStrongAskClock ( dest
, size
, peak
, low
);
920 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %d" , ans
);
921 for ( i
= clkEnd
- 1 ; i
> 0 ; i
--){
925 return 0 ; // for strong waves i don't use the 'best start position' yet...
926 //break; //clock found but continue to find best startpos [not yet]
932 uint8_t clkCnt
, tol
= 0 ;
933 uint16_t bestErr
[]={ 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 };
934 uint8_t bestStart
[]={ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
936 size_t arrLoc
, loopEnd
;
945 //test each valid clock from smallest to greatest to see which lines up
946 for (; clkCnt
< clkEnd
; clkCnt
++) {
947 if ( clk
[ clkCnt
] <= 32 ) {
952 //if no errors allowed - keep start within the first clock
953 if (! maxErr
&& size
> clk
[ clkCnt
]* 2 + tol
&& clk
[ clkCnt
]< 128 )
954 loopCnt
= clk
[ clkCnt
] * 2 ;
956 bestErr
[ clkCnt
] = 1000 ;
958 //try lining up the peaks by moving starting point (try first few clocks)
959 for ( ii
= 0 ; ii
< loopCnt
; ii
++){
960 if ( dest
[ ii
] < peak
&& dest
[ ii
] > low
) continue ;
963 // now that we have the first one lined up test rest of wave array
964 loopEnd
= (( size
- ii
- tol
) / clk
[ clkCnt
]) - 1 ;
965 for ( i
= 0 ; i
< loopEnd
; ++ i
){
966 arrLoc
= ii
+ ( i
* clk
[ clkCnt
]);
967 if ( dest
[ arrLoc
] >= peak
|| dest
[ arrLoc
] <= low
){
968 } else if ( dest
[ arrLoc
- tol
] >= peak
|| dest
[ arrLoc
- tol
] <= low
){
969 } else if ( dest
[ arrLoc
+ tol
] >= peak
|| dest
[ arrLoc
+ tol
] <= low
){
970 } else { //error no peak detected
974 //if we found no errors then we can stop here and a low clock (common clocks)
975 // this is correct one - return this clock
976 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: clk %d, err %d, startpos %d, endpos %d" , clk
[ clkCnt
], errCnt
, ii
, i
);
977 if ( errCnt
== 0 && clkCnt
< 7 ) {
978 if (! clockFnd
) * clock
= clk
[ clkCnt
];
981 //if we found errors see if it is lowest so far and save it as best run
982 if ( errCnt
< bestErr
[ clkCnt
]) {
983 bestErr
[ clkCnt
] = errCnt
;
984 bestStart
[ clkCnt
] = ii
;
990 for ( k
= 1 ; k
< clkEnd
; ++ k
){
991 if ( bestErr
[ k
] < bestErr
[ best
]){
992 if ( bestErr
[ k
] == 0 ) bestErr
[ k
]= 1 ;
993 // current best bit to error ratio vs new bit to error ratio
994 if ( ( size
/ clk
[ best
])/ bestErr
[ best
] < ( size
/ clk
[ k
])/ bestErr
[ k
] ){
998 if ( g_debugMode
== 2 ) prnt ( "DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d" , clk
[ k
], bestErr
[ k
], clk
[ best
], bestStart
[ best
]);
1000 if (! clockFnd
) * clock
= clk
[ best
];
1001 return bestStart
[ best
];
1005 //detect psk clock by reading each phase shift
1006 // a phase shift is determined by measuring the sample length of each wave
1007 int DetectPSKClock ( uint8_t dest
[], size_t size
, int clock
)
1009 uint8_t clk
[]={ 255 , 16 , 32 , 40 , 50 , 64 , 100 , 128 , 255 }; //255 is not a valid clock
1010 uint16_t loopCnt
= 4096 ; //don't need to loop through entire array...
1011 if ( size
== 0 ) return 0 ;
1012 if ( size
< loopCnt
) loopCnt
= size
- 20 ;
1014 //if we already have a valid clock quit
1017 if ( clk
[ i
] == clock
) return clock
;
1019 size_t waveStart
= 0 , waveEnd
= 0 , firstFullWave
= 0 , lastClkBit
= 0 ;
1020 uint8_t clkCnt
, fc
= 0 , fullWaveLen
= 0 , tol
= 1 ;
1021 uint16_t peakcnt
= 0 , errCnt
= 0 , waveLenCnt
= 0 ;
1022 uint16_t bestErr
[]={ 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 , 1000 };
1023 uint16_t peaksdet
[]={ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1024 fc
= countFC ( dest
, size
, 0 );
1025 if ( fc
!= 2 && fc
!= 4 && fc
!= 8 ) return - 1 ;
1026 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: FC: %d" , fc
);
1028 //find first full wave
1029 for ( i
= 160 ; i
< loopCnt
; i
++){
1030 if ( dest
[ i
] < dest
[ i
+ 1 ] && dest
[ i
+ 1 ] >= dest
[ i
+ 2 ]){
1031 if ( waveStart
== 0 ) {
1033 //prnt("DEBUG: waveStart: %d",waveStart);
1036 //prnt("DEBUG: waveEnd: %d",waveEnd);
1037 waveLenCnt
= waveEnd
- waveStart
;
1038 if ( waveLenCnt
> fc
){
1039 firstFullWave
= waveStart
;
1040 fullWaveLen
= waveLenCnt
;
1047 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: firstFullWave: %d, waveLen: %d" , firstFullWave
, fullWaveLen
);
1049 //test each valid clock from greatest to smallest to see which lines up
1050 for ( clkCnt
= 7 ; clkCnt
>= 1 ; clkCnt
--){
1051 lastClkBit
= firstFullWave
; //set end of wave as clock align
1055 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: clk: %d, lastClkBit: %d" , clk
[ clkCnt
], lastClkBit
);
1057 for ( i
= firstFullWave
+ fullWaveLen
- 1 ; i
< loopCnt
- 2 ; i
++){
1058 //top edge of wave = start of new wave
1059 if ( dest
[ i
] < dest
[ i
+ 1 ] && dest
[ i
+ 1 ] >= dest
[ i
+ 2 ]){
1060 if ( waveStart
== 0 ) {
1065 waveLenCnt
= waveEnd
- waveStart
;
1066 if ( waveLenCnt
> fc
){
1067 //if this wave is a phase shift
1068 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d" , waveStart
, waveLenCnt
, lastClkBit
+ clk
[ clkCnt
]- tol
, i
+ 1 , fc
);
1069 if ( i
+ 1 >= lastClkBit
+ clk
[ clkCnt
] - tol
){ //should be a clock bit
1071 lastClkBit
+= clk
[ clkCnt
];
1072 } else if ( i
< lastClkBit
+ 8 ){
1073 //noise after a phase shift - ignore
1074 } else { //phase shift before supposed to based on clock
1077 } else if ( i
+ 1 > lastClkBit
+ clk
[ clkCnt
] + tol
+ fc
){
1078 lastClkBit
+= clk
[ clkCnt
]; //no phase shift but clock bit
1087 if ( errCnt
<= bestErr
[ clkCnt
]) bestErr
[ clkCnt
]= errCnt
;
1088 if ( peakcnt
> peaksdet
[ clkCnt
]) peaksdet
[ clkCnt
]= peakcnt
;
1090 //all tested with errors
1091 //return the highest clk with the most peaks found
1093 for ( i
= 7 ; i
>= 1 ; i
--){
1094 if ( peaksdet
[ i
] > peaksdet
[ best
]) {
1097 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d" , clk
[ i
], peaksdet
[ i
], bestErr
[ i
], clk
[ best
]);
1102 int DetectStrongNRZClk ( uint8_t * dest
, size_t size
, int peak
, int low
){
1103 //find shortest transition from high to low
1105 size_t transition1
= 0 ;
1106 int lowestTransition
= 255 ;
1107 bool lastWasHigh
= false ;
1109 //find first valid beginning of a high or low wave
1110 while (( dest
[ i
] >= peak
|| dest
[ i
] <= low
) && ( i
< size
))
1112 while (( dest
[ i
] < peak
&& dest
[ i
] > low
) && ( i
< size
))
1114 lastWasHigh
= ( dest
[ i
] >= peak
);
1116 if ( i
== size
) return 0 ;
1119 for (; i
< size
; i
++) {
1120 if (( dest
[ i
] >= peak
&& ! lastWasHigh
) || ( dest
[ i
] <= low
&& lastWasHigh
)) {
1121 lastWasHigh
= ( dest
[ i
] >= peak
);
1122 if ( i
- transition1
< lowestTransition
) lowestTransition
= i
- transition1
;
1126 if ( lowestTransition
== 255 ) lowestTransition
= 0 ;
1127 if ( g_debugMode
== 2 ) prnt ( "DEBUG NRZ: detectstrongNRZclk smallest wave: %d" , lowestTransition
);
1128 return lowestTransition
;
1132 //detect nrz clock by reading #peaks vs no peaks(or errors)
1133 int DetectNRZClock ( uint8_t dest
[], size_t size
, int clock
)
1136 uint8_t clk
[]={ 8 , 16 , 32 , 40 , 50 , 64 , 100 , 128 , 255 };
1137 size_t loopCnt
= 4096 ; //don't need to loop through entire array...
1138 if ( size
== 0 ) return 0 ;
1139 if ( size
< loopCnt
) loopCnt
= size
- 20 ;
1140 //if we already have a valid clock quit
1142 if ( clk
[ i
] == clock
) return clock
;
1144 //get high and low peak
1146 if ( getHiLo ( dest
, loopCnt
, & peak
, & low
, 75 , 75 ) < 1 ) return 0 ;
1148 int lowestTransition
= DetectStrongNRZClk ( dest
, size
- 20 , peak
, low
);
1152 uint16_t smplCnt
= 0 ;
1153 int16_t peakcnt
= 0 ;
1154 int16_t peaksdet
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1155 uint16_t maxPeak
= 255 ;
1156 bool firstpeak
= false ;
1157 //test for large clipped waves
1158 for ( i
= 0 ; i
< loopCnt
; i
++){
1159 if ( dest
[ i
] >= peak
|| dest
[ i
] <= low
){
1160 if (! firstpeak
) continue ;
1165 if ( maxPeak
> smplCnt
){
1167 //prnt("maxPk: %d",maxPeak);
1170 //prnt("maxPk: %d, smplCnt: %d, peakcnt: %d",maxPeak,smplCnt,peakcnt);
1175 bool errBitHigh
= 0 ;
1177 uint8_t ignoreCnt
= 0 ;
1178 uint8_t ignoreWindow
= 4 ;
1179 bool lastPeakHigh
= 0 ;
1182 //test each valid clock from smallest to greatest to see which lines up
1183 for ( clkCnt
= 0 ; clkCnt
< 8 ; ++ clkCnt
){
1184 //ignore clocks smaller than smallest peak
1185 if ( clk
[ clkCnt
] < maxPeak
- ( clk
[ clkCnt
]/ 4 )) continue ;
1186 //try lining up the peaks by moving starting point (try first 256)
1187 for ( ii
= 20 ; ii
< loopCnt
; ++ ii
){
1188 if (( dest
[ ii
] >= peak
) || ( dest
[ ii
] <= low
)){
1192 lastBit
= ii
- clk
[ clkCnt
];
1193 //loop through to see if this start location works
1194 for ( i
= ii
; i
< size
- 20 ; ++ i
) {
1195 //if we are at a clock bit
1196 if (( i
>= lastBit
+ clk
[ clkCnt
] - tol
) && ( i
<= lastBit
+ clk
[ clkCnt
] + tol
)) {
1198 if ( dest
[ i
] >= peak
|| dest
[ i
] <= low
) {
1199 //if same peak don't count it
1200 if (( dest
[ i
] >= peak
&& ! lastPeakHigh
) || ( dest
[ i
] <= low
&& lastPeakHigh
)) {
1203 lastPeakHigh
= ( dest
[ i
] >= peak
);
1206 ignoreCnt
= ignoreWindow
;
1207 lastBit
+= clk
[ clkCnt
];
1208 } else if ( i
== lastBit
+ clk
[ clkCnt
] + tol
) {
1209 lastBit
+= clk
[ clkCnt
];
1211 //else if not a clock bit and no peaks
1212 } else if ( dest
[ i
] < peak
&& dest
[ i
] > low
){
1215 if ( errBitHigh
== true ) peakcnt
--;
1220 // else if not a clock bit but we have a peak
1221 } else if (( dest
[ i
]>= peak
|| dest
[ i
]<= low
) && (! bitHigh
)) {
1222 //error bar found no clock...
1226 if ( peakcnt
> peaksdet
[ clkCnt
]) {
1227 peaksdet
[ clkCnt
]= peakcnt
;
1234 for ( iii
= 7 ; iii
> 0 ; iii
--){
1235 if (( peaksdet
[ iii
] >= ( peaksdet
[ best
]- 1 )) && ( peaksdet
[ iii
] <= peaksdet
[ best
]+ 1 ) && lowestTransition
) {
1236 if ( clk
[ iii
] > ( lowestTransition
- ( clk
[ iii
]/ 8 )) && clk
[ iii
] < ( lowestTransition
+ ( clk
[ iii
]/ 8 ))) {
1239 } else if ( peaksdet
[ iii
] > peaksdet
[ best
]){
1242 if ( g_debugMode
== 2 ) prnt ( "DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d" , clk
[ iii
], peaksdet
[ iii
], maxPeak
, clk
[ best
], lowestTransition
);
1249 // convert psk1 demod to psk2 demod
1250 // only transition waves are 1s
1251 void psk1TOpsk2 ( uint8_t * BitStream
, size_t size
)
1254 uint8_t lastBit
= BitStream
[ 0 ];
1255 for (; i
< size
; i
++){
1256 if ( BitStream
[ i
]== 7 ){
1258 } else if ( lastBit
!= BitStream
[ i
]){
1259 lastBit
= BitStream
[ i
];
1269 // convert psk2 demod to psk1 demod
1270 // from only transition waves are 1s to phase shifts change bit
1271 void psk2TOpsk1 ( uint8_t * BitStream
, size_t size
)
1274 for ( size_t i
= 0 ; i
< size
; i
++){
1275 if ( BitStream
[ i
]== 1 ){
1283 // redesigned by marshmellow adjusted from existing decode functions
1284 // indala id decoding - only tested on 26 bit tags, but attempted to make it work for more
1285 int indala26decode ( uint8_t * bitStream
, size_t * size
, uint8_t * invert
)
1287 //26 bit 40134 format (don't know other formats)
1288 uint8_t preamble
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 };
1289 uint8_t preamble_i
[] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 };
1290 size_t startidx
= 0 ;
1291 if (! preambleSearch ( bitStream
, preamble
, sizeof ( preamble
), size
, & startidx
)){
1292 // if didn't find preamble try again inverting
1293 if (! preambleSearch ( bitStream
, preamble_i
, sizeof ( preamble_i
), size
, & startidx
)) return - 1 ;
1296 if (* size
!= 64 && * size
!= 224 ) return - 2 ;
1298 for ( size_t i
= startidx
; i
< * size
; i
++)
1301 return ( int ) startidx
;
1304 // by marshmellow - demodulate NRZ wave - requires a read with strong signal
1305 // peaks invert bit (high=1 low=0) each clock cycle = 1 bit determined by last peak
1306 int nrzRawDemod ( uint8_t * dest
, size_t * size
, int * clk
, int * invert
){
1307 if ( justNoise ( dest
, * size
)) return - 1 ;
1308 * clk
= DetectNRZClock ( dest
, * size
, * clk
);
1309 if (* clk
== 0 ) return - 2 ;
1310 size_t i
, gLen
= 4096 ;
1311 if ( gLen
>* size
) gLen
= * size
- 20 ;
1313 if ( getHiLo ( dest
, gLen
, & high
, & low
, 75 , 75 ) < 1 ) return - 3 ; //25% fuzz on high 25% fuzz on low
1316 //convert wave samples to 1's and 0's
1317 for ( i
= 20 ; i
< * size
- 20 ; i
++){
1318 if ( dest
[ i
] >= high
) bit
= 1 ;
1319 if ( dest
[ i
] <= low
) bit
= 0 ;
1322 //now demod based on clock (rf/32 = 32 1's for one 1 bit, 32 0's for one 0 bit)
1325 for ( i
= 21 ; i
< * size
- 20 ; i
++) {
1326 //if transition detected or large number of same bits - store the passed bits
1327 if ( dest
[ i
] != dest
[ i
- 1 ] || ( i
- lastBit
) == ( 10 * * clk
)) {
1328 memset ( dest
+ numBits
, dest
[ i
- 1 ] ^ * invert
, ( i
- lastBit
+ (* clk
/ 4 )) / * clk
);
1329 numBits
+= ( i
- lastBit
+ (* clk
/ 4 )) / * clk
;
1338 //detects the bit clock for FSK given the high and low Field Clocks
1339 uint8_t detectFSKClk ( uint8_t * BitStream
, size_t size
, uint8_t fcHigh
, uint8_t fcLow
)
1341 uint8_t clk
[] = { 8 , 16 , 32 , 40 , 50 , 64 , 100 , 128 , 0 };
1342 uint16_t rfLens
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1343 uint8_t rfCnts
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1344 uint8_t rfLensFnd
= 0 ;
1345 uint8_t lastFCcnt
= 0 ;
1346 uint16_t fcCounter
= 0 ;
1347 uint16_t rfCounter
= 0 ;
1348 uint8_t firstBitFnd
= 0 ;
1350 if ( size
== 0 ) return 0 ;
1352 uint8_t fcTol
= (( fcHigh
* 100 - fcLow
* 100 )/ 2 + 50 )/ 100 ; //(uint8_t)(0.5+(float)(fcHigh-fcLow)/2);
1357 //prnt("DEBUG: fcTol: %d",fcTol);
1358 // prime i to first peak / up transition
1359 for ( i
= 160 ; i
< size
- 20 ; i
++)
1360 if ( BitStream
[ i
] > BitStream
[ i
- 1 ] && BitStream
[ i
]>= BitStream
[ i
+ 1 ])
1363 for (; i
< size
- 20 ; i
++){
1367 if ( BitStream
[ i
] <= BitStream
[ i
- 1 ] || BitStream
[ i
] < BitStream
[ i
+ 1 ])
1370 // if we got less than the small fc + tolerance then set it to the small fc
1371 if ( fcCounter
< fcLow
+ fcTol
)
1373 else //set it to the large fc
1376 //look for bit clock (rf/xx)
1377 if (( fcCounter
< lastFCcnt
|| fcCounter
> lastFCcnt
)){
1378 //not the same size as the last wave - start of new bit sequence
1379 if ( firstBitFnd
> 1 ){ //skip first wave change - probably not a complete bit
1380 for ( int ii
= 0 ; ii
< 15 ; ii
++){
1381 if ( rfLens
[ ii
] >= ( rfCounter
- 4 ) && rfLens
[ ii
] <= ( rfCounter
+ 4 )){
1387 if ( rfCounter
> 0 && rfLensFnd
< 15 ){
1388 //prnt("DEBUG: rfCntr %d, fcCntr %d",rfCounter,fcCounter);
1389 rfCnts
[ rfLensFnd
]++;
1390 rfLens
[ rfLensFnd
++] = rfCounter
;
1396 lastFCcnt
= fcCounter
;
1400 uint8_t rfHighest
= 15 , rfHighest2
= 15 , rfHighest3
= 15 ;
1402 for ( i
= 0 ; i
< 15 ; i
++){
1403 //get highest 2 RF values (might need to get more values to compare or compare all?)
1404 if ( rfCnts
[ i
]> rfCnts
[ rfHighest
]){
1405 rfHighest3
= rfHighest2
;
1406 rfHighest2
= rfHighest
;
1408 } else if ( rfCnts
[ i
]> rfCnts
[ rfHighest2
]){
1409 rfHighest3
= rfHighest2
;
1411 } else if ( rfCnts
[ i
]> rfCnts
[ rfHighest3
]){
1414 if ( g_debugMode
== 2 ) prnt ( "DEBUG FSK: RF %d, cnts %d" , rfLens
[ i
], rfCnts
[ i
]);
1416 // set allowed clock remainder tolerance to be 1 large field clock length+1
1417 // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off
1418 uint8_t tol1
= fcHigh
+ 1 ;
1420 if ( g_debugMode
== 2 ) prnt ( "DEBUG FSK: most counted rf values: 1 %d, 2 %d, 3 %d" , rfLens
[ rfHighest
], rfLens
[ rfHighest2
], rfLens
[ rfHighest3
]);
1422 // loop to find the highest clock that has a remainder less than the tolerance
1423 // compare samples counted divided by
1424 // test 128 down to 32 (shouldn't be possible to have fc/10 & fc/8 and rf/16 or less)
1426 for (; ii
>= 2 ; ii
--){
1427 if ( rfLens
[ rfHighest
] % clk
[ ii
] < tol1
|| rfLens
[ rfHighest
] % clk
[ ii
] > clk
[ ii
]- tol1
){
1428 if ( rfLens
[ rfHighest2
] % clk
[ ii
] < tol1
|| rfLens
[ rfHighest2
] % clk
[ ii
] > clk
[ ii
]- tol1
){
1429 if ( rfLens
[ rfHighest3
] % clk
[ ii
] < tol1
|| rfLens
[ rfHighest3
] % clk
[ ii
] > clk
[ ii
]- tol1
){
1430 if ( g_debugMode
== 2 ) prnt ( "DEBUG FSK: clk %d divides into the 3 most rf values within tolerance" , clk
[ ii
]);
1437 if ( ii
< 0 ) return 0 ; // oops we went too far
1443 //countFC is to detect the field clock lengths.
1444 //counts and returns the 2 most common wave lengths
1445 //mainly used for FSK field clock detection
1446 uint16_t countFC ( uint8_t * BitStream
, size_t size
, uint8_t fskAdj
)
1448 uint8_t fcLens
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1449 uint16_t fcCnts
[] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 };
1450 uint8_t fcLensFnd
= 0 ;
1451 uint8_t lastFCcnt
= 0 ;
1452 uint8_t fcCounter
= 0 ;
1454 if ( size
== 0 ) return 0 ;
1456 // prime i to first up transition
1457 for ( i
= 160 ; i
< size
- 20 ; i
++)
1458 if ( BitStream
[ i
] > BitStream
[ i
- 1 ] && BitStream
[ i
] >= BitStream
[ i
+ 1 ])
1461 for (; i
< size
- 20 ; i
++){
1462 if ( BitStream
[ i
] > BitStream
[ i
- 1 ] && BitStream
[ i
] >= BitStream
[ i
+ 1 ]){
1463 // new up transition
1466 //if we had 5 and now have 9 then go back to 8 (for when we get a fc 9 instead of an 8)
1467 if ( lastFCcnt
== 5 && fcCounter
== 9 ) fcCounter
--;
1468 //if fc=9 or 4 add one (for when we get a fc 9 instead of 10 or a 4 instead of a 5)
1469 if (( fcCounter
== 9 ) || fcCounter
== 4 ) fcCounter
++;
1470 // save last field clock count (fc/xx)
1471 lastFCcnt
= fcCounter
;
1473 // find which fcLens to save it to:
1474 for ( int ii
= 0 ; ii
< 15 ; ii
++){
1475 if ( fcLens
[ ii
]== fcCounter
){
1481 if ( fcCounter
> 0 && fcLensFnd
< 15 ){
1483 fcCnts
[ fcLensFnd
]++;
1484 fcLens
[ fcLensFnd
++]= fcCounter
;
1493 uint8_t best1
= 14 , best2
= 14 , best3
= 14 ;
1495 // go through fclens and find which ones are bigest 2
1496 for ( i
= 0 ; i
< 15 ; i
++){
1497 // get the 3 best FC values
1498 if ( fcCnts
[ i
]> maxCnt1
) {
1503 } else if ( fcCnts
[ i
]> fcCnts
[ best2
]){
1506 } else if ( fcCnts
[ i
]> fcCnts
[ best3
]){
1509 if ( g_debugMode
== 2 ) prnt ( "DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u" , fcLens
[ i
], fcCnts
[ i
], fcLens
[ best1
], fcLens
[ best2
]);
1511 if ( fcLens
[ best1
]== 0 ) return 0 ;
1512 uint8_t fcH
= 0 , fcL
= 0 ;
1513 if ( fcLens
[ best1
]> fcLens
[ best2
]){
1520 if (( size
- 180 )/ fcH
/ 3 > fcCnts
[ best1
]+ fcCnts
[ best2
]) {
1521 if ( g_debugMode
== 2 ) prnt ( "DEBUG countfc: fc is too large: %u > %u. Not psk or fsk" ,( size
- 180 )/ fcH
/ 3 , fcCnts
[ best1
]+ fcCnts
[ best2
]);
1522 return 0 ; //lots of waves not psk or fsk
1524 // TODO: take top 3 answers and compare to known Field clocks to get top 2
1526 uint16_t fcs
= ((( uint16_t ) fcH
)<< 8 ) | fcL
;
1527 if ( fskAdj
) return fcs
;
1528 return fcLens
[ best1
];
1531 //by marshmellow - demodulate PSK1 wave
1532 //uses wave lengths (# Samples)
1533 int pskRawDemod ( uint8_t dest
[], size_t * size
, int * clock
, int * invert
)
1535 if ( size
== 0 ) return - 1 ;
1536 uint16_t loopCnt
= 4096 ; //don't need to loop through entire array...
1537 if (* size
< loopCnt
) loopCnt
= * size
;
1540 uint8_t curPhase
= * invert
;
1541 size_t i
, waveStart
= 1 , waveEnd
= 0 , firstFullWave
= 0 , lastClkBit
= 0 ;
1542 uint8_t fc
= 0 , fullWaveLen
= 0 , tol
= 1 ;
1543 uint16_t errCnt
= 0 , waveLenCnt
= 0 ;
1544 fc
= countFC ( dest
, * size
, 0 );
1545 if ( fc
!= 2 && fc
!= 4 && fc
!= 8 ) return - 1 ;
1546 //prnt("DEBUG: FC: %d",fc);
1547 * clock
= DetectPSKClock ( dest
, * size
, * clock
);
1548 if (* clock
== 0 ) return - 1 ;
1549 int avgWaveVal
= 0 , lastAvgWaveVal
= 0 ;
1550 //find first phase shift
1551 for ( i
= 0 ; i
< loopCnt
; i
++){
1552 if ( dest
[ i
]+ fc
< dest
[ i
+ 1 ] && dest
[ i
+ 1 ] >= dest
[ i
+ 2 ]){
1554 //prnt("DEBUG: waveEnd: %d",waveEnd);
1555 waveLenCnt
= waveEnd
- waveStart
;
1556 if ( waveLenCnt
> fc
&& waveStart
> fc
&& !( waveLenCnt
> fc
+ 2 )){ //not first peak and is a large wave but not out of whack
1557 lastAvgWaveVal
= avgWaveVal
/( waveLenCnt
);
1558 firstFullWave
= waveStart
;
1559 fullWaveLen
= waveLenCnt
;
1560 //if average wave value is > graph 0 then it is an up wave or a 1
1561 if ( lastAvgWaveVal
> 123 ) curPhase
^= 1 ; //fudge graph 0 a little 123 vs 128
1567 avgWaveVal
+= dest
[ i
+ 2 ];
1569 if ( firstFullWave
== 0 ) {
1570 // no phase shift detected - could be all 1's or 0's - doesn't matter where we start
1571 // so skip a little to ensure we are past any Start Signal
1572 firstFullWave
= 160 ;
1573 memset ( dest
, curPhase
, firstFullWave
/ * clock
);
1575 memset ( dest
, curPhase
^ 1 , firstFullWave
/ * clock
);
1578 numBits
+= ( firstFullWave
/ * clock
);
1579 //set start of wave as clock align
1580 lastClkBit
= firstFullWave
;
1581 if ( g_debugMode
== 2 ) prnt ( "DEBUG PSK: firstFullWave: %u, waveLen: %u" , firstFullWave
, fullWaveLen
);
1582 if ( g_debugMode
== 2 ) prnt ( "DEBUG: clk: %d, lastClkBit: %u, fc: %u" , * clock
, lastClkBit
,( unsigned int ) fc
);
1584 dest
[ numBits
++] = curPhase
; //set first read bit
1585 for ( i
= firstFullWave
+ fullWaveLen
- 1 ; i
< * size
- 3 ; i
++){
1586 //top edge of wave = start of new wave
1587 if ( dest
[ i
]+ fc
< dest
[ i
+ 1 ] && dest
[ i
+ 1 ] >= dest
[ i
+ 2 ]){
1588 if ( waveStart
== 0 ) {
1591 avgWaveVal
= dest
[ i
+ 1 ];
1594 waveLenCnt
= waveEnd
- waveStart
;
1595 lastAvgWaveVal
= avgWaveVal
/ waveLenCnt
;
1596 if ( waveLenCnt
> fc
){
1597 //prnt("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal);
1598 //this wave is a phase shift
1599 //prnt("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc);
1600 if ( i
+ 1 >= lastClkBit
+ * clock
- tol
){ //should be a clock bit
1602 dest
[ numBits
++] = curPhase
;
1603 lastClkBit
+= * clock
;
1604 } else if ( i
< lastClkBit
+ 10 + fc
){
1605 //noise after a phase shift - ignore
1606 } else { //phase shift before supposed to based on clock
1608 dest
[ numBits
++] = 7 ;
1610 } else if ( i
+ 1 > lastClkBit
+ * clock
+ tol
+ fc
){
1611 lastClkBit
+= * clock
; //no phase shift but clock bit
1612 dest
[ numBits
++] = curPhase
;
1618 avgWaveVal
+= dest
[ i
+ 1 ];
1625 //attempt to identify a Sequence Terminator in ASK modulated raw wave
1626 bool DetectST ( uint8_t buffer
[], size_t * size
, int * foundclock
) {
1627 size_t bufsize
= * size
;
1628 //need to loop through all samples and identify our clock, look for the ST pattern
1629 uint8_t fndClk
[] = { 8 , 16 , 32 , 40 , 50 , 64 , 128 };
1632 int i
, j
, skip
, start
, end
, low
, high
, minClk
, waveStart
;
1633 bool complete
= false ;
1634 int tmpbuff
[ bufsize
/ 32 ]; //guess rf/32 clock, if click is smaller we will only have room for a fraction of the samples captured
1635 int waveLen
[ bufsize
/ 32 ]; // if clock is larger then we waste memory in array size that is not needed...
1636 size_t testsize
= ( bufsize
< 512 ) ? bufsize
: 512 ;
1639 memset ( tmpbuff
, 0 , sizeof ( tmpbuff
));
1640 memset ( waveLen
, 0 , sizeof ( waveLen
));
1643 if ( getHiLo ( buffer
, testsize
, & high
, & low
, 80 , 80 ) == - 1 ) {
1644 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: just noise detected - quitting" );
1645 return false ; //just noise
1650 // get to first full low to prime loop and skip incomplete first pulse
1651 while (( buffer
[ i
] < high
) && ( i
< bufsize
))
1653 while (( buffer
[ i
] > low
) && ( i
< bufsize
))
1657 // populate tmpbuff buffer with pulse lengths
1658 while ( i
< bufsize
) {
1659 // measure from low to low
1660 while (( buffer
[ i
] > low
) && ( i
< bufsize
))
1663 while (( buffer
[ i
] < high
) && ( i
< bufsize
))
1665 //first high point for this wave
1667 while (( buffer
[ i
] > low
) && ( i
< bufsize
))
1669 if ( j
>= ( bufsize
/ 32 )) {
1672 waveLen
[ j
] = i
- waveStart
; //first high to first low
1673 tmpbuff
[ j
++] = i
- start
;
1674 if ( i
- start
< minClk
&& i
< bufsize
) {
1678 // set clock - might be able to get this externally and remove this work...
1680 for ( uint8_t clkCnt
= 0 ; clkCnt
< 7 ; clkCnt
++) {
1681 tol
= fndClk
[ clkCnt
]/ 8 ;
1682 if ( minClk
>= fndClk
[ clkCnt
]- tol
&& minClk
<= fndClk
[ clkCnt
]+ 1 ) {
1687 // clock not found - ERROR
1689 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: clock not found - quitting" );
1696 // look for Sequence Terminator - should be pulses of clk*(1 or 1.5), clk*2, clk*(1.5 or 2)
1698 for ( i
= 0 ; i
< j
- 4 ; ++ i
) {
1700 if ( tmpbuff
[ i
] >= clk
* 1 - tol
&& tmpbuff
[ i
] <= ( clk
* 2 )+ tol
&& waveLen
[ i
] < clk
+ tol
) { //1 to 2 clocks depending on 2 bits prior
1701 if ( tmpbuff
[ i
+ 1 ] >= clk
* 2 - tol
&& tmpbuff
[ i
+ 1 ] <= clk
* 2 + tol
&& waveLen
[ i
+ 1 ] > clk
* 3 / 2 - tol
) { //2 clocks and wave size is 1 1/2
1702 if ( tmpbuff
[ i
+ 2 ] >= ( clk
* 3 )/ 2 - tol
&& tmpbuff
[ i
+ 2 ] <= clk
* 2 + tol
&& waveLen
[ i
+ 2 ] > clk
- tol
) { //1 1/2 to 2 clocks and at least one full clock wave
1703 if ( tmpbuff
[ i
+ 3 ] >= clk
* 1 - tol
&& tmpbuff
[ i
+ 3 ] <= clk
* 2 + tol
) { //1 to 2 clocks for end of ST + first bit
1711 // first ST not found - ERROR
1713 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: first STT not found - quitting" );
1716 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: first STT found at: %d, j=%d" , start
, j
);
1718 if ( waveLen
[ i
+ 2 ] > clk
* 1 + tol
)
1723 // skip over the remainder of ST
1724 skip
+= clk
* 7 / 2 ; //3.5 clocks from tmpbuff[i] = end of st - also aligns for ending point
1726 // now do it again to find the end
1728 for ( i
+= 3 ; i
< j
- 4 ; ++ i
) {
1730 if ( tmpbuff
[ i
] >= clk
* 1 - tol
&& tmpbuff
[ i
] <= ( clk
* 2 )+ tol
&& waveLen
[ i
] < clk
+ tol
) { //1 to 2 clocks depending on 2 bits prior
1731 if ( tmpbuff
[ i
+ 1 ] >= clk
* 2 - tol
&& tmpbuff
[ i
+ 1 ] <= clk
* 2 + tol
&& waveLen
[ i
+ 1 ] > clk
* 3 / 2 - tol
) { //2 clocks and wave size is 1 1/2
1732 if ( tmpbuff
[ i
+ 2 ] >= ( clk
* 3 )/ 2 - tol
&& tmpbuff
[ i
+ 2 ] <= clk
* 2 + tol
&& waveLen
[ i
+ 2 ] > clk
- tol
) { //1 1/2 to 2 clocks and at least one full clock wave
1733 if ( tmpbuff
[ i
+ 3 ] >= clk
* 1 - tol
&& tmpbuff
[ i
+ 3 ] <= clk
* 2 + tol
) { //1 to 2 clocks for end of ST + first bit
1742 //didn't find second ST - ERROR
1744 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: second STT not found - quitting" );
1747 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: start of data: %d end of data: %d, datalen: %d, clk: %d, bits: %d, phaseoff: %d" , skip
, end
, end
- skip
, clk
, ( end
- skip
)/ clk
, phaseoff
);
1748 //now begin to trim out ST so we can use normal demod cmds
1750 size_t datalen
= end
- start
;
1751 // check validity of datalen (should be even clock increments) - use a tolerance of up to 1/8th a clock
1752 if ( clk
- ( datalen
% clk
) <= clk
/ 8 ) {
1753 // padd the amount off - could be problematic... but shouldn't happen often
1754 datalen
+= clk
- ( datalen
% clk
);
1755 } else if ( ( datalen
% clk
) <= clk
/ 8 ) {
1756 // padd the amount off - could be problematic... but shouldn't happen often
1757 datalen
-= datalen
% clk
;
1759 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: datalen not divisible by clk: %u %% %d = %d - quitting" , datalen
, clk
, datalen
% clk
);
1762 // if datalen is less than one t55xx block - ERROR
1763 if ( datalen
/ clk
< 8 * 4 ) {
1764 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: datalen is less than 1 full t55xx block - quitting" );
1767 size_t dataloc
= start
;
1768 if ( buffer
[ dataloc
-( clk
* 4 )-( clk
/ 8 )] <= low
&& buffer
[ dataloc
] <= low
&& buffer
[ dataloc
-( clk
* 4 )] >= high
) {
1769 //we have low drift (and a low just before the ST and a low just after the ST) - compensate by backing up the start
1770 for ( i
= 0 ; i
<= ( clk
/ 8 ); ++ i
) {
1771 if ( buffer
[ dataloc
- ( clk
* 4 ) - i
] <= low
) {
1780 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: Starting STT trim - start: %d, datalen: %d " , dataloc
, datalen
);
1782 // warning - overwriting buffer given with raw wave data with ST removed...
1783 while ( dataloc
< bufsize
-( clk
/ 2 ) ) {
1784 //compensate for long high at end of ST not being high due to signal loss... (and we cut out the start of wave high part)
1785 if ( buffer
[ dataloc
]< high
&& buffer
[ dataloc
]> low
&& buffer
[ dataloc
+ 3 ]< high
&& buffer
[ dataloc
+ 3 ]> low
) {
1786 for ( i
= 0 ; i
< clk
/ 2 - tol
; ++ i
) {
1787 buffer
[ dataloc
+ i
] = high
+ 5 ;
1790 for ( i
= 0 ; i
< datalen
; ++ i
) {
1791 if ( i
+ newloc
< bufsize
) {
1792 if ( i
+ newloc
< dataloc
)
1793 buffer
[ i
+ newloc
] = buffer
[ dataloc
];
1799 //skip next ST - we just assume it will be there from now on...
1800 if ( g_debugMode
== 2 ) prnt ( "DEBUG STT: skipping STT at %d to %d" , dataloc
, dataloc
+( clk
* 4 ));