File content as of revision 5:1730064b94bd:

#include "mbed.h"
#include "io.h"
#include "BLEDevice.h"

// Advertise
#define INTERVAL_1SEC       (1000UL)
#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        "akita11/GomiHgy" // Manufacturer Name String - shall represent the name of the manufacturer of the device.
#define MODEL_NUMBER_STRING             "Model Number" // Model Number String - shall represent the model number that is assigned by the device vendor.
#define SERIAL_NUMBER_STRING            "Serial Number"  // Serial Number String - shall represent the serial number for a particular instance of the device.
#define HARDWARE_REVISION_STRING        "v1.0.0@151023" // Hardware Revision String - shall represent the hardware revision for the hardware within the device.
#define FIRMWARE_REVISION_STRING        "rev0004:edd6e262de9e" // Firmware Revision String - shall represent the firmware revision for the firmware within the device.
#define SOFTWARE_REVISION_STRING        "v0.1.00.005:151027r1" // Software Revision String - shall represent the software revision for the software within the device.

// Weight Scale Service (Original)
#define UUID_WEIGHT_SCALE_SERVICE       (0x181D)
#define UUID_WEIGHT_MEASUREMENT_CHAR    (0x3A9D)

#ifdef UART_DEBUG
Serial pc(P0_9, P0_8);// TX=P0_9
#define UART_BAUD_RATE   (9600UL)
#endif

/*
Serial pc(P0_9, P0_8);// TX=P0_9
AnalogIn vin(P0_1);

int main()
{
    pc.baud(9600);
    while(1){
        pc.printf("CONFIG=%x\r\n", NRF_ADC->CONFIG); // 0x0000046a 
// EXTREFSEL=00 (none)
// PSEL=00000100 (use AnalogInput2)
// REFSEL=11 (VDD with 1/3 prescale)
// INPSEL=010 (prescale=1/3)
// RES=10 (10bit)
        pc.printf("%f %d\r\n", vin.read(), NRF_ADC->RESULT);
        wait(0.1);
    }
}
*/    

io io;

Ticker tk; // 1s timer for switch check & weighgt measure
float weight;
char weight_str[20];
uint8_t fPow = 0;

BLEDevice ble;
Gap::ConnectionParams_t connectionParams;

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

/* Weight Scale Service */
GattCharacteristic WeightMeasurement(GattCharacteristic::UUID_SERIAL_NUMBER_STRING_CHAR/*UUID_WEIGHT_MEASUREMENT_CHAR*/, (uint8_t *)&weight_str, sizeof(weight_str), sizeof(weight_str), GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_INDICATE);
GattCharacteristic *WMSChars[] = {&WeightMeasurement };
GattService WMS(UUID_WEIGHT_SCALE_SERVICE , WMSChars, sizeof(WMSChars) / 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 HWVersion(GattCharacteristic::UUID_HARDWARE_REVISION_STRING_CHAR, (uint8_t *)&HARDWARE_REVISION_STRING, sizeof(HARDWARE_REVISION_STRING) - 1, sizeof(HARDWARE_REVISION_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 SWVersion(GattCharacteristic::UUID_SOFTWARE_REVISION_STRING_CHAR, (uint8_t *)&SOFTWARE_REVISION_STRING, sizeof(SOFTWARE_REVISION_STRING) - 1, sizeof(SOFTWARE_REVISION_STRING) - 1,
                           GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ);
GattCharacteristic *DISChars[] = {&ManuName, &ModelNum, /*&SerialNum,*/ &HWVersion, &FWVersion, &SWVersion };
GattService        DIS(GattService::UUID_DEVICE_INFORMATION_SERVICE , DISChars, sizeof(DISChars) / sizeof(GattCharacteristic *));

 // 1s timer for switch check & weighgt measure
 void ticker_1s()
{
    io.analog_pow(1); // turn analog power on
    weight = io.get_weight(); // get weight [g]
    sprintf (weight_str, "%0.3f[g]", weight);
    ble.updateCharacteristicValue(WeightMeasurement.getValueAttribute().getHandle(),
                                            (uint8_t *)&weight_str,
                                            sizeof(weight_str));
/*
    // check switch, and control power flag (fPower)
    if (fPow == 0 && io.get_switch() == 1){
        while(io.get_switch() == 1); // wait until switch released
        fPow = 1;
    }
    if (fPow == 1 && io.get_switch() == 1){
        while(io.get_switch() == 1); // wait until switch released
        fPow = 0;
    }
*/

//    io.display_value = (uint16_t)(io.get_weight_raw() * 9999.0); // dummy display
//    io.display_value = (int)(io.get_x() * 9900 + io.get_y() * 99); // test: display joystick XY value
//    io.display_value = (uint16_t)(io.get_x() * 9999.0); // dummy display


    io.analog_pow(0); // turn analog power off
}

/*
 * BLE CallBacks
 */
void BLEConnectionCallback(Gap::Handle_t handle, Gap::addr_type_t type, const Gap::address_t addr,const Gap::ConnectionParams_t *params)
{
    ble.updateConnectionParams(handle, &connectionParams);                       
}

void BLEDisconnectionCallback(Gap::Handle_t handle, Gap::DisconnectionReason_t reason)
{
    ble.startAdvertising();
}

void BLEDataWrittenCallback(const GattCharacteristicWriteCBParams *params)
{
    // Do Nothing.  
}

void BLEDataReadCallback(const GattCharacteristicReadCBParams *params)
{
    // Do Nothing.
}

void BLERadioNotificationCallback(bool radio_active)
{
    if (radio_active == false)
    {
         // Do Nothing.
    }
}

void BleInitialize(void){
    
    // Initialize
    ble.init();
    
    // Event Set
    ble.onConnection(&BLEConnectionCallback);
    ble.onDisconnection(&BLEDisconnectionCallback);
    //ble.onDataWritten(&BLEDataWrittenCallback);
    //ble.onDataRead(&BLEDataReadCallback);
    ble.onRadioNotification(&BLERadioNotificationCallback);
    
    ble.getPreferredConnectionParams(&connectionParams);
    connectionParams.minConnectionInterval = INTERVAL_1SEC;
    connectionParams.maxConnectionInterval = INTERVAL_1SEC;
    ble.setPreferredConnectionParams(&connectionParams);
    
    ble.setTxPower(BLE_TXPOWER_4DBM);
    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_16BIT_SERVICE_IDS,(uint8_t *)uuid16_list, sizeof(uuid16_list));
                               
    ble.setAdvertisingInterval(INTERVAL_1SEC);
    ble.setAdvertisingTimeout(ADV_TIMEOUT); /* 0 is disable the advertising timeout. */
    
    ble.addService(WMS);
    ble.addService(DIS);
}

int main()
{
    BleInitialize();
    
#ifdef UART_DEBUG
    pc.baud(UART_BAUD_RATE);
#endif
    
    tk.attach(&ticker_1s, 0.1);
    
    ble.startAdvertising();
//    io.calibrate_weight(); // initial calibration
    while(1){
        io.display(1);        
        for (int i = 0; i < 50; i++){
            io.display_value = (uint16_t)(io.get_weight() * 9999.0); // dummy display
            wait(0.1);
        }
        io.display(0.3);        
        for (int i = 0; i < 50; i++){
            io.display_value = (int)(io.get_x() * 9900 + io.get_y() * 99); // test: display joystick XY value
            wait(0.1);
        }
//        io.display_value = (uint16_t)(io.get_weight() * 9999.0); // dummy display
//        wait(0.1);
//        for (float i = 0; i < 1.0; i+=0.05){
//            if (i <0.5) io.display(1.0-i);
//            else io.display(i); // change display brightneess
//            wait(0.1);
//            io.display_value = (uint16_t)(io.get_weight() * 9999.0); // dummy display
//        }
    }
}