cvs.zerfleddert.de Git - proxmark3-svn/blob - client/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
  11 #include <stdio.h>
  12 #include <stdbool.h>
  13 #include <string.h>
  14 #include "ui.h"
  15 #include "graph.h"
  16
  17 int GraphBuffer[MAX_GRAPH_TRACE_LEN];
  18 int GraphTraceLen;
  19
  20 /* write a bit to the graph */
  21 void AppendGraph(int redraw, int clock, int bit)
  22 {
  23   int i;
  24   int half = (int)(clock/2);
  25   int firstbit = bit ^ 1;
  26
  27   for (i = 0; i < half; ++i)
  28     GraphBuffer[GraphTraceLen++] = firstbit;
  29
  30   for (i = 0; i <= half; ++i)
  31     GraphBuffer[GraphTraceLen++] = bit;
  32
  33   if (redraw)
  34     RepaintGraphWindow();
  35 }
  36
  37 /* clear out our graph window */
  38 int ClearGraph(int redraw)
  39 {
  40   int gtl = GraphTraceLen;
  41   memset(GraphBuffer, 0x00, GraphTraceLen);
  42
  43   GraphTraceLen = 0;
  44
  45   if (redraw)
  46     RepaintGraphWindow();
  47
  48   return gtl;
  49 }
  50
  51 /*
  52  * Detect clock rate
  53  */
  54  //decommissioned - has difficulty detecting rf/32 and only works if data is manchester encoded
  55 /*
  56 int DetectClock2(int peak)
  57 {
  58   int i;
  59   int clock = 0xFFFF;
  60   int lastpeak = 0;
  61
  62   // Detect peak if we don't have one
  63   if (!peak)
  64     for (i = 0; i < GraphTraceLen; ++i)
  65       if (GraphBuffer[i] > peak)
  66         peak = GraphBuffer[i];
  67
  68   for (i = 1; i < GraphTraceLen; ++i)
  69   {
  70     // If this is the beginning of a peak
  71     if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak)
  72     {
  73       // Find lowest difference between peaks
  74       if (lastpeak && i - lastpeak < clock)
  75         clock = i - lastpeak;
  76       lastpeak = i;
  77     }
  78   }
  79
  80                 return clock;
  81 }
  82 */
  83
  84 // by marshmellow
  85 // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
  86 // maybe somehow adjust peak trimming value based on samples to fix?
  87 int DetectClock(int peak)
  88         {
  89   int i=0;
  90   int low=0;
  91   int clk[]={16,32,40,50,64,100,128,256};
  92   if (!peak){
  93     for (i=0;i<GraphTraceLen;++i){
  94       if(GraphBuffer[i]>peak){
  95         peak = GraphBuffer[i];
  96       }
  97       if(GraphBuffer[i]<low){
  98         low = GraphBuffer[i];
  99       }
 100     }
 101     peak=(int)(peak*.75);
 102     low= (int)(low*.75);
 103   }
 104   //int numbits;
 105   int ii;
 106   int loopCnt = 256;
 107   if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
 108   int clkCnt;
 109   int tol = 0;
 110   int bestErr=1000;
 111   int errCnt[]={0,0,0,0,0,0,0,0};
 112  // int good;
 113   for(clkCnt=0; clkCnt<6;++clkCnt){
 114     if (clk[clkCnt]==32){
 115       tol=1;
 116     }else{
 117       tol=0;
 118     }
 119     bestErr=1000;
 120     for (ii=0; ii<loopCnt; ++ii){
 121       if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
 122         //numbits=0;
 123         //good=1;
 124         errCnt[clkCnt]=0;
 125         for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
 126           if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
 127             //numbits++;
 128           }else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
 129           }else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
 130           }else{  //error no peak detected
 131             //numbits=0;
 132             //good=0;
 133             errCnt[clkCnt]++;
 134             //break;
 135           }
 136         }
 137         if(errCnt[clkCnt]==0) return clk[clkCnt];
 138         if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
 139       }
 140     }
 141     errCnt[clkCnt]=bestErr;
 142   }
 143   int iii=0;
 144   int best=0;
 145   for (iii=0; iii<6;++iii){
 146     if (errCnt[iii]<errCnt[best]){
 147       best = iii;
 148     }
 149   }
 150   PrintAndLog("clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
 151   return clk[best];
 152 }
 153
 154
 155 /* Get or auto-detect clock rate */
 156 int GetClock(const char *str, int peak, int verbose)
 157 {
 158   int clock;
 159
 160   sscanf(str, "%i", &clock);
 161   if (!strcmp(str, ""))
 162     clock = 0;
 163
 164   /* Auto-detect clock */
 165   if (!clock)
 166   {
 167     clock = DetectClock(peak);
 168     //clock2 = DetectClock2(peak);
 169     /* Only print this message if we're not looping something */
 170     if (!verbose)
 171       PrintAndLog("Auto-detected clock rate: %d", clock);
 172   }
 173
 174   return clock;
 175 }
 176
 177
 178 /* A simple test to see if there is any data inside Graphbuffer.
 179 */
 180 bool HasGraphData(){
 181
 182         if ( GraphTraceLen <= 0) {
 183                 PrintAndLog("No data available, try reading something first");
 184                 return false;
 185         }
 186         return true;
 187 }