debug.cpp
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <string.h>
3 #include <stdarg.h>
4 #include <ctype.h>
5 #include "board.h"
6 // #include "communications.h"
7 #include "../SDK/src/ISConstants.h"
8 #include "../SDK/src/com_manager.h"
9 #include "conf_common.h"
10 #include "misc/utilities.h"
11 #include "globals.h"
12 
13 #include "misc/debug.h"
14 
15 
16 //_____ D E F I N I T I O N S ______________________________________________
17 
18 #define ROUNDUP(x, y) ((x % y) ? ((x) += 4-((x)%4)) : (x))
19 
20 // Terminal Parameter Debug
21 #define PARAM_STARTING_LINE 1
22 #define MAX_NUM_LINES 50
23 #define MAX_NAME_LENGTH 60
24 #define MAX_VALUE_LENGTH 20
25 
26 typedef enum memory_type_t{ M_RAM=0, M_FLASH }memory_type_t;
27 typedef enum number_type_t{ R_X08=0, R_U08, R_S08, R_X16, R_U16, R_S16, R_X32, R_U32, R_S32, R_F32, R_F64, R_F32_R2D, R_STR, R_BLANK }number_type_t;
28 
29 typedef struct term_line_t{
30  union{
31  char* s08p;
32  unsigned char* u08p;
33  short* s16p;
34  unsigned short* u16p;
35  int* s32p;
36  unsigned int* u32p;
37  float* f32p;
38  double* f64p;
39  };
40  union{
41  char s08;
42  unsigned char u08;
43  short s16;
44  unsigned short u16;
45  int s32;
46  unsigned int u32;
47  float f32;
48  double f64;
49  };
50  memory_type_t memType;
51  number_type_t numType;
52  char name[MAX_NAME_LENGTH];
53 }term_line_t;
54 
55 //_____ G L O B A L S ______________________________________________________
56 
57 // static char g_txBuf[TXBUF_SIZE];
58 // static int g_txN=0;
59 
60 #if 0 // terminal code
61 // Terminal Parameter Debug
62 static char g_refresh_term;
63 static int g_numLines;
64 static int g_selLine=1;
65 static char g_value[MAX_VALUE_LENGTH]={0};
66 static int g_valueSize=0;
67 
68 static term_line_t g_term[MAX_NUM_LINES];
69 // static int g_term_update_cnt=0, g_term_compare_cnt=0;
70 
71 extern int g_menu;
72 char g_enableTerm=1; // terminal on by default in Debug mode
73 #endif
74 
75 //_____ L O C A L P R O T O T Y P E S ____________________________________
76 
77 void term_add(void *val, char* name, memory_type_t memType, number_type_t numType);
78 
79 void dg_printf(const char* format, ...)
80 {
81  va_list ap;
82  va_start(ap, format);
83 
84  // Caution: This function can consume quite a bit of stack memory, especially w/ floats.
85  char debugMsg[64];
86  int n = vsnprintf(debugMsg, sizeof(debugMsg - 1), format, ap) + 1; // add null terminator
87  (void)n;
88 
89  va_end(ap);
90 }
91 
92 
93 #if 0
94 void dg_prt_apd(const char *__fmt, ...)
95 {
96  int n;
97 
98  va_list ap;
99  va_start(ap, __fmt);
100  n = vsnprintf(&g_txBuf[g_txN], TXBUF_SIZE-g_txN, __fmt, ap);
101  va_end(ap);
102 
103  n = min(n, TXBUF_SIZE);
104  g_txN += n;
105 
106 // g_txN += strlen(&g_txBuf[g_txN])
107 }
108 
109 void dg_prt_snd(void)
110 {
111  DBG_WRITE((unsigned char*) g_txBuf, g_txN);
112 // if(g_callback_fn_dg_write)
113 // g_callback_fn_dg_write((unsigned char*) g_txBuf, g_txN);
114  g_txN = 0;
115 }
116 
117 void dg_prt_clr(void)
118 {
119  g_txN = 0;
120 }
121 #endif
122 
123 
124 
125 #if 0 // terminal code
126 #include "d_flash.h"
127 void dg_vt100_clear(void) { dg_printf("\x1B[2J"); }
128 void dg_vt100_home(void) { dg_printf("\x1B[H"); }
129 void dg_vt100_row(unsigned int row) { dg_printf("\x1B[%dH", row); }
130 void dg_vt100_belowParams(void) { dg_printf("\x1B[%dH", g_numLines+2); }
131 //void dg_vt100_pos(row,col) { dg_printf("\x1B[%dH\x1B[%dC", row, col); }
132 
133 
134 
135 void init_term(void)
136 {
137  g_numLines = 0;
138  g_refresh_term = 0;
139 
140 // g_term_compare_cnt = (int)(refreshPeriodSec/loopPeriodSec);
141 }
142 
143 void term_update(void)
144 {
145  char buf[MAX_VALUE_LENGTH];
146  char c, mt;
147  int i, n;
148 
149  // Read in Rx data if any
150  n = DBG_READ((unsigned char*)buf, MAX_VALUE_LENGTH);
151 // n = g_callback_fn_dg_read((unsigned char*)buf, MAX_VALUE_LENGTH);
152 
153  if(n)
154  {
155 // // Printout User Input
156 // dg_vt100_row(18);
157 // for( i=0; i<n; i++ )
158 // dg_printf("%d ", buf[i]);
159 // dg_printf(" \n");
160 // return;
161 
162  buf[0] = tolower(buf[0]);
163 
164  if( ((g_term[g_selLine].numType == R_X08 || g_term[g_selLine].numType == R_X16 || g_term[g_selLine].numType == R_X32) &&
165  (buf[0]>='a' && buf[0]<='f')) ||
166  buf[0]=='.' || buf[0]=='-' || (buf[0]>='0' && buf[0]<='9') )
167  { // Is a number
168  n = min(n, MAX_VALUE_LENGTH-g_valueSize);
169  memcpy( &g_value[g_valueSize], buf, n);
170  g_valueSize += n;
171 
172  // Parse current value as a Number
173  switch(g_term[g_selLine].numType)
174  {
175  case R_X08: sscanf(g_value, "%x", &i); g_term[g_selLine].u08 = (U8)i; break;
176  case R_U08: sscanf(g_value, "%u", &i); g_term[g_selLine].u08 = (U8)i; break;
177  case R_S08: sscanf(g_value, "%d", &i); g_term[g_selLine].s08 = (S8)i; break;
178  case R_X16: sscanf(g_value, "%x", &i); g_term[g_selLine].u16 = (U8)i; break;
179  case R_U16: sscanf(g_value, "%u", &i); g_term[g_selLine].u16 = (U8)i; break;
180  case R_S16: sscanf(g_value, "%d", &i); g_term[g_selLine].s16 = (S8)i; break;
181  case R_X32: sscanf(g_value, "%x", &g_term[g_selLine].u32); break;
182  case R_U32: sscanf(g_value, "%u", &g_term[g_selLine].u32); break;
183  case R_S32: sscanf(g_value, "%d", &g_term[g_selLine].s32); break;
184  case R_F32: sscanf(g_value, "%f", &g_term[g_selLine].f32); break;
185  case R_F64: sscanf(g_value, "%lf", &g_term[g_selLine].f64); break;
186  case R_F32_R2D: sscanf(g_value, "%f", &g_term[g_selLine].f32); g_term[g_selLine].f32 *= C_DEG2RAD_F; break;
187  default: break;
188  }
189  }
190  else
191  { // Is a command
192  switch(buf[0])
193  {
194  case 13: // "Enter" to Accept entry
195  if( g_term[g_selLine].memType == M_RAM )
196  { // RAM
197  switch(g_term[g_selLine].numType)
198  {
199  case R_X08:
200  case R_U08: *g_term[g_selLine].u08p = g_term[g_selLine].u08; break;
201  case R_S08: *g_term[g_selLine].s08p = g_term[g_selLine].s08; break;
202  case R_X16:
203  case R_U16: *g_term[g_selLine].u16p = g_term[g_selLine].u16; break;
204  case R_S16: *g_term[g_selLine].s16p = g_term[g_selLine].s16; break;
205  case R_X32:
206  case R_U32: *g_term[g_selLine].u32p = g_term[g_selLine].u32; break;
207  case R_S32: *g_term[g_selLine].s32p = g_term[g_selLine].s32; break;
208  case R_F32_R2D:
209  case R_F32: *g_term[g_selLine].f32p = g_term[g_selLine].f32; break;
210  case R_F64: *g_term[g_selLine].f64p = g_term[g_selLine].f64; break;
211  default: break;
212  }
213  }
214  else
215  { // Flash
216 
217  // Disable gimbal control when writing to flashing.
218 // g_gimbal.modeDes = MODE_HOMING;
219 
220  switch(g_term[g_selLine].numType)
221  {
222  case R_X08:
223  case R_U08: flash_write_U08( (void*)(g_term[g_selLine].u08p), g_term[g_selLine].u08 ); break;
224  case R_S08: flash_write_S08( (void*)(g_term[g_selLine].s08p), g_term[g_selLine].s08 ); break;
225  case R_X16:
226  case R_U16: flash_write_U16( (void*)(g_term[g_selLine].u16p), g_term[g_selLine].u16 ); break;
227  case R_S16: flash_write_S16( (void*)(g_term[g_selLine].s16p), g_term[g_selLine].s16 ); break;
228  case R_X32:
229  case R_U32: flash_write_U32( (void*)(g_term[g_selLine].u32p), g_term[g_selLine].u32 ); break;
230  case R_S32: flash_write_S32( (void*)(g_term[g_selLine].s32p), g_term[g_selLine].s32 ); break;
231  case R_F32_R2D:
232  case R_F32: flash_write_F32( (void*)(g_term[g_selLine].f32p), g_term[g_selLine].f32 ); break;
233  case R_F64: flash_write_F64( (void*)(g_term[g_selLine].f64p), g_term[g_selLine].f64 ); break;
234  default: break;
235  }
236  }
237 // setup_display(g_menu);
238  break;
239 
240  case ' ': // Emergency Stop
241 // g_gimbal.modeDes = MODE_DISABLED;
242  g_enableTerm=1;
243  break;
244 
245  case 'c': // Clear terminal and move to Home (top-left) position
246  dg_vt100_clear();
247  dg_vt100_home();
248  break;
249 
250  case 'o': // Toggle terminal output On/Off
251  if(g_enableTerm)
252  {
253  g_enableTerm=0;
254  dg_vt100_clear();
255  dg_vt100_home();
256  }
257  else
258  g_enableTerm=1;
259  break;
260 
261  case 'q': // Reset to default menu and Setup Terminal
262 // setup_display(g_menu=DEFAULT_MENU);
263  break;
264 
265  case '[': // Up Arrow - Move Up
266  g_selLine = max(--g_selLine, 0);
267  // Skip blank lines and strings
268  switch( g_term[g_selLine].numType )
269  {
270  case R_BLANK:
271  case R_STR:
272  if(g_selLine==0)
273  g_selLine = min(++g_selLine, g_numLines-1);
274  else
275  g_selLine = max(--g_selLine, 0);
276  break;
277  default:
278  break;
279  }
280  break;
281 
282  case ']': // Down Arrow - Move Down
283  g_selLine = min(++g_selLine, g_numLines-1);
284  // Skip blank lines and strings
285  switch( g_term[g_selLine].numType )
286  {
287  case R_BLANK:
288  case R_STR:
289  if(g_selLine==g_numLines-1)
290  g_selLine = max(--g_selLine, 0);
291  else
292  g_selLine = min(++g_selLine, g_numLines-1);
293  break;
294  default:
295  break;
296  }
297  break;
298 
299  case 27:
300  switch( buf[1] )
301  {
302  default: // Alt Key Combinations
303  c = buf[1] - 48;
304 
305  if( c>=0 && c<=9 )
306  {
307  g_menu = c;
308 // setup_display(g_menu);
309  }
310  break;
311 
312  case 91: // Special Keys
313  switch( buf[2] )
314  {
315  case 65: // Up Arrow - Move Up
316  g_selLine = max(--g_selLine, 0);
317  // Skip blank lines and strings
318  switch( g_term[g_selLine].numType )
319  {
320  case R_BLANK:
321  case R_STR:
322  if(g_selLine==0)
323  g_selLine = min(++g_selLine, g_numLines-1);
324  else
325  g_selLine = max(--g_selLine, 0);
326  break;
327  default:
328  break;
329  }
330  break;
331 
332  case 66: // Down Arrow - Move Down
333  g_selLine = min(++g_selLine, g_numLines-1);
334  // Skip blank lines and strings
335  switch( g_term[g_selLine].numType )
336  {
337  case R_BLANK:
338  case R_STR:
339  if(g_selLine==g_numLines-1)
340  g_selLine = max(--g_selLine, 0);
341  else
342  g_selLine = min(++g_selLine, g_numLines-1);
343  break;
344  default:
345  break;
346  }
347  break;
348 
349  case 49: // Function Keys
350  if( buf[3]<=53 ) // F1 - F5
351  g_menu = buf[3] - 48;
352  else // F6 - F8
353  g_menu = buf[3] - 49;
354 
355 // setup_display(g_menu);
356  break;
357  case 50:
358  if( buf[3]<=49 ) // F9 - F10
359  g_menu = buf[3] - 39;
360  else // F11 - F12
361  g_menu = buf[3] - 40;
362 
363 // setup_display(g_menu);
364  break;
365  }
366  break;
367  }
368 // // Printout User Input
369 // dg_vt100_row(18);
370 // dg_printf("DEBUG F%d ", g_menu);
371 // dg_printf(" \n");
372 // return;
373 
374  break;
375 
376  case 127: // Backspace
377  g_valueSize = max(--g_valueSize, 0);
378  g_value[g_valueSize] = 0;
379  // Parse current value
380  switch(g_term[g_selLine].numType)
381  {
382  case R_X08: sscanf(g_value, "%x", &i); g_term[g_selLine].u08 = (U8)i; break;
383  case R_U08: sscanf(g_value, "%u", &i); g_term[g_selLine].u08 = (U8)i; break;
384  case R_S08: sscanf(g_value, "%d", &i); g_term[g_selLine].s08 = (S8)i; break;
385  case R_X16: sscanf(g_value, "%x", &i); g_term[g_selLine].u16 = (U8)i; break;
386  case R_U16: sscanf(g_value, "%u", &i); g_term[g_selLine].u16 = (U8)i; break;
387  case R_S16: sscanf(g_value, "%d", &i); g_term[g_selLine].s16 = (S8)i; break;
388  case R_X32: sscanf(g_value, "%x", &g_term[g_selLine].u32); break;
389  case R_U32: sscanf(g_value, "%u", &g_term[g_selLine].u32); break;
390  case R_S32: sscanf(g_value, "%d", &g_term[g_selLine].s32); break;
391  case R_F32: sscanf(g_value, "%f", &g_term[g_selLine].f32); break;
392  case R_F32_R2D: sscanf(g_value, "%f", &g_term[g_selLine].f32); g_term[g_selLine].f32 *= C_DEG2RAD_F; break;
393  case R_F64: sscanf(g_value, "%lf", &g_term[g_selLine].f64); break;
394  default: break;
395  }
396  }
397 
398  // Remove entry after every command except backspace
399  if(buf[0]!=127)
400  {
401  memset((void*)g_value, 0, sizeof(g_value));
402  g_valueSize = 0;
403  }
404  }
405  //dg_printf("\nselLine %d", g_selLine);
406  //dg_vt100_home();
407  g_refresh_term = 1;
408  }
409 
410  // Only redrawing terminal if flag is set
411 // if(!g_refresh_term && g_term_update_cnt++<g_term_compare_cnt )
412 // return;
413 // g_term_update_cnt = 0;
414 
415  // Limit Selected Line
416  g_selLine = max(min(g_selLine, g_numLines-1), 0);
417 
418  // This keeps data from coming out the serial port if not needed
419  if(!g_enableTerm)
420  return;
421 
422  // Redraw each line if needed
423  for( i=0; i<g_numLines; i++)
424  {
425  dg_vt100_row(i+PARAM_STARTING_LINE);
426 
427  // Selected Line Indicator
428  if(i == g_selLine)
429  if(g_valueSize) c = '>';
430  else c = '*';
431  else c = ' ';
432 
433  // Memory Type Indicator
434  if( g_term[i].memType == M_FLASH) mt = '.';
435  else mt = ' ';
436 
437  if( i==g_selLine && g_valueSize>0)
438  { // Preview new value
439  switch(g_term[i].numType)
440  {
441  case R_X08: dg_printf("%c 0x%2x %c%s", c, g_term[i].u08, mt, g_term[i].name); break;
442  case R_U08: dg_printf("%c %12u %c%s", c, g_term[i].u08, mt, g_term[i].name); break;
443  case R_S08: dg_printf("%c %12d %c%s", c, g_term[i].s08, mt, g_term[i].name); break;
444  case R_X16: dg_printf("%c 0x%4x %c%s", c, g_term[i].u16, mt, g_term[i].name); break;
445  case R_U16: dg_printf("%c %12u %c%s", c, g_term[i].u16, mt, g_term[i].name); break;
446  case R_S16: dg_printf("%c %12d %c%s", c, g_term[i].s16, mt, g_term[i].name); break;
447  case R_X32: dg_printf("%c 0x%8x %c%s", c, g_term[i].u32, mt, g_term[i].name); break;
448  case R_U32: dg_printf("%c %12u %c%s", c, g_term[i].u32, mt, g_term[i].name); break;
449  case R_S32: dg_printf("%c %12d %c%s", c, g_term[i].s32, mt, g_term[i].name); break;
450  case R_F32: dg_printf("%c %12f %c%s", c, g_term[i].f32, mt, g_term[i].name); break;
451  case R_F32_R2D: dg_printf("%c %12f %c%s", c, g_term[i].f32*C_DEG2RAD_F, mt, g_term[i].name); break;
452  case R_F64: dg_printf("%c %12lf %c%s", c, g_term[i].f64, mt, g_term[i].name); break;
453  default: break;
454  }
455  }
456  else
457  { // Print current value
458  switch(g_term[i].numType)
459  {
460  case R_X08: dg_printf("%c 0x%2x %c%s", c, *g_term[i].u08p, mt, g_term[i].name); break;
461  case R_U08: dg_printf("%c %12u %c%s", c, *g_term[i].u08p, mt, g_term[i].name); break;
462  case R_S08: dg_printf("%c %12d %c%s", c, *g_term[i].s08p, mt, g_term[i].name); break;
463  case R_X16: dg_printf("%c 0x%4x %c%s", c, *g_term[i].u16p, mt, g_term[i].name); break;
464  case R_S16: dg_printf("%c %12d %c%s", c, *g_term[i].s16p, mt, g_term[i].name); break;
465  case R_U16: dg_printf("%c %12u %c%s", c, *g_term[i].u16p, mt, g_term[i].name); break;
466  case R_X32: dg_printf("%c 0x%8x %c%s", c, *g_term[i].u32p, mt, g_term[i].name); break;
467  case R_U32: dg_printf("%c %12u %c%s", c, *g_term[i].u32p, mt, g_term[i].name); break;
468  case R_S32: dg_printf("%c %12d %c%s", c, *g_term[i].s32p, mt, g_term[i].name); break;
469  case R_F32: dg_printf("%c %12f %c%s", c, *g_term[i].f32p, mt, g_term[i].name); break;
470  case R_F32_R2D: dg_printf("%c %12f %c%s", c, *g_term[i].f32p*C_DEG2RAD_F, mt, g_term[i].name); break;
471  case R_F64: dg_printf("%c %12lf %c%s", c, *g_term[i].f64p, mt, g_term[i].name); break;
472  case R_STR: dg_printf("%c %s %s", c, g_term[i].s08p, g_term[i].name); break;
473  default: break;
474  }
475  }
476  }
477 
478  // Return cursor to top
479  //dg_vt100_home();
480  //dg_vt100_row(g_numLines+2);
481 
482  // Release print semaphore
483  g_refresh_term = 0;
484 }
485 
486 
487 void term_add(void *ptr, char* name, memory_type_t memType, number_type_t numType)
488 {
489  int nameLen;
490 
491  if(g_numLines >= MAX_NUM_LINES)
492  return;
493 
494  nameLen = min(strlen(name), MAX_NAME_LENGTH);
495 
496  // Add Memory Type
497  g_term[g_numLines].memType = memType;
498 
499  // Add Number Type
500  g_term[g_numLines].numType = numType;
501 
502  // Add Data
503  switch(numType)
504  {
505  case R_STR:
506  case R_X08:
507  case R_U08: g_term[g_numLines].u08p = (unsigned char*)ptr; break;
508  case R_S08: g_term[g_numLines].s08p = (char*)ptr; break;
509  case R_X16:
510  case R_U16: g_term[g_numLines].u16p = (unsigned short*)ptr; break;
511  case R_S16: g_term[g_numLines].s16p = (short*)ptr; break;
512  case R_X32:
513  case R_U32: g_term[g_numLines].u32p = (unsigned int*)ptr; break;
514  case R_S32: g_term[g_numLines].s32p = (int*)ptr; break;
515  case R_F32:
516  case R_F32_R2D: g_term[g_numLines].f32p = (float*)ptr; break;
517  case R_F64: g_term[g_numLines].f64p = (double*)ptr; break;
518  default: break;
519  }
520 
521  // Add Name
522  memset((void*)g_term[g_numLines].name, 0, MAX_NAME_LENGTH);
523  memcpy((void*)g_term[g_numLines].name, name, nameLen);
524 
525  // Increment Number of Lines
526  g_numLines++;
527 
528  g_refresh_term = 1;
529 }
530 
531 
532 void term_addBlankLine(void)
533 {
534  if(g_numLines >= MAX_NUM_LINES)
535  return;
536 
537  // Add Number Type
538  g_term[g_numLines].numType = R_BLANK;
539 
540  // Increment Number of Lines
541  g_numLines++;
542 
543  g_refresh_term = 1;
544 }
545 
546 const char blankStr[] = " ";
547 void term_addLabel( char* name ) { term_addVarStr( (void*)blankStr, name ); }
548 void term_addVarStr( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_STR ); }
549 void term_addVarX08( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_X08 ); }
550 void term_addVarU08( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_U08 ); }
551 void term_addVarS08( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_S08 ); }
552 void term_addVarX16( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_X16 ); }
553 void term_addVarU16( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_U16 ); }
554 void term_addVarS16( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_S16 ); }
555 void term_addVarX32( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_X32 ); }
556 void term_addVarU32( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_U32 ); }
557 void term_addVarS32( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_S32 ); }
558 void term_addVarF32( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_F32 ); }
559 void term_addVarF64( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_F64 ); }
560 void term_addVarF32Rad2Deg( void *ptr, char* name ) { term_add( ptr, name, M_RAM, R_F32_R2D ); }
561 
562 void term_addFlaX08( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_X08 ); }
563 void term_addFlaU08( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_U08 ); }
564 void term_addFlaS08( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_S08 ); }
565 void term_addFlaX16( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_X16 ); }
566 void term_addFlaU16( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_U16 ); }
567 void term_addFlaS16( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_S16 ); }
568 void term_addFlaX32( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_X32 ); }
569 void term_addFlaU32( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_U32 ); }
570 void term_addFlaS32( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_S32 ); }
571 void term_addFlaF32( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_F32 ); }
572 void term_addFlaF64( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_F64 ); }
573 void term_addFlaF32Rad2Deg( void *ptr, char* name ) { term_add( ptr, name, M_FLASH, R_F32_R2D ); }
574 
575 #endif // terminal code
R_F32
Definition: debug.cpp:27
term_line_t
struct term_line_t term_line_t
S8
int8_t S8
8-bit signed integer.
Definition: compiler.h:246
memory_type_t
memory_type_t
Definition: debug.cpp:26
term_line_t::u16p
unsigned short * u16p
Definition: debug.cpp:34
term_line_t::s32
int s32
Definition: debug.cpp:45
term_line_t::f32
float f32
Definition: debug.cpp:47
term_line_t::u16
unsigned short u16
Definition: debug.cpp:44
R_STR
Definition: debug.cpp:27
MAX_NUM_LINES
#define MAX_NUM_LINES
Definition: debug.cpp:22
R_F64
Definition: debug.cpp:27
R_X08
Definition: debug.cpp:27
term_line_t::s08p
char * s08p
Definition: debug.cpp:31
PARAM_STARTING_LINE
#define PARAM_STARTING_LINE
Definition: debug.cpp:21
d_flash.h
number_type_t
number_type_t
Definition: debug.cpp:27
term_line_t::u08p
unsigned char * u08p
Definition: debug.cpp:32
term_line_t::f64
double f64
Definition: debug.cpp:48
min
#define min(a, b)
Takes the minimal value of a and b.
Definition: compiler.h:812
max
#define max(a, b)
Takes the maximal value of a and b.
Definition: compiler.h:823
vsnprintf
#define vsnprintf
Definition: test_suite.cpp:87
R_S32
Definition: debug.cpp:27
term_line_t::numType
number_type_t numType
Definition: debug.cpp:51
MAX_NAME_LENGTH
#define MAX_NAME_LENGTH
Definition: debug.cpp:23
term_line_t::f32p
float * f32p
Definition: debug.cpp:37
term_line_t::s16p
short * s16p
Definition: debug.cpp:33
term_line_t::f64p
double * f64p
Definition: debug.cpp:38
term_line_t::u32p
unsigned int * u32p
Definition: debug.cpp:36
R_U16
Definition: debug.cpp:27
R_X32
Definition: debug.cpp:27
term_add
void term_add(void *val, char *name, memory_type_t memType, number_type_t numType)
MAX_VALUE_LENGTH
#define MAX_VALUE_LENGTH
Definition: debug.cpp:24
R_X16
Definition: debug.cpp:27
C_DEG2RAD_F
#define C_DEG2RAD_F
Definition: ISConstants.h:560
term_line_t
Definition: debug.cpp:29
term_line_t::s08
char s08
Definition: debug.cpp:41
term_line_t::name
char name[MAX_NAME_LENGTH]
Definition: debug.cpp:52
R_S16
Definition: debug.cpp:27
dg_printf
void dg_printf(const char *format,...)
Definition: debug.cpp:79
term_line_t::s32p
int * s32p
Definition: debug.cpp:35
M_RAM
Definition: debug.cpp:26
term_line_t::u08
unsigned char u08
Definition: debug.cpp:42
R_U32
Definition: debug.cpp:27
U8
uint8_t U8
8-bit unsigned integer.
Definition: compiler.h:247
term_line_t::u32
unsigned int u32
Definition: debug.cpp:46
R_S08
Definition: debug.cpp:27
board.h
Standard board header file.
term_line_t::memType
memory_type_t memType
Definition: debug.cpp:50
term_line_t::s16
short s16
Definition: debug.cpp:43
R_U08
Definition: debug.cpp:27

inertial_sense_ros
Author(s):
autogenerated on Sat Sep 19 2020 03:19:04