File content as of revision 8:682b575fd7b3:

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

#include "mbed.h"
#include "ble/BLE.h"
#include "BLEservice.h"
void bleInitComplete(BLE::InitializationCompleteCallbackContext *params);
void onBleInitError(BLE &ble, ble_error_t error);
void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params);
Ticker ticker;
Serial pc(P0_24, P0_25);


const static char     DEVICE_NAME[] = "Test2020";
#define LED_SERVICE 0xA000
#define BTN_SERVICE 0x1eee
#define ACCEL_SERVICE 0xA012
#define TEMP_SERVICE 0xA022
static const uint16_t uuid16_list[] = {LED_SERVICE,BTN_SERVICE,ACCEL_SERVICE,TEMP_SERVICE};
BLEservice * LED;
BLEservice * Button;
BLEservice *Accel;
BLEservice *Temp;
const int LSM303_MAG_ADDRESS=(0x1e << 1);
DigitalOut col1(P0_4, 0);
DigitalOut alivenessLED(P0_13, 0);
DigitalOut actuatedLED(P0_14, 0);
I2C i2c(P0_30, P0_0); // SDA is on P0_30, SCL is on P0_0
const int LSM303_ACCEL_ADDRESS = (0x19<<1); 
void initTemp()
{
        //init code for temp sensor
    char Data[8]; // Declare a buffer for data transfer    
    int Status;

    Data[0] =0x1f;
    Data[1] = 0b11000000;
    i2c.write(LSM303_ACCEL_ADDRESS,Data,2);
    
    Data[0] = 0x23;
    Data[1] = 0b10000000;
    i2c.write(LSM303_ACCEL_ADDRESS,Data,2);

}
void pollTemp()
{
    char Data[8]; // Declare a buffer for data transfer    
    int Status;
    int16_t T;     
    
    Data[0]=0x80+ 0x0c; // Register number 0x28 has the X data (2 bytes)
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,1,true);  // Write register number
    Status = i2c.read(LSM303_ACCEL_ADDRESS,Data,2); // Read register contents
    T = Data[1];
    T = (T << 8) + Data[0];
    T = T / 16;
    T = (20 << 3) + T;
    pc.printf("T=%d\r\n",T/4);
    Temp->writeCharacteristic(0,T/4);
}
void initLED()
{
    actuatedLED = 0;   
}
void pollLED()
{    
    uint16_t Value;    
    Value = LED->readCharacteristic(0);
    actuatedLED = Value;
}
DigitalIn ButtonA(P0_17);
DigitalIn ButtonB(P0_26);
void initButton()
{
    
}
void pollButton()
{
    uint16_t ValueA = ButtonA;
    pc.printf("Button A = %d\r\n",ValueA);    
    Button->writeCharacteristic(0,ValueA);
    uint16_t ValueB = ButtonB;
    pc.printf("Button B = %d\r\n",ValueB);
    Button->writeCharacteristic(1,ValueB);
}



void initAccel()
{
    // Wake the accelerometer from sleep mode by writing disabling low power mode, setting freq to 10Hz and enabling all three axes
    char Data[8]; // Declare a buffer for data transfer    
    int Status;
    Data[0]=0x20;   // wake up LSM303 (max speed, all accel channels)
    Data[1]=0x77;
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,2);  // Write data to register   
   
    Data[0]=0x23;   // enable high resolution mode
    Data[1]=0x0e; 
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,2);  // Write data to register   
    
}
void pollAccel()
{
    char Data[8]; // Declare a buffer for data transfer    
    int Status;
    int16_t X;                                 
    Data[0]=0x80 + 0x28; // Register number 0x28 has the X data (2 bytes)
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,1,true);  // Write register number
    Status = i2c.read(LSM303_ACCEL_ADDRESS,Data,2); // Read register contents
    X = Data[1];
    X = (X << 8) + Data[0];
    
    int16_t Y;
    Data[0]=0x80 + 0x2a; // Register number 0x2a has the Y data (2 bytes)
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,1,true);  // Write register number
    Status = i2c.read(LSM303_ACCEL_ADDRESS,Data,2); // Read register contents
    Y = Data[1];
    Y = (Y << 8) + Data[0];
    
    int16_t Z;
    Data[0]=0x80 + 0x2c; // Register number 0x2c has the Z data (2 bytes)
    Status = i2c.write(LSM303_ACCEL_ADDRESS,Data,1,true);  // Write register number
    Status = i2c.read(LSM303_ACCEL_ADDRESS,Data,2); // Read register contents
    Z = Data[1];
    Z = (Z << 8) + Data[0];
    pc.printf("X : %d , Y %d , Z %d \r\n",X,Y,Z);
    Accel->writeCharacteristic(0,X);
    Accel->writeCharacteristic(1,Y);
    Accel->writeCharacteristic(2,Z);
}
void onDataWrittenCallback(const GattWriteCallbackParams *params)
{   
    pc.printf("Got writeback for %d\r\n",params->handle);
}
void tick()
{
}
void pollIO()
{    
    pc.printf("Poll\r\n");
    LED->poll();
    Button->poll();
    Accel->poll();
    Temp->poll();
}
int main(void)
{       
    BLE &ble = BLE::Instance();
    ble.init(bleInitComplete);
 /* SpinWait for initialization to complete. This is necessary because the
     * BLE object is used in the main loop below. */
    while (ble.hasInitialized()  == false) { /* spin loop */ }

    pc.printf("BLE init complete\r\n");
    
    uint16_t LED_char_array[]={0xabcd};
    pc.printf("Creating LED Service\r\n");
    LED = new BLEservice(ble,LED_SERVICE,1,LED_char_array,initLED,pollLED);        
    LED->init();
    pc.printf("LED service ready\r\n");
    
    uint16_t Button_char_array[]={0x2021,0x2022};
    pc.printf("Creating Button Service\r\n");
    Button = new BLEservice(ble,BTN_SERVICE,2,Button_char_array,initButton,pollButton,1);        
    Button->init();
    pc.printf("Button service ready\r\n");
    
    uint16_t Accel_char_array[]={0xA013,0xA014,0xA015};
    pc.printf("Creating Accel Service\r\n");
    Accel = new BLEservice(ble,ACCEL_SERVICE,3,Accel_char_array,initAccel,pollAccel);        
    Accel->init();
    pc.printf("Accel service ready\r\n");
    
    uint16_t Temp_char_array[]={0xf00d};
    pc.printf("Creating Temp Service\r\n");
    Temp = new BLEservice(ble,TEMP_SERVICE,1,Temp_char_array,initTemp,pollTemp);        
    Temp->init();
    pc.printf("Temp service ready\r\n");
    
    ticker.attach(tick, 1); /* wake from sleep every 100ms */
    while (1) 
    {   pollIO();
        ble.waitForEvent();
    }
}
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);
    // ble.gattServer().onDataRead(onDataReadCallback); // Nordic Soft device will not call this so have to poll instead
  
    
    /* 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(500); /* 500ms. */
    pc.printf("Starting advertising\r\n");
    ble.gap().startAdvertising();
}
void onBleInitError(BLE &ble, ble_error_t error)
{
    /* Initialization error handling should go here */
    pc.printf("BLE init error\r\n");
}
void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    pc.printf("Disconnected, restarting advertising\r\n");
    BLE::Instance().gap().startAdvertising();
}