File content as of revision 2:d61a6f4d9682:

/* mbed Microcontroller Library
 * Copyright (c) 2006-2013 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __CUSTOM_BLE_CONSOLE_SERVICE_H__
#define __CUSTOM_BLE_CONSOLE_SERVICE_H__

#include "BLE.h"

const LongUUIDBytes_t CONS_SERVICE_UUID_128 =                   { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0xb4,0x9a,0xe1,0x11,0x0E,0x00,0x00,0x00,0x00,0x00 }; 

const LongUUIDBytes_t CONS_TERM_CHAR_UUID_128 =                 { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x0E,0x00,0x01,0x00,0x00,0x00 };  
const LongUUIDBytes_t CONS_STDERR_CHAR_UUID_128 =               { 0x1b,0xc5,0xa5,0xd5,0x02,0x00,0x36,0xac,0xe1,0x11,0x0E,0x00,0x02,0x00,0x00,0x00 };  

#define W2ST_CONSOLE_MAX_CHAR_LEN   20

/* Custom Sensors Service */
class CustomConsoleService  {
public:
    CustomConsoleService(BLEDevice &_ble) :
        ble(_ble),
        consTermCharacteristic(CONS_TERM_CHAR_UUID_128,LastTermBuffer, W2ST_CONSOLE_MAX_CHAR_LEN, W2ST_CONSOLE_MAX_CHAR_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE |
                                GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),
        consStderrCharacteristic(CONS_STDERR_CHAR_UUID_128, LastStderrBuffer, W2ST_CONSOLE_MAX_CHAR_LEN, W2ST_CONSOLE_MAX_CHAR_LEN,
                                 GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY)
        {
 
            static bool serviceAdded = false; /* We should only ever need to add the env service once. */
            if (serviceAdded) {
            return;
            }

            GattCharacteristic *charTable[] = {&consTermCharacteristic, &consStderrCharacteristic};        
                        
            GattService   consService(CONS_SERVICE_UUID_128, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));               
                
            ble.gattServer().addService(consService);             

            memset (LastTermBuffer, 0, W2ST_CONSOLE_MAX_CHAR_LEN);  
            memset (LastStderrBuffer, 0, W2ST_CONSOLE_MAX_CHAR_LEN);           
                                                                         
            isBTLEConnected                     = DISCONNECTED;  
            isEnabledTermNotify                 = false;
            isEnabledStderrNotify               = false;                                                                            
            serviceAdded                        = true;                                                                                                                                  
        }

    tBleStatus updateTerm (uint8_t *data,uint8_t length) {
        tBleStatus ret;
        uint8_t Offset;
        uint8_t DataToSend;
//        uint8_t BufferToWrite[W2ST_CONSOLE_MAX_CHAR_LEN];
//        uint8_t BytesToWrite;    

        if (isEnabledTermNotify && isBTLEConnected==CONNECTED) {
        /* Split the code in packages */
            for(Offset =0; Offset<length; Offset +=W2ST_CONSOLE_MAX_CHAR_LEN){
                DataToSend = (length-Offset);
                DataToSend = (DataToSend>W2ST_CONSOLE_MAX_CHAR_LEN) ?  W2ST_CONSOLE_MAX_CHAR_LEN : DataToSend;

                /* keep a copy */
                memcpy(LastTermBuffer,data+Offset,DataToSend);
                LastTermLen = DataToSend;       
                DEBUG("updateTerm handle: %d string: %s\n\r", consTermCharacteristic.getValueAttribute().getHandle(), LastTermBuffer);
                ret = ble.gattServer().write(consTermCharacteristic.getValueAttribute().getHandle(), data+Offset, DataToSend, 0);
                if (ret != BLE_ERROR_NONE) {  /* FIXME the wrong errcode from BLE requires BLE fix */
//                    BytesToWrite = sprintf((char *)BufferToWrite, "Error Updating Stdout Char\r\n");
//                    updateStderr(BufferToWrite,BytesToWrite);               
                }
                return ret;               
            }
        }
        return BLE_STATUS_SUCCESS;
    }
       
    tBleStatus updateStderr (uint8_t *data,uint8_t length) {

        uint8_t Offset;
        uint8_t DataToSend;
        
        if (isEnabledStderrNotify && isBTLEConnected==CONNECTED) {
        /* Split the code in packages */
            for(Offset =0; Offset<length; Offset +=W2ST_CONSOLE_MAX_CHAR_LEN){
                DataToSend = (length-Offset);
                DataToSend = (DataToSend>W2ST_CONSOLE_MAX_CHAR_LEN) ?  W2ST_CONSOLE_MAX_CHAR_LEN : DataToSend;

                /* keep a copy */
                memcpy(LastStderrBuffer,data+Offset,DataToSend);
                LastStderrLen = DataToSend;
                DEBUG("updateStderr handle: %d string: %s\n\r", consStderrCharacteristic.getValueAttribute().getHandle(), LastStderrBuffer);
                return (ble.gattServer().write(consStderrCharacteristic.getValueAttribute().getHandle(), data+Offset, DataToSend, 0));                          
            }
        }
        return BLE_STATUS_SUCCESS;
    }

    void updateConnectionStatus (ConnectionStatus_t status){
            isBTLEConnected = status;                      
            isEnabledTermNotify                 = false;
            isEnabledStderrNotify               = false;                 
    }             

    bool isTermHandle (Gap::Handle_t handle) {
            if (handle == consTermCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }

    bool isStderrHandle (Gap::Handle_t handle) {
            if (handle == consStderrCharacteristic.getValueAttribute().getHandle()) return true;
            return false;
    }
    
    void enNotify (Gap::Handle_t handle)  {
            if (isTermHandle(handle))   { isEnabledTermNotify = true; return; }    
            if (isStderrHandle(handle)) { isEnabledStderrNotify = true; return; }                
    }
        
    void disNotify (Gap::Handle_t handle) {
            if (isTermHandle(handle))   { isEnabledTermNotify = false; return; }    
            if (isStderrHandle(handle)) { isEnabledStderrNotify = false; return; }                            
    }


private:
    BLEDevice           &ble;
    uint8_t             LastTermBuffer     [W2ST_CONSOLE_MAX_CHAR_LEN]; 
    uint8_t             LastTermLen;
    uint8_t             LastStderrBuffer   [W2ST_CONSOLE_MAX_CHAR_LEN];   
    uint8_t             LastStderrLen;                   
     
    GattCharacteristic  consTermCharacteristic;     
    GattCharacteristic  consStderrCharacteristic;   
    ConnectionStatus_t  isBTLEConnected;
    bool                isEnabledTermNotify;
    bool                isEnabledStderrNotify;    
};

#endif /* #ifndef __CUSTOM_BLE_CONSOLE_SERVICE_H__*/