cvs.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

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 //-----------------------------------------------------------------------------

11 #include <stdio.h>

12 #include <stdbool.h>

13 #include <string.h>

14 #include "ui.h"

15 #include "graph.h"

16 #include "lfdemod.h"

17 #include "cmddata.h" //for g_debugmode

19 int GraphBuffer[MAX_GRAPH_TRACE_LEN];

20 int GraphTraceLen;

21 /* write a manchester bit to the graph */

 void AppendGraph(int redraw, int clock, int bit)

23 {

24 int i;

25 //set first half the clock bit (all 1's or 0's for a 0 or 1 bit)

   for (i = 0; i < (int)(clock / 2); ++i)

27 GraphBuffer[GraphTraceLen++] = bit ;

28 //set second half of the clock bit (all 0's or 1's for a 0 or 1 bit)

   for (i = (int)(clock / 2); i < clock; ++i)

     GraphBuffer[GraphTraceLen++] = bit ^ 1;

32 if (redraw)

33 RepaintGraphWindow();

34 }

36 // clear out our graph window

 int ClearGraph(int redraw)

38 {

39 int gtl = GraphTraceLen;

   memset(GraphBuffer, 0x00, GraphTraceLen);

42 GraphTraceLen = 0;

44 if (redraw)

45 RepaintGraphWindow();

47 return gtl;

48 }

49 // option '1' to save GraphBuffer any other to restore

 void save_restoreGB(uint8_t saveOpt)

51 {

52 static int SavedGB[MAX_GRAPH_TRACE_LEN];

53 static int SavedGBlen;

54 static bool GB_Saved = false;

         if (saveOpt==1) { //save

                 memcpy(SavedGB, GraphBuffer, sizeof(GraphBuffer));

58 SavedGBlen = GraphTraceLen;

59 GB_Saved=true;

         } else if (GB_Saved){ //restore

                 memcpy(GraphBuffer, SavedGB, sizeof(GraphBuffer));

62 GraphTraceLen = SavedGBlen;

63 RepaintGraphWindow();

64 }

65 return;

66 }

68 // DETECT CLOCK NOW IN LFDEMOD.C

 void setGraphBuf(uint8_t *buff, size_t size)

71 {

         if ( buff == NULL ) return;

74 uint16_t i = 0;

75 if ( size > MAX_GRAPH_TRACE_LEN )

76 size = MAX_GRAPH_TRACE_LEN;

77 ClearGraph(0);

         for (; i < size; ++i){

                 GraphBuffer[i]=buff[i]-128;

80 }

81 GraphTraceLen=size;

82 RepaintGraphWindow();

83 return;

84 }

 size_t getFromGraphBuf(uint8_t *buff)

86 {

         if (buff == NULL ) return 0;

88 uint32_t i;

         for (i=0;i<GraphTraceLen;++i){

                 if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim

                 if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim

                 buff[i]=(uint8_t)(GraphBuffer[i]+128);

93 }

94 return i;

95 }

97 // A simple test to see if there is any data inside Graphbuffer.

98 bool HasGraphData(){

         if ( GraphTraceLen <= 0) {

101 PrintAndLog("No data available, try reading something first");

102 return false;

103 }

104 return true;

105 }

106

107 // Detect high and lows in Grapbuffer.

108 // Only loops the first 256 values.

 void DetectHighLowInGraph(int *high, int *low, bool addFuzz) {

110

111 uint8_t loopMax = 255;

112 if ( loopMax > GraphTraceLen)

113 loopMax = GraphTraceLen;

114

         for (uint8_t i = 0; i < loopMax; ++i) {

                 if (GraphBuffer[i] > *high)

117 *high = GraphBuffer[i];

                 else if (GraphBuffer[i] < *low)

119 *low = GraphBuffer[i];

120 }

121

122 //12% fuzz in case highs and lows aren't clipped

123 if (addFuzz) {

                 *high = (int)(*high * .88);

                 *low  = (int)(*low  * .88);

126 }

127 }

128

129 // Get or auto-detect ask clock rate

 int GetAskClock(const char str[], bool printAns, bool verbose)

131 {

132 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

135 clock = 0;

136

         if (clock != 0) 

138 return clock;

139 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if (size == 0) {

143 if (verbose)

144 PrintAndLog("Failed to copy from graphbuffer");

145 return -1;

146 }

         bool st = DetectST(grph, &size, &clock);

148 int start = 0;

         if (st == false) {

                 start = DetectASKClock(grph, size, &clock, 20);

151 }

152 // Only print this message if we're not looping something

153 if (printAns) {

                 PrintAndLog("Auto-detected clock rate: %d, Best Starting Position: %d", clock, start);

155 }

156 return clock;

157 }

158

 uint8_t GetPskCarrier(const char str[], bool printAns, bool verbose)

160 {

161 uint8_t carrier=0;

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

165 if (verbose)

166 PrintAndLog("Failed to copy from graphbuffer");

167 return 0;

168 }

169 //uint8_t countPSK_FC(uint8_t *BitStream, size_t size)

170

         carrier = countFC(grph,size,0);

172 // Only print this message if we're not looping something

173 if (printAns){

                 PrintAndLog("Auto-detected PSK carrier rate: %d", carrier);

175 }

176 return carrier;

177 }

178

 int GetPskClock(const char str[], bool printAns, bool verbose)

180 {

181 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, "")) 

184 clock = 0;

185

         if (clock!=0) 

187 return clock;

188 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

192 if (verbose)

193 PrintAndLog("Failed to copy from graphbuffer");

194 return -1;

195 }

         clock = DetectPSKClock(grph,size,0);

197 // Only print this message if we're not looping something

198 if (printAns){

                 PrintAndLog("Auto-detected clock rate: %d", clock);

200 }

201 return clock;

202 }

203

 uint8_t GetNrzClock(const char str[], bool printAns, bool verbose)

205 {

206 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

209 clock = 0;

210

         if (clock!=0) 

212 return clock;

213 // Auto-detect clock

         uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(grph);

         if ( size == 0 ) {

217 if (verbose)

218 PrintAndLog("Failed to copy from graphbuffer");

219 return -1;

220 }

221 size_t clkStartIdx = 0;

         clock = DetectNRZClock(grph, size, 0, &clkStartIdx);

223 // Only print this message if we're not looping something

224 if (printAns){

                 PrintAndLog("Auto-detected clock rate: %d", clock);

226 }

227 return clock;

228 }

229 //by marshmellow

230 //attempt to detect the field clock and bit clock for FSK

 uint8_t GetFskClock(const char str[], bool printAns, bool verbose)

232 {

233 int clock;

         sscanf(str, "%i", &clock);

         if (!strcmp(str, ""))

236 clock = 0;

         if (clock != 0) return (uint8_t)clock;

238

239

         uint8_t fc1=0, fc2=0, rf1=0;

         uint8_t ans = fskClocks(&fc1, &fc2, &rf1, verbose);

         if (ans == 0) return 0;

         if ((fc1==10 && fc2==8) || (fc1==8 && fc2==5)){

                 if (printAns) PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);

245 return rf1;

246 }

247 if (verbose){

248 PrintAndLog("DEBUG: unknown fsk field clock detected");

                 PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);

250 }

251 return 0;

252 }

 uint8_t fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, bool verbose)

254 {

         uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};

         size_t size = getFromGraphBuf(BitStream);

         if (size==0) return 0;

         uint16_t ans = countFC(BitStream, size, 1); 

         if (ans==0) {

                 if (verbose || g_debugMode) PrintAndLog("DEBUG: No data found");

261 return 0;

262 }

         *fc1 = (ans >> 8) & 0xFF;

         *fc2 = ans & 0xFF;

265

         *rf1 = detectFSKClk(BitStream, size, *fc1, *fc2);

         if (*rf1==0) {

                 if (verbose || g_debugMode) PrintAndLog("DEBUG: Clock detect error");

269 return 0;

270 }

271 return 1;

272 }

 bool graphJustNoise(int *BitStream, int size)

274 {

         static const uint8_t THRESHOLD = 15; //might not be high enough for noisy environments

276 //test samples are not just noise

277 bool justNoise1 = 1;

         for(int idx=0; idx < size && justNoise1 ;idx++){

279 justNoise1 = BitStream[idx] < THRESHOLD;

280 }

281 return justNoise1;

282 }