File content as of revision 17:994c1f037198:

#include "mbed.h"
#include "io.h"
#include "BLE.h"
#include "common.h"

// BLE
#define INTERVAL_500MSEC        (500UL)
#define CONNTIMEOUT_3000MSEC    (3000UL)
#define ADV_TIMEOUT             (0)
#define DEVICE_NAME "Kitchen Scale"
#define BLE_TXPOWER_4DBM        (4)

// Device Information Service (DIS) (20 character limit)
// https://developer.bluetooth.org/gatt/services/Pages/ServiceViewer.aspx?u=org.bluetooth.service.device_information.xml
#define MANUFACTURER_NAME_STRING        "Hacarus" // Manufacturer Name String - shall represent the name of the manufacturer of the device.
#define MODEL_NUMBER_STRING             "0001" // Model Number String - shall represent the model number that is assigned by the device vendor.
#define SERIAL_NUMBER_STRING            "000780c0ffeef00d"  // Serial Number String - shall represent the serial number for a particular instance of the device.
#define FIRMWARE_REVISION_STRING        "v1.00.007@rev0016" // Firmware Revision String - shall represent the firmware revision for the firmware within the device.

// Weight Scale Service (Original)
#define UUID_WEIGHT_SCALE_SERVICE       (0x181D)
#define WEIGHT_COEFFICIENT              (8.64)

// Switch
#define SW_THRESHOLD            (0.5)
#define SW_SAMPLECOUNT          (3)

// Mode
#define MODE_OFF    (0) // LED OFF
#define MODE_START  (1) // LED OFF -> ON
#define MODE_ON     (2) // LED ON
#define MODE_END    (3) // LED ON -> OFF

// Led
#define LED_INTERVAL_MSEC   (100)
#define BRIGHTNESS_ADDVALUE (0.1)
#define BRIGHTNESS_MINVALUE (0.0)
#define BRIGHTNESS_MAXVALUE (1.0)

// Properties
io io;
uint32_t weight_data;
float32_t weight = 0.0;
uint32_t scale = 0;
int update_counter = 0;
float sw_data[SW_SAMPLECOUNT];
uint8_t sw_count = 0;
int led_mode = MODE_OFF;
float led_brightness = BRIGHTNESS_MINVALUE;

Timer t;

// UART for debug

#ifdef UART_DEBUG
Serial pc(P0_9, P0_8);// TX=P0_9
#define UART_BAUD_RATE   (9600UL)
#define DEBUG(...)              { pc.printf(__VA_ARGS__); }
#else
#define DEBUG(...) {}
#endif

// BLE 
BLE ble;
Gap::ConnectionParams_t connectionParams;

/* Complete list of 16-bit Service IDs */
uint16_t    uuid16_list[] = {GattService::UUID_DEVICE_INFORMATION_SERVICE};

/* Weight Scale Service */
static const uint8_t UUID_HACARUS_WEIGHT_CHAR[] = {0x00, 0x00, 0x2A, 0x9D, 0x00, 0x01, 0x00, 0x01, 0x00, 'H','a', 'c', 'a', 'r','u', 's'};
GattCharacteristic  WeightMeasurement (UUID(UUID_HACARUS_WEIGHT_CHAR), (uint8_t *)&weight_data, sizeof(weight_data), sizeof(weight_data),
        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_INDICATE);
static const uint8_t UUID_HACARUS_SCALE_CHAR[] = {0x00, 0x00, 0x2A, 0x9E, 0x00, 0x01, 0x00, 0x01, 0x00, 'H','a', 'c', 'a', 'r','u', 's'};
GattCharacteristic  WeightScale (UUID(UUID_HACARUS_SCALE_CHAR), (uint8_t *)&scale, sizeof(scale), sizeof(scale),
        GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE);
GattCharacteristic *Chars[] = {&WeightMeasurement,&WeightScale};
static const uint8_t UUID_HACARUS_WEIGHT_SERVICE[] = {0x00, 0x00, 0x18, 0x1D, 0x00, 0x01, 0x00, 0x01, 0x00, 'H','a', 'c', 'a', 'r','u', 's'};
GattService HWS = GattService(UUID(UUID_HACARUS_WEIGHT_SERVICE), Chars, sizeof(Chars) / sizeof(GattCharacteristic *));

/* Device Information Service */
GattCharacteristic ManuName(GattCharacteristic::UUID_MANUFACTURER_NAME_STRING_CHAR, (uint8_t *)&MANUFACTURER_NAME_STRING, sizeof(MANUFACTURER_NAME_STRING) - 1, sizeof(MANUFACTURER_NAME_STRING) - 1,
                           GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);
GattCharacteristic ModelNum(GattCharacteristic::UUID_MODEL_NUMBER_STRING_CHAR, (uint8_t *)&MODEL_NUMBER_STRING, sizeof(MODEL_NUMBER_STRING) - 1, sizeof(MODEL_NUMBER_STRING) - 1,
                           GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);
GattCharacteristic SerialNum(GattCharacteristic::UUID_SERIAL_NUMBER_STRING_CHAR, (uint8_t *)&SERIAL_NUMBER_STRING, sizeof(SERIAL_NUMBER_STRING) - 1, sizeof(SERIAL_NUMBER_STRING) - 1,
                           GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);
GattCharacteristic FWVersion(GattCharacteristic::UUID_FIRMWARE_REVISION_STRING_CHAR, (uint8_t *)&FIRMWARE_REVISION_STRING, sizeof(FIRMWARE_REVISION_STRING) - 1, sizeof(FIRMWARE_REVISION_STRING) - 1,
                           GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);
GattCharacteristic *DISChars[] = {&ManuName, &ModelNum, &SerialNum, &FWVersion};
GattService        DIS(GattService::UUID_DEVICE_INFORMATION_SERVICE , DISChars, sizeof(DISChars) / sizeof(GattCharacteristic *));

// to confirm joystick
bool check_joystick(){
/*
    float sum_data = 0;
    
    // ジョイスティックXのADC値(0〜1.0換算)が0.5以上ならON、0.5未満ならOFF
    sw_data[sw_count] = io.get_x();
    
    if(++sw_count >= SW_SAMPLECOUNT){
        sw_count = 0;
    }
    
    for(int count = 0;count < SW_SAMPLECOUNT;count++){
        sum_data += sw_data[count];
    }
    
    return ((sum_data / SW_SAMPLECOUNT) >= SW_THRESHOLD);
*/
    return(io.get_switch());
}

uint32_t quick_ieee11073_from_float(float data)
{
    uint8_t  exponent = 0xFE; //exponent is -2
    uint32_t mantissa = (uint32_t)(data*100);
    
    return ( ((uint32_t)exponent) << 24) | mantissa;
}

void SWInit(void){
    // SW Initialize
    for(int count = 0;count < SW_SAMPLECOUNT;count++){
        sw_data[count] = 0;
    }
}

void AppInit(void){
    
    SWInit();
    io.analog_pow(1);
      
/*
    if(NRF_UICR->XTALFREQ == 0xFFFFFF00){
        io.display_value = 3232;
    }else if(NRF_UICR->XTALFREQ == 0xFFFFFFFF){
        io.display_value = 1616;
    }
*/
}

/*
 * BLE CallBacks
 */
void BLEConnectionCallback(const Gap::ConnectionCallbackParams_t *params)
{
    ble.updateConnectionParams(params->handle, params->connectionParams);                       
}

void BLEDisconnectionCallback(const Gap::DisconnectionCallbackParams_t  *params)
{
    if(led_mode == MODE_ON){
        ble.startAdvertising();
    }
}

void BLERadioNotificationCallback(bool radio_active)
{
    if (radio_active == false)
    {
        if(led_mode == MODE_ON){
        }
    }
}

void BleInitialize(void){
    
    uint8_t advertiseServiceID[16];
    
    // Initialize
    ble.init();
    
    // Event Set
    ble.onConnection(&BLEConnectionCallback);
    ble.onDisconnection(&BLEDisconnectionCallback);
    ble.onRadioNotification(&BLERadioNotificationCallback);
    
    ble.getPreferredConnectionParams(&connectionParams);
    connectionParams.maxConnectionInterval = INTERVAL_500MSEC;
    connectionParams.minConnectionInterval = INTERVAL_500MSEC;
    connectionParams.connectionSupervisionTimeout = CONNTIMEOUT_3000MSEC;
    connectionParams.slaveLatency = 2;
    ble.setPreferredConnectionParams(&connectionParams);
    
    ble.setTxPower(BLE_TXPOWER_4DBM);
    
    for(int i=0; i<16; i++){
        advertiseServiceID[i] = UUID_HACARUS_WEIGHT_SERVICE[16 - 1 - i];
    }

    ble.accumulateAdvertisingPayload((GapAdvertisingData::Flags)(GapAdvertisingData::LE_GENERAL_DISCOVERABLE | GapAdvertisingData::BREDR_NOT_SUPPORTED));
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME,
                                        (const uint8_t *)DEVICE_NAME,
                                        strlen(DEVICE_NAME)); 
    ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,
                                     (const uint8_t *)advertiseServiceID, sizeof(advertiseServiceID));
                                                                   
    ble.setAdvertisingInterval(INTERVAL_500MSEC);
    ble.setAdvertisingTimeout(ADV_TIMEOUT); /* 0 is disable the advertising timeout. */
    
    ble.addService(HWS);
    ble.addService(DIS);
}

int main()
{
#ifdef UART_DEBUG
    pc.baud(UART_BAUD_RATE);
#endif
#ifndef PCB_VER1
    // set XTAL=32MHz for TaiyoYuden's module
    //  is moved to mbed-src/targets/cmsis/TARGET_NORDIC/TARGET_MCU_NRF51822/system_nrf51.c
    DEBUG("UICR->XTALFREQ=%x\r\n", NRF_UICR->XTALFREQ); // this should be 0xffffff00, not 0xffffffff
#endif

    BleInitialize();
    AppInit();

    for (;; ) {
        // 100msec waitForEvent
        t.reset();
        while(t.read_ms() < LED_INTERVAL_MSEC){
            t.start();
            ble.waitForEvent();
            t.stop();
        }
        
        io.analog_pow(1);
        // ticker処理
        switch(led_mode){
            case MODE_OFF:
                if(check_joystick()){
                    led_mode = MODE_START;
                }
            break;
            case MODE_START:
                led_brightness += BRIGHTNESS_ADDVALUE;
                io.display(led_brightness);
                if(led_brightness >= BRIGHTNESS_MAXVALUE){
                    update_counter = 0;
                    io.calibrate_weight();
                    SWInit();
                    ble.startAdvertising();
                    led_mode = MODE_ON;
                }
            break;
            case MODE_ON:
                if(check_joystick()){
                    led_mode = MODE_END;
                    if(ble.getGapState().connected){
                        ble.disconnect(Gap::REMOTE_USER_TERMINATED_CONNECTION);
                    }else{
                        ble.stopAdvertising();
                    }
                }else{
                    weight = io.get_weight_raw() / WEIGHT_COEFFICIENT;
//                    pc.printf("w=%f\r\n", weight);
                    if(weight < 0){
                        weight = 0;
                    }
                    io.display_value = (uint16_t)weight; // dummy display
                    if(++update_counter >= 5){
                        weight_data = quick_ieee11073_from_float(weight);
                        ble.updateCharacteristicValue(WeightMeasurement.getValueAttribute().getHandle(),
                                                                            (uint8_t *)&weight_data,
                                                                            sizeof(weight_data));
                        update_counter = 0;
                    }
                }
            break;
            case MODE_END:
                led_brightness -= BRIGHTNESS_ADDVALUE;
                io.display(led_brightness);
                if(led_brightness <= BRIGHTNESS_MINVALUE){
                    SWInit();
                    led_mode = MODE_OFF;
                }
            break;
        }
        io.analog_pow(0);
    }
}