Nordic Semiconductor nRF5 AirFuel SDK  version 2.2.0
ptu_wireless_debug.c
Go to the documentation of this file.
1 /* Copyright (c) 2013 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  * $LastChangedRevision$
12  */
13 
14 #include <string.h>
15 #include <stdio.h>
16 
17 #include "wpt.h"
18 #include "nrf_soc.h"
19 #include "app_util_platform.h"
20 #include "ptu_sm.h"
21 #include "ptu_test_mux.h"
22 #include "ptu_registry.h"
23 #include "ptu_sensors.h"
24 #include "bsp.h"
25 #include "wireless_debug.h"
26 #include "nrf_gzll.h"
27 #include "nrf_assert.h"
28 
34 #define DEBUG_LINE_LENGTH 80
35 #define EVT_STRING_LENGTH_MAX 20
36 #define VTX_INCREMENT 1000
37 #define ITX_INCREMENT 100
38 #define TEMPERATURE_INCREMENT 10
39 #define PIPE_NUMBER 0
40 #define TX_PAYLOAD_LENGTH 32
41 #define UPDATE_INTERVAL 200
46 typedef struct
47 {
48  ptu_sm_state_t current_state;
50  bool link_encrypted[PTU_MAX_CONNECTIONS];
51  ptu_sensor_data_t sensor_data;
53  uint8_t ptu_dbg_flags;
54  uint8_t registered_prus;
55 } debug_output_t;
56 
57 
60 static debug_output_t m_debug_output;
63 static bool m_simplified_beacon_print = false;
64 static bool m_debug_print = false;
65 static uint8_t debug_pkt[TX_PAYLOAD_LENGTH];
66 extern bool gzll_initialized;
73 static void debug_print_string(const char *str)
74 {
75  size_t len = strlen(str);
76  ASSERT(len < (TX_PAYLOAD_LENGTH-1));
77  if(len < (TX_PAYLOAD_LENGTH-1))
78  {
79  strncpy((char *)&debug_pkt[1], str, len);
80  debug_pkt[len+1] = 0;
81  m_debug_print = true;
82  }
83 }
84 
85 
90 {
91  override_values.power_amp_enable = true;
92 
93  for(uint8_t i = 0; i < PTU_Z_MEAS_BUF_LENGTH; ++i)
94  {
95  if(i == 0) // First call
96  override_values.vtx = 10 * (PTU_ITX_MIN * PTU_Z_TX_IN_LOAD_DETECT) + 1; // Make sure v/i > Z_TX_IN_LOAD_DETECTED
97 
98  else // non - first call
99  override_values.vtx = 1;
100 
101  override_values.itx = PTU_ITX_MIN;
102 
103  ptu_tmux_override_values_set(&override_values);
104 
105  (void)ptu_sensors_read(); // Triggers call to load variation detection
106  }
107 
108  override_values.power_amp_enable = false;
109 
110  ptu_tmux_override_values_set(&override_values);
111 
112  (void)ptu_sensors_read(); // Triggers call to load variation detection
113 
114 }
115 
124 static bool m_ptu_process_command_common(uint8_t cmd)
125 {
126  bool cmd_processed = true;
127  uint32_t err_code;
128 
129  ptu_tmux_override_values_get(&override_values);
130 
131  switch (cmd)
132  {
133  case 'z':
134  // Reset
135  debug_print_string("\n\rCommand: Reset\r\n");
136  NVIC_SystemReset();
137  break;
138 
139  case 'b':
140  // Beacon debug print
142  debug_print_string("\n\rCommand: Beacon debug print disabled\r\n");
143  else
144  debug_print_string("\n\rCommand: Beacon debug print enabled\r\n");
146  break;
147 
148  case 'y':
149  override_values.vtx += VTX_INCREMENT;
150  sprintf(temp_string, "\n\rCommand: Inc VTX -> %04X\r\n", override_values.vtx);
152  break;
153 
154  case 'h':
155  override_values.vtx -= VTX_INCREMENT;
156  sprintf(temp_string, "\n\rCommand: Dec VTX -> %04X\r\n", override_values.vtx);
158  break;
159 
160  case 'u':
161  override_values.itx += ITX_INCREMENT;
162  sprintf(temp_string, "\n\rCommand: Inc ITX -> %04X\r\n", override_values.itx);
164  break;
165 
166  case 'j':
167  override_values.itx -= ITX_INCREMENT;
168  sprintf(temp_string, "\n\rCommand: Dec ITX -> %04X\r\n", override_values.itx);
170  break;
171 
172  case 'i':
173  override_values.temperature += TEMPERATURE_INCREMENT;
174  sprintf(temp_string, "\n\rCommand: Inc temperature -> %04X\r\n", override_values.temperature);
176  break;
177 
178  case 'k':
179  override_values.temperature -= TEMPERATURE_INCREMENT;
180  sprintf(temp_string, "\n\rCommand: Dec temperature -> %04X\r\n", override_values.temperature);
181  debug_print_string("\n\r");
182  break;
183 
184  case 'o':
185  debug_print_string("\n\rCommand: Test-mode enabled\n\r");
186  tmux_set_select(TMUX_SELECT_OVERRIDE);
187  tmux_get_select(TMUX_SELECT_OVERRIDE);
188  break;
189 
190  case 'p':
191  debug_print_string("SDK Version ");
193  debug_print_string("\n\r");
194  break;
195 
196  case 'l':
197  debug_print_string("\n\rCommand: Test-mode disabled\n\r");
198  tmux_set_select(TMUX_SELECT_NO_OVERRIDE);
199  tmux_get_select(TMUX_SELECT_NO_OVERRIDE);
200  break;
201 
202  case 'n':
203  debug_print_string("\n\rCommand: TX power set to -40dBm\n\r");
204  err_code = sd_ble_gap_tx_power_set(-40);
205  APP_ERROR_CHECK(err_code);
206  break;
207 
208  case 'm':
209  debug_print_string("\n\rCommand: TX power set to PTU_OUTPUT_TX_POWER\n\r");
210  err_code = sd_ble_gap_tx_power_set(PTU_OUTPUT_TX_POWER);
211  APP_ERROR_CHECK(err_code);
212  break;
213 
214  case 'v':
215  debug_print_string("\n\rCommand: Set Load Variation TRUE\n\r");
217  break;
218 
219 
220  case '2':
221  debug_print_string("\n\rCommand: Resonator ON\n\r");
222  override_values.power_amp_enable = true;
223  break;
224 
225  case '3':
226  debug_print_string("\n\rCommand: Resonator OFF\n\r");
227  override_values.power_amp_enable = true;
228  break;
229 
230  case '4':
231  override_values.power_amp_level += POWERAMP_TEST_VAR_STEP_SIZE;
232  sprintf(temp_string, "\n\rCommand: Inc poweramp level -> %04X\r\n", override_values.power_amp_level);
234  break;
235 
236  case '5':
237  override_values.power_amp_level -= POWERAMP_TEST_VAR_STEP_SIZE;
238  sprintf(temp_string, "\n\rCommand: Dec poweramp level -> %04X\r\n", override_values.power_amp_level);
240  break;
241 
242  case '6':
243  debug_print_string("\n\rptu\n\r");
244  break;
245 
246  case '7':
247  sprintf(temp_string, "ptu_reg_n_entries_get=%02X\r\n", ptu_reg_n_entries_get());
249  break;
250 
251  case '8':
252  #ifdef DFU_SUPPORT
253  debug_print_string("Entering DFU mode ...\n\r");
254  dfu_start();
255  break;
256  #endif //DFU_SUPPORT
257 
258  default:
259  cmd_processed = false;
260  break;
261  }
262 
263  ptu_tmux_override_values_set(&override_values);
264 
265  return cmd_processed;
266 }
267 
276 bool ptu_process_command_board(uint8_t cmd);
277 
280 void cmd_poll(void)
281 {
282  uint8_t cmd = 0;
283  bool b_cmd_processed;
284  if (!debug_cmd_available())
285  {
286  return;
287  }
288 
289  cmd = get_debug_cmd();
290  b_cmd_processed = m_ptu_process_command_common(cmd);
291  if (!b_cmd_processed)
292  {
293  debug_print_string("\n\rCommand not implemented");
294  }
295 }
296 
300 void line_print(void)
301 {
302  int i;
303 
304  for(i = 0; i < DEBUG_LINE_LENGTH; i++)
305  {
306  debug_print_string("-");
307  }
308  debug_print_string("\r\n");
309 }
310 
314 static bool debug_output_changed(void)
315 {
316  int i;
317  bool changed = false;
318  uint32_t err_code;
319  const ptu_sensor_data_t* sensor_data;
320  uint16_t current_powerlevel;
321  bool current_poweramp_status;
322  static bool prev_poweramp_status;
323  static uint32_t prev_powerlevel;
324  ptu_reg_item_t * p_reg_item;
325 
326  err_code = ptu_sensors_data_get(&sensor_data);
327  APP_ERROR_CHECK(err_code);
328 
329  if(m_simplified_beacon_print && m_debug_output.current_state == PTU_SM_STATE_POWER_SAVE)
330  {
331  (void)ptu_tmux_poweramp_enable_get(&current_poweramp_status);
332  (void)ptu_tmux_poweramp_level_get(&current_powerlevel);
333 
334  // Beacon status has changed
335  if((prev_poweramp_status != current_poweramp_status) || (prev_powerlevel != current_powerlevel))
336  {
337  if(current_poweramp_status && current_powerlevel == PTU_POWERAMP_INPUT_BEACON_SHORT)
338  debug_print_string("s");
339  else if(current_poweramp_status && current_powerlevel == PTU_POWERAMP_INPUT_BEACON_LONG)
340  {
341  debug_print_string("e\n\r");
342  debug_print_string("l");
343  }
344 
345  if(!current_poweramp_status)
346  debug_print_string("e\n\r");
347  }
348  prev_poweramp_status = current_poweramp_status;
349  prev_powerlevel = current_powerlevel;
350  }
351 
352 
353  if(m_debug_output.current_state != ptu_sm_execute(PTU_SM_SIGNAL_NULL, NULL))
354  {
355  changed = true;
356  m_debug_output.current_state = ptu_sm_execute(PTU_SM_SIGNAL_NULL, NULL);
357  }
358 
359  if(memcmp(&m_debug_output.sensor_data, sensor_data, sizeof(ptu_sensor_data_t)) != 0)
360  {
361  changed = true;
362  memcpy(&m_debug_output.sensor_data, sensor_data, sizeof(ptu_sensor_data_t));
363  m_debug_output.ptu_dbg_flags = (uint8_t)sensor_data->load_detected
364  | (uint8_t)sensor_data->load_var_detected << 1
365  | (uint8_t)sensor_data->rogue_obj_detected << 2;
366  }
367 
368  uint8_t registered_prus = 0;
369  for(i = 0; i < PTU_MAX_CONNECTIONS; i++)
370  {
371  pru_changed[i] = false;
372  (void)ptu_reg_item_get_from_index(i, &p_reg_item);
373 
374  if (p_reg_item->state == REG_ITEM_STATE_REGISTERED)
375  {
376  registered_prus |= 1 << i;
377  }
378  if(m_debug_output.reg_item_state[i] != p_reg_item->state)
379  {
380  if (p_reg_item->state == REG_ITEM_STATE_REGISTERED)
381  changed = pru_changed[i] = true;
382  m_debug_output.reg_item_state[i] = p_reg_item->state;
383  }
384 
385  if(m_debug_output.link_encrypted[i] != p_reg_item->link_encrypted)
386  {
387  if (p_reg_item->state == REG_ITEM_STATE_REGISTERED)
388  changed = pru_changed[i] = true;
389  m_debug_output.link_encrypted[i] = p_reg_item->link_encrypted;
390  }
391 
392  if(memcmp(&m_debug_output.dyn_params[i], &p_reg_item->prev_pru_dynamic, sizeof(pru_dynamic_t)) != 0)
393  {
394  if (p_reg_item->state == REG_ITEM_STATE_REGISTERED)
395  changed = pru_changed[i] = true;
396  memcpy(&m_debug_output.dyn_params[i], &p_reg_item->prev_pru_dynamic, sizeof(pru_dynamic_t));
397  }
398  }
399  if (m_debug_output.registered_prus != registered_prus)
400  {
401  m_debug_output.registered_prus = registered_prus;
402  changed = true;
403  }
404 
405  if(strlen(m_evt_evt_string) > 0)
406  {
407  changed = true;
408  }
409 
410  return changed;
411 }
412 
417 void get_pru_data(int n, uint8_t *buf)
418 {
419  buf[0] = (uint8_t)(m_debug_output.dyn_params[n].vrect >> 8);
420  buf[1] = (uint8_t)m_debug_output.dyn_params[n].vrect;
421  buf[2] = (uint8_t)(m_debug_output.dyn_params[n].irect >> 8);
422  buf[3] = (uint8_t)m_debug_output.dyn_params[n].irect;
423  buf[4] = (uint8_t)(m_debug_output.dyn_params[n].vout >> 8);
424  buf[5] = (uint8_t)m_debug_output.dyn_params[n].vout;
425  buf[6] = (uint8_t)(m_debug_output.dyn_params[n].iout >> 8);
426  buf[7] = (uint8_t)m_debug_output.dyn_params[n].iout;
427  buf[8] = (uint8_t)(m_debug_output.dyn_params[n].prect >> 8);
428  buf[9] = (uint8_t)m_debug_output.dyn_params[n].prect;
429  buf[10]= (uint8_t)m_debug_output.dyn_params[n].putil;
430  buf[11]= (uint8_t)(m_debug_output.dyn_params[n].temperature >> 8);
431  buf[12]= (uint8_t)m_debug_output.dyn_params[n].temperature;
432  buf[13]= (uint8_t)m_debug_output.dyn_params[n].alerts.charge_complete | (uint8_t)m_debug_output.link_encrypted[n] << 1;
433 }
434 
435 void debug(void)
436 {
437  int i;
438  uint32_t pkt_len = 0;
439  static bool more_data;
440  static bool gzll_ok = true;
441  static uint32_t old_ticks;
442 
443  if (gzll_ok)
444  {
445  uint32_t curr_ticks;
446  (void)app_timer_cnt_get(&curr_ticks);
447  pkt_len = 0;
448  if (debug_pkt[0] == DEBUG_STR)
449  m_debug_print = false;
450  if (!more_data)
451  {
452  more_data = debug_output_changed();
453  }
454  if (m_debug_print)
455  {
456  debug_pkt[0] = DEBUG_STR;
457  m_debug_print = false;
458  pkt_len = strlen((const char *)debug_pkt) + 1;
459  } else if(more_data)
460  {
461  debug_pkt[0] = DEBUG_PTU;
462  debug_pkt[1] = (uint8_t)(curr_ticks >> 24);
463  debug_pkt[2] = (uint8_t)(curr_ticks >> 16);
464  debug_pkt[3] = (uint8_t)(curr_ticks >> 8);
465  debug_pkt[4] = (uint8_t)curr_ticks;
466  debug_pkt[5] = (uint8_t)m_debug_output.current_state;
467  debug_pkt[6] = m_debug_output.ptu_dbg_flags;
468  debug_pkt[7] = (uint8_t)(m_debug_output.sensor_data.res_impedance >> 8);
469  debug_pkt[8] = (uint8_t)m_debug_output.sensor_data.res_impedance;
470  debug_pkt[9] = (uint8_t)(m_debug_output.sensor_data.v_ina >> 8);
471  debug_pkt[10]= (uint8_t)m_debug_output.sensor_data.v_ina;
472  debug_pkt[11]= (uint8_t)(m_debug_output.sensor_data.i_ina >> 8);
473  debug_pkt[12]= (uint8_t)m_debug_output.sensor_data.i_ina;
474  debug_pkt[13]= (uint8_t)(m_debug_output.sensor_data.temperature >> 8);
475  debug_pkt[14]= (uint8_t)m_debug_output.sensor_data.temperature;
476  debug_pkt[15] = m_debug_output.registered_prus;
477  debug_pkt[16] = 0;
478  for(i = 0; i < PTU_MAX_CONNECTIONS; i++)
479  {
480  if (pru_changed[i])
481  {
482  debug_pkt[16] = (uint8_t)(DEBUG_PRU0 + i);
483  get_pru_data(i, &debug_pkt[17]);
484  pru_changed[i] = false;
485  break;
486  }
487  }
488  more_data = false;
489  for (i=0;i < PTU_MAX_CONNECTIONS; i++)
490  {
491  if (pru_changed[i])
492  {
493  more_data = true;
494  break;
495  }
496  }
497  pkt_len = TX_PAYLOAD_LENGTH;
498  }
499  else
500  {
501  if (ticks_diff(curr_ticks, old_ticks)/32 > UPDATE_INTERVAL)
502  {
503  debug_pkt[0] = DEBUG_POLL;
504  pkt_len = 1;
505  old_ticks = curr_ticks;
506  }
507  }
508  }
509  if (pkt_len > 0)
510  {
511  gzll_ok = nrf_gzll_add_packet_to_tx_fifo(PIPE_NUMBER, debug_pkt, pkt_len);
512  }
513  else
514  {
515  gzll_ok = true;
516  }
517  cmd_poll();
518 }
#define EVT_STRING_LENGTH_MAX
static debug_output_t m_debug_output
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...
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
void get_pru_data(int n, uint8_t *buf)
Read PRU debug data.
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
#define PTU_POWERAMP_INPUT_BEACON_LONG
Definition: ptu_hw_config.h:60
#define ITX_INCREMENT
uint32_t ticks_diff(uint32_t ticks_now, uint32_t ticks_old)
Definition: common.c:78
#define PTU_ITX_MIN
Definition: ptu_hw_config.h:87
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
#define TX_PAYLOAD_LENGTH
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
#define VTX_INCREMENT
#define PTU_POWERAMP_INPUT_BEACON_SHORT
Definition: ptu_hw_config.h:59
#define PIPE_NUMBER
#define DEBUG_LINE_LENGTH
static ptu_tmux_override_t override_values
static void debug_print_string(const char *str)
Function for writing a string to the debug packet.
static bool debug_output_changed(void)
Update m_debug_output variable.
void cmd_poll(void)
Get and process uart commands.
#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
bool debug_cmd_available(void)
Check if debug command received from dongle.
void line_print(void)
Print a DEBUG_LINE_LENGTH character long "horizontal line" to UART.
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
static bool m_simplified_beacon_print
bool gzll_initialized
ptu_sm_state_t
PTU states.
Definition: ptu_sm.h:35
uint16_t power_amp_level
Definition: ptu_test_mux.h:38
#define POWERAMP_TEST_VAR_STEP_SIZE
Definition: ptu_hw_config.h:57
static bool pru_changed[PTU_MAX_CONNECTIONS]
Collection of PTU HAL variables that can be overrided by test multiplexer.
Definition: ptu_test_mux.h:35
uint32_t ptu_tmux_poweramp_enable_get(bool *enable)
Test wrapper for ptu_hal_poweramp_enable_get();.
Definition: ptu_test_mux.c:79
#define TEMPERATURE_INCREMENT
static uint8_t debug_pkt[TX_PAYLOAD_LENGTH]
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
static char m_evt_evt_string[EVT_STRING_LENGTH_MAX]
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
bool ptu_process_command_board(uint8_t cmd)
Function for processing board related test commands.
void debug(void)
Process debug commands.
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
#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 SDK_VERSION
Definition: wpt.h:30
ptu_reg_item_state_t state
Definition: ptu_registry.h:49
#define UPDATE_INTERVAL
PRU Dynamic Parameter structure.
Definition: wpt.h:164
char get_debug_cmd(void)
get debug command received from dongle
static bool m_ptu_process_command_common(uint8_t cmd)
Function for processing common test commands.
static char temp_string[DEBUG_LINE_LENGTH]
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
static bool m_debug_print