File content as of revision 0:1eec8720727a:

/* mbed Microcontroller Library
 * Copyright (c) 2006-2014 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.
 */

#include <events/mbed_events.h>
#include <mbed.h>
#include "ble/BLE.h"
#include "ble/Gap.h"
#include "ble/services/BatteryService.h"
#include "DOORService.h"

//DigitalOut led1(LED1, 1);

const static char     DEVICE_NAME[] = "DOORCTL";
static const uint16_t uuid16_list[] = {DOORService::DOOR_SERVICE_UUID};


uint8_t BLE_RX_CMD = 0xFF;
uint8_t doorStatusPayload[2] = {0xFF,};

DigitalOut relay1(D7); // Relay 1
DigitalOut relay2(D6); // Relay 2
DigitalOut relay3(D5); // Relay 3
DigitalOut relay4(D4); // Relay 4

BLEDevice  ble;


static DOORService *doorServicePtr;
static EventQueue eventQueue(
    /* event count */ 16 * /* event size */ 32
);

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    BLE::Instance().gap().startAdvertising();
}



void onDataWrittenCallback(const GattWriteCallbackParams *params) {
    
    
    if ((params->handle == doorServicePtr->getValueHandle()) && (params->len == 1)) {
        {
            BLE_RX_CMD = *(params->data);            
        }
    }
}

void cmd_thread(void const *args) {
    while (true) {
        switch (BLE_RX_CMD)
        {
            case 0x00:
            relay1 = 1;
            relay2 = 0;
            relay3 = 0;
            relay4 = 0;
           // Thread::wait(500);            
            doorStatusPayload[0]=0xF0;
            break;
            
            case 0x01:
            relay1 = 0;
            relay2 = 1;
            relay3 = 0;
            relay4 = 0;
            //Thread::wait(500);
            doorStatusPayload[0]=0xF1;
            break;

            case 0x02:
            relay1 = 0;
            relay2 = 0;
            relay3 = 1;
            relay4 = 0;
            //Thread::wait(500);
            doorStatusPayload[0]=0xF2;
            break;

            case 0x03:
            relay1 = 0;
            relay2 = 0;
            relay3 = 0;
            relay4 = 1;
            //Thread::wait(500);
            doorStatusPayload[0]=0xF3;
            break;

            case 0x04:
            relay1 = 0;
            relay2 = 0;
            relay3 = 0;
            relay4 = 0;            
            //Thread::wait(500);
            doorStatusPayload[0]=0xF4;            
            break;

            case 0x05: //Test Mode!!
            relay1 = 1;
            relay2 = 1;
            relay3 = 1;
            relay4 = 1;       
            //Thread::wait(500);                 
            doorStatusPayload[0]=0xF5;            
            break;

                        
            default:
            break;    
        }
       if (ble.getGapState().connected) {
            ble.updateCharacteristicValue((doorServicePtr->getValueHandle()),doorStatusPayload, 1);           
        }
    }
}



/**
 * This function is called when the ble initialization process has failled
 */
void onBleInitError(BLE &ble, ble_error_t error)
{
    /* Initialization error handling should go here */
}

/**
 * Callback triggered when the ble initialization process has finished
 */
void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
{
    BLE&        ble   = params->ble;
    ble_error_t error = params->error;

    if (error != BLE_ERROR_NONE) {
        /* In case of error, forward the error handling to onBleInitError */
        onBleInitError(ble, error);
        return;
    }

    /* Ensure that it is the default instance of BLE */
    if(ble.getInstanceID() != BLE::DEFAULT_INSTANCE) {
        return;
    }

    ble.gap().onDisconnection(disconnectionCallback);
    ble.gattServer().onDataWritten(onDataWrittenCallback);
    
    /* Setup primary services */  
    uint8_t initialValueForDOORCharacteristic = 0xFF;
    doorServicePtr = new DOORService(ble, initialValueForDOORCharacteristic);

    /* Setup advertising */
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *) uuid16_list, sizeof(uuid16_list));
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *) DEVICE_NAME, sizeof(DEVICE_NAME));
    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.gap().setAdvertisingInterval(1000); /* 1000ms */
    ble.gap().startAdvertising();
}

void scheduleBleEventsProcessing(BLE::OnEventsToProcessCallbackContext* context) {
    BLE &ble = BLE::Instance();
    eventQueue.call(Callback<void()>(&ble, &BLE::processEvents));
}

int main()
{
    relay1 = 0;
    relay2 = 0;
    relay3 = 0;
    relay4 = 0;     
    
    BLE &ble = BLE::Instance();
    ble.onEventsToProcess(scheduleBleEventsProcessing);
    ble.init(bleInitComplete);

    Thread thread0(cmd_thread,(void *)"DOORCTL");
    
    eventQueue.dispatch_forever();
    
    
    return 0;
}