]>
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 | // Graph utilities | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
7fe9b0b7 | 11 | #include <stdio.h> |
c6be64da | 12 | #include <stdbool.h> |
7fe9b0b7 | 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; | |
a61b4976 | 24 | int half = (int)(clock/2); |
25 | int firstbit = bit ^ 1; | |
26 | ||
27 | for (i = 0; i < half; ++i) | |
28 | GraphBuffer[GraphTraceLen++] = firstbit; | |
7fe9b0b7 | 29 | |
a61b4976 | 30 | for (i = 0; i <= half; ++i) |
7fe9b0b7 | 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; | |
2ae8a312 | 41 | memset(GraphBuffer, 0x00, GraphTraceLen); |
7fe9b0b7 | 42 | |
2ae8a312 | 43 | GraphTraceLen = 0; |
44 | ||
7fe9b0b7 | 45 | if (redraw) |
46 | RepaintGraphWindow(); | |
47 | ||
48 | return gtl; | |
49 | } | |
50 | ||
51 | /* | |
52 | * Detect clock rate | |
53 | */ | |
1b492a97 | 54 | //decommissioned - has difficulty detecting rf/32 and only works if data is manchester encoded |
55 | /* | |
56 | int DetectClock2(int peak) | |
7fe9b0b7 | 57 | { |
58 | int i; | |
59 | int clock = 0xFFFF; | |
60 | int lastpeak = 0; | |
61 | ||
1b492a97 | 62 | // Detect peak if we don't have one |
7fe9b0b7 | 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 | { | |
1b492a97 | 70 | // If this is the beginning of a peak |
71 | if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak) | |
7fe9b0b7 | 72 | { |
1b492a97 | 73 | // Find lowest difference between peaks |
7fe9b0b7 | 74 | if (lastpeak && i - lastpeak < clock) |
75 | clock = i - lastpeak; | |
76 | lastpeak = i; | |
77 | } | |
78 | } | |
a61b4976 | 79 | |
a61b4976 | 80 | return clock; |
1b492a97 | 81 | } |
82 | */ | |
a61b4976 | 83 | |
1b492a97 | 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) | |
a61b4976 | 88 | { |
1b492a97 | 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]; | |
7fe9b0b7 | 152 | } |
1b492a97 | 153 | |
7fe9b0b7 | 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); | |
1b492a97 | 168 | //clock2 = DetectClock2(peak); |
7fe9b0b7 | 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 | } | |
c6be64da | 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 | } |