]> git.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
Added indala demodulation command (indalademod) as well as offline
[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
15\r
16#define arraylen(x) (sizeof(x)/sizeof((x)[0]))\r
17\r
18static int CmdHisamplest(char *str, int nrlow);\r
19\r
20static void GetFromBigBuf(BYTE *dest, int bytes)\r
21{\r
22 int n = bytes/4;\r
23\r
24 if(n % 48 != 0) {\r
25 PrintToScrollback("bad len in GetFromBigBuf");\r
26 return;\r
27 }\r
28\r
29 int i;\r
30 for(i = 0; i < n; i += 12) {\r
31 UsbCommand c;\r
32 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
33 c.ext1 = i;\r
34 SendCommand(&c, FALSE);\r
35 ReceiveCommand(&c);\r
36 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
37 PrintToScrollback("bad resp\n");\r
38 return;\r
39 }\r
40\r
41 memcpy(dest+(i*4), c.d.asBytes, 48);\r
42 }\r
43}\r
44\r
45static void CmdQuit(char *str)\r
46{\r
47 exit(0);\r
48}\r
49\r
50static void CmdHIDdemodFSK(char *str)\r
51{\r
52 UsbCommand c;\r
53 c.cmd = CMD_HID_DEMOD_FSK;\r
54 SendCommand(&c, FALSE);\r
55}\r
56\r
57static void CmdTune(char *str)\r
58{\r
59 UsbCommand c;\r
60 c.cmd = CMD_MEASURE_ANTENNA_TUNING;\r
61 SendCommand(&c, FALSE);\r
62}\r
63\r
64static void CmdHi15read(char *str)\r
65{\r
66 UsbCommand c;\r
67 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693;\r
68 SendCommand(&c, FALSE);\r
69}\r
70\r
71static void CmdHi14read(char *str)\r
72{\r
73 UsbCommand c;\r
74 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
75 c.ext1 = atoi(str);\r
76 SendCommand(&c, FALSE);\r
77}\r
78\r
79// ## New command\r
80static void CmdHi14areader(char *str)\r
81{\r
82 UsbCommand c;\r
83 c.cmd = CMD_READER_ISO_14443a;\r
84 c.ext1 = atoi(str);\r
85 SendCommand(&c, FALSE);\r
86}\r
87\r
88// ## New command\r
89static void CmdHi15reader(char *str)\r
90{\r
91 UsbCommand c;\r
92 c.cmd = CMD_READER_ISO_15693;\r
93 c.ext1 = atoi(str);\r
94 SendCommand(&c, FALSE);\r
95}\r
96\r
97// ## New command\r
98static void CmdHi15tag(char *str)\r
99{\r
100 UsbCommand c;\r
101 c.cmd = CMD_SIMTAG_ISO_15693;\r
102 c.ext1 = atoi(str);\r
103 SendCommand(&c, FALSE);\r
104}\r
105\r
106static void CmdHi14read_sim(char *str)\r
107{\r
108 UsbCommand c;\r
109 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443_SIM;\r
110 c.ext1 = atoi(str);\r
111 SendCommand(&c, FALSE);\r
112}\r
113\r
114static void CmdHi14readt(char *str)\r
115{\r
116 UsbCommand c;\r
117 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
118 c.ext1 = atoi(str);\r
119 SendCommand(&c, FALSE);\r
120\r
121 //CmdHisamplest(str);\r
122 while(CmdHisamplest(str,atoi(str))==0) {\r
123 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;\r
124 c.ext1 = atoi(str);\r
125 SendCommand(&c, FALSE);\r
126 }\r
127 RepaintGraphWindow();\r
128}\r
129\r
130static void CmdHisimlisten(char *str)\r
131{\r
132 UsbCommand c;\r
133 c.cmd = CMD_SIMULATE_TAG_HF_LISTEN;\r
134 SendCommand(&c, FALSE);\r
135}\r
136\r
137static void CmdHi14sim(char *str)\r
138{\r
139 UsbCommand c;\r
140 c.cmd = CMD_SIMULATE_TAG_ISO_14443;\r
141 SendCommand(&c, FALSE);\r
142}\r
143
144
145\r
146static void CmdHi14asim(char *str) // ## simulate iso14443a tag\r
147{ // ## greg - added ability to specify tag UID\r
148\r
149 unsigned int hi=0, lo=0;\r
150 int n=0, i=0;\r
151 UsbCommand c;\r
152\r
153 while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
154 hi=(hi<<4)|(lo>>28);\r
155 lo=(lo<<4)|(n&0xf);\r
156 }\r
157\r
158 c.cmd = CMD_SIMULATE_TAG_ISO_14443a;\r
159 // c.ext should be set to *str or convert *str to the correct format for a uid\r
160 c.ext1 = hi;\r
161 c.ext2 = lo;\r
162 PrintToScrollback("Emulating 14443A TAG with UID %x%16x", hi, lo);\r
163 SendCommand(&c, FALSE);\r
164}\r
165\r
166static void CmdHi14snoop(char *str)\r
167{\r
168 UsbCommand c;\r
169 c.cmd = CMD_SNOOP_ISO_14443;\r
170 SendCommand(&c, FALSE);\r
171}\r
172\r
173static void CmdHi14asnoop(char *str)\r
174{\r
175 UsbCommand c;\r
176 c.cmd = CMD_SNOOP_ISO_14443a;\r
177 SendCommand(&c, FALSE);\r
178}\r
179\r
180static void CmdFPGAOff(char *str) // ## FPGA Control\r
181{\r
182 UsbCommand c;\r
183 c.cmd = CMD_FPGA_MAJOR_MODE_OFF;\r
184 SendCommand(&c, FALSE);\r
185}\r
186\r
187static void CmdLosim(char *str)\r
188{\r
189 int i;\r
190\r
191 for(i = 0; i < GraphTraceLen; i += 48) {\r
192 UsbCommand c;\r
193 int j;\r
194 for(j = 0; j < 48; j++) {\r
195 c.d.asBytes[j] = GraphBuffer[i+j];\r
196 }\r
197 c.cmd = CMD_DOWNLOADED_SIM_SAMPLES_125K;\r
198 c.ext1 = i;\r
199 SendCommand(&c, FALSE);\r
200 }\r
201\r
202 UsbCommand c;\r
203 c.cmd = CMD_SIMULATE_TAG_125K;\r
204 c.ext1 = GraphTraceLen;\r
205 SendCommand(&c, FALSE);\r
206}\r
207\r
208static void CmdLoread(char *str)\r
209{\r
210 UsbCommand c;\r
211 // 'h' means higher-low-frequency, 134 kHz\r
212 if(*str == 'h') {\r
213 c.ext1 = 1;\r
214 } else if (*str == '\0') {\r
215 c.ext1 = 0;\r
216 } else {\r
217 PrintToScrollback("use 'loread' or 'loread h'");\r
218 return;\r
219 }\r
220 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_125K;\r
221 SendCommand(&c, FALSE);\r
222}\r
223\r
224static void CmdLosamples(char *str)\r
225{\r
226 int cnt = 0;\r
227 int i;\r
228 int n;\r
229\r
230 n=atoi(str);\r
231 if (n==0) n=128;\r
232 if (n>16000) n=16000;\r
233\r
234 for(i = 0; i < n; i += 12) {\r
235 UsbCommand c;\r
236 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
237 c.ext1 = i;\r
238 SendCommand(&c, FALSE);\r
239 ReceiveCommand(&c);\r
240 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
241 PrintToScrollback("bad resp\n");\r
242 return;\r
243 }\r
244 int j;\r
245 for(j = 0; j < 48; j++) {\r
246 GraphBuffer[cnt++] = ((int)c.d.asBytes[j]) - 128;\r
247 }\r
248 }\r
249 GraphTraceLen = n*4;\r
250 RepaintGraphWindow();\r
251}\r
252\r
253static void CmdBitsamples(char *str)\r
254{\r
255 int cnt = 0;\r
256 int i;\r
257 int n;\r
258\r
259 n = 3072;\r
260 for(i = 0; i < n; i += 12) {\r
261 UsbCommand c;\r
262 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
263 c.ext1 = i;\r
264 SendCommand(&c, FALSE);\r
265 ReceiveCommand(&c);\r
266 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
267 PrintToScrollback("bad resp\n");\r
268 return;\r
269 }\r
270 int j, k;\r
271 for(j = 0; j < 48; j++) {\r
272 for(k = 0; k < 8; k++) {\r
273 if(c.d.asBytes[j] & (1 << (7 - k))) {\r
274 GraphBuffer[cnt++] = 1;\r
275 } else {\r
276 GraphBuffer[cnt++] = 0;\r
277 }\r
278 }\r
279 }\r
280 }\r
281 GraphTraceLen = cnt;\r
282 RepaintGraphWindow();\r
283}\r
284\r
285static void CmdHisamples(char *str)\r
286{\r
287 int cnt = 0;\r
288 int i;\r
289 int n;\r
290 n = 1000;\r
291 for(i = 0; i < n; i += 12) {\r
292 UsbCommand c;\r
293 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
294 c.ext1 = i;\r
295 SendCommand(&c, FALSE);\r
296 ReceiveCommand(&c);\r
297 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
298 PrintToScrollback("bad resp\n");\r
299 return;\r
300 }\r
301 int j;\r
302 for(j = 0; j < 48; j++) {\r
303 GraphBuffer[cnt++] = (int)((BYTE)c.d.asBytes[j]);\r
304 }\r
305 }\r
306 GraphTraceLen = n*4;\r
307\r
308 RepaintGraphWindow();\r
309}\r
310\r
311\r
312static int CmdHisamplest(char *str, int nrlow)\r
313{\r
314 int cnt = 0;\r
315 int t1, t2;\r
316 int i;\r
317 int n;\r
318 int hasbeennull;\r
319 int show;\r
320\r
321\r
322 n = 1000;\r
323 hasbeennull = 0;\r
324 for(i = 0; i < n; i += 12) {\r
325 UsbCommand c;\r
326 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
327 c.ext1 = i;\r
328 SendCommand(&c, FALSE);\r
329 ReceiveCommand(&c);\r
330 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
331 PrintToScrollback("bad resp\n");\r
332 return 0;\r
333 }\r
334 int j;\r
335 for(j = 0; j < 48; j++) {\r
336 t2 = (int)((BYTE)c.d.asBytes[j]);\r
337 if((t2 ^ 0xC0) & 0xC0) { hasbeennull++; }\r
338\r
339 show = 0;\r
340 switch(show) {\r
341 case 0:\r
342 // combined\r
343 t1 = (t2 & 0x80) ^ (t2 & 0x20);\r
344 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x20);\r
345 break;\r
346\r
347 case 1:\r
348 // only reader\r
349 t1 = (t2 & 0x80);\r
350 t2 = ((t2 << 1) & 0x80);\r
351 break;\r
352\r
353 case 2:\r
354 // only tag\r
355 t1 = (t2 & 0x20);\r
356 t2 = ((t2 << 1) & 0x20);\r
357 break;\r
358\r
359 case 3:\r
360 // both, but tag with other algorithm\r
361 t1 = (t2 & 0x80) ^ (t2 & 0x08);\r
362 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x08);\r
363 break;\r
364 }\r
365\r
366 GraphBuffer[cnt++] = t1;\r
367 GraphBuffer[cnt++] = t2;\r
368 }\r
369 }\r
370 GraphTraceLen = n*4;\r
371// 1130\r
372 if(hasbeennull>nrlow || nrlow==0) {\r
373 PrintToScrollback("hasbeennull=%d", hasbeennull);\r
374 return 1;\r
375 }\r
376 else {\r
377 return 0;\r
378 }\r
379}\r
380\r
381\r
382static void CmdHexsamples(char *str)\r
383{\r
384 int i;\r
385 int n;\r
386\r
387 if(atoi(str) == 0) {\r
388 n = 12;\r
389 } else {\r
390 n = atoi(str)/4;\r
391 }\r
392\r
393 for(i = 0; i < n; i += 12) {\r
394 UsbCommand c;\r
395 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
396 c.ext1 = i;\r
397 SendCommand(&c, FALSE);\r
398 ReceiveCommand(&c);\r
399 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
400 PrintToScrollback("bad resp\n");\r
401 return;\r
402 }\r
403 int j;\r
404 for(j = 0; j < 48; j += 8) {\r
405 PrintToScrollback("%02x %02x %02x %02x %02x %02x %02x %02x",\r
406 c.d.asBytes[j+0],\r
407 c.d.asBytes[j+1],\r
408 c.d.asBytes[j+2],\r
409 c.d.asBytes[j+3],\r
410 c.d.asBytes[j+4],\r
411 c.d.asBytes[j+5],\r
412 c.d.asBytes[j+6],\r
413 c.d.asBytes[j+7],\r
414 c.d.asBytes[j+8]\r
415 );\r
416 }\r
417 }\r
418}\r
419\r
420static void CmdHisampless(char *str)\r
421{\r
422 int cnt = 0;\r
423 int i;\r
424 int n;\r
425\r
426 if(atoi(str) == 0) {\r
427 n = 1000;\r
428 } else {\r
429 n = atoi(str)/4;\r
430 }\r
431\r
432 for(i = 0; i < n; i += 12) {\r
433 UsbCommand c;\r
434 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;\r
435 c.ext1 = i;\r
436 SendCommand(&c, FALSE);\r
437 ReceiveCommand(&c);\r
438 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {\r
439 PrintToScrollback("bad resp\n");\r
440 return;\r
441 }\r
442 int j;\r
443 for(j = 0; j < 48; j++) {\r
444 GraphBuffer[cnt++] = (int)((signed char)c.d.asBytes[j]);\r
445 }\r
446 }\r
447 GraphTraceLen = cnt;\r
448\r
449 RepaintGraphWindow();\r
450}\r
451\r
452static WORD Iso15693Crc(BYTE *v, int n)\r
453{\r
454 DWORD reg;\r
455 int i, j;\r
456\r
457 reg = 0xffff;\r
458 for(i = 0; i < n; i++) {\r
459 reg = reg ^ ((DWORD)v[i]);\r
460 for (j = 0; j < 8; j++) {\r
461 if (reg & 0x0001) {\r
462 reg = (reg >> 1) ^ 0x8408;\r
463 } else {\r
464 reg = (reg >> 1);\r
465 }\r
466 }\r
467 }\r
468\r
469 return (WORD)~reg;\r
470}\r
471\r
472static void CmdHi14bdemod(char *str)\r
473{\r
474 int i, j, iold;\r
475 int isum, qsum;\r
476 int outOfWeakAt;\r
477 BOOL negateI, negateQ;\r
478\r
479 BYTE data[256];\r
480 int dataLen=0;\r
481\r
482 // As received, the samples are pairs, correlations against I and Q\r
483 // square waves. So estimate angle of initial carrier (or just\r
484 // quadrant, actually), and then do the demod.\r
485\r
486 // First, estimate where the tag starts modulating.\r
487 for(i = 0; i < GraphTraceLen; i += 2) {\r
488 if(abs(GraphBuffer[i]) + abs(GraphBuffer[i+1]) > 40) {\r
489 break;\r
490 }\r
491 }\r
492 if(i >= GraphTraceLen) {\r
493 PrintToScrollback("too weak to sync");\r
494 return;\r
495 }\r
496 PrintToScrollback("out of weak at %d", i);\r
497 outOfWeakAt = i;\r
498\r
499 // Now, estimate the phase in the initial modulation of the tag\r
500 isum = 0;\r
501 qsum = 0;\r
502 for(; i < (outOfWeakAt + 16); i += 2) {\r
503 isum += GraphBuffer[i+0];\r
504 qsum += GraphBuffer[i+1];\r
505 }\r
506 negateI = (isum < 0);\r
507 negateQ = (qsum < 0);\r
508\r
509 // Turn the correlation pairs into soft decisions on the bit.\r
510 j = 0;\r
511 for(i = 0; i < GraphTraceLen/2; i++) {\r
512 int si = GraphBuffer[j];\r
513 int sq = GraphBuffer[j+1];\r
514 if(negateI) si = -si;\r
515 if(negateQ) sq = -sq;\r
516 GraphBuffer[i] = si + sq;\r
517 j += 2;\r
518 }\r
519 GraphTraceLen = i;\r
520\r
521 i = outOfWeakAt/2;\r
522 while(GraphBuffer[i] > 0 && i < GraphTraceLen)\r
523 i++;\r
524 if(i >= GraphTraceLen) goto demodError;\r
525\r
526 iold = i;\r
527 while(GraphBuffer[i] < 0 && i < GraphTraceLen)\r
528 i++;\r
529 if(i >= GraphTraceLen) goto demodError;\r
530 if((i - iold) > 23) goto demodError;\r
531\r
532 PrintToScrollback("make it to demod loop");\r
533\r
534 for(;;) {\r
535 iold = i;\r
536 while(GraphBuffer[i] >= 0 && i < GraphTraceLen)\r
537 i++;\r
538 if(i >= GraphTraceLen) goto demodError;\r
539 if((i - iold) > 6) goto demodError;\r
540\r
541 WORD shiftReg = 0;\r
542 if(i + 20 >= GraphTraceLen) goto demodError;\r
543\r
544 for(j = 0; j < 10; j++) {\r
545 int soft = GraphBuffer[i] + GraphBuffer[i+1];\r
546\r
547 if(abs(soft) < ((abs(isum) + abs(qsum))/20)) {\r
548 PrintToScrollback("weak bit");\r
549 }\r
550\r
551 shiftReg >>= 1;\r
552 if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {\r
553 shiftReg |= 0x200;\r
554 }\r
555\r
556 i+= 2;\r
557 }\r
558\r
559 if( (shiftReg & 0x200) &&\r
560 !(shiftReg & 0x001))\r
561 {\r
562 // valid data byte, start and stop bits okay\r
563 PrintToScrollback(" %02x", (shiftReg >> 1) & 0xff);\r
564 data[dataLen++] = (shiftReg >> 1) & 0xff;\r
565 if(dataLen >= sizeof(data)) {\r
566 return;\r
567 }\r
568 } else if(shiftReg == 0x000) {\r
569 // this is EOF\r
570 break;\r
571 } else {\r
572 goto demodError;\r
573 }\r
574 }\r
575\r
576 BYTE first, second;\r
577 ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);\r
578 PrintToScrollback("CRC: %02x %02x (%s)\n", first, second,\r
579 (first == data[dataLen-2] && second == data[dataLen-1]) ?\r
580 "ok" : "****FAIL****");\r
581\r
582 RepaintGraphWindow();\r
583 return;\r
584\r
585demodError:\r
586 PrintToScrollback("demod error");\r
587 RepaintGraphWindow();\r
588}\r
589\r
590static void CmdHi14list(char *str)\r
591{\r
592 BYTE got[960];\r
593 GetFromBigBuf(got, sizeof(got));\r
594\r
595 PrintToScrollback("recorded activity:");\r
596 PrintToScrollback(" time :rssi: who bytes");\r
597 PrintToScrollback("---------+----+----+-----------");\r
598\r
599 int i = 0;\r
600 int prev = -1;\r
601\r
602 for(;;) {\r
603 if(i >= 900) {\r
604 break;\r
605 }\r
606\r
607 BOOL isResponse;\r
608 int timestamp = *((DWORD *)(got+i));\r
609 if(timestamp & 0x80000000) {\r
610 timestamp &= 0x7fffffff;\r
611 isResponse = 1;\r
612 } else {\r
613 isResponse = 0;\r
614 }\r
615 int metric = *((DWORD *)(got+i+4));\r
616\r
617 int len = got[i+8];\r
618\r
619 if(len > 100) {\r
620 break;\r
621 }\r
622 if(i + len >= 900) {\r
623 break;\r
624 }\r
625\r
626 BYTE *frame = (got+i+9);\r
627\r
628 char line[1000] = "";\r
629 int j;\r
630 for(j = 0; j < len; j++) {\r
631 sprintf(line+(j*3), "%02x ", frame[j]);\r
632 }\r
633\r
634 char *crc;\r
635 if(len > 2) {\r
636 BYTE b1, b2;\r
637 ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);\r
638 if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
639 crc = "**FAIL CRC**";\r
640 } else {\r
641 crc = "";\r
642 }\r
643 } else {\r
644 crc = "(SHORT)";\r
645 }\r
646\r
647 char metricString[100];\r
648 if(isResponse) {\r
649 sprintf(metricString, "%3d", metric);\r
650 } else {\r
651 strcpy(metricString, " ");\r
652 }\r
653\r
654 PrintToScrollback(" +%7d: %s: %s %s %s",\r
655 (prev < 0 ? 0 : timestamp - prev),\r
656 metricString,\r
657 (isResponse ? "TAG" : " "), line, crc);\r
658\r
659 prev = timestamp;\r
660 i += (len + 9);\r
661 }\r
662}\r
663\r
664static void CmdHi14alist(char *str)\r
665{\r
666 BYTE got[1920];\r
667 GetFromBigBuf(got, sizeof(got));\r
668\r
669 PrintToScrollback("recorded activity:");\r
670 PrintToScrollback(" ETU :rssi: who bytes");\r
671 PrintToScrollback("---------+----+----+-----------");\r
672\r
673 int i = 0;\r
674 int prev = -1;\r
675\r
676 for(;;) {\r
677 if(i >= 1900) {\r
678 break;\r
679 }\r
680\r
681 BOOL isResponse;\r
682 int timestamp = *((DWORD *)(got+i));\r
683 if(timestamp & 0x80000000) {\r
684 timestamp &= 0x7fffffff;\r
685 isResponse = 1;\r
686 } else {\r
687 isResponse = 0;\r
688 }\r
689\r
690 int metric = 0;\r
691 int parityBits = *((DWORD *)(got+i+4));\r
692 // 4 bytes of additional information...\r
693 // maximum of 32 additional parity bit information\r
694 //\r
695 // TODO:\r
696 // at each quarter bit period we can send power level (16 levels)\r
697 // or each half bit period in 256 levels.\r
698\r
699\r
700 int len = got[i+8];\r
701\r
702 if(len > 100) {\r
703 break;\r
704 }\r
705 if(i + len >= 1900) {\r
706 break;\r
707 }\r
708\r
709 BYTE *frame = (got+i+9);\r
710\r
711 // Break and stick with current result if buffer was not completely full\r
712 if(frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }\r
713\r
714 char line[1000] = "";\r
715 int j;\r
716 for(j = 0; j < len; j++) {\r
717 int oddparity = 0x01;\r
718 int k;\r
719\r
720 for(k=0;k<8;k++) {\r
721 oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);\r
722 }\r
723\r
724 //if((parityBits >> (len - j - 1)) & 0x01) {\r
725 if(isResponse && (oddparity != ((parityBits >> (len - j - 1)) & 0x01))) {\r
726 sprintf(line+(j*4), "%02x! ", frame[j]);\r
727 }\r
728 else {\r
729 sprintf(line+(j*4), "%02x ", frame[j]);\r
730 }\r
731 }\r
732\r
733 char *crc;\r
734 crc = "";\r
735 if(len > 2) {\r
736 BYTE b1, b2;\r
737 for(j = 0; j < (len - 1); j++) {\r
738 // gives problems... search for the reason..\r
739 /*if(frame[j] == 0xAA) {\r
740 switch(frame[j+1]) {\r
741 case 0x01:\r
742 crc = "[1] Two drops close after each other";\r
743 break;\r
744 case 0x02:\r
745 crc = "[2] Potential SOC with a drop in second half of bitperiod";\r
746 break;\r
747 case 0x03:\r
748 crc = "[3] Segment Z after segment X is not possible";\r
749 break;\r
750 case 0x04:\r
751 crc = "[4] Parity bit of a fully received byte was wrong";\r
752 break;\r
753 default:\r
754 crc = "[?] Unknown error";\r
755 break;\r
756 }\r
757 break;\r
758 }*/\r
759 }\r
760\r
761 if(strlen(crc)==0) {\r
762 ComputeCrc14443(CRC_14443_A, frame, len-2, &b1, &b2);\r
763 if(b1 != frame[len-2] || b2 != frame[len-1]) {\r
764 crc = (isResponse & (len < 6)) ? "" : " !crc";\r
765 } else {\r
766 crc = "";\r
767 }\r
768 }\r
769 } else {\r
770 crc = ""; // SHORT\r
771 }\r
772\r
773 char metricString[100];\r
774 if(isResponse) {\r
775 sprintf(metricString, "%3d", metric);\r
776 } else {\r
777 strcpy(metricString, " ");\r
778 }\r
779\r
780 PrintToScrollback(" +%7d: %s: %s %s %s",\r
781 (prev < 0 ? 0 : (timestamp - prev)),\r
782 metricString,\r
783 (isResponse ? "TAG" : " "), line, crc);\r
784\r
785 prev = timestamp;\r
786 i += (len + 9);\r
787 }\r
788 CommandFinished = 1;\r
789}\r
790\r
791static void CmdHi15demod(char *str)\r
792{\r
793 // The sampling rate is 106.353 ksps/s, for T = 18.8 us\r
794\r
795 // SOF defined as \r
796 // 1) Unmodulated time of 56.64us\r
797 // 2) 24 pulses of 423.75khz\r
798 // 3) logic '1' (unmodulated for 18.88us followed by 8 pulses of 423.75khz)\r
799\r
800 static const int FrameSOF[] = {\r
801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
803 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
804 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
805 -1, -1, -1, -1,\r
806 -1, -1, -1, -1,\r
807 1, 1, 1, 1,\r
808 1, 1, 1, 1\r
809 };\r
810 static const int Logic0[] = {\r
811 1, 1, 1, 1,\r
812 1, 1, 1, 1,\r
813 -1, -1, -1, -1,\r
814 -1, -1, -1, -1\r
815 };\r
816 static const int Logic1[] = {\r
817 -1, -1, -1, -1,\r
818 -1, -1, -1, -1,\r
819 1, 1, 1, 1,\r
820 1, 1, 1, 1\r
821 };\r
822\r
823 // EOF defined as \r
824 // 1) logic '0' (8 pulses of 423.75khz followed by unmodulated for 18.88us)\r
825 // 2) 24 pulses of 423.75khz\r
826 // 3) Unmodulated time of 56.64us\r
827\r
828 static const int FrameEOF[] = {\r
829 1, 1, 1, 1,\r
830 1, 1, 1, 1,\r
831 -1, -1, -1, -1,\r
832 -1, -1, -1, -1,\r
833 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
834 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1\r
837 };\r
838\r
839 int i, j;\r
840 int max = 0, maxPos;\r
841\r
842 int skip = 4;\r
843\r
844 if(GraphTraceLen < 1000) return;\r
845\r
846 // First, correlate for SOF\r
847 for(i = 0; i < 100; i++) {\r
848 int corr = 0;\r
849 for(j = 0; j < arraylen(FrameSOF); j += skip) {\r
850 corr += FrameSOF[j]*GraphBuffer[i+(j/skip)];\r
851 }\r
852 if(corr > max) {\r
853 max = corr;\r
854 maxPos = i;\r
855 }\r
856 }\r
857 PrintToScrollback("SOF at %d, correlation %d", maxPos,\r
858 max/(arraylen(FrameSOF)/skip));\r
859\r
860 i = maxPos + arraylen(FrameSOF)/skip;\r
861 int k = 0;\r
862 BYTE outBuf[20];\r
863 memset(outBuf, 0, sizeof(outBuf));\r
864 BYTE mask = 0x01;\r
865 for(;;) {\r
866 int corr0 = 0, corr1 = 0, corrEOF = 0;\r
867 for(j = 0; j < arraylen(Logic0); j += skip) {\r
868 corr0 += Logic0[j]*GraphBuffer[i+(j/skip)];\r
869 }\r
870 for(j = 0; j < arraylen(Logic1); j += skip) {\r
871 corr1 += Logic1[j]*GraphBuffer[i+(j/skip)];\r
872 }\r
873 for(j = 0; j < arraylen(FrameEOF); j += skip) {\r
874 corrEOF += FrameEOF[j]*GraphBuffer[i+(j/skip)];\r
875 }\r
876 // Even things out by the length of the target waveform.\r
877 corr0 *= 4;\r
878 corr1 *= 4;\r
879\r
880 if(corrEOF > corr1 && corrEOF > corr0) {\r
881 PrintToScrollback("EOF at %d", i);\r
882 break;\r
883 } else if(corr1 > corr0) {\r
884 i += arraylen(Logic1)/skip;\r
885 outBuf[k] |= mask;\r
886 } else {\r
887 i += arraylen(Logic0)/skip;\r
888 }\r
889 mask <<= 1;\r
890 if(mask == 0) {\r
891 k++;\r
892 mask = 0x01;\r
893 }\r
894 if((i+(int)arraylen(FrameEOF)) >= GraphTraceLen) {\r
895 PrintToScrollback("ran off end!");\r
896 break;\r
897 }\r
898 }\r
899 if(mask != 0x01) {\r
900 PrintToScrollback("error, uneven octet! (discard extra bits!)");\r
901 PrintToScrollback(" mask=%02x", mask);\r
902 }\r
903 PrintToScrollback("%d octets", k);\r
904\r
905 for(i = 0; i < k; i++) {\r
906 PrintToScrollback("# %2d: %02x ", i, outBuf[i]);\r
907 }\r
908 PrintToScrollback("CRC=%04x", Iso15693Crc(outBuf, k-2));\r
909}\r
910\r
911static void CmdTiread(char *str)\r
912{\r
913 UsbCommand c;\r
914 c.cmd = CMD_ACQUIRE_RAW_BITS_TI_TYPE;\r
915 SendCommand(&c, FALSE);\r
916}\r
917\r
918static void CmdTibits(char *str)\r
919{\r
920 int cnt = 0;\r
921 int i;\r
922 for(i = 0; i < 1536; i += 12) {\r
923 UsbCommand c;\r
924 c.cmd = CMD_DOWNLOAD_RAW_BITS_TI_TYPE;\r
925 c.ext1 = i;\r
926 SendCommand(&c, FALSE);\r
927 ReceiveCommand(&c);\r
928 if(c.cmd != CMD_DOWNLOADED_RAW_BITS_TI_TYPE) {\r
929 PrintToScrollback("bad resp\n");\r
930 return;\r
931 }\r
932 int j;\r
933 for(j = 0; j < 12; j++) {\r
934 int k;\r
935 for(k = 31; k >= 0; k--) {\r
936 if(c.d.asDwords[j] & (1 << k)) {\r
937 GraphBuffer[cnt++] = 1;\r
938 } else {\r
939 GraphBuffer[cnt++] = -1;\r
940 }\r
941 }\r
942 }\r
943 }\r
944 GraphTraceLen = 1536*32;\r
945 RepaintGraphWindow();\r
946}\r
947\r
948static void CmdTidemod(char *cmdline)\r
949{\r
950 /* MATLAB as follows:\r
951f_s = 2000000; % sampling frequency\r
952f_l = 123200; % low FSK tone\r
953f_h = 134200; % high FSK tone\r
954\r
955T_l = 119e-6; % low bit duration\r
956T_h = 130e-6; % high bit duration\r
957\r
958l = 2*pi*ones(1, floor(f_s*T_l))*(f_l/f_s);\r
959h = 2*pi*ones(1, floor(f_s*T_h))*(f_h/f_s);\r
960\r
961l = sign(sin(cumsum(l)));\r
962h = sign(sin(cumsum(h)));\r
963 */\r
964 static const int LowTone[] = {\r
965 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1,\r
966 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
967 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1,\r
968 -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1,\r
969 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1,\r
970 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1,\r
971 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1,\r
972 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
973 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1,\r
974 -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1,\r
975 -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,\r
976 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1,\r
977 1, 1, 1, 1, 1, 1, 1, -1, -1, -1,\r
978 };\r
979 static const int HighTone[] = {\r
980 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
981 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,\r
982 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
983 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1,\r
984 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
985 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1,\r
986 -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
987 -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,\r
988 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
989 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,\r
990 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,\r
991 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1,\r
992 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,\r
993 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1,\r
994 };\r
995\r
996 int convLen = max(arraylen(HighTone), arraylen(LowTone));\r
997\r
998 int i;\r
999 for(i = 0; i < GraphTraceLen - convLen; i++) {\r
1000 int j;\r
1001 int lowSum = 0, highSum = 0;;\r
1002 int lowLen = arraylen(LowTone);\r
1003 int highLen = arraylen(HighTone);\r
1004\r
1005 for(j = 0; j < lowLen; j++) {\r
1006 lowSum += LowTone[j]*GraphBuffer[i+j];\r
1007 }\r
1008 for(j = 0; j < highLen; j++) {\r
1009 highSum += HighTone[j]*GraphBuffer[i+j];\r
1010 }\r
1011 lowSum = abs((100*lowSum) / lowLen);\r
1012 highSum = abs((100*highSum) / highLen);\r
1013 GraphBuffer[i] = (highSum << 16) | lowSum;\r
1014 }\r
1015\r
1016 for(i = 0; i < GraphTraceLen - convLen - 16; i++) {\r
1017 int j;\r
1018 int lowTot = 0, highTot = 0;\r
1019 // 16 and 15 are f_s divided by f_l and f_h, rounded\r
1020 for(j = 0; j < 16; j++) {\r
1021 lowTot += (GraphBuffer[i+j] & 0xffff);\r
1022 }\r
1023 for(j = 0; j < 15; j++) {\r
1024 highTot += (GraphBuffer[i+j] >> 16);\r
1025 }\r
1026 GraphBuffer[i] = lowTot - highTot;\r
1027 }\r
1028\r
1029 GraphTraceLen -= (convLen + 16);\r
1030\r
1031 RepaintGraphWindow();\r
1032\r
1033 // Okay, so now we have unsliced soft decisions; find bit-sync, and then\r
1034 // get some bits.\r
1035\r
1036 int max = 0, maxPos = 0;\r
1037 for(i = 0; i < 6000; i++) {\r
1038 int j;\r
1039 int dec = 0;\r
1040 for(j = 0; j < 8*arraylen(LowTone); j++) {\r
1041 dec -= GraphBuffer[i+j];\r
1042 }\r
1043 for(; j < 8*arraylen(LowTone) + 8*arraylen(HighTone); j++) {\r
1044 dec += GraphBuffer[i+j];\r
1045 }\r
1046 if(dec > max) {\r
1047 max = dec;\r
1048 maxPos = i;\r
1049 }\r
1050 }\r
1051 GraphBuffer[maxPos] = 800;\r
1052 GraphBuffer[maxPos+1] = -800;\r
1053\r
1054 maxPos += 8*arraylen(LowTone);\r
1055 GraphBuffer[maxPos] = 800;\r
1056 GraphBuffer[maxPos+1] = -800;\r
1057 maxPos += 8*arraylen(HighTone);\r
1058\r
1059 GraphBuffer[maxPos] = 800;\r
1060 GraphBuffer[maxPos+1] = -800;\r
1061\r
1062 PrintToScrollback("actual data bits start at sample %d", maxPos);\r
1063\r
1064 PrintToScrollback("length %d/%d", arraylen(HighTone), arraylen(LowTone));\r
1065\r
1066 GraphBuffer[maxPos] = 800;\r
1067 GraphBuffer[maxPos+1] = -800;\r
1068\r
1069 BYTE bits[64+16+8+1];\r
1070 bits[sizeof(bits)-1] = '\0';\r
1071\r
1072 for(i = 0; i < arraylen(bits); i++) {\r
1073 int high = 0;\r
1074 int low = 0;\r
1075 int j;\r
1076 for(j = 0; j < arraylen(LowTone); j++) {\r
1077 low -= GraphBuffer[maxPos+j];\r
1078 }\r
1079 for(j = 0; j < arraylen(HighTone); j++) {\r
1080 high += GraphBuffer[maxPos+j];\r
1081 }\r
1082 if(high > low) {\r
1083 bits[i] = '1';\r
1084 maxPos += arraylen(HighTone);\r
1085 } else {\r
1086 bits[i] = '.';\r
1087 maxPos += arraylen(LowTone);\r
1088 }\r
1089 GraphBuffer[maxPos] = 800;\r
1090 GraphBuffer[maxPos+1] = -800;\r
1091 }\r
1092 PrintToScrollback("bits: '%s'", bits);\r
1093\r
1094 DWORD h = 0, l = 0;\r
1095 for(i = 0; i < 32; i++) {\r
1096 if(bits[i] == '1') {\r
1097 l |= (1<<i);\r
1098 }\r
1099 }\r
1100 for(i = 32; i < 64; i++) {\r
1101 if(bits[i] == '1') {\r
1102 h |= (1<<(i-32));\r
1103 }\r
1104 }\r
1105 PrintToScrollback("hex: %08x %08x", h, l);\r
1106}\r
1107\r
1108static void CmdNorm(char *str)\r
1109{\r
1110 int i;\r
1111 int max = INT_MIN, min = INT_MAX;\r
1112 for(i = 10; i < GraphTraceLen; i++) {\r
1113 if(GraphBuffer[i] > max) {\r
1114 max = GraphBuffer[i];\r
1115 }\r
1116 if(GraphBuffer[i] < min) {\r
1117 min = GraphBuffer[i];\r
1118 }\r
1119 }\r
1120 if(max != min) {\r
1121 for(i = 0; i < GraphTraceLen; i++) {\r
1122 GraphBuffer[i] = (GraphBuffer[i] - ((max + min)/2))*1000/\r
1123 (max - min);\r
1124 }\r
1125 }\r
1126 RepaintGraphWindow();\r
1127}\r
1128\r
1129static void CmdDec(char *str)\r
1130{\r
1131 int i;\r
1132 for(i = 0; i < (GraphTraceLen/2); i++) {\r
1133 GraphBuffer[i] = GraphBuffer[i*2];\r
1134 }\r
1135 GraphTraceLen /= 2;\r
1136 PrintToScrollback("decimated by 2");\r
1137 RepaintGraphWindow();\r
1138}\r
1139\r
1140static void CmdHpf(char *str)\r
1141{\r
1142 int i;\r
1143 int accum = 0;\r
1144 for(i = 10; i < GraphTraceLen; i++) {\r
1145 accum += GraphBuffer[i];\r
1146 }\r
1147 accum /= (GraphTraceLen - 10);\r
1148 for(i = 0; i < GraphTraceLen; i++) {\r
1149 GraphBuffer[i] -= accum;\r
1150 }\r
1151\r
1152 RepaintGraphWindow();\r
1153}\r
1154\r
1155static void CmdZerocrossings(char *str)\r
1156{\r
1157 int i;\r
1158 // Zero-crossings aren't meaningful unless the signal is zero-mean.\r
1159 CmdHpf("");\r
1160\r
1161 int sign = 1;\r
1162 int zc = 0;\r
1163 int lastZc = 0;\r
1164 for(i = 0; i < GraphTraceLen; i++) {\r
1165 if(GraphBuffer[i]*sign >= 0) {\r
1166 // No change in sign, reproduce the previous sample count.\r
1167 zc++;\r
1168 GraphBuffer[i] = lastZc;\r
1169 } else {\r
1170 // Change in sign, reset the sample count.\r
1171 sign = -sign;\r
1172 GraphBuffer[i] = lastZc;\r
1173 if(sign > 0) {\r
1174 lastZc = zc;\r
1175 zc = 0;\r
1176 }\r
1177 }\r
1178 }\r
1179\r
1180 RepaintGraphWindow();\r
1181}\r
1182\r
1183static void CmdLtrim(char *str)\r
1184{\r
1185 int i;\r
1186 int ds = atoi(str);\r
1187\r
1188 for(i = ds; i < GraphTraceLen; i++) {\r
1189 GraphBuffer[i-ds] = GraphBuffer[i];\r
1190 }\r
1191 GraphTraceLen -= ds;\r
1192\r
1193 RepaintGraphWindow();\r
1194}\r
1195\r
1196static void CmdAutoCorr(char *str)\r
1197{\r
1198 static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];\r
1199\r
1200 int window = atoi(str);\r
1201\r
1202 if(window == 0) {\r
1203 PrintToScrollback("needs a window");\r
1204 return;\r
1205 }\r
1206\r
1207 if(window >= GraphTraceLen) {\r
1208 PrintToScrollback("window must be smaller than trace (%d samples)",\r
1209 GraphTraceLen);\r
1210 return;\r
1211 }\r
1212\r
1213 PrintToScrollback("performing %d correlations", GraphTraceLen - window);\r
1214\r
1215 int i;\r
1216 for(i = 0; i < GraphTraceLen - window; i++) {\r
1217 int sum = 0;\r
1218 int j;\r
1219 for(j = 0; j < window; j++) {\r
1220 sum += (GraphBuffer[j]*GraphBuffer[i+j]) / 256;\r
1221 }\r
1222 CorrelBuffer[i] = sum;\r
1223 }\r
1224 GraphTraceLen = GraphTraceLen - window;\r
1225 memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen*sizeof(int));\r
1226\r
1227 RepaintGraphWindow();\r
1228}\r
1229\r
1230static void CmdVchdemod(char *str)\r
1231{\r
1232 // Is this the entire sync pattern, or does this also include some\r
1233 // data bits that happen to be the same everywhere? That would be\r
1234 // lovely to know.\r
1235 static const int SyncPattern[] = {\r
1236 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1237 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1238 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1239 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1240 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1241 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1242 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1243 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
1245 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\r
1246 };\r
1247\r
1248 // So first, we correlate for the sync pattern, and mark that.\r
1249 int bestCorrel = 0, bestPos = 0;\r
1250 int i;\r
1251 // It does us no good to find the sync pattern, with fewer than\r
1252 // 2048 samples after it...\r
1253 for(i = 0; i < (GraphTraceLen-2048); i++) {\r
1254 int sum = 0;\r
1255 int j;\r
1256 for(j = 0; j < arraylen(SyncPattern); j++) {\r
1257 sum += GraphBuffer[i+j]*SyncPattern[j];\r
1258 }\r
1259 if(sum > bestCorrel) {\r
1260 bestCorrel = sum;\r
1261 bestPos = i;\r
1262 }\r
1263 }\r
1264 PrintToScrollback("best sync at %d [metric %d]", bestPos, bestCorrel);\r
1265\r
1266 char bits[257];\r
1267 bits[256] = '\0';\r
1268\r
1269 int worst = INT_MAX;\r
1270 int worstPos;\r
1271\r
1272 for(i = 0; i < 2048; i += 8) {\r
1273 int sum = 0;\r
1274 int j;\r
1275 for(j = 0; j < 8; j++) {\r
1276 sum += GraphBuffer[bestPos+i+j];\r
1277 }\r
1278 if(sum < 0) {\r
1279 bits[i/8] = '.';\r
1280 } else {\r
1281 bits[i/8] = '1';\r
1282 }\r
1283 if(abs(sum) < worst) {\r
1284 worst = abs(sum);\r
1285 worstPos = i;\r
1286 }\r
1287 }\r
1288 PrintToScrollback("bits:");\r
1289 PrintToScrollback("%s", bits);\r
1290 PrintToScrollback("worst metric: %d at pos %d", worst, worstPos);\r
1291\r
1292 if(strcmp(str, "clone")==0) {\r
1293 GraphTraceLen = 0;\r
1294 char *s;\r
1295 for(s = bits; *s; s++) {\r
1296 int j;\r
1297 for(j = 0; j < 16; j++) {\r
1298 GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;\r
1299 }\r
1300 }\r
1301 RepaintGraphWindow();\r
1302 }\r
1303}\r
1304\r
a60612db 1305static void CmdIndalademod(char *str)\r
1306{\r
1307 // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID\r
1308\r
1309 int state = -1;\r
1310 int count = 0;\r
1311 int i, j;\r
1312 // worst case with GraphTraceLen=64000 is < 4096\r
1313 // under normal conditions it's < 2048\r
1314 BYTE rawbits[4096];\r
1315 int rawbit = 0;\r
1316 int worst = 0, worstPos = 0;\r
1317 PrintToScrollback("Expecting a bit less than %d raw bits", GraphTraceLen/32);\r
1318 for(i = 0; i < GraphTraceLen-1; i += 2) {\r
1319 count+=1;\r
1320 if((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {\r
1321 if (state == 0) {\r
1322 for(j = 0; j < count - 8; j += 16) {\r
1323 rawbits[rawbit++] = 0;\r
1324 }\r
1325 if ((abs(count - j)) > worst) {\r
1326 worst = abs(count - j);\r
1327 worstPos = i;\r
1328 }\r
1329 }\r
1330 state = 1;\r
1331 count=0;\r
1332 } else if((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {\r
1333 if (state == 1) {\r
1334 for(j = 0; j < count - 8; j += 16) {\r
1335 rawbits[rawbit++] = 1;\r
1336 }\r
1337 if ((abs(count - j)) > worst) {\r
1338 worst = abs(count - j);\r
1339 worstPos = i;\r
1340 }\r
1341 }\r
1342 state = 0;\r
1343 count=0;\r
1344 }\r
1345 }\r
1346 PrintToScrollback("Recovered %d raw bits", rawbit);\r
1347 PrintToScrollback("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);\r
1348\r
1349 // Finding the start of a UID\r
1350 int uidlen, long_wait;\r
1351 if(strcmp(str, "224") == 0) {\r
1352 uidlen=224;\r
1353 long_wait=30;\r
1354 } else {\r
1355 uidlen=64;\r
1356 long_wait=29;\r
1357 }\r
1358 int start;\r
1359 int first = 0;\r
1360 for(start = 0; start <= rawbit - uidlen; start++) {\r
1361 first = rawbits[start];\r
1362 for(i = start; i < start + long_wait; i++) {\r
1363 if(rawbits[i] != first) {\r
1364 break;\r
1365 }\r
1366 }\r
1367 if(i == (start + long_wait)) {\r
1368 break;\r
1369 }\r
1370 }\r
1371 if(start == rawbit - uidlen + 1) {\r
1372 PrintToScrollback("nothing to wait for");\r
1373 return;\r
1374 }\r
1375\r
1376 // Inverting signal if needed\r
1377 if(first == 1) {\r
1378 for(i = start; i < rawbit; i++) {\r
1379 rawbits[i] = !rawbits[i];\r
1380 }\r
1381 }\r
1382\r
1383 // Dumping UID\r
1384 BYTE bits[224];\r
1385 char showbits[225];\r
1386 showbits[uidlen]='\0';\r
1387 int bit;\r
1388 i = start;\r
1389 int times = 0;\r
1390 if(uidlen > rawbit) {\r
1391 PrintToScrollback("Warning: not enough raw bits to get a full UID");\r
1392 for(bit = 0; bit < rawbit; bit++) {\r
1393 bits[bit] = rawbits[i++];\r
1394 // As we cannot know the parity, let's use "." and "/"\r
1395 showbits[bit] = '.' + bits[bit];\r
1396 }\r
1397 showbits[bit+1]='\0';\r
1398 PrintToScrollback("Partial UID=%s", showbits);\r
1399 return;\r
1400 } else {\r
1401 for(bit = 0; bit < uidlen; bit++) {\r
1402 bits[bit] = rawbits[i++];\r
1403 showbits[bit] = '0' + bits[bit];\r
1404 }\r
1405 times = 1;\r
1406 }\r
1407 PrintToScrollback("UID=%s", showbits);\r
1408\r
1409 // Checking UID against next occurences\r
1410 for(; i + uidlen <= rawbit;) {\r
1411 int failed = 0;\r
1412 for(bit = 0; bit < uidlen; bit++) {\r
1413 if(bits[bit] != rawbits[i++]) {\r
1414 failed = 1;\r
1415 break;\r
1416 }\r
1417 }\r
1418 if (failed == 1) {\r
1419 break;\r
1420 }\r
1421 times += 1;\r
1422 }\r
1423 PrintToScrollback("Occurences: %d (expected %d)", times, (rawbit - start) / uidlen);\r
1424\r
1425 // Remodulating for tag cloning\r
1426 GraphTraceLen = 32*uidlen;\r
1427 i = 0;\r
1428 int phase = 0;\r
1429 for(bit = 0; bit < uidlen; bit++) {\r
1430 if(bits[bit] == 0) {\r
1431 phase = 0;\r
1432 } else {\r
1433 phase = 1;\r
1434 }\r
1435 int j;\r
1436 for(j = 0; j < 32; j++) {\r
1437 GraphBuffer[i++] = phase;\r
1438 phase = !phase;\r
1439 }\r
1440 }\r
1441\r
1442 RepaintGraphWindow();\r
1443}\r
1444\r
6658905f 1445static void CmdFlexdemod(char *str)\r
1446{\r
1447 int i;\r
1448 for(i = 0; i < GraphTraceLen; i++) {\r
1449 if(GraphBuffer[i] < 0) {\r
1450 GraphBuffer[i] = -1;\r
1451 } else {\r
1452 GraphBuffer[i] = 1;\r
1453 }\r
1454 }\r
1455\r
1456#define LONG_WAIT 100\r
1457 int start;\r
1458 for(start = 0; start < GraphTraceLen - LONG_WAIT; start++) {\r
1459 int first = GraphBuffer[start];\r
1460 for(i = start; i < start + LONG_WAIT; i++) {\r
1461 if(GraphBuffer[i] != first) {\r
1462 break;\r
1463 }\r
1464 }\r
1465 if(i == (start + LONG_WAIT)) {\r
1466 break;\r
1467 }\r
1468 }\r
1469 if(start == GraphTraceLen - LONG_WAIT) {\r
1470 PrintToScrollback("nothing to wait for");\r
1471 return;\r
1472 }\r
1473\r
1474 GraphBuffer[start] = 2;\r
1475 GraphBuffer[start+1] = -2;\r
1476\r
1477 BYTE bits[64];\r
1478\r
1479 int bit;\r
1480 i = start;\r
1481 for(bit = 0; bit < 64; bit++) {\r
1482 int j;\r
1483 int sum = 0;\r
1484 for(j = 0; j < 16; j++) {\r
1485 sum += GraphBuffer[i++];\r
1486 }\r
1487 if(sum > 0) {\r
1488 bits[bit] = 1;\r
1489 } else {\r
1490 bits[bit] = 0;\r
1491 }\r
1492 PrintToScrollback("bit %d sum %d", bit, sum);\r
1493 }\r
1494\r
1495 for(bit = 0; bit < 64; bit++) {\r
1496 int j;\r
1497 int sum = 0;\r
1498 for(j = 0; j < 16; j++) {\r
1499 sum += GraphBuffer[i++];\r
1500 }\r
1501 if(sum > 0 && bits[bit] != 1) {\r
1502 PrintToScrollback("oops1 at %d", bit);\r
1503 }\r
1504 if(sum < 0 && bits[bit] != 0) {\r
1505 PrintToScrollback("oops2 at %d", bit);\r
1506 }\r
1507 }\r
1508\r
1509 GraphTraceLen = 32*64;\r
1510 i = 0;\r
1511 int phase = 0;\r
1512 for(bit = 0; bit < 64; bit++) {\r
1513 if(bits[bit] == 0) {\r
1514 phase = 0;\r
1515 } else {\r
1516 phase = 1;\r
1517 }\r
1518 int j;\r
1519 for(j = 0; j < 32; j++) {\r
1520 GraphBuffer[i++] = phase;\r
1521 phase = !phase;\r
1522 }\r
1523 }\r
1524\r
1525 RepaintGraphWindow();\r
1526}\r
1527
1528/*
1529 * Generic command to demodulate ASK. bit length in argument.
1530 * Giving the bit length helps discriminate ripple effects
1531 * upon zero crossing for noisy traces.
1532 *
1533 * Second is convention: positive or negative (High mod means zero
1534 * or high mod means one)
1535 *
1536 * Updates the Graph trace with 0/1 values
1537 *
1538 * Arguments:
1539 * sl : bit length in terms of number of samples per bit
1540 * (use yellow/purple markers to compute).
1541 * c : 0 or 1
1542 */
1543
1544static void Cmdaskdemod(char *str) {
1545 int i;
1546 int sign = 1;
1547 int n = 0;
1548 int c = 0;\r
1549 int t1 = 0;
1550
1551 // TODO: complain if we do not give 2 arguments here !
1552 sscanf(str, "%i %i", &n, &c);
1553 if (c == 0) {
1554 c = 1 ;
1555 } else {
1556 c = -1;
1557 }
1558
1559 if (GraphBuffer[0]*c > 0) {
1560 GraphBuffer[0] = 1;
1561 } else {
1562 GraphBuffer[0] = 0;
1563 }
1564 for(i=1;i<GraphTraceLen;i++) {
1565 /* Analyse signal within the symbol length */
1566 /* Decide if we crossed a zero */
1567 if (GraphBuffer[i]*sign < 0) {
1568 /* Crossed a zero, check if this is a ripple or not */
1569 if ( (i-t1) > n/4 ) {
1570 sign = -sign;
1571 t1=i;
1572 if (GraphBuffer[i]*c > 0){
1573 GraphBuffer[i]=1;
1574 } else {
1575 GraphBuffer[i]=0;
1576 }
1577 } else {
1578 /* This is a ripple, set the current sample value
1579 to the same as previous */
1580 GraphBuffer[i] = GraphBuffer[i-1];
1581 }
1582 } else {
1583 GraphBuffer[i] = GraphBuffer[i-1];
1584 }
1585 }
1586 RepaintGraphWindow();
1587}
1588
1589
1590/*
1591 * Manchester demodulate a bitstream. The bitstream needs to be already in
1592 * the GraphBuffer as 0 and 1 values
1593 *
1594 * Give the clock rate as argument in order to help the sync - the algorithm
1595 * resyncs at each pulse anyway.
1596 *
1597 * Not optimized by any means, this is the 1st time I'm writing this type of
1598 * routine, feel free to improve...
1599 *
1600 * 1st argument: clock rate (as number of samples per clock rate)
1601 */
1602static void Cmdmanchesterdemod(char *str) {
1603 int i;
1604 int clock;
6658905f 1605 int lastval;
1606 int lc = 0;
1607 int bitidx = 0;
1608 int bitidx2;
1609
1610
1611 sscanf(str, "%i", &clock);
1612
1613 int tolerance = clock/4;
1614 /* Holds the decoded bitstream. */
1615 int BitStream[MAX_GRAPH_TRACE_LEN*2];
1616 int BitStream2[MAX_GRAPH_TRACE_LEN];
1617
1618 /* Detect first transition */
1619 /* Lo-Hi (arbitrary) */
1620 for(i=1;i<GraphTraceLen;i++) {
1621 if (GraphBuffer[i-1]<GraphBuffer[i]) {
1622 lastval = i;
1623 BitStream[0]=0; // Previous state = 0;
1624 break;
1625 }
1626 }
1627
1628 /* Then detect duration between 2 successive transitions */
1629 /* At this stage, GraphTrace is either 0 or 1 */
1630 for(bitidx = 1 ;i<GraphTraceLen;i++) {
1631 if (GraphBuffer[i-1] != GraphBuffer[i]) {
1632 lc = i-lastval;
1633 lastval = i;
1634 // Then switch depending on lc length:
1635 // Tolerance is 1/4 of clock rate (arbitrary)
1636 if ((lc-clock/2) < tolerance) {
1637 // Short pulse
1638 BitStream[bitidx++]=GraphBuffer[i-1];
1639 } else if ((lc-clock) < tolerance) {
1640 // Long pulse
1641 BitStream[bitidx++]=GraphBuffer[i-1];
1642 BitStream[bitidx++]=GraphBuffer[i-1];
1643 } else {
1644 // Error
1645 PrintToScrollback("Warning: Manchester decode error for pulse width detection.");
1646 PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
1647 }
1648 }
1649 }
1650
1651 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
1652 for (bitidx2 = 0; bitidx2<bitidx; bitidx2 += 2) {
1653 if ((BitStream[bitidx2] == 0) && (BitStream[bitidx2+1] == 1)) {
1654 BitStream2[bitidx2/2] = 1;
1655 } else if ((BitStream[bitidx2] == 1) && (BitStream[bitidx2+1] == 0)) {
1656 BitStream2[bitidx2/2] = 0;
1657 } else {
1658 // We cannot end up in this stage, this means we are unsynchronized,
1659 // move up 1 bit:
1660 bitidx2++;
1661 PrintToScrollback("Unsynchronized, resync...");
1662 PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");
1663 }
1664 }
1665 PrintToScrollback("Manchester decoded bitstream \n---------");
1666 // Now output the bitstream to the scrollback by line of 16 bits
1667 for (i = 0; i<bitidx/2; i+=16) {
1668 PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
1669 BitStream2[i],
1670 BitStream2[i+1],
1671 BitStream2[i+2],
1672 BitStream2[i+3],
1673 BitStream2[i+4],
1674 BitStream2[i+5],
1675 BitStream2[i+6],
1676 BitStream2[i+7],
1677 BitStream2[i+8],
1678 BitStream2[i+9],
1679 BitStream2[i+10],
1680 BitStream2[i+11],
1681 BitStream2[i+12],
1682 BitStream2[i+13],
1683 BitStream2[i+14],
1684 BitStream2[i+15]);
1685 }
1686}
1687
1688
1689
1690/*
1691 * Usage ???
1692 */\r
1693static void CmdHiddemod(char *str)\r
1694{\r
1695 if(GraphTraceLen < 4800) {\r
1696 PrintToScrollback("too short; need at least 4800 samples");\r
1697 return;\r
1698 }\r
1699\r
1700 GraphTraceLen = 4800;\r
1701 int i;\r
1702 for(i = 0; i < GraphTraceLen; i++) {\r
1703 if(GraphBuffer[i] < 0) {\r
1704 GraphBuffer[i] = 0;\r
1705 } else {\r
1706 GraphBuffer[i] = 1;\r
1707 }\r
1708 }\r
1709 RepaintGraphWindow();\r
1710}\r
1711\r
1712static void CmdPlot(char *str)\r
1713{\r
1714 ShowGraphWindow();\r
1715}\r
1716\r
1717static void CmdHide(char *str)\r
1718{\r
1719 HideGraphWindow();\r
1720}\r
1721\r
1722static void CmdScale(char *str)\r
1723{\r
1724 CursorScaleFactor = atoi(str);\r
1725 if(CursorScaleFactor == 0) {\r
1726 PrintToScrollback("bad, can't have zero scale");\r
1727 CursorScaleFactor = 1;\r
1728 }\r
1729 RepaintGraphWindow();\r
1730}\r
1731\r
1732static void CmdSave(char *str)\r
1733{\r
1734 FILE *f = fopen(str, "w");\r
1735 if(!f) {\r
1736 PrintToScrollback("couldn't open '%s'", str);\r
1737 return;\r
1738 }\r
1739 int i;\r
1740 for(i = 0; i < GraphTraceLen; i++) {\r
1741 fprintf(f, "%d\n", GraphBuffer[i]);\r
1742 }\r
1743 fclose(f);\r
1744 PrintToScrollback("saved to '%s'", str);\r
1745}\r
1746\r
1747static void CmdLoad(char *str)\r
1748{\r
1749 FILE *f = fopen(str, "r");\r
1750 if(!f) {\r
1751 PrintToScrollback("couldn't open '%s'", str);\r
1752 return;\r
1753 }\r
1754\r
1755 GraphTraceLen = 0;\r
1756 char line[80];\r
1757 while(fgets(line, sizeof(line), f)) {\r
1758 GraphBuffer[GraphTraceLen] = atoi(line);\r
1759 GraphTraceLen++;\r
1760 }\r
1761 fclose(f);\r
1762 PrintToScrollback("loaded %d samples", GraphTraceLen);\r
1763 RepaintGraphWindow();\r
1764}\r
1765\r
1766static void CmdHIDsimTAG(char *str)\r
1767{\r
1768 unsigned int hi=0, lo=0;\r
1769 int n=0, i=0;\r
1770 UsbCommand c;\r
1771\r
1772 while (sscanf(&str[i++], "%1x", &n ) == 1) {\r
1773 hi=(hi<<4)|(lo>>28);\r
1774 lo=(lo<<4)|(n&0xf);\r
1775 }\r
1776\r
1777 PrintToScrollback("Emulating tag with ID %x%16x", hi, lo);\r
1778\r
1779 c.cmd = CMD_HID_SIM_TAG;\r
1780 c.ext1 = hi;\r
1781 c.ext2 = lo;\r
1782 SendCommand(&c, FALSE);\r
1783}\r
1784\r
1785static void CmdLcdReset(char *str)\r
1786{\r
1787 UsbCommand c;\r
1788 c.cmd = CMD_LCD_RESET;\r
1789 c.ext1 = atoi(str);\r
1790 SendCommand(&c, FALSE);\r
1791}\r
1792\r
1793static void CmdLcd(char *str)\r
1794{\r
1795 int i, j;\r
1796 UsbCommand c;\r
1797 c.cmd = CMD_LCD;\r
1798 sscanf(str, "%x %d", &i, &j);\r
1799 while (j--) {\r
1800 c.ext1 = i&0x1ff;\r
1801 SendCommand(&c, FALSE);\r
1802 }\r
1803}\r
1804\r
1805static void CmdTest(char *str)\r
1806{\r
1807}\r
1808\r
1809typedef void HandlerFunction(char *cmdline);\r
1810\r
1811static struct {\r
1812 char *name;\r
1813 HandlerFunction *handler;\r
1814 char *docString;\r
1815} CommandTable[] = {\r
1816 "tune", CmdTune, "measure antenna tuning",\r
1817 "tiread", CmdTiread, "read a TI-type 134 kHz tag",\r
1818 "tibits", CmdTibits, "get raw bits for TI-type LF tag",\r
1819 "tidemod", CmdTidemod, "demod raw bits for TI-type LF tag",\r
1820 "vchdemod", CmdVchdemod, "demod samples for VeriChip",\r
1821 "plot", CmdPlot, "show graph window",\r
1822 "hide", CmdHide, "hide graph window",\r
1823 "losim", CmdLosim, "simulate LF tag",\r
1824 "loread", CmdLoread, "read (125/134 kHz) LF ID-only tag",\r
1825 "losamples", CmdLosamples, "get raw samples for LF tag",\r
1826 "hisamples", CmdHisamples, "get raw samples for HF tag",\r
1827 "hisampless", CmdHisampless, "get signed raw samples, HF tag",\r
1828 "hisamplest", CmdHi14readt, "get samples HF, for testing",\r
1829 "higet", CmdHi14read_sim, "get samples HF, 'analog'",\r
1830 "bitsamples", CmdBitsamples, "get raw samples as bitstring",\r
1831 "hexsamples", CmdHexsamples, "dump big buffer as hex bytes",\r
1832 "hi15read", CmdHi15read, "read HF tag (ISO 15693)",\r
1833 "hi15reader", CmdHi15reader, "act like an ISO15693 reader", // new command greg\r
1834 "hi15sim", CmdHi15tag, "fake an ISO15693 tag", // new command greg\r
1835 "hi14read", CmdHi14read, "read HF tag (ISO 14443)",\r
1836 "hi14areader", CmdHi14areader, "act like an ISO14443 Type A reader", // ## New reader command\r
1837 "hi15demod", CmdHi15demod, "demod ISO15693 from tag",\r
1838 "hi14bdemod", CmdHi14bdemod, "demod ISO14443 Type B from tag",\r
1839 "autocorr", CmdAutoCorr, "autocorrelation over window",\r
1840 "norm", CmdNorm, "normalize max/min to +/-500",\r
1841 "dec", CmdDec, "decimate",\r
1842 "hpf", CmdHpf, "remove DC offset from trace",\r
1843 "zerocrossings", CmdZerocrossings, "count time between zero-crossings",\r
1844 "ltrim", CmdLtrim, "trim from left of trace",\r
1845 "scale", CmdScale, "set cursor display scale",\r
1846 "flexdemod", CmdFlexdemod, "demod samples for FlexPass",\r
a60612db 1847 "indalademod", CmdIndalademod, "demod samples for Indala",\r
6658905f 1848 "save", CmdSave, "save trace (from graph window)",\r
1849 "load", CmdLoad, "load trace (to graph window",\r
1850 "hisimlisten", CmdHisimlisten, "get HF samples as fake tag",\r
1851 "hi14sim", CmdHi14sim, "fake ISO 14443 tag",\r
1852 "hi14asim", CmdHi14asim, "fake ISO 14443a tag", // ## Simulate 14443a tag\r
1853 "hi14snoop", CmdHi14snoop, "eavesdrop ISO 14443",\r
1854 "hi14asnoop", CmdHi14asnoop, "eavesdrop ISO 14443 Type A", // ## New snoop command\r
1855 "hi14list", CmdHi14list, "list ISO 14443 history",\r
1856 "hi14alist", CmdHi14alist, "list ISO 14443a history", // ## New list command\r
1857 "hiddemod", CmdHiddemod, "HID Prox Card II (not optimal)",\r
1858 "hidfskdemod", CmdHIDdemodFSK, "HID FSK demodulator",\r
1859 "askdemod", Cmdaskdemod, "Attempt to demodulate simple ASK tags",
1860 "hidsimtag", CmdHIDsimTAG, "HID tag simulator",
1861 "mandemod", Cmdmanchesterdemod, "Try a Manchester demodulation on a binary stream",
1862 "fpgaoff", CmdFPGAOff, "set FPGA off", // ## FPGA Control\r
1863 "lcdreset", CmdLcdReset, "Hardware reset LCD",\r
1864 "lcd", CmdLcd, "Send command/data to LCD",\r
1865 "test", CmdTest, "Placeholder command for testing new code",\r
1866 "quit", CmdQuit, "quit program"\r
1867};\r
1868\r
1869//-----------------------------------------------------------------------------\r
1870// Entry point into our code: called whenever the user types a command and\r
1871// then presses Enter, which the full command line that they typed.\r
1872//-----------------------------------------------------------------------------\r
1873void CommandReceived(char *cmd)\r
1874{\r
1875 int i;\r
1876\r
1877 PrintToScrollback("> %s", cmd);\r
1878\r
1879 if(strcmp(cmd, "help")==0) {\r
1880 PrintToScrollback("\r\nAvailable commands:");\r
1881 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
1882 char line[256];\r
1883 memset(line, ' ', sizeof(line));\r
1884 strcpy(line+2, CommandTable[i].name);\r
1885 line[strlen(line)] = ' ';\r
1886 sprintf(line+15, " -- %s", CommandTable[i].docString);\r
1887 PrintToScrollback("%s", line);\r
1888 }\r
1889 PrintToScrollback("");\r
1890 PrintToScrollback("and also: help, cls");\r
1891 return;\r
1892 }\r
1893\r
1894 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {\r
1895 char *name = CommandTable[i].name;\r
1896 if(memcmp(cmd, name, strlen(name))==0 &&\r
1897 (cmd[strlen(name)] == ' ' || cmd[strlen(name)] == '\0'))\r
1898 {\r
1899 cmd += strlen(name);\r
1900 while(*cmd == ' ') {\r
1901 cmd++;\r
1902 }\r
1903 (CommandTable[i].handler)(cmd);\r
1904 return;\r
1905 }\r
1906 }\r
1907 PrintToScrollback(">> bad command '%s'", cmd);\r
1908}\r
1909\r
1910//-----------------------------------------------------------------------------\r
1911// Entry point into our code: called whenever we received a packet over USB\r
1912// that we weren't necessarily expecting, for example a debug print.\r
1913//-----------------------------------------------------------------------------\r
1914void UsbCommandReceived(UsbCommand *c)\r
1915{\r
1916 switch(c->cmd) {\r
1917 case CMD_DEBUG_PRINT_STRING: {\r
1918 char s[100];\r
1919 if(c->ext1 > 70 || c->ext1 < 0) {\r
1920 c->ext1 = 0;\r
1921 }\r
1922 memcpy(s, c->d.asBytes, c->ext1);\r
1923 s[c->ext1] = '\0';\r
1924 PrintToScrollback("#db# %s", s);\r
1925 break;
1926 }\r
1927\r
1928 case CMD_DEBUG_PRINT_INTEGERS:\r
1929 PrintToScrollback("#db# %08x, %08x, %08x\r\n", c->ext1, c->ext2, c->ext3);\r
1930 break;\r
1931\r
1932 case CMD_MEASURED_ANTENNA_TUNING: {\r
1933 int zLf, zHf;\r
1934 int vLf125, vLf134, vHf;\r
1935 vLf125 = c->ext1 & 0xffff;\r
1936 vLf134 = c->ext1 >> 16;\r
1937 vHf = c->ext2;\r
1938 zLf = c->ext3 & 0xffff;\r
1939 zHf = c->ext3 >> 16;\r
1940 PrintToScrollback("# LF antenna @ %3d mA / %5d mV [%d ohms] 125Khz",\r
1941 vLf125/zLf, vLf125, zLf);\r
1942 PrintToScrollback("# LF antenna @ %3d mA / %5d mV [%d ohms] 134Khz",\r
1943 vLf134/((zLf*125)/134), vLf134, (zLf*125)/134);\r
1944 PrintToScrollback("# HF antenna @ %3d mA / %5d mV [%d ohms] 13.56Mhz",\r
1945 vHf/zHf, vHf, zHf);\r
1946 break;\r
1947 }\r
1948 default:\r
1949 PrintToScrollback("unrecognized command %08x\n", c->cmd);\r
1950 break;\r
1951 }\r
1952}\r
Proxmark3 GIT tracking
Impressum, Datenschutz