File content as of revision 0:e71874215e23:

/* 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 "BMA250E.h"
/* UART printf */
Serial pc(p5, p4);

/* Sensor */
BMA250E acclerameter(p14, p13, NC, NC);

DigitalOut ledRed(p16, 1);

/* UUID, Device name */
uint16_t sensServUUID = /*0xA000*/0x1811;
uint16_t acceCharUUID = /*0xA001*/0x2A56;
uint16_t gyroCharUUID = /*0xA002*/0x2A57;
static const char     DEVICE_NAME[] = "mbed Motion";
static const uint16_t uuid16_list[] = { /*0xA000*/0x1811 };

uint8_t accePayload[7];
uint8_t gyroPayload[7];

/* Setup custom characteristics */
GattCharacteristic  acceChar(   acceCharUUID, accePayload,
                                sizeof(accePayload), sizeof(accePayload),
                                GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY | 
                                GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);

GattCharacteristic  gyroChar(   gyroCharUUID, gyroPayload,
                                sizeof(gyroPayload), sizeof(gyroPayload),
                                GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY | 
                                GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);

/* Setup custom service */
GattCharacteristic *characteristics[] = {&acceChar, &gyroChar};
GattService sensServ(sensServUUID, characteristics, sizeof(characteristics) / sizeof(GattCharacteristic *));

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

void blinkCallback(void)
{
    ledRed = !ledRed; /* Do blinky on LED1 while we're waiting for BLE events */
}

/**
 * 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 */
}

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

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

/**
 * 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);

    /* Setup primary service. */
    ble.addService(sensServ);

    /* 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::GENERIC_TAG);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.gap().setAdvertisingInterval(500); /* 500ms */
    ble.gap().startAdvertising();
    
}

void BMA250Ecallback(void) {
    int16_t xyz[3];
    
    acclerameter.ReadXYZ(xyz);
    pc.printf("%d %d %d \r\n", xyz[0], xyz[1], xyz[2]);
}



int main()
{
    pc.printf("Hi \r\n");
    
    eventQueue.call_every(200, blinkCallback);
    eventQueue.call_every(1000, BMA250Ecallback);

    BLE &ble = BLE::Instance();
    ble.onEventsToProcess(scheduleBleEventsProcessing);
    ble.init(bleInitComplete);

    eventQueue.dispatch_forever();

    return 0;
}