2018年8月31日 星期五

python 3 with serial :dynamic update /save MCU uart value with csv file

This article is an implement of:

1. dynamic update chart by matplotlib
2. raw data input by serial (COM port)
3. start/pause function for save value array
4. save as .csv format with system time as file name.

finally, it will be like this:































my Python Settings:


























Install Package in Python 3.6:

from __future__ import print_function
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.widgets import Button
import numpy as np

import serial

import datetime
import csv



STEP 0. check your COM port number at Device manager:
my MCU now is COM61


STEP 1. check uart input format
For this example, I define my MCU input in this format:





















'@' (0x40) as begin, '#' (0x23) as end
5 random values from 0 to 4096 , seperated by ',' (0x2c)

and I want to dynamic show on plot


STEP 2. new Python project file, install package
at the front of this article, I post every package this project need.

from __future__ import print_function
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.widgets import Button
import numpy as np

import serial

import datetime
import csv


STEP 3. add these file into project file path

main.py
replace

COM = 'COM61'
as your COM number checked in STEP 0.


from __future__ import print_function
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.widgets import Button

import datetime
import csv

import class_serial_input as serial
import class_line         as line

UPDATE_INTERVAL_IN_MSEC = 80

SERIAL_DATA_IN = 1
SERIAL_DATA_STOP = 0

serial_data_flag = SERIAL_DATA_IN

COM = 'COM61'


def start_func(label):
 print(" in start func")
 
 global serial_data_flag
 serial_data_flag = SERIAL_DATA_IN


def stop_func(label):
 print(" in stop func")
 
 global serial_data_flag
 serial_data_flag = SERIAL_DATA_STOP


def save_chart_csv(label):
 print(" save chart as csv")
 
 i_line_data = i_line.get_i_line()
 
 with open('output_%u_%u_%u_%u_%u_%u.csv' % (now_time.year, now_time.month, now_time.day,
                                             now_time.hour, now_time.minute, now_time.second),
           'w', newline='') as csvfile:
  writer = csv.writer(csvfile, delimiter=',')
  writer.writerow(i_line_data)
  


if __name__ == "__main__":
 print("start up \r\n")
 
 #default_port = serial_data.Serial_data("random_data" sys.argv[1])
 default_port = serial.serial_input("random_data",com=COM)
 
 #init matplot interface
 fig = plt.figure('random serial value chart power by Agatha Kuan', figsize=(10, 8))
 gs = GridSpec(14, 14, left=0.01, bottom=0.01, right=1 - 0.01, top=1 - 0.01, wspace=1, hspace=1)
 
 i_chart_axes = plt.subplot(gs[1:8, 6:14])
 i_chart_axes.axis([0, 4, 0, 4096])
 
 plt.ion()
 
 plt.ylabel("random value", color='#8d734b', size=12, family='monospace')
 plt.title("signal chart", color='#8d734b', size=15, family='monospace')
 
 plt.grid(True)
 
 #init line
 i_line = line.Init_line("line_1")
 
 #init button
 point_start = plt.subplot(gs[1, :4])
 button_start = Button(point_start, 'start', color='0.95', hovercolor='0.6')
 button_start.label.set_fontsize(11)
 button_start.on_clicked(start_func)
 
 point_stop = plt.subplot(gs[2, :4])
 button_stop = Button(point_stop, 'pause', color='0.95', hovercolor='0.6')
 button_stop.label.set_fontsize(11)
 button_stop.on_clicked(stop_func)
 
 point_save_csv = plt.subplot(gs[4, :2])
 button_save_csv = Button(point_save_csv, 'save as .CSV', color='0.95', hovercolor='0.6')
 button_save_csv.label.set_fontsize(11)
 button_save_csv.on_clicked(save_chart_csv)
 
 now_time = datetime.datetime.now()
 sys_start_time = datetime.datetime.now()
 
 time_stamp = plt.subplot(gs[7:11, :2])
 time_stamp.axis('off')
 time_stamp_text = plt.text(0.01, 0.05, " ", color='#8d734b', size=12, family='monospace',
                            transform=time_stamp.transAxes)
 
 
 
 while 1 :
  if SERIAL_DATA_STOP != serial_data_flag:
   default_port.get_serial_data()
   i_tmp = default_port.get_data()
  
   i_line.draw_update_thershold()
   i_line.draw_update_signal_line(i_tmp)
  
   
   i_chart_axes.relim(True)
   i_chart_axes.autoscale_view(True, 'y', True)
  
  now_time = datetime.datetime.now()
  time_stamp_text.set_text("start at %u/%u %u:%u:%u \n\n"
                           "System Time %u/%u %u:%u:%u \n"%(sys_start_time.month,sys_start_time.day,sys_start_time.hour,
                                                            sys_start_time.minute,sys_start_time.second,
                                                            now_time.month, now_time.day,now_time.hour,
                                                            now_time.minute, now_time.second))
  
  fig.canvas.draw()
  plt.pause(float(UPDATE_INTERVAL_IN_MSEC) / 1000.0)
  
  default_port.clear_data()
  
  

class_serial_input.py

import serial

import numpy as np

POINT_TO_UPDATE = 5
SEPERATE_SIGN = 0x2C
DATA_MAX_LEN = (2+(1+4)*(POINT_TO_UPDATE+1))*2

__metaclass__ = type

class serial_input:
 def __init__(self,name,com='COM61',baudrate=115200):
  
  
  self.ser = serial.Serial(com, baudrate)
  
  self.port = com
  self.baudrate = baudrate
  
  self.num_array = np.repeat(0x00, POINT_TO_UPDATE)
 
 def get_serial_data(self):
  self.ser.flushInput()
  
  char_in = self.ser.read(DATA_MAX_LEN)
  char_in = bytearray(char_in)
  
  temp = np.repeat(0x00, DATA_MAX_LEN)
  valid_tmp = np.repeat(0x00, DATA_MAX_LEN)
  
  for i in range (DATA_MAX_LEN):
   temp[i] = int(char_in[i])
   
  start_addr  = np.argwhere(temp == 0x40)
  end_addr    = np.argwhere(temp == 0x23)
  
  
  if(int(start_addr[0]) < int(end_addr[0])):
   start = int(start_addr[0])
   end   = int(end_addr[0])
   for i in range (end-start):
    valid_tmp[i] = temp[start+1+i]
  else:
   start = int(start_addr[0])
   end = int(end_addr[1])
   for i in range(end - start):
    valid_tmp[i] = temp[start + 1 + i]
   
  common_addr = np.argwhere(valid_tmp == 0x2c)
  
  for i in range (int(common_addr[0])):
   self.num_array[0] = self.num_array[0]+(valid_tmp[i]-0x30)*pow(10, int(common_addr[0])-1-i)
  
  for i in range(1,4):
   start = int(common_addr[i-1])
   end   = int(common_addr[i])
   
   for j in range(0,end-start-1):
    self.num_array[i] = self.num_array[i] + (valid_tmp[start+1+j]-0x30)*pow(10,end-start-2-j)
  
  end_addr = np.argwhere(valid_tmp == 0x23)
  
  for i in range (int(end_addr[0])-int(common_addr[3])-1):
   self.num_array[4] = self.num_array[4]+(valid_tmp[int(common_addr[3])+1+i]-0x30)*pow(10, int(end_addr[0])-int(common_addr[3])-2-i)
   
  
  
 def get_data(self):
  
  print(self.num_array)
  return self.num_array
 
 def clear_data(self):
  self.num_array = np.repeat(0x00, POINT_TO_UPDATE)


class_line.py

#線條的顏色: https://www.cnblogs.com/darkknightzh/p/6117528.html

import matplotlib.pyplot as plt
import numpy as np

__metaclass__ = type


THRESHOLD_VALUE = 2000

TIME_WINDOW_WIDTH_IN_SEC = 2.0

POINTS_IN_ONE_UPDATE = 5
VIEW_POINT_IN_SEC    = 1*POINTS_IN_ONE_UPDATE


TIME_STAMP_ARRAY = np.arange(0, VIEW_POINT_IN_SEC, 1)


class Init_line:
 def __init__(self,name):
  global TIME_STAMP_ARRAY
  
  self.time_window_begin = 0.0
  self.time_window_end = self.time_window_begin + TIME_WINDOW_WIDTH_IN_SEC
  
  self.time_line_value = TIME_STAMP_ARRAY
  self.thershold_line_value = np.repeat(THRESHOLD_VALUE, len(self.time_line_value))
  
  freq = 5.0
  omega = 2.0 * np.pi * freq
  constant_for_signal_shift = 1
  self.i_raw_line_value = np.sin(omega * self.time_line_value) + constant_for_signal_shift
  
  self.thershold_line, = plt.plot(self.time_line_value, self.thershold_line_value,label="thershold",color='#0080FF')
  self.i_raw_line, = plt.plot(self.time_line_value, self.i_raw_line_value,label="I raw", color='#FF8000')
  
  plt.legend(loc='upper right')
  
  
 def draw_thershold(self):
  self.thershold_line, = plt.plot(self.time_line_value, self.thershold_line_value)
 
 def draw_update_thershold(self):
  global TIME_STAMP_ARRAY
  
  self.time_line_value = TIME_STAMP_ARRAY
  self.thershold_line.set_data(self.time_line_value, self.thershold_line_value)
  
 def draw_init_signal_line(self):
  self.i_raw_line, = plt.plot(self.time_line_value, self.i_raw_line_value)
  
 def draw_update_signal_line(self,update_i_temp):
  self.i_raw_line_value = np.roll(self.i_raw_line_value, -POINTS_IN_ONE_UPDATE)
  self.i_raw_line_value[-(POINTS_IN_ONE_UPDATE):] = update_i_temp
  
  self.i_raw_line.set_data(self.time_line_value, self.i_raw_line_value)
  
 def get_i_line(self):
  return self.i_raw_line_value
  
 
  
  
 
  
  
  


STEP 4.run the Python file































when you run this python script, the PLOT start to update.


STEP 5. SAVE as csv file with time stamp as file name


press pause button to pause the update plot, then
press save as csv button

you will see a csv file in project path with time stamp as file name














open the file  in EXCEL, you can see the raw data:














NOTE:

  • this implement only use matplotlib to draw figure and canvas, didn't use other graphic UI structure like TKinter or PyQT5
  • the speed of COM data update is limited cause I didn't use multi-thread programming.


reference:

  1. https://www.cnblogs.com/darkknightzh/p/6117528.html
  2. https://zhuanlan.zhihu.com/p/32019813
  3. https://tw.saowen.com/a/aeeef5a75c5a3589f64d9f31953295c1b21a60ff72902f6e93f16327be2d3d78









2018年5月22日 星期二

ble MESH : how to load provision data to serial example after restart (nordic pyaci supplement)

This article is a supplement of Interactive mesh provisioning and configuration on Nordic website


the introduction of Serial example of nRF52 ble MESH SDK
only teach how to provision a node.

However, the provision data is stored in .JSON outside the chip. We have to load the provisioned nodes information into the nRF52 to act as client after nRF52 Serial restart.

The following step shows how to :

for example, if I have provisioned a node "0577"
devicekey = 0
address key = 8



then after Serial example restart,  I use interactive_pyaci.py to load the provision data :

In [1]: db = MeshDB("database/example_database.json")

In [2]: p = Provisioner(device, db)

In [3]: 2018-05-17 15:37:26,908 - INFO - COM4: Success
2018-05-17 15:37:26,911 - INFO - COM4: Success
2018-05-17 15:37:26,916 - INFO - COM4: SubnetAdd: {'subnet_handle': 0}
2018-05-17 15:37:26,919 - INFO - COM4: AppkeyAdd: {'appkey_handle': 0}
2018-05-17 15:37:26,919 - INFO - COM4: AppkeyAdd: {'appkey_handle': 1}

In [3]: device.send(cmd.AddrPublicationAdd(db.nodes[0].unicast_address))

2018-05-17 15:38:09,309 - INFO - COM4: AddrPublicationAdd: {'address_handle': 0}
In [4]: sc = SimpleOnOffClient()

In [5]: device.model_add(sc)

In [6]: sc.publish_set(0, 0)

In [7]: sc.set(True)

and this sentence:

device.send(cmd.AddrPublicationAdd(db.nodes[0].unicast_address))

is how to load data of one provisioned node into the chip 


reference:
https://devzone.nordicsemi.com/f/nordic-q-a/34254/add-delete-nodes-set-sub-net-function-in-mesh-sdk-serial-example/132390#132390

ble MESH:how to delete a provisioned-node in Serial example (Pyaci)

In this April , Nordic Semiconductor release their Mesh SDK version 2.0.1
in Serial example, this example let:
- a nRF52 connect with a Windows or embedded system with UART
- a nRF52 (program serial example)act as provisioner and config client
- the provision and config records store in JSON database in  a Windows or embedded system
- the Windows or embedded system  control the nRF52 with python script
(named  interactive_pyaci.py)

for detail plz check in Nordic website:
serial example 


However the scripts doesn't have function to delete provisioned records.
That means if the node is reset, this serial example can not provision it again.
Or, if a node leave this Mesh network, the provision is not able to delete it.

In this article , I implement a script to delete the record.
name as delete_provisioned_node.py


#power by Agatha Kuan 05/16/2018
import json as JSON
import os
import sys

def check_provisioned_node(file_name):
    with open(file_name) as f:
        load_in = JSON.load(f)
        print(load_in["nodes"])


        for p in load_in["nodes"]:
            print("device name = "+p["name"])


def delete_node(undeleted_node,file_name):
    with open(file_name) as f:
        load_in = JSON.load(f)
        for p in load_in["nodes"]:
            print("list name = "+p["name"])

        for i in range(len(load_in["nodes"])):
            if load_in["nodes"][i]["name"] == undeleted_node:
                load_in["nodes"].pop(i)
                print("success delete ", undeleted_node)
                break

        open(file_name, "w").write(JSON.dumps(load_in, sort_keys=False, indent=4, separators=(',', ':')))


def main():
#sys.argv[0]  是這個腳本的檔名
    if("-c" == sys.argv[1]):
        print("check recent node")
        print("open file:", sys.argv[2])
        check_provisioned_node(sys.argv[2])

    elif("-d" == sys.argv[1]):
        print("delete device :",sys.argv[2])
        delete_node(sys.argv[2],sys.argv[3])

    elif("?" == sys.argv[1]):
        print("Functions:")
        print("1.for check provisioned node:")
        print("     -c FILE_NAME e.g -c example_database.json")
        print("2.after checking nodes, to select which to delete:")
        print("     -d DEVICE_NAME FILE_NAME e.g -d node_01 example_database.json")




if __name__ == "__main__":
    main()


Demostration:
I provision a node "0577"

in database will add a nodes record:

"nodes": [
    {
      "UUID": "0059ffff0000000009f5cf71a0100577",
      "appKeys": [
        0
      ],
      "cid": "0059",
      "configComplete": false,
      "crpl": 32,
      "deviceKey": "dd5baeb65d8ab9eb709c45397a285ab4",
      "elements": [
        {
          "index": 0,
          "location": "0000",
          "models": [
            {
              "modelId": "0000"
            },
            {
              "modelId": "0002"
            },
            {
              "bind": [
                0
              ],
              "modelId": "00590000"
            }
          ]
        }
      ],
      "features": {
        "friend": 2,
        "lowPower": 2,
        "proxy": 2,
        "relay": 0
      },
      "name": "0577",
      "netKeys": [
        0
      ],
      "pid": "0000",
      "security": "low",
      "unicastAddress": 16,
      "vid": "0000"
    }
]

Than put "delete_provisioned_node.py " in :
../script/interactive_pyaci/database


and run it in CMD :

$ database python delete_provisioned_node.py ?

it will show you operation command



So, if I want to delete "0577" , command

$ database python delete_provisioned_node.py -d 0577 example_database.json



reference:
http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.meshsdk.v2.0.1%2Fmd_scripts_interactive_pyaci_doc_demo_configuration.html&cp=4_1_0_1_1_3_2


2018年3月23日 星期五

ble MESH: activate nRF_Driver/Libraries functions on ble MESH SDK(app uart for example)

in recent nordic ble mesh sdk v1.01, external drivers or libraries  are not fully implement, and the correct ways to activate them,like timers, PWM, SAADC...etc, are totally different from BLE SDK(e.g SDK14.02).

What can we do if we need those drivers or libraries? nordic semiconductor's websites  don't have any message about exactly how to  use an example from the nRF5 SDK in combination with the mesh stack.

In this article, I will present
- how to integrate external drivers or libraries in BLE SDK into ble MESH SDK
- activate them with SEGGER embedded Studio

I use UART function for example.

PLATFORM:
device: nrf52832_xxaa
softdevice:S132
project: light_switch_server_nrf52832_xxaa_s132_3.1.0

ble SDK: nRF5_SDK_14.2.0_17b948a

ble MESH SDK: nrf5_SDK_for_Mesh_v1.0.1_src


STEP 0 : copy necessary drivers file to ble MESH sdk

copy "common" folder
from
..\nRF5_SDK_14.2.0_17b948a\components\softdevice\common
to
..\nrf5_SDK_for_Mesh_v1.0.1_src\external\softdevice




copy clock/common/power/uart 4 folders 
from
..\nRF5_SDK_14.2.0_17b948a\components\drivers_nrf
to
..\nrf5_SDK_for_Mesh_v1.0.1_src\external\nRF5_SDK_14.2.0_17b948a\components\drivers_nrf



copy uart/experimental_log/experimental_section_vars/fifo 4 folders
from
..\nRF5_SDK_14.2.0_17b948a\components\libraries
to
..\nrf5_SDK_for_Mesh_v1.0.1_src\external\nRF5_SDK_14.2.0_17b948a\components\libraries




STEP 1: include divers files to SEGGER embedded Studio preprocessor

click project"light_switch_server", and select "Edit options.."/Preprocessor/ User Include Directories


add the following path into that blue blank:
../../../external/nRF5_SDK_14.2.0_17b948a/components/libraries/uart;
../../../examples/light_switch_idesyn_sandbox/server/src;
../../../external/nRF5_SDK_14.2.0_17b948a/components/drivers_nrf/common;
../../../external/nRF5_SDK_14.2.0_17b948a/components/libraries/experimental_log;
../../../external/nRF5_SDK_14.2.0_17b948a/components/libraries/experimental_section_vars;
../../../external/nRF5_SDK_14.2.0_17b948a/components/libraries/experimental_log/src;
../../../external/nRF5_SDK_14.2.0_17b948a/components/drivers_nrf/power;
../../../external/nRF5_SDK_14.2.0_17b948a/components/drivers_nrf/clock;
../../../external/nRF5_SDK_14.2.0_17b948a/components/drivers_nrf/uart;
../../../external/nRF5_SDK_14.2.0_17b948a/components/libraries/fifo;
../../../external/softdevice/common;


STEP 2: include C files to project

I create nRF_Drivers_Import/nRF_Library_Import 2 folders to put C files imported from SDK14

add to nRF_Drivers_Import:
- nrf_drv_common.c
- nrf_drv_clock.c
- nrf_drv_uart.c
- nrf_drv_power.c

add to nRF_Library_Import:
- app_fifo.c
- app_uart_fifo.c
- retarget.c





STEP 3: initialize UART in main.c

add the following code in main.c

about line 60
#include "app_uart.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

#define UART_HWFC   APP_UART_FLOW_CONTROL_DISABLED
#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */
#define DATA_LEN   (6)
static uint8_t data_array[DATA_LEN];
static uint8_t index = 0;


about line 130
void uart_event_handle(app_uart_evt_t * p_event)
{  

    switch (p_event->evt_type)
    {
        case APP_UART_DATA_READY:
            UNUSED_VARIABLE(app_uart_get(&data_array[index]));
            break;

        case APP_UART_COMMUNICATION_ERROR:
            ERROR_CHECK(p_event->data.error_communication);
            break;

        case APP_UART_FIFO_ERROR:
            ERROR_CHECK(p_event->data.error_code);
            break;

        default:
            break;
    }
}

static void uart_init(void)
{
 uint32_t err_code;
 const app_uart_comm_params_t comm_params =
 {
                 RX_PIN_NUMBER,
   TX_PIN_NUMBER,
   RTS_PIN_NUMBER,
   CTS_PIN_NUMBER,
   UART_HWFC,
   false,
   NRF_UART_BAUDRATE_115200
 };

    APP_UART_FIFO_INIT(&comm_params,
   UART_RX_BUF_SIZE,
   UART_TX_BUF_SIZE,
   uart_event_handle,
   APP_IRQ_PRIORITY_LOWEST,
   err_code);

    ERROR_CHECK(err_code);
}


in main function line 180

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BLE Mesh Light Switch Server Demo -----\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- program by AgathaKuan\n");

    hal_leds_init();
    uart_init(); 

    printf("system start\r\n");


STEP 4: include "nrf_mesh_sdk.h" to app_uart_fifo.c
open app_uart_fifo.c 

add about line 40
#include "sdk_common.h"
#include "nrf_mesh_sdk.h"

STEP 5: modify APP_ERROR_CHECK( ) function as ERROR_CHECK( )
open app_uart_fifo.c 
about 200 app_uart_get( ) function:

change APP_ERROR_CHECK (uart_err_code) to ERROR_CHECK (uart_err_code)
uint32_t app_uart_get(uint8_t * p_byte)
{
    ASSERT(p_byte);
    bool rx_ovf = m_rx_ovf;

    ret_code_t err_code =  app_fifo_get(&m_rx_fifo, p_byte);

    // If FIFO was full new request to receive one byte was not scheduled. Must be done here.
    if (rx_ovf)
    {
        m_rx_ovf = false;
        uint32_t uart_err_code = nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);

        // RX resume should never fail.
        ERROR_CHECK(uart_err_code);
    }

    return err_code;
}


STEP 6: add sdk_config.h near by main.c

copy  sdk_config.h
from
..\nRF5_SDK_14.2.0_17b948a\examples\ble_peripheral\ble_app_template
to
..\nrf5_SDK_for_Mesh_v1.0.1_src\examples\light_switch\server\src




STEP 7: modify sdk_config.h to enable UART

add these about line  3004
// <h> nRF_Libraries 
//==========================================================
// <q> APP_FIFO_ENABLED  - app_fifo - Software FIFO implementation
 

#ifndef APP_FIFO_ENABLED
#define APP_FIFO_ENABLED 1
#endif

then add these about line 3080
// <e> APP_UART_ENABLED - app_uart - UART driver
//==========================================================
#ifndef APP_UART_ENABLED
#define APP_UART_ENABLED 1
#define APP_UART_DRIVER_INSTANCE 0
#endif

then add these about line 3506
// <q> RETARGET_ENABLED  - retarget - Retargeting stdio functions
 

#ifndef RETARGET_ENABLED
#define RETARGET_ENABLED 1
#endif

about line  2724
// <e> UART_ENABLED - nrf_drv_uart - UART/UARTE peripheral driver
//==========================================================
#ifndef UART_ENABLED
#define UART_ENABLED 1
#endif
#if  UART_ENABLED
// <o> UART_DEFAULT_CONFIG_HWFC  - Hardware Flow Control
 
// <0=> Disabled 
// <1=> Enabled 

#ifndef UART_DEFAULT_CONFIG_HWFC
#define UART_DEFAULT_CONFIG_HWFC 0
#endif

// <o> UART_DEFAULT_CONFIG_PARITY  - Parity
 
// <0=> Excluded 
// <14=> Included 

#ifndef UART_DEFAULT_CONFIG_PARITY
#define UART_DEFAULT_CONFIG_PARITY 0
#endif

// <o> UART_DEFAULT_CONFIG_BAUDRATE  - Default Baudrate
 
// <323584=> 1200 baud 
// <643072=> 2400 baud 
// <1290240=> 4800 baud 
// <2576384=> 9600 baud 
// <3862528=> 14400 baud 
// <5152768=> 19200 baud 
// <7716864=> 28800 baud 
// <10289152=> 38400 baud 
// <15400960=> 57600 baud 
// <20615168=> 76800 baud 
// <30801920=> 115200 baud 
// <61865984=> 230400 baud 
// <67108864=> 250000 baud 
// <121634816=> 460800 baud 
// <251658240=> 921600 baud 
// <268435456=> 57600 baud 

#ifndef UART_DEFAULT_CONFIG_BAUDRATE
#define UART_DEFAULT_CONFIG_BAUDRATE 30801920
#endif

// <o> UART_DEFAULT_CONFIG_IRQ_PRIORITY  - Interrupt priority
 

// <i> Priorities 0,2 (nRF51) and 0,1,4,5 (nRF52) are reserved for SoftDevice
// <0=> 0 (highest) 
// <1=> 1 
// <2=> 2 
// <3=> 3 
// <4=> 4 
// <5=> 5 
// <6=> 6 
// <7=> 7 

#ifndef UART_DEFAULT_CONFIG_IRQ_PRIORITY
#define UART_DEFAULT_CONFIG_IRQ_PRIORITY 7
#endif

// <q> UART_EASY_DMA_SUPPORT  - Driver supporting EasyDMA
 

#ifndef UART_EASY_DMA_SUPPORT
#define UART_EASY_DMA_SUPPORT 1
#endif

// <q> UART_LEGACY_SUPPORT  - Driver supporting Legacy mode
 

#ifndef UART_LEGACY_SUPPORT
#define UART_LEGACY_SUPPORT 1
#endif

// <e> UART0_ENABLED - Enable UART0 instance
//==========================================================
#ifndef UART0_ENABLED
#define UART0_ENABLED 1
#endif
#if  UART0_ENABLED
// <q> UART0_CONFIG_USE_EASY_DMA  - Default setting for using EasyDMA
 

#ifndef UART0_CONFIG_USE_EASY_DMA
#define UART0_CONFIG_USE_EASY_DMA 1
#endif

#endif //UART0_ENABLED
// </e>

// <e> UART_CONFIG_LOG_ENABLED - Enables logging in the module.
//==========================================================
#ifndef UART_CONFIG_LOG_ENABLED
#define UART_CONFIG_LOG_ENABLED 0
#endif
#if  UART_CONFIG_LOG_ENABLED
// <o> UART_CONFIG_LOG_LEVEL  - Default Severity level
 
// <0=> Off 
// <1=> Error 
// <2=> Warning 
// <3=> Info 
// <4=> Debug 

#ifndef UART_CONFIG_LOG_LEVEL
#define UART_CONFIG_LOG_LEVEL 3
#endif

// <o> UART_CONFIG_INFO_COLOR  - ANSI escape code prefix.
 
// <0=> Default 
// <1=> Black 
// <2=> Red 
// <3=> Green 
// <4=> Yellow 
// <5=> Blue 
// <6=> Magenta 
// <7=> Cyan 
// <8=> White 

#ifndef UART_CONFIG_INFO_COLOR
#define UART_CONFIG_INFO_COLOR 0
#endif

// <o> UART_CONFIG_DEBUG_COLOR  - ANSI escape code prefix.
 
// <0=> Default 
// <1=> Black 
// <2=> Red 
// <3=> Green 
// <4=> Yellow 
// <5=> Blue 
// <6=> Magenta 
// <7=> Cyan 
// <8=> White 

#ifndef UART_CONFIG_DEBUG_COLOR
#define UART_CONFIG_DEBUG_COLOR 0
#endif

#endif //UART_CONFIG_LOG_ENABLED
// </e>

#endif //UART_ENABLED
// </e>


STEP 8:build project / download to your device
click build/build configuration/ clean "light_switch_server"/ build "light_switch_server"



click target/connect JLink/ Download "light_switch_server" /Verify "light_switch_server"



then open com port, you can see


and that means we exactly activate UART function.


NOTE:
1. nordic semiconductor's websites  don't have any message about exactly how to  use an example from the nRF5 SDK in combination with the mesh stack. However, in this example, I prove that add/ include all necessary files and modify configuration , we can use hardware externals APIs from nRF5 SDK to ble MESH SDK.


REFERENCE:
1. http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.meshsdk.v0.10.0%2Fmd_doc_getting_started_how_to_nordicSDK.html&cp=4_1_0_0_0

2. https://devzone.nordicsemi.com/f/nordic-q-a/19549/segger-studio-tutorial-user-include-directories-has-no-effect---no-such-file

3.http://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.meshsdk.v1.0.0%2FLIBRARIES.html&cp=4_1_0_4