From 79890877023761a0e0b1504137b79b71ea5ac6d0 Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Mon, 16 Nov 2020 08:05:48 -0800 Subject: [PATCH 1/7] SRS-0010 - Updates the test for SRS0010 --- src/application/tasks/ventilation.c | 13 ++++- test/stubs/clinician_input_stub.h | 2 +- test/test_runner.c | 8 +++ test/ventilation_test.c | 85 ++++++++++++++++++++++++++++- test/ventilation_test.h | 8 +++ 5 files changed, 110 insertions(+), 6 deletions(-) diff --git a/src/application/tasks/ventilation.c b/src/application/tasks/ventilation.c index 7e76a8b..ab7ba1f 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -76,9 +76,8 @@ 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; - } + get_respiratory_rate(& RR); + breath_cycle_duration = RR / 60000; if (current_time >= start_current_breath_cycle + breath_cycle_duration) { start_current_breath_cycle = current_time; if (get_circuit_pressure() > MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { @@ -98,3 +97,11 @@ void start_inspiration(){ void reset_to_inspiration_start(){ ventilation_phase = EXPIRATORY_PAUSE; } + +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.h b/test/stubs/clinician_input_stub.h index 1fac697..09184ac 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 */ diff --git a/test/test_runner.c b/test/test_runner.c index 3fb6edc..57fb986 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -4,11 +4,19 @@ int main(int argc, char **argv) { test(startVentilation_afterOneInspiration_openInspiratoryValve, "startVentilation_afterOneInspiration_openInspiratoryValve"); + test(startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration, + "startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration"); + test(startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle, + "startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle"); + test(startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle,"startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle"); + test(startVentilation_duringInspiration_doesNotChangeVentilationPhase, + "startVentilation_duringInspiration_doesNotChangeVentilationPhase"), test(startVentilation_duringInspiration_doesNotopenInspiratoryValve, "startVentilation_duringInspiration_doesNotopenInspiratoryValve"); test(getCircuitPressure_validValues_returnsMeanPressure, "getCircuitPressure_validValues_returnsMeanPressure"); + int result = print_result(); return !result; } diff --git a/test/ventilation_test.c b/test/ventilation_test.c index 234056e..0e37002 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -11,9 +11,12 @@ #include "stubs/sensor_stub.h" #include "test_util.h" #include "platform/common.h" +#include - +//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 @@ -35,6 +38,7 @@ int startVentilation_afterOneInspiration_openInspiratoryValve() { //reinitialize the system to be sure that the valve wasn't previously open close_inspiratory_valve(); + reset_to_inspiration_start(); start_inspiration(); @@ -42,9 +46,59 @@ int startVentilation_afterOneInspiration_openInspiratoryValve() { assertTrue(inspiratory_valve_status == VALVE_OPEN); } +int startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration() { + //initialize the function get_current_time + int* times = (int*) malloc(1*sizeof(int)); + times[0] = 260; + set_current_time(times, 1); + + //initialize the function get_respiratory_rate + uint32_t* RR = (uint32_t*) malloc(1*sizeof(uint32_t)); + RR[0] = 7500000; + status_t* status= (status_t*) malloc(1*sizeof(status_t)); + status[0] = STATUS_OK; + set_respiratory_rate(RR, status, 1); + + //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); + + reset_to_inspiration_start(); + + start_inspiration(); + + int ventilation_phase = get_ventilation_phase(); + assertTrue(ventilation_phase == 1); +} + +int startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle() { + //initialize the function get_current_time + int* times = (int*) malloc(1*sizeof(int)); + int time = 390; + times[0] = time; + set_current_time(times, 1); + + //initialize the function get_respiratory_rate + uint32_t* RR = (uint32_t*) malloc(1*sizeof(uint32_t)); + RR[0] = 7500000; + status_t* status= (status_t*) malloc(1*sizeof(status_t)); + status[0] = STATUS_OK; + set_respiratory_rate(RR, status, 1); + + 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 startVentilation_duringInspiration_doesNotopenInspiratoryValve() { int* times = (int*) malloc(1*sizeof(int)); - times[0] = 0; + times[0] = 150; set_current_time (times, 1); //initialize the function get_respiratory_rate @@ -84,3 +138,30 @@ int getCircuitPressure_validValues_returnsMeanPressure() { assertTrue(circuit_pressure == 53); } + +int startVentilation_duringInspiration_doesNotChangeVentilationPhase() { + int* times = (int*) malloc(1*sizeof(int)); + times[0] = 150; + set_current_time (times, 1); + + reset_to_inspiration_start(); + + start_inspiration(); + + int ventilation_phase = get_ventilation_phase(); + assertTrue(ventilation_phase == 4); +} + +int startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle() { + int* times = (int*) malloc(1*sizeof(int)); + int time = 150; + times[0] = time; + set_current_time (times, 1); + + 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..338980c 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -7,4 +7,12 @@ int startVentilation_afterOneInspiration_openInspiratoryValve(); int startVentilation_duringInspiration_doesNotopenInspiratoryValve(); +int startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration(); + +int startVentilation_duringInspiration_doesNotChangeVentilationPhase(); + +int startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle(); + +int startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle(); + int getCircuitPressure_validValues_returnsMeanPressure(); From aa6b53a64226c0f7e46281d9097875185626f4b4 Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Mon, 23 Nov 2020 13:28:40 -0800 Subject: [PATCH 2/7] Update stub to remove dynamic memory allocation --- test/stubs/clinician_input_stub.c | 10 ++-- test/stubs/clinician_input_stub.h | 2 +- test/stubs/system_info_stub.c | 6 +-- test/stubs/system_info_stub.h | 2 +- test/test_runner.c | 24 +++++----- test/ventilation_test.c | 80 ++++++++++++++----------------- test/ventilation_test.h | 12 ++--- 7 files changed, 60 insertions(+), 76 deletions(-) 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 09184ac..0a9102a 100644 --- a/test/stubs/clinician_input_stub.h +++ b/test/stubs/clinician_input_stub.h @@ -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 57fb986..3efb024 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -2,21 +2,21 @@ #include "test_util.h" int main(int argc, char **argv) { - test(startVentilation_afterOneInspiration_openInspiratoryValve, - "startVentilation_afterOneInspiration_openInspiratoryValve"); - test(startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration, - "startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration"); - test(startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle, - "startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle"); - test(startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle,"startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle"); - test(startVentilation_duringInspiration_doesNotChangeVentilationPhase, - "startVentilation_duringInspiration_doesNotChangeVentilationPhase"), - test(startVentilation_duringInspiration_doesNotopenInspiratoryValve, - "startVentilation_duringInspiration_doesNotopenInspiratoryValve"); + test(startInspiration_afterOneInspiration_openInspiratoryValve, + "startInspiration_afterOneInspiration_openInspiratoryValve"); + test(startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration, + "startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration"); + test(startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle, + "startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle"); + test(startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle, + "startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle"); + test(startInspiration_duringInspiration_doesNotChangeVentilationPhase, + "startInspiration_duringInspiration_doesNotChangeVentilationPhase"), + test(startInspiration_duringInspiration_doesNotopenInspiratoryValve, + "startInspiration_duringInspiration_doesNotopenInspiratoryValve"); test(getCircuitPressure_validValues_returnsMeanPressure, "getCircuitPressure_validValues_returnsMeanPressure"); - int result = print_result(); return !result; } diff --git a/test/ventilation_test.c b/test/ventilation_test.c index 0e37002..b04f051 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -11,23 +11,21 @@ #include "stubs/sensor_stub.h" #include "test_util.h" #include "platform/common.h" -#include //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 startInspiration_afterOneInspiration_openInspiratoryValve() { //initialize the function get_respiratory_rate - uint32_t RR[1] = {7500000}; + uint32_t RR[1] = {7500000}; status_t status[1] = {STATUS_OK}; - set_respiratory_rate(RR, status, 1); + set_respiratory_rate(RR, status); + + //initialize the function get_current_time + int times[1] = {RR[0] + 1}; + set_current_time(times); //initialize the function to get circuit pressure uint32_t inspiratory[2] = {12, 53}; @@ -46,18 +44,15 @@ int startVentilation_afterOneInspiration_openInspiratoryValve() { assertTrue(inspiratory_valve_status == VALVE_OPEN); } -int startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration() { - //initialize the function get_current_time - int* times = (int*) malloc(1*sizeof(int)); - times[0] = 260; - set_current_time(times, 1); - +int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { //initialize the function get_respiratory_rate - uint32_t* RR = (uint32_t*) malloc(1*sizeof(uint32_t)); - RR[0] = 7500000; - status_t* status= (status_t*) malloc(1*sizeof(status_t)); - status[0] = STATUS_OK; - set_respiratory_rate(RR, status, 1); + uint32_t RR[1] = {7500000}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); + + //initialize the function get_current_time + int times[1] = {RR[0] * 2 + 2}; + set_current_time(times); //initialize the function to get circuit pressure uint32_t inspiratory[2] = {12, 53}; @@ -74,19 +69,17 @@ int startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration() { assertTrue(ventilation_phase == 1); } -int startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle() { +int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle() { //initialize the function get_current_time - int* times = (int*) malloc(1*sizeof(int)); - int time = 390; - times[0] = time; - set_current_time(times, 1); +//initialize the function get_respiratory_rate + uint32_t RR[1] = {7500000}; + status_t status[1] = {STATUS_OK}; + set_respiratory_rate(RR, status); - //initialize the function get_respiratory_rate - uint32_t* RR = (uint32_t*) malloc(1*sizeof(uint32_t)); - RR[0] = 7500000; - status_t* status= (status_t*) malloc(1*sizeof(status_t)); - status[0] = STATUS_OK; - set_respiratory_rate(RR, status, 1); + //initialize the function get_current_time + int time = RR[0] * 3 + 3; + int times[1] = {time}; + set_current_time(times); reset_to_inspiration_start(); @@ -96,15 +89,14 @@ int startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle() { assertTrue(time_of_start_current_breath_cycle == time); } -int startVentilation_duringInspiration_doesNotopenInspiratoryValve() { - int* times = (int*) malloc(1*sizeof(int)); - times[0] = 150; - set_current_time (times, 1); +int startInspiration_duringInspiration_doesNotopenInspiratoryValve() { + int times[1] = {0}; + set_current_time (times); //initialize the function get_respiratory_rate uint32_t RR[1] = {7500000}; status_t status[1] = {STATUS_OK}; - set_respiratory_rate(RR, status, 1); + set_respiratory_rate(RR, status); //initialize the function to get circuit pressure uint32_t inspiratory[2] = {35, 53}; @@ -139,10 +131,9 @@ int getCircuitPressure_validValues_returnsMeanPressure() { } -int startVentilation_duringInspiration_doesNotChangeVentilationPhase() { - int* times = (int*) malloc(1*sizeof(int)); - times[0] = 150; - set_current_time (times, 1); +int startInspiration_duringInspiration_doesNotChangeVentilationPhase() { + int times[1] = {0}; + set_current_time (times); reset_to_inspiration_start(); @@ -152,11 +143,10 @@ int startVentilation_duringInspiration_doesNotChangeVentilationPhase() { assertTrue(ventilation_phase == 4); } -int startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle() { - int* times = (int*) malloc(1*sizeof(int)); - int time = 150; - times[0] = time; - set_current_time (times, 1); +int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle() { + int time = 0; + int times[1] = {time}; + set_current_time (times); reset_to_inspiration_start(); diff --git a/test/ventilation_test.h b/test/ventilation_test.h index 338980c..3576d83 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -3,16 +3,16 @@ * */ -int startVentilation_afterOneInspiration_openInspiratoryValve(); +int startInspiration_afterOneInspiration_openInspiratoryValve(); -int startVentilation_duringInspiration_doesNotopenInspiratoryValve(); +int startInspiration_duringInspiration_doesNotopenInspiratoryValve(); -int startVentilation_afterOneInspiration_setsVentilationPhaseToInspiration(); +int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration(); -int startVentilation_duringInspiration_doesNotChangeVentilationPhase(); +int startInspiration_duringInspiration_doesNotChangeVentilationPhase(); -int startVentilation_afterTwoInspirations_updatesStartCurrentBreathCycle(); +int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle(); -int startVentilation_duringInspiration_doesNotUpdatesStartOfcurrentBreathCycle(); +int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle(); int getCircuitPressure_validValues_returnsMeanPressure(); From 0a5525f7892a62faa5e273ae005b39bd058864cb Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Sun, 29 Nov 2020 09:53:29 -0800 Subject: [PATCH 3/7] Update breath cycle duration code until SRS-0001 is impolemented --- src/application/tasks/ventilation.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/application/tasks/ventilation.c b/src/application/tasks/ventilation.c index ab7ba1f..b8e4fe1 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -74,10 +74,10 @@ void ventilation(){ void start_inspiration(){ uint32_t current_time = get_current_time(); - uint32_t RR = 0; - uint32_t breath_cycle_duration = 125; + uint32_t RR = 15; + uint32_t breath_cycle_duration; get_respiratory_rate(& RR); - breath_cycle_duration = RR / 60000; + breath_cycle_duration = 60000 / RR; if (current_time >= start_current_breath_cycle + breath_cycle_duration) { start_current_breath_cycle = current_time; if (get_circuit_pressure() > MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { From d9a00095b58b3f438a806e86eca6df08255c18c6 Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Sun, 29 Nov 2020 10:52:36 -0800 Subject: [PATCH 4/7] Add test chen circuit pressure too high to start inspiration --- src/application/tasks/ventilation.c | 13 ++- test/test_runner.c | 20 ++-- test/ventilation_test.c | 138 ++++++++++++++++++++-------- test/ventilation_test.h | 4 +- 4 files changed, 118 insertions(+), 57 deletions(-) diff --git a/src/application/tasks/ventilation.c b/src/application/tasks/ventilation.c index b8e4fe1..1920c7f 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -24,11 +24,6 @@ */ 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 @@ -50,6 +45,10 @@ 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: start_inspiration(); @@ -76,13 +75,13 @@ void start_inspiration(){ uint32_t current_time = get_current_time(); uint32_t RR = 15; uint32_t breath_cycle_duration; - get_respiratory_rate(& RR); + get_respiratory_rate(&RR); breath_cycle_duration = 60000 / RR; if (current_time >= start_current_breath_cycle + breath_cycle_duration) { - start_current_breath_cycle = current_time; if (get_circuit_pressure() > MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { dss(); } else { + start_current_breath_cycle = current_time; open_inspiratory_valve(); ventilation_phase = INSPIRATION; } diff --git a/test/test_runner.c b/test/test_runner.c index 3efb024..94bf0fe 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -2,20 +2,22 @@ #include "test_util.h" int main(int argc, char **argv) { + test(getCircuitPressure_validValues_returnsMeanPressure, + "getCircuitPressure_validValues_returnsMeanPressure"); test(startInspiration_afterOneInspiration_openInspiratoryValve, - "startInspiration_afterOneInspiration_openInspiratoryValve"); + "startInspiration_afterOneInspiration_openInspiratoryValve"); test(startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration, - "startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration"); + "startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration"); test(startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle, - "startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle"); + "startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle"); test(startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle, - "startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle"); + "startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle"); test(startInspiration_duringInspiration_doesNotChangeVentilationPhase, - "startInspiration_duringInspiration_doesNotChangeVentilationPhase"), - test(startInspiration_duringInspiration_doesNotopenInspiratoryValve, - "startInspiration_duringInspiration_doesNotopenInspiratoryValve"); - test(getCircuitPressure_validValues_returnsMeanPressure, - "getCircuitPressure_validValues_returnsMeanPressure"); + "startInspiration_duringInspiration_doesNotChangeVentilationPhase"); + test(startInspiration_duringInspiration_doesNotopenInspiratoryValve, + "startInspiration_duringInspiration_doesNotopenInspiratoryValve"); + test(startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle, + "startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle"); int result = print_result(); return !result; diff --git a/test/ventilation_test.c b/test/ventilation_test.c index b04f051..c034ddc 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -17,22 +17,41 @@ void reset_to_inspiration_start(); int get_ventilation_phase(); int get_start_current_breath_cycle(); +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); //initialize the function get_current_time - int times[1] = {RR[0] + 1}; + int breath_cycle_duration = 60000/RR[0]; + int times[1] = {breath_cycle_duration + 1}; 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(); @@ -46,20 +65,20 @@ int startInspiration_afterOneInspiration_openInspiratoryValve() { int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { //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); //initialize the function get_current_time - int times[1] = {RR[0] * 2 + 2}; + int breath_cycle_duration = 60000/RR[0]; + int times[1] = {(breath_cycle_duration + 1) * 2}; 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); reset_to_inspiration_start(); @@ -70,17 +89,23 @@ int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { } int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle() { - //initialize the function get_current_time -//initialize the function get_respiratory_rate - uint32_t RR[1] = {7500000}; + //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 time = RR[0] * 3 + 3; + int breath_cycle_duration = 60000/RR[0]; + int time = (breath_cycle_duration + 1) * 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(); @@ -94,16 +119,15 @@ int startInspiration_duringInspiration_doesNotopenInspiratoryValve() { set_current_time (times); //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); //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] = {12}; + uint32_t expiratory[1] = {14}; + set_inspiratory_pressure(inspiratory, status); + set_expiratory_pressure(expiratory, status); close_inspiratory_valve(); reset_to_inspiration_start(); @@ -114,27 +138,21 @@ int startInspiration_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); - - circuit_pressure = get_circuit_pressure(); - assertTrue(circuit_pressure == 53); - -} - -int startInspiration_duringInspiration_doesNotChangeVentilationPhase() { - int times[1] = {0}; - set_current_time (times); - reset_to_inspiration_start(); start_inspiration(); @@ -148,6 +166,46 @@ int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle() 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_circuitPressureToHigh_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(); diff --git a/test/ventilation_test.h b/test/ventilation_test.h index 3576d83..3a3c3d1 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -3,6 +3,8 @@ * */ +int getCircuitPressure_validValues_returnsMeanPressure(); + int startInspiration_afterOneInspiration_openInspiratoryValve(); int startInspiration_duringInspiration_doesNotopenInspiratoryValve(); @@ -15,4 +17,4 @@ int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle(); int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle(); -int getCircuitPressure_validValues_returnsMeanPressure(); +int startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle(); From 7ddaddef2cddad5d9632f2f634f59f235d11fda8 Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Mon, 30 Nov 2020 09:02:41 -0800 Subject: [PATCH 5/7] Clean code --- src/application/tasks/ventilation.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/application/tasks/ventilation.c b/src/application/tasks/ventilation.c index 1920c7f..28c1a1e 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -78,9 +78,7 @@ void start_inspiration(){ 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) { - dss(); - } else { + if (get_circuit_pressure() < MAX_CIRCUIT_PRESSURE_FOR_OPENING_INS_VALVE_CSP) { start_current_breath_cycle = current_time; open_inspiratory_valve(); ventilation_phase = INSPIRATION; From 461634c04ab52273b55355a8f4ef37948b868a4a Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Mon, 30 Nov 2020 11:55:24 -0800 Subject: [PATCH 6/7] Indent and cosmetologic fixes --- test/test_runner.c | 2 +- test/ventilation_test.c | 6 +++--- test/ventilation_test.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/test/test_runner.c b/test/test_runner.c index 94bf0fe..88bb0e4 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -16,7 +16,7 @@ int main(int argc, char **argv) { "startInspiration_duringInspiration_doesNotChangeVentilationPhase"); test(startInspiration_duringInspiration_doesNotopenInspiratoryValve, "startInspiration_duringInspiration_doesNotopenInspiratoryValve"); - test(startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle, + test(startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle, "startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle"); int result = print_result(); diff --git a/test/ventilation_test.c b/test/ventilation_test.c index c034ddc..eaf2108 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -50,8 +50,8 @@ int startInspiration_afterOneInspiration_openInspiratoryValve() { //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); + 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(); @@ -185,7 +185,7 @@ int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle() assertTrue(time_of_start_current_breath_cycle != time); } -int startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle() { +int startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle() { //initialize the function get_current_time //initialize the function get_respiratory_rate uint32_t RR[1] = {20}; diff --git a/test/ventilation_test.h b/test/ventilation_test.h index 3a3c3d1..f9daa5e 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -17,4 +17,4 @@ int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle(); int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle(); -int startInspiration_circuitPressureToHigh_DoesNotStartCurrentBreathCycle(); +int startInspiration_circuitPressureTooHigh_DoesNotStartCurrentBreathCycle(); From 7b75996cf092b2b2f1b7c0867b85bc0a83d73e8d Mon Sep 17 00:00:00 2001 From: Laure Millet Date: Sun, 29 Nov 2020 11:57:26 -0800 Subject: [PATCH 7/7] Implement SRS-0015 and SRS-0020 --- include/application/tasks/ventilation.h | 11 +++ src/application/tasks/ventilation.c | 40 ++++++----- test/test_runner.c | 6 ++ test/ventilation_test.c | 95 +++++++++++++++++++++++-- test/ventilation_test.h | 6 ++ 5 files changed, 137 insertions(+), 21 deletions(-) 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 28c1a1e..91e2213 100644 --- a/src/application/tasks/ventilation.c +++ b/src/application/tasks/ventilation.c @@ -15,9 +15,7 @@ //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 @@ -27,11 +25,14 @@ static int start_current_breath_cycle = 0; /* * 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,20 +51,12 @@ void ventilation(){ * 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: @@ -86,13 +79,26 @@ void start_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() { diff --git a/test/test_runner.c b/test/test_runner.c index 88bb0e4..8e55e20 100644 --- a/test/test_runner.c +++ b/test/test_runner.c @@ -6,10 +6,16 @@ int main(int argc, char **argv) { "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, diff --git a/test/ventilation_test.c b/test/ventilation_test.c index eaf2108..0246ca2 100644 --- a/test/ventilation_test.c +++ b/test/ventilation_test.c @@ -44,7 +44,7 @@ int startInspiration_afterOneInspiration_openInspiratoryValve() { //initialize the function get_current_time int breath_cycle_duration = 60000/RR[0]; - int times[1] = {breath_cycle_duration + 1}; + int times[1] = {breath_cycle_duration}; set_current_time(times); //initialize the function to get circuit pressure @@ -63,6 +63,35 @@ int startInspiration_afterOneInspiration_openInspiratoryValve() { assertTrue(inspiratory_valve_status == VALVE_OPEN); } +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}; @@ -71,7 +100,7 @@ int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { //initialize the function get_current_time int breath_cycle_duration = 60000/RR[0]; - int times[1] = {(breath_cycle_duration + 1) * 2}; + int times[1] = {(breath_cycle_duration) * 2}; set_current_time(times); //initialize the function to get circuit pressure @@ -88,6 +117,35 @@ int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration() { assertTrue(ventilation_phase == 1); } +int startExpiration_afterOneInspiration_opensExpiratoryValve() { + //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 * 2 + 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 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}; @@ -96,7 +154,7 @@ int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle() { //initialize the function get_current_time int breath_cycle_duration = 60000/RR[0]; - int time = (breath_cycle_duration + 1) * 3; + int time = (breath_cycle_duration) * 3; int times[1] = {time}; set_current_time(times); @@ -114,6 +172,35 @@ int startInspiration_afterTwoInspirations_updatesStartCurrentBreathCycle() { 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); @@ -158,7 +245,7 @@ int startInspiration_duringInspiration_doesNotChangeVentilationPhase() { start_inspiration(); int ventilation_phase = get_ventilation_phase(); - assertTrue(ventilation_phase == 4); + assertTrue(ventilation_phase == 2); } int startInspiration_duringInspiration_doesNotUpdateStartOfcurrentBreathCycle() { diff --git a/test/ventilation_test.h b/test/ventilation_test.h index f9daa5e..3f1a5bb 100644 --- a/test/ventilation_test.h +++ b/test/ventilation_test.h @@ -7,6 +7,12 @@ int getCircuitPressure_validValues_returnsMeanPressure(); int startInspiration_afterOneInspiration_openInspiratoryValve(); +int startExpiration_afterOneInspiration_closeInspiratoryValve(); + +int startExpiration_afterOneInspiration_opensExpiratoryValve(); + +int startExpiration_afterThreeInspiration_updatesVentilationPhase(); + int startInspiration_duringInspiration_doesNotopenInspiratoryValve(); int startInspiration_afterOneInspiration_setsVentilationPhaseToInspiration();