Nordic Semiconductor nRF5 AirFuel SDK  version 2.2.0
pru_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  */
12 
15 #include <string.h>
16 #include <stdio.h>
17 
18 #include "simple_uart.h"
19 #include "app_print.h"
20 #include "wpt.h"
21 #include "pru_sm.h"
22 #include "pru_hw_config.h"
23 #include "pru_test_mux.h"
24 #include "debug.h"
25 #include "ble_wpts.h"
26 #include "pru.h"
27 #include "ble.h"
28 #include "nrf_soc.h"
29 #include "softdevice_handler.h"
30 #include "nrf_sdm.h"
31 #include "pru_sensors.h"
32 #include "bsp.h"
33 
34 #define EVT_STRING_LENGTH_MAX 20
35 #define DEBUG_LINE_LENGTH 80
36 #define VRECT_INCREMENT 500
37 #define IRECT_INCREMENT 100
38 #define VOUT_INCREMENT 500
39 #define IOUT_INCREMENT 100
40 #define TEMPERATURE_INCREMENT 5
42 #define DEBUG_CONN_HANDLE 0
43 #define DEBUG_ALERT_VALUE_HANDLE 0x0f
45 /******************************************************************************/
46 
48 /******************************************************************************/
49 
53 typedef struct
54 {
55  pru_sm_state_t state;
56  pru_sensor_data_t sensor_data;
57  pru_control_t control_data;
58 } debug_output_t;
59 
60 static debug_output_t m_debug_output;
64 static bool m_uart_initialized = false;
65 static bool m_transmission_stopped = false;
66 static const ble_gap_addr_t MODE_TRANS_ADDRESS =
67  {.addr_type = BLE_GAP_ADDR_TYPE_RANDOM_STATIC,
68  .addr = {0xee, 0xee, 0xff, 0xff, 0xee, 0xee}};
78 {
80  {
81  memcpy(&m_latest_control_data_received, &p_evt->data.pru_control, sizeof(pru_control_t));
82  }
83 }
84 
93 bool pru_process_command_board(uint8_t cmd);
94 
95 
104 static bool m_uart_chars_available(void)
105 {
106  return (NRF_UART0->EVENTS_RXDRDY == 1);
107 }
108 
114 static void m_send_mode_transition_alert(uint8_t mode_trans_val, bool include_address)
115 {
116  uint32_t err_code;
117  uint8_t alert[BLE_WPTS_PRU_ALERT_MAX_LEN];
118  uint16_t hvx_len = BLE_WPTS_PRU_ALERT_MAX_LEN;
119  ble_gatts_hvx_params_t params;
120 
121  memset(alert, 0, BLE_WPTS_PRU_ALERT_MAX_LEN);
122  params.offset = 0;
123  params.handle = DEBUG_ALERT_VALUE_HANDLE;
124  params.type = BLE_GATT_HVX_INDICATION;
125  params.p_data = alert;
126  params.p_len = &hvx_len;
127 
131  mode_trans_val);
132 
133  if(include_address)
134  {
135  memcpy(&params.p_data[1], MODE_TRANS_ADDRESS.addr, 6); // Copy mode transition address
136 
137  err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &MODE_TRANS_ADDRESS);
138  APP_ERROR_CHECK(err_code);
139  }
140 
141 
142  else
143  memset(&params.p_data[1], 0, 6);
144 
145 
146  err_code = sd_ble_gatts_hvx(DEBUG_CONN_HANDLE, &params);
147  APP_ERROR_CHECK(err_code);
148 }
149 
150 
159 static bool m_pru_process_command_common(uint8_t cmd)
160 {
161  bool b_cmd_processed = true;
162  uint32_t err_code;
163 
164  pru_tmux_override_values_get(&override_values);
165 
166  switch (cmd)
167  {
168  case 'q':
169  print_string("Command: Power adjusted bit set");
170  override_values.power_adjusted = true;
171  print_string("\n\r");
172  break;
173 
174  case 'a':
175  print_string("Command: Power adjusted bit cleared");
176  override_values.power_adjusted = false;
177  print_string("\n\r");
178  break;
179 
180  case 'w':
181  print_string("Command: Inc IOUT -> ");
182  override_values.iout += IOUT_INCREMENT;
183  print_hex(override_values.iout, 2);
184  print_string("\n\r");
185  break;
186 
187  case 's':
188  print_string("Command: Dec IOUT -> ");
189  override_values.iout -= IOUT_INCREMENT;
190  print_hex(override_values.iout, 2);
191  print_string("\n\r");
192  break;
193 
194  case 'r':
195  print_string("Command: Inc VOUT -> ");
196  override_values.vout += VOUT_INCREMENT;
197  print_hex(override_values.vout, 2);
198  print_string("\n\r");
199  break;
200 
201  case 'f':
202  print_string("Command: Dec VOUT -> ");
203  override_values.vout -= VOUT_INCREMENT;
204  print_hex(override_values.vout, 2);
205  print_string("\n\r");
206  break;
207 
208  case 't':
209  print_string("Command: Wired charger on\n\r");
210  override_values.wired_charge_detect = true;
211  break;
212 
213  case 'g':
214  print_string("Command: Wired charger off\n\r");
215  override_values.wired_charge_detect = false;
216  break;
217 
218  case 'y':
219  print_string("Command: Inc VRECT -> ");
220  override_values.vrect += VRECT_INCREMENT;
221  print_hex(override_values.vrect, 2);
222  print_string("\n\r");
223  break;
224 
225  case 'h':
226  print_string("Command: Dec VRECT -> ");
227  override_values.vrect -= VRECT_INCREMENT;
228  print_hex(override_values.vrect, 2);
229  print_string("\n\r");
230  break;
231 
232  case 'u':
233  print_string("Command: Inc IRECT -> ");
234  override_values.irect += IRECT_INCREMENT;
235  print_hex(override_values.irect, 2);
236  print_string("\n\r");
237  break;
238 
239  case 'j':
240  print_string("Command: Dec IRECT -> ");
241  override_values.irect -= IRECT_INCREMENT;
242  print_hex(override_values.irect, 2);
243  print_string("\n\r");
244  break;
245 
246  case 'i':
247  print_string("Command: Inc TEMP -> ");
248  override_values.temperature += TEMPERATURE_INCREMENT;
249  print_hex(override_values.temperature, 2);
250  print_string("\n\r");
251  break;
252 
253  case 'k':
254  print_string("Command: Dec TEMP -> ");
255  override_values.temperature -= TEMPERATURE_INCREMENT;
256  print_hex(override_values.temperature, 2);
257  print_string("\n\r");
258  break;
259 
260  case 'o':
261  print_string("Command: Test-mode enabled\n\r");
262  tmux_get_select(TMUX_SELECT_OVERRIDE);
263  tmux_set_select(TMUX_SELECT_OVERRIDE);
264  break;
265 
266  case 'p':
267  print_string("SDK Version ");
269  print_string("\n\r");
270  break;
271 
272  case 'l':
273  print_string("Command: Test-mode disabled\n\r");
274  tmux_get_select(TMUX_SELECT_NO_OVERRIDE);
275  tmux_set_select(TMUX_SELECT_NO_OVERRIDE);
276  break;
277 
278  case 'z':
279  print_string("Command: Reset\r\n");
280  NVIC_SystemReset();
281  break;
282 
283  case 'x':
284  print_string("Command: Send Slave Security Request\n\r");
285 
286  ble_gap_sec_params_t sec_params;
287  memset(&sec_params, 0, sizeof(ble_gap_sec_params_t));
288  sec_params.mitm = 0;
289  sec_params.bond = 0;
290 
291  err_code = sd_ble_gap_authenticate(DEBUG_CONN_HANDLE, &sec_params);
292  APP_ERROR_CHECK(err_code);
293 
294  break;
295 
296  case 'n':
297  print_string("Command: Charge complete\n\r");
298  override_values.charge_complete = true;
299  break;
300 
301  case 'm':
302  print_string("Command: Charge incomplete\n\r");
303  override_values.charge_complete = false;
304  break;
305 
306  case '1':
307  print_string("Command: Vrect to PRU_VRECT_UVLO\n\r");
308  override_values.vrect = PRU_VRECT_UVLO;
309  break;
310 
311  case '2':
312  print_string("Command: Vrect to PRU_VRECT_BOOT\n\r");
313  override_values.vrect = PRU_VRECT_BOOT;
314  break;
315 
316  case '3':
317  print_string("Command: Vrect to PRU_VRECT_MIN\n\r");
318  override_values.vrect = PRU_VRECT_MIN;
319  break;
320 
321  case '4':
322  print_string("Command: Vrect to PRU_VRECT_HIGH\n\r");
323  override_values.vrect = (PRU_VRECT_HIGH);
324  break;
325 
326  case '5':
327  print_string("Command: Vrect to PRU_VRECT_MAX\n\r");
328  override_values.vrect = (PRU_VRECT_MAX);
329  break;
330 
331  case 'e':
333  break;
334 
335  case 'd':
337  break;
338 
339  case 'E':
341  break;
342 
343  case 'D':
345  break;
346 
347  case 'v':
349  {
350  print_string("Command: Stop packet transmission\n\r");
351  m_transmission_stopped = !m_transmission_stopped; // Need to do this before disabling the softdevice
352  (void)sd_softdevice_disable();
353  }
354 
355  else
356  {
357  print_string("Command: Start packet transmission\n\r");
359  nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
360  SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);
361  }
362  break;
363  case '6':
364  print_string("\n\rpru\n\r");
365  break;
366  case '7':
367  case '8':
368  #ifdef DFU_SUPPORT
369  print_string("Entering DFU mode ...\n\r");
370  dfu_start();
371  break;
372  #endif // DFU_SUPPORT
373 
374  case '9':
375  case 'c':
376  case '0':
377  case ',':
378  case '.':
379  default:
380  b_cmd_processed = false;
381  break;
382  }
383 
384  pru_tmux_override_values_set(&override_values);
385 
386  return b_cmd_processed;
387 }
388 
391 static void sm_uart_rx_poll(void)
392 {
393  uint8_t cmd;
394  bool b_cmd_processed;
395 
396  if (!m_uart_chars_available())
397  {
398  return;
399  }
400 
401  cmd = simple_uart_get();
402 
403  #ifdef PRU_TEST_HW_UART_CMD_ENABLE
404  b_cmd_processed = pru_process_command_board(cmd);
405  if (!b_cmd_processed) b_cmd_processed = m_pru_process_command_common(cmd);
406  #else
407  b_cmd_processed = m_pru_process_command_common(cmd);
408  #endif
409 
410  if (!b_cmd_processed)
411  {
412  print_string("\n\rCommand not implemented\n\r");
413  }
414 }
415 
419 static void line_print(void)
420 {
421  int i;
422 
423  for(i = 0; i < DEBUG_LINE_LENGTH; i++)
424  {
425  print_string("-");
426  }
427  print_string("\r\n");
428 }
429 
433 static bool debug_output_changed(void)
434 {
435  const pru_sensor_data_t * sensor_data;
436  bool changed = false;
437 
438  sensor_data = pru_sensors_data_get();
439 
441  {
442  changed = true;
444  }
445 
446  if(memcmp(&m_debug_output.sensor_data, sensor_data, sizeof(pru_sensor_data_t)) != 0)
447  {
448  changed = true;
449  memcpy(&m_debug_output.sensor_data, sensor_data, sizeof(pru_sensor_data_t));
450  }
451 
452  if(memcmp(&m_debug_output.control_data, &m_latest_control_data_received, sizeof(pru_control_t)))
453  {
454  changed = true;
455  memcpy(&m_debug_output.control_data, &m_latest_control_data_received, sizeof(pru_control_t));
456  }
457 
458  if(strlen(m_evt_evt_string) > 0)
459  {
460  changed = true;
461  }
462 
463  return changed;
464 }
465 
470 static char * m_state_string_get(pru_sm_state_t state)
471 {
472  switch(state)
473  {
474  case PRU_SM_STATE_NULL:
475  return "PRU Null";
476  case PRU_SM_STATE_BOOT:
477  return "PRU Boot";
478  case PRU_SM_STATE_PRU_ON:
479  return "PRU On";
480  case PRU_SM_STATE_SYSTEM_ERROR:
481  return "PRU System Er-or";
482  default:
483  return "Invalid state";
484  }
485 
486 }
487 
490 static void debug_output_print(void)
491 {
494  // Status
495  line_print();
496  print_string("StatusStart\r\n");
497  line_print();
498  print_string("State\r\n");
499  sprintf(temp_string, "%s\r\n", m_state_string_get(m_debug_output.state));
500  print_string(temp_string);
501 
502  // Dynamic parameters
503  line_print();
504  print_string("Dynamic parameters\r\n");
505  line_print();
506  print_string("Vrect\tIrect\tVout\tIout\tTemp\tCharged\tP_adj\r\n");
507  sprintf(temp_string, "%u\t%u\t%u\t%u\t%d\t%u\t%u\r\n",
508  m_debug_output.sensor_data.vrect,
509  m_debug_output.sensor_data.irect,
510  m_debug_output.sensor_data.vout,
511  m_debug_output.sensor_data.iout,
512  m_debug_output.sensor_data.temperature,
513  m_debug_output.sensor_data.charge_complete,
514  m_debug_output.sensor_data.power_adjusted);
515 
516  print_string(temp_string);
517 
518  // Static parameters
519  line_print();
520  print_string("Static parameters\r\n");
521  line_print();
522  print_string("Vrset\tVrmin\tVrhigh\tTempmax\tVrmax\tPrmax\r\n");
523  sprintf(temp_string, "%u\t%u\t%u\t%u\t%u\t%u\r\n",
527  PRU_TEMP_MAX,
529  PRU_PRECT_MAX);
530  print_string(temp_string);
531 
532  // Previous received control data
533  line_print();
534  print_string("Control packet\r\n");
535  line_print();
536 
537  print_string("En_out\tEn_Chin\tAdj_pow\tPerm\tTset\r\n");
538  sprintf(temp_string, "%u\t%u\t%u\t%u\t%u\r\n",
539  m_debug_output.control_data.enable_pru_output,
540  m_debug_output.control_data.enable_pru_charge_indicator,
541  m_debug_output.control_data.adj_power,
542  m_debug_output.control_data.permissions,
543  m_debug_output.control_data.time_set);
544  print_string(temp_string);
545 
546  // Print event message
547  if(strlen(m_evt_evt_string) > 0)
548  {
549  print_string("\r\n");
551  sprintf(m_evt_evt_string, "");
552  }
553 
554  print_string("StatusEnd\r\n");
555 }
556 
559 /******************************************************************************/
562 /******************************************************************************/
563 
564 void debug(void)
565 {
566  if (!m_uart_initialized)
567  {
568  simple_uart_config(UART_BAUDRATE_BAUDRATE_Baud460800, RTS_PIN_NUMBER, TX_PIN_NUMBER, CTS_PIN_NUMBER, RX_PIN_NUMBER, HWFC);
569  m_uart_initialized = true;
570  }
572  {
574  }
575  sm_uart_rx_poll();
576 }
577 
578 void debug_add_string(const char *s)
579 {
580  sprintf(m_evt_evt_string, "%s", s);
581 }
582 
static void debug_output_print(void)
Print contents of m_debug_output to UART.
Definition: pru_debug.c:490
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
bool pru_process_command_board(uint8_t cmd)
Function for processing board specific test commands.
#define IRECT_INCREMENT
Definition: pru_debug.c:37
#define PRU_VRECT_MIN
Definition: pru_hw_config.h:25
PRU Control structure.
Definition: wpt.h:79
static bool m_transmission_stopped
Definition: pru_debug.c:65
#define PRU_VRECT_HIGH
Definition: pru_hw_config.h:27
static char * m_state_string_get(pru_sm_state_t state)
Convert state enum to string.
Definition: pru_debug.c:470
#define BLE_WPTS_PRU_ALERT_POS
PRU alert characteristic byte positions.
#define PRU_TEMP_MAX
Definition: pru_hw_config.h:30
static bool m_uart_chars_available(void)
Check if there are any characters in the UART receive buffer.
Definition: pru_debug.c:104
static bool debug_output_changed(void)
Update m_debug_output variable.
Definition: pru_debug.c:433
#define BLE_WPTS_PRU_ALERT_MODE_TRANSITION_BITPOS
#define VRECT_INCREMENT
Definition: pru_debug.c:36
#define BLE_WPTS_PRU_ALERT_MAX_LEN
#define VOUT_INCREMENT
Definition: pru_debug.c:38
const pru_sensor_data_t * pru_sensors_data_get(void)
Get the latest data from the PRU sensors.
Definition: pru_sensors.c:146
void debug_add_string(const char *s)
Add string to debug output.
Definition: pru_debug.c:578
Definition of PRU reporting data.
Definition: pru_sensors.h:26
#define BLE_WPTS_BITFIELD_WRITE(bitfield, msk, pos, val)
Write bitfield.
void wpts_test_evt_handle_cb(ble_wpts_t *p_wpts, ble_wpts_evt_t *p_evt)
Override weak wpts_test_evt_handle_cb()
Definition: pru_debug.c:77
static char m_evt_evt_string[EVT_STRING_LENGTH_MAX]
Definition: pru_debug.c:61
#define IOUT_INCREMENT
Definition: pru_debug.c:39
#define BLE_WPTS_PRU_ALERT_MODE_TRANSITION_BITMSK
pru_sm_state_t
PRU states.
Definition: pru_sm.h:26
#define PRU_VRECT_BOOT
Definition: pru_hw_config.h:23
ble_wpts_evt_type_t evt_type
Definition: ble_wpts.h:43
#define BLE_WPTS_PRU_ALERT_MODE_6S_MODE_TRANSITION_VAL
#define PRU_VRECT_SET
Definition: pru_hw_config.h:26
void pru_tmux_override_values_set(pru_tmux_override_t *values)
Set override values.
Definition: pru_test_mux.c:146
#define PRU_VRECT_MAX
Definition: pru_hw_config.h:28
WPT Service event.
Definition: ble_wpts.h:41
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 m_pru_process_command_common(uint8_t cmd)
Function for processing common test commands.
Definition: pru_debug.c:159
#define BLE_WPTS_PRU_ALERT_MODE_3S_MODE_TRANSITION_VAL
static bool m_uart_initialized
Definition: pru_debug.c:64
static pru_tmux_override_t override_values
Definition: pru_debug.c:62
#define PRU_PRECT_MAX
Definition: pru_hw_config.h:43
#define DEBUG_LINE_LENGTH
Definition: pru_debug.c:35
union ble_wpts_evt_t::@0 data
Collection of PRU HAL variables that can be overrided by test multiplexer.
Definition: pru_test_mux.h:36
void print_string(char *char_array)
Decomposes char array and send chars through UART TX.
Definition: app_print.c:25
static void line_print(void)
Print a DEBUG_LINE_LENGTH character long "horizontal line" to UART.
Definition: pru_debug.c:419
#define EVT_STRING_LENGTH_MAX
Definition: pru_debug.c:34
pru_control_t pru_control
Definition: ble_wpts.h:46
static const ble_gap_addr_t MODE_TRANS_ADDRESS
Definition: pru_debug.c:66
#define PRU_VRECT_UVLO
Definition: pru_hw_config.h:24
void pru_tmux_override_values_get(pru_tmux_override_t *values)
Get ovveride values.
Definition: pru_test_mux.c:152
void tmux_get_select(tmux_select_t select)
Select source for all **tmux**get() functions.
Definition: pru_test_mux.c:135
static pru_control_t m_latest_control_data_received
Definition: pru_debug.c:63
pru_sm_state_t pru_sm_execute(pru_sm_signal_type_t sig, pru_sm_state_vars_t *p_state)
Execute state machine.
Definition: pru_sm.c:71
static void sm_uart_rx_poll(void)
Get and process uart commands.
Definition: pru_debug.c:391
void debug(void)
Process debug commands.
Definition: pru_debug.c:564
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
static char temp_string[DEBUG_LINE_LENGTH]
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
WPT Service status structure.
Definition: ble_wpts.h:71
#define SDK_VERSION
Definition: wpt.h:30
#define DEBUG_CONN_HANDLE
Definition: pru_debug.c:42
#define TEMPERATURE_INCREMENT
Definition: pru_debug.c:40
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
static debug_output_t m_debug_output
Definition: pru_debug.c:60
static void m_send_mode_transition_alert(uint8_t mode_trans_val, bool include_address)
Send Mode Transition alert to PTU.
Definition: pru_debug.c:114
Simple UART driver.
#define DEBUG_ALERT_VALUE_HANDLE
Definition: pru_debug.c:43