Diff: BLE_demo.cpp

Revision:

0:de03cbbcd0ff

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BLE_demo.cpp	Mon Nov 30 09:32:15 2015 +0000
@@ -0,0 +1,355 @@
+/*
+ * Copyright (C) 2011-2012 by Matthias Ringwald
+ *
+ * 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 the copyright holders nor the names of
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ * 4. This software may not be used in a commercial product
+ *    without an explicit license granted by the copyright holder.
+ *
+ * THIS SOFTWARE IS PROVIDED BY MATTHIAS RINGWALD 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 MATTHIAS
+ * RINGWALD 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.
+ *
+ */
+
+//*****************************************************************************
+//
+// att device demo
+//
+//*****************************************************************************
+
+// TODO: seperate BR/EDR from LE ACL buffers
+// TODO: move LE init into HCI
+// ..
+
+// NOTE: Supports only a single connection
+
+// mbed specific
+#include "mbed.h"
+
+// from btstack ble_server.c
+#include "global.h"
+#include "debug.h"
+#include "btstack/btstack.h"
+#include "btstack/hci_cmds.h"
+#include "btstack/run_loop.h"
+#include "btstack/hal_tick.h"
+
+#include "hci.h"
+#include "l2cap.h"
+#include "btstack_memory.h"
+#include "remote_device_db.h"
+#include "config.h"
+
+#include "att.h"
+#include "TB6612.h"
+
+Serial pc(USBTX, USBRX);
+TB6612 MOTOR_A(p21,p19,p20);
+TB6612 MOTOR_B(p22,p29,p30);
+
+hci_transport_t * hci_transport_picusb_instance();
+
+static att_connection_t att_connection;
+static uint16_t         att_response_handle = 0;
+static uint16_t         att_response_size   = 0;
+static uint8_t          att_response_buffer[28];
+
+static void att_try_respond(void)
+{
+    if (!att_response_size) return;
+    if (!att_response_handle) return;
+    if (!hci_can_send_packet_now(HCI_ACL_DATA_PACKET)) return;
+
+    // update state before sending packet
+    uint16_t size = att_response_size;
+    att_response_size = 0;
+    l2cap_send_connectionless(att_response_handle, L2CAP_CID_ATTRIBUTE_PROTOCOL, att_response_buffer, size);
+}
+
+
+static void att_packet_handler(uint8_t packet_type, uint16_t handle, uint8_t *packet, uint16_t size)
+{
+    if (packet_type != ATT_DATA_PACKET) return;
+
+    att_response_handle = handle;
+    att_response_size = att_handle_request(&att_connection, packet, size, att_response_buffer);
+    att_try_respond();
+}
+
+
+// enable LE, setup ADV data
+static void packet_handler (void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size)
+{
+    static bd_addr_t addr;
+//    uint8_t adv_data[] = { 02, 01, 05,   03, 02, 0xf0, 0xff }; 
+    const uint8_t adv_data[31]="\x02\x01\x05" "\x06\x09mbed";
+    switch (packet_type) {
+
+        case HCI_EVENT_PACKET:
+            switch (packet[0]) {
+
+                case BTSTACK_EVENT_STATE:
+                    // bt stack activated, get started - set local name
+                    if (packet[2] == HCI_STATE_WORKING) {
+                        log_info("Working!\n");
+                        hci_send_cmd(&hci_read_local_supported_features);
+                    }
+                    break;
+
+                case DAEMON_EVENT_HCI_PACKET_SENT:
+                    att_try_respond();
+                    break;
+
+                case HCI_EVENT_LE_META:
+                    switch (packet[2]) {
+                        case HCI_SUBEVENT_LE_CONNECTION_COMPLETE:
+                            // reset connection MTU
+                            att_connection.mtu = 23;
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+
+                case BTSTACK_EVENT_NR_CONNECTIONS_CHANGED:
+                    if (packet[2]) {
+                        connection_status=1;
+                        log_info("CONNECTED\n");
+                    } else {
+                        connection_status=0;
+						MOTOR_A = 0;
+		                MOTOR_B = 0;
+						log_info("NOT CONNECTED\n");
+                    }
+                    break;
+
+                case HCI_EVENT_DISCONNECTION_COMPLETE:
+                    att_response_handle =0;
+                    att_response_size = 0;
+
+                    // restart advertising
+                    hci_send_cmd(&hci_le_set_advertise_enable, 1);
+                    break;
+
+                case HCI_EVENT_COMMAND_COMPLETE:
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_read_bd_addr)) {
+                        bt_flip_addr(addr, &packet[6]);
+                        log_info("BD ADDR: %s\n", bd_addr_to_str(addr));
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_read_local_supported_features)) {
+                        log_info("Local supported features: %04lX%04lX\n", READ_BT_32(packet, 10), READ_BT_32(packet, 6));
+                        hci_send_cmd(&hci_set_event_mask, 0xffffffff, 0x20001fff);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_set_event_mask)) {
+                        hci_send_cmd(&hci_write_le_host_supported, 1, 1);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_write_le_host_supported)) {
+                        hci_send_cmd(&hci_le_set_event_mask, 0xffffffff, 0xffffffff);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_set_event_mask)) {
+                        hci_send_cmd(&hci_le_read_buffer_size);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_read_buffer_size)) {
+                        log_info("LE buffer size: %u, count %u\n", READ_BT_16(packet,6), packet[8]);
+                        hci_send_cmd(&hci_le_read_supported_states);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_read_supported_states)) {
+                        hci_send_cmd(&hci_le_set_advertising_parameters,  0x0400, 0x0800, 0, 0, 0, &addr, 0x07, 0);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_set_advertising_parameters)) {
+                        hci_send_cmd(&hci_le_set_advertising_data, sizeof(adv_data), adv_data);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_set_advertising_data)) {
+                        hci_send_cmd(&hci_le_set_scan_response_data, 10, adv_data);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_set_scan_response_data)) {
+                        hci_send_cmd(&hci_le_set_advertise_enable, 1);
+                        break;
+                    }
+                    if (COMMAND_COMPLETE_EVENT(packet, hci_le_set_advertise_enable)) {
+                        hci_discoverable_control(1);
+                        log_info("startup_state=1\n");
+                        startup_state=1;
+
+                        break;
+                    }
+
+            }
+    }
+}
+
+// test profile
+#include "profile.h"
+
+static uint8_t strbuf[80];
+static uint8_t  ledvalue;
+
+// read requests
+static uint16_t att_read_callback(uint16_t handle, uint16_t offset, uint8_t * buffer, uint16_t buffer_size)
+{
+    uint16_t    ret=0,val;
+
+    if(buffer) {
+        log_info("READ Callback, handle %04x\n", handle);
+
+    }
+    switch(handle) {
+            // Correspond to Characteristics 0xFFF1
+        case 0x000b:
+#if 0
+            if(buffer && ret<=buffer_size) {
+                buffer[0] = sw1.read();
+                log_info("Read value: %u\n", buffer[0]);
+            }
+            ret = 1;
+#else
+			ret = 0;
+            log_info("No action\n");
+#endif
+            break;
+
+            // Correspond to Characteristics 0xFFF2
+        case 0x000d:
+            if(buffer && buffer_size) {
+
+                buffer[0] = ledvalue;
+                log_info("Read value: %u\n", buffer[0]);
+            }
+            ret=1;
+            break;
+
+            // Correspond to Characteristics 0x00001234-0000-1000-8000-00805F9B34FB
+        case 0x000f:
+            if(buffer && buffer_size>=2) {
+                val=timer_counter;
+                log_info("Read value: %u\n", val);
+                buffer[0]=val&0xff;
+                buffer[1]=val>>8;
+            }
+            ret=2;
+            break;
+    }
+    return ret;
+}
+
+// write requests
+static void att_write_callback(uint16_t handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size, signature_t * signature)
+{
+    log_info("WRITE Callback, handle %04x\n", handle);
+
+    switch(handle) {
+            // Correspond to Characteristics 0xFFF1
+        case 0x000b:
+			switch(buffer[0])
+        	{
+            case 0x01:
+                MOTOR_A = 100;
+                MOTOR_B = 100;
+                break;
+            case 0x02:
+                MOTOR_A = -100;
+                MOTOR_B = -100;
+                break;
+            case 0x04:
+                MOTOR_A = 100;
+                MOTOR_B = -100;
+                break;
+            case 0x08:
+                MOTOR_A = -100;
+                MOTOR_B = 100;
+                break;
+            default:
+                MOTOR_A = 0;
+                MOTOR_B = 0;
+      	    }
+            break;
+
+            // Correspond to Characteristics 0xFFF2
+        case 0x000d:
+            log_info("New value: %u\n", buffer[0]);
+            ledvalue = buffer[0];
+            break;
+    }
+}
+
+
+void hal_tick_event(void)
+{
+    timer_counter++;
+}
+
+// main
+int main(void)
+{
+    pc.baud(921600);
+    //pc.baud(230400);
+    log_info("%s\n", __FILE__);
+
+    /// GET STARTED with BTstack ///
+    btstack_memory_init();
+    run_loop_init(RUN_LOOP_EMBEDDED);
+    hal_tick_set_handler(&hal_tick_event);
+
+    // init HCI
+    // use BlueUSB
+    hci_transport_t* transport = hci_transport_usb_instance();
+    bt_control_t       * control   = NULL;
+    hci_uart_config_t  * config    = NULL;
+    remote_device_db_t * remote_db = (remote_device_db_t *) &remote_device_db_memory;
+    hci_init(transport, config, control, remote_db);
+
+    // use eHCILL
+    // bt_control_cc256x_enable_ehcill(1);
+
+    // set up l2cap_le
+    l2cap_init();
+    l2cap_register_fixed_channel(att_packet_handler, L2CAP_CID_ATTRIBUTE_PROTOCOL);
+    l2cap_register_packet_handler(packet_handler);
+
+    // set up ATT
+    att_set_db(profile_data);
+    att_set_write_callback(att_write_callback);
+    att_set_read_callback(att_read_callback);
+    att_dump_attributes();
+    att_connection.mtu = 27;
+
+    log_info("Run...\n\n");
+
+    // turn on!
+    hci_power_control(HCI_POWER_ON);
+
+    // go!
+    run_loop_execute();
+
+    // happy compiler!
+    return 0;
+}