/* Bit fields for EUSART TRIGCTRL */
#define _EUSART_TRIGCTRL_RESETVALUE                   0x00000000UL
#define _EUSART_TRIGCTRL_MASK                         0x00000007UL   
#define EUSART_TRIGCTRL_RXTEN                         (0x1UL << 0)     
#define _EUSART_TRIGCTRL_RXTEN_SHIFT                  0                   
#define _EUSART_TRIGCTRL_RXTEN_MASK                   0x1UL           
#define _EUSART_TRIGCTRL_RXTEN_DEFAULT                0x00000000UL
#define EUSART_TRIGCTRL_RXTEN_DEFAULT                 (_EUSART_TRIGCTRL_RXTEN_DEFAULT << 0)
#define EUSART_TRIGCTRL_TXTEN                         (0x1UL << 1)
#define _EUSART_TRIGCTRL_TXTEN_SHIFT                  1             
#define _EUSART_TRIGCTRL_TXTEN_MASK                   0x2UL     
#define _EUSART_TRIGCTRL_TXTEN_DEFAULT                0x00000000UL
#define EUSART_TRIGCTRL_TXTEN_DEFAULT                 (_EUSART_TRIGCTRL_TXTEN_DEFAULT << 1)
#define EUSART_TRIGCTRL_AUTOTXTEN                     (0x1UL << 2)
#define _EUSART_TRIGCTRL_AUTOTXTEN_SHIFT              2           
#define _EUSART_TRIGCTRL_AUTOTXTEN_MASK               0x4UL
#define _EUSART_TRIGCTRL_AUTOTXTEN_DEFAULT            0x00000000UL
#define EUSART_TRIGCTRL_AUTOTXTEN_DEFAULT             (_EUSART_TRIGCTRL_AUTOTXTEN_DEFAULT << 2)

  switch (SL_BT_MSG_ID(evt->header)) {
    // ----------
    // This event indicates the device has started and the radio is ready.
    // Do not call any stack command before receiving this boot event!
    case sl_bt_evt_system_boot_id:

      sc =  sl_bt_sm_configure(
                               SL_BT_SM_CONFIGURATION_MITM_REQUIRED |
                               SL_BT_SM_CONFIGURATION_SC_ONLY |
                               SL_BT_SM_CONFIGURATION_BONDING_REQUIRED,
                               sl_bt_sm_io_capability_displayonly);
      assert_status(sc);

      sl_bt_sm_set_bondable_mode(1);      // enable new bondings
       sl_bt_sm_set_passkey(111111);          // set passkey

      setup_advertising_or_scanning(evt);
      // Start advertising and enable connections.
      sc = sl_bt_legacy_advertiser_start(advertising_set_handle,
                                         sl_bt_advertiser_connectable_scannable);
      assert_status(sc);

      break;

    case sl_bt_evt_connection_opened_id:
      _conn_handle = evt->data.evt_connection_opened.connection;
          sc = sl_bt_advertiser_stop(advertising_set_handle);
          assert_status(sc);

          /* Request connection parameter update.
           * conn.interval min 20ms, max 40ms, slave latency 4 intervals,
           * supervision timeout 2 seconds
           * (These should be compliant with Apple Bluetooth Accessory Design
           * Guidelines, both R7 and R8) */
         sc = sl_bt_connection_set_parameters(_conn_handle,
                                               24,
                                               40,
                                               0,
                                               200,
                                               0,
                                               0xFFFF);
          assert_status(sc);
          UART0_OutString("BT Connected\r\n");
      break;

    case sl_bt_evt_sm_passkey_display_id:
      {
        uint32_t passkey = evt->data.evt_sm_passkey_display.passkey;
        UART0_OutString("Show passkey: ");
        UART0_OutUDec(passkey);
        UART0_OutString("\r\n");
      }
      break;

   // ----------
    // This event indicates that a connection was closed.
    case sl_bt_evt_connection_closed_id:
              // Restart advertising after client has disconnected.
              sc = sl_bt_legacy_advertiser_start(advertising_set_handle,
                                                 sl_bt_advertiser_connectable_scannable);
              if (sc) {
                  UART0_OutString("error start advertiser. sc=");
                  UART0_OutDec(sc);
              }
              UART0_OutString("BT DisConnected\r\n");
          break;
....

static void setup_advertising_or_scanning(sl_bt_msg_t *evt) {
  (void) *evt;

  sl_status_t sc;
  bd_addr address;
  uint8_t address_type;
  uint8_t system_id[8];

  uint8_t robot_name[] =
#if VARIANT == RED
      "Zumo Red";
#elif VARIANT == YELLOW
      "Zumo Yellow";
#else
      "Zumo Green";
#endif

    // Extract unique ID from BT Address.
    sc = sl_bt_system_get_identity_address(&address, &address_type);
    assert_status(sc);

    system_id[0] = address.addr[5];
    system_id[1] = address.addr[4];
    system_id[2] = address.addr[3];
    system_id[3] = 0xFF;
    system_id[4] = 0xFE;
    system_id[5] = address.addr[2];
    system_id[6] = address.addr[1];
    system_id[7] = address.addr[0];

    sc = sl_bt_gatt_server_write_attribute_value(gattdb_system_id,
                                                 0,
                                                 sizeof(system_id),
                                                 system_id);
    assert_status(sc);

    sc = sl_bt_gatt_server_write_attribute_value(gattdb_device_name, 0, sizeof(robot_name)-1, robot_name);
    if (sc) {
        UART0_OutString("error set Device Name. sc=");
        UART0_OutDec(sc);
    }

    // Create an advertising set.
    sc = sl_bt_advertiser_create_set(&advertising_set_handle);
    assert_status(sc);

    // Generate data for advertising
    sc = sl_bt_legacy_advertiser_generate_data(advertising_set_handle,
                                               sl_bt_advertiser_general_discoverable);
    assert_status(sc);

    // Set advertising interval to 100ms.
    sc = sl_bt_advertiser_set_timing(
      advertising_set_handle,
      160,   // min. adv. interval (milliseconds * 1.6)
      160,   // max. adv. interval (milliseconds * 1.6)
      0,     // adv. duration
      0);    // max. num. adv. events
    assert_status(sc);
}

#include "sl_bt_api.h"
#include "sl_main_init.h"
#include "app_assert.h"
#include "app.h"

#include "sl_sleeptimer.h"
#include "gatt_db.h"
#include "em_gpio.h"
#include "printf.h"
#include "stdio.h"

#define   LED_PORT         gpioPortB
#define   LED_PIN         0

static uint32_t makeRandomPasskey(void);
static uint32_t readPasskey(void);
static void listBondings(void);

static uint8_t adv_set_handle = 0xff;
static uint32_t passkey;
static uint8_t conn_handle;
static char c;

static uint32_t num_bondings;
static size_t bondings_len;
static uint32_t bondings;
static bd_addr address;
static uint8_t address_type, sec_mode, key_size;

// Application Init.
void app_init(void)
{
   GPIO_PinModeSet(LED_PORT, LED_PIN, gpioModePushPull, 0);
}

// Application Process Action.
void app_process_action(void)
{
  if (app_is_process_required()) {}
}

void sl_bt_on_event(sl_bt_msg_t *evt)
{
   switch (SL_BT_MSG_ID(evt->header)) {
      case sl_bt_evt_system_boot_id:                                       // Bluetooth stack is ready
         sl_bt_advertiser_create_set(&adv_set_handle);
         sl_bt_legacy_advertiser_generate_data(adv_set_handle, sl_bt_advertiser_general_discoverable);
         printf("Enable new bonds (y/n)? ");
         do {c = getchar();} while (c == 255);                              // wait for key pressed
         printf("%c\n", c);                                                // echo key to the screen
         if (c == 'y' || c == 'Y') {                                       // new bondings are enabled
            printf("All connections are enabled\n");
            sl_bt_sm_configure(0x07, sl_bt_sm_io_capability_displayonly);         // passkey displayed by this app (responder)
//            sl_bt_sm_configure(0x07, sl_bt_sm_io_capability_keyboardonly);         // passkey displayed by phone (initiator)
//          sl_bt_sm_configure(0x07, sl_bt_sm_io_capability_keyboarddisplay);    // numeric comparison mode
            sl_bt_sm_set_bondable_mode(1);                                 // enable new bondings
            passkey = makeRandomPasskey();                                 // set passkey to be displayed
            sl_bt_sm_set_passkey(passkey);                                 //    with displayonly I/O capability

            printf("Erase existing bonds (y/n)? ");
            do {c = getchar();} while (c == 255);                           // wait for key pressed
            printf("%c\n", c);                                             // echo key to the screen
            if (c == 'y' || c == 'Y') {
               sl_bt_sm_delete_bondings();                                 // erase all existing bondings
               printf("All bonds are erased\n");
            }
         }
         printf("Existing bonds:\n");
         listBondings();                                                   // list all existing bondings
           printf("starting advertisements\n");                              // just start advertisements
           sl_bt_legacy_advertiser_start(adv_set_handle, sl_bt_legacy_advertiser_connectable);
      break;

      case sl_bt_evt_connection_opened_id:
         conn_handle = evt->data.evt_connection_opened.connection;
         GPIO_PinOutSet(LED_PORT, LED_PIN);

      break;

      case sl_bt_evt_connection_closed_id:
         GPIO_PinOutClear(LED_PORT, LED_PIN);
         sl_bt_legacy_advertiser_start(adv_set_handle, sl_bt_legacy_advertiser_connectable);
         printf("connection closed, reason: 0x%2.2x\n\n", evt->data.evt_connection_closed.reason);
      break;

      /***************** Security related events ******************/
      case sl_bt_evt_sm_passkey_display_id:                                 // passkey for establishing new bonding
         printf("Type in this passkey on phone: %d\n", (int)evt->data.evt_sm_passkey_display.passkey);
      break;

      case sl_bt_evt_sm_passkey_request_id:                                 // enter passkey displayed on phone
         printf("Enter the passkey displayed on phone: ");
         passkey = readPasskey();                                          // get user input (passkey)
         printf("\nEntered passkey: %d\n", (int)passkey);
         sl_bt_sm_enter_passkey(conn_handle, passkey);                     // set entered passkey
      break;

      case sl_bt_evt_sm_confirm_bonding_id:                                 // new bonding request is received
         sl_bt_sm_bonding_confirm(conn_handle, 1);                           // accept bonding request
         printf("bonding request accepted\n");
      break;

      case sl_bt_evt_sm_bonded_id:                                          // new bonding outcome (success)
         printf("bond success\n");
      break;

      case sl_bt_evt_sm_bonding_failed_id:                                 // new bonding outcome (failure)
         printf("bonding failed, reason 0x%2X\n", evt->data.evt_sm_bonding_failed.reason);
         sl_bt_connection_close(evt->data.evt_sm_bonding_failed.connection);
      break;

      case sl_bt_evt_sm_confirm_passkey_id:                                 // used in numeric comparison mode
         printf("Do you see this passkey on the other device: %06u? (y/n)  ",
                (int)evt->data.evt_sm_confirm_passkey.passkey);
         do {c = getchar();} while (c == 255);                              // wait for key pressed
         printf("%c\n", c);                                                // echo the user input
         if (c == 'y' || c == 'Y') {
            sl_bt_sm_passkey_confirm(conn_handle, 1);                        // confirm passkey match
            printf("Waiting for other device to confirm...\n");
         }
         else {
            sl_bt_sm_passkey_confirm(conn_handle, 0);                        // do not confirm passkey match
         }
      break;

      default:
      break;
   }
}

uint32_t makeRandomPasskey(void)
{
   uint32_t n;                                                             // get 6-digit TRN
   sl_bt_system_get_random_data(4, 4, NULL, (uint8_t*)&n);
   n = (n % 900000) + 100000;
   return(n);
}

uint32_t readPasskey(void)                                                   // read 6-digit passkey
{
   uint32_t n = 0;
   for (uint8_t i=0; i<6; i++) {
      do {c = getchar();} while (c == 255);                                 // wait for key pressed
      putchar(c);                                                            // echo char to terminal
      n = n*10 + (c - '0');
   }
   return(n);
}

static void listBondings(void)
{
   uint8_t i;
   uint32_t mask = 1;
   sl_bt_sm_get_bonding_handles(0, &num_bondings, 4, &bondings_len, (uint8_t*)&bondings);
   printf("Bondings: num_bondings=%d bondings_len=%d bondings_map=%04x \n", (int)num_bondings, (int)bondings_len, (int)bondings);
   for (i=0; i<32; i++) {
      if (bondings & mask) {
         sl_bt_sm_get_bonding_details(i, &address, &address_type, &sec_mode, &key_size);
         printf("%d: %02x:%02x:%02x:%02x:%02x:%02x type=%d security_mode=%d key_size=%d\n", i,
                address.addr[5], address.addr[4], address.addr[3], address.addr[2], address.addr[1], address.addr[0],
                (int)address_type, (int)sec_mode, (int)key_size);
      }
      mask = mask << 1;
   }
}

   case sl_bt_evt_connection_opened_id:
      _conn_handle = evt->data.evt_connection_opened.connection;
          sc = sl_bt_advertiser_stop(advertising_set_handle);
          assert_status(sc);

          /* Request connection parameter update.
           * conn.interval min 20ms, max 40ms, slave latency 4 intervals,
           * supervision timeout 2 seconds
           * (These should be compliant with Apple Bluetooth Accessory Design
           * Guidelines, both R7 and R8) */
          sc = sl_bt_connection_set_parameters(_conn_handle,
                                               24,
                                               40,
                                               0,
                                               200,
                                               0,
                                               0xFFFF);
          assert_status(sc);

          UART0_OutString("BT Connected\r\n");