main.cpp

00001 #include <mbed.h>
00002 
00003 #include "Gap.h"
00004 #include "command-interpreter.h"  
00005 #include "ble/BLE.h"
00006 #include "ble/services/BatteryService.h"
00007 #include "ble/services/DeviceInformationService.h"
00008 #include "ble/services/UARTService.h"
00009 
00010 #define uart_buffer_size    64      //Do not increase uart_buffer_size to prevent out of memory, 
00011 #define uart_baudrate       38400   //supported baudrate range between 1200 to 230400 (38400) for NQ620 (NNN50)
00012 unsigned char uart_buf[uart_buffer_size];
00013 unsigned int i = 0;
00014 bool isGetCommand = false;
00015 
00016 Serial console(USBTX, USBRX);
00017 
00018 DeviceInformationService *deviceInfo;
00019 BatteryService *batteryService;
00020 static UARTService *uartServicePtr;
00021 const static char     DEVICE_NAME[]        = "DELTA_CLI_UART";
00022 static const uint16_t uuid16_list[]        = {GattService::UUID_HUMAN_INTERFACE_DEVICE_SERVICE,
00023                                               GattService::UUID_BATTERY_SERVICE,
00024                                               GattService::UUID_DEVICE_INFORMATION_SERVICE};
00025 
00026 void CLI_execute() {
00027         if (uart_buf[i-2] != '\r' || uart_buf[i-1] != '\n') return; //detecting \r\n
00028         
00029         isGetCommand = true;
00030             
00031 }
00032 void uart_interrupt() {
00033     uart_buf[i++] = console.getc();
00034     CLI_execute();
00035 }
00036 
00037 void onConnectionCallback(const Gap::ConnectionCallbackParams_t *params)
00038 {
00039     console.printf("Connected\r\n");
00040 }
00041 
00042 void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
00043 {
00044     console.printf("Disconnected\r\n");
00045     BLE::Instance(BLE::DEFAULT_INSTANCE).gap().startAdvertising(); // restart advertising
00046 }
00047 
00048 void onTimeoutCallback(Gap::TimeoutSource_t source)
00049 {
00050     switch (source) {
00051         case Gap::TIMEOUT_SRC_ADVERTISING:
00052             console.printf("Advertising timeout\r\n");
00053             break;  
00054         case Gap::TIMEOUT_SRC_SECURITY_REQUEST:
00055             console.printf("Security request timeout\r\n");
00056             break;
00057         case Gap::TIMEOUT_SRC_SCAN:
00058             console.printf("Scanning timeout\r\n");
00059             break;
00060         case Gap::TIMEOUT_SRC_CONN:
00061             console.printf("Connection timeout\r\n");
00062             break;
00063     }
00064 }
00065 
00066 void serverDataWrittenCallback(const GattWriteCallbackParams *response) {
00067     console.printf("serverDataWrittenCallback\r\n");
00068     if (response->handle == uartServicePtr->getTXCharacteristicHandle()) {
00069         for(int j=0;j<response->len;j++) {
00070             console.printf("data: %02X\r\n", response->data[j]);
00071         }
00072     }
00073 }
00074 
00075 void dataSentCallback(const unsigned callback) {
00076     //uart.printf("dataSentCallback\r\n");
00077 }
00078 
00079 void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
00080 {
00081     BLE &ble          = params->ble;
00082     ble_error_t error = params->error;
00083 
00084     if (error != BLE_ERROR_NONE) {
00085         return;
00086     }
00087     
00088     ble.gap().onDisconnection(disconnectionCallback);
00089     ble.gap().onConnection(onConnectionCallback);
00090     ble.gap().onTimeout(onTimeoutCallback);
00091     ble.gattServer().onDataWritten(serverDataWrittenCallback);
00092     ble.gattServer().onDataSent(dataSentCallback);
00093 
00094     /* Setup primary service. */
00095     uartServicePtr = new UARTService(ble);
00096 
00097     /* Setup auxiliary service. */
00098     batteryService = new BatteryService(ble, 100);
00099     deviceInfo = new DeviceInformationService(ble, "DELTA", "NQ620", "SN1", "hw-rev1", "fw-rev1", "soft-rev1");
00100 
00101     /* Setup advertising. */
00102     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
00103     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
00104     ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
00105     ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
00106     ble.gap().setAdvertisingInterval(50); /* 50ms */
00107     ble.gap().startAdvertising();
00108     console.printf("Start advertising\r\n");
00109 }
00110 
00111 int main(void)
00112 {
00113     
00114     console.attach(&uart_interrupt);
00115     console.baud(uart_baudrate);
00116     console.printf("Application Start\r\n");
00117     
00118     BLE& ble = BLE::Instance(BLE::DEFAULT_INSTANCE);
00119     ble.init(bleInitComplete);
00120 
00121     /* SpinWait for initialization to complete. This is necessary because the
00122      * BLE object is used in the main loop below. */
00123     while (ble.hasInitialized()  == false) { /* spin loop */ }
00124     
00125     while(1) {
00126         if(isGetCommand) {
00127             isGetCommand = false;
00128             
00129             if(uart_buf[0] == 'b') {
00130                 if (ble.getGapState().connected) {
00131                     
00132                     //Write data via RX characteristic
00133                     ble.gattServer().write(uartServicePtr->getRXCharacteristicHandle(), static_cast<const uint8_t *>(uart_buf)+2, i-4);
00134                 }
00135             }
00136             else{
00137                 for (int j=0; j<i; j++)
00138                     cyntecProcessCommandInput(uart_buf[j]);
00139                     //console.putc(uart_buf[j]);//used for debug only
00140             }
00141             
00142             i=0;
00143         }
00144         
00145         ble.waitForEvent(); // low power wait for event
00146     }
00147 }