File content as of revision 36:fb7f31e53ed9:

#include <stdio.h>
#include <math.h>
#include "mbed.h"
#include "ble/BLE.h"
#include "VL53L0X.h"
#include "ble/services/HeartRateService.h"
 
#define range1_addr         (0x56)
#define range2_addr         (0x60)
#define range1_XSHUT        p15
#define range2_XSHUT        p16
#define VL53L0_I2C_SDA      p30 
#define VL53L0_I2C_SCL      p7  
#define TIME_SCALE          3 // sensors activated every 100ms * TIME_SCALE = 0.3 seconds
#define DIST_MIN            0
#define DIST_MAX            22
//#define TIMESTAMP_FREQ      3000 // PROD: time granularity is 100ms * TIMESTAMP_FREQ = 5 minutes
#define TIMESTAMP_FREQ      300 // DEV: time granularity is 100ms * TIMESTAMP_FREQ = 30 seconds
//#define MAX_TIME            1728000 // PROD: keep track of 100ms * MAX_TIME = 2880 minutes = 2 days
#define MAX_TIME            172800 // DEV: keep track of 100ms * MAX_TIME = 288 minutes = 4.8 hours
 
Serial pc(USBTX, USBRX);
static DevI2C devI2c(VL53L0_I2C_SDA, VL53L0_I2C_SCL); 
DigitalOut led1(LED1);
DigitalOut led2(LED2);
DigitalOut led(LED3, 1);
uint16_t customServiceUUID  = 0xA000;
uint16_t readCharUUID       = 0xA001;
uint16_t writeCharUUID      = 0xA002;
 
static DigitalOut shutdown1_pin(range1_XSHUT);
static VL53L0X range1(&devI2c, &shutdown1_pin, NC);
static DigitalOut shutdown2_pin(range2_XSHUT);
static VL53L0X range2(&devI2c, &shutdown2_pin, NC);
 
uint32_t distance1, distance2;
int dist1, dist2, status1, status2;
int timestamp = 0, current_time = 0;

const static int cw = 20 / TIME_SCALE;
const static int time_cycle = TIMESTAMP_FREQ / TIME_SCALE;
const static int maximum_time = MAX_TIME / TIMESTAMP_FREQ;
int countdown = cw;
bool countdown1_triggered = false, countdown2_triggered = false;
bool step_in = false, step_out = false;
bool range1_just_triggered = false, range2_just_triggered = false;
 
const static char     DEVICE_NAME[]        = "OCCUPY-CRICHTON-ST"; 
static const uint16_t uuid16_list[]        = {GattService::UUID_HEART_RATE_SERVICE};
int * encoded_array;
 
HeartRateService         *hrService;
uint8_t hrmCounter = 0; 
int format_dist(int distance) {
   int result;
   if (distance > 2550)
      result = 255;
   else
      result = distance/10;
   return result; 
}

void dec_to_bin(int decimal, int bin[]) {
    int temp;
    // encoding little-endian
    for (int i = 10; i >= 0; i--) {
        temp = decimal >> i;
        bin[i] = temp&1;
    }
}

int bin_to_dec(int binary) {
    int rem, temp, dec = 0, b = 1;
    temp = binary;
    while (temp > 0)
    {
        rem = temp % 10;
        dec = dec + rem * b;
        b *= 2;
        temp /= 10;
    }
    return dec;
}

void encode_bin(int direction, int time, int encoding[]) {
    time = time % maximum_time;
    int bin[11] = {0};
    dec_to_bin(time, bin); 
    
    // for checking transmission errors:
    // sending as 2 messages; designating them with 0 (1st part) and 1`(2nd part)
    encoding [8] = 1;
    encoding [0] = 0;

    // used to send the current time when Bluetooth connection established
    if (direction == -1) {
        encoding[15] = 1;
        encoding[7] = 1;
        
    } else {
        encoding[15] = 0;
        encoding[7] = 0;
        
        // to distinguish whether movement was IN (1) or OUT (0)
        if (direction == 1) {
            encoding[1] = 1;
        } else {
            encoding[1] = 0;
        }
    }
    
    int count = 10;
    for (int i = 14; i >= 2; i--) {
        if (i == 8 || i == 7) { }
        else {
            encoding[i] = bin[count];
            count--;
        }
    }
}

void create_packets(int encoding[], double& packet1, double& packet2) {
    double binary1 = 0, binary2 = 0;
    for (int i = 0; i < 8; i++) {
        binary1 += encoding[i] * pow(10, (double)i);
        binary2 += encoding[8+i] * pow(10, (double)i);
    }
    packet1 = bin_to_dec(binary1);
    packet2 = bin_to_dec(binary2);
}

void send_packet(int direction, int time) {     
    int encoding [16] = {0};
    encode_bin(direction, time, encoding);
    double packet1, packet2;
    create_packets(encoding, packet1, packet2);
    int p1 = (int)packet1;
    int p2 = (int)packet2;
    
    hrmCounter = p1;
    hrService->updateHeartRate(hrmCounter);
    printf("sent packet %i\n", p1);
    hrmCounter = p2;
    hrService->updateHeartRate(hrmCounter);
    printf("sent packet %i\n", p2);
}

void connectionCallback(const Gap::ConnectionCallbackParams_t *) {
    printf("Bluetooth connected at %i\n", current_time);
    send_packet(-1, current_time);
}
 
void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *)
{
    printf("Bluetooth disconnected at %i\n", current_time);
    BLE::Instance(BLE::DEFAULT_INSTANCE).gap().startAdvertising();
}
 
void bleInitComplete(BLE::InitializationCompleteCallbackContext *params)
{
    BLE &ble          = params->ble;
    ble_error_t error = params->error;
    
    if (error != BLE_ERROR_NONE) {
        return;
    }
    
    ble.gap().onConnection(connectionCallback);
    ble.gap().onDisconnection(disconnectionCallback);
    hrService = new HeartRateService(ble, hrmCounter, HeartRateService::LOCATION_FINGER);
 
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
    ble.gap().setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LOCAL_NAME, (uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME));
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_16BIT_SERVICE_IDS, (uint8_t *)uuid16_list, sizeof(uuid16_list));
    ble.gap().setAdvertisingInterval(100);
    ble.gap().accumulateAdvertisingPayload(GapAdvertisingData::GENERIC_HEART_RATE_SENSOR);
 
    ble.gap().startAdvertising();
}
 
void wakeup_event_cb() {

    led != led;
    timestamp++;
    ::current_time = timestamp / time_cycle;
    
    if (countdown1_triggered) {
        countdown--;
        if (countdown == 0) {
            countdown1_triggered = false;
        }
    }
    if (countdown2_triggered) {
        countdown--;
        if (countdown == 0) {
            countdown2_triggered = false;
        }
    }
        
    status1 = range1.get_distance(&distance1);
    status2 = range2.get_distance(&distance2);
    
    dist1 = format_dist(distance1);
    dist2 = format_dist(distance2);
    
    if (status1 == VL53L0X_ERROR_NONE) {
//        printf("Range1 [mm]:            %6ld\r\n", dist1);
        if (dist1 > DIST_MIN && dist1 < DIST_MAX) {
            led1 = 0;
            
            if (!countdown1_triggered && !countdown2_triggered) {
                countdown1_triggered = true;
                countdown = cw;
            } else if (countdown2_triggered && !range1_just_triggered) {
                printf("STEP IN DETECTED\n");
                hrmCounter = 1;
                hrService->updateHeartRate(hrmCounter);
                countdown2_triggered = false;
            }
            
            range1_just_triggered = true;
        }
        else {
            led1 = 1;
            range1_just_triggered = false;
        }
    } else {
//        printf("Range1 [mm]:                --\r\n");
        led1 = 1;
        range2_just_triggered = false;
    }
    if (status2 == VL53L0X_ERROR_NONE) {
//        printf("Range2 [mm]:            %6ld\r\n", dist2);
        if (dist2 > DIST_MIN && dist2 < DIST_MAX) {
            led2 = 0;
            
            if (!countdown1_triggered && !countdown2_triggered) {
                countdown2_triggered = true;
                countdown = cw;
            } else if (countdown1_triggered && !range2_just_triggered) {
                printf("STEP OUT DETECTED\n");
                hrmCounter = 16;
                hrService->updateHeartRate(hrmCounter);
                countdown1_triggered = false;
            }
            
            range2_just_triggered = true;
        }
        else {
            led2 = 1;
            range2_just_triggered = false;
        }
    } else {
//        printf("Range2 [mm]:                --\r\n");
        led2 = 1;
        range2_just_triggered = false;
    }
}
 
int main(void)
{
    range1.init_sensor(range1_addr);
    range2.init_sensor(range2_addr);
    
    BLE& ble = BLE::Instance(BLE::DEFAULT_INSTANCE);
    ble.init(bleInitComplete);
    
    Ticker ticker;
    ticker.attach(wakeup_event_cb, 0.1 * TIME_SCALE);
    
    while (ble.hasInitialized()) {
        ble.waitForEvent(); 
    }
}