File content as of revision 11:73c6def38fbd:

#include "mbed.h"
#include "Adafruit_ADS1015.h"
#include "MPU6050.h"
#include "neopixel.h"
#define NLED (11)
#define ONE_COLOR

InterruptIn lock(p16);                                                      // Interrupts for buttons.
InterruptIn reposition(p17);
InterruptIn mute(p15);
InterruptIn new_patient(p14);
//AnalogIn LDR_val(p18);
AnalogIn batteryvoltage(p18);                                               // Analog input between 0 and 1 (0 and 100 %) for reading batteryvoltage from accupack. 
AnalogIn supplyvoltage(p20);                                                // Analog input between 0 and 1 (0 and 100 %) for reading supplyvoltage from measuringpoint before power supply.

PwmOut LED_intern1(LED1);
DigitalOut LED_intern2(LED2);
DigitalOut LED_intern3(LED3);
DigitalOut LED_intern4(LED4);
neopixel::PixelArray array(p11);

Timer hold_timer;
Timer delay;
Timer speaker_timer;

DigitalOut speaker1(p21);
DigitalOut speaker2(p22);

I2C i2c(p28, p27);                  // I2C
MPU6050 agu(p28,p27);               // Accelerometer/Gyroscope Unit
Adafruit_ADS1115 pr1(&i2c, 0x48);   // first PiëzoResistive ADC
Adafruit_ADS1115 pr2(&i2c, 0x49);   // second PiëzoResistive ADC
Adafruit_ADS1115 pel(&i2c, 0x4B);   // PiëzoElectric ADC
Serial pc(USBTX, USBRX); // tx, rx  // Serial USB connection
Serial pi(p9, p10, 115200);         // Setup serial communication for pi.
Timer t;                            // Timer for equally time-spaced samples
Ticker sample_cycle;                // Polling cycle

int cycle_time = 100000;            // Cycle time in us
int i2c_freq = 400000;              // I2C Frequency
int usb_baud = 115200;              // USB Baud rate
short res[8] = {0,0,0,0,0,0,0,0};   // 8 PR sensors 1 time per cycle
short elec[5] = {0,0,0,0,0};        // 1 PE sensor 5 times per cycle
int angle = 0;                      // Accelerometer Z-axis
int k = 0;
float acce[3];                      // Raw accelerometer data
float gyro[3];                      // Raw gyroscope data
char LED_colour;                                                            // Variable to set LED colour.
bool lock_state, lock_flag, mute_state, alarm, calibration_flag, intensity_select;            // Boolean variables for states logging. 
bool mute_flag, new_patient_flag, reposition_flag;
bool speaker_state, LED_red_state, LED_yellow_state, LED_green_state, power_plug_state;
bool speaker_logged, LED_red_logged, LED_yellow_logged, LED_green_logged, power_plug_logged; 
int locktime_ms = 2000;                                                     // Waittime for lock user interface in ms.
int calibrationtime_ms = 5000;                                              // Time to press new_patient button for calibration system. 
int calibration_flash;                                                      // Variable for flash LED's to indicate calibration. 
int buttondelay_ms = 750;                                                   // Button delay in ms.
int delay_lock_interface = 3000*60;                                         // Delay for non using interface locktime.
int speaker_active_ms = 750;                                                // Time to iterate speaker on and off when alarm occurs. 
double alarm_voltage = 0.2;                                                 // Needed voltage for alarm expressed as a percentage (0 - 100 % => 0 - 3.3 V).
int red_var, green_var, blue_var, intensity, current_intensity = 0;         // Variables to set LED intensity.
int batteryvoltage_current = 0, batteryvoltage_last = 0;

void set_intensity()                                                        // Function to set the intensity for the LED's.
{
    if (intensity_select == 1) {
        intensity = 50;
    } else { 
        intensity = 25;
    }
    //intensity = (1-LDR_val)*100;                                          // Calculate intensity (use right part of the graphic).

    //if (abs(intensity-current_intensity) > 5) {                           // If difference is greater then 5, change intensity dependent on range.
    //    if (intensity <= 20) {
    //        intensity = 20;
    //    }

    //    if (40 >= intensity > 20) {
    //        intensity = 40;
    //    }

    //    if (60 >= intensity > 40) {
    //        intensity = 60;
    //    }

    //    if (80 >= intensity > 60) {
    //        intensity = 80;
    //    }

    //    if (intensity > 80) {
    //        intensity = 100;
    //    }
    //}
    // current_intensity = intensity;                                       // Save intensisty to compare in first if statement of this set_intensity function.
}

void serial_read() {                                                        // Serial read for colourselect
    if (pi.readable()) {
        char message[3];
        pi.scanf("%s",message);
        message[strlen(message)] = '\n';
        
        if (message[0] == '0') {
            intensity_select = 0;
        } 
        
        if (message[0] == '1') { 
            intensity_select = 1; 
        } 
        
        if (message[1] == 'g') {
            LED_colour = 'g'; 
        }

        if (message[1] == 'y') {
            LED_colour = 'y'; 
        }
        
        if (message[1] == 'r') {
            LED_colour = 'r'; 
        }
    }
}

void colour_select(char LED_colour)                                         // Function to select the colour.
{
    set_intensity();                                                        // Call function set_intensity

    if (LED_colour == 'r') {
        red_var = (2.55*intensity);
        green_var = 0;
        blue_var = 0;
        LED_red_state = 1; 
    } else {
        LED_red_state = 0;       
    }

    if (LED_colour == 'y') {
        red_var = (2.55*intensity);
        green_var = (2.55*intensity);
        blue_var = 0;        
        LED_yellow_state = 1;
    } else {
        LED_green_state = 0;
    }

    if (LED_colour == 'g') {
        red_var = 0;
        green_var = (2.55*intensity);
        blue_var = 0;
        LED_green_state = 1;        
    } else {
        LED_green_state = 0;
    }

    if (calibration_flash >= 1) {
        if ((calibration_flash % 2) == 0) {
            red_var = 255;
            green_var = 255;
            blue_var = 255;
        } else {
            red_var = 0;
            green_var = 0;
            blue_var = 0;
        }
        calibration_flash--;
    }
}

void trigger_lock()                                                         // If rising edge lock button is detected start locktimer.
{
    hold_timer.start();
    delay.reset();
    delay.start();
}

void timer_lock()                                                           // End timer lock.
{
    lock_flag = 0;                                                          // Set lock_flag off.
    hold_timer.stop();                                                      // Stop and reset holdtimer
    hold_timer.reset();
}

void trigger_reposition()
{
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {             // Control statement for lock interface and delay for non using buttons at the same time.
    } else {
        delay.reset();
        delay.start();

        if (LED_intern1 == 0) {
            LED_intern1 = 1.0;
        } else {
            LED_intern1 = 0.0;
        }

        reposition_flag = 1;
    }
}

void trigger_mute()
{
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {             // Control statement for lock interface and delay for non using buttons at the same time.
        mute_state = 0;
    } else {
        delay.reset();
        delay.start();
        pi.printf("01\n");
        mute_state = !mute_state;

        if (LED_intern1 == 0) {
            LED_intern1 = 1.0;
        } else {
            LED_intern1 = 0.0;
        }
        
        mute_flag = 1;
    }
}

void trigger_new_patient()                                                  // Function to trigger hold timer for new patient calibration function.
{
    if (lock_state == 1) {
    } else {
        hold_timer.start();
        new_patient_flag = 1;
    }
}

void timer_calibration()                                                    // Timer calibration function.
{
    hold_timer.stop();
    hold_timer.reset();
    
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {             // Control statement for lock interface and delay for non using buttons at the same time.
    } else {
        if (calibration_flag == 0) {
            
            if (LED_intern1 == 0) {
                LED_intern1 = 1.0;
            } else {
                LED_intern1 = 0.0;
            }
            
        } else {
            calibration_flag = 0;
        }
    }
}

void generate(neopixel::Pixel * out, uint32_t index, uintptr_t val)         // Generate LED colour.
{
    out->red   = red_var;
    out->green = green_var;
    out->blue  = blue_var;
}

void read_voltage()
{
    LED_intern3 = 0;
    
    if (batteryvoltage.read() > alarm_voltage) {                            // If supplyvoltage (readed from input) is greater then the setted alarmvoltage.
        alarm = 0;                                                          // Alarm is off.
        speaker_state = 0; 
    } else {
        alarm = 1;                                                          // Else alarm is on.
        speaker_state = 1; 
    }
    
    if (alarm == 1 && mute_state == 0 && (speaker_timer.read_ms() < speaker_active_ms)) { // Set speaker on for 750 ms.
        speaker1 = 1;                                                       // Set speaker.
        speaker2 = 1;
        speaker_timer.start();                                              // Set timer for speaker to iterate on and off.
        LED_intern3 = !LED_intern3;
    }

    if (alarm == 1 && mute_state == 1 && (speaker_timer.read_ms() < speaker_active_ms)) { // Set speaker on for 750 ms.
        speaker1 = 0;                                                       // Set speaker.
        speaker2 = 0;
        speaker_timer.start();                                              // Set timer for speaker to iterate on and off.
        LED_intern3 = !LED_intern3;
    }

    if ((speaker_timer.read_ms() > speaker_active_ms) && (speaker_timer.read_ms() < (speaker_active_ms*2))) {
        speaker1 = 0;                                                       // Turn off speaker (use two outputs because of currentlimiting of one).
        speaker2 = 0;
    }

    if (speaker_timer.read_ms() > (speaker_active_ms*2)) {
        speaker_timer.stop();                                               // Stop speaker timer.
        speaker_timer.reset();
    }
    
    batteryvoltage_current = batteryvoltage.read();    
    
    if (supplyvoltage.read() == 0) {
        power_plug_state = 1; 
    } else {
        power_plug_state = 0;   
    }
}

void read_adc()
{
    t.reset();
    t.start();

    elec[0] = pel.readADC_SingleEnded(0);       //First PE readout

    for (k = 0; k < 4; k = k + 1) {
        res[k] =    pr1.readADC_SingleEnded(k); //First 4 PR readout
    }
    while(t.read_us()<(1*(cycle_time/5))) {}    //Wait untill 20% of cycle

    elec[1] = pel.readADC_SingleEnded(0);       //Second PE readout

    for (k = 0; k < 4; k = k + 1) {
        res[k+4] =  pr2.readADC_SingleEnded(k); //Last 4 PR readout
    }
    while(t.read_us()<(2*(cycle_time/5))) {}    //Wait untill 40% of cycle

    elec[2] = pel.readADC_SingleEnded(0);       //Third PE readout

    agu.getAccelero(acce);                      //Get accelerometer data
    angle = acce[2]*10;
    agu.getGyro(gyro);                          //Get gyroscope data

    while(t.read_us()<(3*(cycle_time/5))) {}    //Wait untill 60% of cycle

    elec[3] = pel.readADC_SingleEnded(0);       //Fourth PE readout

    if ((hold_timer.read_ms() > locktime_ms) && lock_flag == 0 && lock == 1) { // If statement for lock function.
        lock_flag = 1;
        LED_intern2 = !LED_intern2;
        lock_state = !lock_state;
    }

    if ((hold_timer.read_ms() > calibrationtime_ms) && calibration_flag == 0 && new_patient == 1) { // If statement for calibration system.
        calibration_flag = 1;
        calibration_flash = 11;
        pi.printf("Calibration button is pressed.");                    // Print statement for serial communication to inform algorithm to calibrate.
    }
    
    if (delay.read_ms() > delay_lock_interface) {                       // If buttons are not pressed for 3 minutes, set lock active.
        lock_state = 1;
        LED_intern2 = 1;
    }

    batteryvoltage_current = batteryvoltage_current*100;
    batteryvoltage_current = batteryvoltage_last;
    read_voltage();                                                     // Supplyvoltage control for alarm.
    
    uint32_t val = 0;
    colour_select(LED_colour);
    array.update(generate, NLED, val);

    while(t.read_us()<(4*(cycle_time/5))) {}    //Wait untill 80% of cycle

    elec[4] = pel.readADC_SingleEnded(0);       //Fifth PE readout

    while(t.read_us()<(4.5*(cycle_time/5))) {}  //Wait untill 90% of cycle
    pi.printf("!,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,\n", res[4], res[7], res[6], res[5], res[1], res[0], res[2], res[3], elec[0], elec[1], elec[2], elec[3], elec[4], acce[0]*100, acce[1]*100, acce[2]*100, gyro[0]*100, gyro[1]*100, gyro[2]*100); // print all to serial port
    //receiving order: 8 resistive sensors, 5 electric readings, 3 accelerometer axes, 3 gyroscope axes
    
    if (mute_flag == 1) {
        pi.printf(">01\n");
        mute_flag = 0;
        LED_intern4 = 1; 
    } else {
        LED_intern4 = 0;
    }
    
    if (new_patient_flag == 1) {
        pi.printf(">02\n");
        new_patient_flag = 0;
    }
    
    if (reposition_flag == 1) {
        pi.printf(">03\n");
        reposition_flag = 0;
    }
        
    if (batteryvoltage_current != batteryvoltage_last) {
        pi.printf("%%d\n", batteryvoltage_current);
    } 
         
    if (LED_red_logged != LED_red_state) {
        if (LED_red_state == 1) {    
            pi.printf("&04\n");
            LED_red_logged = LED_red_state;
        } 
        if (LED_red_state == 0) {
            pi.printf("&40\n");
            LED_red_logged = LED_red_state;            
        }
    }
    
    if (LED_yellow_logged != LED_yellow_state) {
        if (LED_yellow_state == 1) {    
            pi.printf("&06\n");
            LED_yellow_logged = LED_yellow_state;
        } 
        if (LED_yellow_state == 0) {
            pi.printf("&60\n");
            LED_yellow_logged = LED_yellow_state;            
        }
    }
    
    if (LED_green_logged != LED_green_state) {
        if (LED_green_state == 1) {    
            pi.printf("&05\n");
            LED_green_logged = LED_green_state;
        } 
        if (LED_green_state == 0) {
            pi.printf("&50\n");
            LED_green_logged = LED_green_state;            
        }
    }
    
    if (speaker_logged != speaker_state) {
        if (speaker_state == 1) {    
            pi.printf("&07\n");
            speaker_logged = speaker_state;
        } 
        if (speaker_state == 0) {
            pi.printf("&70\n");
            speaker_logged = speaker_state;            
        }
    }

    if (power_plug_logged != power_plug_state) {
        if (power_plug_state == 1) {    
            pi.printf("#08\n");
            power_plug_logged = power_plug_state;
        } 
        if (power_plug_state == 0) {
            pi.printf("#80\n");
            power_plug_logged = power_plug_state;            
        }
    }
}

int main()
{
    i2c.frequency(i2c_freq);
    pc.baud(usb_baud);
    pr1.setGain(GAIN_TWOTHIRDS); // set range to +/-6.144V
    pr2.setGain(GAIN_TWOTHIRDS); // set range to +/-6.144V
    pel.setGain(GAIN_TWOTHIRDS); // set range to +/-6.144V
    pi.format(8, SerialBase::None, 1);

    lock.rise(&trigger_lock);                                               // Interrupt for rising edge lock button.
    lock.fall(&timer_lock);
    reposition.rise(&trigger_reposition);
    mute.rise(&trigger_mute);
    new_patient.rise(&trigger_new_patient);                                 // New patient/calibration button rising event.
    new_patient.fall(&timer_calibration);                                   // Falling edge for calibration algorithm option.
    delay.reset();                                                          // Delaytimer reset en start.
    delay.start();

    sample_cycle.attach_us(&read_adc, cycle_time);

    while (1) {
        wait_us(cycle_time+1); // wait indefinitely because the ticker restarts every 50 ms
    }
}

/*
Author          :   R. Molenaar
Company         :   Momo Medical
Source          :   developer.mbed.org
File            :   main.cpp
Version | -date :   0.1 | 18-9-2017


#include "mbed.h"
#include "pwm_tone.h"
#include "neopixel.h"
#define NLED (11)
#define ONE_COLOR

Serial pi(p9, p10, 9600);                                                   // Setup serial communication.
Serial pc(USBTX, USBRX, 9600);

InterruptIn lock(p16);                                                      // Interrupts for buttons.
InterruptIn reposition(p17);
InterruptIn mute(p15);
InterruptIn new_patient(p14);

AnalogIn LDR_val(p18);
AnalogIn supplyvoltage(p20);                                                // Analog input between 0 and 1 (0 and 100 %) for reading supplyvoltage from accupack.

PwmOut LED_intern1(LED1);
DigitalOut LED_intern2(LED2);
DigitalOut LED_intern3(LED4);

Timer hold_timer;
Timer delay;
Timer speaker_timer;

DigitalOut speaker1(p21);
DigitalOut speaker2(p22);

char LED_colour;                                                            // Variable to set LED colour.
bool lock_state, lock_flag, mute_state, alarm, calibration_flag;            // Boolean variables for states lock, mute and alarm.
int locktime_ms = 2000;                                                     // Waittime in ms.
int calibrationtime_ms = 5000;
int calibration_flash;
int buttondelay_ms = 750;                                                   // Button delay in ms.
int delay_lock_interface = 3000*60;                                         // Delay for non using interface.
int speaker_active_ms = 750;
double alarm_voltage = 0.2;                                                 // Needed voltage for alarm expressed as a percentage (0 - 100 % => 0 - 3.3 V).
int red_var, green_var, blue_var, intensity, current_intensity = 0;         // Variables to set LED intensity

void set_intensity()                                                        // Function to set the intensity for the LED's
{
    intensity = (1-LDR_val)*100;                                            // Calculate intensity (use right part of the graphic)

    if (abs(intensity-current_intensity) > 5) {                             // If difference is greater then 5, change intensity dependent on range.
        if (intensity <= 20) {
            intensity = 20;
        }

        if (40 >= intensity > 20) {
            intensity = 40;
        }

        if (60 >= intensity > 40) {
            intensity = 60;
        }

        if (80 >= intensity > 60) {
            intensity = 80;
        }

        if (intensity > 80) {
            intensity = 100;
        }
    }
    current_intensity = intensity;                                          // Save intensisty to compare in first if statement of this set_intensity function.
}

void colour_select(char LED_colour)                                         // Function to select the colour.
{
    set_intensity();                                                        // Call function set_intensity

    if (LED_colour == 'r') {
        red_var = (2.55*intensity);
        green_var = 0;
        blue_var = 0;
    }

    if (LED_colour == 'y') {
        red_var = (2.55*intensity);
        green_var = (2.55*intensity);
        blue_var = 0;
    }

    if (LED_colour == 'g') {
        red_var = 0;
        green_var = (2.55*intensity);
        blue_var = 0;
    }

    if (calibration_flash >= 1) {
        if((calibration_flash % 2) == 0) {
            red_var = 255;
            green_var = 255;
            blue_var = 255;
        } else {
            red_var = 0;
            green_var = 0;
            blue_var = 0;
        }
        calibration_flash--;
    }
}


void trigger_lock()                                                         // If rising edge lock button is detected start locktimer.
{
    hold_timer.start();
    delay.reset();
    delay.start();
}

void timer_lock()                                                           // End timer lock.
{
    lock_flag = 0;                                                          // Set lock_flag off.
    hold_timer.stop();                                                      // Stop and reset holdtimer
    hold_timer.reset();
}

void trigger_reposition()
{
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {             // Control statement for lock interface and delay for non using buttons at the same time.
    } else {
        delay.reset();
        delay.start();
        pi.printf("02\n");                                                  // Seriele communicatie met PI.

        if (LED_intern1 == 0) {
            LED_intern1 = 1.0;
        } else {
            LED_intern1 = 0.0;
        }

        LED_colour = 'r';
    }
}

void trigger_mute()
{
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {             // Control statement for lock interface and delay for non using buttons at the same time.
        mute_state = 0;
    } else {
        delay.reset();
        delay.start();
        pi.printf("01\n");
        mute_state = !mute_state;

        if (LED_intern1 == 0) {
            LED_intern1 = 1.0;
        } else {
            LED_intern1 = 0.0;
        }

        LED_colour = 'y';
    }
}

void trigger_new_patient()                                                  // Function to trigger hold timer for new patient calibration function.
{
    if (lock_state == 1) {
    } else {
        hold_timer.start();
    }
}

void timer_calibration()                                                    // Timer calibration function.
{
    hold_timer.stop();
    hold_timer.reset();
    if (lock_state == 1 | (delay.read_ms() < buttondelay_ms)) {              // Control statement for lock interface and delay for non using buttons at the same time.
    } else {
        if (calibration_flag == 0) {
            pi.printf("03\n");


            if (LED_intern1 == 0) {
                LED_intern1 = 1.0;
            } else {
                LED_intern1 = 0.0;
            }

            LED_colour = 'g';
        } else {
            calibration_flag = 0;
        }
    }
}

void generate(neopixel::Pixel * out, uint32_t index, uintptr_t val)         // Generate LED colour.
{
    out->red   = red_var;
    out->green = green_var;
    out->blue  = blue_var;
}

void read_voltage()
{
    LED_intern3 = 0;

    if (supplyvoltage.read() > alarm_voltage) {                             // If supplyvoltage (readed from input) is greater then the setted alarmvoltage.
        alarm = 0;                                                          // Alarm is off.
    } else {
        alarm = 1;                                                          // Else alarm is on.
    }

    if (alarm == 1 && mute_state == 0 && (speaker_timer.read_ms() < speaker_active_ms)) { // Set speaker on for 750 ms.
        speaker1 = 1;                                                       // Set speaker.
        speaker2 = 1;
        speaker_timer.start();                                              // Set timer for speaker to iterate on and off.
        LED_intern3 = !LED_intern3;
    }

    if (alarm == 1 && mute_state == 1 && (speaker_timer.read_ms() < speaker_active_ms)) { // Set speaker on for 750 ms.
        speaker1 = 0;                                                       // Set speaker.
        speaker2 = 0;
        speaker_timer.start();                                              // Set timer for speaker to iterate on and off.
        LED_intern3 = !LED_intern3;
    }

    if ((speaker_timer.read_ms() > speaker_active_ms) && (speaker_timer.read_ms() < (speaker_active_ms*2))) {
        speaker1 = 0;                                                       // Turn off speaker (use two outputs because of currentlimiting of one).
        speaker2 = 0;
    }

    if (speaker_timer.read_ms() > (speaker_active_ms*2)) {
        speaker_timer.stop();                                               // Stop speaker timer.
        speaker_timer.reset();
    }
}

int main()
{
    pi.format(8, SerialBase::None, 1);

    lock.rise(&trigger_lock);                                               // Interrupt for rising edge lock button.
    lock.fall(&timer_lock);
    reposition.rise(&trigger_reposition);
    mute.rise(&trigger_mute);
    new_patient.rise(&trigger_new_patient);                                 // New patient/calibration button rising event.
    new_patient.fall(&timer_calibration);                                   // Falling edge for calibration algorithm option.
    delay.reset();                                                          // Delaytimer reset en start.
    delay.start();

    neopixel::PixelArray array(p11);

    while(1) {
        wait_ms(100);                                                       // Simulate 100 ms delay from sensorplate code.

        if ((hold_timer.read_ms() > locktime_ms) && lock_flag == 0 && lock == 1) { // If statement for lock function.
            lock_flag = 1;
            LED_intern2 = !LED_intern2;
            lock_state = !lock_state;
        }

        if ((hold_timer.read_ms() > calibrationtime_ms) && calibration_flag == 0 && new_patient == 1) { // If statement for calibration system.
            calibration_flag = 1;
            calibration_flash = 11;
            pi.printf("Calibration button is pressed.");                    // Print statement for serial communication to inform algorithm to calibrate.

        if (delay.read_ms() > delay_lock_interface) {                       // If buttons are not pressed for 3 minutes, set lock active.
            lock_state = 1;
            LED_intern2 = 1;
        }

        read_voltage();                                                     // Supplyvoltage control for alarm.

        uint32_t val = 0;
        colour_select(LED_colour);
        array.update(generate, NLED, val);
    }

}*/