uloop.vsp.sb

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++                                                                      ++
// +++++  When UwTerminal downloads the app it will store it as a filenname   ++
// +++++  which consists of all characters up to the first . and excluding it ++
// +++++                                                                      ++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Virtual Serial Port "Soft" Loopback app
// Instructions:
// - Run the app by entering the app name "uloop<cr>"
// - If AUTO_STARTUP bit 0 is set to 1, the initapp command will be run automatically.
// - If AUTO_STARTUP bit 0 is set to 0, enter the "initapp<cr>" command
// - When ready to connect to the devkit, enter the "ad 1" command to start advertising. 
// - Connect to the devkit and start sending data. Any data received are looped back by
//   this app i.e. all data received are sent back to the central unit.
//
// Further commands are available - see comments in the cli.uloop.vsp.sblib file.
//
//   ####################################
//   #                                  #
//   #  Search for TODO to make changes #
//   #                                  #
//   ####################################
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

        //This defines how the application startsup and is a bit mask.
        //Bit 0 == 1 then OnStartup() is called just before waitevent
        //Bit 1 == 1 then StartAds() is called just before waitevent
#define AUTO_STARTUP                         1

        //Set this to 0 to disable all debugging messages
#define ENABLE_DEBUG_PRINTS                  1

#define DEVICENAME                           "LT_ULOOP"
#define DEVICENAME_WRITABLE                  1
#define APPEARANCE                           BLE_APPEARANCE_GENERIC_TAG
#define MANF_NAME                            "Laird Technologies"
#define MODELSTR                             "BL600"
#define SERIALNUM                            "12345"
#define HWREV                                "HwRev1.0"
#define SWREV                                "SwRev1.0"

//-------------------------------------------
//TODO - Uncomment one of the following three lines
//TODO #define SYSID                                "\01\02\03\04\05\06\07\08"
//#define SYSID                                "@"
#define SYSID                                ""
//-------------------------------------------

//-------------------------------------------
//TODO - Uncomment one of the following two lines
//#define REGLIST                              "\DE\AD\C0\DE"
#define REGLIST                              ""
//-------------------------------------------

//-------------------------------------------
//TODO - Uncomment one of the following two lines
//#define PNPID                                "\01\04\BF\03\20\00\01"
#define PNPID                                ""
//-------------------------------------------

#define CHAR_CR                              13


        //Minimum acceptable connection interval (7.5ms)
#define MIN_CONN_INTERVAL                    7500
        //Maximum acceptable connection interval (1 second).
#define MAX_CONN_INTERVAL                    1000000
        //Slave latency -- number of conn events that can be missed
        //Effective Conn interval will be (SLAVE_LATENCY+1)*ACTUAL_CONN_INTERVAL
#define SLAVE_LATENCY                        0
        //Connection supervisory timeout (4 seconds) - max 32 seconds
#define CONN_SUP_TIMEOUT                     10000000
        //DiscoverableMode, set to BLE_DISCOVERABILITY_xxx
#define DISCOVERY_MODE                       BLE_DISCOVERABILITY_GENERAL
#define MAX_DEVNAME_CHRS                     10
        //Set Appearance advertise 0 to suppress
#define ADV_APPEARANCE                       0
        //Advertise interval
#define ADV_INTERVAL_MS                      100
        //Advertise timeout
#define ADV_TIMEOUT_MS                       300000

        //Whitelist Policy in Adverts
#define ADV_WHITELIST_FILTER_POLICY          ADV_FILTERPOLICY_BOTH

        //Minimum long term key size in octets
#define MIN_LTK_SIZE                         8
        //Maximum long term key size in octets
#define MAX_LTK_SIZE                         16

        //Set this to non-zero to enable notiy on batt service
#define BATT_NOTIFY                          0
#define BATT_INIT_LEVEL_PERC                 100

        //This sets the pairing i/p capability using bonding
#define PAIRING_IOCAPABILITY                 BLE_IOCAPABILITY_NONE

        //Connection Update Negotiation paramters
#define FIRST_CONN_PARAMS_UPDATE_DELAY       5000
#define NEXT_CONN_PARAMS_UPDATE_DELAY        5000
#define MAX_CONN_PARAMS_UPDATE_DELAY         15000

//******************************************************************************
// Debugging resource as early as possible
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

// -- lib\cli.uloop.vsp.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++                                                                      ++
// +++++  When UwTerminal downloads the app it will store it as a filenname   ++
// +++++  which consists of all characters up to the first . and excluding it ++
// +++++                                                                      ++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Virtual Serial Port "Soft" Loopback
//
//   ####################################
//   #                                  #
//   #  Search for TODO to make changes #
//   #                                  #
//   ####################################
//
//
//   When you run the app you will get a > command prompt to allow you to submit
//   commands as follows:-
//
//     initapp           - Initialise/start the app (not needed is AUTO_STARTUP bit 0 is set to 1)
//
//     vso               - VSP Open with 144 byte rx buffer & 112 byte tx buffer
//     vw aaaa           - VSP write
//     vr nnn            - VSP read up to nnn bytes from rx buffer
//     vi nnn            - VSP info
//     vsc               - VSP close
//     vsx               - Clear the local vsp read variable
//     vst               - Add the VSP uuid to the scan report
//     ve nn             - Put nn bytes into transmit buffer and send
//
//     fg n              - Set advertising discoverability mode - n is 0 to 3 (see BLE_DISCOVERABILITY_xxx )
//     ai nnnn           - Set advertising interval in milliseconds
//     at nnnn           - Set advertising timeout in milliseconds
//     af n              - Set advertising filter policy 0..3 (see ADV_FILTERPOLICY_xx)
//     scinit            - Initiliase the scan report to empty
//     sd ttaa..aa       - Set scan AD tag && data -- MUST be a hex string
//     scadd             - Append the AD element from sd command to scan report
//     sccmt             - Commit the scan report to the stack for reports
//     ma nnnnn..nnn     - Set mac address - 12 hex digits
//     ad n              - If n=0 then stop adverts otherwise start adverts if
//                            n=1 then ADV_IND
//                            n=2 then ADV_DIRECT_IND
//                            n=3 then ADV_SCAN_IND
//                            n=4 then ADV_NONCONN_IND
//
//     discon            - Disconnect
//     stop              - Exit app to command mode and can resume using RESUME command
//     quit              - Quit app to command mode
//     in nnnn           - Set min conn interval (us)
//     ix nnnn           - Set max conn interval (us)
//     st nnnn           - Set supervision timeout (us)
//     sl nnnn           - Set slave latency
//     negp              - Negotiate connection parameters
//
//     io n              - If n=0 then BLE_IOCAPABILITY_NONE
//                            n=1 then BLE_IOCAPABILITY_DISPLAY_YESNO
//                            n=2 then BLE_IOCAPABILITY_KEYBOARD_ONLY
//                            n=3 then BLE_IOCAPABILITY_DISPLAY_ONLY
//                            n=4 then BLE_IOCAPABILITY_KEYBOARD_DISPLAY
//     ky nnnn           - Set pairing passcode (decimal)
//     kn nn             - Minimum size of ltk
//     kx nn             - Maximum size of ltk
//     setkey            - Commit min and max ltk key size
//
//     db nn             - Display debug info associated with nn
//
//     dr aaaaaa         - GAP - set device name with read only
//     dw aaaaaa         - GAP - set device name with read/write capability only
//
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

#define MAX_RX_HEAP_SIZE                100

//******************************************************************************
// Register Error Handler as early as possible
//******************************************************************************
sub HandlerOnErr()
  if (ENABLE_DEBUG_PRINTS!=0) then
    print "\n OnErr - ";GetLastError();"\n"
  endif
endsub
onerror next HandlerOnErr

//******************************************************************************
// Library Import
//******************************************************************************

// -- lib\debugging.routines.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// +++++                                                                      ++
// +++++  When UwTerminal downloads the app it will store it as a filenname   ++
// +++++  which consists of all characters up to the first . and excluding it ++
// +++++                                                                      ++
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// Debugging and Tracing Routines - BEFORE includes
//
// Have either the following
//
//  #define ENABLE_DEBUG_PRINTS                  1
//
// or
//
//  #define ENABLE_DEBUG_PRINTS                  0
//
// in the source file that includes this
//
//******************************************************************************

// "lib\debugging.routines.sblib"

//==============================================================================
//==============================================================================
sub AssertResCode(byval rc as integer,byval tag as integer)
  if (ENABLE_DEBUG_PRINTS!=0) && (rc!=0) then
    print "Failed with ";integer.h' rc;" at tag ";tag;"\n"
  endif
endsub

//==============================================================================
//==============================================================================
sub DbgMsg(byval msg$ as string)
  if (ENABLE_DEBUG_PRINTS!=0) then
    print msg$;"\n"
  endif
endsub

//==============================================================================
//==============================================================================
sub DbgMsgVal(byval msg$ as string, byval vl as integer)
  if (ENABLE_DEBUG_PRINTS!=0) then
    print msg$;" ";vl;"\n"
  endif
endsub

//==============================================================================
//==============================================================================
sub DbgPrnAdvReport(byref rp$ as string)
  if (ENABLE_DEBUG_PRINTS!=0) then
    print "Rpt=";strhexize$(rp$);"\n"
  endif
endsub



// -- lib\debugging.routines.sblib -- END

// -- lib\ble.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains all the BLE related #defines that will make your app
// more readable
//
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

#define BLE_CONN_HANDLE_INVALID                             0xFFFF
#define BLE_INVALID_UUID_HANDLE                             0
#define BLE_INVALID_CHAR_HANDLE                             0
#define BLE_INVALID_SERVICE_HANDLE                          0
#define CIRCBUFFER_INVALID_HANDLE                           -1

//Set BLE_DISCOVERABILITY_NONE if whitelist is enabled in BleAdvertStart()
//as the 4.0 spec says if whitelist is enabled then discoverability is not allowed
#define BLE_DISCOVERABILITY_NONE                            0
#define BLE_DISCOVERABILITY_LIMITED                         1
#define BLE_DISCOVERABILITY_GENERAL                         2
#define BLE_DISCOVERABILITY_BOTH                            3

#define BLE_APPEARANCE_UNKNOWN                              0
#define BLE_APPEARANCE_GENERIC_PHONE                        64
#define BLE_APPEARANCE_GENERIC_COMPUTER                     128
#define BLE_APPEARANCE_GENERIC_WATCH                        192
#define BLE_APPEARANCE_WATCH_SPORTS_WATCH                   193
#define BLE_APPEARANCE_GENERIC_CLOCK                        256
#define BLE_APPEARANCE_GENERIC_DISPLAY                      320
#define BLE_APPEARANCE_GENERIC_REMOTE_CONTROL               384
#define BLE_APPEARANCE_GENERIC_EYE_GLASSES                  448
#define BLE_APPEARANCE_GENERIC_TAG                          512
#define BLE_APPEARANCE_GENERIC_KEYRING                      576
#define BLE_APPEARANCE_GENERIC_MEDIA_PLAYER                 640
#define BLE_APPEARANCE_GENERIC_BARCODE_SCANNER              704
#define BLE_APPEARANCE_GENERIC_THERMOMETER                  768
#define BLE_APPEARANCE_THERMOMETER_EAR                      769
#define BLE_APPEARANCE_GENERIC_HEART_RATE_SENSOR            832
#define BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT    833
#define BLE_APPEARANCE_GENERIC_BLOOD_PRESSURE               896
#define BLE_APPEARANCE_BLOOD_PRESSURE_ARM                   897
#define BLE_APPEARANCE_BLOOD_PRESSURE_WRIST                 898
#define BLE_APPEARANCE_HUMAN_INTERFACE_DEVICE_HID_GENERIC   960
#define BLE_APPEARANCE_KEYBOARD_HID_SUBTYPE                 961
#define BLE_APPEARANCE_MOUSE_HID_SUBTYPE                    962
#define BLE_APPEARANCE_JOYSTICK_HID_SUBTYPE                 963
#define BLE_APPEARANCE_GAMEPAD_HID_SUBTYPE                  964
#define BLE_APPEARANCE_DIGITIZER_TABLET_HID_SUBTYPE         965
#define BLE_APPEARANCE_CARD_READER_HID_SUBTYPE              966
#define BLE_APPEARANCE_DIGITAL_PEN_HID_SUBTYPE              967
#define BLE_APPEARANCE_BARCODE_SCANNER_HID_SUBTYPE          968
#define BLE_APPEARANCE_GENERIC_GLUCOSE_METER                1024

#define UUID_ALERT_NOTIFICATION_SERVICE                 0x1811
#define UUID_BATTERY_SERVICE                            0x180F
#define UUID_BLOOD_PRESSURE_SERVICE                     0x1810
#define UUID_CURRENT_TIME_SERVICE                       0x1805
#define UUID_DEVICE_INFORMATION_SERVICE                 0x180A
#define UUID_GLUCOSE_SERVICE                            0x1808
#define UUID_HEALTH_THERMOMETER_SERVICE                 0x1809
#define UUID_HEART_RATE_SERVICE                         0x180D
#define UUID_HUMAN_INTERFACE_DEVICE_SERVICE             0x1812
#define UUID_IMMEDIATE_ALERT_SERVICE                    0x1802
#define UUID_LINK_LOSS_SERVICE                          0x1803
#define UUID_NEXT_DST_CHANGE_SERVICE                    0x1807
#define UUID_PHONE_ALERT_STATUS_SERVICE                 0x180E
#define UUID_REFERENCE_TIME_UPDATE_SERVICE              0x1806
#define UUID_SCAN_PARAMETERS_SERVICE                    0x1813
#define UUID_TX_POWER_SERVICE                           0x1804

#define BLE_SERVICE_SECONDARY                           0
#define BLE_SERVICE_PRIMARY                             1

#define BLE_CHAR_METADATA_ATTR_NOT_PRESENT              0

#define BLE_ATTR_ACCESS_NONE                            0
#define BLE_ATTR_ACCESS_OPEN                            1
#define BLE_ATTR_ACCESS_ENC_NO_MITM                     2
#define BLE_ATTR_ACCESS_ENC_WITH_MITM                   3
#define BLE_ATTR_ACCESS_SIGNED_NO_MITM                  4
#define BLE_ATTR_ACCESS_SIGNED_WITH_MITM                5

#define BLE_CHAR_PROPERTIES_BROADCAST                   0x01
#define BLE_CHAR_PROPERTIES_READ                        0x02
#define BLE_CHAR_PROPERTIES_WRITE_WO_RESPONSE           0x04
#define BLE_CHAR_PROPERTIES_WRITE                       0x08
#define BLE_CHAR_PROPERTIES_NOTIFY                      0x10
#define BLE_CHAR_PROPERTIES_INDICATE                    0x20
#define BLE_CHAR_PROPERTIES_AUTH_SIGNED_WR              0x40
#define BLE_CHAR_PROPERTIES_RELIABLE_WRITE              0x80


//Body Sensor Location values
#define BLE_HRS_BODY_SENSOR_LOCATION_OTHER              0
#define BLE_HRS_BODY_SENSOR_LOCATION_CHEST              1
#define BLE_HRS_BODY_SENSOR_LOCATION_WRIST              2
#define BLE_HRS_BODY_SENSOR_LOCATION_FINGER             3
#define BLE_HRS_BODY_SENSOR_LOCATION_HAND               4
#define BLE_HRS_BODY_SENSOR_LOCATION_EAR_LOBE           5
#define BLE_HRS_BODY_SENSOR_LOCATION_FOOT               6

//Types of advert packets
#define ADV_IND                                         0
#define ADV_DIRECT_IND                                  1
#define ADV_SCAN_IND                                    2
#define ADV_NONCONN_IND                                 3

//Types of filter policy
#define ADV_FILTERPOLICY_ANY                            0
#define ADV_FILTERPOLICY_SCANREQ                        1
#define ADV_FILTERPOLICY_CONNREQ                        2
#define ADV_FILTERPOLICY_BOTH                           3



//BLE EVENT MSG IDs
#define BLE_EVBLEMSGID_CONNECT                          0 //msgCtx = connection handle
#define BLE_EVBLEMSGID_DISCONNECT                       1 //msgCtx = connection handle
#define BLE_EVBLEMSGID_IMMEDIATE_ALERT_SERVICE_ALERT    2 //msgCtx = alert level
#define BLE_EVBLEMSGID_LINKLOSS_SERVICE_ALERT           3 //msgCtx = alert level
#define BLE_EVBLEMSGID_SERVICE_ERROR                    4 //msgCtx = resultcode
#define BLE_EVBLEMSGID_HTS_INDICATION_STATE             5 //msgCtx = new indication state 0=off, 1=on
#define BLE_EVBLEMSGID_HTS_INDICATION_CNF               6 //msgCtx = not used
#define BLE_EVBLEMSGID_BPS_INDICATION_STATE             7 //msgCtx = new indication state 0=off, 1=on
#define BLE_EVBLEMSGID_BPS_INDICATION_CNF               8 //msgCtx = not used
#define BLE_EVBLEMSGID_DISPLAY_PASSKEY                  9 //msgCtx = passcode to display
#define BLE_EVBLEMSGID_NEW_BOND                        10 //msgCtx = connection handle
#define BLE_EVBLEMSGID_AUTH_KEY_REQUEST                11 //msgCtx = 1 for passkey, 2 for 16 byte OOB data
#define BLE_EVBLEMSGID_HRS_NOTIFICATION_STATE          12 //msgCtx = new notification state 0=off, 1=on
//#define FUTURE_USE                                   13
#define BLE_EVBLEMSGID_CONN_PARMS_UPDATE               14 //msgCtx = connection handle
#define BLE_EVBLEMSGID_CONN_PARMS_UPDATE_FAIL          15 //msgCtx = connection handle
#define BLE_EVBLEMSGID_CONN_TO_BONDED_MASTER           16 //msgCtx = connection handle
#define BLE_EVBLEMSGID_UPDATED_BOND                    17 //msgCtx = connection handle
#define BLE_EVBLEMSGID_ENCRYPTED                       18 //msgCtx = connection handle
#define BLE_EVBLEMSGID_POWER_FAILURE_WARNING           19 //msgCtx = current supply voltage
#define BLE_EVBLEMSGID_UNENCRYPTED                     20 //msgCtx = connection handle
#define BLE_EVBLEMSGID_DEVICENAME_WRITE                21 //msgCtx = connection handle 

//BLE Alert Levels
#define BLE_ALERT_LEVEL_NO_ALERT                        0
#define BLE_ALERT_LEVEL_MILD_ALERT                      1
#define BLE_ALERT_LEVEL_HIGH_ALERT                      2


//Blood Pressure Feature Bits
#define BLE_BPS_FEATURE_BODY_MOVEMENT_BIT               1
#define BLE_BPS_FEATURE_CUFF_FIT_BIT                    2
#define BLE_BPS_FEATURE_IRREGULAR_PULSE_BIT             4
#define BLE_BPS_FEATURE_PULSE_RATE_RANGE_BIT            8
#define BLE_BPS_FEATURE_MEASUREMENT_POSITION_BIT        16
#define BLE_BPS_FEATURE_MULTIPLE_BOND_BIT               32

//Blood Pressure Measurement Status flags
#define BLE_BPS_MEAS_STAT_BODY_MOVEMENT                 1
#define BLE_BPS_MEAS_STAT_CUFF_FIT                      2
#define BLE_BPS_MEAS_STAT_IRREGULAR_PULSE               4
#define BLE_BPS_MEAS_STAT_PULSE_RATE_RANGE              8
#define BLE_BPS_MEAS_STAT_MEASUREMENT_POSITION          16

//Pairing i/o capability
#define BLE_IOCAPABILITY_NONE                           0
#define BLE_IOCAPABILITY_DISPLAY_YESNO                  1
#define BLE_IOCAPABILITY_KEYBOARD_ONLY                  2
#define BLE_IOCAPABILITY_DISPLAY_ONLY                   3
#define BLE_IOCAPABILITY_KEYBOARD_DISPLAY               4
#define BLE_IOCAPABILITY_ILLEGAL                        5


//Health thermometer sensor location
#define BLE_HTS_TEMP_TYPE_ARMPIT                        1
#define BLE_HTS_TEMP_TYPE_BODY                          2
#define BLE_HTS_TEMP_TYPE_EAR                           3
#define BLE_HTS_TEMP_TYPE_FINGER                        4
#define BLE_HTS_TEMP_TYPE_GI_TRACT                      5
#define BLE_HTS_TEMP_TYPE_MOUTH                         6
#define BLE_HTS_TEMP_TYPE_RECTUM                        7
#define BLE_HTS_TEMP_TYPE_TOE                           8
#define BLE_HTS_TEMP_TYPE_EAR_DRUM                      9

//HCI Status Codes
#define BLE_HCI_AUTHENTICATION_FAILURE                  0x05
#define BLE_HCI_CONNECTION_TIMEOUT                      0x08


//Some Useful Result Codes to help with documentation
#define RESCODE_BLE_SVC_REGISTERED                      0x6018

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Equivalent to main() in C
//******************************************************************************

// -- lib\ble.sblib -- END

// -- lib\standard.advert.mngr.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains a standard advert manager and should be
// d in your app
//
//   Usage: (also see sample hrs.heart.rate.sb for more details)
//
//     (*) Call StartAdverts(...) from your code
//
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

dim advState                //Will be 0 if not advertising, 1,2,3,4 for the four advert types
dim advType                 //As per ADV_ in ble.sblib
dim addr$                   //Peer address for Directed Adverts (MSB first) and exactly 6 bytes long
dim advInt                  //Adv interval in milliseconds
dim advTmout                //Adv timeout in milliseconds
dim advFilPol               //Adv filter policy - see ADV_FILTERPOLICY_xxx in blelib.sblib
                            // 0 = Any
                            // 1 = Filter Scan Request
                            // 2 = Filter Connection Request
                            // 3 = Both

//******************************************************************************
// Initialisse Global Variable
//******************************************************************************

advState = 0
advType  = ADV_IND
addr$ = ""
advInt   = ADV_INTERVAL_MS
advTmout = ADV_TIMEOUT_MS
advFilPol= ADV_WHITELIST_FILTER_POLICY

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
// returns 0 if parameters are acceptable
//==============================================================================
function SetAdvertType(byval adType as integer,byref ad$ as string) as integer
  if (adType>=ADV_IND)&&(adType<=ADV_NONCONN_IND) then
    if (adType==ADV_DIRECT_IND) then
      if (strlen(ad$)!=6)  then
        exitfunc 0
      endif
      addr$=ad$
    endif
    advType = adType
    exitfunc 1
  endif
endfunc 0

//==============================================================================
//==============================================================================
function GetAdvertState() as integer
endfunc advState

//==============================================================================
//==============================================================================
function SetAdvertInt(intvl as integer) as integer
  if intvl < 20 then
    exitfunc 0
  endif
  if advType >= ADV_SCAN_IND then
    if intvl < 100 then
      exitfunc 0
    endif
  endif
  advInt = intvl
endfunc 1

//==============================================================================
//==============================================================================
function SetAdvertTout(inttm as integer) as integer
  if inttm < (advInt+20) then
    exitfunc 0
  endif
  advTmout = inttm
endfunc 1

//==============================================================================
//==============================================================================
function SetPeerAddr(ad$ as string) as integer
  ad$=StrDehexize$(ad$)
  if strlen(ad$) != 7 then
    exitfunc 5
  endif
  addr$=ad$
endfunc 0

//==============================================================================
//==============================================================================
function SetAdvertFPol(fpol as integer) as integer
  if (fpol >= ADV_FILTERPOLICY_ANY)&&(fpol <= ADV_FILTERPOLICY_BOTH)then
    advFilPol = fpol
    exitfunc 1
  endif
endfunc 0

//==============================================================================
// Returns 0 if successful, otherwise appropriate error code
//==============================================================================
function StopAdverts() as integer
  dim rc
  rc=0
  if advState != 0 then
    //currently advertising
    rc = BleAdvertStop()
    AssertResCode(rc,3000)
    if rc==0 then
      //adverts stopped successfully
      advState=0
    endif
  endif
endfunc rc

//==============================================================================
// -1 for the last valid type of advert that was sent
//  0 ADV_IND
//  1 ADV_DIRECT_IND
//  2 ADV_SCAN_IND
//  3 ADV_NONCONN_IND
//
// Returns 0 if successful, otherwise appropriate error code
//==============================================================================
function StartAdverts(adv as integer) as integer
  dim rc
  if advState == 0 then
    //currently not advertising
    if adv == -1 then
      adv = advType
    elseif (adv<0)||(adv>3) then
      //invalid advertising type
      rc=0xEF01
      AssertResCode(rc,3120)
      exitfunc rc
    endif
    rc = BleAdvertStart(adv,addr$,advInt,advTmout,advFilPol)
    AssertResCode(rc,3100)
    //
    // Warning: If you get an error here it is most likely that you
    //          have limited discoverability and the advert timeout is > 180000
    //
    if rc==0 then
      //Adverts started successfully
      advType = adv
      advState = advType + 1
    endif
  else
    //Currently advertising
    rc=0xEF00
    AssertResCode(rc,3110)
  endif
endfunc rc


//==============================================================================
// MUST be called from the BLE message handler
//==============================================================================
sub AdvMngrOnBleMsg(BYVAL nMsgId AS INTEGER, BYVAL nCtx AS INTEGER)
  dim rc

  select nMsgId
  case BLE_EVBLEMSGID_CONNECT
    advState=0

  case BLE_EVBLEMSGID_DISCONNECT
    //Restart advertising
    rc=StartAdverts(-1)
    AssertResCode(rc,3200)

  case else
    //Do nothing
  endselect

endsub

//==============================================================================
// Will return 0 if no longer advertising
//==============================================================================
function AdvMngrOnAdvTimeOut() as integer
  advState = 0
endfunc advState

//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************


// -- lib\standard.advert.mngr.sblib -- END

// -- lib\advert.report.manager.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains the advert & scan report manager and should be
// d in your app
//
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

dim adRpt$ as string        //Contains the most recent Advertise report
dim scRpt$ as string        //Contains the most recent scan report
dim advUuid[6]              //These are the uuid's that are exposed
dim advUuidCnt              //Uuid Counts for advert report

//******************************************************************************
// Initialise Global Variable
//******************************************************************************

adRpt$=""
scRpt$=""

//Initialise the uuid array list with -1 which will be taken as item not to
//to be included in the advert report for the uuid AD element.
for advUuidCnt=0 to 5
  advUuid[advUuidCnt]=-1
next
advUuidCnt = 0

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
// Will add to array if there is space
//==============================================================================
sub AddUuid(nUuid as integer)
  if advUuidCnt < 5 then
    advUuid[advUuidCnt]=nUuid
    advUuidCnt = advUuidCnt + 1
  endif
endsub

//==============================================================================
// advFlags = Flags for Advert Report
//==============================================================================
sub InitAdvReports(advFlags as integer)
  dim rc

  adRpt$=""
  scRpt$=""

  //If whitelist filter policy is enabled and there is at least one master
  //in the bonding manager, then need to reset the advFlags so that
  //discoverability is disabled
  if advFilPol != ADV_FILTERPOLICY_ANY then
    //Filter policy has been enabled
    if sysinfo(2009) != 0 then
      //There is at least one master in the trusted device database
      advFlags = advFlags & 0xFFFFFFFC
    endif
  endif

  //Create a minimal advertise report
  rc = BleAdvRptInit(adRpt$,advFlags,ADV_APPEARANCE,MAX_DEVNAME_CHRS)
  AssertResCode(rc,2030)

  //Append the uuid list to the advert report
  rc = BleAdvRptAddUuid16(adRpt$,advUuid[0],advUuid[1],advUuid[2],advUuid[3],advUuid[4],advUuid[5])
  AssertResCode(rc,2040)

  //Initialise an empty scan report
  rc = BleScanRptInit(scRpt$)
  AssertResCode(rc,2045)

  //Commit the advert and scan report to the scan
  rc = BleAdvRptsCommit(adRpt$,scRpt$)
  AssertResCode(rc,2050)

endsub

//==============================================================================
//==============================================================================
function ScanReportInit()
  dim rc
  rc = BleScanRptInit(scRpt$)
  AssertResCode(rc,2060)
endfunc rc

//==============================================================================
//==============================================================================
function ScanReportAppend(nTag as integer, byref adData$ as string)
  dim rc
  rc = BleAdvRptAppendAD(scRpt$,nTag,adData$)
  AssertResCode(rc,2070)
endfunc rc

//==============================================================================
//==============================================================================
function ScanReportCommit()
  dim rc,rpt$
  rpt$=""
  rc = BleAdvRptsCommit(rpt$,scRpt$)
  AssertResCode(rc,2080)
endfunc rc


//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************


// -- lib\advert.report.manager.sblib -- END

// -- lib\connection.manager.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains the connection manager and should be
// d in your app
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

dim minint          //Minimum interval range is 7500us to 4000000us
dim maxint          //Minimum interval range is 7500us to 4000000us
dim sprtout         //Link supervision timeout max value 32000000us
dim slatncy         //Slave latency 0..N where N*Interval must be less than link
                    //Supervision timeout
dim hConn           //Connection handle

//******************************************************************************
// Initialise Global Variable
//******************************************************************************

hConn   = BLE_CONN_HANDLE_INVALID
minint  = MIN_CONN_INTERVAL
maxint  = MAX_CONN_INTERVAL
sprtout = CONN_SUP_TIMEOUT
slatncy = SLAVE_LATENCY


//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
// hc is the handle of the connection to be dropped
//==============================================================================
function Disconnect(hc as integer) as integer
  dim rc
  rc = BleDisconnect(hc)
  AssertResCode(rc,4100)
endfunc rc

//==============================================================================
// hc is the handle of the connection to be dropped
//==============================================================================
function ConnNewParms(hc as integer) as integer
  dim rc
  rc = BleSetCurConnParms(hc,minint,maxint,sprtout,slatncy)
  AssertResCode(rc,4110)
endfunc rc


//==============================================================================
// MUST be called from the BLE message handler
//==============================================================================
sub ConnMngrOnBleMsg(BYVAL nMsgId AS INTEGER, BYVAL nCtx AS INTEGER)
  select nMsgId
  case BLE_EVBLEMSGID_CONNECT
    hConn = nCtx

  case BLE_EVBLEMSGID_DISCONNECT
    hConn = BLE_CONN_HANDLE_INVALID

  case else
    //Do nothing
  endselect
endsub


//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************


// -- lib\connection.manager.sblib -- END

// -- lib\security.manager.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains a standard advert manager and should be
// d in your app
//
//   Usage: (also see sample hrs.heart.rate.sb for more details)
//
//     (*) Call SendPassKey(...) from your code
//
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

//******************************************************************************
// Initialise Global Variable
//******************************************************************************

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
//==============================================================================
function SecSendPassKey(hc as integer, byval ky as integer) as integer
  dim rc
  if hc != BLE_CONN_HANDLE_INVALID then
    rc = BleSecMngrPassKey(hc,ky)
    AssertResCode(rc,4010)
  endif
endfunc rc

//==============================================================================
//==============================================================================
function SecSetIoCap(ioCap as integer) as integer
  dim rc
  rc = BleSecMngrIocap(iocap)
  AssertResCode(rc,4020)
endfunc rc

//==============================================================================
//==============================================================================
function SecSetLtkSizeRange(mnLtk as integer, mxLtk as integer) as integer
  dim rc
  rc = BleSecMngrKeySizes(mnLtk,mxLtk)
  AssertResCode(rc,4030)
endfunc rc

//==============================================================================
//==============================================================================
sub InitSecurityMngr(ioCap as integer,mnLtk as integer, mxLtk as integer)
  dim rc
  rc = SecSetIoCap(ioCap)
  rc = SecSetLtkSizeRange(mnLtk,mxLtk)
endsub

//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************


// -- lib\security.manager.sblib -- END

// -- lib\gap.service.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains the GAP service manager and should be
// d in your app
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

//******************************************************************************
// Initialise Global Variable
//******************************************************************************

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
//==============================================================================
sub InitGapService()
  dim rc
  rc = BleGapSvcInit(DEVICENAME,DEVICENAME_WRITABLE,APPEARANCE,MIN_CONN_INTERVAL,MAX_CONN_INTERVAL,CONN_SUP_TIMEOUT,SLAVE_LATENCY)
  AssertResCode(rc,2410)
endsub


//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************




// -- lib\gap.service.sblib -- END

// -- lib\device.information.service.sblib -- START

// Copyright (c) 2013, Laird
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
// IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier:ISC
//
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ######                                                                #######
// ######        Library File meant to be d in files             #######
// ######                                                                #######
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// This library contains contains the Device Information Service and should be
// d in your app
//
//******************************************************************************

//******************************************************************************
// Definitions
//******************************************************************************

//******************************************************************************
// Library Import
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

//******************************************************************************
// Initialise Global Variable
//******************************************************************************

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//==============================================================================
//==============================================================================
sub InitDisService()
  dim mf$,md$,sy$,rl$
  dim rc

  mf$=MANF_NAME
  md$=MODELSTR
  rl$=REGLIST
  sy$=SYSID
  rc = BleSvcRegDevInfo(mf$,md$,SERIALNUM,HWREV,SWREV,sy$,rl$,PNPID)

  if (rc==0) || (rc==RESCODE_BLE_SVC_REGISTERED) then
     AddUuid(UUID_DEVICE_INFORMATION_SERVICE)
  else
    AssertResCode(rc,2510)
  endif

endsub

//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Other initialisations
//******************************************************************************




// -- lib\device.information.service.sblib -- END

//******************************************************************************
// Debugging resource after libs
//******************************************************************************

//==============================================================================
//==============================================================================
sub DbgInfo(id as integer)
  select id
  case 0
    DbgPrnAdvReport(adRpt$)
  case 1
    DbgPrnAdvReport(scRpt$)

  case else
  endselect
endsub


//******************************************************************************
// Global Variable Declarations
//******************************************************************************

dim stRsp$ as string        //Uart rx data is stored here
dim ok$,er$
dim msg$
dim mnltk                   //Min size of ltk
dim mxltk                   //Max size of ltk
dim advFlags                //Value for flags AD
dim adTag                   //AD Tag
dim adDta$                  //AD Data

dim tsz                     //txbuf size for VSP
dim rsz                     //rxbuf size for VSP
dim flgs                    //Flags for VSP
dim uuhdl                   //Service uuid handle for VSP
dim rx$                     //VSP read data stored here
dim rxb                     //VSP read block size

//******************************************************************************
// Initialisse Global Variable
//******************************************************************************

ok$      = "\nOK\r\n>"
er$      = "\nERROR\r\n>"

mnltk    = MIN_LTK_SIZE
mxltk    = MAX_LTK_SIZE
advFlags = DISCOVERY_MODE    //Can be changed via 'fg' command

adTag    = 0
adDta$   = ""

tsz      = 112
rsz      = 144
flgs     = 1
uuhdl    = 0

rxb      = 60

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************


//==============================================================================
//==============================================================================
sub UartRsp(rsp as integer)
  dim rc
  if rsp == 0 then
    rc = UartWrite(ok$)
  else
    rc = UartWrite(er$)
  endif
endsub

//==============================================================================
//==============================================================================
sub UartMsg(byref msg$ as string)
  dim rc
  rc = UartWrite(msg$)
endsub


//==============================================================================
//==============================================================================
function StartAds(adv as integer) as integer
  dim rc
  rc=StartAdverts(adv)
  if rc==0 then
    DbgMsgVal("Start Adverts",adv)
  endif
endfunc rc

//==============================================================================
//==============================================================================
function StopAds() as integer
  dim rc
  rc=StopAdverts()
  if rc==0 then
    DbgMsg("Stop Adverts")
  endif
endfunc rc

//==============================================================================
//==============================================================================
sub SetDeviceName(st$ as string,wr as integer)
  dim rc
  rc = BleGapSvcInit(st$,wr,APPEARANCE,MIN_CONN_INTERVAL,MAX_CONN_INTERVAL,CONN_SUP_TIMEOUT,SLAVE_LATENCY)
  AssertResCode(rc,2020)
  InitAdvReports(advFlags)
endsub

//==============================================================================
//==============================================================================
function SaveMacAddr(byref ad$ as string) as integer
  dim vl
  vl=strlen(ad$)
  if vl==7 then
    addr$ = ad$
    exitfunc 0
  endif
endfunc 1

//==============================================================================
//==============================================================================
function ProcAdvCmd(vl as integer) as integer
  dim rc
  if vl==0 then
    rc= StopAds()
  else
    vl=vl-1
    rc= StartAds(vl)
  endif
endfunc rc

//==============================================================================
//==============================================================================
sub ShowConnParms(nCtx as integer)
  dim rc
  dim intrvl,sprvto,slat
  rc= BleGetCurConnParms(nCtx,intrvl,sprvto,slat)
  AssertResCode(rc,1240)
  if rc==0 then
    DbgMsgVal("Conn Interval",intrvl)
    DbgMsgVal("Conn Supervision Timeout",sprvto)
    DbgMsgVal("Conn Slave Latency",slat)
  endif
endsub


//==============================================================================
//==============================================================================
function ProcScanData(st$ as string)
  dim rc
  rc = 1
  if strlen(st$) >= 1 then
    adTag  = StrGetChr(st$,0)
    adDta$ = mid$(st$,1,65535)
    rc=0
  endif
endfunc rc


//==============================================================================
//==============================================================================
function VSpOpen()
  dim rc
  rc = BleVSpOpen(tsz,rsz,flgs,uuhdl)
  AssertResCode(rc,7400)
  if rc==0 then
    print "\nBleVSpOpen() OK  (uuhdl=";uuhdl;")\n"
    //Get the rx read block size, and limit to 60 so that large block
    //from heap is not taken
    rxb = BleVspInfo(1)
    if rxb > MAX_RX_HEAP_SIZE then
      rxb = MAX_RX_HEAP_SIZE
    endif
  else
    print "\nBleVSpOpen() FAILED  (rc=";rc;")\n"
  endif
endfunc rc

//==============================================================================
//==============================================================================
function VSpClose()
  BleVSpClose()
  print "\nBleVSpClose() OK"
endfunc 0

//==============================================================================
//==============================================================================
function VSpInfo(itype)
  print "\nBleVSpInfo(";itype;") returned ";BleVSpInfo(iType)
endfunc 0

//==============================================================================
//==============================================================================
function VSpWrite(x$)
  dim n
  n = BleVSpWrite(x$)
  print "\nBleVSpWrite(x$) returned ";n;" and len of x$ was ";strlen(x$)
endfunc 0

//==============================================================================
//==============================================================================
function VSpWriteEx(ln)
  dim n,r,x$
  r=strfill(x$,0,ln)
  if r==0 then
    ln= ln-1
    for n=0 to ln
      r = 0x41 + (n%57)   //'A' + offset
      r = strsetchr(x$,r,n)
    next
    r = BleVSpWrite(x$)
    print "\nBleVSpWrite(x$) returned ";r;" and len of x$ was ";strlen(x$)
  else
    exitfunc r
  endif
endfunc 0

//==============================================================================
//==============================================================================
function VSpRead(ilen)
  dim n
  n = BleVSpRead(rx$,ilen)
  print "\nBleVSpRead(,";ilen;") returned ";n;" and datalen ";strlen(rx$)
  print "\nData=";rx$
endfunc 0

//==============================================================================
//==============================================================================
function VSpAdvert()
  dim rc,rpt$
  rc = BleAdvRptAddUuid128(scRpt$,uuhdl)
  AssertResCode(rc,7410)
  if rc == 0 then
    rpt$=""
    rc = BleAdvRptsCommit(rpt$,scRpt$)
    AssertResCode(rc,7420)
  endif
  if rc == 0 then
    print "\nVSP added 128 uuid to scanrpt"
  endif
endfunc rc

//==============================================================================
// This is called to start things off just before the waitevent at the end of
// the file
//==============================================================================
sub OnStartup()
  dim rc

  InitSecurityMngr(PAIRING_IOCAPABILITY,MIN_LTK_SIZE, MAX_LTK_SIZE)

  //Initialise services
  InitGapService()
  InitDisService()

  //Initiliase advert and scan reports
  InitAdvReports(advFlags)

  //Initialise VSP service
  rc = VSpOpen()
  AssertResCode(rc,7982)

  //Add the VSP service to the scan report
  rc = VSpAdvert()
  AssertResCode(rc,7981)

endsub


//==============================================================================
// Expecting to see XX=nnn\n\r  where nnn =1 to 2 digit decimal number
//==============================================================================
function OnUartCmd(stData$,datalen) as integer
  dim stRS$,vl$
  dim vl,rc

  rc=0  //Assume OK response

  if datalen >= 4 then

    //Drop the terminating CR
    datalen = datalen - 1
    stData$ = left$(stData$,datalen)
    //Extract the command
    stRS$ = strsplitleft$(stData$,3)
    //************ Advertisement related commands ******************************

    if strcmp(stRS$,"ad ")==0 then
      rc = ProcAdvCmd(strvaldec(stData$))

    elseif strcmp(stRS$,"ma ")==0 then
      vl$ = strdehexize$(stData$)
      rc=SaveMacAddr(vl$)

    elseif  strcmp(stRS$,"ai ")==0 then  //Advertising interval in milliseconds
      if SetAdvertInt(strvaldec(stData$)) == 0 then
        rc = 1
      endif

    elseif  strcmp(stRS$,"at ")==0 then  //Advertising timeout in milliseconds
      if SetAdvertTout(strvaldec(stData$)) == 0 then
        rc = 1
      endif

    elseif  strcmp(stRS$,"af ")==0 then  //Advertising filter policy
      if SetAdvertFPol(strvaldec(stData$)) == 0 then
        rc = 1
      endif

    elseif strcmp(stRS$,"fg ")==0 then   //Flags AD value (0..3) see BLE_DISCOVERABILITY_xxx
      advFlags = strvaldec(stData$)

    elseif strcmp(stRS$,"sci")==0 then   //scinit - Initiliase the scan report to empty
      rc=ScanReportInit()

    elseif strcmp(stRS$,"scc")==0 then   //sccmt  - Commit the scan report to the stack for reports
      rc=ScanReportCommit()

    elseif strcmp(stRS$,"sd ")==0 then   //sd ttaa..aa - Set scan AD tag && data -- MUST be a hex string
      vl$ = strdehexize$(stData$)
      rc = ProcScanData(vl$)

    elseif strcmp(stRS$,"sca")==0 then   //scadd  - Append the AD element from sd command to scan report
      rc = ScanReportAppend(adTag,adDta$)


    //************ Profile related commands ************************

    elseif strcmp(stRS$,"vso")==0 then   //vo       - VSP Open with 144 byte rx buffer & 112 byte tx buffer
      rc=VSpOpen()

    elseif strcmp(stRS$,"vsc")==0 then   //vc       - VSP close
      rc=VSpClose()

    elseif strcmp(stRS$,"vi ")==0 then   //vi nnn   - VSP info for nnn
      rc=VSpInfo(strvaldec(stData$))

    elseif strcmp(stRS$,"vw ")==0 then   //vw aaaa  - VSP write
      rc=VSpWrite(stData$)

    elseif strcmp(stRS$,"ve ")==0 then   //ve nn    - VSP store nn bytes and then write
      rc=VSpWriteEx(strvaldec(stData$))

    elseif strcmp(stRS$,"vr ")==0 then   //vr nnn   - VSP read up to nnn bytes from rx buffer
      rc=VSpRead(strvaldec(stData$))

    elseif strcmp(stRS$,"vsx")==0 then   //Clear the local vsp read variable
      rx$=""
      rc=0

    elseif strcmp(stRS$,"vst")==0 then   //vt       - Add the VSP uuid to the scan report
      rc=VSpAdvert()


    //************ GAP service related commands ****************************

    elseif strcmp(stRS$,"dr ")==0 then
      SetDeviceName(stData$,0)

    elseif strcmp(stRS$,"dw ")==0 then
      SetDeviceName(stData$,1)

    //************ Pairing related commands ************************************

    elseif strcmp(stRS$,"ky ")==0 then
      vl = strvaldec(stData$)
      DbgMsgVal( "Passkey : ",vl )
      rc = SecSendPassKey(hConn,vl)

    elseif strcmp(stRS$,"io ")==0 then
      rc = SecSetIoCap(strvaldec(stData$))

    elseif strcmp(stRS$,"kn ")==0 then
      mnltk = strvaldec(stData$)

    elseif strcmp(stRS$,"kx ")==0 then
      mxltk = strvaldec(stData$)

    elseif strcmp(stRS$,"set")==0 then     //setkey
      rc = SecSetLtkSizeRange(mnltk,mxltk)

    //************ connection related commands ************************************

    elseif  strcmp(stRS$,"in ")==0 then  //Minimum interval (us) for conn parameters
      minint = strvaldec(stData$)

    elseif  strcmp(stRS$,"ix ")==0 then  //Maximum interval (us) for conn parameters
      maxint = strvaldec(stData$)

    elseif  strcmp(stRS$,"st ")==0 then  //Supervision teimout (us) for conn parameters
      sprtout = strvaldec(stData$)

    elseif  strcmp(stRS$,"sl ")==0 then  //Slave latency for conn parameters
      slatncy = strvaldec(stData$)

    elseif strcmp(stRS$,"neg")==0 then
      rc = ConnNewParms(hConn)

    elseif strcmp(stRS$,"dis")==0 then   //Disconnect
      rc = Disconnect(hConn)

    //************ Misc & Debug related commands *******************************

    elseif strcmp(stRS$,"db ")==0 then
      DbgInfo(strvaldec(stData$))

    elseif strcmp(stRS$,"sto")==0 then
      stop

    elseif strcmp(stRS$,"qui")==0 then
      reset(0)
      exitfunc 0

    elseif ((AUTO_STARTUP & 1) == 0) && strcmp(stRS$,"ini")==0 then     //initapp
      OnStartup()
      DbgMsg( "OnStartup() called" )

    //**************************************************************************
    else
      rc = 1
    endif

  else
    rc = 1

  endif

  //Send a response back to the user
  UartRsp(rc)

endfunc 1



//******************************************************************************
// Handler definitions
//******************************************************************************

//==============================================================================
// This handler is called when there is a BLE message
//==============================================================================
function HandlerBleMsg(BYVAL nMsgId AS INTEGER, BYVAL nCtx AS INTEGER) as integer

  //Inform libraries
  ConnMngrOnBleMsg(nMsgId,nCtx)
  AdvMngrOnBleMsg(nMsgId,nCtx)

  select nMsgId
  case BLE_EVBLEMSGID_CONNECT
    DbgMsgVal(" --- Connect : ",nCtx)
    ShowConnParms(nCtx)

  case BLE_EVBLEMSGID_DISCONNECT
    DbgMsgVal(" --- Disconnect : ",nCtx)

  case BLE_EVBLEMSGID_IMMEDIATE_ALERT_SERVICE_ALERT
    DbgMsgVal( "\n --- Immediate Alert Service Alert ", nCtx)
    DbgMsg("\n")

  case BLE_EVBLEMSGID_DISPLAY_PASSKEY
    DbgMsgVal("Display Pairing Passkey ",nCtx)

  case BLE_EVBLEMSGID_NEW_BOND
    DbgMsg(" +++ New Bond")

  case BLE_EVBLEMSGID_UPDATED_BOND
    DbgMsg(" +++ Updated Bond")

  case BLE_EVBLEMSGID_ENCRYPTED
    DbgMsg(" +++ Encrypted Connection")

  case BLE_EVBLEMSGID_CONN_TO_BONDED_MASTER
    DbgMsgVal(" -- Conn to Bonded Master ",nCtx)

  case BLE_EVBLEMSGID_AUTH_KEY_REQUEST
    DbgMsgVal(" +++ Auth Key Request, type=",nCtx)

  case BLE_EVBLEMSGID_CONN_PARMS_UPDATE
    ShowConnParms(nCtx)

  case BLE_EVBLEMSGID_CONN_PARMS_UPDATE_FAIL
    DbgMsg(" ??? Conn Parm Negotiation FAILED")

  case else
    DbgMsgVal("Unknown Ble Msg", nMsgId)
  endselect
endfunc 1

//==============================================================================
// This handler is called when data has arrived at the serial port
//==============================================================================
function HandlerUartRx() as integer
  dim nMatch
  dim stData$

  nMatch=UartReadMatch(stRsp$,13)
  if nMatch!=0 then
    stData$ = strsplitleft$(stRsp$,nMatch)
    exitfunc OnUartCmd(stData$,nMatch)
  endif
endfunc 1

//==============================================================================
// This handler is called when data has arrived at the virtual serial port
// or if the vsp tx buffer is empty
//==============================================================================
function HandlerVspLoop() as integer
  dim ts,rxn

  while(1)

    //Get space in transmit buffer
    ts = BleVspInfo(4)
    if ts == 0 then
      //There is no space in the transmit buffer
      exitfunc 1
    elseif ts > rxb then
      //Because we want to limit taking up larger heap space for rx buffer
      ts = rxb
    endif

    //Reaching here means there could be at least 1 byte space in tx buffer
    rxn = BleVSpRead(rx$,ts)
    if rxn == 0 then
      //The rx buffer was empty
      exitfunc 1
    endif

    //Reaching here means rx$ has at least one byte to send
    //and definitely the space to send it because rxn<=ts
    ts = BleVSpWrite(rx$)

  endwhile

endfunc 1

//==============================================================================
// This handler is called when data has arrived at the serial port
//==============================================================================
function HandlerBlrAdvTimOut() as integer

  if AdvMngrOnAdvTimeOut() == 0 then

    DbgMsg( "\nAdvert stopped via timeout" )
    //DbgMsg( "\n   - could use SystemStateSet(0) to switch off" )

    //------------------------------------------------------------
    //  Switch off the system - requires a power cycle to recover
    //------------------------------------------------------------
    //  rc = SystemStateSet(0)
    //  AssertResCode(rc,1199)
  endif

endfunc 1

//******************************************************************************
// Equivalent to main() in C
//******************************************************************************

//------------------------------------------------------------------------------
// Enable synchronous event handlers
//------------------------------------------------------------------------------
OnEvent  EVUARTRX           call HandlerUartRx
OnEvent  EVBLE_ADV_TIMEOUT  call HandlerBlrAdvTimOut
OnEvent  EVBLEMSG           call HandlerBleMsg

//Both events have the same handler
OnEvent  EVVSPRX            call HandlerVspLoop
OnEvent  EVVSPTXEMPTY       call HandlerVspLoop

//------------------------------------------------------------------------------
// Initialise Services and then wait for events
//------------------------------------------------------------------------------
if (AUTO_STARTUP & 1) != 0 then
  //Create Advert packets and register services
  OnStartup()
endif
if (AUTO_STARTUP & 2) != 0 then
  //Start advertising
  dim rc
  rc=StartAds(ADV_IND)
endif


//Send user prompt for uart based command interface
msg$="\n\r"
UartMsg(msg$)
msg$=DEVICENAME
UartMsg(msg$)
msg$="\n\r"
UartMsg(msg$)

//Send an OK response
UartRsp(0)


// -- lib\cli.uloop.vsp.sblib -- END

//******************************************************************************
// Debugging resource after libs
//******************************************************************************

//******************************************************************************
// Global Variable Declarations
//******************************************************************************

//******************************************************************************
// Initialisse Global Variable
//******************************************************************************

//******************************************************************************
// Function and Subroutine definitions
//******************************************************************************

//******************************************************************************
// Handler definitions
//******************************************************************************

//******************************************************************************
// Equivalent to main() in C
//******************************************************************************


//------------------------------------------------------------------------------
// Wait for a synchronous event.
// An application can have multiple <WaitEvent> statements
//------------------------------------------------------------------------------
WaitEvent