Momo-Medical / Nucleo-transfer

Nucleo-transfer

Dependencies:   ADS1015 MPU6050 PixelArray PixelArray-Nucleo mbed WS2813

Fork of Nucleo-transfer by Momo Medical

Sensorplate/main.cpp@72:9d9846baf590, 2018-07-03 (annotated)

Committer:
deldering95
Date:
Tue Jul 03 17:26:08 2018 +0000
Revision:
72:9d9846baf590
Parent:
71:040674ed2ce1 
Watchdog added for unexpected crashes to be handled

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ricardo_95 36:d10f368d037b 1 /********************* CODE INFORMATON ******************************
ricardo_95 34:1614f4f2b841 2 Date of creation: 30-09-2017
ricardo_95 34:1614f4f2b841 3 Authors: Danny Eldering & Ricardo Molenaar
Ishy 60:2f7e82c6f916 4 co-authors: Menno Gravemaker & Ishvara Lalta
ricardo_95 34:1614f4f2b841 5 (c) Copyright by Momo Medical BV.
ricardo_95 34:1614f4f2b841 6
ricardo_95 45:7ebe860702b4 7 Current version name: 2.1.4
ricardo_95 45:7ebe860702b4 8 Date of modification: 8-1-2018
ricardo_95 36:d10f368d037b 9 Purpose of this file: Code for LPC1768 microcontroller for controlling buttons, LED's and communicate to PI
ricardo_95 45:7ebe860702b4 10 Update ‘what’s new in this version?’: Sensorplate connection test changed from software to hardware check.
deldering95 48:aca02ef5cd01 11 ADC readout for accu deleted.
ricardo_95 36:d10f368d037b 12 Todo: -> Fix LED issue (yellow and red flashes at random moments);
deldering95 43:d09814c177a0 13 -> Optimize functions / improve readability;
ricardo_95 36:d10f368d037b 14 -> Split functions in seperate files?;
ricardo_95 36:d10f368d037b 15 -> Fix when sensorplate is not connected;
ricardo_95 36:d10f368d037b 16 -> Rule 570: if statement change to turn off LED's when power is plugged out (also related to rule 106).
ricardo_95 36:d10f368d037b 17 -> For the speaker two outputs of the uC are used. Add MOSFET with external supply and control these by uC?
ricardo_95 36:d10f368d037b 18 Source file: http://mbed.com/
ricardo_95 33:df21cb8dc5c7 19
ricardo_95 36:d10f368d037b 20 Information files:
deldering95 43:d09814c177a0 21 (1) Flowchart:
ricardo_95 36:d10f368d037b 22 (2) Table serial communication: https://docs.google.com/spreadsheets/d/1kHlithHxtoMDGvbcdH8vwSw5W5ArxlwDPsyfra1dtQM/edit?usp=drive_web
deldering95 43:d09814c177a0 23 (3) Technical manual CU-/software:
ricardo_95 12:7b3a5940f911 24 */
ricardo_95 12:7b3a5940f911 25
ricardo_95 21:13e4824bc364 26 /************************ CONFIG ***********************************/
ricardo_95 21:13e4824bc364 27
ricardo_95 36:d10f368d037b 28 #include "mbed.h" // Include files and define parameters.
DEldering 0:c0e44c46c573 29 #include "Adafruit_ADS1015.h"
DEldering 0:c0e44c46c573 30 #include "MPU6050.h"
ricardo_95 33:df21cb8dc5c7 31 #include "MPU6050_belt.h"
deldering95 43:d09814c177a0 32 #include "PixelArray.h"
deldering95 43:d09814c177a0 33 #include "WS2812.h"
deldering95 71:040674ed2ce1 34 #include "Watchdog.h"
ricardo_95 37:d8f7b2b5719a 35
deldering95 66:88c910cd4d9e 36 #define ALARMBUF 16
deldering95 66:88c910cd4d9e 37 #define NUM_COLORS 8
deldering95 68:1663f305ac33 38 #define YELLOW_TRANSITION 13
deldering95 68:1663f305ac33 39 #define RED_TRANSITION 16
deldering95 43:d09814c177a0 40 #define NUM_LEDS_PER_COLOR 3
deldering95 48:aca02ef5cd01 41 #define NUMBER_LED_FRONT (3)
ricardo_95 7:dba5091c8b7d 42 #define ONE_COLOR
deldering95 66:88c910cd4d9e 43 #define TAIL_LENGTH 6
deldering95 66:88c910cd4d9e 44 #define COMET_TAIL_END_INTENSITY 90
deldering95 66:88c910cd4d9e 45 #define FADE_STEPS 20
ricardo_95 7:dba5091c8b7d 46
deldering95 71:040674ed2ce1 47 Watchdog woofwoof;
deldering95 71:040674ed2ce1 48
deldering95 66:88c910cd4d9e 49 InterruptIn button_lock(PC_0); // Input on intterupt base decleration.
deldering95 68:1663f305ac33 50 InterruptIn button_reposition(PC_1);
Ishy 41:5380ada94ec6 51 InterruptIn button_mute(PC_2);
deldering95 68:1663f305ac33 52 InterruptIn button_new_patient(PC_3);
ricardo_95 7:dba5091c8b7d 53
deldering95 43:d09814c177a0 54 DigitalIn intensity_code(PA_12);
deldering95 43:d09814c177a0 55 DigitalIn colour_code_1(PA_11);
deldering95 43:d09814c177a0 56 DigitalIn colour_code_0(PB_12);
deldering95 57:fac732476810 57 InterruptIn testpin_sensorplate(PC_6);
deldering95 43:d09814c177a0 58
deldering95 43:d09814c177a0 59 DigitalOut LED_on_dev_board1(LED1); // Decleration of digital outputs.
ricardo_95 36:d10f368d037b 60 DigitalOut LED_on_dev_board2(LED2);
ricardo_95 36:d10f368d037b 61 DigitalOut LED_on_dev_board3(LED3);
ricardo_95 36:d10f368d037b 62 DigitalOut LED_on_dev_board4(LED4);
deldering95 43:d09814c177a0 63 DigitalOut speaker1(PC_12); // relatie aangeven!
deldering95 43:d09814c177a0 64 //neopixel::PixelArray indicator_LEDs(PA_7);
deldering95 66:88c910cd4d9e 65 PixelArray px(ALARMBUF);
deldering95 66:88c910cd4d9e 66 //WS2812 ws(PA_7, ALARMBUF, 3, 9, 9, 6);
deldering95 66:88c910cd4d9e 67 WS2812 ws(PA_7, ALARMBUF, 3, 12, 8, 12);
deldering95 43:d09814c177a0 68
deldering95 51:69087c44e8ac 69 PwmOut lock_feedback_LED(PB_13); //(PB_1); // Declaration of pulse with modulation outputs.
deldering95 51:69087c44e8ac 70 PwmOut mute_feedback_LED(PB_14); //(PB_15);
deldering95 51:69087c44e8ac 71 PwmOut new_patient_feedback_LED(PB_15); //(PB_14);
deldering95 51:69087c44e8ac 72 PwmOut reposition_feedback_LED(PB_1); //(PB_13);
ricardo_95 36:d10f368d037b 73
ricardo_95 37:d8f7b2b5719a 74 Timer button_lock_hold_timer; // Timer for time lock button should be pressed.
ricardo_95 36:d10f368d037b 75 Timer button_calibration_hold_timer; // Timer for calibration function (new patient holding 5 seconds).
deldering95 43:d09814c177a0 76 Timer delay_between_button_pressed; // Timer for time between two buttons (to prevent pressing buttons simultaneously).
ricardo_95 36:d10f368d037b 77 Timer speaker_timer; // Timer for speaker activation.
ricardo_95 36:d10f368d037b 78 Timer piezo_electric_sample_timer; // Timer for equally time-spaced samples.
deldering95 66:88c910cd4d9e 79 Timer comet_timer;
deldering95 66:88c910cd4d9e 80 Timer reposition_button_hold_timer;
deldering95 66:88c910cd4d9e 81 Timer new_patient_button_hold_timer;
deldering95 43:d09814c177a0 82 /*
ricardo_95 36:d10f368d037b 83 The code underneath this commentbox has some fixed parameters for serial/ADC reading:
ricardo_95 36:d10f368d037b 84 -> The address for the angle_device_reference_belt is set to 0x68 in the file MPU6050_belt (rule number: 19);
ricardo_95 36:d10f368d037b 85 -> The adress for the angle_device_sensorplate is set to 0x69 in the file MPU6050.h (rule number: 19);
ricardo_95 36:d10f368d037b 86 -> This is because of using the same I2C line;
ricardo_95 36:d10f368d037b 87 -> For detailed information/questions about this item, please read the technical manual or contact: Ricardo Molenaar | ricardo.molenaar@gmail.com
ricardo_95 36:d10f368d037b 88 */
Ishy 41:5380ada94ec6 89 I2C i2c_sensorplate_adc(PB_9, PB_8); // I2C for sensorplate.
ricardo_95 46:a0e6e088a50a 90 MPU6050_belt angle_device_sensorplate(PB_9, PB_8); // i2c pins // i2c address hardcoded 0x68.
deldering95 68:1663f305ac33 91 MPU6050 angle_device_reference_belt(PB_9, PB_8); // i2c pins // i2c address hardcoded 0x69.
ricardo_95 36:d10f368d037b 92 Adafruit_ADS1115 piezo_resistive_adc1(&i2c_sensorplate_adc, 0x48); // i2c pins, i2c address.
ricardo_95 36:d10f368d037b 93 Adafruit_ADS1115 piezo_resistive_adc2(&i2c_sensorplate_adc, 0x49); // i2c pins, i2c address.
ricardo_95 36:d10f368d037b 94 Adafruit_ADS1115 piezo_electric_adc(&i2c_sensorplate_adc, 0x4B); // i2c pins, i2c address.
deldering95 66:88c910cd4d9e 95 RawSerial usb_serial(SERIAL_TX, SERIAL_RX); // tx, rx
deldering95 66:88c910cd4d9e 96 RawSerial pi_serial(PC_10, PC_11); // tx, rx
ricardo_95 36:d10f368d037b 97 Ticker total_readout_cycle; // Polling cycle.
deldering95 43:d09814c177a0 98 // End of commentbox related to the serial configuration/ADC reading components.
ricardo_95 34:1614f4f2b841 99
ricardo_95 12:7b3a5940f911 100 int boot_delay_ms = 500;
Ishy 42:673ddef4cfa4 101 int total_readout_cycle_time_us = 100000; // Cycle time in us.
deldering95 66:88c910cd4d9e 102 int total_comet_cycle_time_ms = 750/16;
deldering95 71:040674ed2ce1 103 int i2c__frequency = 100000; // I2C Frequency.
ricardo_95 36:d10f368d037b 104 int baud_rate = 115200; // Baud rate.
deldering95 68:1663f305ac33 105 int uart_input_buffer[120];
deldering95 68:1663f305ac33 106 int buffer_counter = 0;
ricardo_95 36:d10f368d037b 107 short piezo_resistive_array[8] = {0,0,0,0,0,0,0,0}; // 8 PR sensors 1 time per cycle.
deldering95 58:8cfa736d8553 108 short piezo_electric_array[6] = {0,0,0,0,0,0}; // 1 PE sensor 5 times per cycle.
ricardo_95 36:d10f368d037b 109 int angle = 0; // Accelerometer Z-axis.
ricardo_95 37:d8f7b2b5719a 110 float accelerometer_sensorplate[3] = {0.0, 0.0, 0.0}; // Raw accelerometer data.
ricardo_95 36:d10f368d037b 111 float gyroscope_sensorplate[3]; // Raw gyroscope data.
ricardo_95 36:d10f368d037b 112 float accelerometer_reference_belt[3]; // Raw accelerometer data from belt.
ricardo_95 36:d10f368d037b 113 float gyroscope_reference_belt[3]; // Raw gyroscope data from belt.
deldering95 66:88c910cd4d9e 114 int colourbuf[NUM_COLORS] = {0xff0000,0x00ff00,0x0000ff,0xffa500,0x555555,0x800080,0x000000,0x8B4513}; // hex codes for the different colours
deldering95 44:dcbde3175a37 115 char LED_colour = 'w'; // Variable to set LED colour (standard set to green, untill PI sends other character). Other possible colours: red ('r') & yellow ('y').
ricardo_95 37:d8f7b2b5719a 116 bool lock_state = false, lock_flag = 0, mute_state = 0, alarm = 0, calibration_flag = 0, intensity_select = 1; // Boolean variables for logging states.
Ishy 55:b74e7076d7a0 117 bool mute_flag = 0, new_patient_flag = 0, reposition_flag = 0, new_patient_lock_flag = 0, reposition_lock_flag = 0, mute_lock_flag; // Flag variables.
ricardo_95 21:13e4824bc364 118 bool speaker_state = 0, LED_red_state = 0, LED_yellow_state = 0, LED_green_state = 0, power_plug_state = 0;
Ishy 55:b74e7076d7a0 119 bool auto_lock_led_logged = 0, lock_is_logged = 0, speaker_logged = 0, LED_red_logged = 0, LED_yellow_logged = 0, LED_green_logged = 0, power_plug_logged = 0; // is toevoegen
ricardo_95 36:d10f368d037b 120 int locktime_ms = 2000; // Waittime for lock user interface in ms.
deldering95 48:aca02ef5cd01 121 int calibrationtime_ms = 2000; // Time to press new_patient button for calibration system.
ricardo_95 37:d8f7b2b5719a 122 int calibration_flash = 0; // Variable for flash LED's to indicate calibration.
deldering95 48:aca02ef5cd01 123 int lock_flash = 0;
Ishy 55:b74e7076d7a0 124 int buttondelay_ms = 250; // Button delay in ms. Default: 750
ricardo_95 36:d10f368d037b 125 int delay_lock_interface = 3000*60; // Delay for non using interface locktime.
ricardo_95 36:d10f368d037b 126 int speaker_active_ms = 750; // Time to iterate speaker on and off when alarm occurs.
ricardo_95 38:764847892afc 127 int alarm_voltage = 2400; // Needed voltage for alarm expressed as a digital 15 bit value (= 20% of max battery voltage).
ricardo_95 37:d8f7b2b5719a 128 int LED_red_intensity = 0, LED_blue_intensity = 0, LED_green_intensity = 0; // Variables to set LED intensity.
deldering95 66:88c910cd4d9e 129 int LED_colour_wheel_percentage=0;
deldering95 66:88c910cd4d9e 130 int ring_colour_old,mixer=0;
deldering95 66:88c910cd4d9e 131 int colour_wheel_filler = 5;
deldering95 68:1663f305ac33 132 int patient_present=4;
deldering95 68:1663f305ac33 133 int patient_present_old=4;
deldering95 66:88c910cd4d9e 134 bool colour_wheel_drain_reposition = false;
deldering95 66:88c910cd4d9e 135 bool colour_wheel_drain_new_patient = false;
deldering95 66:88c910cd4d9e 136 bool circle_filling_reposition = false;
deldering95 66:88c910cd4d9e 137 bool circle_filling_new_patient = false;
deldering95 66:88c910cd4d9e 138 int circle_filled_reposition = 0;
deldering95 66:88c910cd4d9e 139 int circle_filled_new_patient = 0;
deldering95 66:88c910cd4d9e 140 int comet=0;
deldering95 66:88c910cd4d9e 141 int tail,tail_step;
ricardo_95 45:7ebe860702b4 142 //short batteryvoltage_current = 0, batteryvoltage_last = 0, powervoltage_current, powervoltage_last; // Variables to manage batteryvoltage. Maybe change current to other?
ricardo_95 45:7ebe860702b4 143 //const int digital_value_ADC_powervoltage_unplugged = 15000; // Digital value to set the indicating LEDs to wall blue (should be set off later). const in hoofdletters
deldering95 68:1663f305ac33 144 int intensity_day = 30, intensity_night = 15; // Intensity settings for LED's to wall.
ricardo_95 38:764847892afc 145 double intensity = 0.0, control_LED_intensity = 0.0; // Variable between 0 and 1 to set the intensity of the LED's above the buttons. Intensity change to smart name!
deldering95 44:dcbde3175a37 146 int colour_code = 0b00;
deldering95 44:dcbde3175a37 147 bool pi_active = false;
deldering95 68:1663f305ac33 148 bool i2c_error=false;
ricardo_95 33:df21cb8dc5c7 149 /*************************** TEST ********************************/
ricardo_95 36:d10f368d037b 150 // Verify algoritm function: for belt activation, set test_belt 1 (connect pin p20 to 3.3V).
deldering95 43:d09814c177a0 151 Timer test_timer;
Ishy 41:5380ada94ec6 152 DigitalIn test_pin(PA_11, PullDown);
ricardo_95 33:df21cb8dc5c7 153
deldering95 67:1b300aa30923 154 float percentage_tester=0;
deldering95 67:1b300aa30923 155
deldering95 43:d09814c177a0 156 // Variable to set if belt is used to test algorithm:
deldering95 71:040674ed2ce1 157 bool test_belt = 1;
ricardo_95 33:df21cb8dc5c7 158
deldering95 43:d09814c177a0 159 // Set test mode on (log functions to pc serial: interrupts, LED intensity and serial messages):
deldering95 68:1663f305ac33 160 bool test_mode = 0;
ricardo_95 34:1614f4f2b841 161
ricardo_95 36:d10f368d037b 162 // Variable for connection test (should be changed):
ricardo_95 46:a0e6e088a50a 163 bool connection_test_sensorplate;
ricardo_95 33:df21cb8dc5c7 164
ricardo_95 21:13e4824bc364 165 /*************************** CODE ********************************/
ricardo_95 7:dba5091c8b7d 166
ricardo_95 36:d10f368d037b 167 void set_intensity_LEDs() // Function to set the intensity for the LED's.
ricardo_95 7:dba5091c8b7d 168 {
ricardo_95 11:73c6def38fbd 169 if (intensity_select == 1) {
ricardo_95 12:7b3a5940f911 170 intensity = intensity_day;
ricardo_95 12:7b3a5940f911 171 } else {
ricardo_95 12:7b3a5940f911 172 intensity = intensity_night;
ricardo_95 7:dba5091c8b7d 173 }
ricardo_95 21:13e4824bc364 174 control_LED_intensity = (intensity/100);
ricardo_95 34:1614f4f2b841 175
ricardo_95 37:d8f7b2b5719a 176 if (test_mode == 1) { // If statement for test purposal LED_intensity values. if def gebruiken voor testmode
Ishy 55:b74e7076d7a0 177 // usb_serial.printf("Intensity LED's shines to wall = %f\n", intensity);
Ishy 55:b74e7076d7a0 178 // usb_serial.printf("Intensity LED's above buttons = %f\n", control_LED_intensity);
ricardo_95 33:df21cb8dc5c7 179 }
ricardo_95 7:dba5091c8b7d 180 }
ricardo_95 7:dba5091c8b7d 181
ricardo_95 36:d10f368d037b 182 void serial_read() // Function for serial read for select LED intensity and colour.
ricardo_95 12:7b3a5940f911 183 {
deldering95 68:1663f305ac33 184 mute_feedback_LED=1;
deldering95 68:1663f305ac33 185 if(pi_serial.readable()) {
deldering95 68:1663f305ac33 186 uart_input_buffer[buffer_counter] = pi_serial.getc();
deldering95 68:1663f305ac33 187 buffer_counter++;
deldering95 68:1663f305ac33 188 }
deldering95 68:1663f305ac33 189 mute_feedback_LED=0;
ricardo_95 11:73c6def38fbd 190 }
ricardo_95 11:73c6def38fbd 191
deldering95 58:8cfa736d8553 192 void serial_log() // Function for serial logging. See link to table with code declarations above in code.
deldering95 58:8cfa736d8553 193 {
Ishy 55:b74e7076d7a0 194
Ishy 55:b74e7076d7a0 195 if (reposition_flag == 1) { // If statement to control logging for reposition button.
ricardo_95 36:d10f368d037b 196 pi_serial.printf(">01\n");
ricardo_95 34:1614f4f2b841 197
deldering95 43:d09814c177a0 198 if (test_mode == 1) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 199 usb_serial.printf(">01\n");
ricardo_95 33:df21cb8dc5c7 200 }
ricardo_95 34:1614f4f2b841 201
Ishy 55:b74e7076d7a0 202 reposition_flag = 0;
Ishy 55:b74e7076d7a0 203 }
deldering95 58:8cfa736d8553 204
Ishy 55:b74e7076d7a0 205 if (reposition_lock_flag == 1) { // If statement to control logging for reposition button.
Ishy 55:b74e7076d7a0 206 pi_serial.printf(">10\n");
Ishy 55:b74e7076d7a0 207
Ishy 55:b74e7076d7a0 208 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 209 usb_serial.printf(">10\n");
Ishy 55:b74e7076d7a0 210 }
Ishy 55:b74e7076d7a0 211
Ishy 55:b74e7076d7a0 212 reposition_lock_flag = 0;
ricardo_95 19:3b5999fa7b7e 213 }
ricardo_95 12:7b3a5940f911 214
ricardo_95 36:d10f368d037b 215 if (new_patient_flag == 1) { // If statement to control logging for new patient button.
Ishy 55:b74e7076d7a0 216 pi_serial.printf(">02\n");
Ishy 55:b74e7076d7a0 217
Ishy 55:b74e7076d7a0 218 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 219 usb_serial.printf(">02\n");
Ishy 55:b74e7076d7a0 220 }
Ishy 55:b74e7076d7a0 221
Ishy 55:b74e7076d7a0 222 new_patient_flag = 0;
Ishy 55:b74e7076d7a0 223 }
deldering95 58:8cfa736d8553 224
Ishy 55:b74e7076d7a0 225 if (new_patient_lock_flag == 1) { // If statement to control logging for new patient button.
Ishy 55:b74e7076d7a0 226 pi_serial.printf(">20\n");
Ishy 55:b74e7076d7a0 227
Ishy 55:b74e7076d7a0 228 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 229 usb_serial.printf(">20\n");
Ishy 55:b74e7076d7a0 230 }
Ishy 55:b74e7076d7a0 231
Ishy 55:b74e7076d7a0 232 new_patient_lock_flag = 0;
Ishy 55:b74e7076d7a0 233 }
Ishy 55:b74e7076d7a0 234 // The new calibration button trigger
Ishy 55:b74e7076d7a0 235 if (mute_flag == 1) { // If statement to control logging for new patient button.
ricardo_95 36:d10f368d037b 236 pi_serial.printf(">03\n");
ricardo_95 34:1614f4f2b841 237
deldering95 43:d09814c177a0 238 if (test_mode == 1) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 239 usb_serial.printf(">03\n");
ricardo_95 33:df21cb8dc5c7 240 }
ricardo_95 34:1614f4f2b841 241
Ishy 55:b74e7076d7a0 242 mute_flag = 0;
ricardo_95 7:dba5091c8b7d 243 }
Ishy 55:b74e7076d7a0 244 // The new calibration button trigger
Ishy 55:b74e7076d7a0 245 if (mute_lock_flag == 1) { // If statement to control logging for new patient button.
Ishy 55:b74e7076d7a0 246 pi_serial.printf(">30\n");
ricardo_95 34:1614f4f2b841 247
deldering95 43:d09814c177a0 248 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 249 usb_serial.printf(">30\n");
ricardo_95 33:df21cb8dc5c7 250 }
ricardo_95 34:1614f4f2b841 251
Ishy 55:b74e7076d7a0 252 mute_lock_flag = 0;
Ishy 55:b74e7076d7a0 253 }
deldering95 58:8cfa736d8553 254
Ishy 55:b74e7076d7a0 255 if (lock_flag == 1 && !lock_is_logged) {
Ishy 55:b74e7076d7a0 256 if (lock_state == 0) // If statement to control logging for lock button.
Ishy 55:b74e7076d7a0 257 pi_serial.printf(">04\n");
Ishy 55:b74e7076d7a0 258 else if(lock_state == 1)
Ishy 55:b74e7076d7a0 259 pi_serial.printf(">40\n");
Ishy 55:b74e7076d7a0 260
Ishy 55:b74e7076d7a0 261 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 262 if (lock_state == 0) // If statement to control logging for lock button.
Ishy 55:b74e7076d7a0 263 usb_serial.printf(">04\n");
Ishy 55:b74e7076d7a0 264 else if(lock_state == 1)
Ishy 55:b74e7076d7a0 265 usb_serial.printf(">40\n"); // If statement for test purposal.
Ishy 55:b74e7076d7a0 266 }
Ishy 55:b74e7076d7a0 267 lock_is_logged = 1;
ricardo_95 7:dba5091c8b7d 268 }
ricardo_95 12:7b3a5940f911 269
ricardo_95 36:d10f368d037b 270 if (LED_red_logged != LED_red_state) { // If statement to control logging for LED_red.
ricardo_95 12:7b3a5940f911 271 if (LED_red_state == 1) {
Ishy 55:b74e7076d7a0 272 pi_serial.printf("&01\n");
ricardo_95 9:514a44bf510f 273 LED_red_logged = LED_red_state;
ricardo_95 34:1614f4f2b841 274 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 275 usb_serial.printf("&01\n");
ricardo_95 34:1614f4f2b841 276 }
ricardo_95 12:7b3a5940f911 277 }
deldering95 43:d09814c177a0 278
ricardo_95 9:514a44bf510f 279 if (LED_red_state == 0) {
Ishy 55:b74e7076d7a0 280 pi_serial.printf("&10\n");
ricardo_95 12:7b3a5940f911 281 LED_red_logged = LED_red_state;
ricardo_95 34:1614f4f2b841 282 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 283 usb_serial.printf("&10\n");
ricardo_95 34:1614f4f2b841 284 }
ricardo_95 9:514a44bf510f 285 }
ricardo_95 8:bf0f7a6fb1fd 286 }
ricardo_95 12:7b3a5940f911 287
ricardo_95 36:d10f368d037b 288 if (LED_yellow_logged != LED_yellow_state) { // If statement to control logging for LED_yellow.
deldering95 43:d09814c177a0 289 if (LED_yellow_state == 1) {
Ishy 55:b74e7076d7a0 290 pi_serial.printf("&02\n");
ricardo_95 9:514a44bf510f 291 LED_yellow_logged = LED_yellow_state;
ricardo_95 34:1614f4f2b841 292 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 293 usb_serial.printf("&02\n");
ricardo_95 34:1614f4f2b841 294 }
ricardo_95 12:7b3a5940f911 295 }
ricardo_95 9:514a44bf510f 296 if (LED_yellow_state == 0) {
Ishy 55:b74e7076d7a0 297 pi_serial.printf("&20\n");
ricardo_95 12:7b3a5940f911 298 LED_yellow_logged = LED_yellow_state;
ricardo_95 34:1614f4f2b841 299 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 300 usb_serial.printf("&20\n");
ricardo_95 34:1614f4f2b841 301 }
ricardo_95 9:514a44bf510f 302 }
ricardo_95 7:dba5091c8b7d 303 }
ricardo_95 12:7b3a5940f911 304
ricardo_95 36:d10f368d037b 305 if (LED_green_logged != LED_green_state) { // If statement to control logging for LED_green.
ricardo_95 12:7b3a5940f911 306 if (LED_green_state == 1) {
Ishy 55:b74e7076d7a0 307 pi_serial.printf("&03\n");
ricardo_95 9:514a44bf510f 308 LED_green_logged = LED_green_state;
deldering95 43:d09814c177a0 309
ricardo_95 34:1614f4f2b841 310 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 311 usb_serial.printf("&03\n");
ricardo_95 34:1614f4f2b841 312 }
ricardo_95 12:7b3a5940f911 313 }
deldering95 43:d09814c177a0 314
ricardo_95 9:514a44bf510f 315 if (LED_green_state == 0) {
Ishy 55:b74e7076d7a0 316 pi_serial.printf("&30\n");
ricardo_95 12:7b3a5940f911 317 LED_green_logged = LED_green_state;
deldering95 43:d09814c177a0 318
ricardo_95 34:1614f4f2b841 319 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 320 usb_serial.printf("&30\n");
ricardo_95 34:1614f4f2b841 321 }
ricardo_95 9:514a44bf510f 322 }
ricardo_95 7:dba5091c8b7d 323 }
ricardo_95 12:7b3a5940f911 324
deldering95 43:d09814c177a0 325 if (speaker_logged != speaker_state) { // If statement to control logging for speaker.
ricardo_95 12:7b3a5940f911 326 if (speaker_state == 1) {
Ishy 55:b74e7076d7a0 327 pi_serial.printf("&04\n");
ricardo_95 9:514a44bf510f 328 speaker_logged = speaker_state;
deldering95 43:d09814c177a0 329
ricardo_95 36:d10f368d037b 330 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 331 usb_serial.printf("&04\n");
ricardo_95 34:1614f4f2b841 332 }
ricardo_95 12:7b3a5940f911 333 }
deldering95 43:d09814c177a0 334
ricardo_95 9:514a44bf510f 335 if (speaker_state == 0) {
Ishy 55:b74e7076d7a0 336 pi_serial.printf("&40\n");
ricardo_95 12:7b3a5940f911 337 speaker_logged = speaker_state;
deldering95 43:d09814c177a0 338
ricardo_95 36:d10f368d037b 339 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 340 usb_serial.printf("&40\n");
ricardo_95 34:1614f4f2b841 341 }
ricardo_95 9:514a44bf510f 342 }
ricardo_95 8:bf0f7a6fb1fd 343 }
ricardo_95 9:514a44bf510f 344
deldering95 43:d09814c177a0 345 if (connection_test_sensorplate == 1) { // If statement for sending serial information sensorplate data when connection test is active.
deldering95 43:d09814c177a0 346 // Receiving order sensor information: 8 resistive sensors, 5 electric readings. Is splitted in two parts - part 1/2.
deldering95 68:1663f305ac33 347 pi_serial.printf("!,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,\n", piezo_resistive_array[0], piezo_resistive_array[3], piezo_resistive_array[1], piezo_resistive_array[4], piezo_resistive_array[2], piezo_resistive_array[5], piezo_resistive_array[6], piezo_resistive_array[7], piezo_electric_array[0], piezo_electric_array[1], piezo_electric_array[2], piezo_electric_array[3], piezo_electric_array[4], piezo_electric_array[5]); // print all to serial port
deldering95 43:d09814c177a0 348
ricardo_95 34:1614f4f2b841 349 if (test_mode == 1) {
deldering95 68:1663f305ac33 350 usb_serial.printf("%d,%d\n%d,%d\n%d,%d\n", piezo_electric_array[0], piezo_electric_array[3], piezo_electric_array[1], piezo_electric_array[4], piezo_electric_array[2],piezo_electric_array[5]); // print all to serial port
ricardo_95 34:1614f4f2b841 351 }
deldering95 53:54c882995514 352 } else {
deldering95 58:8cfa736d8553 353 pi_serial.printf("!,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,\n",0,0,0,0,0,0,0,0,0,0,0,0,0,0);
Ishy 56:97dea631c5f2 354 if (test_mode == 1) {
deldering95 58:8cfa736d8553 355 usb_serial.printf("!,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,\n",0,0,0,0,0,0,0,0,0,0,0,0,0,0); // print all to serial port
Ishy 56:97dea631c5f2 356 }
ricardo_95 28:b4bee068780d 357 }
ricardo_95 34:1614f4f2b841 358
DEldering 0:c0e44c46c573 359 }
DEldering 0:c0e44c46c573 360
deldering95 68:1663f305ac33 361 bool i2c_error_detect()
deldering95 68:1663f305ac33 362 {
deldering95 68:1663f305ac33 363 int error_counter=0;
deldering95 68:1663f305ac33 364 for(int i=0; i<4; i++) {
deldering95 68:1663f305ac33 365 if(piezo_resistive_array[i]==193+16*i)error_counter++;
deldering95 68:1663f305ac33 366 if(piezo_resistive_array[i+4]==193+16*i)error_counter++;
deldering95 68:1663f305ac33 367 }
deldering95 68:1663f305ac33 368 if(error_counter==8)return 1;
deldering95 68:1663f305ac33 369 error_counter=0;
deldering95 68:1663f305ac33 370 for(int i=0; i<3; i++) {
deldering95 68:1663f305ac33 371 if (piezo_electric_array[i]==149)error_counter++;
deldering95 68:1663f305ac33 372 if (piezo_electric_array[i+3]==165)error_counter++;
deldering95 68:1663f305ac33 373 }
deldering95 68:1663f305ac33 374 if (error_counter==6)return 1;
deldering95 68:1663f305ac33 375 return 0;
deldering95 68:1663f305ac33 376 }
deldering95 68:1663f305ac33 377
deldering95 68:1663f305ac33 378
deldering95 66:88c910cd4d9e 379 int minimum(int a,int b)
deldering95 66:88c910cd4d9e 380 {
deldering95 66:88c910cd4d9e 381 if(a>b)return b;
deldering95 66:88c910cd4d9e 382 else return a;
deldering95 66:88c910cd4d9e 383 }
deldering95 66:88c910cd4d9e 384
deldering95 66:88c910cd4d9e 385 int colour_fade(int colour_old,int colour_new,int colour_mix)
deldering95 66:88c910cd4d9e 386 {
deldering95 66:88c910cd4d9e 387 int old_r=(colour_old&0xff0000)>>16;
deldering95 66:88c910cd4d9e 388 int old_g=(colour_old&0x00ff00)>> 8;
deldering95 66:88c910cd4d9e 389 int old_b=(colour_old&0x0000ff)>> 0;
deldering95 66:88c910cd4d9e 390 int new_r=(colour_new&0xff0000)>>16;
deldering95 66:88c910cd4d9e 391 int new_g=(colour_new&0x00ff00)>> 8;
deldering95 66:88c910cd4d9e 392 int new_b=(colour_new&0x0000ff)>> 0;
deldering95 66:88c910cd4d9e 393 int mix = (100*colour_mix)/FADE_STEPS;
deldering95 66:88c910cd4d9e 394 int mix_r=((new_r-old_r)*mix/100)+old_r;
deldering95 66:88c910cd4d9e 395 int mix_g=((new_g-old_g)*mix/100)+old_g;
deldering95 66:88c910cd4d9e 396 int mix_b=((new_b-old_b)*mix/100)+old_b;
deldering95 66:88c910cd4d9e 397 return ((mix_r<<16)|(mix_g<<8)|(mix_b));
deldering95 66:88c910cd4d9e 398
deldering95 66:88c910cd4d9e 399 }
deldering95 66:88c910cd4d9e 400
deldering95 66:88c910cd4d9e 401
deldering95 66:88c910cd4d9e 402
deldering95 66:88c910cd4d9e 403 void colour_wheel(int percentage_in)
deldering95 66:88c910cd4d9e 404 {
deldering95 66:88c910cd4d9e 405 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 406 if(percentage_in>100)percentage_in=100;
deldering95 66:88c910cd4d9e 407 int ring_colour = colourbuf[2];
deldering95 66:88c910cd4d9e 408 px.SetAll(colourbuf[6]);
deldering95 68:1663f305ac33 409 int leds_on =((percentage_in*15)/100)+1;
deldering95 68:1663f305ac33 410 float led_partly = ((percentage_in*15)%100);
deldering95 68:1663f305ac33 411 if(leds_on>=YELLOW_TRANSITION&&leds_on<RED_TRANSITION) {
deldering95 66:88c910cd4d9e 412 if(mixer>20)mixer=20;
deldering95 66:88c910cd4d9e 413 ring_colour = colour_fade(colourbuf[2],colourbuf[3],mixer);
deldering95 66:88c910cd4d9e 414 mixer++;
deldering95 66:88c910cd4d9e 415 }
deldering95 68:1663f305ac33 416 if(leds_on>YELLOW_TRANSITION&&leds_on<RED_TRANSITION&&(ring_colour_old==colourbuf[3]||ring_colour_old==colourbuf[4])) {
deldering95 66:88c910cd4d9e 417 ring_colour=colourbuf[3];
deldering95 66:88c910cd4d9e 418 mixer=0;
deldering95 66:88c910cd4d9e 419 }
deldering95 68:1663f305ac33 420 if(leds_on>=RED_TRANSITION) {
deldering95 66:88c910cd4d9e 421 if(mixer>20)mixer=20;
deldering95 66:88c910cd4d9e 422 usb_serial.printf("mixer:%d\n",mixer);
deldering95 66:88c910cd4d9e 423 ring_colour = colour_fade(colourbuf[3],colourbuf[0],mixer);
deldering95 66:88c910cd4d9e 424 mixer++;
deldering95 66:88c910cd4d9e 425 }
deldering95 68:1663f305ac33 426 if(leds_on>RED_TRANSITION&&(ring_colour_old==colourbuf[0]||ring_colour_old==colourbuf[4])) {
deldering95 66:88c910cd4d9e 427 ring_colour = colourbuf[0];
deldering95 66:88c910cd4d9e 428 mixer=0;
deldering95 66:88c910cd4d9e 429 }
deldering95 68:1663f305ac33 430 //usb_serial.printf("on:%d,part:%f\n",leds_on,led_partly);
deldering95 68:1663f305ac33 431 for(int j = 0; j<(leds_on); j++)px.Set(((16-j)%16),ring_colour);
deldering95 66:88c910cd4d9e 432 px.SetAllI(int(intensity*2.55));
deldering95 68:1663f305ac33 433 if((16-leds_on)>0) {
deldering95 68:1663f305ac33 434 px.Set(((16-leds_on)%16),ring_colour);
deldering95 68:1663f305ac33 435 px.SetI(((16-leds_on)%16),int(0.01*led_partly*intensity*2.55));
deldering95 66:88c910cd4d9e 436 }
deldering95 70:204686903e4c 437 //usb_serial.printf("percentage in %d,%d\n",percentage_in,leds_on);
deldering95 66:88c910cd4d9e 438
deldering95 68:1663f305ac33 439 if(patient_present==4) {
deldering95 68:1663f305ac33 440 //if(mixer>20)mixer=20;
deldering95 68:1663f305ac33 441 //ring_colour = colour_fade(ring_colour,colourbuf[4],mixer);
deldering95 67:1b300aa30923 442 px.SetAll(colourbuf[4]);
deldering95 67:1b300aa30923 443 px.SetAllI(int(2.55*intensity));
deldering95 68:1663f305ac33 444 //mixer++;
deldering95 68:1663f305ac33 445 //usb_serial.putc(0xee);
deldering95 68:1663f305ac33 446 }
deldering95 68:1663f305ac33 447 /*else{
deldering95 68:1663f305ac33 448 if(mixer>20)mixer=20;
deldering95 68:1663f305ac33 449 ring_colour = colour_fade(colourbuf[4],ring_colour,mixer);
deldering95 68:1663f305ac33 450 px.SetAll(ring_colour);
deldering95 68:1663f305ac33 451 px.SetAllI(int(2.55*intensity));
deldering95 68:1663f305ac33 452 mixer++;
deldering95 68:1663f305ac33 453 usb_serial.putc(0xdd);
deldering95 68:1663f305ac33 454 }*/
deldering95 67:1b300aa30923 455
deldering95 67:1b300aa30923 456
deldering95 66:88c910cd4d9e 457 if(reposition_button_hold_timer.read_ms()) {
deldering95 70:204686903e4c 458 usb_serial.printf("filling circle repo\n");
deldering95 66:88c910cd4d9e 459 circle_filling_reposition = true;
deldering95 70:204686903e4c 460 colour_wheel_filler = reposition_button_hold_timer.read_ms()/250+1;
deldering95 70:204686903e4c 461 if(colour_wheel_filler>=9) {
deldering95 70:204686903e4c 462 colour_wheel_filler=9;
deldering95 66:88c910cd4d9e 463 circle_filled_reposition = 15;
deldering95 66:88c910cd4d9e 464 circle_filling_reposition = false;
deldering95 66:88c910cd4d9e 465 colour_wheel_drain_reposition = false;
deldering95 66:88c910cd4d9e 466 reposition_flag = 1;
deldering95 66:88c910cd4d9e 467 }
deldering95 66:88c910cd4d9e 468 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 469 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 470 px.Set(k,colourbuf[5]);
deldering95 66:88c910cd4d9e 471 px.Set(16-k,colourbuf[5]);
deldering95 66:88c910cd4d9e 472 }
deldering95 66:88c910cd4d9e 473 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 474 }
deldering95 66:88c910cd4d9e 475
deldering95 66:88c910cd4d9e 476 if(new_patient_button_hold_timer.read_ms()) {
deldering95 70:204686903e4c 477 usb_serial.printf("filling circle patient\n");
deldering95 66:88c910cd4d9e 478 circle_filling_new_patient = true;
deldering95 70:204686903e4c 479 colour_wheel_filler = new_patient_button_hold_timer.read_ms()/250+1;
deldering95 70:204686903e4c 480 usb_serial.printf("Hold %d\n",colour_wheel_filler);
deldering95 70:204686903e4c 481 if(colour_wheel_filler>=9) {
deldering95 70:204686903e4c 482 colour_wheel_filler=9;
deldering95 66:88c910cd4d9e 483 circle_filled_new_patient = 10;
deldering95 66:88c910cd4d9e 484 circle_filling_new_patient = false;
deldering95 66:88c910cd4d9e 485 colour_wheel_drain_new_patient = false;
deldering95 66:88c910cd4d9e 486 new_patient_flag = 1;
deldering95 70:204686903e4c 487 //usb_serial.printf("patient filled");
deldering95 66:88c910cd4d9e 488 }
deldering95 66:88c910cd4d9e 489 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 490 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 491 px.Set((k+8)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 492 px.Set((16-k+8)%16,colourbuf[5]);
deldering95 70:204686903e4c 493 //usb_serial.printf("counter %d\n",k);
deldering95 66:88c910cd4d9e 494 }
deldering95 66:88c910cd4d9e 495 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 496 }
deldering95 66:88c910cd4d9e 497
deldering95 66:88c910cd4d9e 498 if(!reposition_button_hold_timer.read_ms()&&circle_filling_reposition&&!colour_wheel_drain_reposition) {
deldering95 71:040674ed2ce1 499 usb_serial.printf("Short hold repo\n");
deldering95 66:88c910cd4d9e 500 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 501 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 502 px.Set(k,colourbuf[5]);
deldering95 66:88c910cd4d9e 503 px.Set(16-k,colourbuf[5]);
deldering95 66:88c910cd4d9e 504 }
deldering95 66:88c910cd4d9e 505 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 506 if(colour_wheel_filler>=5) {
deldering95 66:88c910cd4d9e 507 colour_wheel_drain_reposition=true;
deldering95 66:88c910cd4d9e 508 circle_filling_reposition=false;
deldering95 70:204686903e4c 509 } else colour_wheel_filler++;
deldering95 66:88c910cd4d9e 510 }
deldering95 66:88c910cd4d9e 511
deldering95 66:88c910cd4d9e 512 if(!new_patient_button_hold_timer.read_ms()&&circle_filling_new_patient&&!colour_wheel_drain_new_patient) {
deldering95 71:040674ed2ce1 513 usb_serial.printf("Short hold patient\n");
deldering95 66:88c910cd4d9e 514 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 515 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 516 px.Set((k+8)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 517 px.Set((16-k+8)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 518 }
deldering95 66:88c910cd4d9e 519 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 520 if(colour_wheel_filler>=5) {
deldering95 66:88c910cd4d9e 521 colour_wheel_drain_new_patient=true;
deldering95 66:88c910cd4d9e 522 circle_filling_new_patient=false;
deldering95 70:204686903e4c 523 } else colour_wheel_filler++;
deldering95 66:88c910cd4d9e 524 }
deldering95 70:204686903e4c 525 //usb_serial.printf("pre drain %d\n",colour_wheel_filler);
deldering95 71:040674ed2ce1 526 if(colour_wheel_drain_reposition&&!circle_filling_new_patient) {
deldering95 71:040674ed2ce1 527 usb_serial.printf("drain_repo\n");
deldering95 66:88c910cd4d9e 528 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 529 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 530 px.Set(k,colourbuf[5]);
deldering95 66:88c910cd4d9e 531 px.Set(16-k,colourbuf[5]);
deldering95 66:88c910cd4d9e 532 }
deldering95 66:88c910cd4d9e 533 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 534 colour_wheel_filler--;
deldering95 70:204686903e4c 535 if(colour_wheel_filler<0)colour_wheel_filler=0;
deldering95 66:88c910cd4d9e 536 if(!colour_wheel_filler)colour_wheel_drain_reposition=false;
deldering95 66:88c910cd4d9e 537 }
deldering95 70:204686903e4c 538 //usb_serial.printf("post repo %d\n",colour_wheel_filler);
deldering95 71:040674ed2ce1 539 if(colour_wheel_drain_new_patient&&!circle_filling_reposition) {
deldering95 71:040674ed2ce1 540 usb_serial.printf("drain_patient\n");
deldering95 66:88c910cd4d9e 541 px.SetAll(colourbuf[6]);
deldering95 70:204686903e4c 542 for(int k =0; k<colour_wheel_filler; k++) {
deldering95 66:88c910cd4d9e 543 px.Set((k+8)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 544 px.Set((16-k+8)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 545 }
deldering95 66:88c910cd4d9e 546 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 547 colour_wheel_filler--;
deldering95 70:204686903e4c 548 if(colour_wheel_filler<0)colour_wheel_filler=0;
deldering95 66:88c910cd4d9e 549 if(!colour_wheel_filler)colour_wheel_drain_new_patient=false;
deldering95 66:88c910cd4d9e 550 }
deldering95 70:204686903e4c 551 //usb_serial.printf("post drain %d\n",colour_wheel_filler);
deldering95 66:88c910cd4d9e 552 if(circle_filled_reposition) {
deldering95 70:204686903e4c 553 usb_serial.printf("circle_filled_repo\n");
deldering95 66:88c910cd4d9e 554 px.SetAll(colourbuf[6]);
deldering95 66:88c910cd4d9e 555 for(int k =0; k<=circle_filled_reposition; k++) {
deldering95 66:88c910cd4d9e 556 px.Set((16-k)%16,colourbuf[5]);
deldering95 66:88c910cd4d9e 557 }
deldering95 66:88c910cd4d9e 558 px.Set((16-circle_filled_reposition)%16,colourbuf[4]);
deldering95 66:88c910cd4d9e 559 px.SetAllI(int(intensity*2.55));
deldering95 66:88c910cd4d9e 560 circle_filled_reposition--;
deldering95 67:1b300aa30923 561 percentage_tester=0;
deldering95 66:88c910cd4d9e 562 }
deldering95 66:88c910cd4d9e 563
deldering95 66:88c910cd4d9e 564 if(circle_filled_new_patient) {
deldering95 70:204686903e4c 565 usb_serial.printf("circle_filled_new_patient\n");
deldering95 66:88c910cd4d9e 566 px.SetAll(colourbuf[5]);
deldering95 66:88c910cd4d9e 567 px.SetAllI(int(intensity*2.55*(7-(circle_filled_new_patient%5))/7));
deldering95 66:88c910cd4d9e 568 circle_filled_new_patient--;
deldering95 66:88c910cd4d9e 569 }
deldering95 68:1663f305ac33 570 if(!connection_test_sensorplate||i2c_error) {
deldering95 71:040674ed2ce1 571 //usb_serial.printf("i2c error = %d\n",i2c_error);
deldering95 68:1663f305ac33 572 px.Set(5,colourbuf[0]);
deldering95 67:1b300aa30923 573 px.Set(6,colourbuf[0]);
deldering95 68:1663f305ac33 574 px.Set(7,colourbuf[0]);
deldering95 68:1663f305ac33 575 px.SetI(5,int(intensity*0.5));
deldering95 67:1b300aa30923 576 px.SetI(6,int(intensity*2.55));
deldering95 68:1663f305ac33 577 px.SetI(7,int(intensity*0.5));
deldering95 67:1b300aa30923 578 }
deldering95 66:88c910cd4d9e 579 ws.write_offsets(px.getBuf(),0,0,0);
deldering95 66:88c910cd4d9e 580 ring_colour_old=ring_colour;
deldering95 66:88c910cd4d9e 581 }
deldering95 66:88c910cd4d9e 582
ricardo_95 36:d10f368d037b 583 void trigger_lock() // If rising edge lock button is detected start locktimer.
ricardo_95 21:13e4824bc364 584 {
ricardo_95 34:1614f4f2b841 585 if (test_mode == 1) {
ricardo_95 36:d10f368d037b 586 usb_serial.printf("Lock triggered.\n");
ricardo_95 34:1614f4f2b841 587 }
Ishy 55:b74e7076d7a0 588 if (lock_state == 0) pi_serial.printf(">44\n");
Ishy 55:b74e7076d7a0 589 else if (lock_state == 1) pi_serial.printf(">00\n");
ricardo_95 36:d10f368d037b 590 button_lock_hold_timer.reset();
ricardo_95 36:d10f368d037b 591 button_lock_hold_timer.start();
ricardo_95 36:d10f368d037b 592 delay_between_button_pressed.reset();
ricardo_95 36:d10f368d037b 593 delay_between_button_pressed.start();
ricardo_95 21:13e4824bc364 594 }
ricardo_95 21:13e4824bc364 595
ricardo_95 36:d10f368d037b 596 void end_timer_lock_button() // End timer lock.
ricardo_95 21:13e4824bc364 597 {
deldering95 43:d09814c177a0 598 if (test_mode == 1) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 599 usb_serial.printf("Lock released.\n");
ricardo_95 36:d10f368d037b 600 }
ricardo_95 36:d10f368d037b 601 lock_flag = 0; // Set lock_flag off.
Ishy 55:b74e7076d7a0 602 lock_is_logged = 0;
ricardo_95 36:d10f368d037b 603 button_lock_hold_timer.stop(); // Stop and reset holdtimer
ricardo_95 36:d10f368d037b 604 button_lock_hold_timer.reset();
ricardo_95 36:d10f368d037b 605 }
ricardo_95 36:d10f368d037b 606
ricardo_95 36:d10f368d037b 607 void reposition_button_triggered()
ricardo_95 36:d10f368d037b 608 {
ricardo_95 36:d10f368d037b 609 if (lock_state == 1 | (delay_between_button_pressed.read_ms() < buttondelay_ms)) { // Control statement for lock interface and delay for non using buttons at the same time.
deldering95 48:aca02ef5cd01 610 lock_flash = 10;
deldering95 58:8cfa736d8553 611 }
deldering95 58:8cfa736d8553 612
Ishy 55:b74e7076d7a0 613 delay_between_button_pressed.reset();
Ishy 55:b74e7076d7a0 614 delay_between_button_pressed.start();
Ishy 55:b74e7076d7a0 615 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 616 usb_serial.printf("Reposition triggered.\n");
Ishy 55:b74e7076d7a0 617 LED_on_dev_board1 = !LED_on_dev_board1;
Ishy 55:b74e7076d7a0 618 }
deldering95 58:8cfa736d8553 619
deldering95 66:88c910cd4d9e 620 if (lock_state == 1||button_new_patient.read()==0) reposition_lock_flag = 1;
deldering95 58:8cfa736d8553 621 else {
deldering95 66:88c910cd4d9e 622 reposition_button_hold_timer.reset();
deldering95 66:88c910cd4d9e 623 reposition_button_hold_timer.start();
deldering95 66:88c910cd4d9e 624
ricardo_95 36:d10f368d037b 625 reposition_feedback_LED = control_LED_intensity;
Ishy 55:b74e7076d7a0 626 pi_serial.printf("&05\n");
deldering95 58:8cfa736d8553 627 if(test_mode == 1) usb_serial.printf("&05\n");
ricardo_95 21:13e4824bc364 628 }
ricardo_95 21:13e4824bc364 629 }
ricardo_95 21:13e4824bc364 630
deldering95 43:d09814c177a0 631 void rise_reposition() // Interrupt for rising edge reposition function (deactivation; active low).
ricardo_95 21:13e4824bc364 632 {
deldering95 43:d09814c177a0 633 if (test_mode == 1) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 634 usb_serial.printf("Reposition released.\n");
ricardo_95 34:1614f4f2b841 635 }
deldering95 58:8cfa736d8553 636
Ishy 55:b74e7076d7a0 637 if (reposition_feedback_LED != 0) {
Ishy 55:b74e7076d7a0 638 pi_serial.printf("&50\n");
deldering95 58:8cfa736d8553 639
Ishy 55:b74e7076d7a0 640 if(test_mode == 1) usb_serial.printf("&50\n");
Ishy 55:b74e7076d7a0 641 }
deldering95 66:88c910cd4d9e 642 reposition_button_hold_timer.stop();
deldering95 66:88c910cd4d9e 643 reposition_button_hold_timer.reset();
ricardo_95 36:d10f368d037b 644 reposition_feedback_LED = 0;
ricardo_95 21:13e4824bc364 645 }
Ishy 55:b74e7076d7a0 646 //TODO rename to calibration
ricardo_95 36:d10f368d037b 647 void mute_button_triggered()
ricardo_95 21:13e4824bc364 648 {
ricardo_95 21:13e4824bc364 649
ricardo_95 36:d10f368d037b 650 if (lock_state == 1 | (delay_between_button_pressed.read_ms() < buttondelay_ms)) { // Control statement for lock interface and delay for non using buttons at the same time.
deldering95 48:aca02ef5cd01 651 lock_flash = 10;
Ishy 55:b74e7076d7a0 652 }
deldering95 58:8cfa736d8553 653
Ishy 55:b74e7076d7a0 654 delay_between_button_pressed.reset();
Ishy 55:b74e7076d7a0 655 delay_between_button_pressed.start();
Ishy 55:b74e7076d7a0 656 button_calibration_hold_timer.reset(); // inline ?
Ishy 55:b74e7076d7a0 657 button_calibration_hold_timer.start();
deldering95 58:8cfa736d8553 658
Ishy 55:b74e7076d7a0 659 if (lock_state == 1) {
Ishy 55:b74e7076d7a0 660 mute_lock_flag = 1;
Ishy 55:b74e7076d7a0 661 }
deldering95 58:8cfa736d8553 662
Ishy 55:b74e7076d7a0 663 else {
deldering95 58:8cfa736d8553 664 mute_feedback_LED = control_LED_intensity;
deldering95 58:8cfa736d8553 665 pi_serial.printf("&07\n");
deldering95 58:8cfa736d8553 666 if (test_mode == 1) usb_serial.printf("&07\n");
deldering95 58:8cfa736d8553 667 mute_flag = 1;
Ishy 55:b74e7076d7a0 668 }
deldering95 58:8cfa736d8553 669
Ishy 55:b74e7076d7a0 670 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 671 usb_serial.printf("Calibration triggered\n");
Ishy 55:b74e7076d7a0 672 LED_on_dev_board1 = !LED_on_dev_board1;
Ishy 55:b74e7076d7a0 673 }
deldering95 43:d09814c177a0 674
deldering95 58:8cfa736d8553 675
ricardo_95 21:13e4824bc364 676 }
ricardo_95 21:13e4824bc364 677
deldering95 51:69087c44e8ac 678 void rise_mute() // Interrupt for rising edge reposition function (deactivation; active low).
ricardo_95 21:13e4824bc364 679 {
deldering95 43:d09814c177a0 680 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 681 usb_serial.printf("Calibration released.\n");
ricardo_95 34:1614f4f2b841 682 }
Ishy 55:b74e7076d7a0 683 if(lock_state == 0 && mute_feedback_LED != 0) {
Ishy 55:b74e7076d7a0 684 pi_serial.printf("&70\n");
Ishy 55:b74e7076d7a0 685 if (test_mode == 1) usb_serial.printf("&70\n");
Ishy 55:b74e7076d7a0 686 }
deldering95 58:8cfa736d8553 687
deldering95 51:69087c44e8ac 688 mute_feedback_LED = 0;
ricardo_95 21:13e4824bc364 689
deldering95 43:d09814c177a0 690 button_calibration_hold_timer.stop(); // Timer reset for calibration function of new patient button.
ricardo_95 36:d10f368d037b 691 button_calibration_hold_timer.reset();
ricardo_95 21:13e4824bc364 692
ricardo_95 36:d10f368d037b 693 if (lock_state == 1 | (delay_between_button_pressed.read_ms() < buttondelay_ms)) { // Control statement for lock interface and delay for non using buttons at the same time.
ricardo_95 21:13e4824bc364 694 } else {
ricardo_95 21:13e4824bc364 695 if (calibration_flag == 0) {
ricardo_95 21:13e4824bc364 696
deldering95 43:d09814c177a0 697 if (LED_on_dev_board1 == 0) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 698 LED_on_dev_board1 = 1;
ricardo_95 21:13e4824bc364 699 } else {
ricardo_95 36:d10f368d037b 700 LED_on_dev_board1 = 0;
ricardo_95 21:13e4824bc364 701 }
ricardo_95 21:13e4824bc364 702
ricardo_95 21:13e4824bc364 703 } else {
ricardo_95 21:13e4824bc364 704 calibration_flag = 0;
ricardo_95 21:13e4824bc364 705 }
ricardo_95 21:13e4824bc364 706 }
deldering95 51:69087c44e8ac 707
deldering95 51:69087c44e8ac 708 }
deldering95 51:69087c44e8ac 709
deldering95 51:69087c44e8ac 710 void trigger_new_patient() // Function to trigger hold timer for new patient and calibration function.
deldering95 51:69087c44e8ac 711 {
deldering95 51:69087c44e8ac 712
deldering95 51:69087c44e8ac 713 if (lock_state == 1 | (delay_between_button_pressed.read_ms() < buttondelay_ms)) {
deldering95 51:69087c44e8ac 714 lock_flash = 10;
Ishy 55:b74e7076d7a0 715 }
deldering95 58:8cfa736d8553 716
Ishy 55:b74e7076d7a0 717 delay_between_button_pressed.reset();
Ishy 55:b74e7076d7a0 718 delay_between_button_pressed.start();
deldering95 58:8cfa736d8553 719
deldering95 66:88c910cd4d9e 720 if (lock_state == 1||button_reposition.read()==0) new_patient_lock_flag = 1;
Ishy 55:b74e7076d7a0 721 else {
deldering95 66:88c910cd4d9e 722 new_patient_button_hold_timer.reset();
deldering95 66:88c910cd4d9e 723 new_patient_button_hold_timer.start();
deldering95 66:88c910cd4d9e 724
Ishy 55:b74e7076d7a0 725 new_patient_feedback_LED = control_LED_intensity;
Ishy 55:b74e7076d7a0 726 pi_serial.printf("&06\n");
deldering95 66:88c910cd4d9e 727 //new_patient_flag = 1;
deldering95 58:8cfa736d8553 728
deldering95 58:8cfa736d8553 729 if(test_mode == 1) {
Ishy 55:b74e7076d7a0 730 usb_serial.printf("&06\n");
deldering95 51:69087c44e8ac 731 }
deldering95 51:69087c44e8ac 732 }
deldering95 58:8cfa736d8553 733
Ishy 55:b74e7076d7a0 734 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 735 usb_serial.printf("New patient triggered.\n");
Ishy 55:b74e7076d7a0 736 }
deldering95 58:8cfa736d8553 737
deldering95 51:69087c44e8ac 738 }
deldering95 51:69087c44e8ac 739
deldering95 51:69087c44e8ac 740 void activate_new_patient_function() // Timer calibration function.
deldering95 51:69087c44e8ac 741 {
deldering95 51:69087c44e8ac 742 if (test_mode == 1) { // If statement for test purposal.
deldering95 51:69087c44e8ac 743 usb_serial.printf("New patient released.\n");
deldering95 58:8cfa736d8553 744
Ishy 55:b74e7076d7a0 745 }
deldering95 66:88c910cd4d9e 746 new_patient_button_hold_timer.stop();
deldering95 66:88c910cd4d9e 747 new_patient_button_hold_timer.reset();
deldering95 66:88c910cd4d9e 748
deldering95 58:8cfa736d8553 749
Ishy 55:b74e7076d7a0 750 if (new_patient_feedback_LED != 0) {
Ishy 55:b74e7076d7a0 751 pi_serial.printf("&60\n");
Ishy 55:b74e7076d7a0 752 if(test_mode) usb_serial.printf("&60\n");
deldering95 51:69087c44e8ac 753 }
deldering95 51:69087c44e8ac 754 new_patient_feedback_LED = 0;
ricardo_95 21:13e4824bc364 755 }
ricardo_95 21:13e4824bc364 756
deldering95 43:d09814c177a0 757 void timer_functions() // Function which contains statements using timers.
ricardo_95 21:13e4824bc364 758 {
deldering95 48:aca02ef5cd01 759 if (button_lock == 1) {
deldering95 44:dcbde3175a37 760 button_lock_hold_timer.stop();
deldering95 44:dcbde3175a37 761 button_lock_hold_timer.reset();
deldering95 44:dcbde3175a37 762 }
ricardo_95 36:d10f368d037b 763 if ((button_lock_hold_timer.read_ms() > locktime_ms) && lock_flag == 0 && button_lock == 0) { // If statement for lock function.
ricardo_95 21:13e4824bc364 764 lock_flag = 1;
ricardo_95 36:d10f368d037b 765 LED_on_dev_board2 = !LED_on_dev_board2;
ricardo_95 21:13e4824bc364 766 lock_state = !lock_state;
deldering95 43:d09814c177a0 767
deldering95 43:d09814c177a0 768 if (lock_state == 0) { // If statement to control lock feedback LED above button.
ricardo_95 36:d10f368d037b 769 lock_feedback_LED = control_LED_intensity;
Ishy 55:b74e7076d7a0 770 pi_serial.printf("&08\n");
deldering95 58:8cfa736d8553 771 if(test_mode == 1) usb_serial.printf("&08\n");
ricardo_95 21:13e4824bc364 772 } else {
ricardo_95 36:d10f368d037b 773 lock_feedback_LED = 0;
Ishy 55:b74e7076d7a0 774 pi_serial.printf("&80\n");
Ishy 55:b74e7076d7a0 775 if(test_mode == 1) usb_serial.printf("&80\n");
ricardo_95 21:13e4824bc364 776 }
ricardo_95 21:13e4824bc364 777 }
ricardo_95 21:13e4824bc364 778
deldering95 51:69087c44e8ac 779 if (button_mute == 1) {
deldering95 44:dcbde3175a37 780 button_calibration_hold_timer.stop();
deldering95 44:dcbde3175a37 781 button_calibration_hold_timer.reset();
deldering95 44:dcbde3175a37 782 }
deldering95 44:dcbde3175a37 783
deldering95 70:204686903e4c 784 if (button_new_patient == 1) {
deldering95 70:204686903e4c 785 new_patient_button_hold_timer.stop();
deldering95 70:204686903e4c 786 new_patient_button_hold_timer.reset();
deldering95 70:204686903e4c 787 }
deldering95 70:204686903e4c 788
deldering95 66:88c910cd4d9e 789 if (button_reposition == 1) {
deldering95 66:88c910cd4d9e 790 reposition_button_hold_timer.stop();
deldering95 66:88c910cd4d9e 791 reposition_button_hold_timer.reset();
deldering95 66:88c910cd4d9e 792 }
deldering95 66:88c910cd4d9e 793
deldering95 66:88c910cd4d9e 794
deldering95 51:69087c44e8ac 795 if ((button_calibration_hold_timer.read_ms() > calibrationtime_ms) && calibration_flag == 0 && button_mute == 0 && lock_state == 0) { // If statement for calibration algorithm.
ricardo_95 21:13e4824bc364 796 calibration_flag = 1;
ricardo_95 21:13e4824bc364 797 calibration_flash = 11;
deldering95 58:8cfa736d8553 798
Ishy 55:b74e7076d7a0 799 if (test_mode == 1) { // If statement for test purposal.
ricardo_95 36:d10f368d037b 800 usb_serial.printf("Calibrate triggered.\n");
ricardo_95 34:1614f4f2b841 801 }
Ishy 55:b74e7076d7a0 802 pi_serial.printf(">33\n");
deldering95 58:8cfa736d8553 803
ricardo_95 21:13e4824bc364 804 }
deldering95 66:88c910cd4d9e 805 /*
deldering95 66:88c910cd4d9e 806 if (delay_between_button_pressed.read_ms() > delay_lock_interface) { // If buttons are not pressed for 3 minutes, set lock active.
deldering95 66:88c910cd4d9e 807 lock_state = 1;
deldering95 66:88c910cd4d9e 808 LED_on_dev_board2 = 1;
deldering95 66:88c910cd4d9e 809 lock_feedback_LED = 0;
deldering95 66:88c910cd4d9e 810 if (!auto_lock_led_logged) {
deldering95 66:88c910cd4d9e 811 pi_serial.printf("&80\n");
deldering95 66:88c910cd4d9e 812 if(test_mode == 1) usb_serial.printf("&80\n");
deldering95 66:88c910cd4d9e 813 auto_lock_led_logged = 1;
deldering95 66:88c910cd4d9e 814 }
deldering95 66:88c910cd4d9e 815 } else {
deldering95 66:88c910cd4d9e 816 auto_lock_led_logged = 0;
deldering95 66:88c910cd4d9e 817 }*/
ricardo_95 21:13e4824bc364 818 }
ricardo_95 21:13e4824bc364 819
ricardo_95 36:d10f368d037b 820 void set_userinterface_LED() // Control functions for LED above buttons (added because of failures).
ricardo_95 21:13e4824bc364 821 {
ricardo_95 21:13e4824bc364 822 if (lock_state == 1) {
ricardo_95 21:13e4824bc364 823 } else {
ricardo_95 36:d10f368d037b 824 if (button_reposition == 0) {
ricardo_95 36:d10f368d037b 825 reposition_feedback_LED = control_LED_intensity;
ricardo_95 21:13e4824bc364 826 } else {
ricardo_95 36:d10f368d037b 827 reposition_feedback_LED = 0;
ricardo_95 21:13e4824bc364 828 }
ricardo_95 21:13e4824bc364 829
ricardo_95 36:d10f368d037b 830 if (button_new_patient == 0) {
ricardo_95 36:d10f368d037b 831 new_patient_feedback_LED = control_LED_intensity;
ricardo_95 21:13e4824bc364 832 } else {
ricardo_95 36:d10f368d037b 833 new_patient_feedback_LED = 0;
ricardo_95 21:13e4824bc364 834 }
ricardo_95 21:13e4824bc364 835 }
deldering95 48:aca02ef5cd01 836 if (lock_flash >= 1 && lock_state == 1) {
deldering95 48:aca02ef5cd01 837 if ((lock_flash % 2) == 0) {
deldering95 48:aca02ef5cd01 838 lock_feedback_LED = control_LED_intensity;
Ishy 55:b74e7076d7a0 839 pi_serial.printf("&08\n");
Ishy 55:b74e7076d7a0 840 if(test_mode == 1) usb_serial.printf("&08\n");
deldering95 48:aca02ef5cd01 841 } else {
deldering95 48:aca02ef5cd01 842 lock_feedback_LED = 0;
Ishy 55:b74e7076d7a0 843 pi_serial.printf("&80\n");
Ishy 55:b74e7076d7a0 844 if(test_mode == 1) usb_serial.printf("&80\n");
ricardo_95 21:13e4824bc364 845 }
deldering95 48:aca02ef5cd01 846 lock_flash--;
deldering95 48:aca02ef5cd01 847 } else {
deldering95 48:aca02ef5cd01 848 lock_flash = 0;
ricardo_95 21:13e4824bc364 849 }
ricardo_95 21:13e4824bc364 850 }
ricardo_95 21:13e4824bc364 851
deldering95 57:fac732476810 852 void sensorplate_detached()
deldering95 57:fac732476810 853 {
deldering95 71:040674ed2ce1 854 //NVIC_SystemReset();
deldering95 71:040674ed2ce1 855 I2C i2c_sensorplate_adc(PB_9, PB_8); // I2C for sensorplate.
deldering95 71:040674ed2ce1 856 MPU6050_belt angle_device_sensorplate(PB_9, PB_8); // i2c pins // i2c address hardcoded 0x68.
deldering95 71:040674ed2ce1 857 MPU6050 angle_device_reference_belt(PB_9, PB_8); // i2c pins // i2c address hardcoded 0x69.
deldering95 71:040674ed2ce1 858 Adafruit_ADS1115 piezo_resistive_adc1(&i2c_sensorplate_adc, 0x48); // i2c pins, i2c address.
deldering95 71:040674ed2ce1 859 Adafruit_ADS1115 piezo_resistive_adc2(&i2c_sensorplate_adc, 0x49); // i2c pins, i2c address.
deldering95 71:040674ed2ce1 860 Adafruit_ADS1115 piezo_electric_adc(&i2c_sensorplate_adc, 0x4B); // i2c pins, i2c address.
deldering95 57:fac732476810 861 }
deldering95 57:fac732476810 862
deldering95 57:fac732476810 863
deldering95 43:d09814c177a0 864 int main() // Main function. inline function "Momo Init" bijvoorbeeld
deldering95 43:d09814c177a0 865 {
deldering95 71:040674ed2ce1 866
deldering95 66:88c910cd4d9e 867 pi_serial.attach(serial_read,Serial::RxIrq);
deldering95 66:88c910cd4d9e 868 ws.useII(WS2812::PER_PIXEL);
deldering95 66:88c910cd4d9e 869 ws.setII(255);
deldering95 66:88c910cd4d9e 870 px.SetAll(colourbuf[4]); // use global intensity scaling
deldering95 51:69087c44e8ac 871 set_intensity_LEDs(); // Initialize intensity for user interface LED's and LED's shines to wall.
deldering95 66:88c910cd4d9e 872 ws.write_offsets(px.getBuf(),0,0,0);
deldering95 53:54c882995514 873
ricardo_95 39:cff99a9b7237 874 i2c_sensorplate_adc.frequency(i2c__frequency); // Set frequency for i2c connection to sensorplate (variable is declared in config part).
ricardo_95 36:d10f368d037b 875 usb_serial.baud(baud_rate); // Set serial USB connection baud rate (variable is declared in config part).
ricardo_95 36:d10f368d037b 876 pi_serial.baud(baud_rate); // Same as line 697, but now for serial PI connection.
ricardo_95 36:d10f368d037b 877 piezo_resistive_adc1.setGain(GAIN_TWOTHIRDS); // Set ranges of ADC to +/-6.144V (end is marked with #):
deldering95 43:d09814c177a0 878 piezo_resistive_adc2.setGain(GAIN_TWOTHIRDS);
deldering95 51:69087c44e8ac 879 piezo_electric_adc.setGain(GAIN_TWO);
deldering95 43:d09814c177a0 880 pi_serial.format(8, SerialBase::None, 1); // Set serial communication line with PI.
ricardo_95 7:dba5091c8b7d 881
deldering95 57:fac732476810 882 testpin_sensorplate.mode(PullUp);
deldering95 43:d09814c177a0 883 button_lock.mode(PullUp);
deldering95 43:d09814c177a0 884 button_reposition.mode(PullUp);
deldering95 43:d09814c177a0 885 button_mute.mode(PullUp);
deldering95 43:d09814c177a0 886 button_new_patient.mode(PullUp);
deldering95 43:d09814c177a0 887
deldering95 70:204686903e4c 888 testpin_sensorplate.rise(&sensorplate_detached);
deldering95 71:040674ed2ce1 889 testpin_sensorplate.fall(&sensorplate_detached);
ricardo_95 36:d10f368d037b 890 button_lock.fall(&trigger_lock); // Interrupt for rising edge lock button.
ricardo_95 36:d10f368d037b 891 button_lock.rise(&end_timer_lock_button);
ricardo_95 36:d10f368d037b 892 button_reposition.fall(&reposition_button_triggered);
ricardo_95 36:d10f368d037b 893 button_reposition.rise(&rise_reposition);
ricardo_95 36:d10f368d037b 894 button_mute.fall(&mute_button_triggered);
deldering95 51:69087c44e8ac 895 button_mute.rise(&rise_mute);
ricardo_95 36:d10f368d037b 896 button_new_patient.fall(&trigger_new_patient); // New patient/calibration button rising event.
deldering95 43:d09814c177a0 897 button_new_patient.rise(&activate_new_patient_function); // Falling edge for calibration algorithm option.
deldering95 68:1663f305ac33 898 colour_code = (colour_code_1 << 1 | colour_code_0);
deldering95 68:1663f305ac33 899 if(colour_code != 0b00 && pi_active == false) {
deldering95 68:1663f305ac33 900 pi_active = true;
deldering95 66:88c910cd4d9e 901 }
ricardo_95 19:3b5999fa7b7e 902
deldering95 68:1663f305ac33 903 if(!pi_active) {
deldering95 71:040674ed2ce1 904 speaker1 = 1;
deldering95 71:040674ed2ce1 905 wait_ms(boot_delay_ms); // Wait to boot sensorplate first.
deldering95 71:040674ed2ce1 906 speaker1 = 0;
deldering95 68:1663f305ac33 907 __disable_irq();
deldering95 68:1663f305ac33 908 while(!pi_active) {
deldering95 68:1663f305ac33 909 comet_timer.reset();
deldering95 68:1663f305ac33 910 comet_timer.start();
deldering95 68:1663f305ac33 911 ws.useII(WS2812::PER_PIXEL);
deldering95 68:1663f305ac33 912 ws.setII(255);
deldering95 68:1663f305ac33 913 tail_step = (255-COMET_TAIL_END_INTENSITY)/TAIL_LENGTH;
deldering95 68:1663f305ac33 914 comet++;
deldering95 68:1663f305ac33 915 px.SetAll(colourbuf[6]);
deldering95 68:1663f305ac33 916 px.Set(comet%ALARMBUF,colourbuf[4]);
deldering95 68:1663f305ac33 917 px.SetI(comet%ALARMBUF,255);
deldering95 68:1663f305ac33 918 for(int i=1; i<=TAIL_LENGTH; i++) {
deldering95 68:1663f305ac33 919 tail=(comet-i);
deldering95 68:1663f305ac33 920 if(tail<0)tail=0;
deldering95 68:1663f305ac33 921 px.Set(tail%ALARMBUF,colourbuf[4]);
deldering95 68:1663f305ac33 922 px.SetI(tail%ALARMBUF,(255-(tail_step*i)));
deldering95 68:1663f305ac33 923 }
deldering95 68:1663f305ac33 924 colour_code = (colour_code_1 << 1 | colour_code_0);
deldering95 68:1663f305ac33 925 if(colour_code != 0b00 && pi_active == false && (comet%ALARMBUF)==(ALARMBUF-1)) {
deldering95 68:1663f305ac33 926 pi_active = true;
deldering95 71:040674ed2ce1 927 }//else if(comet>160)pi_active=true;
deldering95 68:1663f305ac33 928 if(testpin_sensorplate.read()||i2c_error) {
deldering95 68:1663f305ac33 929 px.Set(5,colourbuf[0]);
deldering95 68:1663f305ac33 930 px.Set(6,colourbuf[0]);
deldering95 68:1663f305ac33 931 px.Set(7,colourbuf[0]);
deldering95 68:1663f305ac33 932 px.SetI(5,int(intensity*0.5));
deldering95 68:1663f305ac33 933 px.SetI(6,int(intensity*2.55));
deldering95 68:1663f305ac33 934 px.SetI(7,int(intensity*0.5));
deldering95 68:1663f305ac33 935 }
deldering95 68:1663f305ac33 936 ws.write_offsets(px.getBuf(),0,0,0);
deldering95 68:1663f305ac33 937 while(comet_timer.read_ms()<total_comet_cycle_time_ms) {}
deldering95 68:1663f305ac33 938 }
deldering95 68:1663f305ac33 939 for(int i=ALARMBUF-1; i>=0; i--) {
deldering95 68:1663f305ac33 940 comet_timer.reset();
deldering95 68:1663f305ac33 941 comet_timer.start();
deldering95 68:1663f305ac33 942 for(int j=1; j<=TAIL_LENGTH; j++) {
deldering95 68:1663f305ac33 943 tail=(i-j);
deldering95 68:1663f305ac33 944 if(tail>=0) {
deldering95 68:1663f305ac33 945 px.Set(tail,colourbuf[4]);
deldering95 68:1663f305ac33 946 px.SetI(tail,(int(255-(tail_step*j))));
deldering95 68:1663f305ac33 947 }
deldering95 68:1663f305ac33 948 }
deldering95 68:1663f305ac33 949 px.Set(i,colourbuf[4]);
deldering95 68:1663f305ac33 950 px.SetI(i,255);
deldering95 68:1663f305ac33 951 if(testpin_sensorplate.read()||i2c_error) {
deldering95 68:1663f305ac33 952 px.Set(5,colourbuf[0]);
deldering95 68:1663f305ac33 953 px.Set(6,colourbuf[0]);
deldering95 68:1663f305ac33 954 px.Set(7,colourbuf[0]);
deldering95 68:1663f305ac33 955 px.SetI(5,int(intensity*0.5));
deldering95 68:1663f305ac33 956 px.SetI(6,int(intensity*2.55));
deldering95 68:1663f305ac33 957 px.SetI(7,int(intensity*0.5));
deldering95 68:1663f305ac33 958 }
deldering95 68:1663f305ac33 959 while(comet_timer.read_ms()<total_comet_cycle_time_ms) {}
deldering95 68:1663f305ac33 960 ws.write_offsets(px.getBuf(),0,0,0);
deldering95 68:1663f305ac33 961 }
deldering95 68:1663f305ac33 962
deldering95 68:1663f305ac33 963 __enable_irq();
deldering95 68:1663f305ac33 964 wait(1);
deldering95 68:1663f305ac33 965 }
deldering95 51:69087c44e8ac 966 delay_between_button_pressed.reset(); // Delaytimer reset en start.
deldering95 51:69087c44e8ac 967 delay_between_button_pressed.start();
deldering95 51:69087c44e8ac 968
deldering95 66:88c910cd4d9e 969 // ws.useII(WS2812::GLOBAL);
deldering95 51:69087c44e8ac 970 reposition_feedback_LED = 0;
deldering95 51:69087c44e8ac 971 new_patient_feedback_LED = 0;
deldering95 51:69087c44e8ac 972 mute_feedback_LED = 0;
deldering95 51:69087c44e8ac 973 usb_serial.printf("Lock State: %d\n",lock_state);
deldering95 48:aca02ef5cd01 974 lock_feedback_LED = control_LED_intensity; // Lock LED initialization.
deldering95 71:040674ed2ce1 975 woofwoof.Configure(10);
deldering95 51:69087c44e8ac 976
DEldering 0:c0e44c46c573 977 while (1) {
Ishy 42:673ddef4cfa4 978 piezo_electric_sample_timer.reset(); // Clock gebruiken o.i.d.?
Ishy 42:673ddef4cfa4 979 piezo_electric_sample_timer.start();
ricardo_95 46:a0e6e088a50a 980 connection_test_sensorplate = !testpin_sensorplate && pi_active;
deldering95 71:040674ed2ce1 981 //usb_serial.printf("start %d\n",piezo_electric_sample_timer.read_us());
deldering95 43:d09814c177a0 982
Ishy 42:673ddef4cfa4 983 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 984 // usb_serial.printf("Connection test sensorplate = %d\n", connection_test_sensorplate);
Ishy 42:673ddef4cfa4 985 }
deldering95 43:d09814c177a0 986 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 987 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 988 }
deldering95 43:d09814c177a0 989
deldering95 70:204686903e4c 990 if (!testpin_sensorplate) {
deldering95 58:8cfa736d8553 991 piezo_electric_array[0] = piezo_electric_adc.readADC_Differential_0_3(); // First PE readout.
deldering95 58:8cfa736d8553 992 piezo_electric_array[3] = piezo_electric_adc.readADC_Differential_1_3(); // First PE readout.
deldering95 58:8cfa736d8553 993
deldering95 48:aca02ef5cd01 994 for (uint8_t k = 0; k < 4; ++k) {
deldering95 48:aca02ef5cd01 995 piezo_resistive_array[k] = piezo_resistive_adc1.readADC_SingleEnded(k); // First 4 PR readout.
deldering95 48:aca02ef5cd01 996 }
deldering95 43:d09814c177a0 997 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 998 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 999 }
deldering95 71:040674ed2ce1 1000 //usb_serial.printf("eenderde %d\n",piezo_electric_sample_timer.read_us());
deldering95 58:8cfa736d8553 1001 while(piezo_electric_sample_timer.read_us()<(1*(total_readout_cycle_time_us/3))) {} // Wait untill 20% of cycle. Energy efficiency is not fine in this situation, correct if low energy is needed.
deldering95 58:8cfa736d8553 1002 piezo_electric_array[1] = piezo_electric_adc.readADC_Differential_0_3(); // Second PE readout.
deldering95 58:8cfa736d8553 1003 piezo_electric_array[4] = piezo_electric_adc.readADC_Differential_1_3(); // First PE readout.
deldering95 43:d09814c177a0 1004
deldering95 48:aca02ef5cd01 1005 for (uint8_t k = 0; k < 4; ++k) {
deldering95 48:aca02ef5cd01 1006 piezo_resistive_array[k+4] = piezo_resistive_adc2.readADC_SingleEnded(k); // Last 4 PR readout.
deldering95 48:aca02ef5cd01 1007 }
deldering95 43:d09814c177a0 1008 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 1009 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1010 }
deldering95 71:040674ed2ce1 1011 //usb_serial.printf("tweederde %d\n",piezo_electric_sample_timer.read_us());
deldering95 58:8cfa736d8553 1012 while(piezo_electric_sample_timer.read_us()<(2*(total_readout_cycle_time_us/3))) {} // Wait untill 40% of cycle. Energy efficiency is not fine in this situation, correct if low energy is needed.
deldering95 58:8cfa736d8553 1013 piezo_electric_array[2] = piezo_electric_adc.readADC_Differential_0_3(); // Third PE readout.
deldering95 58:8cfa736d8553 1014 piezo_electric_array[5] = piezo_electric_adc.readADC_Differential_1_3(); // First PE readout.
deldering95 43:d09814c177a0 1015
deldering95 48:aca02ef5cd01 1016 angle_device_sensorplate.getAccelero(accelerometer_sensorplate); // Get accelerometer data.
deldering95 48:aca02ef5cd01 1017 angle = accelerometer_sensorplate[2]*100;
deldering95 48:aca02ef5cd01 1018 if(angle == 0) {
deldering95 51:69087c44e8ac 1019 MPU6050_belt angle_device_sensorplate(PB_9, PB_8);
deldering95 53:54c882995514 1020 angle_device_sensorplate.getAccelero(accelerometer_sensorplate);
deldering95 48:aca02ef5cd01 1021 angle = accelerometer_sensorplate[2]*100;
deldering95 48:aca02ef5cd01 1022 }
deldering95 53:54c882995514 1023 if((abs(accelerometer_sensorplate[0])+abs(accelerometer_sensorplate[1])+abs(accelerometer_sensorplate[2]))<= 6) {
deldering95 53:54c882995514 1024 for(uint8_t k = 0; k < 3; ++k) {
deldering95 53:54c882995514 1025 accelerometer_sensorplate[k]=accelerometer_sensorplate[k]*2;
deldering95 53:54c882995514 1026 }
deldering95 53:54c882995514 1027 }
deldering95 48:aca02ef5cd01 1028 angle_device_sensorplate.getGyro(gyroscope_sensorplate); // Get gyroscope data.
deldering95 43:d09814c177a0 1029 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 1030 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1031 }
deldering95 48:aca02ef5cd01 1032 if (test_belt == 1) {
deldering95 68:1663f305ac33 1033 angle_device_reference_belt.getAccelero(accelerometer_reference_belt); // Get accelerometer data from belt.
deldering95 68:1663f305ac33 1034 if(accelerometer_reference_belt[0]==0) {
deldering95 68:1663f305ac33 1035 MPU6050 angle_device_reference_belt(PB_9, PB_8);
deldering95 68:1663f305ac33 1036 angle_device_reference_belt.getAccelero(accelerometer_reference_belt); // Get accelerometer data from belt.
deldering95 68:1663f305ac33 1037 }
deldering95 48:aca02ef5cd01 1038 angle_device_reference_belt.getGyro(gyroscope_reference_belt); // Get gyroscope data from Belt.
deldering95 48:aca02ef5cd01 1039 }
deldering95 43:d09814c177a0 1040
deldering95 48:aca02ef5cd01 1041 if (connection_test_sensorplate == 1) {
deldering95 48:aca02ef5cd01 1042 if (test_belt == 0) { // If statement for sending serial information sensorplate data when connection test is active.
deldering95 48:aca02ef5cd01 1043 pi_serial.printf("?,%f,%f,%f,%f,%f,%f,0,0,0,0,0,0,\n", accelerometer_sensorplate[0], accelerometer_sensorplate[1], accelerometer_sensorplate[2], gyroscope_sensorplate[0], gyroscope_sensorplate[1], gyroscope_sensorplate[2]);
deldering95 53:54c882995514 1044 } else {
deldering95 53:54c882995514 1045 // Receiving order sensor information: 3 accelero sensors & 3 gyroscope sensors from sensorplate; 3 accelero sensors & 3 gyroscope sensors from belt. Is splitted in two parts - part 2/2.
deldering95 53:54c882995514 1046 pi_serial.printf("?,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,\n", accelerometer_sensorplate[0], accelerometer_sensorplate[1], accelerometer_sensorplate[2], gyroscope_sensorplate[0], gyroscope_sensorplate[1], gyroscope_sensorplate[2], accelerometer_reference_belt[0], accelerometer_reference_belt[1], accelerometer_reference_belt[2], gyroscope_reference_belt[0], gyroscope_reference_belt[1], gyroscope_reference_belt[2]);
deldering95 68:1663f305ac33 1047 //usb_serial.printf("?,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,\n", accelerometer_sensorplate[0], accelerometer_sensorplate[1], accelerometer_sensorplate[2], gyroscope_sensorplate[0], gyroscope_sensorplate[1], gyroscope_sensorplate[2], accelerometer_reference_belt[0], accelerometer_reference_belt[1], accelerometer_reference_belt[2], gyroscope_reference_belt[0], gyroscope_reference_belt[1], gyroscope_reference_belt[2]);
deldering95 48:aca02ef5cd01 1048 }
deldering95 48:aca02ef5cd01 1049 } // binair print and convert in pi
deldering95 53:54c882995514 1050 else {
deldering95 53:54c882995514 1051 pi_serial.printf("?,%f,%f,%f,%f,%f,%f,0,0,0,0,0,0,\n",0,0,0,0,0,0);
deldering95 53:54c882995514 1052 }
Ishy 42:673ddef4cfa4 1053 }
deldering95 43:d09814c177a0 1054 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 1055 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1056 }
Ishy 42:673ddef4cfa4 1057 timer_functions();
deldering95 43:d09814c177a0 1058 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 1059 // usb_serial.printf("Loop time after timer_functions: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1060 }
deldering95 43:d09814c177a0 1061
deldering95 71:040674ed2ce1 1062 if(buffer_counter>4&& buffer_counter%2==0) {
deldering95 71:040674ed2ce1 1063 for(int i=0; i<buffer_counter-1; i++) {
deldering95 68:1663f305ac33 1064 if(uart_input_buffer[i]=='='&&(uart_input_buffer[(i+2)%4]=='{'||uart_input_buffer[(i+2)%4]=='='))patient_present=uart_input_buffer[(i+1)];
deldering95 68:1663f305ac33 1065 if(uart_input_buffer[i]=='{'&&(uart_input_buffer[(i+2)%4]=='='||uart_input_buffer[(i+2)%4]=='{'))LED_colour_wheel_percentage=uart_input_buffer[(i+1)];
deldering95 68:1663f305ac33 1066 if((patient_present_old==4&&patient_present!=4)||(patient_present_old!=4&&patient_present==4))mixer=0;
deldering95 70:204686903e4c 1067 //usb_serial.putc(uart_input_buffer[i]);
deldering95 68:1663f305ac33 1068 }
deldering95 71:040674ed2ce1 1069 //usb_serial.putc(0x20);
deldering95 68:1663f305ac33 1070 patient_present_old=patient_present;
deldering95 68:1663f305ac33 1071 buffer_counter=0;
deldering95 68:1663f305ac33 1072 }
deldering95 71:040674ed2ce1 1073 if(1==0){
deldering95 71:040674ed2ce1 1074 percentage_tester+=0.25;
deldering95 71:040674ed2ce1 1075 patient_present=1;
deldering95 71:040674ed2ce1 1076 LED_colour_wheel_percentage=percentage_tester;
deldering95 71:040674ed2ce1 1077 }
deldering95 66:88c910cd4d9e 1078 colour_wheel(LED_colour_wheel_percentage); // Function to select colour.
Ishy 42:673ddef4cfa4 1079 set_userinterface_LED(); // Set LED's of user interface (LED's above buttons).
deldering95 43:d09814c177a0 1080
deldering95 43:d09814c177a0 1081 if (test_mode == 1) { // If statement for test purposal.
Ishy 55:b74e7076d7a0 1082 // usb_serial.printf("Angle device sensorplate = %d\n",angle_device_sensorplate.testConnection());
Ishy 42:673ddef4cfa4 1083 }
deldering95 43:d09814c177a0 1084
Ishy 42:673ddef4cfa4 1085 while(piezo_electric_sample_timer.read_us()<(4.25*(total_readout_cycle_time_us/5))) {} // Wait untill 85% of cycle. Energy efficiency is not fine in this situation, correct if low energy is needed.
Ishy 42:673ddef4cfa4 1086
deldering95 43:d09814c177a0 1087 if (test_mode == 1) {
Ishy 55:b74e7076d7a0 1088 // usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1089 }
deldering95 43:d09814c177a0 1090
deldering95 43:d09814c177a0 1091 if (test_mode == 0) { // If statements for test purposal (untill * mark).
Ishy 55:b74e7076d7a0 1092 // usb_serial.printf("Loop time pre serial: %d ms\n",piezo_electric_sample_timer.read_ms());
deldering95 43:d09814c177a0 1093 }
deldering95 66:88c910cd4d9e 1094 //serial_read(); // Call function for reading information from PI by serial connection.
deldering95 43:d09814c177a0 1095 serial_log(); // Call function for logging information to PI by serial connection.
deldering95 68:1663f305ac33 1096 if(connection_test_sensorplate)i2c_error=i2c_error_detect();
deldering95 43:d09814c177a0 1097
deldering95 43:d09814c177a0 1098 if (test_mode == 0) { // If statements for test purposal (untill * mark).
deldering95 68:1663f305ac33 1099 //usb_serial.printf("Loop time: %d ms\n",piezo_electric_sample_timer.read_ms());
Ishy 42:673ddef4cfa4 1100 }
deldering95 48:aca02ef5cd01 1101
deldering95 71:040674ed2ce1 1102 woofwoof.Service();
deldering95 71:040674ed2ce1 1103 //usb_serial.printf("einde %d\n",piezo_electric_sample_timer.read_us());
deldering95 47:80cfc181f8b3 1104 while(piezo_electric_sample_timer.read_us()<(total_readout_cycle_time_us)) {} // Wait untill 100% of cycle. Energy efficiency is not fine in this situation, correct if low energy is needed.
Ishy 42:673ddef4cfa4 1105 //if (test_pin == 1) {
Ishy 42:673ddef4cfa4 1106 // test_mode = 1;
Ishy 42:673ddef4cfa4 1107 // usb_serial.printf("%d\n",test_mode);
Ishy 42:673ddef4cfa4 1108 // }
Ishy 42:673ddef4cfa4 1109 // if (test_pin == 0) {
Ishy 42:673ddef4cfa4 1110 // test_mode = 0;
Ishy 42:673ddef4cfa4 1111 // usb_serial.printf("%d\n",test_mode);
Ishy 42:673ddef4cfa4 1112 // }
DEldering 0:c0e44c46c573 1113 }
ricardo_95 12:7b3a5940f911 1114 }