client/src/graph.c

   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 // Graph utilities
   9 //-----------------------------------------------------------------------------
  10 #include "graph.h"
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include "ui.h"
  14 #include "proxgui.h"
  15 #include "util.h"    //param_get32ex
  16 #include "lfdemod.h"
  17 #include "cmddata.h" //for g_debugmode
  18
  19
  20 int GraphBuffer[MAX_GRAPH_TRACE_LEN];
  21 size_t GraphTraceLen;
  22
  23 /* write a manchester bit to the graph
  24 TODO,  verfy that this doesn't overflow buffer  (iceman)
  25 */
  26 void AppendGraph(bool redraw, uint16_t clock, int bit) {
  27     uint8_t half = clock / 2;
  28     uint8_t i;
  29     //set first half the clock bit (all 1's or 0's for a 0 or 1 bit)
  30     for (i = 0; i < half; ++i)
  31         GraphBuffer[GraphTraceLen++] = bit;
  32
  33     //set second half of the clock bit (all 0's or 1's for a 0 or 1 bit)
  34     for (; i < clock; ++i)
  35         GraphBuffer[GraphTraceLen++] = bit ^ 1;
  36
  37     if (redraw)
  38         RepaintGraphWindow();
  39 }
  40
  41 // clear out our graph window
  42 size_t ClearGraph(bool redraw) {
  43     size_t gtl = GraphTraceLen;
  44     memset(GraphBuffer, 0x00, GraphTraceLen);
  45     GraphTraceLen = 0;
  46     if (redraw)
  47         RepaintGraphWindow();
  48     return gtl;
  49 }
  50 // option '1' to save GraphBuffer any other to restore
  51 void save_restoreGB(uint8_t saveOpt) {
  52     static int SavedGB[MAX_GRAPH_TRACE_LEN];
  53     static size_t SavedGBlen = 0;
  54     static bool GB_Saved = false;
  55     static int SavedGridOffsetAdj = 0;
  56
  57     if (saveOpt == GRAPH_SAVE) { //save
  58         memcpy(SavedGB, GraphBuffer, sizeof(GraphBuffer));
  59         SavedGBlen = GraphTraceLen;
  60         GB_Saved = true;
  61         SavedGridOffsetAdj = GridOffset;
  62     } else if (GB_Saved) { //restore
  63         memcpy(GraphBuffer, SavedGB, sizeof(GraphBuffer));
  64         GraphTraceLen = SavedGBlen;
  65         GridOffset = SavedGridOffsetAdj;
  66         RepaintGraphWindow();
  67     }
  68 }
  69
  70 void setGraphBuf(uint8_t *buff, size_t size) {
  71     if (buff == NULL) return;
  72
  73     ClearGraph(false);
  74
  75     if (size > MAX_GRAPH_TRACE_LEN)
  76         size = MAX_GRAPH_TRACE_LEN;
  77
  78     for (size_t i = 0; i < size; ++i)
  79         GraphBuffer[i] = buff[i] - 128;
  80
  81     GraphTraceLen = size;
  82     RepaintGraphWindow();
  83 }
  84
  85 size_t getFromGraphBuf(uint8_t *buff) {
  86     if (buff == NULL) return 0;
  87     if (GraphTraceLen == 0) return 0;
  88
  89     size_t i;
  90     for (i = 0; i < GraphTraceLen; ++i) {
  91         //trim
  92         if (GraphBuffer[i] > 127) GraphBuffer[i] = 127;
  93         if (GraphBuffer[i] < -127) GraphBuffer[i] = -127;
  94         buff[i] = (uint8_t)(GraphBuffer[i] + 128);
  95     }
  96     return i;
  97 }
  98
  99 // A simple test to see if there is any data inside Graphbuffer.
 100 bool HasGraphData(void) {
 101     if (GraphTraceLen == 0) {
 102         PrintAndLogEx(NORMAL, "No data available, try reading something first");
 103         return false;
 104     }
 105     return true;
 106 }
 107
 108 bool isGraphBitstream(void) {
 109     // convert to bitstream if necessary
 110     for (int i = 0; i < GraphTraceLen; i++) {
 111         if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0) {
 112             return false;
 113         }
 114     }
 115     return true;
 116 }
 117
 118 void convertGraphFromBitstream(void) {
 119     convertGraphFromBitstreamEx(1, 0);
 120 }
 121
 122 void convertGraphFromBitstreamEx(int hi, int low) {
 123     for (int i = 0; i < GraphTraceLen; i++) {
 124         if (GraphBuffer[i] == hi)
 125             GraphBuffer[i] = 127;
 126         else if (GraphBuffer[i] == low)
 127             GraphBuffer[i] = -127;
 128         else
 129             GraphBuffer[i] = 0;
 130     }
 131
 132     uint8_t *bits = calloc(GraphTraceLen, sizeof(uint8_t));
 133     if (bits == NULL) {
 134         PrintAndLogEx(DEBUG, "ERR: convertGraphFromBitstreamEx, failed to allocate memory");
 135         return;
 136     }
 137
 138     size_t size = getFromGraphBuf(bits);
 139     if (size == 0) {
 140         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 141         free(bits);
 142         return;
 143     }
 144
 145     // set signal properties low/high/mean/amplitude and is_noise detection
 146     computeSignalProperties(bits, size);
 147     free(bits);
 148     RepaintGraphWindow();
 149 }
 150
 151 // Get or auto-detect ask clock rate
 152 int GetAskClock(const char *str, bool verbose) {
 153     if (getSignalProperties()->isnoise)
 154         return -1;
 155
 156     int clock1 = param_get32ex(str, 0, 0, 10);
 157     if (clock1 > 0)
 158         return clock1;
 159
 160     // Auto-detect clock
 161
 162     uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN,  sizeof(uint8_t));
 163     if (bits == NULL) {
 164         PrintAndLogEx(WARNING, "Failed to allocate memory");
 165         return -1;
 166     }
 167
 168     size_t size = getFromGraphBuf(bits);
 169     if (size == 0) {
 170         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 171         free(bits);
 172         return -1;
 173     }
 174
 175     size_t ststart = 0, stend = 0;
 176     bool st = DetectST(bits, &size, &clock1, &ststart, &stend);
 177     int idx = stend;
 178     if (st == false) {
 179         idx = DetectASKClock(bits, size, &clock1, 20);
 180     }
 181
 182     if (clock1 > 0) {
 183         setClockGrid(clock1, idx);
 184     }
 185     // Only print this message if we're not looping something
 186     if (verbose || g_debugMode)
 187         PrintAndLogEx(SUCCESS, "Auto-detected clock rate: %d, Best Starting Position: %d", clock1, idx);
 188
 189     free(bits);
 190     return clock1;
 191 }
 192
 193 int GetPskCarrier(bool verbose) {
 194     if (getSignalProperties()->isnoise)
 195         return -1;
 196
 197     uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN,  sizeof(uint8_t));
 198     if (bits == NULL) {
 199         PrintAndLogEx(WARNING, "Failed to allocate memory");
 200         return -1;
 201     }
 202
 203     size_t size = getFromGraphBuf(bits);
 204     if (size == 0) {
 205         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 206         free(bits);
 207         return -1;
 208     }
 209
 210     uint16_t fc = countFC(bits, size, false);
 211     free(bits);
 212
 213     uint8_t carrier = fc & 0xFF;
 214     if (carrier != 2 && carrier != 4 && carrier != 8) return 0;
 215     if ((fc >> 8) == 10 && carrier == 8) return 0;
 216     // Only print this message if we're not looping something
 217     if (verbose)
 218         PrintAndLogEx(SUCCESS, "Auto-detected PSK carrier rate: %d", carrier);
 219
 220     return carrier;
 221 }
 222
 223 int GetPskClock(const char *str, bool verbose) {
 224
 225     if (getSignalProperties()->isnoise)
 226         return -1;
 227
 228     int clock1 = param_get32ex(str, 0, 0, 10);
 229     if (clock1 != 0)
 230         return clock1;
 231
 232     // Auto-detect clock
 233     uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN,  sizeof(uint8_t));
 234     if (bits == NULL) {
 235         PrintAndLogEx(WARNING, "Failed to allocate memory");
 236         return -1;
 237     }
 238
 239     size_t size = getFromGraphBuf(bits);
 240     if (size == 0) {
 241         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 242         free(bits);
 243         return -1;
 244     }
 245
 246     size_t firstPhaseShiftLoc = 0;
 247     uint8_t curPhase = 0, fc = 0;
 248     clock1 = DetectPSKClock(bits, size, 0, &firstPhaseShiftLoc, &curPhase, &fc);
 249
 250     if (clock1 >= 0)
 251         setClockGrid(clock1, firstPhaseShiftLoc);
 252
 253     // Only print this message if we're not looping something
 254     if (verbose)
 255         PrintAndLogEx(SUCCESS, "Auto-detected clock rate: %d", clock1);
 256
 257     free(bits);
 258     return clock1;
 259 }
 260
 261 int GetNrzClock(const char *str, bool verbose) {
 262
 263     if (getSignalProperties()->isnoise)
 264         return -1;
 265
 266     int clock1 = param_get32ex(str, 0, 0, 10);
 267     if (clock1 != 0)
 268         return clock1;
 269
 270     // Auto-detect clock
 271     uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN,  sizeof(uint8_t));
 272     if (bits == NULL) {
 273         PrintAndLogEx(WARNING, "Failed to allocate memory");
 274         return -1;
 275     }
 276
 277     size_t size = getFromGraphBuf(bits);
 278     if (size == 0) {
 279         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 280         free(bits);
 281         return -1;
 282     }
 283
 284     size_t clkStartIdx = 0;
 285     clock1 = DetectNRZClock(bits, size, 0, &clkStartIdx);
 286     setClockGrid(clock1, clkStartIdx);
 287     // Only print this message if we're not looping something
 288     if (verbose)
 289         PrintAndLogEx(SUCCESS, "Auto-detected clock rate: %d", clock1);
 290
 291     free(bits);
 292     return clock1;
 293 }
 294
 295 //by marshmellow
 296 //attempt to detect the field clock and bit clock for FSK
 297 int GetFskClock(const char *str, bool verbose) {
 298
 299     int clock1 = param_get32ex(str, 0, 0, 10);
 300     if (clock1 != 0)
 301         return clock1;
 302
 303     uint8_t fc1 = 0, fc2 = 0, rf1 = 0;
 304     int firstClockEdge = 0;
 305
 306     if (fskClocks(&fc1, &fc2, &rf1, &firstClockEdge) == false)
 307         return 0;
 308
 309     if ((fc1 == 10 && fc2 == 8) || (fc1 == 8 && fc2 == 5)) {
 310         if (verbose)
 311             PrintAndLogEx(SUCCESS, "Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
 312
 313         setClockGrid(rf1, firstClockEdge);
 314         return rf1;
 315     }
 316
 317     PrintAndLogEx(DEBUG, "DEBUG: unknown fsk field clock detected");
 318     PrintAndLogEx(DEBUG, "Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
 319     return 0;
 320 }
 321
 322 bool fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, int *firstClockEdge) {
 323
 324     if (getSignalProperties()->isnoise)
 325         return false;
 326
 327     uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN,  sizeof(uint8_t));
 328     if (bits == NULL) {
 329         PrintAndLogEx(WARNING, "Failed to allocate memory");
 330         return false;
 331     }
 332
 333     size_t size = getFromGraphBuf(bits);
 334     if (size == 0) {
 335         PrintAndLogEx(WARNING, "Failed to copy from graphbuffer");
 336         free(bits);
 337         return false;
 338     }
 339
 340     uint16_t ans = countFC(bits, size, true);
 341     if (ans == 0) {
 342         PrintAndLogEx(DEBUG, "DEBUG: No data found");
 343         free(bits);
 344         return false;
 345     }
 346
 347     *fc1 = (ans >> 8) & 0xFF;
 348     *fc2 = ans & 0xFF;
 349     *rf1 = detectFSKClk(bits, size, *fc1, *fc2, firstClockEdge);
 350
 351     free(bits);
 352
 353     if (*rf1 == 0) {
 354         PrintAndLogEx(DEBUG, "DEBUG: Clock detect error");
 355         return false;
 356     }
 357     return true;
 358 }
 359