]> cvs.zerfleddert.de Git - proxmark3-svn/blame - winsrc/command.cpp
projects / proxmark3-svn / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Junk Eclipse environment files. Not source code.
[proxmark3-svn] / winsrc / command.cpp
CommitLineData
6658905f 1//-----------------------------------------------------------------------------\r
2// The actual command interpeter for what the user types at the command line.\r
3// Jonathan Westhues, Sept 2005\r
4// Edits by Gerhard de Koning Gans, Sep 2007 (##)\r
5//-----------------------------------------------------------------------------\r
6#include <windows.h>\r
7#include <stdlib.h>\r
8#include <string.h>\r
9#include <stdio.h>\r
10#include <limits.h>\r
11#include <math.h>\r
12\r
13#include "prox.h"\r
14#include "../common/iso14443_crc.c"\r
0c2ed92d 15#include "../common/crc16.c"\r
6658905f 16\r
17#define arraylen(x) (sizeof(x)/sizeof((x)[0]))\r
9760414b 18#define BIT(x) GraphBuffer[x * clock]\r
19#define BITS (GraphTraceLen / clock)\r
6658905f 20\r
9760414b 21int go = 0;\r
6658905f 22static int CmdHisamplest(char *str, int nrlow);\r
23\r
24static void GetFromBigBuf(BYTE *dest, int bytes)\r
25{\r
26 int n = bytes/4;\r
27\r
28 if(n % 48 != 0) {\r
29 PrintToScrollback("bad len in GetFromBigBuf");\r
30 return;\r
31 }\r
32\r
33 int i;\r
34 for(i = 0; i < n; i += 12) {\r
35 UsbCommand c;\r
36 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
37 c.ext1 = i;\r
38 SendCommand(&c, FALSE);\r
39 ReceiveCommand(&c);\r
40 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 41 PrintToScrollback("bad resp");\r
6658905f 42 return;\r
43 }\r
44\r
45 memcpy(dest+(i*4), c.d.asBytes, 48);\r
46 }\r
47}\r
48\r
d722c4ce 49static void CmdReset(char *str)\r
50{\r
51 UsbCommand c;\r
52 c.cmd = CMD_HARDWARE_RESET;\r
53 SendCommand(&c, FALSE);\r
54}\r
55\r
f23e056d 56static void CmdBuffClear(char *str)\r
57{\r
58 UsbCommand c;\r
59 c.cmd = CMD_BUFF_CLEAR;\r
60 SendCommand(&c, FALSE);\r
61 CmdClearGraph(TRUE);\r
62}\r
d722c4ce 63\r
6658905f 64static void CmdQuit(char *str)\r
65{\r
66 exit(0);\r
67}\r
68\r
69static void CmdHIDdemodFSK(char *str)\r
70{\r
71 UsbCommand c;\r
72 c.cmd = CMD_HID_DEMOD_FSK;\r
73 SendCommand(&c, FALSE);\r
74}\r
75\r
76static void CmdTune(char *str)\r
77{\r
78 UsbCommand c;\r
79 c.cmd = CMD_MEASURE_ANTENNA_TUNING;\r
80 SendCommand(&c, FALSE);\r
81}\r
82\r
83static void CmdHi15read(char *str)\r
84{\r
85 UsbCommand c;\r
86 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693;\r
87 SendCommand(&c, FALSE);\r
88}\r
89\r
90static void CmdHi14read(char *str)\r
91{\r
92 UsbCommand c;\r
93 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
94 c.ext1 = atoi(str);\r
95 SendCommand(&c, FALSE);\r
96}\r
9760414b 97\r
98\r
99/* New command to read the contents of a SRI512 tag\r
100 * SRI512 tags are ISO14443-B modulated memory tags,\r
101 * this command just dumps the contents of the memory/\r
102 */\r
103static void CmdSri512read(char *str)\r
104{\r
fb25b483 105 UsbCommand c;\r
106 c.cmd = CMD_READ_SRI512_TAG;\r
107 c.ext1 = atoi(str);\r
9760414b 108 SendCommand(&c, FALSE);\r
109}\r
6658905f 110\r
111// ## New command\r
112static void CmdHi14areader(char *str)\r
113{\r
114 UsbCommand c;\r
115 c.cmd = CMD_READER_ISO_14443a;\r
116 c.ext1 = atoi(str);\r
117 SendCommand(&c, FALSE);\r
118}\r
119\r
120// ## New command\r
121static void CmdHi15reader(char *str)\r
122{\r
123 UsbCommand c;\r
124 c.cmd = CMD_READER_ISO_15693;\r
125 c.ext1 = atoi(str);\r
126 SendCommand(&c, FALSE);\r
127}\r
128\r
129// ## New command\r
130static void CmdHi15tag(char *str)\r
131{\r
132 UsbCommand c;\r
133 c.cmd = CMD_SIMTAG_ISO_15693;\r
134 c.ext1 = atoi(str);\r
135 SendCommand(&c, FALSE);\r
136}\r
137\r
138static void CmdHi14read_sim(char *str)\r
139{\r
140 UsbCommand c;\r
141 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443_SIM;\r
142 c.ext1 = atoi(str);\r
143 SendCommand(&c, FALSE);\r
144}\r
145\r
146static void CmdHi14readt(char *str)\r
147{\r
148 UsbCommand c;\r
149 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
150 c.ext1 = atoi(str);\r
151 SendCommand(&c, FALSE);\r
152\r
153 //CmdHisamplest(str);\r
154 while(CmdHisamplest(str,atoi(str))==0) {\r
155 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
156 c.ext1 = atoi(str);\r
157 SendCommand(&c, FALSE);\r
158 }\r
159 RepaintGraphWindow();\r
160}\r
161\r
162static void CmdHisimlisten(char *str)\r
163{\r
164 UsbCommand c;\r
165 c.cmd = CMD_SIMULATE_TAG_HF_LISTEN;\r
166 SendCommand(&c, FALSE);\r
167}\r
168\r
169static void CmdHi14sim(char *str)\r
170{\r
171 UsbCommand c;\r
172 c.cmd = CMD_SIMULATE_TAG_ISO_14443;\r
173 SendCommand(&c, FALSE);\r
174}\r
6658905f 175\r
176static void CmdHi14asim(char *str) // ## simulate iso14443a tag\r
177{ // ## greg - added ability to specify tag UID\r
178\r
179 unsigned int hi=0, lo=0;\r
180 int n=0, i=0;\r
181 UsbCommand c;\r
182\r
183 while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
184 hi=(hi<<4)|(lo>>28);\r
185 lo=(lo<<4)|(n&0xf);\r
186 }\r
187\r
188 c.cmd = CMD_SIMULATE_TAG_ISO_14443a;\r
189 // c.ext should be set to *str or convert *str to the correct format for a uid\r
190 c.ext1 = hi;\r
191 c.ext2 = lo;\r
192 PrintToScrollback("Emulating 14443A TAG with UID %x%16x", hi, lo);\r
193 SendCommand(&c, FALSE);\r
194}\r
195\r
196static void CmdHi14snoop(char *str)\r
197{\r
198 UsbCommand c;\r
199 c.cmd = CMD_SNOOP_ISO_14443;\r
200 SendCommand(&c, FALSE);\r
201}\r
202\r
203static void CmdHi14asnoop(char *str)\r
204{\r
205 UsbCommand c;\r
206 c.cmd = CMD_SNOOP_ISO_14443a;\r
207 SendCommand(&c, FALSE);\r
208}\r
209\r
210static void CmdFPGAOff(char *str) // ## FPGA Control\r
211{\r
212 UsbCommand c;\r
213 c.cmd = CMD_FPGA_MAJOR_MODE_OFF;\r
214 SendCommand(&c, FALSE);\r
215}\r
216\r
9760414b 217/* clear out our graph window */\r
218int CmdClearGraph(int redraw)\r
219{\r
220 int gtl = GraphTraceLen;\r
221 GraphTraceLen = 0;\r
15db5fb7 222\r
9760414b 223 if (redraw)\r
224 RepaintGraphWindow();\r
15db5fb7 225\r
9760414b 226 return gtl;\r
227}\r
228\r
229/* write a bit to the graph */\r
230static void CmdAppendGraph(int redraw, int clock, int bit)\r
6658905f 231{\r
232 int i;\r
233\r
9760414b 234 for (i = 0; i < (int)(clock/2); i++)\r
235 GraphBuffer[GraphTraceLen++] = bit ^ 1;\r
15db5fb7 236\r
237 for (i = (int)(clock/2); i < clock; i++)\r
9760414b 238 GraphBuffer[GraphTraceLen++] = bit;\r
239\r
240 if (redraw)\r
241 RepaintGraphWindow();\r
242}\r
243\r
244/* Function is equivalent of loread + losamples + em410xread\r
245 * looped until an EM410x tag is detected */\r
246static void CmdEM410xwatch(char *str)\r
247{\r
248 char *zero = "";\r
249 char *twok = "2000";\r
250 go = 1;\r
15db5fb7 251\r
9760414b 252 do\r
253 {\r
254 CmdLoread(zero);\r
255 CmdLosamples(twok);\r
256 CmdEM410xread(zero);\r
257 } while (go);\r
258}\r
259\r
955aa93f 260/* Read the transmitted data of an EM4x50 tag\r
261 * Format:\r
262 *\r
263 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
264 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
265 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
266 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity\r
267 * CCCCCCCC <- column parity bits\r
268 * 0 <- stop bit\r
269 * LW <- Listen Window\r
270 *\r
271 * This pattern repeats for every block of data being transmitted.\r
272 * Transmission starts with two Listen Windows (LW - a modulated\r
273 * pattern of 320 cycles each (32/32/128/64/64)).\r
274 *\r
275 * Note that this data may or may not be the UID. It is whatever data\r
67853904 276 * is stored in the blocks defined in the control word First and Last\r
955aa93f 277 * Word Read values. UID is stored in block 32.\r
67853904 278 */\r
955aa93f 279static void CmdEM4x50read(char *str)\r
280{\r
281 int i, j, startblock, clock, skip, block, start, end, low, high;\r
282 BOOL complete= FALSE;\r
283 int tmpbuff[MAX_GRAPH_TRACE_LEN / 64];\r
284 char tmp[6];\r
285\r
286 high= low= 0;\r
287 clock= 64;\r
288\r
289 /* first get high and low values */\r
290 for (i = 0; i < GraphTraceLen; i++)\r
291 {\r
67853904 292 if (GraphBuffer[i] > high)\r
955aa93f 293 high = GraphBuffer[i];\r
294 else if (GraphBuffer[i] < low)\r
295 low = GraphBuffer[i];\r
296 }\r
297\r
298 /* populate a buffer with pulse lengths */\r
299 i= 0;\r
300 j= 0;\r
301 while(i < GraphTraceLen)\r
302 {\r
303 // measure from low to low\r
3628c318 304 while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
955aa93f 305 ++i;\r
306 start= i;\r
3628c318 307 while((GraphBuffer[i] < high) && (i<GraphTraceLen))\r
955aa93f 308 ++i;\r
3628c318 309 while((GraphBuffer[i] > low) && (i<GraphTraceLen))\r
955aa93f 310 ++i;\r
3628c318 311 if (j>(MAX_GRAPH_TRACE_LEN/64)) {\r
312 break;\r
313 }\r
955aa93f 314 tmpbuff[j++]= i - start;\r
315 }\r
316\r
955aa93f 317 /* look for data start - should be 2 pairs of LW (pulses of 192,128) */\r
318 start= -1;\r
319 skip= 0;\r
320 for (i= 0; i < j - 4 ; ++i)\r
321 {\r
322 skip += tmpbuff[i];\r
323 if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
324 if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
325 if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
326 if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
327 {\r
328 start= i + 3;\r
329 break;\r
330 }\r
331 }\r
332 startblock= i + 3;\r
333\r
334 /* skip over the remainder of the LW */\r
335 skip += tmpbuff[i+1]+tmpbuff[i+2];\r
f81c82c3 336 while(skip < MAX_GRAPH_TRACE_LEN && GraphBuffer[skip] > low)\r
955aa93f 337 ++skip;\r
338 skip += 8;\r
339\r
340 /* now do it again to find the end */\r
341 end= start;\r
342 for (i += 3; i < j - 4 ; ++i)\r
343 {\r
344 end += tmpbuff[i];\r
345 if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
346 if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
347 if (tmpbuff[i+2] >= 190 && tmpbuff[i+2] <= 194)\r
348 if (tmpbuff[i+3] >= 126 && tmpbuff[i+3] <= 130)\r
349 {\r
350 complete= TRUE;\r
351 break;\r
352 }\r
353 }\r
354\r
355 if (start >= 0)\r
356 PrintToScrollback("Found data at sample: %i",skip);\r
357 else\r
358 {\r
359 PrintToScrollback("No data found!");\r
360 PrintToScrollback("Try again with more samples.");\r
361 return;\r
362 }\r
363\r
364 if (!complete)\r
365 {\r
366 PrintToScrollback("*** Warning!");\r
367 PrintToScrollback("Partial data - no end found!");\r
368 PrintToScrollback("Try again with more samples.");\r
369 }\r
370\r
371 /* get rid of leading crap */\r
372 sprintf(tmp,"%i",skip);\r
373 CmdLtrim(tmp);\r
374\r
375 /* now work through remaining buffer printing out data blocks */\r
376 block= 0;\r
377 i= startblock;\r
378 while(block < 6)\r
379 {\r
380 PrintToScrollback("Block %i:", block);\r
381 // mandemod routine needs to be split so we can call it for data\r
382 // just print for now for debugging\r
383 Cmdmanchesterdemod("i 64");\r
384 skip= 0;\r
385 /* look for LW before start of next block */\r
386 for ( ; i < j - 4 ; ++i)\r
387 {\r
388 skip += tmpbuff[i];\r
389 if (tmpbuff[i] >= 190 && tmpbuff[i] <= 194)\r
390 if (tmpbuff[i+1] >= 126 && tmpbuff[i+1] <= 130)\r
391 break;\r
392 }\r
393 while(GraphBuffer[skip] > low)\r
394 ++skip;\r
395 skip += 8;\r
396 sprintf(tmp,"%i",skip);\r
397 CmdLtrim(tmp);\r
398 start += skip;\r
399 block++;\r
400 }\r
401}\r
402\r
403\r
9760414b 404/* Read the ID of an EM410x tag.\r
405 * Format:\r
406 * 1111 1111 1 <-- standard non-repeatable header\r
407 * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
408 * ....\r
409 * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
410 * 0 <-- stop bit, end of tag\r
411 */\r
412static void CmdEM410xread(char *str)\r
413{\r
414 int i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;\r
415 int parity[4];\r
416 char id[11];\r
a91ff4c8 417 int retested = 0;\r
9760414b 418 int BitStream[MAX_GRAPH_TRACE_LEN];\r
419 high = low = 0;\r
15db5fb7 420\r
9760414b 421 /* Detect high and lows and clock */\r
422 for (i = 0; i < GraphTraceLen; i++)\r
423 {\r
424 if (GraphBuffer[i] > high)\r
425 high = GraphBuffer[i];\r
426 else if (GraphBuffer[i] < low)\r
427 low = GraphBuffer[i];\r
15db5fb7 428 }\r
429\r
9760414b 430 /* get clock */\r
431 clock = GetClock(str, high);\r
15db5fb7 432\r
9760414b 433 /* parity for our 4 columns */\r
434 parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
435 header = rows = 0;\r
15db5fb7 436\r
9760414b 437 /* manchester demodulate */\r
438 bit = bit2idx = 0;\r
439 for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
440 {\r
441 hithigh = 0;\r
442 hitlow = 0;\r
443 first = 1;\r
15db5fb7 444\r
9760414b 445 /* Find out if we hit both high and low peaks */\r
446 for (j = 0; j < clock; j++)\r
447 {\r
448 if (GraphBuffer[(i * clock) + j] == high)\r
449 hithigh = 1;\r
450 else if (GraphBuffer[(i * clock) + j] == low)\r
451 hitlow = 1;\r
15db5fb7 452\r
9760414b 453 /* it doesn't count if it's the first part of our read\r
454 because it's really just trailing from the last sequence */\r
455 if (first && (hithigh || hitlow))\r
456 hithigh = hitlow = 0;\r
457 else\r
458 first = 0;\r
15db5fb7 459\r
9760414b 460 if (hithigh && hitlow)\r
461 break;\r
462 }\r
67853904 463\r
9760414b 464 /* If we didn't hit both high and low peaks, we had a bit transition */\r
465 if (!hithigh || !hitlow)\r
466 bit ^= 1;\r
67853904 467\r
9760414b 468 BitStream[bit2idx++] = bit;\r
469 }\r
67853904 470\r
a91ff4c8 471retest:\r
9760414b 472 /* We go till 5 before the graph ends because we'll get that far below */\r
473 for (i = 1; i < bit2idx - 5; i++)\r
474 {\r
475 /* Step 2: We have our header but need our tag ID */\r
476 if (header == 9 && rows < 10)\r
477 {\r
478 /* Confirm parity is correct */\r
479 if ((BitStream[i] ^ BitStream[i+1] ^ BitStream[i+2] ^ BitStream[i+3]) == BitStream[i+4])\r
480 {\r
481 /* Read another byte! */\r
482 sprintf(id+rows, "%x", (8 * BitStream[i]) + (4 * BitStream[i+1]) + (2 * BitStream[i+2]) + (1 * BitStream[i+3]));\r
483 rows++;\r
15db5fb7 484\r
9760414b 485 /* Keep parity info */\r
486 parity[0] ^= BitStream[i];\r
487 parity[1] ^= BitStream[i+1];\r
488 parity[2] ^= BitStream[i+2];\r
489 parity[3] ^= BitStream[i+3];\r
15db5fb7 490\r
9760414b 491 /* Move 4 bits ahead */\r
492 i += 4;\r
493 }\r
15db5fb7 494\r
9760414b 495 /* Damn, something wrong! reset */\r
496 else\r
497 {\r
498 PrintToScrollback("Thought we had a valid tag but failed at word %d (i=%d)", rows + 1, i);\r
15db5fb7 499\r
9760414b 500 /* Start back rows * 5 + 9 header bits, -1 to not start at same place */\r
501 i -= 9 + (5 * rows) - 5;\r
502\r
503 rows = header = 0;\r
504 }\r
505 }\r
15db5fb7 506\r
9760414b 507 /* Step 3: Got our 40 bits! confirm column parity */\r
508 else if (rows == 10)\r
509 {\r
510 /* We need to make sure our 4 bits of parity are correct and we have a stop bit */\r
511 if (BitStream[i] == parity[0] && BitStream[i+1] == parity[1] &&\r
512 BitStream[i+2] == parity[2] && BitStream[i+3] == parity[3] &&\r
513 BitStream[i+4] == 0)\r
514 {\r
515 /* Sweet! */\r
516 PrintToScrollback("EM410x Tag ID: %s", id);\r
15db5fb7 517\r
9760414b 518 /* Stop any loops */\r
519 go = 0;\r
a91ff4c8 520 return;\r
9760414b 521 }\r
15db5fb7 522\r
9760414b 523 /* Crap! Incorrect parity or no stop bit, start all over */\r
524 else\r
525 {\r
526 rows = header = 0;\r
15db5fb7 527\r
9760414b 528 /* Go back 59 bits (9 header bits + 10 rows at 4+1 parity) */\r
529 i -= 59;\r
530 }\r
531 }\r
15db5fb7 532\r
9760414b 533 /* Step 1: get our header */\r
534 else if (header < 9)\r
535 {\r
536 /* Need 9 consecutive 1's */\r
537 if (BitStream[i] == 1)\r
538 header++;\r
15db5fb7 539\r
9760414b 540 /* We don't have a header, not enough consecutive 1 bits */\r
541 else\r
542 header = 0;\r
543 }\r
544 }\r
67853904 545\r
a91ff4c8 546 /* if we've already retested after flipping bits, return */\r
547 if (retested++)\r
548 return;\r
549\r
550 /* if this didn't work, try flipping bits */\r
551 for (i = 0; i < bit2idx; i++)\r
552 BitStream[i] ^= 1;\r
553\r
554 goto retest;\r
9760414b 555}\r
556\r
557/* emulate an EM410X tag\r
558 * Format:\r
559 * 1111 1111 1 <-- standard non-repeatable header\r
560 * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID\r
561 * ....\r
562 * CCCC <-- each bit here is parity for the 10 bits above in corresponding column\r
563 * 0 <-- stop bit, end of tag\r
564 */\r
565static void CmdEM410xsim(char *str)\r
566{\r
567 int i, n, j, h, binary[4], parity[4];\r
568 char *s = "0";\r
15db5fb7 569\r
9760414b 570 /* clock is 64 in EM410x tags */\r
571 int clock = 64;\r
15db5fb7 572\r
9760414b 573 /* clear our graph */\r
574 CmdClearGraph(0);\r
15db5fb7 575\r
9760414b 576 /* write it out a few times */\r
577 for (h = 0; h < 4; h++)\r
578 {\r
579 /* write 9 start bits */\r
580 for (i = 0; i < 9; i++)\r
581 CmdAppendGraph(0, clock, 1);\r
15db5fb7 582\r
9760414b 583 /* for each hex char */\r
584 parity[0] = parity[1] = parity[2] = parity[3] = 0;\r
585 for (i = 0; i < 10; i++)\r
586 {\r
587 /* read each hex char */\r
588 sscanf(&str[i], "%1x", &n);\r
589 for (j = 3; j >= 0; j--, n/= 2)\r
590 binary[j] = n % 2;\r
15db5fb7 591\r
9760414b 592 /* append each bit */\r
593 CmdAppendGraph(0, clock, binary[0]);\r
594 CmdAppendGraph(0, clock, binary[1]);\r
595 CmdAppendGraph(0, clock, binary[2]);\r
596 CmdAppendGraph(0, clock, binary[3]);\r
15db5fb7 597\r
9760414b 598 /* append parity bit */\r
599 CmdAppendGraph(0, clock, binary[0] ^ binary[1] ^ binary[2] ^ binary[3]);\r
15db5fb7 600\r
9760414b 601 /* keep track of column parity */\r
602 parity[0] ^= binary[0];\r
603 parity[1] ^= binary[1];\r
604 parity[2] ^= binary[2];\r
605 parity[3] ^= binary[3];\r
606 }\r
15db5fb7 607\r
9760414b 608 /* parity columns */\r
609 CmdAppendGraph(0, clock, parity[0]);\r
610 CmdAppendGraph(0, clock, parity[1]);\r
611 CmdAppendGraph(0, clock, parity[2]);\r
612 CmdAppendGraph(0, clock, parity[3]);\r
15db5fb7 613\r
9760414b 614 /* stop bit */\r
615 CmdAppendGraph(0, clock, 0);\r
616 }\r
15db5fb7 617\r
9760414b 618 /* modulate that biatch */\r
619 Cmdmanchestermod(s);\r
15db5fb7 620\r
9760414b 621 /* booyah! */\r
622 RepaintGraphWindow();\r
623\r
624 CmdLosim(s);\r
625}\r
626\r
627static void ChkBitstream(char *str)\r
628{\r
629 int i;\r
15db5fb7 630\r
9760414b 631 /* convert to bitstream if necessary */\r
632 for (i = 0; i < (int)(GraphTraceLen / 2); i++)\r
633 {\r
634 if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0)\r
635 {\r
636 Cmdbitstream(str);\r
637 break;\r
638 }\r
639 }\r
640}\r
641\r
642static void CmdLosim(char *str)\r
643{\r
644 int i;\r
15db5fb7 645\r
9760414b 646 /* convert to bitstream if necessary */\r
647 ChkBitstream(str);\r
15db5fb7 648\r
9760414b 649 for (i = 0; i < GraphTraceLen; i += 48) {\r
6658905f 650 UsbCommand c;\r
651 int j;\r
652 for(j = 0; j < 48; j++) {\r
653 c.d.asBytes[j] = GraphBuffer[i+j];\r
654 }\r
655 c.cmd = CMD_DOWNLOADED_SIM_SAMPLES_125K;\r
656 c.ext1 = i;\r
657 SendCommand(&c, FALSE);\r
658 }\r
659\r
660 UsbCommand c;\r
661 c.cmd = CMD_SIMULATE_TAG_125K;\r
662 c.ext1 = GraphTraceLen;\r
663 SendCommand(&c, FALSE);\r
664}\r
665\r
666static void CmdLoread(char *str)\r
667{\r
668 UsbCommand c;\r
669 // 'h' means higher-low-frequency, 134 kHz\r
670 if(*str == 'h') {\r
671 c.ext1 = 1;\r
672 } else if (*str == '\0') {\r
673 c.ext1 = 0;\r
674 } else {\r
675 PrintToScrollback("use 'loread' or 'loread h'");\r
676 return;\r
677 }\r
678 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
679 SendCommand(&c, FALSE);\r
680}\r
681\r
7f348042 682static void CmdDetectReader(char *str)\r
683{\r
684 UsbCommand c;\r
685 // 'l' means LF - 125/134 kHz\r
686 if(*str == 'l') {\r
687 c.ext1 = 1;\r
688 } else if (*str == 'h') {\r
689 c.ext1 = 2;\r
690 } else if (*str != '\0') {\r
691 PrintToScrollback("use 'detectreader' or 'detectreader l' or 'detectreader h'");\r
692 return;\r
693 }\r
694 c.cmd = CMD_LISTEN_READER_FIELD;\r
695 SendCommand(&c, FALSE);\r
696}\r
697\r
959baa89 698/* send a command before reading */\r
699static void CmdLoCommandRead(char *str)\r
700{\r
701 static char dummy[3];\r
702\r
703 dummy[0]= ' ';\r
67853904 704\r
959baa89 705 UsbCommand c;\r
706 c.cmd = CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
1dd23352 707 sscanf(str, "%i %i %i %s %s", &c.ext1, &c.ext2, &c.ext3, (char *) &c.d.asBytes,(char *) &dummy+1);\r
959baa89 708 // in case they specified 'h'\r
8172fb35 709 strcpy((char *)&c.d.asBytes + strlen((char *)c.d.asBytes), dummy);\r
959baa89 710 SendCommand(&c, FALSE);\r
711}\r
712\r
6658905f 713static void CmdLosamples(char *str)\r
714{\r
715 int cnt = 0;\r
716 int i;\r
717 int n;\r
718\r
719 n=atoi(str);\r
720 if (n==0) n=128;\r
721 if (n>16000) n=16000;\r
722\r
723 for(i = 0; i < n; i += 12) {\r
724 UsbCommand c;\r
725 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
726 c.ext1 = i;\r
727 SendCommand(&c, FALSE);\r
728 ReceiveCommand(&c);\r
729 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 730 if (!go)\r
731 PrintToScrollback("bad resp");\r
6658905f 732 return;\r
733 }\r
734 int j;\r
735 for(j = 0; j < 48; j++) {\r
736 GraphBuffer[cnt++] = ((int)c.d.asBytes[j]) - 128;\r
737 }\r
738 }\r
739 GraphTraceLen = n*4;\r
740 RepaintGraphWindow();\r
741}\r
742\r
743static void CmdBitsamples(char *str)\r
744{\r
745 int cnt = 0;\r
746 int i;\r
747 int n;\r
748\r
749 n = 3072;\r
750 for(i = 0; i < n; i += 12) {\r
751 UsbCommand c;\r
752 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
753 c.ext1 = i;\r
754 SendCommand(&c, FALSE);\r
755 ReceiveCommand(&c);\r
756 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 757 PrintToScrollback("bad resp");\r
6658905f 758 return;\r
759 }\r
760 int j, k;\r
761 for(j = 0; j < 48; j++) {\r
762 for(k = 0; k < 8; k++) {\r
763 if(c.d.asBytes[j] & (1 << (7 - k))) {\r
764 GraphBuffer[cnt++] = 1;\r
765 } else {\r
766 GraphBuffer[cnt++] = 0;\r
767 }\r
768 }\r
769 }\r
770 }\r
771 GraphTraceLen = cnt;\r
772 RepaintGraphWindow();\r
773}\r
774\r
775static void CmdHisamples(char *str)\r
776{\r
777 int cnt = 0;\r
778 int i;\r
779 int n;\r
780 n = 1000;\r
781 for(i = 0; i < n; i += 12) {\r
782 UsbCommand c;\r
783 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
784 c.ext1 = i;\r
785 SendCommand(&c, FALSE);\r
786 ReceiveCommand(&c);\r
787 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 788 PrintToScrollback("bad resp");\r
6658905f 789 return;\r
790 }\r
791 int j;\r
792 for(j = 0; j < 48; j++) {\r
793 GraphBuffer[cnt++] = (int)((BYTE)c.d.asBytes[j]);\r
794 }\r
795 }\r
796 GraphTraceLen = n*4;\r
797\r
798 RepaintGraphWindow();\r
799}\r
800\r
6658905f 801static int CmdHisamplest(char *str, int nrlow)\r
802{\r
803 int cnt = 0;\r
804 int t1, t2;\r
805 int i;\r
806 int n;\r
807 int hasbeennull;\r
808 int show;\r
809\r
810\r
811 n = 1000;\r
812 hasbeennull = 0;\r
813 for(i = 0; i < n; i += 12) {\r
814 UsbCommand c;\r
815 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
816 c.ext1 = i;\r
817 SendCommand(&c, FALSE);\r
818 ReceiveCommand(&c);\r
819 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 820 PrintToScrollback("bad resp");\r
6658905f 821 return 0;\r
822 }\r
823 int j;\r
824 for(j = 0; j < 48; j++) {\r
825 t2 = (int)((BYTE)c.d.asBytes[j]);\r
826 if((t2 ^ 0xC0) & 0xC0) { hasbeennull++; }\r
827\r
828 show = 0;\r
829 switch(show) {\r
830 case 0:\r
831 // combined\r
832 t1 = (t2 & 0x80) ^ (t2 & 0x20);\r
833 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x20);\r
834 break;\r
835\r
836 case 1:\r
837 // only reader\r
838 t1 = (t2 & 0x80);\r
839 t2 = ((t2 << 1) & 0x80);\r
840 break;\r
841\r
842 case 2:\r
843 // only tag\r
844 t1 = (t2 & 0x20);\r
845 t2 = ((t2 << 1) & 0x20);\r
846 break;\r
847\r
848 case 3:\r
849 // both, but tag with other algorithm\r
850 t1 = (t2 & 0x80) ^ (t2 & 0x08);\r
851 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x08);\r
852 break;\r
853 }\r
854\r
855 GraphBuffer[cnt++] = t1;\r
856 GraphBuffer[cnt++] = t2;\r
857 }\r
858 }\r
859 GraphTraceLen = n*4;\r
860// 1130\r
861 if(hasbeennull>nrlow || nrlow==0) {\r
862 PrintToScrollback("hasbeennull=%d", hasbeennull);\r
863 return 1;\r
864 }\r
865 else {\r
866 return 0;\r
867 }\r
868}\r
869\r
870\r
871static void CmdHexsamples(char *str)\r
872{\r
873 int i;\r
874 int n;\r
875\r
876 if(atoi(str) == 0) {\r
877 n = 12;\r
878 } else {\r
879 n = atoi(str)/4;\r
880 }\r
881\r
882 for(i = 0; i < n; i += 12) {\r
883 UsbCommand c;\r
884 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
885 c.ext1 = i;\r
886 SendCommand(&c, FALSE);\r
887 ReceiveCommand(&c);\r
888 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 889 PrintToScrollback("bad resp");\r
6658905f 890 return;\r
891 }\r
892 int j;\r
893 for(j = 0; j < 48; j += 8) {\r
894 PrintToScrollback("%02x %02x %02x %02x %02x %02x %02x %02x",\r
895 c.d.asBytes[j+0],\r
896 c.d.asBytes[j+1],\r
897 c.d.asBytes[j+2],\r
898 c.d.asBytes[j+3],\r
899 c.d.asBytes[j+4],\r
900 c.d.asBytes[j+5],\r
901 c.d.asBytes[j+6],\r
902 c.d.asBytes[j+7],\r
903 c.d.asBytes[j+8]\r
904 );\r
905 }\r
906 }\r
907}\r
908\r
909static void CmdHisampless(char *str)\r
910{\r
911 int cnt = 0;\r
912 int i;\r
913 int n;\r
914\r
915 if(atoi(str) == 0) {\r
916 n = 1000;\r
917 } else {\r
918 n = atoi(str)/4;\r
919 }\r
920\r
921 for(i = 0; i < n; i += 12) {\r
922 UsbCommand c;\r
923 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
924 c.ext1 = i;\r
925 SendCommand(&c, FALSE);\r
926 ReceiveCommand(&c);\r
927 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
9760414b 928 PrintToScrollback("bad resp");\r
6658905f 929 return;\r
930 }\r
931 int j;\r
932 for(j = 0; j < 48; j++) {\r
933 GraphBuffer[cnt++] = (int)((signed char)c.d.asBytes[j]);\r
934 }\r
935 }\r
936 GraphTraceLen = cnt;\r
937\r
938 RepaintGraphWindow();\r
939}\r
940\r
941static WORD Iso15693Crc(BYTE *v, int n)\r
942{\r
943 DWORD reg;\r
944 int i, j;\r
945\r
946 reg = 0xffff;\r
947 for(i = 0; i < n; i++) {\r
948 reg = reg ^ ((DWORD)v[i]);\r
949 for (j = 0; j < 8; j++) {\r
950 if (reg & 0x0001) {\r
951 reg = (reg >> 1) ^ 0x8408;\r
952 } else {\r
953 reg = (reg >> 1);\r
954 }\r
955 }\r
956 }\r
957\r
958 return (WORD)~reg;\r
959}\r
960\r
961static void CmdHi14bdemod(char *str)\r
962{\r
963 int i, j, iold;\r
964 int isum, qsum;\r
965 int outOfWeakAt;\r
966 BOOL negateI, negateQ;\r
967\r
968 BYTE data[256];\r
969 int dataLen=0;\r
970\r
971 // As received, the samples are pairs, correlations against I and Q\r
972 // square waves. So estimate angle of initial carrier (or just\r
973 // quadrant, actually), and then do the demod.\r
974\r
975 // First, estimate where the tag starts modulating.\r
976 for(i = 0; i < GraphTraceLen; i += 2) {\r
977 if(abs(GraphBuffer[i]) + abs(GraphBuffer[i+1]) > 40) {\r
978 break;\r
979 }\r
980 }\r
981 if(i >= GraphTraceLen) {\r
982 PrintToScrollback("too weak to sync");\r
983 return;\r
984 }\r
985 PrintToScrollback("out of weak at %d", i);\r
986 outOfWeakAt = i;\r
987\r
988 // Now, estimate the phase in the initial modulation of the tag\r
989 isum = 0;\r
990 qsum = 0;\r
991 for(; i < (outOfWeakAt + 16); i += 2) {\r
992 isum += GraphBuffer[i+0];\r
993 qsum += GraphBuffer[i+1];\r
994 }\r
995 negateI = (isum < 0);\r
996 negateQ = (qsum < 0);\r
997\r
998 // Turn the correlation pairs into soft decisions on the bit.\r
999 j = 0;\r
1000 for(i = 0; i < GraphTraceLen/2; i++) {\r
1001 int si = GraphBuffer[j];\r
1002 int sq = GraphBuffer[j+1];\r
1003 if(negateI) si = -si;\r
1004 if(negateQ) sq = -sq;\r
1005 GraphBuffer[i] = si + sq;\r
1006 j += 2;\r
1007 }\r
1008 GraphTraceLen = i;\r
1009\r
1010 i = outOfWeakAt/2;\r
1011 while(GraphBuffer[i] > 0 && i < GraphTraceLen)\r
1012 i++;\r
1013 if(i >= GraphTraceLen) goto demodError;\r
1014\r
1015 iold = i;\r
1016 while(GraphBuffer[i] < 0 && i < GraphTraceLen)\r
1017 i++;\r
1018 if(i >= GraphTraceLen) goto demodError;\r
1019 if((i - iold) > 23) goto demodError;\r
1020\r
1021 PrintToScrollback("make it to demod loop");\r
1022\r
1023 for(;;) {\r
1024 iold = i;\r
1025 while(GraphBuffer[i] >= 0 && i < GraphTraceLen)\r
1026 i++;\r
1027 if(i >= GraphTraceLen) goto demodError;\r
1028 if((i - iold) > 6) goto demodError;\r
1029\r
1030 WORD shiftReg = 0;\r
1031 if(i + 20 >= GraphTraceLen) goto demodError;\r
1032\r
1033 for(j = 0; j < 10; j++) {\r
1034 int soft = GraphBuffer[i] + GraphBuffer[i+1];\r
1035\r
1036 if(abs(soft) < ((abs(isum) + abs(qsum))/20)) {\r
1037 PrintToScrollback("weak bit");\r
1038 }\r
1039\r
1040 shiftReg >>= 1;\r
1041 if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {\r
1042 shiftReg |= 0x200;\r
1043 }\r
1044\r
1045 i+= 2;\r
1046 }\r
1047\r
1048 if( (shiftReg & 0x200) &&\r
1049 !(shiftReg & 0x001))\r
1050 {\r
1051 // valid data byte, start and stop bits okay\r
1052 PrintToScrollback(" %02x", (shiftReg >> 1) & 0xff);\r
1053 data[dataLen++] = (shiftReg >> 1) & 0xff;\r
1054 if(dataLen >= sizeof(data)) {\r
1055 return;\r
1056 }\r
1057 } else if(shiftReg == 0x000) {\r
1058 // this is EOF\r
1059 break;\r
1060 } else {\r
1061 goto demodError;\r
1062 }\r
1063 }\r
1064\r
1065 BYTE first, second;\r
1066 ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);\r
1067 PrintToScrollback("CRC: %02x %02x (%s)\n", first, second,\r
1068 (first == data[dataLen-2] && second == data[dataLen-1]) ?\r
1069 "ok" : "****FAIL****");\r
1070\r
1071 RepaintGraphWindow();\r
1072 return;\r
1073\r
1074demodError:\r
1075 PrintToScrollback("demod error");\r
1076 RepaintGraphWindow();\r
1077}\r
1078\r
1079static void CmdHi14list(char *str)\r
1080{\r
1081 BYTE got[960];\r
1082 GetFromBigBuf(got, sizeof(got));\r
1083\r
1084 PrintToScrollback("recorded activity:");\r
1085 PrintToScrollback(" time :rssi: who bytes");\r
1086 PrintToScrollback("---------+----+----+-----------");\r
1087\r
1088 int i = 0;\r
1089 int prev = -1;\r
1090\r
1091 for(;;) {\r
1092 if(i >= 900) {\r
1093 break;\r
1094 }\r
1095\r
1096 BOOL isResponse;\r
1097 int timestamp = *((DWORD *)(got+i));\r
1098 if(timestamp & 0x80000000) {\r
1099 timestamp &= 0x7fffffff;\r
1100 isResponse = 1;\r
1101 } else {\r
1102 isResponse = 0;\r
1103 }\r
1104 int metric = *((DWORD *)(got+i+4));\r
1105\r
1106 int len = got[i+8];\r
1107\r
1108 if(len > 100) {\r
1109 break;\r
1110 }\r
1111 if(i + len >= 900) {\r
1112 break;\r
1113 }\r
1114\r
1115 BYTE *frame = (got+i+9);\r
1116\r
1117 char line[1000] = "";\r
1118 int j;\r
1119 for(j = 0; j < len; j++) {\r
1120 sprintf(line+(j*3), "%02x ", frame[j]);\r
1121 }\r
1122\r
1123 char *crc;\r
1124 if(len > 2) {\r
1125 BYTE b1, b2;\r
1126 ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);\r
1127 if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
1128 crc = "**FAIL CRC**";\r
1129 } else {\r
1130 crc = "";\r
1131 }\r
1132 } else {\r
1133 crc = "(SHORT)";\r
1134 }\r
1135\r
1136 char metricString[100];\r
1137 if(isResponse) {\r
1138 sprintf(metricString, "%3d", metric);\r
1139 } else {\r
1140 strcpy(metricString, " ");\r
1141 }\r
1142\r
1143 PrintToScrollback(" +%7d: %s: %s %s %s",\r
1144 (prev < 0 ? 0 : timestamp - prev),\r
1145 metricString,\r
1146 (isResponse ? "TAG" : " "), line, crc);\r
1147\r
1148 prev = timestamp;\r
1149 i += (len + 9);\r
1150 }\r
1151}\r
1152\r
1153static void CmdHi14alist(char *str)\r
1154{\r
1155 BYTE got[1920];\r
1156 GetFromBigBuf(got, sizeof(got));\r
1157\r
1158 PrintToScrollback("recorded activity:");\r
1159 PrintToScrollback(" ETU :rssi: who bytes");\r
1160 PrintToScrollback("---------+----+----+-----------");\r
1161\r
1162 int i = 0;\r
1163 int prev = -1;\r
1164\r
1165 for(;;) {\r
1166 if(i >= 1900) {\r
1167 break;\r
1168 }\r
1169\r
1170 BOOL isResponse;\r
1171 int timestamp = *((DWORD *)(got+i));\r
1172 if(timestamp & 0x80000000) {\r
1173 timestamp &= 0x7fffffff;\r
1174 isResponse = 1;\r
1175 } else {\r
1176 isResponse = 0;\r
1177 }\r
1178\r
1179 int metric = 0;\r
1180 int parityBits = *((DWORD *)(got+i+4));\r
1181 // 4 bytes of additional information...\r
1182 // maximum of 32 additional parity bit information\r
1183 //\r
1184 // TODO:\r
1185 // at each quarter bit period we can send power level (16 levels)\r
1186 // or each half bit period in 256 levels.\r
1187\r
1188\r
1189 int len = got[i+8];\r
1190\r
1191 if(len > 100) {\r
1192 break;\r
1193 }\r
1194 if(i + len >= 1900) {\r
1195 break;\r
1196 }\r
1197\r
1198 BYTE *frame = (got+i+9);\r
1199\r
1200 // Break and stick with current result if buffer was not completely full\r
1201 if(frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }\r
1202\r
1203 char line[1000] = "";\r
1204 int j;\r
1205 for(j = 0; j < len; j++) {\r
1206 int oddparity = 0x01;\r
1207 int k;\r
1208\r
1209 for(k=0;k<8;k++) {\r
1210 oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);\r
1211 }\r
1212\r
1213 //if((parityBits >> (len - j - 1)) & 0x01) {\r
1214 if(isResponse && (oddparity != ((parityBits >> (len - j - 1)) & 0x01))) {\r
1215 sprintf(line+(j*4), "%02x! ", frame[j]);\r
1216 }\r
1217 else {\r
1218 sprintf(line+(j*4), "%02x ", frame[j]);\r
1219 }\r
1220 }\r
1221\r
1222 char *crc;\r
1223 crc = "";\r
1224 if(len > 2) {\r
1225 BYTE b1, b2;\r
1226 for(j = 0; j < (len - 1); j++) {\r
1227 // gives problems... search for the reason..\r
1228 /*if(frame[j] == 0xAA) {\r
1229 switch(frame[j+1]) {\r
1230 case 0x01:\r
1231 crc = "[1] Two drops close after each other";\r
1232 break;\r
1233 case 0x02:\r
1234 crc = "[2] Potential SOC with a drop in second half of bitperiod";\r
1235 break;\r
1236 case 0x03:\r
1237 crc = "[3] Segment Z after segment X is not possible";\r
1238 break;\r
1239 case 0x04:\r
1240 crc = "[4] Parity bit of a fully received byte was wrong";\r
1241 break;\r
1242 default:\r
1243 crc = "[?] Unknown error";\r
1244 break;\r
1245 }\r
1246 break;\r
1247 }*/\r
1248 }\r
1249\r
1250 if(strlen(crc)==0) {\r
1251 ComputeCrc14443(CRC_14443_A, frame, len-2, &b1, &b2);\r
1252 if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
1253 crc = (isResponse & (len < 6)) ? "" : " !crc";\r
1254 } else {\r
1255 crc = "";\r
1256 }\r
1257 }\r
1258 } else {\r
1259 crc = ""; // SHORT\r
1260 }\r
1261\r
1262 char metricString[100];\r
1263 if(isResponse) {\r
1264 sprintf(metricString, "%3d", metric);\r
1265 } else {\r
1266 strcpy(metricString, " ");\r
1267 }\r
1268\r
1269 PrintToScrollback(" +%7d: %s: %s %s %s",\r
1270 (prev < 0 ? 0 : (timestamp - prev)),\r
1271 metricString,\r
1272 (isResponse ? "TAG" : " "), line, crc);\r
1273\r
1274 prev = timestamp;\r
1275 i += (len + 9);\r
1276 }\r
1277 CommandFinished = 1;\r
1278}\r
1279\r
1280static void CmdHi15demod(char *str)\r
1281{\r
1282 // The sampling rate is 106.353 ksps/s, for T = 18.8 us\r
1283\r
0e25ae11 1284 // SOF defined as\r
6658905f 1285 // 1) Unmodulated time of 56.64us\r
1286 // 2) 24 pulses of 423.75khz\r
1287 // 3) logic '1' (unmodulated for 18.88us followed by 8 pulses of 423.75khz)\r
1288\r
1289 static const int FrameSOF[] = {\r
1290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1292 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1293 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1294 -1, -1, -1, -1,\r
1295 -1, -1, -1, -1,\r
1296 1, 1, 1, 1,\r
1297 1, 1, 1, 1\r
1298 };\r
1299 static const int Logic0[] = {\r
1300 1, 1, 1, 1,\r
1301 1, 1, 1, 1,\r
1302 -1, -1, -1, -1,\r
1303 -1, -1, -1, -1\r
1304 };\r
1305 static const int Logic1[] = {\r
1306 -1, -1, -1, -1,\r
1307 -1, -1, -1, -1,\r
1308 1, 1, 1, 1,\r
1309 1, 1, 1, 1\r
1310 };\r
1311\r
0e25ae11 1312 // EOF defined as\r
6658905f 1313 // 1) logic '0' (8 pulses of 423.75khz followed by unmodulated for 18.88us)\r
1314 // 2) 24 pulses of 423.75khz\r
1315 // 3) Unmodulated time of 56.64us\r
1316\r
1317 static const int FrameEOF[] = {\r
1318 1, 1, 1, 1,\r
1319 1, 1, 1, 1,\r
1320 -1, -1, -1, -1,\r
1321 -1, -1, -1, -1,\r
1322 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1323 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1\r
1326 };\r
1327\r
1328 int i, j;\r
1329 int max = 0, maxPos;\r
1330\r
1331 int skip = 4;\r
1332\r
1333 if(GraphTraceLen < 1000) return;\r
1334\r
1335 // First, correlate for SOF\r
1336 for(i = 0; i < 100; i++) {\r
1337 int corr = 0;\r
1338 for(j = 0; j < arraylen(FrameSOF); j += skip) {\r
1339 corr += FrameSOF[j]*GraphBuffer[i+(j/skip)];\r
1340 }\r
1341 if(corr > max) {\r
1342 max = corr;\r
1343 maxPos = i;\r
1344 }\r
1345 }\r
1346 PrintToScrollback("SOF at %d, correlation %d", maxPos,\r
1347 max/(arraylen(FrameSOF)/skip));\r
1348\r
1349 i = maxPos + arraylen(FrameSOF)/skip;\r
1350 int k = 0;\r
1351 BYTE outBuf[20];\r
1352 memset(outBuf, 0, sizeof(outBuf));\r
1353 BYTE mask = 0x01;\r
1354 for(;;) {\r
1355 int corr0 = 0, corr1 = 0, corrEOF = 0;\r
1356 for(j = 0; j < arraylen(Logic0); j += skip) {\r
1357 corr0 += Logic0[j]*GraphBuffer[i+(j/skip)];\r
1358 }\r
1359 for(j = 0; j < arraylen(Logic1); j += skip) {\r
1360 corr1 += Logic1[j]*GraphBuffer[i+(j/skip)];\r
1361 }\r
1362 for(j = 0; j < arraylen(FrameEOF); j += skip) {\r
1363 corrEOF += FrameEOF[j]*GraphBuffer[i+(j/skip)];\r
1364 }\r
1365 // Even things out by the length of the target waveform.\r
1366 corr0 *= 4;\r
1367 corr1 *= 4;\r
1368\r
1369 if(corrEOF > corr1 && corrEOF > corr0) {\r
1370 PrintToScrollback("EOF at %d", i);\r
1371 break;\r
1372 } else if(corr1 > corr0) {\r
1373 i += arraylen(Logic1)/skip;\r
1374 outBuf[k] |= mask;\r
1375 } else {\r
1376 i += arraylen(Logic0)/skip;\r
1377 }\r
1378 mask <<= 1;\r
1379 if(mask == 0) {\r
1380 k++;\r
1381 mask = 0x01;\r
1382 }\r
1383 if((i+(int)arraylen(FrameEOF)) >= GraphTraceLen) {\r
1384 PrintToScrollback("ran off end!");\r
1385 break;\r
1386 }\r
1387 }\r
1388 if(mask != 0x01) {\r
1389 PrintToScrollback("error, uneven octet! (discard extra bits!)");\r
1390 PrintToScrollback(" mask=%02x", mask);\r
1391 }\r
1392 PrintToScrollback("%d octets", k);\r
1393\r
1394 for(i = 0; i < k; i++) {\r
1395 PrintToScrollback("# %2d: %02x ", i, outBuf[i]);\r
1396 }\r
1397 PrintToScrollback("CRC=%04x", Iso15693Crc(outBuf, k-2));\r
1398}\r
1399\r
67853904 1400static void CmdFSKdemod(char *cmdline)\r
1401{\r
1402 static const int LowTone[] = {\r
1403 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
1404 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
1405 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
1406 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
1407 1, 1, 1, 1, 1, -1, -1, -1, -1, -1\r
1408 };\r
1409 static const int HighTone[] = {\r
1410 1, 1, 1, 1, 1, -1, -1, -1, -1,\r
1411 1, 1, 1, 1, -1, -1, -1, -1,\r
1412 1, 1, 1, 1, -1, -1, -1, -1,\r
1413 1, 1, 1, 1, -1, -1, -1, -1,\r
1414 1, 1, 1, 1, -1, -1, -1, -1,\r
1415 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
1416 };\r
1417\r
7381e8f2 1418 int lowLen = sizeof(LowTone)/sizeof(int);\r
1419 int highLen = sizeof(HighTone)/sizeof(int);\r
1420 int convLen = (highLen>lowLen)?highLen:lowLen;\r
67853904 1421 DWORD hi = 0, lo = 0;\r
1422\r
1423 int i, j;\r
1424 int minMark=0, maxMark=0;\r
67853904 1425\r
1426 for(i = 0; i < GraphTraceLen - convLen; i++) {\r
1427 int lowSum = 0, highSum = 0;\r
1428\r
1429 for(j = 0; j < lowLen; j++) {\r
1430 lowSum += LowTone[j]*GraphBuffer[i+j];\r
1431 }\r
1432 for(j = 0; j < highLen; j++) {\r
1433 highSum += HighTone[j]*GraphBuffer[i+j];\r
1434 }\r
1435 lowSum = abs((100*lowSum) / lowLen);\r
1436 highSum = abs((100*highSum) / highLen);\r
1437 GraphBuffer[i] = (highSum << 16) | lowSum;\r
1438 }\r
1439\r
1440 for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
1441 int j;\r
1442 int lowTot = 0, highTot = 0;\r
1443 // 10 and 8 are f_s divided by f_l and f_h, rounded\r
1444 for(j = 0; j < 10; j++) {\r
1445 lowTot += (GraphBuffer[i+j] & 0xffff);\r
1446 }\r
1447 for(j = 0; j < 8; j++) {\r
1448 highTot += (GraphBuffer[i+j] >> 16);\r
1449 }\r
1450 GraphBuffer[i] = lowTot - highTot;\r
1451 if (GraphBuffer[i]>maxMark) maxMark=GraphBuffer[i];\r
1452 if (GraphBuffer[i]<minMark) minMark=GraphBuffer[i];\r
1453 }\r
1454\r
1455 GraphTraceLen -= (convLen + 16);\r
1456\r
1457 RepaintGraphWindow();\r
1458\r
1459 // Find bit-sync (3 lo followed by 3 high)\r
1460 int max = 0, maxPos = 0;\r
1461 for(i = 0; i < 6000; i++) {\r
1462 int dec = 0;\r
7381e8f2 1463 for(j = 0; j < 3*lowLen; j++) {\r
67853904 1464 dec -= GraphBuffer[i+j];\r
1465 }\r
7381e8f2 1466 for(; j < 3*(lowLen + highLen ); j++) {\r
67853904 1467 dec += GraphBuffer[i+j];\r
1468 }\r
1469 if(dec > max) {\r
1470 max = dec;\r
1471 maxPos = i;\r
1472 }\r
1473 }\r
1474\r
1475 // place start of bit sync marker in graph\r
1476 GraphBuffer[maxPos] = maxMark;\r
1477 GraphBuffer[maxPos+1] = minMark;\r
1478\r
1479 maxPos += j;\r
1480\r
1481 // place end of bit sync marker in graph\r
1482 GraphBuffer[maxPos] = maxMark;\r
1483 GraphBuffer[maxPos+1] = minMark;\r
1484\r
1485 PrintToScrollback("actual data bits start at sample %d", maxPos);\r
7381e8f2 1486 PrintToScrollback("length %d/%d", highLen, lowLen);\r
67853904 1487\r
1488 BYTE bits[46];\r
1489 bits[sizeof(bits)-1] = '\0';\r
1490\r
1491 // find bit pairs and manchester decode them\r
1492 for(i = 0; i < arraylen(bits)-1; i++) {\r
1493 int dec = 0;\r
7381e8f2 1494 for(j = 0; j < lowLen; j++) {\r
67853904 1495 dec -= GraphBuffer[maxPos+j];\r
1496 }\r
7381e8f2 1497 for(; j < lowLen + highLen; j++) {\r
67853904 1498 dec += GraphBuffer[maxPos+j];\r
1499 }\r
1500 maxPos += j;\r
1501 // place inter bit marker in graph\r
1502 GraphBuffer[maxPos] = maxMark;\r
1503 GraphBuffer[maxPos+1] = minMark;\r
1504\r
1505 // hi and lo form a 64 bit pair\r
1506 hi = (hi<<1)|(lo>>31);\r
1507 lo = (lo<<1);\r
1508 // store decoded bit as binary (in hi/lo) and text (in bits[])\r
1509 if(dec<0) {\r
1510 bits[i] = '1';\r
1511 lo|=1;\r
1512 } else {\r
1513 bits[i] = '0';\r
1514 }\r
1515 }\r
1516 PrintToScrollback("bits: '%s'", bits);\r
1517 PrintToScrollback("hex: %08x %08x", hi, lo);\r
1518}\r
1519\r
9bea179a 1520// read a TI tag and return its ID\r
1521static void CmdTIRead(char *str)\r
1522{\r
1523 UsbCommand c;\r
1524 c.cmd = CMD_READ_TI_TYPE;\r
1525 SendCommand(&c, FALSE);\r
1526}\r
1527\r
1528// write new data to a r/w TI tag\r
1529static void CmdTIWrite(char *str)\r
1530{\r
1531 UsbCommand c;\r
1532 int res=0;\r
1533\r
1534 c.cmd = CMD_WRITE_TI_TYPE;\r
1535 res = sscanf(str, "0x%x 0x%x 0x%x ", &c.ext1, &c.ext2, &c.ext3);\r
1536 if (res == 2) c.ext3=0;\r
1537 if (res<2)\r
7381e8f2 1538 PrintToScrollback("Please specify the data as two hex strings, optionally the CRC as a third");\r
3628c318 1539 else\r
9bea179a 1540 SendCommand(&c, FALSE);\r
1541}\r
1542\r
1543static void CmdTIDemod(char *cmdline)\r
6658905f 1544{\r
1545 /* MATLAB as follows:\r
1546f_s = 2000000; % sampling frequency\r
1547f_l = 123200; % low FSK tone\r
1548f_h = 134200; % high FSK tone\r
1549\r
1550T_l = 119e-6; % low bit duration\r
1551T_h = 130e-6; % high bit duration\r
1552\r
1553l = 2*pi*ones(1, floor(f_s*T_l))*(f_l/f_s);\r
1554h = 2*pi*ones(1, floor(f_s*T_h))*(f_h/f_s);\r
1555\r
1556l = sign(sin(cumsum(l)));\r
1557h = sign(sin(cumsum(h)));\r
1558 */\r
7381e8f2 1559\r
1560// 2M*16/134.2k = 238\r
67853904 1561 static const int LowTone[] = {\r
7381e8f2 1562 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1563 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1564 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1565 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1566 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1567 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1568 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1569 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1570 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1571 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1572 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1573 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1574 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1575 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1576 1, 1, 1, 1, 1, 1, 1, 1, -1, -1\r
67853904 1577 };\r
7381e8f2 1578// 2M*16/123.2k = 260\r
67853904 1579 static const int HighTone[] = {\r
7381e8f2 1580 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1581 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1582 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1583 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1584 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1585 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1586 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1587 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1588 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1589 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1590 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1591 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1592 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1593 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1594 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1595 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1596 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
1597 1, 1, 1, 1, 1, 1, 1, 1\r
67853904 1598 };\r
7381e8f2 1599 int lowLen = sizeof(LowTone)/sizeof(int);\r
1600 int highLen = sizeof(HighTone)/sizeof(int);\r
1601 int convLen = (highLen>lowLen)?highLen:lowLen;\r
0c2ed92d 1602 WORD crc;\r
7381e8f2 1603 int i, j, TagType;\r
1604 int lowSum = 0, highSum = 0;;\r
1605 int lowTot = 0, highTot = 0;\r
1606\r
6658905f 1607 for(i = 0; i < GraphTraceLen - convLen; i++) {\r
7381e8f2 1608 lowSum = 0;\r
1609 highSum = 0;;\r
6658905f 1610\r
1611 for(j = 0; j < lowLen; j++) {\r
1612 lowSum += LowTone[j]*GraphBuffer[i+j];\r
1613 }\r
1614 for(j = 0; j < highLen; j++) {\r
1615 highSum += HighTone[j]*GraphBuffer[i+j];\r
1616 }\r
1617 lowSum = abs((100*lowSum) / lowLen);\r
1618 highSum = abs((100*highSum) / highLen);\r
7381e8f2 1619 lowSum = (lowSum<0)?-lowSum:lowSum;\r
1620 highSum = (highSum<0)?-highSum:highSum;\r
1621\r
6658905f 1622 GraphBuffer[i] = (highSum << 16) | lowSum;\r
1623 }\r
1624\r
1625 for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
7381e8f2 1626 lowTot = 0;\r
1627 highTot = 0;\r
6658905f 1628 // 16 and 15 are f_s divided by f_l and f_h, rounded\r
1629 for(j = 0; j < 16; j++) {\r
1630 lowTot += (GraphBuffer[i+j] & 0xffff);\r
1631 }\r
1632 for(j = 0; j < 15; j++) {\r
1633 highTot += (GraphBuffer[i+j] >> 16);\r
1634 }\r
1635 GraphBuffer[i] = lowTot - highTot;\r
1636 }\r
1637\r
1638 GraphTraceLen -= (convLen + 16);\r
1639\r
1640 RepaintGraphWindow();\r
1641\r
0c2ed92d 1642 // TI tag data format is 16 prebits, 8 start bits, 64 data bits,\r
1643 // 16 crc CCITT bits, 8 stop bits, 15 end bits\r
1644\r
1645 // the 16 prebits are always low\r
1646 // the 8 start and stop bits of a tag must match\r
1647 // the start/stop prebits of a ro tag are 01111110\r
1648 // the start/stop prebits of a rw tag are 11111110\r
1649 // the 15 end bits of a ro tag are all low\r
1650 // the 15 end bits of a rw tag match bits 15-1 of the data bits\r
6658905f 1651\r
0c2ed92d 1652 // Okay, so now we have unsliced soft decisions;\r
1653 // find bit-sync, and then get some bits.\r
1654 // look for 17 low bits followed by 6 highs (common pattern for ro and rw tags)\r
6658905f 1655 int max = 0, maxPos = 0;\r
1656 for(i = 0; i < 6000; i++) {\r
1657 int j;\r
1658 int dec = 0;\r
0c2ed92d 1659 // searching 17 consecutive lows\r
7381e8f2 1660 for(j = 0; j < 17*lowLen; j++) {\r
6658905f 1661 dec -= GraphBuffer[i+j];\r
1662 }\r
0c2ed92d 1663 // searching 7 consecutive highs\r
7381e8f2 1664 for(; j < 17*lowLen + 6*highLen; j++) {\r
6658905f 1665 dec += GraphBuffer[i+j];\r
1666 }\r
1667 if(dec > max) {\r
1668 max = dec;\r
1669 maxPos = i;\r
1670 }\r
1671 }\r
6658905f 1672\r
0c2ed92d 1673 // place a marker in the buffer to visually aid location\r
1674 // of the start of sync\r
6658905f 1675 GraphBuffer[maxPos] = 800;\r
1676 GraphBuffer[maxPos+1] = -800;\r
6658905f 1677\r
0c2ed92d 1678 // advance pointer to start of actual data stream (after 16 pre and 8 start bits)\r
7381e8f2 1679 maxPos += 17*lowLen;\r
1680 maxPos += 6*highLen;\r
0c2ed92d 1681\r
1682 // place a marker in the buffer to visually aid location\r
1683 // of the end of sync\r
6658905f 1684 GraphBuffer[maxPos] = 800;\r
1685 GraphBuffer[maxPos+1] = -800;\r
1686\r
1687 PrintToScrollback("actual data bits start at sample %d", maxPos);\r
1688\r
7381e8f2 1689 PrintToScrollback("length %d/%d", highLen, lowLen);\r
6658905f 1690\r
0c2ed92d 1691 BYTE bits[1+64+16+8+16];\r
6658905f 1692 bits[sizeof(bits)-1] = '\0';\r
1693\r
0c2ed92d 1694 DWORD shift3 = 0x7e000000, shift2 = 0, shift1 = 0, shift0 = 0;\r
1695\r
1696 for(i = 0; i < arraylen(bits)-1; i++) {\r
6658905f 1697 int high = 0;\r
1698 int low = 0;\r
1699 int j;\r
7381e8f2 1700 for(j = 0; j < lowLen; j++) {\r
6658905f 1701 low -= GraphBuffer[maxPos+j];\r
1702 }\r
7381e8f2 1703 for(j = 0; j < highLen; j++) {\r
6658905f 1704 high += GraphBuffer[maxPos+j];\r
1705 }\r
0c2ed92d 1706\r
6658905f 1707 if(high > low) {\r
1708 bits[i] = '1';\r
7381e8f2 1709 maxPos += highLen;\r
0c2ed92d 1710 // bitstream arrives lsb first so shift right\r
1711 shift3 |= (1<<31);\r
6658905f 1712 } else {\r
1713 bits[i] = '.';\r
7381e8f2 1714 maxPos += lowLen;\r
6658905f 1715 }\r
0c2ed92d 1716\r
1717 // 128 bit right shift register\r
1718 shift0 = (shift0>>1) | (shift1 << 31);\r
1719 shift1 = (shift1>>1) | (shift2 << 31);\r
1720 shift2 = (shift2>>1) | (shift3 << 31);\r
1721 shift3 >>= 1;\r
1722\r
1723 // place a marker in the buffer between bits to visually aid location\r
6658905f 1724 GraphBuffer[maxPos] = 800;\r
1725 GraphBuffer[maxPos+1] = -800;\r
1726 }\r
0c2ed92d 1727 PrintToScrollback("Info: raw tag bits = %s", bits);\r
6658905f 1728\r
0c2ed92d 1729 TagType = (shift3>>8)&0xff;\r
1730 if ( TagType != ((shift0>>16)&0xff) ) {\r
1731 PrintToScrollback("Error: start and stop bits do not match!");\r
1732 return;\r
1733 }\r
1734 else if (TagType == 0x7e) {\r
1735 PrintToScrollback("Info: Readonly TI tag detected.");\r
1736 return;\r
6658905f 1737 }\r
0c2ed92d 1738 else if (TagType == 0xfe) {\r
1739 PrintToScrollback("Info: Rewriteable TI tag detected.");\r
1740\r
1741 // put 64 bit data into shift1 and shift0\r
1742 shift0 = (shift0>>24) | (shift1 << 8);\r
1743 shift1 = (shift1>>24) | (shift2 << 8);\r
1744\r
1745 // align 16 bit crc into lower half of shift2\r
1746 shift2 = ((shift2>>24) | (shift3 << 8)) & 0x0ffff;\r
1747\r
1748 // align 16 bit "end bits" or "ident" into lower half of shift3\r
1749 shift3 >>= 16;\r
1750\r
9bea179a 1751 // only 15 bits compare, last bit of ident is not valid\r
1752 if ( (shift3^shift0)&0x7fff ) {\r
0c2ed92d 1753 PrintToScrollback("Error: Ident mismatch!");\r
1754 }\r
9bea179a 1755 // WARNING the order of the bytes in which we calc crc below needs checking\r
1756 // i'm 99% sure the crc algorithm is correct, but it may need to eat the\r
1757 // bytes in reverse or something\r
0c2ed92d 1758 // calculate CRC\r
1759 crc=0;\r
1760 crc = update_crc16(crc, (shift0)&0xff);\r
1761 crc = update_crc16(crc, (shift0>>8)&0xff);\r
1762 crc = update_crc16(crc, (shift0>>16)&0xff);\r
1763 crc = update_crc16(crc, (shift0>>24)&0xff);\r
1764 crc = update_crc16(crc, (shift1)&0xff);\r
1765 crc = update_crc16(crc, (shift1>>8)&0xff);\r
1766 crc = update_crc16(crc, (shift1>>16)&0xff);\r
1767 crc = update_crc16(crc, (shift1>>24)&0xff);\r
1768 PrintToScrollback("Info: Tag data = %08X%08X", shift1, shift0);\r
1769 if (crc != (shift2&0xffff)) {\r
1770 PrintToScrollback("Error: CRC mismatch, calculated %04X, got ^04X", crc, shift2&0xffff);\r
1771 } else {\r
1772 PrintToScrollback("Info: CRC %04X is good", crc);\r
6658905f 1773 }\r
1774 }\r
0c2ed92d 1775 else {\r
1776 PrintToScrollback("Unknown tag type.");\r
1777 return;\r
1778 }\r
6658905f 1779}\r
1780\r
1781static void CmdNorm(char *str)\r
1782{\r
1783 int i;\r
1784 int max = INT_MIN, min = INT_MAX;\r
1785 for(i = 10; i < GraphTraceLen; i++) {\r
1786 if(GraphBuffer[i] > max) {\r
1787 max = GraphBuffer[i];\r
1788 }\r
1789 if(GraphBuffer[i] < min) {\r
1790 min = GraphBuffer[i];\r
1791 }\r
1792 }\r
1793 if(max != min) {\r
1794 for(i = 0; i < GraphTraceLen; i++) {\r
1795 GraphBuffer[i] = (GraphBuffer[i] - ((max + min)/2))*1000/\r
1796 (max - min);\r
1797 }\r
1798 }\r
1799 RepaintGraphWindow();\r
1800}\r
1801\r
1802static void CmdDec(char *str)\r
1803{\r
1804 int i;\r
1805 for(i = 0; i < (GraphTraceLen/2); i++) {\r
1806 GraphBuffer[i] = GraphBuffer[i*2];\r
1807 }\r
1808 GraphTraceLen /= 2;\r
1809 PrintToScrollback("decimated by 2");\r
1810 RepaintGraphWindow();\r
1811}\r
1812\r
1813static void CmdHpf(char *str)\r
1814{\r
1815 int i;\r
1816 int accum = 0;\r
1817 for(i = 10; i < GraphTraceLen; i++) {\r
1818 accum += GraphBuffer[i];\r
1819 }\r
1820 accum /= (GraphTraceLen - 10);\r
1821 for(i = 0; i < GraphTraceLen; i++) {\r
1822 GraphBuffer[i] -= accum;\r
1823 }\r
1824\r
1825 RepaintGraphWindow();\r
1826}\r
1827\r
1828static void CmdZerocrossings(char *str)\r
1829{\r
1830 int i;\r
1831 // Zero-crossings aren't meaningful unless the signal is zero-mean.\r
1832 CmdHpf("");\r
1833\r
1834 int sign = 1;\r
1835 int zc = 0;\r
1836 int lastZc = 0;\r
1837 for(i = 0; i < GraphTraceLen; i++) {\r
1838 if(GraphBuffer[i]*sign >= 0) {\r
1839 // No change in sign, reproduce the previous sample count.\r
1840 zc++;\r
1841 GraphBuffer[i] = lastZc;\r
1842 } else {\r
1843 // Change in sign, reset the sample count.\r
1844 sign = -sign;\r
1845 GraphBuffer[i] = lastZc;\r
1846 if(sign > 0) {\r
1847 lastZc = zc;\r
1848 zc = 0;\r
1849 }\r
1850 }\r
1851 }\r
1852\r
1853 RepaintGraphWindow();\r
1854}\r
1855\r
67853904 1856static void CmdThreshold(char *str)\r
1857{\r
1858 int i;\r
1859 int threshold = atoi(str);\r
1860\r
1861 for(i = 0; i < GraphTraceLen; i++) {\r
1862 if(GraphBuffer[i]>= threshold)\r
bd4cc2c9 1863 GraphBuffer[i]=1;\r
67853904 1864 else\r
bd4cc2c9 1865 GraphBuffer[i]=-1;\r
67853904 1866 }\r
1867 RepaintGraphWindow();\r
1868}\r
1869\r
6658905f 1870static void CmdLtrim(char *str)\r
1871{\r
1872 int i;\r
1873 int ds = atoi(str);\r
1874\r
1875 for(i = ds; i < GraphTraceLen; i++) {\r
1876 GraphBuffer[i-ds] = GraphBuffer[i];\r
1877 }\r
1878 GraphTraceLen -= ds;\r
1879\r
1880 RepaintGraphWindow();\r
1881}\r
1882\r
1883static void CmdAutoCorr(char *str)\r
1884{\r
1885 static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];\r
1886\r
1887 int window = atoi(str);\r
1888\r
1889 if(window == 0) {\r
1890 PrintToScrollback("needs a window");\r
1891 return;\r
1892 }\r
1893\r
1894 if(window >= GraphTraceLen) {\r
1895 PrintToScrollback("window must be smaller than trace (%d samples)",\r
1896 GraphTraceLen);\r
1897 return;\r
1898 }\r
1899\r
1900 PrintToScrollback("performing %d correlations", GraphTraceLen - window);\r
1901\r
1902 int i;\r
1903 for(i = 0; i < GraphTraceLen - window; i++) {\r
1904 int sum = 0;\r
1905 int j;\r
1906 for(j = 0; j < window; j++) {\r
1907 sum += (GraphBuffer[j]*GraphBuffer[i+j]) / 256;\r
1908 }\r
1909 CorrelBuffer[i] = sum;\r
1910 }\r
1911 GraphTraceLen = GraphTraceLen - window;\r
1912 memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen*sizeof(int));\r
1913\r
1914 RepaintGraphWindow();\r
1915}\r
1916\r
1917static void CmdVchdemod(char *str)\r
1918{\r
1919 // Is this the entire sync pattern, or does this also include some\r
1920 // data bits that happen to be the same everywhere? That would be\r
1921 // lovely to know.\r
1922 static const int SyncPattern[] = {\r
1923 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1924 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1925 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1926 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1927 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1928 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1929 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1930 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1931 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1932 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1933 };\r
1934\r
1935 // So first, we correlate for the sync pattern, and mark that.\r
1936 int bestCorrel = 0, bestPos = 0;\r
1937 int i;\r
1938 // It does us no good to find the sync pattern, with fewer than\r
1939 // 2048 samples after it...\r
1940 for(i = 0; i < (GraphTraceLen-2048); i++) {\r
1941 int sum = 0;\r
1942 int j;\r
1943 for(j = 0; j < arraylen(SyncPattern); j++) {\r
1944 sum += GraphBuffer[i+j]*SyncPattern[j];\r
1945 }\r
1946 if(sum > bestCorrel) {\r
1947 bestCorrel = sum;\r
1948 bestPos = i;\r
1949 }\r
1950 }\r
1951 PrintToScrollback("best sync at %d [metric %d]", bestPos, bestCorrel);\r
1952\r
1953 char bits[257];\r
1954 bits[256] = '\0';\r
1955\r
1956 int worst = INT_MAX;\r
1957 int worstPos;\r
1958\r
1959 for(i = 0; i < 2048; i += 8) {\r
1960 int sum = 0;\r
1961 int j;\r
1962 for(j = 0; j < 8; j++) {\r
1963 sum += GraphBuffer[bestPos+i+j];\r
1964 }\r
1965 if(sum < 0) {\r
1966 bits[i/8] = '.';\r
1967 } else {\r
1968 bits[i/8] = '1';\r
1969 }\r
1970 if(abs(sum) < worst) {\r
1971 worst = abs(sum);\r
1972 worstPos = i;\r
1973 }\r
1974 }\r
1975 PrintToScrollback("bits:");\r
1976 PrintToScrollback("%s", bits);\r
1977 PrintToScrollback("worst metric: %d at pos %d", worst, worstPos);\r
1978\r
1979 if(strcmp(str, "clone")==0) {\r
1980 GraphTraceLen = 0;\r
1981 char *s;\r
1982 for(s = bits; *s; s++) {\r
1983 int j;\r
1984 for(j = 0; j < 16; j++) {\r
1985 GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;\r
1986 }\r
1987 }\r
1988 RepaintGraphWindow();\r
1989 }\r
1990}\r
1991\r
a60612db 1992static void CmdIndalademod(char *str)\r
1993{\r
1994 // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID\r
1995\r
1996 int state = -1;\r
1997 int count = 0;\r
1998 int i, j;\r
1999 // worst case with GraphTraceLen=64000 is < 4096\r
2000 // under normal conditions it's < 2048\r
2001 BYTE rawbits[4096];\r
2002 int rawbit = 0;\r
2003 int worst = 0, worstPos = 0;\r
2004 PrintToScrollback("Expecting a bit less than %d raw bits", GraphTraceLen/32);\r
2005 for(i = 0; i < GraphTraceLen-1; i += 2) {\r
2006 count+=1;\r
2007 if((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {\r
2008 if (state == 0) {\r
2009 for(j = 0; j < count - 8; j += 16) {\r
2010 rawbits[rawbit++] = 0;\r
2011 }\r
2012 if ((abs(count - j)) > worst) {\r
2013 worst = abs(count - j);\r
2014 worstPos = i;\r
2015 }\r
2016 }\r
2017 state = 1;\r
2018 count=0;\r
2019 } else if((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {\r
2020 if (state == 1) {\r
2021 for(j = 0; j < count - 8; j += 16) {\r
2022 rawbits[rawbit++] = 1;\r
2023 }\r
2024 if ((abs(count - j)) > worst) {\r
2025 worst = abs(count - j);\r
2026 worstPos = i;\r
2027 }\r
2028 }\r
2029 state = 0;\r
2030 count=0;\r
2031 }\r
2032 }\r
2033 PrintToScrollback("Recovered %d raw bits", rawbit);\r
2034 PrintToScrollback("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);\r
2035\r
2036 // Finding the start of a UID\r
2037 int uidlen, long_wait;\r
2038 if(strcmp(str, "224") == 0) {\r
2039 uidlen=224;\r
2040 long_wait=30;\r
2041 } else {\r
2042 uidlen=64;\r
2043 long_wait=29;\r
2044 }\r
2045 int start;\r
2046 int first = 0;\r
2047 for(start = 0; start <= rawbit - uidlen; start++) {\r
2048 first = rawbits[start];\r
2049 for(i = start; i < start + long_wait; i++) {\r
2050 if(rawbits[i] != first) {\r
2051 break;\r
2052 }\r
2053 }\r
2054 if(i == (start + long_wait)) {\r
2055 break;\r
2056 }\r
2057 }\r
2058 if(start == rawbit - uidlen + 1) {\r
2059 PrintToScrollback("nothing to wait for");\r
2060 return;\r
2061 }\r
2062\r
2063 // Inverting signal if needed\r
2064 if(first == 1) {\r
2065 for(i = start; i < rawbit; i++) {\r
2066 rawbits[i] = !rawbits[i];\r
2067 }\r
2068 }\r
2069\r
2070 // Dumping UID\r
2071 BYTE bits[224];\r
2072 char showbits[225];\r
2073 showbits[uidlen]='\0';\r
2074 int bit;\r
2075 i = start;\r
2076 int times = 0;\r
2077 if(uidlen > rawbit) {\r
2078 PrintToScrollback("Warning: not enough raw bits to get a full UID");\r
2079 for(bit = 0; bit < rawbit; bit++) {\r
2080 bits[bit] = rawbits[i++];\r
2081 // As we cannot know the parity, let's use "." and "/"\r
2082 showbits[bit] = '.' + bits[bit];\r
2083 }\r
2084 showbits[bit+1]='\0';\r
2085 PrintToScrollback("Partial UID=%s", showbits);\r
2086 return;\r
2087 } else {\r
2088 for(bit = 0; bit < uidlen; bit++) {\r
2089 bits[bit] = rawbits[i++];\r
2090 showbits[bit] = '0' + bits[bit];\r
2091 }\r
2092 times = 1;\r
2093 }\r
2094 PrintToScrollback("UID=%s", showbits);\r
2095\r
2096 // Checking UID against next occurences\r
2097 for(; i + uidlen <= rawbit;) {\r
2098 int failed = 0;\r
2099 for(bit = 0; bit < uidlen; bit++) {\r
2100 if(bits[bit] != rawbits[i++]) {\r
2101 failed = 1;\r
2102 break;\r
2103 }\r
2104 }\r
2105 if (failed == 1) {\r
2106 break;\r
2107 }\r
2108 times += 1;\r
2109 }\r
2110 PrintToScrollback("Occurences: %d (expected %d)", times, (rawbit - start) / uidlen);\r
2111\r
2112 // Remodulating for tag cloning\r
2113 GraphTraceLen = 32*uidlen;\r
2114 i = 0;\r
2115 int phase = 0;\r
2116 for(bit = 0; bit < uidlen; bit++) {\r
2117 if(bits[bit] == 0) {\r
2118 phase = 0;\r
2119 } else {\r
2120 phase = 1;\r
2121 }\r
2122 int j;\r
2123 for(j = 0; j < 32; j++) {\r
2124 GraphBuffer[i++] = phase;\r
2125 phase = !phase;\r
2126 }\r
2127 }\r
2128\r
2129 RepaintGraphWindow();\r
2130}\r
2131\r
6658905f 2132static void CmdFlexdemod(char *str)\r
2133{\r
2134 int i;\r
2135 for(i = 0; i < GraphTraceLen; i++) {\r
2136 if(GraphBuffer[i] < 0) {\r
2137 GraphBuffer[i] = -1;\r
2138 } else {\r
2139 GraphBuffer[i] = 1;\r
2140 }\r
2141 }\r
2142\r
2143#define LONG_WAIT 100\r
2144 int start;\r
2145 for(start = 0; start < GraphTraceLen - LONG_WAIT; start++) {\r
2146 int first = GraphBuffer[start];\r
2147 for(i = start; i < start + LONG_WAIT; i++) {\r
2148 if(GraphBuffer[i] != first) {\r
2149 break;\r
2150 }\r
2151 }\r
2152 if(i == (start + LONG_WAIT)) {\r
2153 break;\r
2154 }\r
2155 }\r
2156 if(start == GraphTraceLen - LONG_WAIT) {\r
2157 PrintToScrollback("nothing to wait for");\r
2158 return;\r
2159 }\r
2160\r
2161 GraphBuffer[start] = 2;\r
2162 GraphBuffer[start+1] = -2;\r
2163\r
2164 BYTE bits[64];\r
2165\r
2166 int bit;\r
2167 i = start;\r
2168 for(bit = 0; bit < 64; bit++) {\r
2169 int j;\r
2170 int sum = 0;\r
2171 for(j = 0; j < 16; j++) {\r
2172 sum += GraphBuffer[i++];\r
2173 }\r
2174 if(sum > 0) {\r
2175 bits[bit] = 1;\r
2176 } else {\r
2177 bits[bit] = 0;\r
2178 }\r
2179 PrintToScrollback("bit %d sum %d", bit, sum);\r
2180 }\r
2181\r
2182 for(bit = 0; bit < 64; bit++) {\r
2183 int j;\r
2184 int sum = 0;\r
2185 for(j = 0; j < 16; j++) {\r
2186 sum += GraphBuffer[i++];\r
2187 }\r
2188 if(sum > 0 && bits[bit] != 1) {\r
2189 PrintToScrollback("oops1 at %d", bit);\r
2190 }\r
2191 if(sum < 0 && bits[bit] != 0) {\r
2192 PrintToScrollback("oops2 at %d", bit);\r
2193 }\r
2194 }\r
2195\r
2196 GraphTraceLen = 32*64;\r
2197 i = 0;\r
2198 int phase = 0;\r
2199 for(bit = 0; bit < 64; bit++) {\r
2200 if(bits[bit] == 0) {\r
2201 phase = 0;\r
2202 } else {\r
2203 phase = 1;\r
2204 }\r
2205 int j;\r
2206 for(j = 0; j < 32; j++) {\r
2207 GraphBuffer[i++] = phase;\r
2208 phase = !phase;\r
2209 }\r
2210 }\r
2211\r
2212 RepaintGraphWindow();\r
2213}\r
9760414b 2214\r
2215/*\r
15db5fb7 2216 * Generic command to demodulate ASK.\r
9760414b 2217 *\r
15db5fb7 2218 * Argument is convention: positive or negative (High mod means zero\r
9760414b 2219 * or high mod means one)\r
2220 *\r
2221 * Updates the Graph trace with 0/1 values\r
2222 *\r
2223 * Arguments:\r
9760414b 2224 * c : 0 or 1\r
2225 */\r
2226\r
2227static void Cmdaskdemod(char *str) {\r
2228 int i;\r
8172fb35 2229 int c, high = 0, low = 0;\r
9760414b 2230\r
2231 // TODO: complain if we do not give 2 arguments here !\r
15db5fb7 2232 sscanf(str, "%i", &c);\r
2233\r
2234 /* Detect high and lows and clock */\r
2235 for (i = 0; i < GraphTraceLen; i++)\r
2236 {\r
2237 if (GraphBuffer[i] > high)\r
2238 high = GraphBuffer[i];\r
2239 else if (GraphBuffer[i] < low)\r
2240 low = GraphBuffer[i];\r
9760414b 2241 }\r
2242\r
15db5fb7 2243 if (GraphBuffer[0] > 0) {\r
2244 GraphBuffer[0] = 1-c;\r
9760414b 2245 } else {\r
15db5fb7 2246 GraphBuffer[0] = c;\r
9760414b 2247 }\r
2248 for(i=1;i<GraphTraceLen;i++) {\r
15db5fb7 2249 /* Transitions are detected at each peak\r
2250 * Transitions are either:\r
2251 * - we're low: transition if we hit a high\r
2252 * - we're high: transition if we hit a low\r
2253 * (we need to do it this way because some tags keep high or\r
2254 * low for long periods, others just reach the peak and go\r
a91ff4c8 2255 * down)\r
15db5fb7 2256 */\r
2257 if ((GraphBuffer[i]==high) && (GraphBuffer[i-1] == c)) {\r
2258 GraphBuffer[i]=1-c;\r
2259 } else if ((GraphBuffer[i]==low) && (GraphBuffer[i-1] == (1-c))){\r
2260 GraphBuffer[i] = c;\r
9760414b 2261 } else {\r
15db5fb7 2262 /* No transition */\r
9760414b 2263 GraphBuffer[i] = GraphBuffer[i-1];\r
2264 }\r
2265 }\r
2266 RepaintGraphWindow();\r
2267}\r
2268\r
2269/* Print our clock rate */\r
2270static void Cmddetectclockrate(char *str)\r
2271{\r
2272 int clock = detectclock(0);\r
2273 PrintToScrollback("Auto-detected clock rate: %d", clock);\r
2274}\r
2275\r
2276/*\r
2277 * Detect clock rate\r
2278 */\r
2279int detectclock(int peak)\r
2280{\r
2281 int i;\r
2282 int clock = 0xFFFF;\r
2283 int lastpeak = 0;\r
2284\r
2285 /* Detect peak if we don't have one */\r
2286 if (!peak)\r
2287 for (i = 0; i < GraphTraceLen; i++)\r
2288 if (GraphBuffer[i] > peak)\r
2289 peak = GraphBuffer[i];\r
2290\r
2291 for (i = 1; i < GraphTraceLen; i++)\r
2292 {\r
2293 /* If this is the beginning of a peak */\r
2294 if (GraphBuffer[i-1] != GraphBuffer[i] && GraphBuffer[i] == peak)\r
2295 {\r
2296 /* Find lowest difference between peaks */\r
2297 if (lastpeak && i - lastpeak < clock)\r
2298 {\r
2299 clock = i - lastpeak;\r
2300 }\r
2301 lastpeak = i;\r
2302 }\r
2303 }\r
15db5fb7 2304\r
9760414b 2305 return clock;\r
2306}\r
2307\r
2308/* Get or auto-detect clock rate */\r
2309int GetClock(char *str, int peak)\r
2310{\r
2311 int clock;\r
15db5fb7 2312\r
9760414b 2313 sscanf(str, "%i", &clock);\r
2314 if (!strcmp(str, ""))\r
2315 clock = 0;\r
2316\r
2317 /* Auto-detect clock */\r
2318 if (!clock)\r
2319 {\r
2320 clock = detectclock(peak);\r
15db5fb7 2321\r
9760414b 2322 /* Only print this message if we're not looping something */\r
2323 if (!go)\r
2324 PrintToScrollback("Auto-detected clock rate: %d", clock);\r
2325 }\r
15db5fb7 2326\r
9760414b 2327 return clock;\r
2328}\r
2329\r
2330/*\r
2331 * Convert to a bitstream\r
2332 */\r
2333static void Cmdbitstream(char *str) {\r
c9f99c01 2334 int i, j;\r
2335 int bit;\r
9760414b 2336 int gtl;\r
2337 int clock;\r
c9f99c01 2338 int low = 0;\r
2339 int high = 0;\r
2340 int hithigh, hitlow, first;\r
9760414b 2341\r
2342 /* Detect high and lows and clock */\r
2343 for (i = 0; i < GraphTraceLen; i++)\r
c9f99c01 2344 {\r
9760414b 2345 if (GraphBuffer[i] > high)\r
2346 high = GraphBuffer[i];\r
2347 else if (GraphBuffer[i] < low)\r
2348 low = GraphBuffer[i];\r
c9f99c01 2349 }\r
9760414b 2350\r
2351 /* Get our clock */\r
2352 clock = GetClock(str, high);\r
15db5fb7 2353\r
9760414b 2354 gtl = CmdClearGraph(0);\r
15db5fb7 2355\r
9760414b 2356 bit = 0;\r
2357 for (i = 0; i < (int)(gtl / clock); i++)\r
2358 {\r
2359 hithigh = 0;\r
2360 hitlow = 0;\r
2361 first = 1;\r
15db5fb7 2362\r
9760414b 2363 /* Find out if we hit both high and low peaks */\r
2364 for (j = 0; j < clock; j++)\r
2365 {\r
2366 if (GraphBuffer[(i * clock) + j] == high)\r
2367 hithigh = 1;\r
2368 else if (GraphBuffer[(i * clock) + j] == low)\r
2369 hitlow = 1;\r
15db5fb7 2370\r
9760414b 2371 /* it doesn't count if it's the first part of our read\r
2372 because it's really just trailing from the last sequence */\r
2373 if (first && (hithigh || hitlow))\r
2374 hithigh = hitlow = 0;\r
2375 else\r
2376 first = 0;\r
15db5fb7 2377\r
9760414b 2378 if (hithigh && hitlow)\r
2379 break;\r
2380 }\r
15db5fb7 2381\r
9760414b 2382 /* If we didn't hit both high and low peaks, we had a bit transition */\r
2383 if (!hithigh || !hitlow)\r
2384 bit ^= 1;\r
2385\r
2386 CmdAppendGraph(0, clock, bit);\r
2387// for (j = 0; j < (int)(clock/2); j++)\r
2388// GraphBuffer[(i * clock) + j] = bit ^ 1;\r
2389// for (j = (int)(clock/2); j < clock; j++)\r
2390// GraphBuffer[(i * clock) + j] = bit;\r
2391 }\r
2392\r
2393 RepaintGraphWindow();\r
2394}\r
2395\r
2396/* Modulate our data into manchester */\r
2397static void Cmdmanchestermod(char *str)\r
2398{\r
2399 int i, j;\r
2400 int clock;\r
2401 int bit, lastbit, wave;\r
15db5fb7 2402\r
9760414b 2403 /* Get our clock */\r
2404 clock = GetClock(str, 0);\r
2405\r
2406 wave = 0;\r
2407 lastbit = 1;\r
2408 for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
2409 {\r
2410 bit = GraphBuffer[i * clock] ^ 1;\r
15db5fb7 2411\r
9760414b 2412 for (j = 0; j < (int)(clock/2); j++)\r
2413 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;\r
2414 for (j = (int)(clock/2); j < clock; j++)\r
2415 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;\r
15db5fb7 2416\r
9760414b 2417 /* Keep track of how we start our wave and if we changed or not this time */\r
2418 wave ^= bit ^ lastbit;\r
2419 lastbit = bit;\r
2420 }\r
15db5fb7 2421\r
9760414b 2422 RepaintGraphWindow();\r
2423}\r
2424\r
2425/*\r
2426 * Manchester demodulate a bitstream. The bitstream needs to be already in\r
2427 * the GraphBuffer as 0 and 1 values\r
2428 *\r
2429 * Give the clock rate as argument in order to help the sync - the algorithm\r
2430 * resyncs at each pulse anyway.\r
2431 *\r
2432 * Not optimized by any means, this is the 1st time I'm writing this type of\r
2433 * routine, feel free to improve...\r
2434 *\r
2435 * 1st argument: clock rate (as number of samples per clock rate)\r
2436 * Typical values can be 64, 32, 128...\r
2437 */\r
2438static void Cmdmanchesterdemod(char *str) {\r
736aea60 2439 int i, j, invert= 0;\r
9760414b 2440 int bit;\r
2441 int clock;\r
2442 int lastval;\r
2443 int low = 0;\r
2444 int high = 0;\r
2445 int hithigh, hitlow, first;\r
2446 int lc = 0;\r
2447 int bitidx = 0;\r
2448 int bit2idx = 0;\r
2449 int warnings = 0;\r
2450\r
736aea60 2451 /* check if we're inverting output */\r
2452 if(*str == 'i')\r
2453 {\r
2454 PrintToScrollback("Inverting output");\r
2455 invert= 1;\r
2456 do\r
2457 ++str;\r
2458 while(*str == ' '); // in case a 2nd argument was given\r
2459 }\r
2460\r
9760414b 2461 /* Holds the decoded bitstream: each clock period contains 2 bits */\r
2462 /* later simplified to 1 bit after manchester decoding. */\r
2463 /* Add 10 bits to allow for noisy / uncertain traces without aborting */\r
2464 /* int BitStream[GraphTraceLen*2/clock+10]; */\r
2465\r
2466 /* But it does not work if compiling on WIndows: therefore we just allocate a */\r
2467 /* large array */\r
2468 int BitStream[MAX_GRAPH_TRACE_LEN];\r
2469\r
c9f99c01 2470 /* Detect high and lows */\r
2471 for (i = 0; i < GraphTraceLen; i++)\r
2472 {\r
2473 if (GraphBuffer[i] > high)\r
2474 high = GraphBuffer[i];\r
2475 else if (GraphBuffer[i] < low)\r
2476 low = GraphBuffer[i];\r
2477 }\r
2478\r
9760414b 2479 /* Get our clock */\r
2480 clock = GetClock(str, high);\r
15db5fb7 2481\r
9760414b 2482 int tolerance = clock/4;\r
15db5fb7 2483\r
9760414b 2484 /* Detect first transition */\r
2485 /* Lo-Hi (arbitrary) */\r
c9f99c01 2486 for (i = 0; i < GraphTraceLen; i++)\r
2487 {\r
2488 if (GraphBuffer[i] == low)\r
2489 {\r
9760414b 2490 lastval = i;\r
2491 break;\r
2492 }\r
2493 }\r
c9f99c01 2494\r
2495 /* If we're not working with 1/0s, demod based off clock */\r
2496 if (high != 1)\r
2497 {\r
15db5fb7 2498 bit = 0; /* We assume the 1st bit is zero, it may not be\r
2499 * the case: this routine (I think) has an init problem.\r
2500 * Ed.\r
2501 */\r
2502 for (; i < (int)(GraphTraceLen / clock); i++)\r
c9f99c01 2503 {\r
2504 hithigh = 0;\r
2505 hitlow = 0;\r
2506 first = 1;\r
2507\r
2508 /* Find out if we hit both high and low peaks */\r
2509 for (j = 0; j < clock; j++)\r
2510 {\r
2511 if (GraphBuffer[(i * clock) + j] == high)\r
2512 hithigh = 1;\r
2513 else if (GraphBuffer[(i * clock) + j] == low)\r
2514 hitlow = 1;\r
2515\r
2516 /* it doesn't count if it's the first part of our read\r
2517 because it's really just trailing from the last sequence */\r
2518 if (first && (hithigh || hitlow))\r
2519 hithigh = hitlow = 0;\r
2520 else\r
2521 first = 0;\r
2522\r
2523 if (hithigh && hitlow)\r
2524 break;\r
2525 }\r
2526\r
2527 /* If we didn't hit both high and low peaks, we had a bit transition */\r
2528 if (!hithigh || !hitlow)\r
2529 bit ^= 1;\r
2530\r
736aea60 2531 BitStream[bit2idx++] = bit ^ invert;\r
c9f99c01 2532 }\r
2533 }\r
2534\r
2535 /* standard 1/0 bitstream */\r
2536 else\r
2537 {\r
9760414b 2538\r
736aea60 2539 /* Then detect duration between 2 successive transitions */\r
c9f99c01 2540 for (bitidx = 1; i < GraphTraceLen; i++)\r
2541 {\r
2542 if (GraphBuffer[i-1] != GraphBuffer[i])\r
2543 {\r
9760414b 2544 lc = i-lastval;\r
2545 lastval = i;\r
2546\r
2547 // Error check: if bitidx becomes too large, we do not\r
2548 // have a Manchester encoded bitstream or the clock is really\r
2549 // wrong!\r
2550 if (bitidx > (GraphTraceLen*2/clock+8) ) {\r
2551 PrintToScrollback("Error: the clock you gave is probably wrong, aborting.");\r
2552 return;\r
2553 }\r
2554 // Then switch depending on lc length:\r
2555 // Tolerance is 1/4 of clock rate (arbitrary)\r
2556 if (abs(lc-clock/2) < tolerance) {\r
2557 // Short pulse : either "1" or "0"\r
2558 BitStream[bitidx++]=GraphBuffer[i-1];\r
2559 } else if (abs(lc-clock) < tolerance) {\r
2560 // Long pulse: either "11" or "00"\r
2561 BitStream[bitidx++]=GraphBuffer[i-1];\r
2562 BitStream[bitidx++]=GraphBuffer[i-1];\r
2563 } else {\r
2564 // Error\r
c9f99c01 2565 warnings++;\r
9760414b 2566 PrintToScrollback("Warning: Manchester decode error for pulse width detection.");\r
2567 PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");\r
c9f99c01 2568\r
2569 if (warnings > 100)\r
2570 {\r
2571 PrintToScrollback("Error: too many detection errors, aborting.");\r
2572 return;\r
2573 }\r
736aea60 2574 }\r
9760414b 2575 }\r
2576 }\r
9760414b 2577\r
736aea60 2578 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream\r
2579 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful\r
2580 // to stop output at the final bitidx2 value, not bitidx\r
2581 for (i = 0; i < bitidx; i += 2) {\r
2582 if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {\r
2583 BitStream[bit2idx++] = 1 ^ invert;\r
9760414b 2584 } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {\r
736aea60 2585 BitStream[bit2idx++] = 0 ^ invert;\r
9760414b 2586 } else {\r
2587 // We cannot end up in this state, this means we are unsynchronized,\r
2588 // move up 1 bit:\r
2589 i++;\r
c9f99c01 2590 warnings++;\r
9760414b 2591 PrintToScrollback("Unsynchronized, resync...");\r
2592 PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");\r
c9f99c01 2593\r
2594 if (warnings > 100)\r
2595 {\r
2596 PrintToScrollback("Error: too many decode errors, aborting.");\r
2597 return;\r
2598 }\r
736aea60 2599 }\r
67853904 2600 }\r
c9f99c01 2601 }\r
2602\r
2603 PrintToScrollback("Manchester decoded bitstream");\r
9760414b 2604 // Now output the bitstream to the scrollback by line of 16 bits\r
2605 for (i = 0; i < (bit2idx-16); i+=16) {\r
2606 PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",\r
2607 BitStream[i],\r
2608 BitStream[i+1],\r
2609 BitStream[i+2],\r
2610 BitStream[i+3],\r
2611 BitStream[i+4],\r
2612 BitStream[i+5],\r
2613 BitStream[i+6],\r
2614 BitStream[i+7],\r
2615 BitStream[i+8],\r
2616 BitStream[i+9],\r
2617 BitStream[i+10],\r
2618 BitStream[i+11],\r
2619 BitStream[i+12],\r
2620 BitStream[i+13],\r
2621 BitStream[i+14],\r
2622 BitStream[i+15]);\r
2623 }\r
2624}\r
2625\r
9760414b 2626/*\r
2627 * Usage ???\r
6658905f 2628 */\r
2629static void CmdHiddemod(char *str)\r
2630{\r
2631 if(GraphTraceLen < 4800) {\r
2632 PrintToScrollback("too short; need at least 4800 samples");\r
2633 return;\r
2634 }\r
2635\r
2636 GraphTraceLen = 4800;\r
2637 int i;\r
2638 for(i = 0; i < GraphTraceLen; i++) {\r
2639 if(GraphBuffer[i] < 0) {\r
2640 GraphBuffer[i] = 0;\r
2641 } else {\r
2642 GraphBuffer[i] = 1;\r
2643 }\r
2644 }\r
2645 RepaintGraphWindow();\r
2646}\r
2647\r
2648static void CmdPlot(char *str)\r
2649{\r
2650 ShowGraphWindow();\r
2651}\r
2652\r
bd4cc2c9 2653static void CmdGrid(char *str)\r
2654{\r
f4434ad2 2655 sscanf(str, "%i %i", &PlotGridX, &PlotGridY);\r
bd4cc2c9 2656 RepaintGraphWindow();\r
2657}\r
2658\r
6658905f 2659static void CmdHide(char *str)\r
2660{\r
2661 HideGraphWindow();\r
2662}\r
2663\r
2664static void CmdScale(char *str)\r
2665{\r
2666 CursorScaleFactor = atoi(str);\r
2667 if(CursorScaleFactor == 0) {\r
2668 PrintToScrollback("bad, can't have zero scale");\r
2669 CursorScaleFactor = 1;\r
2670 }\r
2671 RepaintGraphWindow();\r
2672}\r
2673\r
2674static void CmdSave(char *str)\r
2675{\r
2676 FILE *f = fopen(str, "w");\r
2677 if(!f) {\r
2678 PrintToScrollback("couldn't open '%s'", str);\r
2679 return;\r
2680 }\r
2681 int i;\r
2682 for(i = 0; i < GraphTraceLen; i++) {\r
2683 fprintf(f, "%d\n", GraphBuffer[i]);\r
2684 }\r
2685 fclose(f);\r
2686 PrintToScrollback("saved to '%s'", str);\r
2687}\r
2688\r
2689static void CmdLoad(char *str)\r
2690{\r
2691 FILE *f = fopen(str, "r");\r
2692 if(!f) {\r
2693 PrintToScrollback("couldn't open '%s'", str);\r
2694 return;\r
2695 }\r
2696\r
2697 GraphTraceLen = 0;\r
2698 char line[80];\r
2699 while(fgets(line, sizeof(line), f)) {\r
2700 GraphBuffer[GraphTraceLen] = atoi(line);\r
2701 GraphTraceLen++;\r
2702 }\r
2703 fclose(f);\r
2704 PrintToScrollback("loaded %d samples", GraphTraceLen);\r
2705 RepaintGraphWindow();\r
2706}\r
2707\r
2708static void CmdHIDsimTAG(char *str)\r
2709{\r
2710 unsigned int hi=0, lo=0;\r
2711 int n=0, i=0;\r
2712 UsbCommand c;\r
2713\r
2714 while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
2715 hi=(hi<<4)|(lo>>28);\r
2716 lo=(lo<<4)|(n&0xf);\r
2717 }\r
2718\r
2719 PrintToScrollback("Emulating tag with ID %x%16x", hi, lo);\r
2720\r
2721 c.cmd = CMD_HID_SIM_TAG;\r
2722 c.ext1 = hi;\r
2723 c.ext2 = lo;\r
2724 SendCommand(&c, FALSE);\r
2725}\r
2726\r
1dff8c42 2727static void CmdReadmem(char *str)\r
2728{\r
2729 UsbCommand c;\r
2730 c.cmd = CMD_READ_MEM;\r
2731 c.ext1 = atoi(str);\r
2732 SendCommand(&c, FALSE);\r
2733}\r
2734\r
6658905f 2735static void CmdLcdReset(char *str)\r
2736{\r
2737 UsbCommand c;\r
2738 c.cmd = CMD_LCD_RESET;\r
2739 c.ext1 = atoi(str);\r
2740 SendCommand(&c, FALSE);\r
2741}\r
2742\r
2743static void CmdLcd(char *str)\r
2744{\r
2745 int i, j;\r
2746 UsbCommand c;\r
2747 c.cmd = CMD_LCD;\r
2748 sscanf(str, "%x %d", &i, &j);\r
2749 while (j--) {\r
2750 c.ext1 = i&0x1ff;\r
2751 SendCommand(&c, FALSE);\r
2752 }\r
2753}\r
2754\r
9760414b 2755/*\r
2756 * Sets the divisor for LF frequency clock: lets the user choose any LF frequency below\r
2757 * 600kHz.\r
2758 */\r
30f2a7d3 2759static void CmdSetDivisor(char *str)\r
2760{\r
2761 UsbCommand c;\r
2762 c.cmd = CMD_SET_LF_DIVISOR;\r
2763 c.ext1 = atoi(str);\r
2764 if (( c.ext1<0) || (c.ext1>255)) {\r
2765 PrintToScrollback("divisor must be between 19 and 255");\r
2766 } else {\r
2767 SendCommand(&c, FALSE);\r
2768 PrintToScrollback("Divisor set, expected freq=%dHz", 12000000/(c.ext1+1));\r
2769 }\r
2770}\r
2771\r
6658905f 2772typedef void HandlerFunction(char *cmdline);\r
2773\r
3f030abe 2774/* in alphabetic order */\r
6658905f 2775static struct {\r
fb25b483 2776 char *name;\r
2777 HandlerFunction *handler;\r
2778 int offline; // 1 if the command can be used when in offline mode\r
9760414b 2779 char *docString;\r
6658905f 2780} CommandTable[] = {\r
bd4cc2c9 2781 {"askdemod", Cmdaskdemod, 1, "<samples per bit> <0|1> -- Attempt to demodulate simple ASK tags"},\r
2782 {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},\r
2783 {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},\r
2784 {"bitstream", Cmdbitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},\r
1569d977 2785 {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},\r
bd4cc2c9 2786 {"dec", CmdDec, 1, "Decimate samples"},\r
2787 {"detectclock", Cmddetectclockrate, 1, "Detect clock rate"},\r
2788 {"detectreader", CmdDetectReader, 0, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"},\r
2789 {"em410xsim", CmdEM410xsim, 1, "<UID> -- Simulate EM410x tag"},\r
2790 {"em410xread", CmdEM410xread, 1, "[clock rate] -- Extract ID from EM410x tag"},\r
2791 {"em410xwatch", CmdEM410xwatch, 0, "Watches for EM410x tags"},\r
2792 {"em4x50read", CmdEM4x50read, 1, "Extract data from EM4x50 tag"},\r
2793 {"exit", CmdQuit, 1, "Exit program"},\r
2794 {"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"},\r
2795 {"fpgaoff", CmdFPGAOff, 0, "Set FPGA off"},\r
2796 {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},\r
f4434ad2 2797 {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},\r
bd4cc2c9 2798 {"hexsamples", CmdHexsamples, 0, "<blocks> -- Dump big buffer as hex bytes"},\r
2799 {"hi14alist", CmdHi14alist, 0, "List ISO 14443a history"},\r
2800 {"hi14areader", CmdHi14areader, 0, "Act like an ISO14443 Type A reader"},\r
2801 {"hi14asim", CmdHi14asim, 0, "<UID> -- Fake ISO 14443a tag"},\r
2802 {"hi14asnoop", CmdHi14asnoop, 0, "Eavesdrop ISO 14443 Type A"},\r
2803 {"hi14bdemod", CmdHi14bdemod, 1, "Demodulate ISO14443 Type B from tag"},\r
2804 {"hi14list", CmdHi14list, 0, "List ISO 14443 history"},\r
2805 {"hi14read", CmdHi14read, 0, "Read HF tag (ISO 14443)"},\r
2806 {"hi14sim", CmdHi14sim, 0, "Fake ISO 14443 tag"},\r
2807 {"hi14snoop", CmdHi14snoop, 0, "Eavesdrop ISO 14443"},\r
2808 {"hi15demod", CmdHi15demod, 1, "Demodulate ISO15693 from tag"},\r
2809 {"hi15read", CmdHi15read, 0, "Read HF tag (ISO 15693)"},\r
2810 {"hi15reader", CmdHi15reader, 0, "Act like an ISO15693 reader"},\r
2811 {"hi15sim", CmdHi15tag, 0, "Fake an ISO15693 tag"},\r
2812 {"hiddemod", CmdHiddemod, 1, "Demodulate HID Prox Card II (not optimal)"},\r
2813 {"hide", CmdHide, 1, "Hide graph window"},\r
2814 {"hidfskdemod", CmdHIDdemodFSK, 0, "Realtime HID FSK demodulator"},\r
2815 {"hidsimtag", CmdHIDsimTAG, 0, "<ID> -- HID tag simulator"},\r
2816 {"higet", CmdHi14read_sim, 0, "<samples> -- Get samples HF, 'analog'"},\r
2817 {"hisamples", CmdHisamples, 0, "Get raw samples for HF tag"},\r
2818 {"hisampless", CmdHisampless, 0, "<samples> -- Get signed raw samples, HF tag"},\r
2819 {"hisamplest", CmdHi14readt, 0, "Get samples HF, for testing"},\r
2820 {"hisimlisten", CmdHisimlisten, 0, "Get HF samples as fake tag"},\r
2821 {"hpf", CmdHpf, 1, "Remove DC offset from trace"},\r
2822 {"indalademod", CmdIndalademod, 0, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},\r
2823 {"lcd", CmdLcd, 0, "<HEX command> <count> -- Send command/data to LCD"},\r
2824 {"lcdreset", CmdLcdReset, 0, "Hardware reset LCD"},\r
2825 {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},\r
2826 {"locomread", CmdLoCommandRead, 0, "<off period> <'0' period> <'1' period> <command> ['h'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'h' for 134)"},\r
2827 {"loread", CmdLoread, 0, "['h'] -- Read 125/134 kHz LF ID-only tag (option 'h' for 134)"},\r
2828 {"losamples", CmdLosamples, 0, "[128 - 16000] -- Get raw samples for LF tag"},\r
2829 {"losim", CmdLosim, 0, "Simulate LF tag"},\r
2830 {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},\r
2831 {"mandemod", Cmdmanchesterdemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},\r
2832 {"manmod", Cmdmanchestermod, 1, "[clock rate] -- Manchester modulate a binary stream"},\r
2833 {"norm", CmdNorm, 1, "Normalize max/min to +/-500"},\r
2834 {"plot", CmdPlot, 1, "Show graph window"},\r
2835 {"quit", CmdQuit, 1, "Quit program"},\r
2836 {"readmem", CmdReadmem, 0, "[address] -- Read memory at decimal address from flash"},\r
2837 {"reset", CmdReset, 0, "Reset the Proxmark3"},\r
2838 {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},\r
2839 {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},\r
2840 {"setlfdivisor", CmdSetDivisor, 0, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"},\r
2841 {"sri512read", CmdSri512read, 0, "<int> -- Read contents of a SRI512 tag"},\r
9bea179a 2842 {"tidemod", CmdTIDemod, 1, "Demodulate raw bits for TI-type LF tag"},\r
9bea179a 2843 {"tiread", CmdTIRead, 0, "Read and decode a TI 134 kHz tag"},\r
2844 {"tiwrite", CmdTIWrite, 0, "Write new data to a r/w TI 134 kHz tag"},\r
bd4cc2c9 2845 {"threshold", CmdThreshold, 1, "Maximize/minimize every value in the graph window depending on threshold"},\r
2846 {"tune", CmdTune, 0, "Measure antenna tuning"},\r
2847 {"vchdemod", CmdVchdemod, 0, "['clone'] -- Demodulate samples for VeriChip"},\r
2848 {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},\r
6658905f 2849};\r
2850\r
7f93ef2c 2851static struct {\r
2852 char *name;\r
2853 char *args;\r
2854 char *argshelp;\r
2855 char *description;\r
2856 } CommandExtendedHelp[]= {\r
a52a7d19 2857 {"detectreader","'l'|'h'","'l' specifies LF antenna scan only, 'h' specifies HF antenna scan only.","Monitor antenna for changes in voltage. Output is in three fields: CHANGED, CURRENT, PERIOD,\nwhere CHANGED is the value just changed from, CURRENT is the current value and PERIOD is the\nnumber of program loops since the last change.\n\nThe RED LED indicates LF field detected, and the GREEN LED indicates HF field detected."},\r
e7aee94e 2858 {"tune","","","Drive LF antenna at all divisor range values (19 - 255) and store the results in the output\nbuffer. Issuing 'losamples' and then 'plot' commands will display the resulting peak. 12MHz\ndivided by the peak's position plus one gives the antenna's resonant frequency. For convenience,\nthis value is also printed out by the command."},\r
7f93ef2c 2859 };\r
fb25b483 2860\r
6658905f 2861//-----------------------------------------------------------------------------\r
2862// Entry point into our code: called whenever the user types a command and\r
2863// then presses Enter, which the full command line that they typed.\r
2864//-----------------------------------------------------------------------------\r
2865void CommandReceived(char *cmd)\r
2866{\r
2867 int i;\r
7f93ef2c 2868 char line[256];\r
6658905f 2869\r
2870 PrintToScrollback("> %s", cmd);\r
2871\r
7f93ef2c 2872 if(strcmp(cmd, "help") == 0 || strncmp(cmd,"help ",strlen("help ")) == 0) {\r
2873 // check if we're doing extended help\r
2874 if(strlen(cmd) > strlen("help ")) {\r
2875 cmd += strlen("help ");\r
2876 for(i = 0; i < sizeof(CommandExtendedHelp) / sizeof(CommandExtendedHelp[0]); i++) {\r
2877 if(strcmp(CommandExtendedHelp[i].name,cmd) == 0) {\r
2878 PrintToScrollback("\nExtended help for '%s':\n", cmd);\r
2879 PrintToScrollback("Args: %s\t- %s\n",CommandExtendedHelp[i].args,CommandExtendedHelp[i].argshelp);\r
2880 PrintToScrollback(CommandExtendedHelp[i].description);\r
a52a7d19 2881 PrintToScrollback("");\r
7f93ef2c 2882 return;\r
2883 }\r
2884 }\r
2885 PrintToScrollback("No extended help available for '%s'", cmd);\r
2886 return;\r
2887 }\r
d722c4ce 2888 if (offline) PrintToScrollback("Operating in OFFLINE mode (no device connected)");\r
6658905f 2889 PrintToScrollback("\r\nAvailable commands:");\r
2890 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
d722c4ce 2891 if (offline && (CommandTable[i].offline==0)) continue;\r
6658905f 2892 memset(line, ' ', sizeof(line));\r
2893 strcpy(line+2, CommandTable[i].name);\r
2894 line[strlen(line)] = ' ';\r
2895 sprintf(line+15, " -- %s", CommandTable[i].docString);\r
2896 PrintToScrollback("%s", line);\r
2897 }\r
2898 PrintToScrollback("");\r
a52a7d19 2899 PrintToScrollback("'help <command>' for extended help on that command\n");\r
6658905f 2900 return;\r
2901 }\r
2902\r
2903 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
2904 char *name = CommandTable[i].name;\r
2905 if(memcmp(cmd, name, strlen(name))==0 &&\r
2906 (cmd[strlen(name)] == ' ' || cmd[strlen(name)] == '\0'))\r
2907 {\r
2908 cmd += strlen(name);\r
2909 while(*cmd == ' ') {\r
2910 cmd++;\r
2911 }\r
d722c4ce 2912 if (offline && (CommandTable[i].offline==0)) {\r
2913 PrintToScrollback("Offline mode, cannot use this command.");\r
2914 return;\r
2915 }\r
6658905f 2916 (CommandTable[i].handler)(cmd);\r
2917 return;\r
2918 }\r
2919 }\r
2920 PrintToScrollback(">> bad command '%s'", cmd);\r
2921}\r
2922\r
2923//-----------------------------------------------------------------------------\r
2924// Entry point into our code: called whenever we received a packet over USB\r
2925// that we weren't necessarily expecting, for example a debug print.\r
2926//-----------------------------------------------------------------------------\r
2927void UsbCommandReceived(UsbCommand *c)\r
2928{\r
2929 switch(c->cmd) {\r
2930 case CMD_DEBUG_PRINT_STRING: {\r
2931 char s[100];\r
2932 if(c->ext1 > 70 || c->ext1 < 0) {\r
2933 c->ext1 = 0;\r
2934 }\r
2935 memcpy(s, c->d.asBytes, c->ext1);\r
2936 s[c->ext1] = '\0';\r
2937 PrintToScrollback("#db# %s", s);\r
9760414b 2938 break;\r
6658905f 2939 }\r
2940\r
2941 case CMD_DEBUG_PRINT_INTEGERS:\r
2942 PrintToScrollback("#db# %08x, %08x, %08x\r\n", c->ext1, c->ext2, c->ext3);\r
2943 break;\r
2944\r
2945 case CMD_MEASURED_ANTENNA_TUNING: {\r
e7aee94e 2946 int peakv, peakf;\r
6658905f 2947 int vLf125, vLf134, vHf;\r
2948 vLf125 = c->ext1 & 0xffff;\r
2949 vLf134 = c->ext1 >> 16;\r
e7aee94e 2950 vHf = c->ext2 & 0xffff;;\r
2951 peakf = c->ext3 & 0xffff;\r
2952 peakv = c->ext3 >> 16;\r
ad2a9782 2953 PrintToScrollback("");\r
2954 PrintToScrollback("");\r
2955 PrintToScrollback("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0);\r
2956 PrintToScrollback("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0);\r
2957 PrintToScrollback("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));\r
2958 PrintToScrollback("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0);\r
e7aee94e 2959 if (peakv<2000)\r
67853904 2960 PrintToScrollback("# Your LF antenna is unusable.");\r
e7aee94e 2961 else if (peakv<10000)\r
2962 PrintToScrollback("# Your LF antenna is marginal.");\r
2963 if (vHf<2000)\r
67853904 2964 PrintToScrollback("# Your HF antenna is unusable.");\r
e7aee94e 2965 else if (vHf<5000)\r
2966 PrintToScrollback("# Your HF antenna is marginal.");\r
6658905f 2967 break;\r
2968 }\r
2969 default:\r
2970 PrintToScrollback("unrecognized command %08x\n", c->cmd);\r
2971 break;\r
2972 }\r
2973}\r
Proxmark3 GIT tracking
Impressum, Datenschutz