auto_kernel.c

// NOTICE: do not edit this file it is autogenerated
    
    struct state
    {
      // Desired interval between writes to system log
      unsigned long LOG_INTERVAL;
      // Maximum log size
      unsigned long MAX_LOG_SIZE;
      // Time that alarms are suspended for by user pressing the "Alarm
      // silence" button.
      byte ALARM_SUSPEND_DURATION;
      // Patient weight
      unsigned int PATIENT_WEIGHT;
      // Patient height, required for calculating ideal body weight
      unsigned int PATIENT_HEIGHT;
      // Patient gender, required for calculating ideal body weight
      enum PATIENT_GENDER;
      // Ideal body weight, used for expressing volumes in terms of ml per kg
      // of ideal weight.
      unsigned int IDEAL_BODY_WEIGHT;
      // Desired tidal volume [VCV, PRVC]
      unsigned int TV;
      // Desired inspiratory pressure (Pi),  [PSV, PCV]
      int SET_PI;
      // inspiration trigger [PSV]
      byte INSPIRATION_FLOW_TRIGGER;
      // inspiration trigger [PSV]
      byte INSP_P_TRIGGER;
      // expiratory termination trigger (percent of peak inspiratory flow)
      // (PSV)
      byte EXP_TERMINATION_TRIGGER;
      // inspiratory time (which together with respiratory rate imply IE)
      unsigned int INSP_TIME;
      // In PCV and VCV modes this is the rate, however synchronised modes this
      // value is the minimum rate.
      byte MIN_RR;
      // PEEP
      byte SET_PEEP;
      // FiO2
      byte SET_FIO2;
      enum VENTILATION_MODE;
      // Battery status
      byte BATTERY;
      // Mains electricity power supply status
      unsigned int MAINS;
      // Combined battery and mains power status
      byte POWER;
      // Oxygen supply line pressure
      unsigned int OXYGEN_LINE;
      // Air supply line pressure
      unsigned int AIR_LINE;
      // Internal ventilator temperature
      unsigned int TEMPERATURE;
      // Observed circuit pressure
      int P;
      // Observed respiratory rate
      unsigned int RR;
      // Primary pressure sensor value
      int P1;
      // Secondary pressure sensor value
      int P2;
      // Gas flow recorded by the inspiratory manifold sensor
      unsigned int FI;
      // Gas flow recorded by the expiratory manifold sensor
      unsigned int FE;
      // Gas flow recorded by both sensors and smoothed
      int FLOW;
      // Fraction of gas that is oxygen at the patient airway
      unsigned int FO2;
      // Partial pressure of CO2 measured at the patient airway
      byte PCO2;
      // flag to indicate phase of respiratory cycle
      bool INSPIRING;
      // Pi with some smoothing applied
      unsigned int PI;
      // Peak observed pressure
      unsigned int PEAK_PI;
      // PEEP
      unsigned int PEEP;
      // TVi
      unsigned int TVI;
      // TVe
      unsigned int TVE;
      // Minute volume (the product of respiratory rate and tidal volume)
      unsigned int MV;
      // FiO2
      byte FIO2;
      // FeO2
      byte FEO2;
      // EtCO2
      byte ETCO2;
      // inspired CO2 partial pressure
      byte ICO2;
      // last time the system wrote to the log
      unsigned long LAST_LOG_TIME;
      // Alarm suspended time
      unsigned long ALARM_SUSPENDED_TIME;
    };
    
    
void MAIN(struct State *state)
{
  hook_pre_MAIN(state); // call all pre hooks
  core_MAIN(state); // call core code
  hook_post_MAIN(state); // call all post hooks
}

void hook_pre_MAIN(struct State *state)
{
  ; // no pre_MAIN hooks
}

void hook_post_MAIN(struct State *state)
{
  ; // no post_MAIN hooks
}

void START(struct State *state)
{
  hook_pre_START(state); // call all pre hooks
  core_START(state); // call core code
  hook_post_START(state); // call all post hooks
}

void hook_pre_START(struct State *state)
{
  ; // no pre_START hooks
}

void hook_post_START(struct State *state)
{
  ; // no post_START hooks
}

void LOOP(struct State *state)
{
  hook_pre_LOOP(state); // call all pre hooks
  core_LOOP(state); // call core code
  hook_post_LOOP(state); // call all post hooks
}

void hook_pre_LOOP(struct State *state)
{
  ; // no pre_LOOP hooks
}

void hook_post_LOOP(struct State *state)
{
  ; // no post_LOOP hooks
}

void STOP(struct State *state)
{
  hook_pre_STOP(state); // call all pre hooks
  core_STOP(state); // call core code
  hook_post_STOP(state); // call all post hooks
}

void hook_pre_STOP(struct State *state)
{
  ; // no pre_STOP hooks
}

void hook_post_STOP(struct State *state)
{
  ; // no post_STOP hooks
}

void CHECK(struct State *state)
{
  hook_pre_CHECK(state); // call all pre hooks
  core_CHECK(state); // call core code
  hook_post_CHECK(state); // call all post hooks
}

void hook_pre_CHECK(struct State *state)
{
  ; // no pre_CHECK hooks
}

void hook_post_CHECK(struct State *state)
{
  ; // no post_CHECK hooks
}

void ALARM(struct State *state)
{
  hook_pre_ALARM(state); // call all pre hooks
  core_ALARM(state); // call core code
  hook_post_ALARM(state); // call all post hooks
}

void hook_pre_ALARM(struct State *state)
{
  ; // no pre_ALARM hooks
}

void hook_post_ALARM(struct State *state)
{
  ; // no post_ALARM hooks
}

void SENSE(struct State *state)
{
  hook_pre_SENSE(state); // call all pre hooks
  core_SENSE(state); // call core code
  hook_post_SENSE(state); // call all post hooks
}

void hook_pre_SENSE(struct State *state)
{
  ; // no pre_SENSE hooks
}

void hook_post_SENSE(struct State *state)
{
  ; // no post_SENSE hooks
}

void THINK(struct State *state)
{
  hook_pre_THINK(state); // call all pre hooks
  core_THINK(state); // call core code
  hook_post_THINK(state); // call all post hooks
}

void hook_pre_THINK(struct State *state)
{
  ; // no pre_THINK hooks
}

void hook_post_THINK(struct State *state)
{
  hook_post_THINK_BLUETOOTH(state);
  hook_post_THINK_SUPER_PRVC(state);
}

void DRIVE(struct State *state)
{
  hook_pre_DRIVE(state); // call all pre hooks
  core_DRIVE(state); // call core code
  hook_post_DRIVE(state); // call all post hooks
}

void hook_pre_DRIVE(struct State *state)
{
  ; // no pre_DRIVE hooks
}

void hook_post_DRIVE(struct State *state)
{
  ; // no post_DRIVE hooks
}

void LOG(struct State *state)
{
  hook_pre_LOG(state); // call all pre hooks
  core_LOG(state); // call core code
  hook_post_LOG(state); // call all post hooks
}

void hook_pre_LOG(struct State *state)
{
  hook_pre_LOG_SUPER_PRVC(state);
}

void hook_post_LOG(struct State *state)
{
  hook_post_LOG_BLUETOOTH(state);
}

void DISPLAY(struct State *state)
{
  hook_pre_DISPLAY(state); // call all pre hooks
  core_DISPLAY(state); // call core code
  hook_post_DISPLAY(state); // call all post hooks
}

void hook_pre_DISPLAY(struct State *state)
{
  ; // no pre_DISPLAY hooks
}

void hook_post_DISPLAY(struct State *state)
{
  ; // no post_DISPLAY hooks
}

void READ(struct State *state)
{
  hook_pre_READ(state); // call all pre hooks
  core_READ(state); // call core code
  hook_post_READ(state); // call all post hooks
}

void hook_pre_READ(struct State *state)
{
  ; // no pre_READ hooks
}

void hook_post_READ(struct State *state)
{
  ; // no post_READ hooks
}