diff --git a/include/application/tasks/ventilation.h b/include/application/tasks/ventilation.h index 162f051..f03dc9e 100644 --- a/include/application/tasks/ventilation.h +++ b/include/application/tasks/ventilation.h @@ -9,6 +9,7 @@ #include "platform/common.h" #define MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP 32 //todo replace this value by the real value +#define MIN_CIRCUIT_PRESSURE_FOR_OPENING_EXP_VALVE_CSP 8 //todo replace this value by the real value /* * SLS-0055 @@ -27,4 +28,14 @@ uint32_t get_circuit_pressure(); */ void start_inspiration(); +/** + * Ends inspiration and Start Expiration + * + * Verify that the pressure is acceptable to start an expiration + * Ends the inspiration by closing the inspiratory valve + * Starts the expiration by opening the expiratory valve + * SRS-0015 and SRS-0020 + */ +void start_expiration(); + #endif /* INC_PLATFORM_VENTILATION_H_ */ diff --git a/src/application/tasks/ventilation.c b/src/application/tasks/ventilation.c index 7e76a8b..91e2213 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -15,28 +15,24 @@ //todo rename this so that it does not look like they are time #define INSPIRATION 1 -#define INSPIRATORY_PAUSE 2 -#define EXPIRATION 3 -#define EXPIRATORY_PAUSE 4 +#define EXPIRATION 2 /* * the time the current breath cycle was supposed to start */ static int start_current_breath_cycle = 0; -/* - * the time the current breath cycle was supposed to start - */ -// static int breath_cycle_duration = 125; //to do replace this value by the real one - /* * Phase of the ventilation * This should always be one of - * INSPIRATION | INSPIRATORY_PAUSE - * | EXPIRATION | EXPIRATORY_PAUSE + * INSPIRATION | EXPIRATION + * The pauses are obtained through the mechanical parts of the system + * and not the software parts. + * The inspiration pause is obtained through the maximal pressure + * The expiration pause is obtained through the PEEP valve */ -static int ventilation_phase = EXPIRATORY_PAUSE; +static int ventilation_phase = EXPIRATION; uint32_t get_circuit_pressure() { @@ -50,21 +46,17 @@ uint32_t get_circuit_pressure() { void ventilation(){ + /*Attention there is no initialisation of start_current_breath_cycle for the + * ventilation to start as soon as the code is called this will lead to a + * a waiting period of breath_cycle_duration for the first ventilation preiod + */ switch (ventilation_phase) { - case EXPIRATORY_PAUSE: + case EXPIRATION: start_inspiration(); break; case INSPIRATION: - // statements - break; - - case INSPIRATORY_PAUSE: - // statements - break; - - case EXPIRATION: - // statements + start_expiration(); break; default: @@ -74,27 +66,45 @@ void ventilation(){ void start_inspiration(){ uint32_t current_time = get_current_time(); - uint32_t RR = 0; - uint32_t breath_cycle_duration = 125; - if (get_respiratory_rate(& RR) == STATUS_OK) { - breath_cycle_duration = RR / 60000; - } + uint32_t RR = 15; + uint32_t breath_cycle_duration; + get_respiratory_rate(&RR); + breath_cycle_duration = 60000 / RR; if (current_time >= start_current_breath_cycle + breath_cycle_duration) { + if (get_circuit_pressure() < MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { start_current_breath_cycle = current_time; - if (get_circuit_pressure() > MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { - dss(); - } else { open_inspiratory_valve(); ventilation_phase = INSPIRATION; } } } +void start_expiration(){ + uint32_t current_time = get_current_time(); + uint32_t selected_inspiratory_time; + get_selected_inspiratory_time(&selected_inspiratory_time); + if (current_time >= start_current_breath_cycle + selected_inspiratory_time) { + if (get_circuit_pressure() > MIN_CIRCUIT_PRESSURE_FOR_OPENING_EXP_VALVE_CSP){ + close_inspiratory_valve(); + open_expiratory_valve(); + ventilation_phase = EXPIRATION; + } + } +} + /* * function for test only */ void reset_to_inspiration_start(){ - ventilation_phase = EXPIRATORY_PAUSE; + ventilation_phase = EXPIRATION; +} + +int get_ventilation_phase() { + return ventilation_phase; +} + +int get_start_current_breath_cycle() { + return start_current_breath_cycle; } diff --git a/test/stubs/clinician_input_stub.c b/test/stubs/clinician_input_stub.c index 02d45f7..0a9f64c 100644 --- a/test/stubs/clinician_input_stub.c +++ b/test/stubs/clinician_input_stub.c @@ -12,13 +12,9 @@ static uint32_t* RR_to_return; static status_t* status_RR_to_return; static int RR_current_call = 0; -void set_respiratory_rate(uint32_t* RR, status_t* status, size_t size){ - free(RR_to_return); - free(status_RR_to_return); - RR_to_return = (uint32_t*) malloc(sizeof(*RR) * size); - status_RR_to_return = (status_t*) malloc(sizeof(*status) * size); - memcpy(RR_to_return, RR, sizeof(*RR) * size); - memcpy(status_RR_to_return, status, sizeof(*status) * size); +void set_respiratory_rate(uint32_t* RR, status_t* status) { + RR_to_return = RR; + status_RR_to_return = status; RR_current_call = 0; } diff --git a/test/stubs/clinician_input_stub.h b/test/stubs/clinician_input_stub.h index 1fac697..0a9102a 100644 --- a/test/stubs/clinician_input_stub.h +++ b/test/stubs/clinician_input_stub.h @@ -1,5 +1,5 @@ /* - * clinician_info_stub.h + * clinician_input_stub.h * * Stub for the function that retreive the clinician inputs */ @@ -8,7 +8,7 @@ #include #include "platform/common.h" -void set_respiratory_rate(uint32_t* RR, status_t* status, size_t size); +void set_respiratory_rate(uint32_t* RR, status_t* status); status_t get_respiratory_rate(uint32_t * RR); diff --git a/test/stubs/system_info_stub.c b/test/stubs/system_info_stub.c index bda972a..9bab6df 100644 --- a/test/stubs/system_info_stub.c +++ b/test/stubs/system_info_stub.c @@ -10,10 +10,8 @@ static int* time_to_return; static int current_call = 0; -void set_current_time(int* times, size_t size){ - free(time_to_return); - time_to_return = (int*) malloc(sizeof(*times) * size); - memcpy(time_to_return, times, sizeof(*times) * size); +void set_current_time(int* times){ + time_to_return = times; current_call = 0; } diff --git a/test/stubs/system_info_stub.h b/test/stubs/system_info_stub.h index d3f0395..38f4893 100644 --- a/test/stubs/system_info_stub.h +++ b/test/stubs/system_info_stub.h @@ -6,7 +6,7 @@ #include -void set_current_time(int* times, size_t size); +void set_current_time(int* times); int get_current_time(); diff --git a/test/test_runner.c b/test/test_runner.c index 3fb6edc..8e55e20 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -2,12 +2,28 @@ #include "test_util.h" int main(int argc, char **argv) { - test(startVentilation_afterOneInspiration_openInspiratoryValve, - "startVentilation_afterOneInspiration_openInspiratoryValve"); - test(startVentilation_duringInspiration_doesNotopenInspiratoryValve, - "startVentilation_duringInspiration_doesNotopenInspiratoryValve"); test(getCircuitPressure_validValues_returnsMeanPressure, - "getCircuitPressure_validValues_returnsMeanPressure"); + "getCircuitPressure_validValues_returnsMeanPressure"); + test(startInspiration_afterOneInspiration_openInspiratoryValve, + "startInspiration_afterOneInspiration_openInspiratoryValve"); + test(startExpiration_afterOneInspiration_closeInspiratoryValve, + "startExpiration_afterOneInspiration_closeInspiratoryValve"); + test(startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration, + "startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration"); + test(startExpiration_afterOneInspiration_opensExpiratoryValve, + "startExpiration_afterOneInspiration_opensExpiratoryValve"); + test(startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle, + "startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle"); + test(startExpiration_afterThreeInspiration_updatesVentilationPhase, + "startExpiration_afterThreeInspiration_updatesVentilationPhase"); + test(startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle, + "startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle"); + test(startInspiration_duringInspiration_doesNotChangeVentilationPhase, + "startInspiration_duringInspiration_doesNotChangeVentilationPhase"); + test(startInspiration_duringInspiration_doesNotopenInspiratoryValve, + "startInspiration_duringInspiration_doesNotopenInspiratoryValve"); + test(startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle, + "startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle"); int result = print_result(); return !result; diff --git a/test/ventilation_test.c b/test/ventilation_test.c index 234056e..0246ca2 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -12,29 +12,50 @@ #include "test_util.h" #include "platform/common.h" - +//test functions defined in ventilation.c only void reset_to_inspiration_start(); +int get_ventilation_phase(); +int get_start_current_breath_cycle(); -int startVentilation_afterOneInspiration_openInspiratoryValve() { - //initialize the function get_current_time - int* times = (int*) malloc(1*sizeof(int)); - times[0] = 130; - set_current_time(times, 1); +int getCircuitPressure_validValues_returnsMeanPressure() { + uint32_t inspiratory[2] = {35, 53}; + uint32_t expiratory[2] = {40, 53}; + + status_t status[2] = {STATUS_OK, STATUS_OK}; + + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + uint32_t circuit_pressure = get_circuit_pressure(); + //The integer division of an odd number by two is the floor value + assertTrue(circuit_pressure == 37); + + circuit_pressure = get_circuit_pressure(); + //The integer divion of an even number by two is as expected + assertTrue(circuit_pressure == 53); + +} + +int startInspiration_afterOneInspiration_openInspiratoryValve() { //initialize the function get_respiratory_rate - uint32_t RR[1] = {7500000}; + uint32_t RR[1] = {20}; status_t status[1] = {STATUS_OK}; - set_respiratory_rate(RR, status, 1); + set_respiratory_rate(RR, status); + + //initialize the function get_current_time + int breath_cycle_duration = 60000/RR[0]; + int times[1] = {breath_cycle_duration}; + set_current_time(times); //initialize the function to get circuit pressure - uint32_t inspiratory[2] = {12, 53}; - uint32_t expiratory[2] = {14, 53}; - status_t status_pressure[2] = {STATUS_OK, STATUS_OK}; - set_inspiratory_pressure(inspiratory, status_pressure); - set_expiratory_pressure(expiratory, status_pressure); + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); //reinitialize the system to be sure that the valve wasn't previously open close_inspiratory_valve(); + reset_to_inspiration_start(); start_inspiration(); @@ -42,22 +63,158 @@ int startVentilation_afterOneInspiration_openInspiratoryValve() { assertTrue(inspiratory_valve_status == VALVE_OPEN); } -int startVentilation_duringInspiration_doesNotopenInspiratoryValve() { - int* times = (int*) malloc(1*sizeof(int)); - times[0] = 0; - set_current_time (times, 1); +int startExpiration_afterOneInspiration_closeInspiratoryValve() { + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + int breath_cycle_duration = 60000/RR[0]; + + //initialize the selected inspiratory time + uint32_t insp_time [1] = {breath_cycle_duration/2}; + set_selected_inspiratory_time(insp_time, status); + + //initialize the function get_current_time + int times[1] = {breath_cycle_duration + insp_time[0]}; + set_current_time(times); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {40}; + uint32_t expiratory[1] = {41}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + //reinitialize the system to be sure that the valve wasn't previously open + start_expiration(); + + int inspiratory_valve_status = get_inspiratory_valve_status(); + assertTrue(inspiratory_valve_status == VALVE_CLOSE); +} + +int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + //initialize the function get_current_time + int breath_cycle_duration = 60000/RR[0]; + int times[1] = {(breath_cycle_duration) * 2}; + set_current_time(times); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + reset_to_inspiration_start(); + + start_inspiration(); + + int ventilation_phase = get_ventilation_phase(); + assertTrue(ventilation_phase == 1); +} + +int startExpiration_afterOneInspiration_opensExpiratoryValve() { //initialize the function get_respiratory_rate - uint32_t RR[1] = {7500000}; + uint32_t RR[1] = {20}; status_t status[1] = {STATUS_OK}; - set_respiratory_rate(RR, status, 1); + set_respiratory_rate(RR, status); + + int breath_cycle_duration = 60000/RR[0]; + + //initialize the selected inspiratory time + uint32_t insp_time [1] = {breath_cycle_duration/2}; + set_selected_inspiratory_time(insp_time, status); + + //initialize the function get_current_time + int times[1] = {breath_cycle_duration * 2 + insp_time[0]}; + set_current_time(times); //initialize the function to get circuit pressure - uint32_t inspiratory[2] = {35, 53}; - uint32_t expiratory[2] = {40, 53}; - status_t status_pressure[2] = {STATUS_OK, STATUS_OK}; - set_inspiratory_pressure(inspiratory, status_pressure); - set_expiratory_pressure(expiratory, status_pressure); + uint32_t inspiratory[1] = {40}; + uint32_t expiratory[1] = {41}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + //reinitialize the system to be sure that the valve wasn't previously open + start_expiration(); + + int expiratory_valve_status = get_expiratory_valve_status(); + assertTrue(expiratory_valve_status == VALVE_OPEN); +} + +int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle() { + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + //initialize the function get_current_time + int breath_cycle_duration = 60000/RR[0]; + int time = (breath_cycle_duration) * 3; + int times[1] = {time}; + set_current_time(times); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + reset_to_inspiration_start(); + + start_inspiration(); + + int time_of_start_current_breath_cycle = get_start_current_breath_cycle(); + assertTrue(time_of_start_current_breath_cycle == time); +} + +int startExpiration_afterThreeInspiration_updatesVentilationPhase() { + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + int breath_cycle_duration = 60000/RR[0]; + + //initialize the selected inspiratory time + uint32_t insp_time [1] = {breath_cycle_duration/2}; + set_selected_inspiratory_time(insp_time, status); + + //initialize the function get_current_time + int times[1] = {breath_cycle_duration * 3 + insp_time[0]}; + set_current_time(times); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {40}; + uint32_t expiratory[1] = {41}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + //reinitialize the system to be sure that the valve wasn't previously open + start_expiration(); + + int ventilation_phase = get_ventilation_phase(); + assertTrue(ventilation_phase == 2); +} + +int startInspiration_duringInspiration_doesNotopenInspiratoryValve() { + int times[1] = {0}; + set_current_time (times); + + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); close_inspiratory_valve(); reset_to_inspiration_start(); @@ -68,19 +225,78 @@ int startVentilation_duringInspiration_doesNotopenInspiratoryValve() { assertTrue(inspiratory_valve_status == VALVE_CLOSE); } -int getCircuitPressure_validValues_returnsMeanPressure() { - uint32_t inspiratory[2] = {35, 53}; - uint32_t expiratory[2] = {40, 53}; +int startInspiration_duringInspiration_doesNotChangeVentilationPhase() { + int times[1] = {0}; + set_current_time (times); - status_t status[2] = {STATUS_OK, STATUS_OK}; + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; set_inspiratory_pressure(inspiratory, status); set_expiratory_pressure(expiratory, status); - uint32_t circuit_pressure = get_circuit_pressure(); - assertTrue(circuit_pressure == 37); + reset_to_inspiration_start(); + + start_inspiration(); - circuit_pressure = get_circuit_pressure(); - assertTrue(circuit_pressure == 53); + int ventilation_phase = get_ventilation_phase(); + assertTrue(ventilation_phase == 2); +} + +int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle() { + int time = 0; + int times[1] = {time}; + set_current_time (times); + + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + reset_to_inspiration_start(); + + start_inspiration(); + + int time_of_start_current_breath_cycle = get_start_current_breath_cycle(); + assertTrue(time_of_start_current_breath_cycle != time); +} + +int startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle() { + //initialize the function get_current_time + //initialize the function get_respiratory_rate + uint32_t RR[1] = {20}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + + + //initialize the function get_current_time + int breath_cycle_duration = 60000/RR[0]; + int time = (breath_cycle_duration + 1) * 4; + int times[1] = {time}; + set_current_time(times); + + //initialize the function to get circuit pressure + uint32_t inspiratory[1] = {100}; + uint32_t expiratory[1] = {100}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); + + reset_to_inspiration_start(); + + start_inspiration(); + int time_of_start_current_breath_cycle = get_start_current_breath_cycle(); + assertTrue(time_of_start_current_breath_cycle != time); } diff --git a/test/ventilation_test.h b/test/ventilation_test.h index 409772d..3f1a5bb 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -3,8 +3,24 @@ * */ -int startVentilation_afterOneInspiration_openInspiratoryValve(); +int getCircuitPressure_validValues_returnsMeanPressure(); -int startVentilation_duringInspiration_doesNotopenInspiratoryValve(); +int startInspiration_afterOneInspiration_openInspiratoryValve(); -int getCircuitPressure_validValues_returnsMeanPressure(); +int startExpiration_afterOneInspiration_closeInspiratoryValve(); + +int startExpiration_afterOneInspiration_opensExpiratoryValve(); + +int startExpiration_afterThreeInspiration_updatesVentilationPhase(); + +int startInspiration_duringInspiration_doesNotopenInspiratoryValve(); + +int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration(); + +int startInspiration_duringInspiration_doesNotChangeVentilationPhase(); + +int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle(); + +int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle(); + +int startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle();