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> |
a1557c4c |
12 | #include <stdbool.h> |
7fe9b0b7 |
13 | #include <string.h> |
14 | #include "ui.h" |
15 | #include "graph.h" |
d5a72d2f |
16 | #include "lfdemod.h" |
7fe9b0b7 |
17 | |
18 | int GraphBuffer[MAX_GRAPH_TRACE_LEN]; |
19 | int GraphTraceLen; |
abd6112f |
20 | /* write a manchester bit to the graph */ |
7fe9b0b7 |
21 | void AppendGraph(int redraw, int clock, int bit) |
22 | { |
23 | int i; |
abd6112f |
24 | //set first half the clock bit (all 1's or 0's for a 0 or 1 bit) |
7fe9b0b7 |
25 | for (i = 0; i < (int)(clock / 2); ++i) |
78f5b1a7 |
26 | GraphBuffer[GraphTraceLen++] = bit ; |
abd6112f |
27 | //set second half of the clock bit (all 0's or 1's for a 0 or 1 bit) |
7fe9b0b7 |
28 | for (i = (int)(clock / 2); i < clock; ++i) |
78f5b1a7 |
29 | GraphBuffer[GraphTraceLen++] = bit ^ 1; |
7fe9b0b7 |
30 | |
31 | if (redraw) |
32 | RepaintGraphWindow(); |
33 | } |
34 | |
c12512e9 |
35 | // clear out our graph window |
7fe9b0b7 |
36 | int ClearGraph(int redraw) |
37 | { |
38 | int gtl = GraphTraceLen; |
52ab55ab |
39 | memset(GraphBuffer, 0x00, GraphTraceLen); |
40 | |
7fe9b0b7 |
41 | GraphTraceLen = 0; |
42 | |
43 | if (redraw) |
44 | RepaintGraphWindow(); |
45 | |
46 | return gtl; |
47 | } |
23f0a7d8 |
48 | // option '1' to save GraphBuffer any other to restore |
49 | void save_restoreGB(uint8_t saveOpt) |
50 | { |
51 | static int SavedGB[MAX_GRAPH_TRACE_LEN]; |
52 | static int SavedGBlen; |
53 | static bool GB_Saved = false; |
54 | |
55 | if (saveOpt==1) { //save |
2767fc02 |
56 | memcpy(SavedGB, GraphBuffer, sizeof(GraphBuffer)); |
23f0a7d8 |
57 | SavedGBlen = GraphTraceLen; |
58 | GB_Saved=true; |
49bbc60a |
59 | } else if (GB_Saved){ //restore |
2767fc02 |
60 | memcpy(GraphBuffer, SavedGB, sizeof(GraphBuffer)); |
23f0a7d8 |
61 | GraphTraceLen = SavedGBlen; |
49bbc60a |
62 | RepaintGraphWindow(); |
23f0a7d8 |
63 | } |
64 | return; |
65 | } |
7fe9b0b7 |
66 | |
c12512e9 |
67 | // DETECT CLOCK NOW IN LFDEMOD.C |
7fe9b0b7 |
68 | |
ba1a299c |
69 | void setGraphBuf(uint8_t *buff, size_t size) |
d5a72d2f |
70 | { |
a1557c4c |
71 | if ( buff == NULL ) return; |
72 | |
73 | uint16_t i = 0; |
74 | if ( size > MAX_GRAPH_TRACE_LEN ) |
75 | size = MAX_GRAPH_TRACE_LEN; |
b4fb11ba |
76 | ClearGraph(0); |
77 | for (; i < size; ++i){ |
ba1a299c |
78 | GraphBuffer[i]=buff[i]-128; |
b4fb11ba |
79 | } |
80 | GraphTraceLen=size; |
81 | RepaintGraphWindow(); |
82 | return; |
d5a72d2f |
83 | } |
ba1a299c |
84 | size_t getFromGraphBuf(uint8_t *buff) |
d5a72d2f |
85 | { |
e770c648 |
86 | if (buff == NULL ) return 0; |
b4fb11ba |
87 | uint32_t i; |
88 | for (i=0;i<GraphTraceLen;++i){ |
89 | if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim |
90 | if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim |
91 | buff[i]=(uint8_t)(GraphBuffer[i]+128); |
92 | } |
93 | return i; |
d5a72d2f |
94 | } |
ec75f5c1 |
95 | |
a1557c4c |
96 | // A simple test to see if there is any data inside Graphbuffer. |
97 | bool HasGraphData(){ |
7fe9b0b7 |
98 | |
a1557c4c |
99 | if ( GraphTraceLen <= 0) { |
100 | PrintAndLog("No data available, try reading something first"); |
101 | return false; |
102 | } |
103 | return true; |
104 | } |
105 | |
106 | // Detect high and lows in Grapbuffer. |
107 | // Only loops the first 256 values. |
108 | void DetectHighLowInGraph(int *high, int *low, bool addFuzz) { |
109 | |
110 | uint8_t loopMax = 255; |
111 | if ( loopMax > GraphTraceLen) |
112 | loopMax = GraphTraceLen; |
113 | |
114 | for (uint8_t i = 0; i < loopMax; ++i) { |
115 | if (GraphBuffer[i] > *high) |
116 | *high = GraphBuffer[i]; |
117 | else if (GraphBuffer[i] < *low) |
118 | *low = GraphBuffer[i]; |
119 | } |
120 | |
121 | //12% fuzz in case highs and lows aren't clipped |
122 | if (addFuzz) { |
123 | *high = (int)(*high * .88); |
124 | *low = (int)(*low * .88); |
125 | } |
7fe9b0b7 |
126 | } |
ba1a299c |
127 | |
f3bf15e4 |
128 | // Get or auto-detect ask clock rate |
129 | int GetAskClock(const char str[], bool printAns, bool verbose) |
e770c648 |
130 | { |
131 | int clock; |
132 | sscanf(str, "%i", &clock); |
133 | if (!strcmp(str, "")) |
134 | clock = 0; |
135 | |
f3bf15e4 |
136 | if (clock != 0) |
137 | return clock; |
e770c648 |
138 | // Auto-detect clock |
f3bf15e4 |
139 | uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; |
140 | size_t size = getFromGraphBuf(grph); |
141 | if (size == 0) { |
142 | if (verbose) |
e770c648 |
143 | PrintAndLog("Failed to copy from graphbuffer"); |
f3bf15e4 |
144 | return -1; |
145 | } |
fef74fdc |
146 | int start = DetectASKClock(grph, size, &clock, 20); |
f3bf15e4 |
147 | // Only print this message if we're not looping something |
148 | if (printAns){ |
fef74fdc |
149 | PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start); |
e770c648 |
150 | } |
151 | return clock; |
152 | } |
153 | |
872e3d4d |
154 | uint8_t GetPskCarrier(const char str[], bool printAns, bool verbose) |
155 | { |
156 | uint8_t carrier=0; |
157 | uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; |
158 | size_t size = getFromGraphBuf(grph); |
159 | if ( size == 0 ) { |
160 | if (verbose) |
161 | PrintAndLog("Failed to copy from graphbuffer"); |
162 | return 0; |
163 | } |
164 | //uint8_t countPSK_FC(uint8_t *BitStream, size_t size) |
165 | |
2eec55c8 |
166 | carrier = countFC(grph,size,0); |
872e3d4d |
167 | // Only print this message if we're not looping something |
168 | if (printAns){ |
169 | PrintAndLog("Auto-detected PSK carrier rate: %d", carrier); |
170 | } |
171 | return carrier; |
172 | } |
173 | |
f3bf15e4 |
174 | int GetPskClock(const char str[], bool printAns, bool verbose) |
175 | { |
176 | int clock; |
177 | sscanf(str, "%i", &clock); |
178 | if (!strcmp(str, "")) |
179 | clock = 0; |
180 | |
181 | if (clock!=0) |
182 | return clock; |
183 | // Auto-detect clock |
184 | uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; |
185 | size_t size = getFromGraphBuf(grph); |
186 | if ( size == 0 ) { |
187 | if (verbose) |
188 | PrintAndLog("Failed to copy from graphbuffer"); |
189 | return -1; |
190 | } |
191 | clock = DetectPSKClock(grph,size,0); |
192 | // Only print this message if we're not looping something |
193 | if (printAns){ |
194 | PrintAndLog("Auto-detected clock rate: %d", clock); |
195 | } |
196 | return clock; |
197 | } |
198 | |
199 | uint8_t GetNrzClock(const char str[], bool printAns, bool verbose) |
4118b74d |
200 | { |
ba1a299c |
201 | int clock; |
ba1a299c |
202 | sscanf(str, "%i", &clock); |
203 | if (!strcmp(str, "")) |
204 | clock = 0; |
205 | |
f3bf15e4 |
206 | if (clock!=0) |
207 | return clock; |
ba1a299c |
208 | // Auto-detect clock |
f3bf15e4 |
209 | uint8_t grph[MAX_GRAPH_TRACE_LEN]={0}; |
210 | size_t size = getFromGraphBuf(grph); |
211 | if ( size == 0 ) { |
212 | if (verbose) |
e629181f |
213 | PrintAndLog("Failed to copy from graphbuffer"); |
f3bf15e4 |
214 | return -1; |
215 | } |
216 | clock = DetectNRZClock(grph, size, 0); |
217 | // Only print this message if we're not looping something |
218 | if (printAns){ |
219 | PrintAndLog("Auto-detected clock rate: %d", clock); |
ba1a299c |
220 | } |
221 | return clock; |
4118b74d |
222 | } |
f3bf15e4 |
223 | //by marshmellow |
224 | //attempt to detect the field clock and bit clock for FSK |
225 | uint8_t GetFskClock(const char str[], bool printAns, bool verbose) |
226 | { |
227 | int clock; |
228 | sscanf(str, "%i", &clock); |
229 | if (!strcmp(str, "")) |
230 | clock = 0; |
231 | if (clock != 0) return (uint8_t)clock; |
232 | |
abd6112f |
233 | |
234 | uint8_t fc1=0, fc2=0, rf1=0; |
235 | uint8_t ans = fskClocks(&fc1, &fc2, &rf1, verbose); |
236 | if (ans == 0) return 0; |
237 | if ((fc1==10 && fc2==8) || (fc1==8 && fc2==5)){ |
238 | if (printAns) PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1); |
239 | return rf1; |
240 | } |
241 | if (verbose){ |
242 | PrintAndLog("DEBUG: unknown fsk field clock detected"); |
243 | PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1); |
244 | } |
245 | return 0; |
246 | } |
247 | uint8_t fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, bool verbose) |
248 | { |
f3bf15e4 |
249 | uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; |
250 | size_t size = getFromGraphBuf(BitStream); |
251 | if (size==0) return 0; |
2eec55c8 |
252 | uint16_t ans = countFC(BitStream, size, 1); |
f3bf15e4 |
253 | if (ans==0) { |
254 | if (verbose) PrintAndLog("DEBUG: No data found"); |
255 | return 0; |
256 | } |
abd6112f |
257 | *fc1 = (ans >> 8) & 0xFF; |
258 | *fc2 = ans & 0xFF; |
f3bf15e4 |
259 | |
abd6112f |
260 | *rf1 = detectFSKClk(BitStream, size, *fc1, *fc2); |
261 | if (*rf1==0) { |
f3bf15e4 |
262 | if (verbose) PrintAndLog("DEBUG: Clock detect error"); |
263 | return 0; |
264 | } |
abd6112f |
265 | return 1; |
f3bf15e4 |
266 | } |