]>
Commit | Line | Data |
---|---|---|
a553f267 | 1 | //----------------------------------------------------------------------------- |
2 | // Copyright (C) 2010 iZsh <izsh at fail0verflow.com> | |
3 | // | |
4 | // This code is licensed to you under the terms of the GNU GPL, version 2 or, | |
5 | // at your option, any later version. See the LICENSE.txt file for the text of | |
6 | // the license. | |
7 | //----------------------------------------------------------------------------- | |
8 | // Data and Graph commands | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
6923d3f1 | 11 | #include <stdio.h> // also included in util.h |
12 | #include <string.h> // also included in util.h | |
43534cba | 13 | #include <inttypes.h> |
6923d3f1 | 14 | #include <limits.h> // for CmdNorm INT_MIN && INT_MAX |
15 | #include "data.h" // also included in util.h | |
16 | #include "cmddata.h" | |
d51b2eda | 17 | #include "util.h" |
7fe9b0b7 | 18 | #include "cmdmain.h" |
6923d3f1 | 19 | #include "proxmark3.h" |
20 | #include "ui.h" // for show graph controls | |
21 | #include "graph.h" // for graph data | |
22 | #include "cmdparser.h"// already included in cmdmain.h | |
23 | #include "usb_cmd.h" // already included in cmdmain.h and proxmark3.h | |
24 | #include "lfdemod.h" // for demod code | |
6923d3f1 | 25 | #include "loclass/cipherutils.h" // for decimating samples in getsamples |
35aa230e | 26 | #include "cmdlfem4x.h"// for em410x demod |
31abe49f | 27 | |
4118b74d | 28 | uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN]; |
b362de62 | 29 | uint8_t g_debugMode=0; |
30 | size_t DemodBufferLen=0; | |
b8fdac9e | 31 | int g_DemodStartIdx=0; |
32 | int g_DemodClock=0; | |
127f1490 | 33 | |
7fe9b0b7 | 34 | static int CmdHelp(const char *Cmd); |
35 | ||
4118b74d | 36 | //set the demod buffer with given array of binary (one bit per byte) |
37 | //by marshmellow | |
ec75f5c1 | 38 | void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx) |
4118b74d | 39 | { |
13d77ef9 | 40 | if (buff == NULL) |
41 | return; | |
42 | ||
90e9da25 | 43 | if ( size > MAX_DEMOD_BUF_LEN - startIdx) |
44 | size = MAX_DEMOD_BUF_LEN - startIdx; | |
13d77ef9 | 45 | |
ec75f5c1 | 46 | size_t i = 0; |
8e2e6c8e | 47 | for (; i < size; i++){ |
ec75f5c1 | 48 | DemodBuffer[i]=buff[startIdx++]; |
ba1a299c | 49 | } |
50 | DemodBufferLen=size; | |
51 | return; | |
4118b74d | 52 | } |
53 | ||
b9957414 | 54 | bool getDemodBuf(uint8_t *buff, size_t *size) { |
55 | if (buff == NULL) return false; | |
56 | if (size == NULL) return false; | |
57 | if (*size == 0) return false; | |
58 | ||
59 | *size = (*size > DemodBufferLen) ? DemodBufferLen : *size; | |
60 | ||
61 | memcpy(buff, DemodBuffer, *size); | |
62 | return true; | |
63 | } | |
64 | ||
b97311b1 | 65 | // option '1' to save DemodBuffer any other to restore |
66 | void save_restoreDB(uint8_t saveOpt) | |
67 | { | |
f1004b34 | 68 | static uint8_t SavedDB[MAX_DEMOD_BUF_LEN]; |
b97311b1 | 69 | static size_t SavedDBlen; |
70 | static bool DB_Saved = false; | |
1c70664a | 71 | static int savedDemodStartIdx = 0; |
72 | static int savedDemodClock = 0; | |
b97311b1 | 73 | |
3fd7fce4 | 74 | if (saveOpt == GRAPH_SAVE) { //save |
f1004b34 | 75 | |
b97311b1 | 76 | memcpy(SavedDB, DemodBuffer, sizeof(DemodBuffer)); |
77 | SavedDBlen = DemodBufferLen; | |
78 | DB_Saved=true; | |
1c70664a | 79 | savedDemodStartIdx = g_DemodStartIdx; |
80 | savedDemodClock = g_DemodClock; | |
b9957414 | 81 | } else if (DB_Saved) { //restore |
b97311b1 | 82 | memcpy(DemodBuffer, SavedDB, sizeof(DemodBuffer)); |
83 | DemodBufferLen = SavedDBlen; | |
1c70664a | 84 | g_DemodClock = savedDemodClock; |
85 | g_DemodStartIdx = savedDemodStartIdx; | |
b97311b1 | 86 | } |
87 | return; | |
88 | } | |
89 | ||
ec75f5c1 | 90 | int CmdSetDebugMode(const char *Cmd) |
91 | { | |
e0165dcf | 92 | int demod=0; |
93 | sscanf(Cmd, "%i", &demod); | |
94 | g_debugMode=(uint8_t)demod; | |
95 | return 1; | |
ec75f5c1 | 96 | } |
97 | ||
979bba37 | 98 | int usage_data_printdemodbuf(){ |
ace26dbd | 99 | PrintAndLog("Usage: data printdemodbuffer x o <offset> l <length>"); |
979bba37 | 100 | PrintAndLog("Options: "); |
101 | PrintAndLog(" h This help"); | |
102 | PrintAndLog(" x output in hex (omit for binary output)"); | |
103 | PrintAndLog(" o <offset> enter offset in # of bits"); | |
ace26dbd | 104 | PrintAndLog(" l <length> enter length to print in # of bits or hex characters respectively"); |
979bba37 | 105 | return 0; |
106 | } | |
107 | ||
4118b74d | 108 | //by marshmellow |
abd6112f | 109 | void printDemodBuff(void) |
4118b74d | 110 | { |
ba1a299c | 111 | int bitLen = DemodBufferLen; |
2767fc02 | 112 | if (bitLen<1) { |
ba1a299c | 113 | PrintAndLog("no bits found in demod buffer"); |
114 | return; | |
115 | } | |
116 | if (bitLen>512) bitLen=512; //max output to 512 bits if we have more - should be plenty | |
e0165dcf | 117 | |
2767fc02 | 118 | char *bin = sprint_bin_break(DemodBuffer,bitLen,16); |
119 | PrintAndLog("%s",bin); | |
120 | ||
ba1a299c | 121 | return; |
4118b74d | 122 | } |
123 | ||
8d960002 | 124 | int CmdPrintDemodBuff(const char *Cmd) |
125 | { | |
979bba37 | 126 | char hex[512]={0x00}; |
127 | bool hexMode = false; | |
128 | bool errors = false; | |
ace26dbd | 129 | uint32_t offset = 0; //could be size_t but no param_get16... |
130 | uint32_t length = 512; | |
979bba37 | 131 | char cmdp = 0; |
132 | while(param_getchar(Cmd, cmdp) != 0x00) | |
133 | { | |
134 | switch(param_getchar(Cmd, cmdp)) | |
135 | { | |
136 | case 'h': | |
137 | case 'H': | |
138 | return usage_data_printdemodbuf(); | |
139 | case 'x': | |
140 | case 'X': | |
141 | hexMode = true; | |
142 | cmdp++; | |
143 | break; | |
144 | case 'o': | |
145 | case 'O': | |
ace26dbd | 146 | offset = param_get32ex(Cmd, cmdp+1, 0, 10); |
979bba37 | 147 | if (!offset) errors = true; |
148 | cmdp += 2; | |
149 | break; | |
ace26dbd | 150 | case 'l': |
151 | case 'L': | |
152 | length = param_get32ex(Cmd, cmdp+1, 512, 10); | |
153 | if (!length) errors = true; | |
154 | cmdp += 2; | |
155 | break; | |
979bba37 | 156 | default: |
157 | PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); | |
158 | errors = true; | |
159 | break; | |
160 | } | |
161 | if(errors) break; | |
e0165dcf | 162 | } |
979bba37 | 163 | //Validations |
164 | if(errors) return usage_data_printdemodbuf(); | |
ace26dbd | 165 | length = (length > (DemodBufferLen-offset)) ? DemodBufferLen-offset : length; |
166 | int numBits = (length) & 0x00FFC; //make sure we don't exceed our string | |
979bba37 | 167 | |
168 | if (hexMode){ | |
185e038c | 169 | char *buf = (char *) (DemodBuffer + offset); |
ace26dbd | 170 | numBits = (numBits > sizeof(hex)) ? sizeof(hex) : numBits; |
979bba37 | 171 | numBits = binarraytohex(hex, buf, numBits); |
e0165dcf | 172 | if (numBits==0) return 0; |
979bba37 | 173 | PrintAndLog("DemodBuffer: %s",hex); |
e0165dcf | 174 | } else { |
709665b5 | 175 | PrintAndLog("DemodBuffer:\n%s", sprint_bin_break(DemodBuffer+offset,numBits,16)); |
e0165dcf | 176 | } |
177 | return 1; | |
8d960002 | 178 | } |
7fe9b0b7 | 179 | |
2767fc02 | 180 | //by marshmellow |
78f5b1a7 | 181 | //this function strictly converts >1 to 1 and <1 to 0 for each sample in the graphbuffer |
182 | int CmdGetBitStream(const char *Cmd) | |
183 | { | |
e0165dcf | 184 | int i; |
185 | CmdHpf(Cmd); | |
186 | for (i = 0; i < GraphTraceLen; i++) { | |
187 | if (GraphBuffer[i] >= 1) { | |
188 | GraphBuffer[i] = 1; | |
189 | } else { | |
190 | GraphBuffer[i] = 0; | |
191 | } | |
192 | } | |
193 | RepaintGraphWindow(); | |
194 | return 0; | |
78f5b1a7 | 195 | } |
196 | ||
fef74fdc | 197 | //by marshmellow |
198 | //Cmd Args: Clock, invert, maxErr, maxLen as integers and amplify as char == 'a' | |
199 | // (amp may not be needed anymore) | |
200 | //verbose will print results and demoding messages | |
201 | //emSearch will auto search for EM410x format in bitstream | |
202 | //askType switches decode: ask/raw = 0, ask/manchester = 1 | |
d1869c33 | 203 | int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType, bool *stCheck) { |
e0165dcf | 204 | int invert=0; |
205 | int clk=0; | |
206 | int maxErr=100; | |
fef74fdc | 207 | int maxLen=0; |
01d0f8ae | 208 | uint8_t askamp = 0; |
fef74fdc | 209 | char amp = param_getchar(Cmd, 0); |
e0165dcf | 210 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; |
fef74fdc | 211 | sscanf(Cmd, "%i %i %i %i %c", &clk, &invert, &maxErr, &maxLen, &); |
ace26dbd | 212 | if (!maxLen) maxLen = BIGBUF_SIZE; |
e0165dcf | 213 | if (invert != 0 && invert != 1) { |
214 | PrintAndLog("Invalid argument: %s", Cmd); | |
215 | return 0; | |
216 | } | |
217 | if (clk==1){ | |
218 | invert=1; | |
219 | clk=0; | |
220 | } | |
221 | size_t BitLen = getFromGraphBuf(BitStream); | |
2767fc02 | 222 | if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); |
d1869c33 | 223 | if (BitLen < 255) return 0; |
224 | if (maxLen < BitLen && maxLen != 0) BitLen = maxLen; | |
225 | int foundclk = 0; | |
01d0f8ae | 226 | //amp before ST check |
227 | if (amp == 'a' || amp == 'A') { | |
228 | askAmp(BitStream, BitLen); | |
229 | } | |
d1869c33 | 230 | bool st = false; |
ab812dfa | 231 | size_t ststart = 0, stend = 0; |
0f321d63 | 232 | if (*stCheck) st = DetectST(BitStream, &BitLen, &foundclk, &ststart, &stend); |
b9957414 | 233 | *stCheck = st; |
d1869c33 | 234 | if (st) { |
d1869c33 | 235 | clk = (clk == 0) ? foundclk : clk; |
ab812dfa | 236 | CursorCPos = ststart; |
237 | CursorDPos = stend; | |
f75b313b | 238 | if (verbose || g_debugMode) PrintAndLog("\nFound Sequence Terminator - First one is shown by orange and blue graph markers"); |
b97311b1 | 239 | //Graph ST trim (for testing) |
240 | //for (int i = 0; i < BitLen; i++) { | |
241 | // GraphBuffer[i] = BitStream[i]-128; | |
242 | //} | |
243 | //RepaintGraphWindow(); | |
d1869c33 | 244 | } |
0f321d63 | 245 | int startIdx = 0; |
246 | int errCnt = askdemod_ext(BitStream, &BitLen, &clk, &invert, maxErr, askamp, askType, &startIdx); | |
fef74fdc | 247 | if (errCnt<0 || BitLen<16){ //if fatal error (or -1) |
2767fc02 | 248 | if (g_debugMode) PrintAndLog("DEBUG: no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); |
e0165dcf | 249 | return 0; |
250 | } | |
d1869c33 | 251 | if (errCnt > maxErr){ |
2767fc02 | 252 | if (g_debugMode) PrintAndLog("DEBUG: Too many errors found, errors:%d, bits:%d, clock:%d",errCnt, BitLen, clk); |
253 | return 0; | |
254 | } | |
255 | if (verbose || g_debugMode) PrintAndLog("\nUsing Clock:%d, Invert:%d, Bits Found:%d",clk,invert,BitLen); | |
e0165dcf | 256 | //output |
e0165dcf | 257 | setDemodBuf(BitStream,BitLen,0); |
0f321d63 | 258 | setClockGrid(clk, startIdx); |
259 | ||
fef74fdc | 260 | if (verbose || g_debugMode){ |
261 | if (errCnt>0) PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d",errCnt); | |
8e2e6c8e | 262 | if (askType) PrintAndLog("ASK/Manchester - Clock: %d - Decoded bitstream:",clk); |
263 | else PrintAndLog("ASK/Raw - Clock: %d - Decoded bitstream:",clk); | |
fef74fdc | 264 | // Now output the bitstream to the scrollback by line of 16 bits |
265 | printDemodBuff(); | |
266 | ||
267 | } | |
268 | uint64_t lo = 0; | |
269 | uint32_t hi = 0; | |
e0165dcf | 270 | if (emSearch){ |
fef74fdc | 271 | AskEm410xDecode(true, &hi, &lo); |
e0165dcf | 272 | } |
273 | return 1; | |
eb191de6 | 274 | } |
d1869c33 | 275 | int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType) { |
276 | bool st = false; | |
277 | return ASKDemod_ext(Cmd, verbose, emSearch, askType, &st); | |
278 | } | |
eb191de6 | 279 | |
4ac906d1 | 280 | //by marshmellow |
fef74fdc | 281 | //takes 5 arguments - clock, invert, maxErr, maxLen as integers and amplify as char == 'a' |
4ac906d1 | 282 | //attempts to demodulate ask while decoding manchester |
283 | //prints binary found and saves in graphbuffer for further commands | |
284 | int Cmdaskmandemod(const char *Cmd) | |
285 | { | |
e0165dcf | 286 | char cmdp = param_getchar(Cmd, 0); |
01d0f8ae | 287 | if (strlen(Cmd) > 45 || cmdp == 'h' || cmdp == 'H') { |
d1869c33 | 288 | PrintAndLog("Usage: data rawdemod am <s> [clock] <invert> [maxError] [maxLen] [amplify]"); |
289 | PrintAndLog(" ['s'] optional, check for Sequence Terminator"); | |
fef74fdc | 290 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect"); |
291 | PrintAndLog(" <invert>, 1 to invert output"); | |
292 | PrintAndLog(" [set maximum allowed errors], default = 100"); | |
293 | PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)"); | |
294 | PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp"); | |
e0165dcf | 295 | PrintAndLog(""); |
296 | PrintAndLog(" sample: data rawdemod am = demod an ask/manchester tag from GraphBuffer"); | |
297 | PrintAndLog(" : data rawdemod am 32 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32"); | |
298 | PrintAndLog(" : data rawdemod am 32 1 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32 and inverting data"); | |
299 | PrintAndLog(" : data rawdemod am 1 = demod an ask/manchester tag from GraphBuffer while inverting data"); | |
300 | PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); | |
301 | return 0; | |
302 | } | |
7cb8516c | 303 | bool st = true; |
d1869c33 | 304 | if (Cmd[0]=='s') |
b8fdac9e | 305 | return ASKDemod_ext(Cmd++, true, false, 1, &st); |
d1869c33 | 306 | else if (Cmd[1] == 's') |
b8fdac9e | 307 | return ASKDemod_ext(Cmd+=2, true, false, 1, &st); |
d1869c33 | 308 | else |
b8fdac9e | 309 | return ASKDemod(Cmd, true, false, 1); |
4ac906d1 | 310 | } |
311 | ||
eb191de6 | 312 | //by marshmellow |
d5a72d2f | 313 | //manchester decode |
eb191de6 | 314 | //stricktly take 10 and 01 and convert to 0 and 1 |
315 | int Cmdmandecoderaw(const char *Cmd) | |
316 | { | |
e0165dcf | 317 | int i =0; |
318 | int errCnt=0; | |
319 | size_t size=0; | |
fef74fdc | 320 | int invert=0; |
6ac4cb27 | 321 | int maxErr = 20; |
e0165dcf | 322 | char cmdp = param_getchar(Cmd, 0); |
1f918317 | 323 | if (strlen(Cmd) > 5 || cmdp == 'h' || cmdp == 'H') { |
fef74fdc | 324 | PrintAndLog("Usage: data manrawdecode [invert] [maxErr]"); |
e0165dcf | 325 | PrintAndLog(" Takes 10 and 01 and converts to 0 and 1 respectively"); |
326 | PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)"); | |
fef74fdc | 327 | PrintAndLog(" [invert] invert output"); |
1f918317 | 328 | PrintAndLog(" [maxErr] set number of errors allowed (default = 20)"); |
e0165dcf | 329 | PrintAndLog(""); |
330 | PrintAndLog(" sample: data manrawdecode = decode manchester bitstream from the demodbuffer"); | |
331 | return 0; | |
332 | } | |
333 | if (DemodBufferLen==0) return 0; | |
f1004b34 | 334 | uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0}; |
e0165dcf | 335 | int high=0,low=0; |
336 | for (;i<DemodBufferLen;++i){ | |
337 | if (DemodBuffer[i]>high) high=DemodBuffer[i]; | |
338 | else if(DemodBuffer[i]<low) low=DemodBuffer[i]; | |
339 | BitStream[i]=DemodBuffer[i]; | |
340 | } | |
1f918317 | 341 | if (high>7 || low <0 ){ |
2767fc02 | 342 | PrintAndLog("Error: please raw demod the wave first then manchester raw decode"); |
e0165dcf | 343 | return 0; |
344 | } | |
1f918317 | 345 | |
fef74fdc | 346 | sscanf(Cmd, "%i %i", &invert, &maxErr); |
e0165dcf | 347 | size=i; |
127f1490 | 348 | uint8_t alignPos = 0; |
349 | errCnt=manrawdecode(BitStream, &size, invert, &alignPos); | |
e0165dcf | 350 | if (errCnt>=maxErr){ |
351 | PrintAndLog("Too many errors: %d",errCnt); | |
352 | return 0; | |
353 | } | |
354 | PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt); | |
2767fc02 | 355 | PrintAndLog("%s", sprint_bin_break(BitStream, size, 16)); |
e0165dcf | 356 | if (errCnt==0){ |
357 | uint64_t id = 0; | |
358 | uint32_t hi = 0; | |
359 | size_t idx=0; | |
360 | if (Em410xDecode(BitStream, &size, &idx, &hi, &id)){ | |
361 | //need to adjust to set bitstream back to manchester encoded data | |
362 | //setDemodBuf(BitStream, size, idx); | |
363 | ||
364 | printEM410x(hi, id); | |
365 | } | |
366 | } | |
367 | return 1; | |
d5a72d2f | 368 | } |
369 | ||
370 | //by marshmellow | |
371 | //biphase decode | |
372 | //take 01 or 10 = 0 and 11 or 00 = 1 | |
1e090a61 | 373 | //takes 2 arguments "offset" default = 0 if 1 it will shift the decode by one bit |
374 | // and "invert" default = 0 if 1 it will invert output | |
2767fc02 | 375 | // the argument offset allows us to manually shift if the output is incorrect - [EDIT: now auto detects] |
d5a72d2f | 376 | int CmdBiphaseDecodeRaw(const char *Cmd) |
377 | { | |
ba1a299c | 378 | size_t size=0; |
b41534d1 | 379 | int offset=0, invert=0, maxErr=20, errCnt=0; |
b4fb11ba | 380 | char cmdp = param_getchar(Cmd, 0); |
381 | if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') { | |
b41534d1 | 382 | PrintAndLog("Usage: data biphaserawdecode [offset] [invert] [maxErr]"); |
383 | PrintAndLog(" Converts 10 or 01 to 1 and 11 or 00 to 0"); | |
b4fb11ba | 384 | PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)"); |
e0165dcf | 385 | PrintAndLog(" --invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester"); |
b4fb11ba | 386 | PrintAndLog(""); |
387 | PrintAndLog(" [offset <0|1>], set to 0 not to adjust start position or to 1 to adjust decode start position"); | |
388 | PrintAndLog(" [invert <0|1>], set to 1 to invert output"); | |
b41534d1 | 389 | PrintAndLog(" [maxErr int], set max errors tolerated - default=20"); |
b4fb11ba | 390 | PrintAndLog(""); |
391 | PrintAndLog(" sample: data biphaserawdecode = decode biphase bitstream from the demodbuffer"); | |
392 | PrintAndLog(" sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output"); | |
393 | return 0; | |
394 | } | |
b41534d1 | 395 | sscanf(Cmd, "%i %i %i", &offset, &invert, &maxErr); |
b9957414 | 396 | if (DemodBufferLen==0) { |
b41534d1 | 397 | PrintAndLog("DemodBuffer Empty - run 'data rawdemod ar' first"); |
b4fb11ba | 398 | return 0; |
399 | } | |
f1004b34 | 400 | uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0}; |
b9957414 | 401 | size = sizeof(BitStream); |
402 | if ( !getDemodBuf(BitStream, &size) ) return 0; | |
9fe4507c | 403 | errCnt=BiphaseRawDecode(BitStream, &size, &offset, invert); |
b41534d1 | 404 | if (errCnt<0){ |
405 | PrintAndLog("Error during decode:%d", errCnt); | |
406 | return 0; | |
407 | } | |
408 | if (errCnt>maxErr){ | |
b4fb11ba | 409 | PrintAndLog("Too many errors attempting to decode: %d",errCnt); |
410 | return 0; | |
411 | } | |
b41534d1 | 412 | |
413 | if (errCnt>0){ | |
2767fc02 | 414 | PrintAndLog("# Errors found during Demod (shown as 7 in bit stream): %d",errCnt); |
b41534d1 | 415 | } |
9fe4507c | 416 | |
b41534d1 | 417 | PrintAndLog("Biphase Decoded using offset: %d - # invert:%d - data:",offset,invert); |
2767fc02 | 418 | PrintAndLog("%s", sprint_bin_break(BitStream, size, 16)); |
b41534d1 | 419 | |
420 | if (offset) setDemodBuf(DemodBuffer,DemodBufferLen-offset, offset); //remove first bit from raw demod | |
9fe4507c | 421 | setClockGrid(g_DemodClock, g_DemodStartIdx + g_DemodClock*offset/2); |
b4fb11ba | 422 | return 1; |
eb191de6 | 423 | } |
424 | ||
b41534d1 | 425 | //by marshmellow |
426 | // - ASK Demod then Biphase decode GraphBuffer samples | |
427 | int ASKbiphaseDemod(const char *Cmd, bool verbose) | |
428 | { | |
429 | //ask raw demod GraphBuffer first | |
c7d67212 | 430 | int offset=0, clk=0, invert=0, maxErr=0; |
431 | sscanf(Cmd, "%i %i %i %i", &offset, &clk, &invert, &maxErr); | |
b41534d1 | 432 | |
f1004b34 | 433 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]; |
9fe4507c | 434 | size_t size = getFromGraphBuf(BitStream); |
435 | int startIdx = 0; | |
fd227f4e | 436 | //invert here inverts the ask raw demoded bits which has no effect on the demod, but we need the pointer |
9fe4507c | 437 | int errCnt = askdemod_ext(BitStream, &size, &clk, &invert, maxErr, 0, 0, &startIdx); |
8e2e6c8e | 438 | if ( errCnt < 0 || errCnt > maxErr ) { |
439 | if (g_debugMode) PrintAndLog("DEBUG: no data or error found %d, clock: %d", errCnt, clk); | |
440 | return 0; | |
9fe4507c | 441 | } |
8e2e6c8e | 442 | |
443 | //attempt to Biphase decode BitStream | |
9fe4507c | 444 | errCnt = BiphaseRawDecode(BitStream, &size, &offset, invert); |
b41534d1 | 445 | if (errCnt < 0){ |
446 | if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode: %d", errCnt); | |
447 | return 0; | |
9fe4507c | 448 | } |
b41534d1 | 449 | if (errCnt > maxErr) { |
450 | if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode too many errors: %d", errCnt); | |
451 | return 0; | |
452 | } | |
453 | //success set DemodBuffer and return | |
454 | setDemodBuf(BitStream, size, 0); | |
9fe4507c | 455 | setClockGrid(clk, startIdx + clk*offset/2); |
b41534d1 | 456 | if (g_debugMode || verbose){ |
8e2e6c8e | 457 | PrintAndLog("Biphase Decoded using offset: %d - clock: %d - # errors:%d - data:",offset,clk,errCnt); |
b41534d1 | 458 | printDemodBuff(); |
459 | } | |
460 | return 1; | |
461 | } | |
462 | //by marshmellow - see ASKbiphaseDemod | |
463 | int Cmdaskbiphdemod(const char *Cmd) | |
464 | { | |
e0165dcf | 465 | char cmdp = param_getchar(Cmd, 0); |
fef74fdc | 466 | if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') { |
467 | PrintAndLog("Usage: data rawdemod ab [offset] [clock] <invert> [maxError] [maxLen] <amplify>"); | |
e0165dcf | 468 | PrintAndLog(" [offset], offset to begin biphase, default=0"); |
469 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect"); | |
470 | PrintAndLog(" <invert>, 1 to invert output"); | |
471 | PrintAndLog(" [set maximum allowed errors], default = 100"); | |
fef74fdc | 472 | PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)"); |
e0165dcf | 473 | PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp"); |
474 | PrintAndLog(" NOTE: <invert> can be entered as second or third argument"); | |
475 | PrintAndLog(" NOTE: <amplify> can be entered as first, second or last argument"); | |
476 | PrintAndLog(" NOTE: any other arg must have previous args set to work"); | |
477 | PrintAndLog(""); | |
478 | PrintAndLog(" NOTE: --invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester"); | |
479 | PrintAndLog(""); | |
fef74fdc | 480 | PrintAndLog(" sample: data rawdemod ab = demod an ask/biph tag from GraphBuffer"); |
481 | PrintAndLog(" : data rawdemod ab 0 a = demod an ask/biph tag from GraphBuffer, amplified"); | |
482 | PrintAndLog(" : data rawdemod ab 1 32 = demod an ask/biph tag from GraphBuffer using an offset of 1 and a clock of RF/32"); | |
483 | PrintAndLog(" : data rawdemod ab 0 32 1 = demod an ask/biph tag from GraphBuffer using a clock of RF/32 and inverting data"); | |
484 | PrintAndLog(" : data rawdemod ab 0 1 = demod an ask/biph tag from GraphBuffer while inverting data"); | |
485 | PrintAndLog(" : data rawdemod ab 0 64 1 0 = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); | |
486 | PrintAndLog(" : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); | |
e0165dcf | 487 | return 0; |
488 | } | |
7cb8516c | 489 | return ASKbiphaseDemod(Cmd, true); |
b41534d1 | 490 | } |
491 | ||
fef74fdc | 492 | //by marshmellow - see ASKDemod |
4ac906d1 | 493 | int Cmdaskrawdemod(const char *Cmd) |
494 | { | |
e0165dcf | 495 | char cmdp = param_getchar(Cmd, 0); |
01d0f8ae | 496 | if (strlen(Cmd) > 35 || cmdp == 'h' || cmdp == 'H') { |
fef74fdc | 497 | PrintAndLog("Usage: data rawdemod ar [clock] <invert> [maxError] [maxLen] [amplify]"); |
e0165dcf | 498 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect"); |
499 | PrintAndLog(" <invert>, 1 to invert output"); | |
500 | PrintAndLog(" [set maximum allowed errors], default = 100"); | |
fef74fdc | 501 | PrintAndLog(" [set maximum Samples to read], default = 32768 (1024 bits at rf/64)"); |
e0165dcf | 502 | PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp"); |
503 | PrintAndLog(""); | |
fef74fdc | 504 | PrintAndLog(" sample: data rawdemod ar = demod an ask tag from GraphBuffer"); |
505 | PrintAndLog(" : data rawdemod ar a = demod an ask tag from GraphBuffer, amplified"); | |
506 | PrintAndLog(" : data rawdemod ar 32 = demod an ask tag from GraphBuffer using a clock of RF/32"); | |
507 | PrintAndLog(" : data rawdemod ar 32 1 = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data"); | |
508 | PrintAndLog(" : data rawdemod ar 1 = demod an ask tag from GraphBuffer while inverting data"); | |
509 | PrintAndLog(" : data rawdemod ar 64 1 0 = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); | |
510 | PrintAndLog(" : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); | |
e0165dcf | 511 | return 0; |
512 | } | |
7cb8516c | 513 | return ASKDemod(Cmd, true, false, 0); |
4ac906d1 | 514 | } |
515 | ||
c4f51073 | 516 | int AutoCorrelate(const int *in, int *out, size_t len, int window, bool SaveGrph, bool verbose) |
7fe9b0b7 | 517 | { |
e0165dcf | 518 | static int CorrelBuffer[MAX_GRAPH_TRACE_LEN]; |
519 | size_t Correlation = 0; | |
520 | int maxSum = 0; | |
521 | int lastMax = 0; | |
522 | if (verbose) PrintAndLog("performing %d correlations", GraphTraceLen - window); | |
c4f51073 | 523 | for (int i = 0; i < len - window; ++i) { |
e0165dcf | 524 | int sum = 0; |
525 | for (int j = 0; j < window; ++j) { | |
c4f51073 | 526 | sum += (in[j]*in[i + j]) / 256; |
e0165dcf | 527 | } |
528 | CorrelBuffer[i] = sum; | |
c4f51073 | 529 | if (sum >= maxSum-100 && sum <= maxSum+100) { |
e0165dcf | 530 | //another max |
531 | Correlation = i-lastMax; | |
532 | lastMax = i; | |
533 | if (sum > maxSum) maxSum = sum; | |
c4f51073 | 534 | } else if (sum > maxSum) { |
e0165dcf | 535 | maxSum=sum; |
536 | lastMax = i; | |
537 | } | |
538 | } | |
c4f51073 | 539 | if (Correlation==0) { |
e0165dcf | 540 | //try again with wider margin |
c4f51073 | 541 | for (int i = 0; i < len - window; i++) { |
542 | if (CorrelBuffer[i] >= maxSum-(maxSum*0.05) && CorrelBuffer[i] <= maxSum+(maxSum*0.05)) { | |
e0165dcf | 543 | //another max |
544 | Correlation = i-lastMax; | |
545 | lastMax = i; | |
e0165dcf | 546 | } |
547 | } | |
548 | } | |
549 | if (verbose && Correlation > 0) PrintAndLog("Possible Correlation: %d samples",Correlation); | |
550 | ||
c4f51073 | 551 | if (SaveGrph) { |
552 | //GraphTraceLen = GraphTraceLen - window; | |
553 | memcpy(out, CorrelBuffer, len * sizeof(int)); | |
e0165dcf | 554 | RepaintGraphWindow(); |
555 | } | |
556 | return Correlation; | |
73d04bb4 | 557 | } |
7fe9b0b7 | 558 | |
9f7bbd24 | 559 | int usage_data_autocorr(void) |
560 | { | |
e0165dcf | 561 | //print help |
562 | PrintAndLog("Usage: data autocorr [window] [g]"); | |
563 | PrintAndLog("Options: "); | |
564 | PrintAndLog(" h This help"); | |
565 | PrintAndLog(" [window] window length for correlation - default = 4000"); | |
566 | PrintAndLog(" g save back to GraphBuffer (overwrite)"); | |
567 | return 0; | |
9f7bbd24 | 568 | } |
569 | ||
73d04bb4 | 570 | int CmdAutoCorr(const char *Cmd) |
571 | { | |
e0165dcf | 572 | char cmdp = param_getchar(Cmd, 0); |
573 | if (cmdp == 'h' || cmdp == 'H') | |
574 | return usage_data_autocorr(); | |
575 | int window = 4000; //set default | |
576 | char grph=0; | |
7cb8516c | 577 | bool updateGrph = false; |
e0165dcf | 578 | sscanf(Cmd, "%i %c", &window, &grph); |
579 | ||
580 | if (window >= GraphTraceLen) { | |
581 | PrintAndLog("window must be smaller than trace (%d samples)", | |
582 | GraphTraceLen); | |
583 | return 0; | |
584 | } | |
7cb8516c | 585 | if (grph == 'g') updateGrph=true; |
c4f51073 | 586 | return AutoCorrelate(GraphBuffer, GraphBuffer, GraphTraceLen, window, updateGrph, true); |
7fe9b0b7 | 587 | } |
588 | ||
589 | int CmdBitsamples(const char *Cmd) | |
590 | { | |
e0165dcf | 591 | int cnt = 0; |
592 | uint8_t got[12288]; | |
952a8bb5 | 593 | |
e0165dcf | 594 | GetFromBigBuf(got,sizeof(got),0); |
595 | WaitForResponse(CMD_ACK,NULL); | |
7fe9b0b7 | 596 | |
e0165dcf | 597 | for (int j = 0; j < sizeof(got); j++) { |
598 | for (int k = 0; k < 8; k++) { | |
599 | if(got[j] & (1 << (7 - k))) { | |
600 | GraphBuffer[cnt++] = 1; | |
601 | } else { | |
602 | GraphBuffer[cnt++] = 0; | |
603 | } | |
604 | } | |
605 | } | |
606 | GraphTraceLen = cnt; | |
607 | RepaintGraphWindow(); | |
608 | return 0; | |
7fe9b0b7 | 609 | } |
610 | ||
7fe9b0b7 | 611 | int CmdBuffClear(const char *Cmd) |
612 | { | |
e0165dcf | 613 | UsbCommand c = {CMD_BUFF_CLEAR}; |
614 | SendCommand(&c); | |
615 | ClearGraph(true); | |
616 | return 0; | |
7fe9b0b7 | 617 | } |
618 | ||
619 | int CmdDec(const char *Cmd) | |
620 | { | |
e0165dcf | 621 | for (int i = 0; i < (GraphTraceLen / 2); ++i) |
622 | GraphBuffer[i] = GraphBuffer[i * 2]; | |
623 | GraphTraceLen /= 2; | |
624 | PrintAndLog("decimated by 2"); | |
625 | RepaintGraphWindow(); | |
626 | return 0; | |
7fe9b0b7 | 627 | } |
698b649e MHS |
628 | /** |
629 | * Undecimate - I'd call it 'interpolate', but we'll save that | |
630 | * name until someone does an actual interpolation command, not just | |
631 | * blindly repeating samples | |
632 | * @param Cmd | |
633 | * @return | |
634 | */ | |
635 | int CmdUndec(const char *Cmd) | |
636 | { | |
c856ceae MHS |
637 | if(param_getchar(Cmd, 0) == 'h') |
638 | { | |
639 | PrintAndLog("Usage: data undec [factor]"); | |
640 | PrintAndLog("This function performs un-decimation, by repeating each sample N times"); | |
641 | PrintAndLog("Options: "); | |
642 | PrintAndLog(" h This help"); | |
643 | PrintAndLog(" factor The number of times to repeat each sample.[default:2]"); | |
644 | PrintAndLog("Example: 'data undec 3'"); | |
645 | return 0; | |
646 | } | |
647 | ||
648 | uint8_t factor = param_get8ex(Cmd, 0,2, 10); | |
698b649e MHS |
649 | //We have memory, don't we? |
650 | int swap[MAX_GRAPH_TRACE_LEN] = { 0 }; | |
72c5877a | 651 | uint32_t g_index = 0, s_index = 0; |
652 | while(g_index < GraphTraceLen && s_index + factor < MAX_GRAPH_TRACE_LEN) | |
698b649e | 653 | { |
c856ceae | 654 | int count = 0; |
72c5877a | 655 | for(count = 0; count < factor && s_index + count < MAX_GRAPH_TRACE_LEN; count++) |
c856ceae | 656 | swap[s_index+count] = GraphBuffer[g_index]; |
72c5877a | 657 | |
658 | s_index += count; | |
659 | g_index++; | |
698b649e | 660 | } |
698b649e | 661 | |
72c5877a | 662 | memcpy(GraphBuffer, swap, s_index * sizeof(int)); |
c856ceae MHS |
663 | GraphTraceLen = s_index; |
664 | RepaintGraphWindow(); | |
698b649e MHS |
665 | return 0; |
666 | } | |
7fe9b0b7 | 667 | |
ec75f5c1 | 668 | //by marshmellow |
669 | //shift graph zero up or down based on input + or - | |
670 | int CmdGraphShiftZero(const char *Cmd) | |
671 | { | |
672 | ||
e0165dcf | 673 | int shift=0; |
674 | //set options from parameters entered with the command | |
675 | sscanf(Cmd, "%i", &shift); | |
676 | int shiftedVal=0; | |
677 | for(int i = 0; i<GraphTraceLen; i++){ | |
678 | shiftedVal=GraphBuffer[i]+shift; | |
679 | if (shiftedVal>127) | |
680 | shiftedVal=127; | |
681 | else if (shiftedVal<-127) | |
682 | shiftedVal=-127; | |
683 | GraphBuffer[i]= shiftedVal; | |
684 | } | |
685 | CmdNorm(""); | |
686 | return 0; | |
ec75f5c1 | 687 | } |
688 | ||
c4f51073 | 689 | int AskEdgeDetect(const int *in, int *out, int len, int threshold) { |
690 | int Last = 0; | |
691 | for(int i = 1; i<len; i++) { | |
692 | if (in[i]-in[i-1] >= threshold) //large jump up | |
693 | Last = 127; | |
694 | else if(in[i]-in[i-1] <= -1 * threshold) //large jump down | |
695 | Last = -127; | |
696 | out[i-1] = Last; | |
697 | } | |
698 | return 0; | |
699 | } | |
700 | ||
6de43508 | 701 | //by marshmellow |
702 | //use large jumps in read samples to identify edges of waves and then amplify that wave to max | |
2767fc02 | 703 | //similar to dirtheshold, threshold commands |
6de43508 | 704 | //takes a threshold length which is the measured length between two samples then determines an edge |
705 | int CmdAskEdgeDetect(const char *Cmd) | |
706 | { | |
e0165dcf | 707 | int thresLen = 25; |
c4f51073 | 708 | int ans = 0; |
e0165dcf | 709 | sscanf(Cmd, "%i", &thresLen); |
49bbc60a | 710 | |
c4f51073 | 711 | ans = AskEdgeDetect(GraphBuffer, GraphBuffer, GraphTraceLen, thresLen); |
e0165dcf | 712 | RepaintGraphWindow(); |
c4f51073 | 713 | return ans; |
6de43508 | 714 | } |
715 | ||
7fe9b0b7 | 716 | /* Print our clock rate */ |
ba1a299c | 717 | // uses data from graphbuffer |
f3bf15e4 | 718 | // adjusted to take char parameter for type of modulation to find the clock - by marshmellow. |
7fe9b0b7 | 719 | int CmdDetectClockRate(const char *Cmd) |
720 | { | |
f3bf15e4 | 721 | char cmdp = param_getchar(Cmd, 0); |
fef74fdc | 722 | if (strlen(Cmd) > 6 || strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') { |
723 | PrintAndLog("Usage: data detectclock [modulation] <clock>"); | |
f3bf15e4 | 724 | PrintAndLog(" [modulation as char], specify the modulation type you want to detect the clock of"); |
fef74fdc | 725 | PrintAndLog(" <clock> , specify the clock (optional - to get best start position only)"); |
f3bf15e4 | 726 | PrintAndLog(" 'a' = ask, 'f' = fsk, 'n' = nrz/direct, 'p' = psk"); |
727 | PrintAndLog(""); | |
728 | PrintAndLog(" sample: data detectclock a = detect the clock of an ask modulated wave in the GraphBuffer"); | |
729 | PrintAndLog(" data detectclock f = detect the clock of an fsk modulated wave in the GraphBuffer"); | |
730 | PrintAndLog(" data detectclock p = detect the clock of an psk modulated wave in the GraphBuffer"); | |
731 | PrintAndLog(" data detectclock n = detect the clock of an nrz/direct modulated wave in the GraphBuffer"); | |
732 | } | |
733 | int ans=0; | |
734 | if (cmdp == 'a'){ | |
fef74fdc | 735 | ans = GetAskClock(Cmd+1, true, false); |
f3bf15e4 | 736 | } else if (cmdp == 'f'){ |
737 | ans = GetFskClock("", true, false); | |
738 | } else if (cmdp == 'n'){ | |
739 | ans = GetNrzClock("", true, false); | |
740 | } else if (cmdp == 'p'){ | |
741 | ans = GetPskClock("", true, false); | |
742 | } else { | |
743 | PrintAndLog ("Please specify a valid modulation to detect the clock of - see option h for help"); | |
744 | } | |
745 | return ans; | |
7fe9b0b7 | 746 | } |
66707a3b | 747 | |
2767fc02 | 748 | char *GetFSKType(uint8_t fchigh, uint8_t fclow, uint8_t invert) |
749 | { | |
0c50084a | 750 | static char fType[8]; |
9e4cee22 | 751 | memset(fType, 0x00, 8); |
0c50084a | 752 | char *fskType = fType; |
2767fc02 | 753 | if (fchigh==10 && fclow==8){ |
754 | if (invert) //fsk2a | |
38b35095 | 755 | memcpy(fskType, "FSK2a", 5); |
2767fc02 | 756 | else //fsk2 |
38b35095 | 757 | memcpy(fskType, "FSK2", 4); |
2767fc02 | 758 | } else if (fchigh == 8 && fclow == 5) { |
759 | if (invert) | |
38b35095 | 760 | memcpy(fskType, "FSK1", 4); |
2767fc02 | 761 | else |
38b35095 | 762 | memcpy(fskType, "FSK1a", 5); |
2767fc02 | 763 | } else { |
38b35095 | 764 | memcpy(fskType, "FSK??", 5); |
2767fc02 | 765 | } |
766 | return fskType; | |
767 | } | |
768 | ||
2fc2150e | 769 | //by marshmellow |
eb191de6 | 770 | //fsk raw demod and print binary |
6de43508 | 771 | //takes 4 arguments - Clock, invert, fchigh, fclow |
772 | //defaults: clock = 50, invert=1, fchigh=10, fclow=8 (RF/10 RF/8 (fsk2a)) | |
4ac906d1 | 773 | int FSKrawDemod(const char *Cmd, bool verbose) |
b3b70669 | 774 | { |
e0165dcf | 775 | //raw fsk demod no manchester decoding no start bit finding just get binary from wave |
506672c4 | 776 | uint8_t rfLen, invert, fchigh, fclow; |
506672c4 | 777 | //set defaults |
e0165dcf | 778 | //set options from parameters entered with the command |
6ca1477c | 779 | rfLen = param_get8(Cmd, 0); |
780 | invert = param_get8(Cmd, 1); | |
781 | fchigh = param_get8(Cmd, 2); | |
782 | fclow = param_get8(Cmd, 3); | |
d1869c33 | 783 | |
e0165dcf | 784 | if (strlen(Cmd)>0 && strlen(Cmd)<=2) { |
a0cc89b4 | 785 | if (rfLen==1) { |
2eec55c8 | 786 | invert = 1; //if invert option only is used |
e0165dcf | 787 | rfLen = 0; |
a0cc89b4 | 788 | } |
e0165dcf | 789 | } |
e0165dcf | 790 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; |
791 | size_t BitLen = getFromGraphBuf(BitStream); | |
792 | if (BitLen==0) return 0; | |
793 | //get field clock lengths | |
a0cc89b4 | 794 | uint16_t fcs=0; |
506672c4 | 795 | if (!fchigh || !fclow) { |
a0cc89b4 | 796 | fcs = countFC(BitStream, BitLen, 1); |
797 | if (!fcs) { | |
798 | fchigh = 10; | |
799 | fclow = 8; | |
800 | } else { | |
801 | fchigh = (fcs >> 8) & 0x00FF; | |
802 | fclow = fcs & 0x00FF; | |
e0165dcf | 803 | } |
804 | } | |
805 | //get bit clock length | |
a0cc89b4 | 806 | if (!rfLen) { |
0f321d63 | 807 | int firstClockEdge = 0; //todo - align grid on graph with this... |
808 | rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow, &firstClockEdge); | |
506672c4 | 809 | if (!rfLen) rfLen = 50; |
e0165dcf | 810 | } |
0f321d63 | 811 | int startIdx = 0; |
1c70664a | 812 | int size = fskdemod(BitStream, BitLen, rfLen, invert, fchigh, fclow, &startIdx); |
a0cc89b4 | 813 | if (size > 0) { |
e0165dcf | 814 | setDemodBuf(BitStream,size,0); |
0f321d63 | 815 | setClockGrid(rfLen, startIdx); |
e0165dcf | 816 | |
c4809fd4 | 817 | // Now output the bitstream to the scrollback by line of 16 bits |
2767fc02 | 818 | if (verbose || g_debugMode) { |
a0cc89b4 | 819 | PrintAndLog("\nUsing Clock:%u, invert:%u, fchigh:%u, fclow:%u", (unsigned int)rfLen, (unsigned int)invert, (unsigned int)fchigh, (unsigned int)fclow); |
2767fc02 | 820 | PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert)); |
821 | printDemodBuff(); | |
e0165dcf | 822 | } |
d1869c33 | 823 | |
e0165dcf | 824 | return 1; |
506672c4 | 825 | } else { |
2767fc02 | 826 | if (g_debugMode) PrintAndLog("no FSK data found"); |
e0165dcf | 827 | } |
828 | return 0; | |
b3b70669 | 829 | } |
830 | ||
4ac906d1 | 831 | //by marshmellow |
832 | //fsk raw demod and print binary | |
833 | //takes 4 arguments - Clock, invert, fchigh, fclow | |
834 | //defaults: clock = 50, invert=1, fchigh=10, fclow=8 (RF/10 RF/8 (fsk2a)) | |
835 | int CmdFSKrawdemod(const char *Cmd) | |
836 | { | |
e0165dcf | 837 | char cmdp = param_getchar(Cmd, 0); |
01d0f8ae | 838 | if (strlen(Cmd) > 20 || cmdp == 'h' || cmdp == 'H') { |
e0165dcf | 839 | PrintAndLog("Usage: data rawdemod fs [clock] <invert> [fchigh] [fclow]"); |
840 | PrintAndLog(" [set clock as integer] optional, omit for autodetect."); | |
841 | PrintAndLog(" <invert>, 1 for invert output, can be used even if the clock is omitted"); | |
842 | PrintAndLog(" [fchigh], larger field clock length, omit for autodetect"); | |
843 | PrintAndLog(" [fclow], small field clock length, omit for autodetect"); | |
844 | PrintAndLog(""); | |
845 | PrintAndLog(" sample: data rawdemod fs = demod an fsk tag from GraphBuffer using autodetect"); | |
846 | PrintAndLog(" : data rawdemod fs 32 = demod an fsk tag from GraphBuffer using a clock of RF/32, autodetect fc"); | |
847 | PrintAndLog(" : data rawdemod fs 1 = demod an fsk tag from GraphBuffer using autodetect, invert output"); | |
848 | PrintAndLog(" : data rawdemod fs 32 1 = demod an fsk tag from GraphBuffer using a clock of RF/32, invert output, autodetect fc"); | |
849 | PrintAndLog(" : data rawdemod fs 64 0 8 5 = demod an fsk1 RF/64 tag from GraphBuffer"); | |
850 | PrintAndLog(" : data rawdemod fs 50 0 10 8 = demod an fsk2 RF/50 tag from GraphBuffer"); | |
851 | PrintAndLog(" : data rawdemod fs 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer"); | |
852 | return 0; | |
853 | } | |
7cb8516c | 854 | return FSKrawDemod(Cmd, true); |
4ac906d1 | 855 | } |
856 | ||
e770c648 | 857 | //by marshmellow |
858 | //attempt to psk1 demod graph buffer | |
4ac906d1 | 859 | int PSKDemod(const char *Cmd, bool verbose) |
e770c648 | 860 | { |
e0165dcf | 861 | int invert=0; |
862 | int clk=0; | |
863 | int maxErr=100; | |
864 | sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr); | |
865 | if (clk==1){ | |
866 | invert=1; | |
867 | clk=0; | |
868 | } | |
869 | if (invert != 0 && invert != 1) { | |
2ec87733 | 870 | if (g_debugMode || verbose) PrintAndLog("Invalid argument: %s", Cmd); |
e0165dcf | 871 | return 0; |
872 | } | |
873 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; | |
874 | size_t BitLen = getFromGraphBuf(BitStream); | |
2ec87733 | 875 | if (BitLen==0) return 0; |
e0165dcf | 876 | int errCnt=0; |
0f321d63 | 877 | int startIdx = 0; |
878 | errCnt = pskRawDemod_ext(BitStream, &BitLen, &clk, &invert, &startIdx); | |
e0165dcf | 879 | if (errCnt > maxErr){ |
2767fc02 | 880 | if (g_debugMode || verbose) PrintAndLog("Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); |
e0165dcf | 881 | return 0; |
882 | } | |
883 | if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) | |
2767fc02 | 884 | if (g_debugMode || verbose) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); |
e0165dcf | 885 | return 0; |
886 | } | |
2767fc02 | 887 | if (verbose || g_debugMode){ |
888 | PrintAndLog("\nUsing Clock:%d, invert:%d, Bits Found:%d",clk,invert,BitLen); | |
e0165dcf | 889 | if (errCnt>0){ |
2767fc02 | 890 | PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d",errCnt); |
e0165dcf | 891 | } |
892 | } | |
893 | //prime demod buffer for output | |
894 | setDemodBuf(BitStream,BitLen,0); | |
0f321d63 | 895 | setClockGrid(clk, startIdx); |
896 | ||
e0165dcf | 897 | return 1; |
4118b74d | 898 | } |
e770c648 | 899 | |
04d2721b | 900 | // by marshmellow |
e770c648 | 901 | // takes 3 arguments - clock, invert, maxErr as integers |
902 | // attempts to demodulate nrz only | |
903 | // prints binary found and saves in demodbuffer for further commands | |
b4a2fcf6 | 904 | int NRZrawDemod(const char *Cmd, bool verbose) |
e770c648 | 905 | { |
e0165dcf | 906 | int invert=0; |
907 | int clk=0; | |
908 | int maxErr=100; | |
909 | sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr); | |
910 | if (clk==1){ | |
911 | invert=1; | |
912 | clk=0; | |
913 | } | |
914 | if (invert != 0 && invert != 1) { | |
915 | PrintAndLog("Invalid argument: %s", Cmd); | |
916 | return 0; | |
917 | } | |
918 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; | |
919 | size_t BitLen = getFromGraphBuf(BitStream); | |
920 | if (BitLen==0) return 0; | |
921 | int errCnt=0; | |
6f36848f | 922 | int clkStartIdx = 0; |
923 | errCnt = nrzRawDemod(BitStream, &BitLen, &clk, &invert, &clkStartIdx); | |
e0165dcf | 924 | if (errCnt > maxErr){ |
925 | if (g_debugMode) PrintAndLog("Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); | |
926 | return 0; | |
927 | } | |
2eec55c8 | 928 | if (errCnt<0 || BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) |
e0165dcf | 929 | if (g_debugMode) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); |
930 | return 0; | |
931 | } | |
932 | if (verbose || g_debugMode) PrintAndLog("Tried NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); | |
933 | //prime demod buffer for output | |
934 | setDemodBuf(BitStream,BitLen,0); | |
0f321d63 | 935 | setClockGrid(clk, clkStartIdx); |
936 | ||
e0165dcf | 937 | |
2767fc02 | 938 | if (errCnt>0 && (verbose || g_debugMode)) PrintAndLog("# Errors during Demoding (shown as 7 in bit stream): %d",errCnt); |
e0165dcf | 939 | if (verbose || g_debugMode) { |
940 | PrintAndLog("NRZ demoded bitstream:"); | |
941 | // Now output the bitstream to the scrollback by line of 16 bits | |
942 | printDemodBuff(); | |
943 | } | |
944 | return 1; | |
b4a2fcf6 | 945 | } |
946 | ||
947 | int CmdNRZrawDemod(const char *Cmd) | |
948 | { | |
e0165dcf | 949 | char cmdp = param_getchar(Cmd, 0); |
01d0f8ae | 950 | if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') { |
e0165dcf | 951 | PrintAndLog("Usage: data rawdemod nr [clock] <0|1> [maxError]"); |
952 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect."); | |
953 | PrintAndLog(" <invert>, 1 for invert output"); | |
954 | PrintAndLog(" [set maximum allowed errors], default = 100."); | |
955 | PrintAndLog(""); | |
956 | PrintAndLog(" sample: data rawdemod nr = demod a nrz/direct tag from GraphBuffer"); | |
957 | PrintAndLog(" : data rawdemod nr 32 = demod a nrz/direct tag from GraphBuffer using a clock of RF/32"); | |
958 | PrintAndLog(" : data rawdemod nr 32 1 = demod a nrz/direct tag from GraphBuffer using a clock of RF/32 and inverting data"); | |
959 | PrintAndLog(" : data rawdemod nr 1 = demod a nrz/direct tag from GraphBuffer while inverting data"); | |
960 | PrintAndLog(" : data rawdemod nr 64 1 0 = demod a nrz/direct tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); | |
961 | return 0; | |
962 | } | |
7cb8516c | 963 | return NRZrawDemod(Cmd, true); |
e770c648 | 964 | } |
965 | ||
966 | // by marshmellow | |
967 | // takes 3 arguments - clock, invert, maxErr as integers | |
04d2721b | 968 | // attempts to demodulate psk only |
969 | // prints binary found and saves in demodbuffer for further commands | |
e770c648 | 970 | int CmdPSK1rawDemod(const char *Cmd) |
4118b74d | 971 | { |
e0165dcf | 972 | int ans; |
973 | char cmdp = param_getchar(Cmd, 0); | |
01d0f8ae | 974 | if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') { |
e0165dcf | 975 | PrintAndLog("Usage: data rawdemod p1 [clock] <0|1> [maxError]"); |
976 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect."); | |
977 | PrintAndLog(" <invert>, 1 for invert output"); | |
978 | PrintAndLog(" [set maximum allowed errors], default = 100."); | |
979 | PrintAndLog(""); | |
980 | PrintAndLog(" sample: data rawdemod p1 = demod a psk1 tag from GraphBuffer"); | |
981 | PrintAndLog(" : data rawdemod p1 32 = demod a psk1 tag from GraphBuffer using a clock of RF/32"); | |
982 | PrintAndLog(" : data rawdemod p1 32 1 = demod a psk1 tag from GraphBuffer using a clock of RF/32 and inverting data"); | |
983 | PrintAndLog(" : data rawdemod p1 1 = demod a psk1 tag from GraphBuffer while inverting data"); | |
984 | PrintAndLog(" : data rawdemod p1 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); | |
985 | return 0; | |
986 | } | |
7cb8516c | 987 | ans = PSKDemod(Cmd, true); |
e0165dcf | 988 | //output |
989 | if (!ans){ | |
990 | if (g_debugMode) PrintAndLog("Error demoding: %d",ans); | |
991 | return 0; | |
992 | } | |
7a8a982b | 993 | |
2767fc02 | 994 | PrintAndLog("PSK1 demoded bitstream:"); |
e0165dcf | 995 | // Now output the bitstream to the scrollback by line of 16 bits |
996 | printDemodBuff(); | |
997 | return 1; | |
4118b74d | 998 | } |
999 | ||
04d2721b | 1000 | // by marshmellow |
19ff0210 | 1001 | // takes same args as cmdpsk1rawdemod |
04d2721b | 1002 | int CmdPSK2rawDemod(const char *Cmd) |
1003 | { | |
e0165dcf | 1004 | int ans=0; |
1005 | char cmdp = param_getchar(Cmd, 0); | |
01d0f8ae | 1006 | if (strlen(Cmd) > 16 || cmdp == 'h' || cmdp == 'H') { |
e0165dcf | 1007 | PrintAndLog("Usage: data rawdemod p2 [clock] <0|1> [maxError]"); |
1008 | PrintAndLog(" [set clock as integer] optional, if not set, autodetect."); | |
1009 | PrintAndLog(" <invert>, 1 for invert output"); | |
1010 | PrintAndLog(" [set maximum allowed errors], default = 100."); | |
1011 | PrintAndLog(""); | |
1012 | PrintAndLog(" sample: data rawdemod p2 = demod a psk2 tag from GraphBuffer, autodetect clock"); | |
1013 | PrintAndLog(" : data rawdemod p2 32 = demod a psk2 tag from GraphBuffer using a clock of RF/32"); | |
1014 | PrintAndLog(" : data rawdemod p2 32 1 = demod a psk2 tag from GraphBuffer using a clock of RF/32 and inverting output"); | |
1015 | PrintAndLog(" : data rawdemod p2 1 = demod a psk2 tag from GraphBuffer, autodetect clock and invert output"); | |
1016 | PrintAndLog(" : data rawdemod p2 64 1 0 = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors"); | |
1017 | return 0; | |
1018 | } | |
7cb8516c | 1019 | ans=PSKDemod(Cmd, true); |
e0165dcf | 1020 | if (!ans){ |
1021 | if (g_debugMode) PrintAndLog("Error demoding: %d",ans); | |
1022 | return 0; | |
1023 | } | |
1024 | psk1TOpsk2(DemodBuffer, DemodBufferLen); | |
1025 | PrintAndLog("PSK2 demoded bitstream:"); | |
1026 | // Now output the bitstream to the scrollback by line of 16 bits | |
1027 | printDemodBuff(); | |
1028 | return 1; | |
04d2721b | 1029 | } |
1030 | ||
19ff0210 | 1031 | // by marshmellow - combines all raw demod functions into one menu command |
1032 | int CmdRawDemod(const char *Cmd) | |
1033 | { | |
1034 | char cmdp = Cmd[0]; //param_getchar(Cmd, 0); | |
1035 | ||
01d0f8ae | 1036 | if (strlen(Cmd) > 35 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd)<2) { |
19ff0210 | 1037 | PrintAndLog("Usage: data rawdemod [modulation] <help>|<options>"); |
b41534d1 | 1038 | PrintAndLog(" [modulation] as 2 char, 'ab' for ask/biphase, 'am' for ask/manchester, 'ar' for ask/raw, 'fs' for fsk, ..."); |
1039 | PrintAndLog(" 'nr' for nrz/direct, 'p1' for psk1, 'p2' for psk2"); | |
19ff0210 | 1040 | PrintAndLog(" <help> as 'h', prints the help for the specific modulation"); |
1041 | PrintAndLog(" <options> see specific modulation help for optional parameters"); | |
1042 | PrintAndLog(""); | |
1fbf8956 | 1043 | PrintAndLog(" sample: data rawdemod fs h = print help specific to fsk demod"); |
19ff0210 | 1044 | PrintAndLog(" : data rawdemod fs = demod GraphBuffer using: fsk - autodetect"); |
b41534d1 | 1045 | PrintAndLog(" : data rawdemod ab = demod GraphBuffer using: ask/biphase - autodetect"); |
19ff0210 | 1046 | PrintAndLog(" : data rawdemod am = demod GraphBuffer using: ask/manchester - autodetect"); |
1047 | PrintAndLog(" : data rawdemod ar = demod GraphBuffer using: ask/raw - autodetect"); | |
1048 | PrintAndLog(" : data rawdemod nr = demod GraphBuffer using: nrz/direct - autodetect"); | |
1049 | PrintAndLog(" : data rawdemod p1 = demod GraphBuffer using: psk1 - autodetect"); | |
1050 | PrintAndLog(" : data rawdemod p2 = demod GraphBuffer using: psk2 - autodetect"); | |
1051 | return 0; | |
1052 | } | |
1053 | char cmdp2 = Cmd[1]; | |
1054 | int ans = 0; | |
1055 | if (cmdp == 'f' && cmdp2 == 's'){ | |
f8f894a5 | 1056 | ans = CmdFSKrawdemod(Cmd+2); |
b41534d1 | 1057 | } else if(cmdp == 'a' && cmdp2 == 'b'){ |
f8f894a5 | 1058 | ans = Cmdaskbiphdemod(Cmd+2); |
19ff0210 | 1059 | } else if(cmdp == 'a' && cmdp2 == 'm'){ |
f8f894a5 | 1060 | ans = Cmdaskmandemod(Cmd+2); |
19ff0210 | 1061 | } else if(cmdp == 'a' && cmdp2 == 'r'){ |
f8f894a5 | 1062 | ans = Cmdaskrawdemod(Cmd+2); |
19ff0210 | 1063 | } else if(cmdp == 'n' && cmdp2 == 'r'){ |
f8f894a5 | 1064 | ans = CmdNRZrawDemod(Cmd+2); |
19ff0210 | 1065 | } else if(cmdp == 'p' && cmdp2 == '1'){ |
f8f894a5 | 1066 | ans = CmdPSK1rawDemod(Cmd+2); |
19ff0210 | 1067 | } else if(cmdp == 'p' && cmdp2 == '2'){ |
f8f894a5 | 1068 | ans = CmdPSK2rawDemod(Cmd+2); |
19ff0210 | 1069 | } else { |
1070 | PrintAndLog("unknown modulation entered - see help ('h') for parameter structure"); | |
1071 | } | |
1072 | return ans; | |
1073 | } | |
1074 | ||
0f321d63 | 1075 | void setClockGrid(int clk, int offset) { |
b8fdac9e | 1076 | g_DemodStartIdx = offset; |
1077 | g_DemodClock = clk; | |
f516ff08 | 1078 | if (g_debugMode) PrintAndLog("demodoffset %d, clk %d",offset,clk); |
c4809fd4 | 1079 | |
3fd7fce4 | 1080 | if (offset > clk) offset %= clk; |
0f321d63 | 1081 | if (offset < 0) offset += clk; |
1082 | ||
1083 | if (offset > GraphTraceLen || offset < 0) return; | |
1084 | if (clk < 8 || clk > GraphTraceLen) { | |
1085 | GridLocked = false; | |
1086 | GridOffset = 0; | |
1087 | PlotGridX = 0; | |
1088 | PlotGridXdefault = 0; | |
1089 | RepaintGraphWindow(); | |
1090 | } else { | |
1091 | GridLocked = true; | |
1092 | GridOffset = offset; | |
1093 | PlotGridX = clk; | |
1094 | PlotGridXdefault = clk; | |
1095 | RepaintGraphWindow(); | |
1096 | } | |
1097 | } | |
1098 | ||
7fe9b0b7 | 1099 | int CmdGrid(const char *Cmd) |
1100 | { | |
e0165dcf | 1101 | sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY); |
1102 | PlotGridXdefault= PlotGridX; | |
1103 | PlotGridYdefault= PlotGridY; | |
1104 | RepaintGraphWindow(); | |
1105 | return 0; | |
7fe9b0b7 | 1106 | } |
1107 | ||
f9f0e83b | 1108 | int CmdSetGraphMarkers(const char *Cmd) { |
1109 | sscanf(Cmd, "%i %i", &CursorCPos, &CursorDPos); | |
1110 | RepaintGraphWindow(); | |
1111 | return 0; | |
1112 | } | |
1113 | ||
7fe9b0b7 | 1114 | int CmdHexsamples(const char *Cmd) |
1115 | { | |
e0165dcf | 1116 | int i, j; |
1117 | int requested = 0; | |
1118 | int offset = 0; | |
1119 | char string_buf[25]; | |
1120 | char* string_ptr = string_buf; | |
1121 | uint8_t got[BIGBUF_SIZE]; | |
1122 | ||
1123 | sscanf(Cmd, "%i %i", &requested, &offset); | |
1124 | ||
1125 | /* if no args send something */ | |
1126 | if (requested == 0) { | |
1127 | requested = 8; | |
1128 | } | |
1129 | if (offset + requested > sizeof(got)) { | |
1130 | PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > %d", BIGBUF_SIZE); | |
1131 | return 0; | |
1132 | } | |
1133 | ||
1134 | GetFromBigBuf(got,requested,offset); | |
1135 | WaitForResponse(CMD_ACK,NULL); | |
1136 | ||
1137 | i = 0; | |
1138 | for (j = 0; j < requested; j++) { | |
1139 | i++; | |
1140 | string_ptr += sprintf(string_ptr, "%02x ", got[j]); | |
1141 | if (i == 8) { | |
1142 | *(string_ptr - 1) = '\0'; // remove the trailing space | |
1143 | PrintAndLog("%s", string_buf); | |
1144 | string_buf[0] = '\0'; | |
1145 | string_ptr = string_buf; | |
1146 | i = 0; | |
1147 | } | |
1148 | if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes | |
1149 | *(string_ptr - 1) = '\0'; | |
1150 | PrintAndLog("%s", string_buf); | |
1151 | string_buf[0] = '\0'; | |
1152 | } | |
1153 | } | |
1154 | return 0; | |
7fe9b0b7 | 1155 | } |
1156 | ||
7fe9b0b7 | 1157 | int CmdHide(const char *Cmd) |
1158 | { | |
e0165dcf | 1159 | HideGraphWindow(); |
1160 | return 0; | |
7fe9b0b7 | 1161 | } |
1162 | ||
78f5b1a7 | 1163 | //zero mean GraphBuffer |
7fe9b0b7 | 1164 | int CmdHpf(const char *Cmd) |
1165 | { | |
e0165dcf | 1166 | int i; |
1167 | int accum = 0; | |
7fe9b0b7 | 1168 | |
e0165dcf | 1169 | for (i = 10; i < GraphTraceLen; ++i) |
1170 | accum += GraphBuffer[i]; | |
1171 | accum /= (GraphTraceLen - 10); | |
1172 | for (i = 0; i < GraphTraceLen; ++i) | |
1173 | GraphBuffer[i] -= accum; | |
7fe9b0b7 | 1174 | |
e0165dcf | 1175 | RepaintGraphWindow(); |
1176 | return 0; | |
7fe9b0b7 | 1177 | } |
f6d9fb17 | 1178 | |
f6821167 | 1179 | uint8_t getByte(uint8_t bits_per_sample, BitstreamIn* b) |
f6d9fb17 MHS |
1180 | { |
1181 | int i; | |
1182 | uint8_t val = 0; | |
1183 | for(i =0 ; i < bits_per_sample; i++) | |
1184 | { | |
f6821167 | 1185 | val |= (headBit(b) << (7-i)); |
f6d9fb17 MHS |
1186 | } |
1187 | return val; | |
1188 | } | |
7fe9b0b7 | 1189 | |
b9957414 | 1190 | int getSamples(int n, bool silent) |
7fe9b0b7 | 1191 | { |
e0165dcf | 1192 | //If we get all but the last byte in bigbuf, |
1193 | // we don't have to worry about remaining trash | |
1194 | // in the last byte in case the bits-per-sample | |
1195 | // does not line up on byte boundaries | |
1196 | ||
1197 | uint8_t got[BIGBUF_SIZE-1] = { 0 }; | |
1198 | ||
709665b5 | 1199 | if (n == 0 || n > sizeof(got)) |
e0165dcf | 1200 | n = sizeof(got); |
1201 | ||
b9957414 | 1202 | if (!silent) PrintAndLog("Reading %d bytes from device memory\n", n); |
e0165dcf | 1203 | GetFromBigBuf(got,n,0); |
b9957414 | 1204 | if (!silent) PrintAndLog("Data fetched"); |
e0165dcf | 1205 | UsbCommand response; |
1206 | WaitForResponse(CMD_ACK, &response); | |
1207 | uint8_t bits_per_sample = 8; | |
1208 | ||
1209 | //Old devices without this feature would send 0 at arg[0] | |
1210 | if(response.arg[0] > 0) | |
1211 | { | |
1212 | sample_config *sc = (sample_config *) response.d.asBytes; | |
e8647c57 | 1213 | if (!silent) PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample |
e0165dcf | 1214 | , sc->decimation); |
1215 | bits_per_sample = sc->bits_per_sample; | |
1216 | } | |
1217 | if(bits_per_sample < 8) | |
1218 | { | |
b9957414 | 1219 | if (!silent) PrintAndLog("Unpacking..."); |
f6821167 | 1220 | BitstreamIn bout = { got, bits_per_sample * n, 0}; |
e0165dcf | 1221 | int j =0; |
e6432f05 | 1222 | for (j = 0; j * bits_per_sample < n * 8 && j < n; j++) { |
e0165dcf | 1223 | uint8_t sample = getByte(bits_per_sample, &bout); |
1224 | GraphBuffer[j] = ((int) sample )- 128; | |
1225 | } | |
1226 | GraphTraceLen = j; | |
1227 | PrintAndLog("Unpacked %d samples" , j ); | |
1228 | }else | |
1229 | { | |
1230 | for (int j = 0; j < n; j++) { | |
1231 | GraphBuffer[j] = ((int)got[j]) - 128; | |
1232 | } | |
1233 | GraphTraceLen = n; | |
1234 | } | |
1235 | ||
b8fdac9e | 1236 | setClockGrid(0,0); |
0e2ddb41 | 1237 | DemodBufferLen = 0; |
e0165dcf | 1238 | RepaintGraphWindow(); |
1239 | return 0; | |
1fbf8956 | 1240 | } |
1241 | ||
1242 | int CmdSamples(const char *Cmd) | |
1243 | { | |
b9957414 | 1244 | int n = strtol(Cmd, NULL, 0); |
1245 | return getSamples(n, false); | |
7fe9b0b7 | 1246 | } |
1247 | ||
d6a120a2 MHS |
1248 | int CmdTuneSamples(const char *Cmd) |
1249 | { | |
fdcfbdcc RAB |
1250 | int timeout = 0, arg = FLAG_TUNE_ALL; |
1251 | ||
1252 | if(*Cmd == 'l') { | |
1253 | arg = FLAG_TUNE_LF; | |
1254 | } else if (*Cmd == 'h') { | |
1255 | arg = FLAG_TUNE_HF; | |
1256 | } else if (*Cmd != '\0') { | |
1257 | PrintAndLog("use 'tune' or 'tune l' or 'tune h'"); | |
1258 | return 0; | |
1259 | } | |
1260 | ||
3aa4014b | 1261 | printf("\nMeasuring antenna characteristics, please wait..."); |
ba1a299c | 1262 | |
fdcfbdcc | 1263 | UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING, {arg, 0, 0}}; |
3aa4014b | 1264 | SendCommand(&c); |
1265 | ||
1266 | UsbCommand resp; | |
1267 | while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING,&resp,1000)) { | |
1268 | timeout++; | |
1269 | printf("."); | |
1270 | if (timeout > 7) { | |
1271 | PrintAndLog("\nNo response from Proxmark. Aborting..."); | |
1272 | return 1; | |
1273 | } | |
1274 | } | |
1275 | ||
1276 | int peakv, peakf; | |
1277 | int vLf125, vLf134, vHf; | |
1278 | vLf125 = resp.arg[0] & 0xffff; | |
1279 | vLf134 = resp.arg[0] >> 16; | |
1280 | vHf = resp.arg[1] & 0xffff;; | |
1281 | peakf = resp.arg[2] & 0xffff; | |
1282 | peakv = resp.arg[2] >> 16; | |
1283 | PrintAndLog(""); | |
1284 | PrintAndLog("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0); | |
1285 | PrintAndLog("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0); | |
1286 | PrintAndLog("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1)); | |
1287 | PrintAndLog("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0); | |
0d0d0499 | 1288 | |
2767fc02 | 1289 | #define LF_UNUSABLE_V 2948 // was 2000. Changed due to bugfix in voltage measurements. LF results are now 47% higher. |
1290 | #define LF_MARGINAL_V 14739 // was 10000. Changed due to bugfix bug in voltage measurements. LF results are now 47% higher. | |
1291 | #define HF_UNUSABLE_V 3167 // was 2000. Changed due to bugfix in voltage measurements. HF results are now 58% higher. | |
1292 | #define HF_MARGINAL_V 7917 // was 5000. Changed due to bugfix in voltage measurements. HF results are now 58% higher. | |
0d0d0499 | 1293 | |
1294 | if (peakv < LF_UNUSABLE_V) | |
3aa4014b | 1295 | PrintAndLog("# Your LF antenna is unusable."); |
0d0d0499 | 1296 | else if (peakv < LF_MARGINAL_V) |
3aa4014b | 1297 | PrintAndLog("# Your LF antenna is marginal."); |
0d0d0499 | 1298 | if (vHf < HF_UNUSABLE_V) |
3aa4014b | 1299 | PrintAndLog("# Your HF antenna is unusable."); |
0d0d0499 | 1300 | else if (vHf < HF_MARGINAL_V) |
3aa4014b | 1301 | PrintAndLog("# Your HF antenna is marginal."); |
1302 | ||
0d0d0499 | 1303 | if (peakv >= LF_UNUSABLE_V) { |
1304 | for (int i = 0; i < 256; i++) { | |
1305 | GraphBuffer[i] = resp.d.asBytes[i] - 128; | |
1306 | } | |
1307 | PrintAndLog("Displaying LF tuning graph. Divisor 89 is 134khz, 95 is 125khz.\n"); | |
1308 | PrintAndLog("\n"); | |
1309 | GraphTraceLen = 256; | |
1310 | ShowGraphWindow(); | |
abd16c45 | 1311 | RepaintGraphWindow(); |
ba1a299c | 1312 | } |
1313 | ||
b4fb11ba | 1314 | return 0; |
d6a120a2 MHS |
1315 | } |
1316 | ||
3aa4014b | 1317 | |
7fe9b0b7 | 1318 | int CmdLoad(const char *Cmd) |
1319 | { | |
e0165dcf | 1320 | char filename[FILE_PATH_SIZE] = {0x00}; |
1321 | int len = 0; | |
b915fda3 | 1322 | |
e0165dcf | 1323 | len = strlen(Cmd); |
1324 | if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; | |
1325 | memcpy(filename, Cmd, len); | |
b915fda3 | 1326 | |
e0165dcf | 1327 | FILE *f = fopen(filename, "r"); |
1328 | if (!f) { | |
1329 | PrintAndLog("couldn't open '%s'", filename); | |
1330 | return 0; | |
1331 | } | |
1332 | ||
1333 | GraphTraceLen = 0; | |
1334 | char line[80]; | |
1335 | while (fgets(line, sizeof (line), f)) { | |
1336 | GraphBuffer[GraphTraceLen] = atoi(line); | |
1337 | GraphTraceLen++; | |
1338 | } | |
1339 | fclose(f); | |
1340 | PrintAndLog("loaded %d samples", GraphTraceLen); | |
b8fdac9e | 1341 | setClockGrid(0,0); |
0e2ddb41 | 1342 | DemodBufferLen = 0; |
e0165dcf | 1343 | RepaintGraphWindow(); |
1344 | return 0; | |
7fe9b0b7 | 1345 | } |
1346 | ||
1347 | int CmdLtrim(const char *Cmd) | |
1348 | { | |
e0165dcf | 1349 | int ds = atoi(Cmd); |
cc15a118 | 1350 | if (GraphTraceLen<=0) return 0; |
e0165dcf | 1351 | for (int i = ds; i < GraphTraceLen; ++i) |
1352 | GraphBuffer[i-ds] = GraphBuffer[i]; | |
1353 | GraphTraceLen -= ds; | |
7fe9b0b7 | 1354 | |
e0165dcf | 1355 | RepaintGraphWindow(); |
1356 | return 0; | |
7fe9b0b7 | 1357 | } |
ec75f5c1 | 1358 | |
1359 | // trim graph to input argument length | |
9ec1416a | 1360 | int CmdRtrim(const char *Cmd) |
1361 | { | |
e0165dcf | 1362 | int ds = atoi(Cmd); |
9ec1416a | 1363 | |
e0165dcf | 1364 | GraphTraceLen = ds; |
9ec1416a | 1365 | |
e0165dcf | 1366 | RepaintGraphWindow(); |
1367 | return 0; | |
9ec1416a | 1368 | } |
7fe9b0b7 | 1369 | |
f75b313b | 1370 | // trim graph (middle) piece |
1371 | int CmdMtrim(const char *Cmd) { | |
1372 | int start = 0, stop = 0; | |
1373 | sscanf(Cmd, "%i %i", &start, &stop); | |
1374 | ||
1375 | if (start > GraphTraceLen || stop > GraphTraceLen || start > stop) return 0; | |
1376 | start++; //leave start position sample | |
1377 | ||
3991b2ec | 1378 | GraphTraceLen = stop - start; |
f75b313b | 1379 | for (int i = 0; i < GraphTraceLen; i++) { |
3991b2ec | 1380 | GraphBuffer[i] = GraphBuffer[start+i]; |
f75b313b | 1381 | } |
1382 | return 0; | |
1383 | } | |
1384 | ||
1385 | ||
7fe9b0b7 | 1386 | int CmdNorm(const char *Cmd) |
1387 | { | |
e0165dcf | 1388 | int i; |
1389 | int max = INT_MIN, min = INT_MAX; | |
7fe9b0b7 | 1390 | |
e0165dcf | 1391 | for (i = 10; i < GraphTraceLen; ++i) { |
1392 | if (GraphBuffer[i] > max) | |
1393 | max = GraphBuffer[i]; | |
1394 | if (GraphBuffer[i] < min) | |
1395 | min = GraphBuffer[i]; | |
1396 | } | |
7fe9b0b7 | 1397 | |
e0165dcf | 1398 | if (max != min) { |
1399 | for (i = 0; i < GraphTraceLen; ++i) { | |
0e2ddb41 | 1400 | GraphBuffer[i] = ((long)(GraphBuffer[i] - ((max + min) / 2)) * 256) / (max - min); |
ba1a299c | 1401 | //marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work |
e0165dcf | 1402 | } |
1403 | } | |
1404 | RepaintGraphWindow(); | |
1405 | return 0; | |
7fe9b0b7 | 1406 | } |
1407 | ||
1408 | int CmdPlot(const char *Cmd) | |
1409 | { | |
e0165dcf | 1410 | ShowGraphWindow(); |
1411 | return 0; | |
7fe9b0b7 | 1412 | } |
1413 | ||
1414 | int CmdSave(const char *Cmd) | |
1415 | { | |
e0165dcf | 1416 | char filename[FILE_PATH_SIZE] = {0x00}; |
1417 | int len = 0; | |
b915fda3 | 1418 | |
e0165dcf | 1419 | len = strlen(Cmd); |
1420 | if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; | |
1421 | memcpy(filename, Cmd, len); | |
1422 | ||
b915fda3 | 1423 | |
e0165dcf | 1424 | FILE *f = fopen(filename, "w"); |
1425 | if(!f) { | |
1426 | PrintAndLog("couldn't open '%s'", filename); | |
1427 | return 0; | |
1428 | } | |
1429 | int i; | |
1430 | for (i = 0; i < GraphTraceLen; i++) { | |
1431 | fprintf(f, "%d\n", GraphBuffer[i]); | |
1432 | } | |
1433 | fclose(f); | |
1434 | PrintAndLog("saved to '%s'", Cmd); | |
1435 | return 0; | |
7fe9b0b7 | 1436 | } |
1437 | ||
1438 | int CmdScale(const char *Cmd) | |
1439 | { | |
e0165dcf | 1440 | CursorScaleFactor = atoi(Cmd); |
1441 | if (CursorScaleFactor == 0) { | |
1442 | PrintAndLog("bad, can't have zero scale"); | |
1443 | CursorScaleFactor = 1; | |
1444 | } | |
1445 | RepaintGraphWindow(); | |
1446 | return 0; | |
7fe9b0b7 | 1447 | } |
1448 | ||
c4f51073 | 1449 | int directionalThreshold(const int* in, int *out, size_t len, int8_t up, int8_t down) |
d51b2eda | 1450 | { |
c4f51073 | 1451 | int lastValue = in[0]; |
1452 | out[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in. | |
e0165dcf | 1453 | |
c4f51073 | 1454 | for (int i = 1; i < len; ++i) { |
e0165dcf | 1455 | // Apply first threshold to samples heading up |
c4f51073 | 1456 | if (in[i] >= up && in[i] > lastValue) |
e0165dcf | 1457 | { |
c4f51073 | 1458 | lastValue = out[i]; // Buffer last value as we overwrite it. |
1459 | out[i] = 1; | |
e0165dcf | 1460 | } |
1461 | // Apply second threshold to samples heading down | |
c4f51073 | 1462 | else if (in[i] <= down && in[i] < lastValue) |
e0165dcf | 1463 | { |
c4f51073 | 1464 | lastValue = out[i]; // Buffer last value as we overwrite it. |
1465 | out[i] = -1; | |
e0165dcf | 1466 | } |
1467 | else | |
1468 | { | |
c4f51073 | 1469 | lastValue = out[i]; // Buffer last value as we overwrite it. |
1470 | out[i] = out[i-1]; | |
e0165dcf | 1471 | } |
1472 | } | |
c4f51073 | 1473 | out[0] = out[1]; // Align with first edited sample. |
1474 | return 0; | |
1475 | } | |
1476 | ||
1477 | int CmdDirectionalThreshold(const char *Cmd) | |
1478 | { | |
1479 | int8_t upThres = param_get8(Cmd, 0); | |
1480 | int8_t downThres = param_get8(Cmd, 1); | |
1481 | ||
1482 | printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres); | |
1483 | ||
1484 | directionalThreshold(GraphBuffer, GraphBuffer,GraphTraceLen, upThres, downThres); | |
e0165dcf | 1485 | RepaintGraphWindow(); |
1486 | return 0; | |
d51b2eda MHS |
1487 | } |
1488 | ||
7fe9b0b7 | 1489 | int CmdZerocrossings(const char *Cmd) |
1490 | { | |
e0165dcf | 1491 | // Zero-crossings aren't meaningful unless the signal is zero-mean. |
1492 | CmdHpf(""); | |
1493 | ||
1494 | int sign = 1; | |
1495 | int zc = 0; | |
1496 | int lastZc = 0; | |
1497 | ||
1498 | for (int i = 0; i < GraphTraceLen; ++i) { | |
1499 | if (GraphBuffer[i] * sign >= 0) { | |
1500 | // No change in sign, reproduce the previous sample count. | |
1501 | zc++; | |
1502 | GraphBuffer[i] = lastZc; | |
1503 | } else { | |
1504 | // Change in sign, reset the sample count. | |
1505 | sign = -sign; | |
1506 | GraphBuffer[i] = lastZc; | |
1507 | if (sign > 0) { | |
1508 | lastZc = zc; | |
1509 | zc = 0; | |
1510 | } | |
1511 | } | |
1512 | } | |
1513 | ||
1514 | RepaintGraphWindow(); | |
1515 | return 0; | |
7fe9b0b7 | 1516 | } |
1517 | ||
f6821167 MHS |
1518 | int usage_data_bin2hex(){ |
1519 | PrintAndLog("Usage: data bin2hex <binary_digits>"); | |
1520 | PrintAndLog(" This function will ignore all characters not 1 or 0 (but stop reading on whitespace)"); | |
1521 | return 0; | |
1522 | } | |
1523 | ||
1524 | /** | |
1525 | * @brief Utility for conversion via cmdline. | |
1526 | * @param Cmd | |
1527 | * @return | |
1528 | */ | |
1529 | int Cmdbin2hex(const char *Cmd) | |
1530 | { | |
1531 | int bg =0, en =0; | |
1532 | if(param_getptr(Cmd, &bg, &en, 0)) | |
1533 | { | |
1534 | return usage_data_bin2hex(); | |
1535 | } | |
1536 | //Number of digits supplied as argument | |
1537 | size_t length = en - bg +1; | |
1538 | size_t bytelen = (length+7) / 8; | |
1539 | uint8_t* arr = (uint8_t *) malloc(bytelen); | |
1540 | memset(arr, 0, bytelen); | |
1541 | BitstreamOut bout = { arr, 0, 0 }; | |
1542 | ||
1543 | for(; bg <= en ;bg++) | |
1544 | { | |
1545 | char c = Cmd[bg]; | |
1546 | if( c == '1') pushBit(&bout, 1); | |
1547 | else if( c == '0') pushBit(&bout, 0); | |
1548 | else PrintAndLog("Ignoring '%c'", c); | |
1549 | } | |
1550 | ||
1551 | if(bout.numbits % 8 != 0) | |
1552 | { | |
1553 | printf("[padded with %d zeroes]\n", 8-(bout.numbits % 8)); | |
1554 | } | |
1555 | ||
1556 | //Uses printf instead of PrintAndLog since the latter | |
1557 | // adds linebreaks to each printout - this way was more convenient since we don't have to | |
1558 | // allocate a string and write to that first... | |
1559 | for(size_t x = 0; x < bytelen ; x++) | |
1560 | { | |
1561 | printf("%02X", arr[x]); | |
1562 | } | |
1563 | printf("\n"); | |
1564 | free(arr); | |
1565 | return 0; | |
1566 | } | |
1567 | ||
72c5877a | 1568 | int usage_data_hex2bin() { |
1569 | PrintAndLog("Usage: data hex2bin <hex_digits>"); | |
f6821167 MHS |
1570 | PrintAndLog(" This function will ignore all non-hexadecimal characters (but stop reading on whitespace)"); |
1571 | return 0; | |
1572 | ||
1573 | } | |
1574 | ||
1575 | int Cmdhex2bin(const char *Cmd) | |
1576 | { | |
1577 | int bg =0, en =0; | |
1578 | if(param_getptr(Cmd, &bg, &en, 0)) | |
1579 | { | |
1580 | return usage_data_hex2bin(); | |
1581 | } | |
1582 | ||
1583 | ||
1584 | while(bg <= en ) | |
1585 | { | |
1586 | char x = Cmd[bg++]; | |
1587 | // capitalize | |
1588 | if (x >= 'a' && x <= 'f') | |
1589 | x -= 32; | |
1590 | // convert to numeric value | |
1591 | if (x >= '0' && x <= '9') | |
1592 | x -= '0'; | |
1593 | else if (x >= 'A' && x <= 'F') | |
1594 | x -= 'A' - 10; | |
1595 | else | |
1596 | continue; | |
1597 | ||
1598 | //Uses printf instead of PrintAndLog since the latter | |
1599 | // adds linebreaks to each printout - this way was more convenient since we don't have to | |
1600 | // allocate a string and write to that first... | |
1601 | ||
1602 | for(int i= 0 ; i < 4 ; ++i) | |
1603 | printf("%d",(x >> (3 - i)) & 1); | |
1604 | } | |
1605 | printf("\n"); | |
1606 | ||
1607 | return 0; | |
1608 | } | |
1609 | ||
0e2ddb41 | 1610 | /* // example of FSK2 RF/50 Tones |
1611 | static const int LowTone[] = { | |
1612 | 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, | |
1613 | 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, | |
1614 | 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, | |
1615 | 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, | |
1616 | 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 | |
1617 | }; | |
1618 | static const int HighTone[] = { | |
1619 | 1, 1, 1, 1, 1, -1, -1, -1, -1, // note one extra 1 to padd due to 50/8 remainder (1/2 the remainder) | |
1620 | 1, 1, 1, 1, -1, -1, -1, -1, | |
1621 | 1, 1, 1, 1, -1, -1, -1, -1, | |
1622 | 1, 1, 1, 1, -1, -1, -1, -1, | |
1623 | 1, 1, 1, 1, -1, -1, -1, -1, | |
1624 | 1, 1, 1, 1, -1, -1, -1, -1, -1, // note one extra -1 to padd due to 50/8 remainder | |
1625 | }; | |
1626 | */ | |
1627 | void GetHiLoTone(int *LowTone, int *HighTone, int clk, int LowToneFC, int HighToneFC) { | |
1628 | int i,j=0; | |
1629 | int Left_Modifier = ((clk % LowToneFC) % 2) + ((clk % LowToneFC)/2); | |
1630 | int Right_Modifier = (clk % LowToneFC) / 2; | |
1631 | //int HighToneMod = clk mod HighToneFC; | |
1632 | int LeftHalfFCCnt = (LowToneFC % 2) + (LowToneFC/2); //truncate | |
1633 | int FCs_per_clk = clk/LowToneFC; | |
1634 | ||
1635 | // need to correctly split up the clock to field clocks. | |
1636 | // First attempt uses modifiers on each end to make up for when FCs don't evenly divide into Clk | |
1637 | ||
1638 | // start with LowTone | |
1639 | // set extra 1 modifiers to make up for when FC doesn't divide evenly into Clk | |
1640 | for (i = 0; i < Left_Modifier; i++) { | |
1641 | LowTone[i] = 1; | |
1642 | } | |
1643 | ||
1644 | // loop # of field clocks inside the main clock | |
1645 | for (i = 0; i < (FCs_per_clk); i++) { | |
1646 | // loop # of samples per field clock | |
1647 | for (j = 0; j < LowToneFC; j++) { | |
1648 | LowTone[(i*LowToneFC)+Left_Modifier+j] = ( j < LeftHalfFCCnt ) ? 1 : -1; | |
1649 | } | |
1650 | } | |
1651 | ||
1652 | int k; | |
1653 | // add last -1 modifiers | |
1654 | for (k = 0; k < Right_Modifier; k++) { | |
1655 | LowTone[((i-1)*LowToneFC)+Left_Modifier+j+k] = -1; | |
1656 | } | |
1657 | ||
1658 | // now do hightone | |
1659 | Left_Modifier = ((clk % HighToneFC) % 2) + ((clk % HighToneFC)/2); | |
1660 | Right_Modifier = (clk % HighToneFC) / 2; | |
1661 | LeftHalfFCCnt = (HighToneFC % 2) + (HighToneFC/2); //truncate | |
1662 | FCs_per_clk = clk/HighToneFC; | |
1663 | ||
1664 | for (i = 0; i < Left_Modifier; i++) { | |
1665 | HighTone[i] = 1; | |
1666 | } | |
1667 | ||
1668 | // loop # of field clocks inside the main clock | |
1669 | for (i = 0; i < (FCs_per_clk); i++) { | |
1670 | // loop # of samples per field clock | |
1671 | for (j = 0; j < HighToneFC; j++) { | |
1672 | HighTone[(i*HighToneFC)+Left_Modifier+j] = ( j < LeftHalfFCCnt ) ? 1 : -1; | |
1673 | } | |
1674 | } | |
1675 | ||
1676 | // add last -1 modifiers | |
1677 | for (k = 0; k < Right_Modifier; k++) { | |
1678 | PrintAndLog("(i-1)*HighToneFC+lm+j+k %i",((i-1)*HighToneFC)+Left_Modifier+j+k); | |
1679 | HighTone[((i-1)*HighToneFC)+Left_Modifier+j+k] = -1; | |
1680 | } | |
1681 | if (g_debugMode == 2) { | |
1682 | for ( i = 0; i < clk; i++) { | |
1683 | PrintAndLog("Low: %i, High: %i",LowTone[i],HighTone[i]); | |
1684 | } | |
1685 | } | |
1686 | } | |
1687 | ||
1688 | //old CmdFSKdemod adapted by marshmellow | |
1689 | //converts FSK to clear NRZ style wave. (or demodulates) | |
1690 | int FSKToNRZ(int *data, int *dataLen, int clk, int LowToneFC, int HighToneFC) { | |
1691 | uint8_t ans=0; | |
1692 | if (clk == 0 || LowToneFC == 0 || HighToneFC == 0) { | |
1693 | int firstClockEdge=0; | |
1694 | ans = fskClocks((uint8_t *) &LowToneFC, (uint8_t *) &HighToneFC, (uint8_t *) &clk, false, &firstClockEdge); | |
1695 | if (g_debugMode > 1) { | |
1696 | PrintAndLog ("DEBUG FSKtoNRZ: detected clocks: fc_low %i, fc_high %i, clk %i, firstClockEdge %i, ans %u", LowToneFC, HighToneFC, clk, firstClockEdge, ans); | |
1697 | } | |
1698 | } | |
1699 | // currently only know fsk modulations with field clocks < 10 samples and > 4 samples. filter out to remove false positives (and possibly destroying ask/psk modulated waves...) | |
1700 | if (ans == 0 || clk == 0 || LowToneFC == 0 || HighToneFC == 0 || LowToneFC > 10 || HighToneFC < 4) { | |
1701 | if (g_debugMode > 1) { | |
1702 | PrintAndLog ("DEBUG FSKtoNRZ: no fsk clocks found"); | |
1703 | } | |
1704 | return 0; | |
1705 | } | |
1706 | int LowTone[clk]; | |
1707 | int HighTone[clk]; | |
1708 | GetHiLoTone(LowTone, HighTone, clk, LowToneFC, HighToneFC); | |
1709 | ||
1710 | int i, j; | |
1711 | ||
1712 | // loop through ([all samples] - clk) | |
1713 | for (i = 0; i < *dataLen - clk; ++i) { | |
1714 | int lowSum = 0, highSum = 0; | |
1715 | ||
1716 | // sum all samples together starting from this sample for [clk] samples for each tone (multiply tone value with sample data) | |
1717 | for (j = 0; j < clk; ++j) { | |
1718 | lowSum += LowTone[j] * data[i+j]; | |
1719 | highSum += HighTone[j] * data[i + j]; | |
1720 | } | |
1721 | // get abs( [average sample value per clk] * 100 ) (or a rolling average of sorts) | |
1722 | lowSum = abs(100 * lowSum / clk); | |
1723 | highSum = abs(100 * highSum / clk); | |
1724 | // save these back to buffer for later use | |
1725 | data[i] = (highSum << 16) | lowSum; | |
1726 | } | |
1727 | ||
1728 | // now we have the abs( [average sample value per clk] * 100 ) for each tone | |
1729 | // loop through again [all samples] - clk - 16 | |
1730 | // note why 16??? is 16 the largest FC? changed to LowToneFC as that should be the > fc | |
1731 | for(i = 0; i < *dataLen - clk - LowToneFC; ++i) { | |
1732 | int lowTot = 0, highTot = 0; | |
1733 | ||
1734 | // sum a field clock width of abs( [average sample values per clk] * 100) for each tone | |
1735 | for (j = 0; j < LowToneFC; ++j) { //10 for fsk2 | |
1736 | lowTot += (data[i + j] & 0xffff); | |
1737 | } | |
1738 | for (j = 0; j < HighToneFC; j++) { //8 for fsk2 | |
1739 | highTot += (data[i + j] >> 16); | |
1740 | } | |
1741 | ||
1742 | // subtract the sum of lowTone averages by the sum of highTone averages as it | |
1743 | // and write back the new graph value | |
1744 | data[i] = lowTot - highTot; | |
1745 | } | |
1746 | // update dataLen to what we put back to the data sample buffer | |
1747 | *dataLen -= (clk + LowToneFC); | |
1748 | return 0; | |
1749 | } | |
1750 | ||
1751 | int usage_data_fsktonrz() { | |
1752 | PrintAndLog("Usage: data fsktonrz c <clock> l <fc_low> f <fc_high>"); | |
1753 | PrintAndLog("Options: "); | |
1754 | PrintAndLog(" h This help"); | |
1755 | PrintAndLog(" c <clock> enter the a clock (omit to autodetect)"); | |
1756 | PrintAndLog(" l <fc_low> enter a field clock (omit to autodetect)"); | |
1757 | PrintAndLog(" f <fc_high> enter a field clock (omit to autodetect)"); | |
1758 | return 0; | |
1759 | } | |
1760 | ||
1761 | int CmdFSKToNRZ(const char *Cmd) { | |
1762 | // take clk, fc_low, fc_high | |
1763 | // blank = auto; | |
1764 | bool errors = false; | |
1765 | int clk = 0; | |
1766 | char cmdp = 0; | |
1767 | int fc_low = 10, fc_high = 8; | |
1768 | while(param_getchar(Cmd, cmdp) != 0x00) | |
1769 | { | |
1770 | switch(param_getchar(Cmd, cmdp)) | |
1771 | { | |
1772 | case 'h': | |
1773 | case 'H': | |
1774 | return usage_data_fsktonrz(); | |
1775 | case 'C': | |
1776 | case 'c': | |
1777 | clk = param_get32ex(Cmd, cmdp+1, 0, 10); | |
1778 | cmdp += 2; | |
1779 | break; | |
1780 | case 'F': | |
1781 | case 'f': | |
1782 | fc_high = param_get32ex(Cmd, cmdp+1, 0, 10); | |
1783 | cmdp += 2; | |
1784 | break; | |
1785 | case 'L': | |
1786 | case 'l': | |
1787 | fc_low = param_get32ex(Cmd, cmdp+1, 0, 10); | |
1788 | cmdp += 2; | |
1789 | break; | |
1790 | default: | |
1791 | PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); | |
1792 | errors = true; | |
1793 | break; | |
1794 | } | |
1795 | if(errors) break; | |
1796 | } | |
1797 | //Validations | |
1798 | if(errors) return usage_data_fsktonrz(); | |
1799 | ||
1800 | setClockGrid(0,0); | |
1801 | DemodBufferLen = 0; | |
1802 | int ans = FSKToNRZ(GraphBuffer, &GraphTraceLen, clk, fc_low, fc_high); | |
1803 | CmdNorm(""); | |
1804 | RepaintGraphWindow(); | |
1805 | return ans; | |
1806 | } | |
1807 | ||
1808 | ||
ba1a299c | 1809 | static command_t CommandTable[] = |
7fe9b0b7 | 1810 | { |
e0165dcf | 1811 | {"help", CmdHelp, 1, "This help"}, |
49bbc60a | 1812 | {"askedgedetect", CmdAskEdgeDetect, 1, "[threshold] Adjust Graph for manual ask demod using the length of sample differences to detect the edge of a wave (use 20-45, def:25)"}, |
e0165dcf | 1813 | {"autocorr", CmdAutoCorr, 1, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"}, |
fef74fdc | 1814 | {"biphaserawdecode",CmdBiphaseDecodeRaw,1, "[offset] [invert<0|1>] [maxErr] -- Biphase decode bin stream in DemodBuffer (offset = 0|1 bits to shift the decode start)"}, |
5d01f50a | 1815 | {"bin2hex", Cmdbin2hex, 1, "bin2hex <digits> -- Converts binary to hexadecimal"}, |
e0165dcf | 1816 | {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, |
e0165dcf | 1817 | {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"}, |
1818 | {"dec", CmdDec, 1, "Decimate samples"}, | |
1819 | {"detectclock", CmdDetectClockRate, 1, "[modulation] Detect clock rate of wave in GraphBuffer (options: 'a','f','n','p' for ask, fsk, nrz, psk respectively)"}, | |
0e2ddb41 | 1820 | {"fsktonrz", CmdFSKToNRZ, 1, "Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)"}, |
e0165dcf | 1821 | {"getbitstream", CmdGetBitStream, 1, "Convert GraphBuffer's >=1 values to 1 and <1 to 0"}, |
1822 | {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"}, | |
1823 | {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"}, | |
f6821167 | 1824 | {"hex2bin", Cmdhex2bin, 1, "hex2bin <hexadecimal> -- Converts hexadecimal to binary"}, |
e0165dcf | 1825 | {"hide", CmdHide, 1, "Hide graph window"}, |
1826 | {"hpf", CmdHpf, 1, "Remove DC offset from trace"}, | |
1827 | {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"}, | |
1828 | {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"}, | |
1829 | {"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"}, | |
f75b313b | 1830 | {"mtrim", CmdMtrim, 1, "<start> <stop> -- Trim out samples from the specified start to the specified stop"}, |
fef74fdc | 1831 | {"manrawdecode", Cmdmandecoderaw, 1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"}, |
e0165dcf | 1832 | {"norm", CmdNorm, 1, "Normalize max/min to +/-128"}, |
1833 | {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, | |
ace26dbd | 1834 | {"printdemodbuffer",CmdPrintDemodBuff, 1, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"}, |
e0165dcf | 1835 | {"rawdemod", CmdRawDemod, 1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"}, |
1836 | {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"}, | |
1837 | {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"}, | |
f9f0e83b | 1838 | {"setgraphmarkers", CmdSetGraphMarkers, 1, "[orange_marker] [blue_marker] (in graph window)"}, |
e0165dcf | 1839 | {"scale", CmdScale, 1, "<int> -- Set cursor display scale"}, |
709665b5 | 1840 | {"setdebugmode", CmdSetDebugMode, 1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"}, |
e0165dcf | 1841 | {"shiftgraphzero", CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"}, |
e0165dcf | 1842 | {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, |
1843 | {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, | |
1844 | {"undec", CmdUndec, 1, "Un-decimate samples by 2"}, | |
1845 | {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"}, | |
1846 | {NULL, NULL, 0, NULL} | |
7fe9b0b7 | 1847 | }; |
1848 | ||
1849 | int CmdData(const char *Cmd) | |
1850 | { | |
e0165dcf | 1851 | CmdsParse(CommandTable, Cmd); |
1852 | return 0; | |
7fe9b0b7 | 1853 | } |
1854 | ||
1855 | int CmdHelp(const char *Cmd) | |
1856 | { | |
e0165dcf | 1857 | CmdsHelp(CommandTable); |
1858 | return 0; | |
7fe9b0b7 | 1859 | } |