#include "ui.h"
#include "graph.h"
#include "cmdparser.h"
+#include "util.h"
#include "cmdmain.h"
#include "cmddata.h"
+
static int CmdHelp(const char *Cmd);
int CmdAmp(const char *Cmd)
int i;
int c, high = 0, low = 0;
- // TODO: complain if we do not give 2 arguments here !
- // (AL - this doesn't make sense! we're only using one argument!!!)
sscanf(Cmd, "%i", &c);
- /* Detect high and lows and clock */
- // (AL - clock???)
+ if (c != 0 && c != 1) {
+ PrintAndLog("Invalid argument: %s", Cmd);
+ return 0;
+ }
+
+ /* Detect high and lows */
for (i = 0; i < GraphTraceLen; ++i)
{
if (GraphBuffer[i] > high)
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
- if (c != 0 && c != 1) {
- PrintAndLog("Invalid argument: %s", Cmd);
- return 0;
- }
-
+
if (GraphBuffer[0] > 0) {
GraphBuffer[0] = 1-c;
} else {
int CmdSamples(const char *Cmd)
{
- int cnt = 0;
- int n;
- uint8_t got[40000];
-
- n = strtol(Cmd, NULL, 0);
- if (n == 0) n = 512;
- if (n > sizeof(got)) n = sizeof(got);
+ uint8_t got[36440] = {0x00};
+
+ int n = strtol(Cmd, NULL, 0);
+ if (n == 0)
+ n = 16000;
+ if (n > sizeof(got))
+ n = sizeof(got);
- PrintAndLog("Reading %d samples\n", n);
- GetFromBigBuf(got,n,0);
- WaitForResponse(CMD_ACK,NULL);
- for (int j = 0; j < n; j++) {
- GraphBuffer[cnt++] = ((int)got[j]) - 128;
- }
+ PrintAndLog("Reading %d samples from device memory\n", n);
+ GetFromBigBuf(got,n,3560);
+ WaitForResponse(CMD_ACK,NULL);
+ for (int j = 0; j < n; ++j) {
+ GraphBuffer[j] = ((int)got[j]) - 128;
+ }
+ GraphTraceLen = n;
+ RepaintGraphWindow();
+ return 0;
+}
+int CmdTuneSamples(const char *Cmd)
+{
+ int timeout = 0;
+ printf("\nMeasuring antenna characteristics, please wait...");
+
+ UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING};
+ SendCommand(&c);
+
+ UsbCommand resp;
+ while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING,&resp,1000)) {
+ timeout++;
+ printf(".");
+ if (timeout > 7) {
+ PrintAndLog("\nNo response from Proxmark. Aborting...");
+ return 1;
+ }
+ }
+
+ int peakv, peakf;
+ int vLf125, vLf134, vHf;
+ vLf125 = resp.arg[0] & 0xffff;
+ vLf134 = resp.arg[0] >> 16;
+ vHf = resp.arg[1] & 0xffff;;
+ peakf = resp.arg[2] & 0xffff;
+ peakv = resp.arg[2] >> 16;
+ PrintAndLog("");
+ PrintAndLog("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0);
+ PrintAndLog("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0);
+ PrintAndLog("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));
+ PrintAndLog("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0);
+ if (peakv<2000)
+ PrintAndLog("# Your LF antenna is unusable.");
+ else if (peakv<10000)
+ PrintAndLog("# Your LF antenna is marginal.");
+ if (vHf<2000)
+ PrintAndLog("# Your HF antenna is unusable.");
+ else if (vHf<5000)
+ PrintAndLog("# Your HF antenna is marginal.");
+
+ for (int i = 0; i < 256; i++) {
+ GraphBuffer[i] = resp.d.asBytes[i] - 128;
+ }
- PrintAndLog("Done!\n");
- GraphTraceLen = n;
- RepaintGraphWindow();
+ PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
+ PrintAndLog("\n");
+ GraphTraceLen = 256;
+ ShowGraphWindow();
+
return 0;
}
+
int CmdLoad(const char *Cmd)
{
- FILE *f = fopen(Cmd, "r");
- if (!f) {
- PrintAndLog("couldn't open '%s'", Cmd);
- return 0;
- }
+ char filename[FILE_PATH_SIZE] = {0x00};
+ int len = 0;
+
+ len = strlen(Cmd);
+ if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+ memcpy(filename, Cmd, len);
+
+ FILE *f = fopen(filename, "r");
+ if (!f) {
+ PrintAndLog("couldn't open '%s'", filename);
+ return 0;
+ }
GraphTraceLen = 0;
char line[80];
/* But it does not work if compiling on WIndows: therefore we just allocate a */
/* large array */
- uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
+ uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
/* Detect high and lows */
for (i = 0; i < GraphTraceLen; i++)
}
/* Get our clock */
- clock = GetClock(Cmd, high, 1);
-
+ clock = GetClock(Cmd, high, 1);
int tolerance = clock/4;
/* Detect first transition */
break;
}
}
-
+
/* If we're not working with 1/0s, demod based off clock */
if (high != 1)
{
+ PrintAndLog("Entering path A");
bit = 0; /* We assume the 1st bit is zero, it may not be
* the case: this routine (I think) has an init problem.
* Ed.
- */
+ */
for (; i < (int)(GraphTraceLen / clock); i++)
{
hithigh = 0;
// At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
// Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
// to stop output at the final bitidx2 value, not bitidx
- for (i = 0; i < bitidx; i += 2) {
+
+ //http://www.proxmark.org/forum/viewtopic.php?id=403
+ for (i = 1; i < bitidx; i += 2) {
if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
BitStream[bit2idx++] = 1 ^ invert;
} else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
// We cannot end up in this state, this means we are unsynchronized,
// move up 1 bit:
i++;
- warnings++;
+ warnings++;
PrintAndLog("Unsynchronized, resync...");
PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
BitStream[i+14],
BitStream[i+15]);
}
- return 0;
+ return bit2idx;
}
/* Modulate our data into manchester */
int CmdManchesterMod(const char *Cmd)
{
int i, j;
- int clock;
int bit, lastbit, wave;
-
- /* Get our clock */
- clock = GetClock(Cmd, 0, 1);
-
+ int clock = GetClock(Cmd, 0, 1);
+ int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
+ PrintAndLog("MAN MOD CLOCKS: %d ice %d", clock,clock1);
+
+ int half = (int)(clock/2);
+
wave = 0;
lastbit = 1;
for (i = 0; i < (int)(GraphTraceLen / clock); i++)
{
bit = GraphBuffer[i * clock] ^ 1;
- for (j = 0; j < (int)(clock/2); j++)
+ for (j = 0; j < half; ++j)
GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
- for (j = (int)(clock/2); j < clock; j++)
+ for (j = half; j < clock; ++j)
GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
/* Keep track of how we start our wave and if we changed or not this time */
int CmdSave(const char *Cmd)
{
- FILE *f = fopen(Cmd, "w");
+ char filename[FILE_PATH_SIZE] = {0x00};
+ int len = 0;
+
+ len = strlen(Cmd);
+ if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+ memcpy(filename, Cmd, len);
+
+
+ FILE *f = fopen(filename, "w");
if(!f) {
- PrintAndLog("couldn't open '%s'", Cmd);
+ PrintAndLog("couldn't open '%s'", filename);
return 0;
}
int i;
return 0;
}
+int CmdDirectionalThreshold(const char *Cmd)
+{
+ int8_t upThres = param_get8(Cmd, 0);
+ int8_t downThres = param_get8(Cmd, 1);
+
+ printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
+
+ int lastValue = GraphBuffer[0];
+ GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
+
+ for (int i = 1; i < GraphTraceLen; ++i) {
+ // Apply first threshold to samples heading up
+ if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
+ {
+ lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+ GraphBuffer[i] = 1;
+ }
+ // Apply second threshold to samples heading down
+ else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
+ {
+ lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+ GraphBuffer[i] = -1;
+ }
+ else
+ {
+ lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+ GraphBuffer[i] = GraphBuffer[i-1];
+
+ }
+ }
+ GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
+ RepaintGraphWindow();
+ return 0;
+}
+
int CmdZerocrossings(const char *Cmd)
{
// Zero-crossings aren't meaningful unless the signal is zero-mean.
{"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
{"dec", CmdDec, 1, "Decimate samples"},
{"detectclock", CmdDetectClockRate, 1, "Detect clock rate"},
+ {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
{"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
{"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
+ {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},
{"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
{NULL, NULL, 0, NULL}
};
projects / proxmark3-svn / blobdiff