raspiezo / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   Nucleo_L432KC_Quadrature_Decoder_with_ADC_and_DAC

Fork of mbed-dev by mbed official

targets/TARGET_NORDIC/TARGET_NRF5/sdk/libraries/util/nrf_log.c@161:bd0311f1ad86, 2017-05-27 (annotated)

Committer:
tonnyleonard
Date:
Sat May 27 01:26:18 2017 +0000
Revision:
161:bd0311f1ad86
Parent:
150:02e0a0aed4ec 
Testing ADC with shunt

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 #include "nrf.h"
<> 144:ef7eb2e8f9f7 2 #include "nrf_log.h"
<> 144:ef7eb2e8f9f7 3 #include "nrf_error.h"
<> 144:ef7eb2e8f9f7 4 #include <stdarg.h>
<> 144:ef7eb2e8f9f7 5 #include <string.h>
<> 144:ef7eb2e8f9f7 6 #include <stdio.h>
<> 144:ef7eb2e8f9f7 7
<> 144:ef7eb2e8f9f7 8 #if defined(NRF_LOG_USES_RTT) && NRF_LOG_USES_RTT == 1
<> 144:ef7eb2e8f9f7 9
<> 144:ef7eb2e8f9f7 10 #include <SEGGER_RTT_Conf.h>
<> 144:ef7eb2e8f9f7 11 #include <SEGGER_RTT.h>
<> 144:ef7eb2e8f9f7 12
<> 144:ef7eb2e8f9f7 13 static char buf_normal_up[BUFFER_SIZE_UP];
<> 144:ef7eb2e8f9f7 14 static char buf_down[BUFFER_SIZE_DOWN];
<> 144:ef7eb2e8f9f7 15
<> 144:ef7eb2e8f9f7 16 uint32_t log_rtt_init(void)
<> 144:ef7eb2e8f9f7 17 {
<> 144:ef7eb2e8f9f7 18 static bool initialized = false;
<> 144:ef7eb2e8f9f7 19 if (initialized)
<> 144:ef7eb2e8f9f7 20 {
<> 144:ef7eb2e8f9f7 21 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 22 }
<> 144:ef7eb2e8f9f7 23
<> 144:ef7eb2e8f9f7 24 if (SEGGER_RTT_ConfigUpBuffer(LOG_TERMINAL_NORMAL,
<> 144:ef7eb2e8f9f7 25 "Normal",
<> 144:ef7eb2e8f9f7 26 buf_normal_up,
<> 144:ef7eb2e8f9f7 27 BUFFER_SIZE_UP,
<> 144:ef7eb2e8f9f7 28 SEGGER_RTT_MODE_NO_BLOCK_TRIM
<> 144:ef7eb2e8f9f7 29 )
<> 144:ef7eb2e8f9f7 30 != 0)
<> 144:ef7eb2e8f9f7 31 {
<> 144:ef7eb2e8f9f7 32 return NRF_ERROR_INVALID_STATE;
<> 144:ef7eb2e8f9f7 33 }
<> 144:ef7eb2e8f9f7 34
<> 144:ef7eb2e8f9f7 35 if (SEGGER_RTT_ConfigDownBuffer(LOG_TERMINAL_INPUT,
<> 144:ef7eb2e8f9f7 36 "Input",
<> 144:ef7eb2e8f9f7 37 buf_down,
<> 144:ef7eb2e8f9f7 38 BUFFER_SIZE_DOWN,
<> 144:ef7eb2e8f9f7 39 SEGGER_RTT_MODE_NO_BLOCK_SKIP
<> 144:ef7eb2e8f9f7 40 )
<> 144:ef7eb2e8f9f7 41 != 0)
<> 144:ef7eb2e8f9f7 42 {
<> 144:ef7eb2e8f9f7 43 return NRF_ERROR_INVALID_STATE;
<> 144:ef7eb2e8f9f7 44 }
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 initialized = true;
<> 144:ef7eb2e8f9f7 47
<> 144:ef7eb2e8f9f7 48 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 49 }
<> 144:ef7eb2e8f9f7 50
<> 144:ef7eb2e8f9f7 51 // Forward declaration of SEGGER RTT vprintf function
<> 144:ef7eb2e8f9f7 52 int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
<> 144:ef7eb2e8f9f7 53
<> 144:ef7eb2e8f9f7 54 void log_rtt_printf(int terminal_index, char * format_msg, ...)
<> 144:ef7eb2e8f9f7 55 {
<> 144:ef7eb2e8f9f7 56 //lint -save -e526 -e628 -e530
<> 144:ef7eb2e8f9f7 57 va_list p_args;
<> 144:ef7eb2e8f9f7 58 va_start(p_args, format_msg);
<> 144:ef7eb2e8f9f7 59 (void)SEGGER_RTT_vprintf(terminal_index, format_msg, &p_args);
<> 144:ef7eb2e8f9f7 60 va_end(p_args);
<> 144:ef7eb2e8f9f7 61 //lint -restore
<> 144:ef7eb2e8f9f7 62 }
<> 144:ef7eb2e8f9f7 63
<> 144:ef7eb2e8f9f7 64 __INLINE void log_rtt_write_string(int terminal_index, int num_args, ...)
<> 144:ef7eb2e8f9f7 65 {
<> 144:ef7eb2e8f9f7 66 const char* msg;
<> 144:ef7eb2e8f9f7 67 //lint -save -e516 -e530
<> 144:ef7eb2e8f9f7 68 va_list p_args;
<> 144:ef7eb2e8f9f7 69 va_start(p_args, num_args);
<> 144:ef7eb2e8f9f7 70 //lint -restore
<> 144:ef7eb2e8f9f7 71
<> 144:ef7eb2e8f9f7 72 for (int i = 0; i < num_args; i++)
<> 144:ef7eb2e8f9f7 73 {
<> 144:ef7eb2e8f9f7 74 //lint -save -e26 -e10 -e64 -e526 -e628 -e530
<> 144:ef7eb2e8f9f7 75 msg = va_arg(p_args, const char*);
<> 144:ef7eb2e8f9f7 76 //lint -restore
<> 144:ef7eb2e8f9f7 77 (void)SEGGER_RTT_WriteString(terminal_index, msg);
<> 144:ef7eb2e8f9f7 78 }
<> 144:ef7eb2e8f9f7 79 va_end(p_args);
<> 144:ef7eb2e8f9f7 80 }
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 void log_rtt_write_hex(int terminal_index, uint32_t value)
<> 144:ef7eb2e8f9f7 83 {
<> 144:ef7eb2e8f9f7 84 char temp[11];
<> 144:ef7eb2e8f9f7 85 temp[0] = '0';
<> 144:ef7eb2e8f9f7 86 temp[1] = 'x';
<> 144:ef7eb2e8f9f7 87 temp[10] = 0; // Null termination
<> 144:ef7eb2e8f9f7 88 uint8_t nibble;
<> 144:ef7eb2e8f9f7 89 uint8_t i = 8;
<> 144:ef7eb2e8f9f7 90
<> 144:ef7eb2e8f9f7 91 while(i-- != 0)
<> 144:ef7eb2e8f9f7 92 {
<> 144:ef7eb2e8f9f7 93 nibble = (value >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 94 temp[9-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
<> 144:ef7eb2e8f9f7 95 }
<> 144:ef7eb2e8f9f7 96
<> 144:ef7eb2e8f9f7 97 (void)SEGGER_RTT_WriteString(terminal_index, temp);
<> 144:ef7eb2e8f9f7 98 }
<> 144:ef7eb2e8f9f7 99
<> 144:ef7eb2e8f9f7 100 void log_rtt_write_hex_char(int terminal_index, uint8_t value)
<> 144:ef7eb2e8f9f7 101 {
<> 144:ef7eb2e8f9f7 102 char temp[3];
<> 144:ef7eb2e8f9f7 103 temp[2] = 0; // Null termination
<> 144:ef7eb2e8f9f7 104 uint8_t nibble;
<> 144:ef7eb2e8f9f7 105 uint8_t i = 2;
<> 144:ef7eb2e8f9f7 106
<> 144:ef7eb2e8f9f7 107 while(i-- != 0)
<> 144:ef7eb2e8f9f7 108 {
<> 144:ef7eb2e8f9f7 109 nibble = (value >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 110 temp[1-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
<> 144:ef7eb2e8f9f7 111 }
<> 144:ef7eb2e8f9f7 112
<> 144:ef7eb2e8f9f7 113 (void)SEGGER_RTT_WriteString(terminal_index, temp);
<> 144:ef7eb2e8f9f7 114 }
<> 144:ef7eb2e8f9f7 115
<> 144:ef7eb2e8f9f7 116 __INLINE int log_rtt_has_input()
<> 144:ef7eb2e8f9f7 117 {
<> 144:ef7eb2e8f9f7 118 return SEGGER_RTT_HasKey();
<> 144:ef7eb2e8f9f7 119 }
<> 144:ef7eb2e8f9f7 120
<> 144:ef7eb2e8f9f7 121 uint32_t log_rtt_read_input(char * c)
<> 144:ef7eb2e8f9f7 122 {
<> 144:ef7eb2e8f9f7 123 int r;
<> 144:ef7eb2e8f9f7 124
<> 144:ef7eb2e8f9f7 125 r = SEGGER_RTT_Read(LOG_TERMINAL_INPUT, c, 1);
<> 144:ef7eb2e8f9f7 126 if (r == 1)
<> 144:ef7eb2e8f9f7 127 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 128 else
<> 144:ef7eb2e8f9f7 129 return NRF_ERROR_NULL;
<> 144:ef7eb2e8f9f7 130 }
<> 144:ef7eb2e8f9f7 131
<> 144:ef7eb2e8f9f7 132 #elif defined(NRF_LOG_USES_UART) && NRF_LOG_USES_UART == 1
<> 144:ef7eb2e8f9f7 133
<> 144:ef7eb2e8f9f7 134 #include "app_uart.h"
<> 144:ef7eb2e8f9f7 135 #include "app_error.h"
<> 144:ef7eb2e8f9f7 136 #include <stdio.h>
<> 144:ef7eb2e8f9f7 137 #include <string.h>
<> 144:ef7eb2e8f9f7 138 #include "nrf.h"
<> 144:ef7eb2e8f9f7 139 #include "bsp.h"
<> 144:ef7eb2e8f9f7 140
<> 144:ef7eb2e8f9f7 141 #define MAX_TEST_DATA_BYTES (15U) /**< max number of test bytes to be used for tx and rx. */
<> 144:ef7eb2e8f9f7 142 #define UART_TX_BUF_SIZE 512 /**< UART TX buffer size. */
<> 144:ef7eb2e8f9f7 143 #define UART_RX_BUF_SIZE 1 /**< UART RX buffer size. */
<> 144:ef7eb2e8f9f7 144
<> 144:ef7eb2e8f9f7 145 static uint8_t m_uart_data;
<> 144:ef7eb2e8f9f7 146 static bool m_uart_has_input;
<> 144:ef7eb2e8f9f7 147
<> 144:ef7eb2e8f9f7 148 void uart_error_cb(app_uart_evt_t * p_event)
<> 144:ef7eb2e8f9f7 149 {
<> 144:ef7eb2e8f9f7 150 if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
<> 144:ef7eb2e8f9f7 151 {
<> 144:ef7eb2e8f9f7 152 APP_ERROR_HANDLER(p_event->data.error_communication);
<> 144:ef7eb2e8f9f7 153 }
<> 144:ef7eb2e8f9f7 154 else if (p_event->evt_type == APP_UART_FIFO_ERROR)
<> 144:ef7eb2e8f9f7 155 {
<> 144:ef7eb2e8f9f7 156 APP_ERROR_HANDLER(p_event->data.error_code);
<> 144:ef7eb2e8f9f7 157 }
<> 144:ef7eb2e8f9f7 158 }
<> 144:ef7eb2e8f9f7 159
<> 144:ef7eb2e8f9f7 160 uint32_t log_uart_init()
<> 144:ef7eb2e8f9f7 161 {
<> 144:ef7eb2e8f9f7 162 static bool initialized = false;
<> 144:ef7eb2e8f9f7 163 if (initialized)
<> 144:ef7eb2e8f9f7 164 {
<> 144:ef7eb2e8f9f7 165 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 166 }
<> 144:ef7eb2e8f9f7 167
<> 144:ef7eb2e8f9f7 168 uint32_t err_code;
<> 144:ef7eb2e8f9f7 169 const app_uart_comm_params_t comm_params =
<> 144:ef7eb2e8f9f7 170 {
<> 144:ef7eb2e8f9f7 171 RX_PIN_NUMBER,
<> 144:ef7eb2e8f9f7 172 TX_PIN_NUMBER,
<> 144:ef7eb2e8f9f7 173 RTS_PIN_NUMBER,
<> 144:ef7eb2e8f9f7 174 CTS_PIN_NUMBER,
<> 144:ef7eb2e8f9f7 175 APP_UART_FLOW_CONTROL_ENABLED,
<> 144:ef7eb2e8f9f7 176 false,
<> 144:ef7eb2e8f9f7 177 UART_BAUDRATE_BAUDRATE_Baud115200
<> 144:ef7eb2e8f9f7 178 };
<> 144:ef7eb2e8f9f7 179
<> 144:ef7eb2e8f9f7 180 APP_UART_FIFO_INIT(&comm_params,
<> 144:ef7eb2e8f9f7 181 UART_RX_BUF_SIZE,
<> 144:ef7eb2e8f9f7 182 UART_TX_BUF_SIZE,
<> 144:ef7eb2e8f9f7 183 uart_error_cb,
<> 150:02e0a0aed4ec 184 #ifdef NRF51
<> 150:02e0a0aed4ec 185 APP_IRQ_PRIORITY_LOW
<> 150:02e0a0aed4ec 186 #elif defined(NRF52)
<> 150:02e0a0aed4ec 187 APP_IRQ_PRIORITY_LOWEST
<> 150:02e0a0aed4ec 188 #endif
<> 144:ef7eb2e8f9f7 189 err_code);
<> 144:ef7eb2e8f9f7 190
<> 144:ef7eb2e8f9f7 191 initialized = true;
<> 144:ef7eb2e8f9f7 192
<> 144:ef7eb2e8f9f7 193 return err_code;
<> 144:ef7eb2e8f9f7 194 }
<> 144:ef7eb2e8f9f7 195
<> 144:ef7eb2e8f9f7 196 //lint -save -e530 -e64
<> 144:ef7eb2e8f9f7 197 void log_uart_printf(const char * format_msg, ...)
<> 144:ef7eb2e8f9f7 198 {
<> 144:ef7eb2e8f9f7 199 va_list p_args;
<> 144:ef7eb2e8f9f7 200 va_start(p_args, format_msg);
<> 144:ef7eb2e8f9f7 201 (void)vprintf(format_msg, p_args);
<> 144:ef7eb2e8f9f7 202 va_end(p_args);
<> 144:ef7eb2e8f9f7 203 }
<> 144:ef7eb2e8f9f7 204
<> 144:ef7eb2e8f9f7 205 __INLINE void log_uart_write_string_many(int num_args, ...)
<> 144:ef7eb2e8f9f7 206 {
<> 144:ef7eb2e8f9f7 207 const char* msg;
<> 144:ef7eb2e8f9f7 208 va_list p_args;
<> 144:ef7eb2e8f9f7 209 va_start(p_args, num_args);
<> 144:ef7eb2e8f9f7 210
<> 144:ef7eb2e8f9f7 211 for (int i = 0; i < num_args; i++)
<> 144:ef7eb2e8f9f7 212 {
<> 144:ef7eb2e8f9f7 213 msg = va_arg(p_args, const char*);
<> 144:ef7eb2e8f9f7 214 log_uart_write_string(msg);
<> 144:ef7eb2e8f9f7 215 }
<> 144:ef7eb2e8f9f7 216 va_end(p_args);
<> 144:ef7eb2e8f9f7 217 }
<> 144:ef7eb2e8f9f7 218
<> 144:ef7eb2e8f9f7 219 __INLINE void log_uart_write_string(const char* msg)
<> 144:ef7eb2e8f9f7 220 {
<> 144:ef7eb2e8f9f7 221 while( *msg )
<> 144:ef7eb2e8f9f7 222 {
<> 144:ef7eb2e8f9f7 223 (void)app_uart_put(*msg++);
<> 144:ef7eb2e8f9f7 224 }
<> 144:ef7eb2e8f9f7 225 }
<> 144:ef7eb2e8f9f7 226 //lint -restore
<> 144:ef7eb2e8f9f7 227
<> 144:ef7eb2e8f9f7 228 void log_uart_write_hex(uint32_t value)
<> 144:ef7eb2e8f9f7 229 {
<> 144:ef7eb2e8f9f7 230 uint8_t nibble;
<> 144:ef7eb2e8f9f7 231 uint8_t i = 8;
<> 144:ef7eb2e8f9f7 232
<> 144:ef7eb2e8f9f7 233 (void)app_uart_put('0');
<> 144:ef7eb2e8f9f7 234 (void)app_uart_put('x');
<> 144:ef7eb2e8f9f7 235 while( i-- != 0 )
<> 144:ef7eb2e8f9f7 236 {
<> 144:ef7eb2e8f9f7 237 nibble = (value >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 238 (void)app_uart_put( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
<> 144:ef7eb2e8f9f7 239 }
<> 144:ef7eb2e8f9f7 240 }
<> 144:ef7eb2e8f9f7 241
<> 144:ef7eb2e8f9f7 242 void log_uart_write_hex_char(uint8_t c)
<> 144:ef7eb2e8f9f7 243 {
<> 144:ef7eb2e8f9f7 244 uint8_t nibble;
<> 144:ef7eb2e8f9f7 245 uint8_t i = 2;
<> 144:ef7eb2e8f9f7 246
<> 144:ef7eb2e8f9f7 247 while( i-- != 0 )
<> 144:ef7eb2e8f9f7 248 {
<> 144:ef7eb2e8f9f7 249 nibble = (c >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 250 (void)app_uart_put( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
<> 144:ef7eb2e8f9f7 251 }
<> 144:ef7eb2e8f9f7 252 }
<> 144:ef7eb2e8f9f7 253
<> 144:ef7eb2e8f9f7 254 __INLINE int log_uart_has_input()
<> 144:ef7eb2e8f9f7 255 {
<> 144:ef7eb2e8f9f7 256 if (m_uart_has_input) return 1;
<> 144:ef7eb2e8f9f7 257 if (app_uart_get(&m_uart_data) == NRF_SUCCESS)
<> 144:ef7eb2e8f9f7 258 {
<> 144:ef7eb2e8f9f7 259 m_uart_has_input = true;
<> 144:ef7eb2e8f9f7 260 return 1;
<> 144:ef7eb2e8f9f7 261 }
<> 144:ef7eb2e8f9f7 262 return 0;
<> 144:ef7eb2e8f9f7 263 }
<> 144:ef7eb2e8f9f7 264
<> 144:ef7eb2e8f9f7 265 uint32_t log_uart_read_input(char * c)
<> 144:ef7eb2e8f9f7 266 {
<> 144:ef7eb2e8f9f7 267 if (m_uart_has_input)
<> 144:ef7eb2e8f9f7 268 {
<> 144:ef7eb2e8f9f7 269 *c = (char)m_uart_data;
<> 144:ef7eb2e8f9f7 270 m_uart_has_input = false;
<> 144:ef7eb2e8f9f7 271 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 272 }
<> 144:ef7eb2e8f9f7 273 if (app_uart_get((uint8_t *)c) == NRF_SUCCESS)
<> 144:ef7eb2e8f9f7 274 {
<> 144:ef7eb2e8f9f7 275 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 276 }
<> 144:ef7eb2e8f9f7 277 return NRF_ERROR_NULL;
<> 144:ef7eb2e8f9f7 278 }
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280 #elif defined(NRF_LOG_USES_RAW_UART) && NRF_LOG_USES_RAW_UART == 1
<> 144:ef7eb2e8f9f7 281
<> 144:ef7eb2e8f9f7 282 #include "app_uart.h"
<> 144:ef7eb2e8f9f7 283 #include <stdio.h>
<> 144:ef7eb2e8f9f7 284 #include <string.h>
<> 144:ef7eb2e8f9f7 285 #include "bsp.h"
<> 144:ef7eb2e8f9f7 286
<> 144:ef7eb2e8f9f7 287 uint32_t log_raw_uart_init()
<> 144:ef7eb2e8f9f7 288 {
<> 144:ef7eb2e8f9f7 289 // Disable UART
<> 144:ef7eb2e8f9f7 290 NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Disabled;
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 // Configure RX/TX pins
<> 144:ef7eb2e8f9f7 293 nrf_gpio_cfg_output( TX_PIN_NUMBER );
<> 144:ef7eb2e8f9f7 294 nrf_gpio_cfg_input(RX_PIN_NUMBER, NRF_GPIO_PIN_NOPULL);
<> 144:ef7eb2e8f9f7 295
<> 144:ef7eb2e8f9f7 296 // Set a default baud rate of UART0_CONFIG_BAUDRATE
<> 144:ef7eb2e8f9f7 297 NRF_UART0->PSELTXD = TX_PIN_NUMBER;
<> 144:ef7eb2e8f9f7 298 NRF_UART0->BAUDRATE = UART0_CONFIG_BAUDRATE;
<> 144:ef7eb2e8f9f7 299
<> 144:ef7eb2e8f9f7 300 NRF_UART0->PSELRTS = 0xFFFFFFFF;
<> 144:ef7eb2e8f9f7 301 NRF_UART0->PSELCTS = 0xFFFFFFFF;
<> 144:ef7eb2e8f9f7 302
<> 144:ef7eb2e8f9f7 303 // Disable parity and interrupt
<> 144:ef7eb2e8f9f7 304 NRF_UART0->CONFIG = (UART_CONFIG_PARITY_Excluded << UART_CONFIG_PARITY_Pos );
<> 144:ef7eb2e8f9f7 305 NRF_UART0->CONFIG |= (UART_CONFIG_HWFC_Disabled << UART_CONFIG_HWFC_Pos );
<> 144:ef7eb2e8f9f7 306
<> 144:ef7eb2e8f9f7 307 // Re-enable the UART
<> 144:ef7eb2e8f9f7 308 NRF_UART0->ENABLE = UART_ENABLE_ENABLE_Enabled;
<> 144:ef7eb2e8f9f7 309 NRF_UART0->INTENSET = 0;
<> 144:ef7eb2e8f9f7 310 NRF_UART0->TASKS_STARTTX = 1;
<> 144:ef7eb2e8f9f7 311 NRF_UART0->TASKS_STARTRX = 1;
<> 144:ef7eb2e8f9f7 312
<> 144:ef7eb2e8f9f7 313 return NRF_SUCCESS;
<> 144:ef7eb2e8f9f7 314 }
<> 144:ef7eb2e8f9f7 315
<> 144:ef7eb2e8f9f7 316 void log_raw_uart_printf(const char * format_msg, ...)
<> 144:ef7eb2e8f9f7 317 {
<> 144:ef7eb2e8f9f7 318 static char buffer[256];
<> 144:ef7eb2e8f9f7 319
<> 144:ef7eb2e8f9f7 320 va_list p_args;
<> 144:ef7eb2e8f9f7 321 va_start(p_args, format_msg);
<> 144:ef7eb2e8f9f7 322 sprintf(buffer, format_msg, p_args);
<> 144:ef7eb2e8f9f7 323 va_end(p_args);
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 log_raw_uart_write_string(buffer);
<> 144:ef7eb2e8f9f7 326 }
<> 144:ef7eb2e8f9f7 327
<> 144:ef7eb2e8f9f7 328 __INLINE void log_raw_uart_write_char(const char c)
<> 144:ef7eb2e8f9f7 329 {
<> 144:ef7eb2e8f9f7 330 NRF_UART0->TXD = c;
<> 144:ef7eb2e8f9f7 331 while( NRF_UART0->EVENTS_TXDRDY != 1 );
<> 144:ef7eb2e8f9f7 332 NRF_UART0->EVENTS_TXDRDY = 0;
<> 144:ef7eb2e8f9f7 333 }
<> 144:ef7eb2e8f9f7 334
<> 144:ef7eb2e8f9f7 335 __INLINE void log_raw_uart_write_string_many(int num_args, ...)
<> 144:ef7eb2e8f9f7 336 {
<> 144:ef7eb2e8f9f7 337
<> 144:ef7eb2e8f9f7 338 const char* msg;
<> 144:ef7eb2e8f9f7 339 va_list p_args;
<> 144:ef7eb2e8f9f7 340 va_start(p_args, num_args);
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 for (int i = 0; i < num_args; i++)
<> 144:ef7eb2e8f9f7 343 {
<> 144:ef7eb2e8f9f7 344 msg = va_arg(p_args, const char*);
<> 144:ef7eb2e8f9f7 345 log_raw_uart_write_string(msg);
<> 144:ef7eb2e8f9f7 346 }
<> 144:ef7eb2e8f9f7 347 va_end(p_args);
<> 144:ef7eb2e8f9f7 348 }
<> 144:ef7eb2e8f9f7 349
<> 144:ef7eb2e8f9f7 350 __INLINE void log_raw_uart_write_string(const char* msg)
<> 144:ef7eb2e8f9f7 351 {
<> 144:ef7eb2e8f9f7 352 while( *msg )
<> 144:ef7eb2e8f9f7 353 {
<> 144:ef7eb2e8f9f7 354 NRF_UART0->TXD = *msg++;
<> 144:ef7eb2e8f9f7 355 while( NRF_UART0->EVENTS_TXDRDY != 1 );
<> 144:ef7eb2e8f9f7 356 NRF_UART0->EVENTS_TXDRDY = 0;
<> 144:ef7eb2e8f9f7 357 }
<> 144:ef7eb2e8f9f7 358 }
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 void log_raw_uart_write_hex(uint32_t value)
<> 144:ef7eb2e8f9f7 361 {
<> 144:ef7eb2e8f9f7 362 uint8_t nibble;
<> 144:ef7eb2e8f9f7 363 uint8_t i = 8;
<> 144:ef7eb2e8f9f7 364
<> 144:ef7eb2e8f9f7 365 log_raw_uart_write_string( "0x" );
<> 144:ef7eb2e8f9f7 366 while( i-- != 0 )
<> 144:ef7eb2e8f9f7 367 {
<> 144:ef7eb2e8f9f7 368 nibble = (value >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 369 log_raw_uart_write_char( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
<> 144:ef7eb2e8f9f7 370 }
<> 144:ef7eb2e8f9f7 371 }
<> 144:ef7eb2e8f9f7 372
<> 144:ef7eb2e8f9f7 373 void log_raw_uart_write_hex_char(uint8_t c)
<> 144:ef7eb2e8f9f7 374 {
<> 144:ef7eb2e8f9f7 375 uint8_t nibble;
<> 144:ef7eb2e8f9f7 376 uint8_t i = 2;
<> 144:ef7eb2e8f9f7 377
<> 144:ef7eb2e8f9f7 378 while( i-- != 0 )
<> 144:ef7eb2e8f9f7 379 {
<> 144:ef7eb2e8f9f7 380 nibble = (c >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 381 log_raw_uart_write_hex( (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble) );
<> 144:ef7eb2e8f9f7 382 }
<> 144:ef7eb2e8f9f7 383 }
<> 144:ef7eb2e8f9f7 384
<> 144:ef7eb2e8f9f7 385 __INLINE int log_raw_uart_has_input()
<> 144:ef7eb2e8f9f7 386 {
<> 144:ef7eb2e8f9f7 387 return 0;
<> 144:ef7eb2e8f9f7 388 }
<> 144:ef7eb2e8f9f7 389
<> 144:ef7eb2e8f9f7 390 uint32_t log_raw_uart_read_input(char * c)
<> 144:ef7eb2e8f9f7 391 {
<> 144:ef7eb2e8f9f7 392 return NRF_ERROR_NULL;
<> 144:ef7eb2e8f9f7 393 }
<> 144:ef7eb2e8f9f7 394
<> 144:ef7eb2e8f9f7 395 #endif // NRF_LOG_USES_RAW_UART == 1
<> 144:ef7eb2e8f9f7 396
<> 144:ef7eb2e8f9f7 397
<> 144:ef7eb2e8f9f7 398 const char* log_hex_char(const char c)
<> 144:ef7eb2e8f9f7 399 {
<> 144:ef7eb2e8f9f7 400 static volatile char hex_string[3];
<> 144:ef7eb2e8f9f7 401 hex_string[2] = 0; // Null termination
<> 144:ef7eb2e8f9f7 402 uint8_t nibble;
<> 144:ef7eb2e8f9f7 403 uint8_t i = 2;
<> 144:ef7eb2e8f9f7 404 while(i-- != 0)
<> 144:ef7eb2e8f9f7 405 {
<> 144:ef7eb2e8f9f7 406 nibble = (c >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 407 hex_string[1-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
<> 144:ef7eb2e8f9f7 408 }
<> 144:ef7eb2e8f9f7 409 return (const char*) hex_string;
<> 144:ef7eb2e8f9f7 410 }
<> 144:ef7eb2e8f9f7 411
<> 144:ef7eb2e8f9f7 412 const char* log_hex(uint32_t value)
<> 144:ef7eb2e8f9f7 413 {
<> 144:ef7eb2e8f9f7 414 static volatile char hex_string[11];
<> 144:ef7eb2e8f9f7 415 hex_string[0] = '0';
<> 144:ef7eb2e8f9f7 416 hex_string[1] = 'x';
<> 144:ef7eb2e8f9f7 417 hex_string[10] = 0;
<> 144:ef7eb2e8f9f7 418 uint8_t nibble;
<> 144:ef7eb2e8f9f7 419 uint8_t i = 8;
<> 144:ef7eb2e8f9f7 420
<> 144:ef7eb2e8f9f7 421 while(i-- != 0)
<> 144:ef7eb2e8f9f7 422 {
<> 144:ef7eb2e8f9f7 423 nibble = (value >> (4 * i)) & 0x0F;
<> 144:ef7eb2e8f9f7 424 hex_string[9-i] = (nibble > 9) ? ('A' + nibble - 10) : ('0' + nibble);
<> 144:ef7eb2e8f9f7 425 }
<> 144:ef7eb2e8f9f7 426
<> 144:ef7eb2e8f9f7 427 return (const char*)hex_string;
<> 144:ef7eb2e8f9f7 428 }
<> 144:ef7eb2e8f9f7 429