-
-/*
- * Generic command to demodulate ASK. bit length in argument.
- * Giving the bit length helps discriminate ripple effects
- * upon zero crossing for noisy traces.
- *
- * Second is convention: positive or negative (High mod means zero
- * or high mod means one)
- *
- * Updates the Graph trace with 0/1 values
- *
- * Arguments:
- * sl : bit length in terms of number of samples per bit
- * (use yellow/purple markers to compute).
- * c : 0 or 1
- */
-
-static void Cmdaskdemod(char *str) {
- int i;
- int sign = 1;
- int n = 0;
- int c = 0;\r
- int t1 = 0;
-
- // TODO: complain if we do not give 2 arguments here !
- sscanf(str, "%i %i", &n, &c);
- if (c == 0) {
- c = 1 ;
- } else {
- c = -1;
- }
-
- if (GraphBuffer[0]*c > 0) {
- GraphBuffer[0] = 1;
- } else {
- GraphBuffer[0] = 0;
- }
- for(i=1;i<GraphTraceLen;i++) {
- /* Analyse signal within the symbol length */
- /* Decide if we crossed a zero */
- if (GraphBuffer[i]*sign < 0) {
- /* Crossed a zero, check if this is a ripple or not */
- if ( (i-t1) > n/4 ) {
- sign = -sign;
- t1=i;
- if (GraphBuffer[i]*c > 0){
- GraphBuffer[i]=1;
- } else {
- GraphBuffer[i]=0;
- }
- } else {
- /* This is a ripple, set the current sample value
- to the same as previous */
- GraphBuffer[i] = GraphBuffer[i-1];
- }
- } else {
- GraphBuffer[i] = GraphBuffer[i-1];
- }
- }
- RepaintGraphWindow();
-}
-
-
-/*
- * Manchester demodulate a bitstream. The bitstream needs to be already in
- * the GraphBuffer as 0 and 1 values
- *
- * Give the clock rate as argument in order to help the sync - the algorithm
- * resyncs at each pulse anyway.
- *
- * Not optimized by any means, this is the 1st time I'm writing this type of
- * routine, feel free to improve...
- *
- * 1st argument: clock rate (as number of samples per clock rate)
- */
-static void Cmdmanchesterdemod(char *str) {
- int i;
- int clock;
- int lastval;
- int lc = 0;
- int bitidx = 0;
- int bitidx2;
-
-
- sscanf(str, "%i", &clock);
-
- int tolerance = clock/4;
- /* Holds the decoded bitstream. */
- int BitStream[MAX_GRAPH_TRACE_LEN*2];
- int BitStream2[MAX_GRAPH_TRACE_LEN];
-
- /* Detect first transition */
- /* Lo-Hi (arbitrary) */
- for(i=1;i<GraphTraceLen;i++) {
- if (GraphBuffer[i-1]<GraphBuffer[i]) {
- lastval = i;
- BitStream[0]=0; // Previous state = 0;
- break;
- }
- }
-
- /* Then detect duration between 2 successive transitions */
- /* At this stage, GraphTrace is either 0 or 1 */
- for(bitidx = 1 ;i<GraphTraceLen;i++) {
- if (GraphBuffer[i-1] != GraphBuffer[i]) {
- lc = i-lastval;
- lastval = i;
- // Then switch depending on lc length:
- // Tolerance is 1/4 of clock rate (arbitrary)
- if ((lc-clock/2) < tolerance) {
- // Short pulse
- BitStream[bitidx++]=GraphBuffer[i-1];
- } else if ((lc-clock) < tolerance) {
- // Long pulse
- BitStream[bitidx++]=GraphBuffer[i-1];
- BitStream[bitidx++]=GraphBuffer[i-1];
- } else {
- // Error
- PrintToScrollback("Warning: Manchester decode error for pulse width detection.");
- PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
- }
- }
- }
-
- // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
- for (bitidx2 = 0; bitidx2<bitidx; bitidx2 += 2) {
- if ((BitStream[bitidx2] == 0) && (BitStream[bitidx2+1] == 1)) {
- BitStream2[bitidx2/2] = 1;
- } else if ((BitStream[bitidx2] == 1) && (BitStream[bitidx2+1] == 0)) {
- BitStream2[bitidx2/2] = 0;
- } else {
- // We cannot end up in this state, this means we are unsynchronized,
- // move up 1 bit:
- bitidx2++;
- PrintToScrollback("Unsynchronized, resync...");
- PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");
- }
- }
- PrintToScrollback("Manchester decoded bitstream \n---------");
- // Now output the bitstream to the scrollback by line of 16 bits
- for (i = 0; i<bitidx/2; i+=16) {
- PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
- BitStream2[i],
- BitStream2[i+1],
- BitStream2[i+2],
- BitStream2[i+3],
- BitStream2[i+4],
- BitStream2[i+5],
- BitStream2[i+6],
- BitStream2[i+7],
- BitStream2[i+8],
- BitStream2[i+9],
- BitStream2[i+10],
- BitStream2[i+11],
- BitStream2[i+12],
- BitStream2[i+13],
- BitStream2[i+14],
- BitStream2[i+15]);
- }
-}
-
-
-
-/*
- * Usage ???
+\r
+/*\r
+ * Generic command to demodulate ASK.\r
+ *\r
+ * Argument is convention: positive or negative (High mod means zero\r
+ * or high mod means one)\r
+ *\r
+ * Updates the Graph trace with 0/1 values\r
+ *\r
+ * Arguments:\r
+ * c : 0 or 1\r
+ */\r
+\r
+static void Cmdaskdemod(char *str) {\r
+ int i;\r
+ int n = 0;\r
+ int c,high,low = 0;\r
+\r
+ // TODO: complain if we do not give 2 arguments here !\r
+ sscanf(str, "%i", &c);\r
+\r
+ /* Detect high and lows and clock */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ if (GraphBuffer[0] > 0) {\r
+ GraphBuffer[0] = 1-c;\r
+ } else {\r
+ GraphBuffer[0] = c;\r
+ }\r
+ for(i=1;i<GraphTraceLen;i++) {\r
+ /* Transitions are detected at each peak\r
+ * Transitions are either:\r
+ * - we're low: transition if we hit a high\r
+ * - we're high: transition if we hit a low\r
+ * (we need to do it this way because some tags keep high or\r
+ * low for long periods, others just reach the peak and go\r
+ * down)\r
+ */\r
+ if ((GraphBuffer[i]==high) && (GraphBuffer[i-1] == c)) {\r
+ GraphBuffer[i]=1-c;\r
+ } else if ((GraphBuffer[i]==low) && (GraphBuffer[i-1] == (1-c))){\r
+ GraphBuffer[i] = c;\r
+ } else {\r
+ /* No transition */\r
+ GraphBuffer[i] = GraphBuffer[i-1];\r
+ }\r
+ }\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/* Print our clock rate */\r
+static void Cmddetectclockrate(char *str)\r
+{\r
+ int clock = detectclock(0);\r
+ PrintToScrollback("Auto-detected clock rate: %d", clock);\r
+}\r
+\r
+/*\r
+ * Detect clock rate\r
+ */\r
+int detectclock(int peak)\r
+{\r
+ int i;\r
+ int clock = 0xFFFF;\r
+ int lastpeak = 0;\r
+\r
+ /* Detect peak if we don't have one */\r
+ if (!peak)\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ if (GraphBuffer[i] > peak)\r
+ peak = GraphBuffer[i];\r
+\r
+ for (i = 1; i < GraphTraceLen; i++)\r
+ {\r
+ /* If this is the beginning of a peak */\r
+ if (GraphBuffer[i-1] != GraphBuffer[i] && GraphBuffer[i] == peak)\r
+ {\r
+ /* Find lowest difference between peaks */\r
+ if (lastpeak && i - lastpeak < clock)\r
+ {\r
+ clock = i - lastpeak;\r
+ }\r
+ lastpeak = i;\r
+ }\r
+ }\r
+\r
+ return clock;\r
+}\r
+\r
+/* Get or auto-detect clock rate */\r
+int GetClock(char *str, int peak)\r
+{\r
+ int clock;\r
+\r
+ sscanf(str, "%i", &clock);\r
+ if (!strcmp(str, ""))\r
+ clock = 0;\r
+\r
+ /* Auto-detect clock */\r
+ if (!clock)\r
+ {\r
+ clock = detectclock(peak);\r
+\r
+ /* Only print this message if we're not looping something */\r
+ if (!go)\r
+ PrintToScrollback("Auto-detected clock rate: %d", clock);\r
+ }\r
+\r
+ return clock;\r
+}\r
+\r
+/*\r
+ * Convert to a bitstream\r
+ */\r
+static void Cmdbitstream(char *str) {\r
+ int i, j;\r
+ int bit;\r
+ int gtl;\r
+ int clock;\r
+ int low = 0;\r
+ int high = 0;\r
+ int hithigh, hitlow, first;\r
+\r
+ /* Detect high and lows and clock */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, high);\r
+\r
+ gtl = CmdClearGraph(0);\r
+\r
+ bit = 0;\r
+ for (i = 0; i < (int)(gtl / clock); i++)\r
+ {\r
+ hithigh = 0;\r
+ hitlow = 0;\r
+ first = 1;\r
+\r
+ /* Find out if we hit both high and low peaks */\r
+ for (j = 0; j < clock; j++)\r
+ {\r
+ if (GraphBuffer[(i * clock) + j] == high)\r
+ hithigh = 1;\r
+ else if (GraphBuffer[(i * clock) + j] == low)\r
+ hitlow = 1;\r
+\r
+ /* it doesn't count if it's the first part of our read\r
+ because it's really just trailing from the last sequence */\r
+ if (first && (hithigh || hitlow))\r
+ hithigh = hitlow = 0;\r
+ else\r
+ first = 0;\r
+\r
+ if (hithigh && hitlow)\r
+ break;\r
+ }\r
+\r
+ /* If we didn't hit both high and low peaks, we had a bit transition */\r
+ if (!hithigh || !hitlow)\r
+ bit ^= 1;\r
+\r
+ CmdAppendGraph(0, clock, bit);\r
+// for (j = 0; j < (int)(clock/2); j++)\r
+// GraphBuffer[(i * clock) + j] = bit ^ 1;\r
+// for (j = (int)(clock/2); j < clock; j++)\r
+// GraphBuffer[(i * clock) + j] = bit;\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/* Modulate our data into manchester */\r
+static void Cmdmanchestermod(char *str)\r
+{\r
+ int i, j;\r
+ int clock;\r
+ int bit, lastbit, wave;\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, 0);\r
+\r
+ wave = 0;\r
+ lastbit = 1;\r
+ for (i = 0; i < (int)(GraphTraceLen / clock); i++)\r
+ {\r
+ bit = GraphBuffer[i * clock] ^ 1;\r
+\r
+ for (j = 0; j < (int)(clock/2); j++)\r
+ GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;\r
+ for (j = (int)(clock/2); j < clock; j++)\r
+ GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;\r
+\r
+ /* Keep track of how we start our wave and if we changed or not this time */\r
+ wave ^= bit ^ lastbit;\r
+ lastbit = bit;\r
+ }\r
+\r
+ RepaintGraphWindow();\r
+}\r
+\r
+/*\r
+ * Manchester demodulate a bitstream. The bitstream needs to be already in\r
+ * the GraphBuffer as 0 and 1 values\r
+ *\r
+ * Give the clock rate as argument in order to help the sync - the algorithm\r
+ * resyncs at each pulse anyway.\r
+ *\r
+ * Not optimized by any means, this is the 1st time I'm writing this type of\r
+ * routine, feel free to improve...\r
+ *\r
+ * 1st argument: clock rate (as number of samples per clock rate)\r
+ * Typical values can be 64, 32, 128...\r
+ */\r
+static void Cmdmanchesterdemod(char *str) {\r
+ int i, j;\r
+ int bit;\r
+ int clock;\r
+ int lastval;\r
+ int low = 0;\r
+ int high = 0;\r
+ int hithigh, hitlow, first;\r
+ int lc = 0;\r
+ int bitidx = 0;\r
+ int bit2idx = 0;\r
+ int warnings = 0;\r
+\r
+ /* Holds the decoded bitstream: each clock period contains 2 bits */\r
+ /* later simplified to 1 bit after manchester decoding. */\r
+ /* Add 10 bits to allow for noisy / uncertain traces without aborting */\r
+ /* int BitStream[GraphTraceLen*2/clock+10]; */\r
+\r
+ /* But it does not work if compiling on WIndows: therefore we just allocate a */\r
+ /* large array */\r
+ int BitStream[MAX_GRAPH_TRACE_LEN];\r
+\r
+ /* Detect high and lows */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] > high)\r
+ high = GraphBuffer[i];\r
+ else if (GraphBuffer[i] < low)\r
+ low = GraphBuffer[i];\r
+ }\r
+\r
+ /* Get our clock */\r
+ clock = GetClock(str, high);\r
+\r
+ int tolerance = clock/4;\r
+\r
+ /* Detect first transition */\r
+ /* Lo-Hi (arbitrary) */\r
+ for (i = 0; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i] == low)\r
+ {\r
+ lastval = i;\r
+ break;\r
+ }\r
+ }\r
+\r
+ /* If we're not working with 1/0s, demod based off clock */\r
+ if (high != 1)\r
+ {\r
+ bit = 0; /* We assume the 1st bit is zero, it may not be\r
+ * the case: this routine (I think) has an init problem.\r
+ * Ed.\r
+ */\r
+ for (; i < (int)(GraphTraceLen / clock); i++)\r
+ {\r
+ hithigh = 0;\r
+ hitlow = 0;\r
+ first = 1;\r
+\r
+ /* Find out if we hit both high and low peaks */\r
+ for (j = 0; j < clock; j++)\r
+ {\r
+ if (GraphBuffer[(i * clock) + j] == high)\r
+ hithigh = 1;\r
+ else if (GraphBuffer[(i * clock) + j] == low)\r
+ hitlow = 1;\r
+\r
+ /* it doesn't count if it's the first part of our read\r
+ because it's really just trailing from the last sequence */\r
+ if (first && (hithigh || hitlow))\r
+ hithigh = hitlow = 0;\r
+ else\r
+ first = 0;\r
+\r
+ if (hithigh && hitlow)\r
+ break;\r
+ }\r
+\r
+ /* If we didn't hit both high and low peaks, we had a bit transition */\r
+ if (!hithigh || !hitlow)\r
+ bit ^= 1;\r
+\r
+ BitStream[bit2idx++] = bit;\r
+ }\r
+ }\r
+\r
+ /* standard 1/0 bitstream */\r
+ else\r
+ {\r
+\r
+ /* Then detect duration between 2 successive transitions */\r
+ for (bitidx = 1; i < GraphTraceLen; i++)\r
+ {\r
+ if (GraphBuffer[i-1] != GraphBuffer[i])\r
+ {\r
+ lc = i-lastval;\r
+ lastval = i;\r
+\r
+ // Error check: if bitidx becomes too large, we do not\r
+ // have a Manchester encoded bitstream or the clock is really\r
+ // wrong!\r
+ if (bitidx > (GraphTraceLen*2/clock+8) ) {\r
+ PrintToScrollback("Error: the clock you gave is probably wrong, aborting.");\r
+ return;\r
+ }\r
+ // Then switch depending on lc length:\r
+ // Tolerance is 1/4 of clock rate (arbitrary)\r
+ if (abs(lc-clock/2) < tolerance) {\r
+ // Short pulse : either "1" or "0"\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ } else if (abs(lc-clock) < tolerance) {\r
+ // Long pulse: either "11" or "00"\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ BitStream[bitidx++]=GraphBuffer[i-1];\r
+ } else {\r
+ // Error\r
+ warnings++;\r
+ PrintToScrollback("Warning: Manchester decode error for pulse width detection.");\r
+ PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");\r
+\r
+ if (warnings > 100)\r
+ {\r
+ PrintToScrollback("Error: too many detection errors, aborting.");\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream\r
+ // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful\r
+ // to stop output at the final bitidx2 value, not bitidx\r
+ for (i = 0; i < bitidx; i += 2) {\r
+ if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {\r
+ BitStream[bit2idx++] = 1;\r
+ } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {\r
+ BitStream[bit2idx++] = 0;\r
+ } else {\r
+ // We cannot end up in this state, this means we are unsynchronized,\r
+ // move up 1 bit:\r
+ i++;\r
+ warnings++;\r
+ PrintToScrollback("Unsynchronized, resync...");\r
+ PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");\r
+\r
+ if (warnings > 100)\r
+ {\r
+ PrintToScrollback("Error: too many decode errors, aborting.");\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ PrintToScrollback("Manchester decoded bitstream");\r
+ // Now output the bitstream to the scrollback by line of 16 bits\r
+ for (i = 0; i < (bit2idx-16); i+=16) {\r
+ PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",\r
+ BitStream[i],\r
+ BitStream[i+1],\r
+ BitStream[i+2],\r
+ BitStream[i+3],\r
+ BitStream[i+4],\r
+ BitStream[i+5],\r
+ BitStream[i+6],\r
+ BitStream[i+7],\r
+ BitStream[i+8],\r
+ BitStream[i+9],\r
+ BitStream[i+10],\r
+ BitStream[i+11],\r
+ BitStream[i+12],\r
+ BitStream[i+13],\r
+ BitStream[i+14],\r
+ BitStream[i+15]);\r
+ }\r
+}\r
+\r
+\r
+\r
+/*\r
+ * Usage ???\r
projects / proxmark3-svn / blobdiff