From a327efd414deb43205cd00d78edc8d6ce0d1a897 Mon Sep 17 00:00:00 2001 From: shchen Date: Wed, 23 Dec 2020 16:31:47 +0800 Subject: [PATCH] ble demo --- customer_app/sdk_app_bledemo/Makefile | 40 ++ customer_app/sdk_app_bledemo/README.md | 52 ++ customer_app/sdk_app_bledemo/genromap | 3 + customer_app/sdk_app_bledemo/logo.png | Bin 0 -> 17129 bytes customer_app/sdk_app_bledemo/proj_config.mk | 56 ++ .../sdk_app_bledemo/sdk_app_bledemo/ble_app.h | 73 +++ .../sdk_app_bledemo/ble_appc.c | 332 ++++++++++++ .../sdk_app_bledemo/ble_apps.c | 354 ++++++++++++ .../sdk_app_bledemo/bouffalo.mk | 26 + .../sdk_app_bledemo/sdk_app_bledemo/main.c | 509 ++++++++++++++++++ 10 files changed, 1445 insertions(+) create mode 100644 customer_app/sdk_app_bledemo/Makefile create mode 100644 customer_app/sdk_app_bledemo/README.md create mode 100644 customer_app/sdk_app_bledemo/genromap create mode 100644 customer_app/sdk_app_bledemo/logo.png create mode 100644 customer_app/sdk_app_bledemo/proj_config.mk create mode 100644 customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_app.h create mode 100644 customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_appc.c create mode 100644 customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_apps.c create mode 100644 customer_app/sdk_app_bledemo/sdk_app_bledemo/bouffalo.mk create mode 100644 customer_app/sdk_app_bledemo/sdk_app_bledemo/main.c diff --git a/customer_app/sdk_app_bledemo/Makefile b/customer_app/sdk_app_bledemo/Makefile new file mode 100644 index 00000000..6c8dfdbf --- /dev/null +++ b/customer_app/sdk_app_bledemo/Makefile @@ -0,0 +1,40 @@ +# +# This is a project Makefile. It is assumed the directory this Makefile resides in is a +# project subdirectory. +# + +PROJECT_NAME := sdk_app_bledemo +PROJECT_PATH := $(abspath .) +PROJECT_BOARD := evb +export PROJECT_PATH PROJECT_BOARD +#CONFIG_TOOLPREFIX := + +-include ./proj_config.mk + +ifeq ($(origin BL60X_SDK_PATH), undefined) +BL60X_SDK_PATH_GUESS ?= $(shell pwd) +BL60X_SDK_PATH ?= $(BL60X_SDK_PATH_GUESS)/../.. +$(info ****** Please SET BL60X_SDK_PATH ******) +$(info ****** Trying SDK PATH [$(BL60X_SDK_PATH)]) +endif + +COMPONENTS_NETWORK := sntp dns_server +COMPONENTS_BLSYS := bltime blfdt blmtd blota bloop loopadc looprt loopset +COMPONENTS_VFS := romfs +COMPONENTS_BLE := blecontroller blestack + +INCLUDE_COMPONENTS += freertos_riscv_ram bl602 bl602_std bl602_wifi bl602_wifidrv hal_drv lwip lwip_dhcpd mbedtls vfs yloop utils cli aws-iot httpc netutils blog blog_testc blsync_ble cjson +INCLUDE_COMPONENTS += easyflash4 +INCLUDE_COMPONENTS += $(COMPONENTS_NETWORK) +INCLUDE_COMPONENTS += $(COMPONENTS_BLSYS) +INCLUDE_COMPONENTS += $(COMPONENTS_VFS) +INCLUDE_COMPONENTS += $(PROJECT_NAME) + +ifeq ($(CONFIG_BT),1) +INCLUDE_COMPONENTS += $(COMPONENTS_BLE) +ifeq ($(CONFIG_BT_MESH),1) +INCLUDE_COMPONENTS += blemesh +endif +endif + +include $(BL60X_SDK_PATH)/make_scripts_riscv/project.mk diff --git a/customer_app/sdk_app_bledemo/README.md b/customer_app/sdk_app_bledemo/README.md new file mode 100644 index 00000000..52fa32cf --- /dev/null +++ b/customer_app/sdk_app_bledemo/README.md @@ -0,0 +1,52 @@ +# BLE Demo user guide + +This demo code button pin is IO12. Please add the following setting to corresponding dts file ：this node feature is " button" and mode is " multipress". this node will trigger three event , customer can set "press time" setting. + + The central device will connect peripheral device when two devices is close to 5 cm to 10 cm ( Rssi < -20 ). + +```c +gpio2 { + status = "okay"; + pin = <12>; + feature = "button"; + active = "Hi"; + mode = "multipress"; + button { + debounce = <10>; + short_press_ms { + start = <100>; + end = <2000>; + kevent = <2>; + }; + long_press_ms { + start = <3000>; + end = <5000>; + kevent = <3>; + }; + longlong_press_ms { + start = <10000>; + kevent = <4>; + }; + trig_level = "Lo"; + }; + hbn_use = "disable"; +}; +``` + + + +## 1. Peripheral Function + +Short press button : Start Bluetooth Advertising. + +Longlong press button : Send notification when device state is connected. + +## 2. Central Function + +Long press button : Start Bluetooth Scanning. + +Longlong press button : Write data without response when device state is connected. + + + + \ No newline at end of file diff --git a/customer_app/sdk_app_bledemo/genromap b/customer_app/sdk_app_bledemo/genromap new file mode 100644 index 00000000..31d3ab20 --- /dev/null +++ b/customer_app/sdk_app_bledemo/genromap @@ -0,0 +1,3 @@ +#!/bin/sh +make CONFIG_CHIP_NAME=BL602 CONFIG_LINK_ROM=1 -j +exit $? diff --git a/customer_app/sdk_app_bledemo/logo.png b/customer_app/sdk_app_bledemo/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..859f106d513644593087d1a6fabf51d19a8f5767 GIT binary patch literal 17129 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 literal 0 HcmV?d00001 diff --git a/customer_app/sdk_app_bledemo/proj_config.mk b/customer_app/sdk_app_bledemo/proj_config.mk new file mode 100644 index 00000000..375b741e --- /dev/null +++ b/customer_app/sdk_app_bledemo/proj_config.mk @@ -0,0 +1,56 @@ +# +#compiler flag config domain +# +#CONFIG_TOOLPREFIX := +#CONFIG_OPTIMIZATION_LEVEL_RELEASE := 1 +#CONFIG_M4_SOFTFP := 1 + +# +#board config domain +# +CONFIG_BOARD_FLASH_SIZE := 2 + +#firmware config domain +# + +#set CONFIG_ENABLE_ACP to 1 to enable ACP, set to 0 or comment this line to disable +#CONFIG_ENABLE_ACP:=1 +CONFIG_BL_IOT_FW_AP:=1 +CONFIG_BL_IOT_FW_AMPDU:=0 +CONFIG_BL_IOT_FW_AMSDU:=0 +CONFIG_BL_IOT_FW_P2P:=0 +CONFIG_ENABLE_PSM_RAM:=1 +#CONFIG_ENABLE_CAMERA:=1 +CONFIG_ENABLE_BLSYNC:=1 +#CONFIG_ENABLE_VFS_SPI:=1 +CONFIG_ENABLE_VFS_ROMFS:=1 + +# set easyflash env psm size, only support 4K、8K、16K options +CONFIG_ENABLE_PSM_EF_SIZE:=16K + +CONFIG_FREERTOS_TICKLESS_MODE:=0 + +CONFIG_BT:=1 +CONFIG_BT_PERIPHERAL:=1 +CONFIG_BT_CENTRAL:=1 +CONFIG_BT_OBSERVER:=1 +CONFIG_BT_CONN:=1 +CONFIG_BLE_TP_SERVER:=1 +CONFIG_BT_SMP:=1 +CONFIG_BT_FIXED_PASSKEY:=1 +CONFIG_BT_SETTINGS:=1 +#CONFIG_BT_MESH := 1 +CONFIG_BLE_STACK_DBG_PRINT := 1 +CONFIG_BT_STACK_PTS := 0 +ifeq ($(CONFIG_BT_MESH),1) +CONFIG_BT_MESH_PB_ADV := 1 +CONFIG_BT_MESH_PB_GATT := 1 +CONFIG_BT_MESH_FRIEND := 1 +CONFIG_BT_MESH_LOW_POWER := 1 +CONFIG_BT_MESH_PROXY := 1 +CONFIG_BT_MESH_GATT_PROXY := 1 + +endif + +#blog enable components format :=blog_testc cli vfs helper +LOG_ENABLED_COMPONENTS:=blog_testc hal_drv loopset looprt bloop diff --git a/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_app.h b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_app.h new file mode 100644 index 00000000..b27748a9 --- /dev/null +++ b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_app.h @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2020 Bouffalolab. + * + * This file is part of + * *** Bouffalolab Software Dev Kit *** + * (see www.bouffalolab.com). + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Bouffalo Lab nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef __BLE_APP_H_ +#define __BLE_APP_H_ + + +#define NAME_LEN 30 +#define CHAR_SIZE_MAX 512 +#define BT_UUID_TEST BT_UUID_DECLARE_16(0xFFF0) +#define BT_UUID_TEST_RX BT_UUID_DECLARE_16(0xFFF1) +#define BT_UUID_TEST_TX BT_UUID_DECLARE_16(0xFFF2) + + +#define EV_BLE_TEST 0x0504 +#define BLE_ADV_START 0x01 +#define BLE_ADV_STOP 0x02 +#define BLE_DEV_CONN 0x03 +#define BLE_DEV_DISCONN 0x04 +#define BLE_SCAN_START 0x05 +#define BLE_SCAN_STOP 0x06 + +#define LED_RED_PIN (17) +#define LED_GREEN_PIN (14) +#define LED_BLUE_PIN (11) + +enum app_ble_role +{ + PERIPHERAL=1, + CENTRAL +}; + +void apps_ble_start (void); +void bleapps_adv_starting(void); +void bleapps_adv_stop(void); +void ble_bl_notify_task(void); +void ble_bl_disconnect(void); + + + +void ble_appc_start(void); +void start_scan(void); +void ble_appc_stopscan(void); +void bl_gatt_write_without_rsp(void); +void ble_appc_disconnected(void); + +#endif diff --git a/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_appc.c b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_appc.c new file mode 100644 index 00000000..7dc8bbf3 --- /dev/null +++ b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_appc.c @@ -0,0 +1,332 @@ +/* + * Copyright (c) 2020 Bouffblfolab. + * + * This file is part of + * *** Bouffblfolab Software Dev Kit *** + * (see www.bouffblfolab.com). + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materiblfs provided with the distribution. + * 3. Neither the name of Bouffblfo Lab nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHblfL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTblf, SPECIblf, EXEMPLARY, OR CONSEQUENTIblf + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "ble_app.h" +#include +#include +#include "bluetooth.h" +#include "ble_cli_cmds.h" +#include "hci_driver.h" +#include "ble_lib_api.h" +#include +#include +#include + +#include "conn.h" +#include "gatt.h" +#include "hci_core.h" +#include "uuid.h" +#include "oad_api.h" +#include "hal_pwm.h" +#include "hal_gpio.h" +#include "bl_gpio.h" +#include + + + +static struct bt_conn *default_conn; +static struct bt_uuid_16 uuid = BT_UUID_INIT_16(0); +static struct bt_gatt_discover_params discover_params; +static struct bt_gatt_subscribe_params subscribe_params; +static u16_t bt_gatt_write_without_hanle=0; + +static uint8_t notify_func(struct bt_conn *conn, + struct bt_gatt_subscribe_params *params, + const void *data, uint16_t length) +{ + + if(length!=0){ + + uint8_t *recv_buffer; + recv_buffer=pvPortMalloc(sizeof(uint8_t)*length); + memcpy(recv_buffer, data, length); + printf("ble notification="); + for (size_t i = 0; i < length; i++) + { + printf("0x%x ",recv_buffer[i]); + } + vPortFree(recv_buffer); + printf("\n"); + + } + + return BT_GATT_ITER_CONTINUE; +} +void bl_gatt_write_without_rsp(void) +{ + char data[10] = {0x00,0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09}; + if(default_conn!=NULL){ + + bt_gatt_write_without_response(default_conn, bt_gatt_write_without_hanle, data, 10, 0); + + } + +} + + +void ble_appc_disconnected(void) +{ + if(default_conn!=NULL) + { + + printf("user disconnect\n"); + bt_conn_disconnect(default_conn,BT_HCI_ERR_REMOTE_USER_TERM_CONN); + aos_post_event(EV_BLE_TEST,BLE_DEV_DISCONN,NULL); + } +} +void ble_appc_stopscan(void) +{ + + printf("user stop scan\n"); + bt_le_scan_stop(); + aos_post_event(EV_BLE_TEST,BLE_SCAN_STOP,NULL); + +} +static uint8_t discover_func(struct bt_conn *conn, + const struct bt_gatt_attr *attr, + struct bt_gatt_discover_params *params) +{ + int err; + + if (!attr) { + printf("Discover complete\n"); + (void)memset(params, 0, sizeof(*params)); + return BT_GATT_ITER_STOP; + } + + printf("[ATTRIBUTE] handle %d\n", attr->handle); + + if (!bt_uuid_cmp(discover_params.uuid, BT_UUID_TEST)) { + + memcpy(&uuid, BT_UUID_TEST_RX, sizeof(uuid)); + discover_params.uuid = &uuid.uuid; + discover_params.start_handle = attr->handle + 1; + discover_params.type = BT_GATT_DISCOVER_CHARACTERISTIC; + + err = bt_gatt_discover(conn, &discover_params); + if (err) { + printf("Discover failed (err %d)\n", err); + } + } else if (!bt_uuid_cmp(discover_params.uuid, + BT_UUID_TEST_RX)) { + memcpy(&uuid, BT_UUID_GATT_CCC, sizeof(uuid)); + discover_params.uuid = &uuid.uuid; + discover_params.start_handle = attr->handle + 2; + discover_params.type = BT_GATT_DISCOVER_DESCRIPTOR; + subscribe_params.value_handle = bt_gatt_attr_value_handle(attr); + + err = bt_gatt_discover(conn, &discover_params); + if (err) { + printf("Discover failed (err %d)\n", err); + } + } else if(!bt_uuid_cmp(discover_params.uuid, + BT_UUID_GATT_CCC)) { + subscribe_params.notify = notify_func; + subscribe_params.value = BT_GATT_CCC_NOTIFY; + subscribe_params.ccc_handle = attr->handle; + err = bt_gatt_subscribe(conn, &subscribe_params); + if (err && err != -EALREADY) { + printf("Subscribe failed (err %d)\n", err); + } else { + printf("[SUBSCRIBED]\n"); + bt_gatt_write_without_hanle=subscribe_params.ccc_handle+2; + } + + + return BT_GATT_ITER_STOP; + } + + return BT_GATT_ITER_STOP; +} + +static bool data_cb(struct bt_data *data, void *user_data) +{ + char *name = user_data; + u8_t len; + + switch (data->type) { + case BT_DATA_NAME_SHORTENED: + case BT_DATA_NAME_COMPLETE: + len = (data->data_len > NAME_LEN - 1)?(NAME_LEN - 1):(data->data_len); + memcpy(name, data->data, len); + return false; + default: + return true; + } +} + + +static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type, + struct net_buf_simple *ad) +{ + char dev[BT_ADDR_LE_STR_LEN]; + char name[NAME_LEN]; + + struct bt_le_conn_param param = { + .interval_min = BT_GAP_INIT_CONN_INT_MIN, + .interval_max = BT_GAP_INIT_CONN_INT_MAX, + .latency = 0, + .timeout = 400, + }; + //struct bt_le_conn_param param; + bt_addr_le_to_str(addr, dev, sizeof(dev)); + + if (rssi < -20) + { + return; + } + /* We're only interested in connectable events */ + if (type == BT_LE_ADV_IND) { + + bt_le_scan_stop(); + printf("device_found ok\r\n"); + (void)memset(name, 0, sizeof(name)); + bt_data_parse(ad, data_cb, name); + printf("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i NAME=%s\n", + dev, type, ad->len, rssi,name); + + default_conn = bt_conn_create_le(addr, ¶m); + + if(!default_conn){ + printf("Connection failed\r\n"); + }else{ + printf("Connection pending\r\n"); + } + + } + +} + +void start_scan(void) +{ + int err; + struct bt_le_scan_param scan_param; + + scan_param.type=BT_LE_SCAN_TYPE_PASSIVE; + scan_param.filter_dup=0; + scan_param.interval=0x80; + scan_param.window=0x40; + err = bt_le_scan_start(&scan_param, device_found); + if (err) { + printf("Scanning failed to start (err %d)\n", err); + return; + } + aos_post_event(EV_BLE_TEST,BLE_SCAN_START,NULL); + printf("Scanning successfully started\n"); +} + +static void connected(struct bt_conn *conn, uint8_t conn_err) +{ + char addr[BT_ADDR_LE_STR_LEN]; + int err; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + if (conn_err) { + printf("Failed to connect to %s (%u)\n", addr, conn_err); + + bt_conn_unref(default_conn); + default_conn = NULL; + + + return; + } + + printf("Connected: %s\n", addr); + aos_post_event(EV_BLE_TEST,BLE_DEV_CONN,NULL); + if (conn == default_conn) { + memcpy(&uuid, BT_UUID_TEST, sizeof(uuid)); + discover_params.uuid = &uuid.uuid; + discover_params.func = discover_func; + discover_params.start_handle = 0x0001; + discover_params.end_handle = 0xffff; + discover_params.type = BT_GATT_DISCOVER_PRIMARY; + + err = bt_gatt_discover(default_conn, &discover_params); + if (err) { + printf("Discover failed(err %d)\n", err); + return; + } + } +} + +static void disconnected(struct bt_conn *conn, uint8_t reason) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("Disconnected: %s (reason 0x%02x)\n", addr, reason); + + if (default_conn != conn) { + return; + } + + bt_conn_unref(default_conn); + default_conn = NULL; + aos_post_event(EV_BLE_TEST,BLE_DEV_DISCONN,NULL); +} + +static struct bt_conn_cb conn_callbacks = { + .connected = connected, + .disconnected = disconnected, +}; + +static void bt_ready(void) +{ + start_scan(); +} + +static void ble_app_init(int err) +{ + if (err != 0) { + printf("BT FAILED started\n"); + }else{ + printf("BT SUCCESS started\n"); + bt_ready(); + } + +} + +void ble_appc_start(void) +{ + int err; + ble_controller_init(configMAX_PRIORITIES - 1); + // Initiblfize BLE Host stack + hci_driver_init(); + err = bt_enable(ble_app_init); + + if (err) { + printf("Bluetooth init failed (err %d)\n", err); + return; + } + bt_conn_cb_register(&conn_callbacks); + +} + diff --git a/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_apps.c b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_apps.c new file mode 100644 index 00000000..f261a448 --- /dev/null +++ b/customer_app/sdk_app_bledemo/sdk_app_bledemo/ble_apps.c @@ -0,0 +1,354 @@ +/* + * Copyright (c) 2020 Bouffblfolab. + * + * This file is part of + * *** Bouffblfolab Software Dev Kit *** + * (see www.bouffblfolab.com). + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materiblfs provided with the distribution. + * 3. Neither the name of Bouffblfo Lab nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHblfL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTblf, SPECIblf, EXEMPLARY, OR CONSEQUENTIblf + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "ble_app.h" +#include +#include +#include "bluetooth.h" +#include "ble_cli_cmds.h" +#include "hci_driver.h" +#include "ble_lib_api.h" + +#include +#include + +#include "conn.h" +#include "gatt.h" +#include "hci_core.h" +#include "uuid.h" +#include "oad_api.h" +#include "hal_pwm.h" +#include "hal_gpio.h" +#include "bl_gpio.h" +#include +#include +#include + +static void ble_bl_ccc_cfg_changed(const struct bt_gatt_attr *attr, u16_t vblfue); +static int ble_blf_recv(struct bt_conn *conn, + const struct bt_gatt_attr *attr, const void *buf, + u16_t len, u16_t offset, u8_t flags); + + +static const struct bt_data ad[] = { + BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), + BT_DATA(BT_DATA_NAME_COMPLETE, "BL_602", 6), + BT_DATA(BT_DATA_MANUFACTURER_DATA, "BL_602", 6), + +}; +static struct bt_gatt_attr blattrs[]= { + BT_GATT_PRIMARY_SERVICE(BT_UUID_TEST), + + BT_GATT_CHARACTERISTIC(BT_UUID_TEST_RX, + BT_GATT_CHRC_NOTIFY, + BT_GATT_PERM_READ, + NULL, + NULL, + NULL), + + BT_GATT_CCC(ble_bl_ccc_cfg_changed, BT_GATT_PERM_READ | BT_GATT_PERM_WRITE), + + BT_GATT_CHARACTERISTIC(BT_UUID_TEST_TX, + BT_GATT_CHRC_WRITE_WITHOUT_RESP, + BT_GATT_PERM_READ | BT_GATT_PERM_WRITE, + NULL, + ble_blf_recv, + NULL) +}; +static struct bt_conn *ble_bl_conn=NULL; +static bool notify_flag=false; +static void ble_bl_ccc_cfg_changed(const struct bt_gatt_attr *attr, u16_t vblfue) +{ + if(vblfue == BT_GATT_CCC_NOTIFY) { + + printf("enable notify.\n"); + notify_flag=true; + + } else { + printf("disable notify.\n"); + notify_flag=false; + } + +} + + + +void ble_bl_notify_task(void) +{ + + char data[10] = {0x00,0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09}; + if(ble_bl_conn!=NULL&¬ify_flag==true){ + printf("ble_bl_notify_task.\n"); + bt_gatt_notify(ble_bl_conn, &blattrs[1],data,10); + + } + +} +void ble_bl_disconnect(void) +{ + + + if(ble_bl_conn!=NULL) + { + + printf("user disconnect\n"); + bt_conn_disconnect(ble_bl_conn,BT_HCI_ERR_REMOTE_USER_TERM_CONN); + aos_post_event(EV_BLE_TEST,BLE_DEV_DISCONN,NULL); + } +} + +static int ble_blf_recv(struct bt_conn *conn, + const struct bt_gatt_attr *attr, const void *buf, + u16_t len, u16_t offset, u8_t flags) +{ + uint8_t *recv_buffer; + recv_buffer=pvPortMalloc(sizeof(uint8_t)*len); + memcpy(recv_buffer, buf, len); + printf("ble rx=%d\n",len); + for (size_t i = 0; i < len; i++) + { + printf("0x%x ",recv_buffer[i]); + } + vPortFree(recv_buffer); + printf("\n"); + return 0; +} + + + +struct bt_gatt_service ble_bl_server = BT_GATT_SERVICE(blattrs); + +static void bt_ready(void) +{ + + bt_set_name("blf_602"); + printf("Bluetooth initiblfized\n"); + bleapps_adv_starting(); + + +} + +void bleapps_adv_starting(void) +{ + int err; + + printf("Bluetooth Advertising start\n"); + err = bt_le_adv_start(BT_LE_ADV_CONN_NAME, ad, ARRAY_SIZE(ad), NULL, 0); + if (err) { + printf("Advertising failed to start (err %d)\n", err); + + }else{ + + aos_post_event(EV_BLE_TEST,BLE_ADV_START,NULL); + } + +} +void bleapps_adv_stop(void) +{ + int err; + printf("Bluetooth Advertising stop\n"); + err =bt_le_adv_stop(); + if (err) { + printf("Advertising failed to stop (err %d)\n", err); + + }else{ + + aos_post_event(EV_BLE_TEST,BLE_ADV_STOP,NULL); + + } +} + + + +static void ble_app_init(int err) +{ + if (err != 0) { + printf("BT FAILED started\n"); + }else{ + printf("BT SUCCESS started\n"); + bt_ready(); + + } + +} + +static void bl_connected(struct bt_conn *conn, uint8_t err) +{ + struct bt_le_conn_param param; + param.interval_max=24; + param.interval_min=24; + param.latency=0; + param.timeout=600; + int update_err; + if (err) { + printf("Connection failed (err 0x%02x)\n", err); + } else { + printf("Connected\n"); + ble_bl_conn=conn; + update_err = bt_conn_le_param_update(conn, ¶m); + + if (err) { + printf("conn update failed (err %d)\r\n", err); + } else { + printf("conn update initiated\r\n"); + } + #if 0 + #if defined(CONFIG_BT_SMP) + bt_conn_set_security(conn, BT_SECURITY_L4); + #endif + #endif + aos_post_event(EV_BLE_TEST,BLE_DEV_CONN,NULL); + } +} + +static void bl_disconnected(struct bt_conn *conn, uint8_t reason) +{ + printf("Disconnected (reason 0x%02x)\n", reason); + aos_post_event(EV_BLE_TEST,BLE_DEV_DISCONN,NULL); +} + +static struct bt_conn_cb conn_callbacks = { + .connected = bl_connected, + .disconnected = bl_disconnected, +}; + + + + +static void ble_stack_start(void) +{ + // Initiblfize BLE controller + ble_controller_init(configMAX_PRIORITIES - 1); + // Initiblfize BLE Host stack + hci_driver_init(); + bt_enable(ble_app_init); + +} +#if defined(CONFIG_BT_SMP) + +static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("passkey_str is: %06u\r\n", passkey); +} + +static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("Confirm passkey for %s: %06u\r\n", addr, passkey); + bt_conn_auth_passkey_confirm(conn); +} + +static void auth_passkey_entry(struct bt_conn *conn) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("Enter passkey for %s\r\n", addr); +} + +static void auth_cancel(struct bt_conn *conn) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("Pairing cancelled: %s\r\n", addr); +} + +static void auth_pairing_confirm(struct bt_conn *conn) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("Confirm pairing for %s\r\n", addr); + +} + +static void auth_pairing_complete(struct bt_conn *conn, bool bonded) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + + printf("%s with %s\r\n", bonded ? "Bonded" : "Paired", addr); +} + +static void auth_pairing_failed(struct bt_conn *conn, enum bt_security_err reason) +{ + char addr[BT_ADDR_LE_STR_LEN]; + + bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + printf("Pairing failed with %s\r\n", addr); +} + +static struct bt_conn_auth_cb auth_cb_display = { + .passkey_display = auth_passkey_display, + .passkey_entry = auth_passkey_entry, + .passkey_confirm = auth_passkey_confirm, + .cancel = auth_cancel, + .pairing_confirm = auth_pairing_confirm, + .pairing_failed = auth_pairing_failed, + .pairing_complete = auth_pairing_complete, +}; +#endif + +void apps_ble_start(void) +{ + int err; + ble_stack_start(); + bt_conn_cb_register(&conn_callbacks); + err=bt_gatt_service_register(&ble_bl_server); + if (err==0) { + printf("bt_gatt_service_register ok\n"); + } else { + printf("bt_gatt_service_register err\n"); + + } + + + #if defined(CONFIG_BT_SMP) + err = bt_conn_auth_cb_register(&auth_cb_display); + + if(err){ + printf("Auth callback has blfready been registered\r\n"); + }else{ + printf("Register auth callback successfully\r\n"); + } + #endif +} + diff --git a/customer_app/sdk_app_bledemo/sdk_app_bledemo/bouffalo.mk b/customer_app/sdk_app_bledemo/sdk_app_bledemo/bouffalo.mk new file mode 100644 index 00000000..e12ff417 --- /dev/null +++ b/customer_app/sdk_app_bledemo/sdk_app_bledemo/bouffalo.mk @@ -0,0 +1,26 @@ +# +# "main" pseudo-component makefile. +# +# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.) + +include $(BL60X_SDK_PATH)/components/network/ble/ble_common.mk + +ifeq ($(CONFIG_ENABLE_PSM_RAM),1) +CPPFLAGS += -DCONF_USER_ENABLE_PSRAM +endif + +ifeq ($(CONFIG_ENABLE_CAMERA),1) +CPPFLAGS += -DCONF_USER_ENABLE_CAMERA +endif + +ifeq ($(CONFIG_ENABLE_BLSYNC),1) +CPPFLAGS += -DCONF_USER_ENABLE_BLSYNC +endif + +ifeq ($(CONFIG_ENABLE_VFS_SPI),1) +CPPFLAGS += -DCONF_USER_ENABLE_VFS_SPI +endif + +ifeq ($(CONFIG_ENABLE_VFS_ROMFS),1) +CPPFLAGS += -DCONF_USER_ENABLE_VFS_ROMFS +endif diff --git a/customer_app/sdk_app_bledemo/sdk_app_bledemo/main.c b/customer_app/sdk_app_bledemo/sdk_app_bledemo/main.c new file mode 100644 index 00000000..7b60c62d --- /dev/null +++ b/customer_app/sdk_app_bledemo/sdk_app_bledemo/main.c @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2020 Bouffalolab. + * + * This file is part of + * *** Bouffalolab Software Dev Kit *** + * (see www.bouffalolab.com). + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of Bouffalo Lab nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include "bl602_adc.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "hal_pwm.h" +#include +#include +#include +#include +#include +#include +#include "ble_lib_api.h" +#include "ble_app.h" +#include "hal_pds.h" +#include "bl_rtc.h" +#include "utils_string.h" + +extern uint8_t _heap_start; +extern uint8_t _heap_size; // @suppress("Type cannot be resolved") +extern uint8_t _heap_wifi_start; +extern uint8_t _heap_wifi_size; // @suppress("Type cannot be resolved") +static HeapRegion_t xHeapRegions[] = +{ + { &_heap_start, (unsigned int) &_heap_size}, //set on runtime + { &_heap_wifi_start, (unsigned int) &_heap_wifi_size }, + { NULL, 0 }, /* Terminates the array. */ + { NULL, 0 } /* Terminates the array. */ +}; + + +void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName ) +{ + puts("Stack Overflow checked\r\n"); + while (1) { + /*empty here*/ + } +} + +void vApplicationMallocFailedHook(void) +{ + printf("Memory Allocate Failed. Current left size is %d bytes\r\n", + xPortGetFreeHeapSize() + ); + while (1) { + /*empty here*/ + } +} + +void vApplicationIdleHook(void) +{ + + __asm volatile( + " wfi " + ); + + +} + +static void proc_hellow_entry(void *pvParameters) +{ + + vTaskDelay(500); + + while (1) { + printf("%s: RISC-V rv32imafc\r\n", __func__); + vTaskDelay(10000); + } + vTaskDelete(NULL); +} + + + + +static int get_dts_addr(const char *name, uint32_t *start, uint32_t *off) +{ + uint32_t addr = hal_board_get_factory_addr(); + const void *fdt = (const void *)addr; + uint32_t offset; + + if (!name || !start || !off) { + return -1; + } + + offset = fdt_subnode_offset(fdt, 0, name); + if (offset <= 0) { + log_error("%s NULL.\r\n", name); + return -1; + } + + *start = (uint32_t)fdt; + *off = offset; + + return 0; +} +static enum app_ble_role app_role; +static void event_cb_key_event(input_event_t *event, void *private_data) +{ + switch (event->code) { + case KEY_1: + { + printf("[KEY_1] [EVT] INIT DONE %lld\r\n", aos_now_ms()); + printf("short press \r\n"); + apps_ble_start(); + app_role=PERIPHERAL; + } + break; + case KEY_2: + { + printf("[KEY_2] [EVT] INIT DONE %lld\r\n", aos_now_ms()); + printf("long press \r\n"); + ble_appc_start(); + app_role=CENTRAL; + } + break; + case KEY_3: + { + printf("[KEY_3] [EVT] INIT DONE %lld\r\n", aos_now_ms()); + printf("longlong press \r\n"); + if(app_role==PERIPHERAL){ + + ble_bl_notify_task(); + }else{ + + bl_gatt_write_without_rsp(); + } + + } + break; + default: + { + printf("[KEY] [EVT] Unknown code %u, %lld\r\n", event->code, aos_now_ms()); + /*nothing*/ + } + } +} + +static void borad_rgb_init(void) +{ + + bl_gpio_enable_output(LED_RED_PIN,1,0); + bl_gpio_enable_output(LED_GREEN_PIN,1,0); + bl_gpio_enable_output(LED_BLUE_PIN,1,0); + bl_gpio_output_set(LED_RED_PIN,1); + bl_gpio_output_set(LED_GREEN_PIN,1); + bl_gpio_output_set(LED_BLUE_PIN,1); + +} +static void borad_rgb_off(void) +{ + + bl_gpio_output_set(LED_RED_PIN,1); + bl_gpio_output_set(LED_GREEN_PIN,1); + bl_gpio_output_set(LED_BLUE_PIN,1); + +} +static void event_cb_ble_event(input_event_t *event, void *private_data) +{ + switch (event->code) { + case BLE_ADV_START: + { + borad_rgb_off(); + printf("ble adv start \r\n"); + bl_gpio_output_set(LED_BLUE_PIN,0); + + + } + break; + case BLE_ADV_STOP: + { + printf("ble adv stop \r\n"); + borad_rgb_off(); + + } + break; + case BLE_DEV_CONN: + { + borad_rgb_off(); + bl_gpio_output_set(LED_GREEN_PIN,0); + + printf("ble dev connnected \r\n"); + + + } + break; + case BLE_DEV_DISCONN: + { + borad_rgb_off(); + bl_gpio_output_set(LED_RED_PIN,0); + + printf("ble dev disconnnected\r\n"); + vTaskDelay(5000); + if(app_role==PERIPHERAL){ + + bleapps_adv_starting(); + }else{ + + start_scan(); + } + } + break; + case BLE_SCAN_START: + { + borad_rgb_off(); + bl_gpio_output_set(LED_BLUE_PIN,0); + printf("ble dev scanning\r\n"); + } + break; + case BLE_SCAN_STOP: + { + borad_rgb_off(); + printf("ble dev stop scan\r\n"); + } + break; + default: + { + printf("[KEY] [EVT] Unknown code %u, %lld\r\n", event->code, aos_now_ms()); + /*nothing*/ + } + } +} + + + +static void aos_loop_proc(void *pvParameters) +{ + int fd_console; + uint32_t fdt = 0, offset = 0; + static StackType_t proc_stack_looprt[512]; + static StaticTask_t proc_task_looprt; + + /*Init bloop stuff*/ + looprt_start(proc_stack_looprt, 512, &proc_task_looprt); + loopset_led_hook_on_looprt(); + +// easyflash_init(); + vfs_init(); + vfs_device_init(); + + /* uart */ +#if 1 + if (0 == get_dts_addr("uart", &fdt, &offset)) { + vfs_uart_init(fdt, offset); + } +#else + vfs_uart_init_simple_mode(0, 7, 16, 2 * 1000 * 1000, "/dev/ttyS0"); +#endif + if (0 == get_dts_addr("gpio", &fdt, &offset)) { + fdt_button_module_init((const void *)fdt, (int)offset); + } + +#if 0 /* pwm */ + if (0 == get_dts_addr("pwm", &fdt, &offset)) { + vfs_pwm_init(fdt, offset); + } +#endif + aos_loop_init(); + + fd_console = aos_open("/dev/ttyS0", 0); + if (fd_console >= 0) { + printf("Init CLI with event Driven\r\n"); + aos_cli_init(0); + aos_poll_read_fd(fd_console, aos_cli_event_cb_read_get(), (void*)0x12345678); + } + + aos_register_event_filter(EV_KEY, event_cb_key_event, NULL); + aos_register_event_filter(EV_BLE_TEST, event_cb_ble_event, NULL); + //tsen_adc_init(); + + #if defined(CONFIG_BT_TL) + //uart's pinmux has been configured in vfs_uart_init(load uart1's pin info from devicetree) + uart_init(1); + ble_controller_init(configMAX_PRIORITIES - 1); + #endif + + aos_loop_run(); + + puts("------------------------------------------\r\n"); + puts("+++++++++Critical Exit From Loop++++++++++\r\n"); + puts("******************************************\r\n"); + vTaskDelete(NULL); +} + +void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize) +{ + /* If the buffers to be provided to the Idle task are declared inside this + function then they must be declared static - otherwise they will be allocated on + the stack and so not exists after this function exits. */ + static StaticTask_t xIdleTaskTCB; + //static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ]; + static StackType_t uxIdleTaskStack[512]; + + /* Pass out a pointer to the StaticTask_t structure in which the Idle task's + state will be stored. */ + *ppxIdleTaskTCBBuffer = &xIdleTaskTCB; + + /* Pass out the array that will be used as the Idle task's stack. */ + *ppxIdleTaskStackBuffer = uxIdleTaskStack; + + /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer. + Note that, as the array is necessarily of type StackType_t, + configMINIMAL_STACK_SIZE is specified in words, not bytes. */ + //*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; + *pulIdleTaskStackSize = 512;//size 512 words is For ble pds mode, otherwise stack overflow of idle task will happen. +} + +/* configSUPPORT_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the +application must provide an implementation of vApplicationGetTimerTaskMemory() +to provide the memory that is used by the Timer service task. */ +void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize) +{ + /* If the buffers to be provided to the Timer task are declared inside this + function then they must be declared static - otherwise they will be allocated on + the stack and so not exists after this function exits. */ + static StaticTask_t xTimerTaskTCB; + static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ]; + + /* Pass out a pointer to the StaticTask_t structure in which the Timer + task's state will be stored. */ + *ppxTimerTaskTCBBuffer = &xTimerTaskTCB; + + /* Pass out the array that will be used as the Timer task's stack. */ + *ppxTimerTaskStackBuffer = uxTimerTaskStack; + + /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer. + Note that, as the array is necessarily of type StackType_t, + configTIMER_TASK_STACK_DEPTH is specified in words, not bytes. */ + *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH; +} + +void user_vAssertCalled(void) __attribute__ ((weak, alias ("vAssertCalled"))); +void vAssertCalled(void) +{ + volatile uint32_t ulSetTo1ToExitFunction = 0; + + taskDISABLE_INTERRUPTS(); + while( ulSetTo1ToExitFunction != 1 ) { + __asm volatile( "NOP" ); + } +} + +static void _dump_boot_info(void) +{ + char chip_feature[40]; + const char *banner; + + puts("Booting BL602 Chip...\r\n"); + + /*Display Banner*/ + if (0 == bl_chip_banner(&banner)) { + puts(banner); + } + puts("\r\n"); + /*Chip Feature list*/ + puts("\r\n"); + puts("------------------------------------------------------------\r\n"); + puts("RISC-V Core Feature:"); + bl_chip_info(chip_feature); + puts(chip_feature); + puts("\r\n"); + + puts("Build Version: "); + puts(BL_SDK_VER); // @suppress("Symbol is not resolved") + puts("\r\n"); + + puts("Build Version: "); + puts(BL_SDK_VER); // @suppress("Symbol is not resolved") + puts("\r\n"); + + puts("PHY Version: "); + puts(BL_SDK_PHY_VER); // @suppress("Symbol is not resolved") + puts("\r\n"); + + puts("RF Version: "); + puts(BL_SDK_RF_VER); // @suppress("Symbol is not resolved") + puts("\r\n"); + + puts("Build Date: "); + puts(__DATE__); + puts("\r\n"); + puts("Build Time: "); + puts(__TIME__); + puts("\r\n"); + puts("------------------------------------------------------------\r\n"); + +} + +static void system_init(void) +{ + blog_init(); + bl_irq_init(); + bl_sec_init(); + bl_sec_test(); + bl_dma_init(); + bl_rtc_init(); + hal_boot2_init(); + + /* board config is set after system is init*/ + hal_board_cfg(0); +} + +static void system_thread_init() +{ + +} + + + +void bfl_main() +{ + + static StackType_t proc_hellow_stack[512]; + static StaticTask_t proc_hellow_task; + + static StackType_t aos_loop_proc_stack[1024]; + static StaticTask_t aos_loop_proc_task; + + bl_sys_early_init(); + + /*Init UART In the first place*/ + bl_uart_init(0, 16, 7, 255, 255, 2 * 1000 * 1000); + puts("Starting bl602 now....\r\n"); + + bl_sys_init(); + + _dump_boot_info(); + borad_rgb_init(); + vPortDefineHeapRegions(xHeapRegions); + printf("Heap %u@%p, %u@%p\r\n", + (unsigned int)&_heap_size, &_heap_start, + (unsigned int)&_heap_wifi_size, &_heap_wifi_start + ); + + system_init(); + system_thread_init(); + + puts("[OS] Starting proc_hellow_entry task...\r\n"); + xTaskCreateStatic(proc_hellow_entry, (char*)"hellow", 512, NULL, 15, proc_hellow_stack, &proc_hellow_task); + + puts("[OS] Starting aos_loop_proc task...\r\n"); + xTaskCreateStatic(aos_loop_proc, (char*)"event_loop", 1024, NULL, 15, aos_loop_proc_stack, &aos_loop_proc_task); + + puts("[OS] Starting OS Scheduler...\r\n"); + vTaskStartScheduler(); +}