Nordic Semiconductor nRF5 AirFuel SDK  version 2.2.0
ptu_debug.c
Go to the documentation of this file.
1 /* Copyright (c) Nordic Semiconductor. All Rights Reserved.
2  *
3  * The information contained herein is property of Nordic Semiconductor ASA.
4  * Terms and conditions of usage are described in detail in NORDIC
5  * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
6  *
7  * Licensees are granted free, non-transferable use of the information. NO
8  * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
9  * the file.
10  *
11  */
12 
13 #include <string.h>
14 #include <stdio.h>
15 
16 #include "app_print.h"
17 #include "simple_uart.h"
18 #include "ptu_test_mux.h"
19 #include "ptu_registry.h"
20 #include "ptu_sensors.h"
21 #include "bsp.h"
22 
29 #define DEBUG_LINE_LENGTH 80
30 #define EVT_STRING_LENGTH_MAX 20
31 #define VTX_INCREMENT 1000
32 #define ITX_INCREMENT 100
33 #define TEMPERATURE_INCREMENT 10
34 #define EXTENDED_BEACON_THRESHOLD_MS 500
35 #define MAX_RTC_COUNTER_VAL 0x00FFFFFF
37 /******************************************************************************/
38 
40 /******************************************************************************/
41 
45 typedef struct
46 {
47  ptu_sm_state_t current_state;
49  bool link_encrypted[PTU_MAX_CONNECTIONS];
50  ptu_sensor_data_t sensor_data;
52  uint8_t extended_beacon_currently_running;
53 } debug_output_t;
54 
55 static debug_output_t m_debug_output;
58 static bool m_uart_initialized = false;
59 static bool m_simplified_beacon_print = false;
60 static bool force_debug_print = false;
66 {
67  override_values.power_amp_enable = true;
68 
69  for(uint8_t i = 0; i < PTU_Z_MEAS_BUF_LENGTH; ++i)
70  {
71  if(i == 0) // First call
72  override_values.vtx = 10 * (PTU_ITX_MIN * PTU_Z_TX_IN_LOAD_DETECT) + 1; // Make sure v/i > Z_TX_IN_LOAD_DETECTED
73 
74  else // non - first call
75  override_values.vtx = 1;
76 
77  override_values.itx = PTU_ITX_MIN;
78 
79  ptu_tmux_override_values_set(&override_values);
80 
81  (void)ptu_sensors_read(); // Triggers call to load variation detection
82  }
83 
84  override_values.power_amp_enable = false;
85 
86  ptu_tmux_override_values_set(&override_values);
87 
88  (void)ptu_sensors_read(); // Triggers call to load variation detection
89 
90 }
91 
97 static char * sm_state_string_get(ptu_sm_state_t state)
98 {
99  switch(state)
100  {
101  case PTU_SM_STATE_CONFIGURATION:
102  return ("Conf");
103  case PTU_SM_STATE_POWER_SAVE:
104  return ("Psave");
105  case PTU_SM_STATE_LOW_POWER:
106  return ("LowP");
107  case PTU_SM_STATE_POWER_TRANSFER:
108  return ("Ptrans");
109  case PTU_SM_STATE_LATCH_FAULT:
110  return ("LatchF");
111  case PTU_SM_STATE_LOCAL_FAULT:
112  return ("LocF");
113  default:
114  return "Invalid state";
115  }
116 }
117 
125 static bool m_uart_chars_available(void)
126 {
127  return (NRF_UART0->EVENTS_RXDRDY == 1);
128 }
129 
138 static bool m_ptu_process_command_common(uint8_t cmd)
139 {
140  bool cmd_processed = true;
141  uint32_t err_code;
142 
143  ptu_tmux_override_values_get(&override_values);
144 
145  switch (cmd)
146  {
147  case 'z':
148  // Reset
149  print_string("\n\rCommand: Reset\r\n");
150  NVIC_SystemReset();
151  break;
152 
153  case 'b':
154  // Beacon debug print
156  print_string("\n\rCommand: Beacon debug print disabled\r\n");
157  else
158  print_string("\n\rCommand: Beacon debug print enabled\r\n");
160  break;
161 
162  case 'y':
163  print_string("\n\rCommand: Inc VTX -> ");
164  override_values.vtx += VTX_INCREMENT;
165  print_hex(override_values.vtx, 2);
166  print_string("\n\r");
167  break;
168 
169  case 'h':
170  print_string("\n\rCommand: Dec VTX -> ");
171  override_values.vtx -= VTX_INCREMENT;
172  print_hex(override_values.vtx, 2);
173  print_string("\n\r");
174  break;
175 
176  case 'u':
177  print_string("\n\rCommand: Inc ITX -> ");
178  override_values.itx += ITX_INCREMENT;
179  print_hex(override_values.itx, 2);
180  print_string("\n\r");
181  break;
182 
183  case 'j':
184  print_string("\n\rCommand: Dec ITX -> ");
185  override_values.itx -= ITX_INCREMENT;
186  print_hex(override_values.itx, 2);
187  print_string("\n\r");
188  break;
189 
190  case 'i':
191  print_string("\n\rCommand: Inc temperature -> ");
192  override_values.temperature += TEMPERATURE_INCREMENT;
193  print_hex(override_values.temperature, 2);
194  print_string("\n\r");
195  break;
196 
197  case 'k':
198  print_string("\n\rCommand: Dec temperature -> ");
199  override_values.temperature -= TEMPERATURE_INCREMENT;
200  print_hex(override_values.temperature, 2);
201  print_string("\n\r");
202  break;
203 
204  case 'o':
205  print_string("\n\rCommand: Test-mode enabled\n\r");
206  tmux_set_select(TMUX_SELECT_OVERRIDE);
207  tmux_get_select(TMUX_SELECT_OVERRIDE);
208  force_debug_print=true;
209  break;
210 
211  case 'p':
212  print_string("SDK Version ");
214  print_string("\n\r");
215  break;
216 
217  case 'l':
218  print_string("\n\rCommand: Test-mode disabled\n\r");
219  tmux_set_select(TMUX_SELECT_NO_OVERRIDE);
220  tmux_get_select(TMUX_SELECT_NO_OVERRIDE);
221  force_debug_print=true;
222  break;
223 
224  case 'n':
225  print_string("\n\rCommand: TX power set to -40dBm\n\r");
226  err_code = sd_ble_gap_tx_power_set(-40);
227  APP_ERROR_CHECK(err_code);
228  break;
229 
230  case 'm':
231  print_string("\n\rCommand: TX power set to PTU_OUTPUT_TX_POWER\n\r");
232  err_code = sd_ble_gap_tx_power_set(PTU_OUTPUT_TX_POWER);
233  APP_ERROR_CHECK(err_code);
234  break;
235 
236  case 'v':
237  print_string("\n\rCommand: Set Load Variation TRUE\n\r");
239  break;
240 
241 
242  case '2':
243  print_string("\n\rCommand: Resonator ON\n\r");
244  override_values.power_amp_enable = true;
245  break;
246 
247  case '3':
248  print_string("\n\rCommand: Resonator OFF\n\r");
249  override_values.power_amp_enable = false;
250  break;
251 
252  case '4':
253  print_string("\n\rCommand: Inc poweramp level -> ");
254  override_values.power_amp_level += POWERAMP_TEST_VAR_STEP_SIZE;
255  print_hex(override_values.power_amp_level, 2);
256  print_string("\n\r");
257  break;
258 
259  case '5':
260  print_string("\n\rCommand: Dec poweramp level -> ");
261  override_values.power_amp_level -= POWERAMP_TEST_VAR_STEP_SIZE;
262  print_hex(override_values.power_amp_level, 2);
263  print_string("\n\r");
264  break;
265 
266  case '6':
267  print_string("\n\rptu\n\r");
268  break;
269 
270  case '7':
271  print_string("ptu_reg_n_entries_get=");
273  print_string("\n\r");
274  break;
275 
276  case '8':
277  #ifdef DFU_SUPPORT
278  print_string("Entering DFU mode ...\n\r");
279  dfu_start();
280  break;
281  #endif //DFU_SUPPORT
282 
283  default:
284  cmd_processed = false;
285  break;
286  }
287 
288  ptu_tmux_override_values_set(&override_values);
289 
290  return cmd_processed;
291 }
292 
300 static uint32_t ms_since(uint32_t tick){
301  uint32_t current_tick;
302  uint32_t delta_ticks;
303 
304  (void) app_timer_cnt_get(&current_tick);
305  if(tick>current_tick) //Overflow occured
306  {
307  delta_ticks = (((MAX_RTC_COUNTER_VAL-tick)+current_tick) & MAX_RTC_COUNTER_VAL);
308  }
309  else
310  {
311  delta_ticks = ((current_tick-tick) & MAX_RTC_COUNTER_VAL);
312  }
313  return (1000*delta_ticks)/APP_TIMER_CLOCK_FREQ;
314 }
315 
316 
319 /******************************************************************************/
322 /******************************************************************************/
323 
332 bool ptu_process_command_board(uint8_t cmd);
333 
336 void sm_uart_rx_poll(void)
337 {
338  uint8_t cmd = 0;
339  bool b_cmd_processed;
340  if (!m_uart_chars_available())
341  {
342  return;
343  }
344 
345  cmd = simple_uart_get();
346 
347  #ifdef PTU_TEST_HW_UART_CMD_ENABLE
348  b_cmd_processed = ptu_process_command_board(cmd);
349  if (!b_cmd_processed) b_cmd_processed = m_ptu_process_command_common(cmd);
350  #else
351  b_cmd_processed = m_ptu_process_command_common(cmd);
352  #endif
353 
354  if (!b_cmd_processed)
355  {
356  print_string("\n\rCommand not implemented");
357  }
358 }
359 
363 void line_print(void)
364 {
365  int i;
366 
367  for(i = 0; i < DEBUG_LINE_LENGTH; i++)
368  {
369  print_string("-");
370  }
371  print_string("\r\n");
372 }
373 
377 static bool debug_output_changed(void)
378 {
379  int i;
380  bool changed = false;
381  uint32_t err_code;
382  const ptu_sensor_data_t* sensor_data;
383  uint16_t current_powerlevel;
384  bool current_poweramp_status;
385  static bool prev_poweramp_status;
386  static uint32_t prev_powerlevel;
387  static uint32_t ticks_at_last_beacon_changed;
388  static uint8_t currently_in_long_beacon = false;
389  ptu_reg_item_t * p_reg_item;
390 
391  err_code = ptu_sensors_data_get(&sensor_data);
392  APP_ERROR_CHECK(err_code);
393 
394 
395  (void)ptu_tmux_poweramp_enable_get(&current_poweramp_status);
396  (void)ptu_tmux_poweramp_level_get(&current_powerlevel);
397 
398  uint32_t delta=ms_since(ticks_at_last_beacon_changed);
399 
400  // Beacon status has changed
401  if(prev_poweramp_status != current_poweramp_status ||
402  prev_powerlevel != current_powerlevel)
403  {
404  err_code = app_timer_cnt_get(&ticks_at_last_beacon_changed);
405  APP_ERROR_CHECK(err_code);
406 
407  if(current_poweramp_status && current_powerlevel == PTU_POWERAMP_INPUT_BEACON_SHORT){
408  currently_in_long_beacon = false;
409  m_debug_output.extended_beacon_currently_running=false;
411  print_string("s");
412  }
413  else if(current_poweramp_status && current_powerlevel == PTU_POWERAMP_INPUT_BEACON_LONG)
414  {
415  currently_in_long_beacon = true;
416  m_debug_output.extended_beacon_currently_running=false;
418  print_string("e\n\r");
419  print_string("l");
420  }
421  }
422 
423  if(!current_poweramp_status){
424  currently_in_long_beacon = false;
425  m_debug_output.extended_beacon_currently_running=false;
427  print_string("e\n\r");
428  }
429  }
430  // Extended beacon
431  else if(currently_in_long_beacon && delta > EXTENDED_BEACON_THRESHOLD_MS)
432  {
433  currently_in_long_beacon = false;
434  m_debug_output.extended_beacon_currently_running=true;
436  print_string("e\n\r");
437  print_string("x");
438  }
439  }
440  prev_poweramp_status = current_poweramp_status;
441  prev_powerlevel = current_powerlevel;
442 
444  return false;
445 
446 
447 
448  if(m_debug_output.current_state != ptu_sm_execute(PTU_SM_SIGNAL_NULL, NULL))
449  {
450  changed = true;
451  m_debug_output.current_state = ptu_sm_execute(PTU_SM_SIGNAL_NULL, NULL);
452  }
453 
454  if(memcmp(&m_debug_output.sensor_data, sensor_data, sizeof(ptu_sensor_data_t)) != 0)
455  {
456  changed = true;
457  memcpy(&m_debug_output.sensor_data, sensor_data, sizeof(ptu_sensor_data_t));
458  }
459 
460  for(i = 0; i < PTU_MAX_CONNECTIONS; i++)
461  {
462  (void)ptu_reg_item_get_from_index(i, &p_reg_item);
463 
464  if(m_debug_output.reg_item_state[i] != p_reg_item->state)
465  {
466  changed = true;
467  m_debug_output.reg_item_state[i] = p_reg_item->state;
468  }
469 
470  if(m_debug_output.link_encrypted[i] != p_reg_item->link_encrypted)
471  {
472  changed = true;
473  m_debug_output.link_encrypted[i] = p_reg_item->link_encrypted;
474  }
475 
476 
477  if(memcmp(&m_debug_output.dyn_params[i], &p_reg_item->prev_pru_dynamic, sizeof(pru_dynamic_t)) != 0)
478  {
479  changed = true;
480  memcpy(&m_debug_output.dyn_params[i], &p_reg_item->prev_pru_dynamic, sizeof(pru_dynamic_t));
481  }
482  }
483 
484  if(strlen(m_evt_evt_string) > 0)
485  {
486  changed = true;
487  }
488 
489  return changed;
490 }
491 
494 static void debug_output_print(void)
495 {
496  int i;
498  uint32_t curr_ticks;
499 
500  (void) app_timer_cnt_get(&curr_ticks);
501 
502  line_print();
503 
504  // PTU main heading
505  print_string("StatusStart ");
506  print_hex((curr_ticks/32), 4); // Output current ticks value in ms.
507  print_string("\r\n");
508 
509  line_print();
510 
511  // Table heading 1
512  print_string("State\tSubst\tLddet\tLoadvar\tRobj\tResimp\tVina\tIina\tTemp\tX Beacon\r\n");
513 
514  // Table contents 1
515  sprintf(temp_string, "%s\t", sm_state_string_get(m_debug_output.current_state));
516  print_string(temp_string);
517 
518  print_string(temp_string);
519 
520  char * x_beacon_status[]={"Off", "On"};
521  sprintf(temp_string, "%u\t%u\t%u\t%u\t%u\t%u\t%d\t%s\r\n",
522  m_debug_output.sensor_data.load_detected,
523  m_debug_output.sensor_data.load_var_detected,
524  m_debug_output.sensor_data.rogue_obj_detected,
525  m_debug_output.sensor_data.res_impedance,
526  m_debug_output.sensor_data.v_ina,
527  m_debug_output.sensor_data.i_ina,
528  m_debug_output.sensor_data.temperature,
529  x_beacon_status[m_debug_output.extended_beacon_currently_running]);
530  print_string(temp_string);
531  line_print();
532 
533  // Table heading 2
534  print_string("Registered PRUs\r\n");
535  line_print();
536 
537  // Table contents 2
538  print_string("#\tVrect\tIrect\tVout\tIout\tPrect\tPutil\tTemp\tCharged\tEncrypt\r\n");
539  for(i = 0; i < PTU_MAX_CONNECTIONS; i++)
540  {
541  if(m_debug_output.reg_item_state[i] == REG_ITEM_STATE_REGISTERED)
542  {
543  sprintf(temp_string, "%u\t%u\t%u\t%u\t%u\t%u\t%u\t%i\t%u\t%u\t",
544  i,
545  m_debug_output.dyn_params[i].vrect,
546  m_debug_output.dyn_params[i].irect,
547  m_debug_output.dyn_params[i].vout,
548  m_debug_output.dyn_params[i].iout,
549  m_debug_output.dyn_params[i].prect,
550  m_debug_output.dyn_params[i].putil,
551  m_debug_output.dyn_params[i].temperature,
552  m_debug_output.dyn_params[i].alerts.charge_complete,
553  m_debug_output.link_encrypted[i]);
554  }
555  else
556  {
557  sprintf(temp_string, "%u\t-\t-\t-\t-\t-\t-\t-\t-\t-", i);
558  }
559  print_string(temp_string);
560  print_string("\r\n");
561  }
562 
563  // Print event message
564  if(strlen(m_evt_evt_string) > 0)
565  {
566  print_string("\r\n");
568  sprintf(m_evt_evt_string, "");
569  }
570 
571  print_string("StatusEnd\r\n");
572 }
573 
574 void debug(void)
575 {
576  if (!m_uart_initialized)
577  {
578  simple_uart_config(UART_BAUDRATE_BAUDRATE_Baud460800, RTS_PIN_NUMBER, TX_PIN_NUMBER, CTS_PIN_NUMBER, RX_PIN_NUMBER, HWFC);
579  m_uart_initialized = true;
580  }
582  {
584  force_debug_print=false;
585  }
586  sm_uart_rx_poll();
587 }
588 
589 void debug_add_string(const char *s)
590 {
591  sprintf(m_evt_evt_string, "%s", s);
592 }
593 
uint8_t simple_uart_get(void)
Function for reading a character from UART. Execution is blocked until UART peripheral detects charac...
Definition: simple_uart.c:22
Registry item.
Definition: ptu_registry.h:47
void ptu_tmux_override_values_set(ptu_tmux_override_t *values)
Set override values.
Definition: ptu_test_mux.c:138
uint8_t link_encrypted
Definition: ptu_registry.h:68
uint32_t ptu_sensors_read(void)
Read sensors. This function should typically be called regularly by a timer and can generate events b...
Definition: ptu_sensors.c:303
static bool m_ptu_process_command_common(uint8_t cmd)
Function for processing common test commands.
Definition: ptu_debug.c:138
#define PTU_POWERAMP_INPUT_BEACON_LONG
Definition: ptu_hw_config.h:60
#define PTU_ITX_MIN
Definition: ptu_hw_config.h:87
static bool m_simplified_beacon_print
Definition: ptu_debug.c:59
uint32_t ptu_reg_item_get_from_index(uint8_t index, ptu_reg_item_t **item_p)
Get registry item from index in database. Index must be < PTU_MAX_CONNECTIONS.
Definition: ptu_registry.c:126
uint8_t ptu_reg_n_entries_get(void)
Get the number of devices currently in registry. This will include all connected devices, as well as all devices which is currently being registered.
Definition: ptu_registry.c:268
static bool m_uart_chars_available(void)
Check if there are any characters in the UART receive buffer.
Definition: ptu_debug.c:125
static bool debug_output_changed(void)
Update m_debug_output variable.
Definition: ptu_debug.c:377
static ptu_tmux_override_t override_values
Definition: ptu_debug.c:57
#define PTU_POWERAMP_INPUT_BEACON_SHORT
Definition: ptu_hw_config.h:59
static char m_evt_evt_string[EVT_STRING_LENGTH_MAX]
Definition: ptu_debug.c:56
void debug_add_string(const char *s)
Add string to debug output.
Definition: ptu_debug.c:589
static char * sm_state_string_get(ptu_sm_state_t state)
Convert state to string.
Definition: ptu_debug.c:97
static uint32_t ms_since(uint32_t tick)
Function for getting the time, in ms, that have passed since the argument system tick.
Definition: ptu_debug.c:300
#define PTU_Z_TX_IN_LOAD_DETECT
Definition: ptu_config.h:72
ptu_reg_item_state_t
Registry item status.
Definition: ptu_registry.h:31
#define EXTENDED_BEACON_THRESHOLD_MS
Definition: ptu_debug.c:34
void ptu_tmux_override_values_get(ptu_tmux_override_t *values)
Get ovveride values.
Definition: ptu_test_mux.c:144
#define PTU_OUTPUT_TX_POWER
Definition: ptu_config.h:31
void print_hex(uint32_t number, uint8_t byte_size)
Converts hex number into char and send it through UART TX.
Definition: app_print.c:42
static bool force_debug_print
Definition: ptu_debug.c:60
#define MAX_RTC_COUNTER_VAL
Definition: ptu_debug.c:35
ptu_sm_state_t
PTU states.
Definition: ptu_sm.h:35
uint16_t power_amp_level
Definition: ptu_test_mux.h:38
#define ITX_INCREMENT
Definition: ptu_debug.c:32
#define POWERAMP_TEST_VAR_STEP_SIZE
Definition: ptu_hw_config.h:57
static bool m_uart_initialized
Definition: ptu_debug.c:58
#define VTX_INCREMENT
Definition: ptu_debug.c:31
void print_string(char *char_array)
Decomposes char array and send chars through UART TX.
Definition: app_print.c:25
Collection of PTU HAL variables that can be overrided by test multiplexer.
Definition: ptu_test_mux.h:35
#define EVT_STRING_LENGTH_MAX
Definition: ptu_debug.c:30
#define DEBUG_LINE_LENGTH
Definition: ptu_debug.c:29
uint32_t ptu_tmux_poweramp_enable_get(bool *enable)
Test wrapper for ptu_hal_poweramp_enable_get();.
Definition: ptu_test_mux.c:79
bool ptu_process_command_board(uint8_t cmd)
Function for processing board related test commands.
uint32_t ptu_sensors_data_get(const ptu_sensor_data_t **sensors_data)
Get the latest data read from the PTU sensors.
Definition: ptu_sensors.c:404
void tmux_get_select(tmux_select_t select)
Select source for all **tmux**get() functions.
Definition: pru_test_mux.c:135
#define PTU_Z_MEAS_BUF_LENGTH
Definition: ptu_config.h:79
pru_dynamic_t prev_pru_dynamic
Definition: ptu_registry.h:54
static void m_set_load_variation_detected(void)
Will syntesize a load representing a load variation to the sensors module. This will be set to true f...
Definition: ptu_debug.c:65
void debug(void)
Process debug commands.
Definition: ptu_debug.c:574
void tmux_set_select(tmux_select_t select)
Select whether override values shall be used when writing to **hal**set() functions.
Definition: pru_test_mux.c:140
uint32_t ptu_tmux_poweramp_level_get(uint16_t *p_level)
Test wrapper for ptu_hal_poweramp_level_get().
Definition: ptu_test_mux.c:86
void sm_uart_rx_poll(void)
Get and process uart commands.
Definition: ptu_debug.c:336
static char temp_string[DEBUG_LINE_LENGTH]
#define PTU_MAX_CONNECTIONS
Definition: ptu_config.h:29
void dfu_start(void)
Starts DFU mode. The function writes a special value to retention register to tell bootloader to star...
Definition: common.c:93
#define TEMPERATURE_INCREMENT
Definition: ptu_debug.c:33
#define SDK_VERSION
Definition: wpt.h:30
ptu_reg_item_state_t state
Definition: ptu_registry.h:49
static debug_output_t m_debug_output
Definition: ptu_debug.c:55
void line_print(void)
Print a DEBUG_LINE_LENGTH character long "horizontal line" to UART.
Definition: ptu_debug.c:363
void simple_uart_config(uint32_t baudrate, uint8_t rts_pin_number, uint8_t txd_pin_number, uint8_t cts_pin_number, uint8_t rxd_pin_number, bool hwfc)
UART configuration.
Definition: simple_uart.c:87
PRU Dynamic Parameter structure.
Definition: wpt.h:164
static void debug_output_print(void)
Print contents of m_debug_output to UART.
Definition: ptu_debug.c:494
Simple UART driver.
Definition of PTU sensor data.
Definition: ptu_hw_config.h:99
ptu_sm_state_t ptu_sm_execute(ptu_sm_signal_type_t signal, ptu_sm_state_vars_t *p_state)
State machine input signal handler.
Definition: ptu_sm.c:94