Untitled

uint8_t mode = 2;
// zoptymalizować typ zmiennej

//dodać konstruktor i funkcje
void standbyMode(void) {
    // Deactivate all actuators and reset necessary variables
    __HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, PWM_TURBINE_MIN); // Minimal PWM
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 1300); // open PEEP valve
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_2, 1300); //  open main valve 
    //HAL_GPIO_WritePin(GPIOB, VALVE_IN_Pin, GPIO_PIN_RESET);
    //HAL_GPIO_WritePin(GPIOB, VALVE_Pin, GPIO_PIN_RESET);
    //HAL_GPIO_WritePin(GPIOB, VALVE_BYPASS_Pin, GPIO_PIN_RESET);
    volume = 0;
    breathCounter = 0;
    pid_reset(&pidData);
    pid_reset(&pidPEEP);
}


//zmodyfikować odbiór danych z uart 

if (receive[0] == startByte && receive[9] == stopByte) {
    mode = receive[1];
    if (mode == 0) {
        maxVolume = (receive[3] << 8) | receive[2];
    } else if (mode == 1) {
        maxPressure = (receive[3] << 8) | receive[2];
    }
    inhaleTime = (receive[5] << 8) | receive[4];
    exhaleTime = (receive[7] << 8) | receive[6];
    PEEP = receive[8];
}

//zmodyfikować callback timera11 case zamiast if

        switch (mode) {
            case 0: // Flow Mode
                flowMode();
                break;

            case 1: // Pressure Mode
                pressureMode();
                break;

            case 2: // Standby Mode
                standbyMode();
                break;

            default: // Default standbyMode
                standbyMode();
                break;
        }


// nieblokujący odczyt z magistrali I2C

//konfiguracja ioc
//ic2 mode
Mode: I2C
Timing: 400kHz
Włącz Interrupt dla obsługi przerwań.

W sekcji NVIC Settings:
Zaznacz:
I2Cx Event interrupt (I2Cx_EV)
I2Cx Error interrupt (I2Cx_ER)
//timer11
        HAL_I2C_Master_Receive_IT(&hi2c3, ADDR, i2cReceiveBuf, sizeof(i2cReceiveBuf));

//callback przerwania
void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c)
{
    if (hi2c == &hi2c3) {
        signed int res = (i2cReceiveBuf[0] << 8) | i2cReceiveBuf[1];
        flowSLM = (res - OFFSET_FLOW) / SCALE_FLOW;
    }
}

//claback obsługi błędów

void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c)
{
    if (hi2c == &hi2c3) {
        HAL_I2C_DeInit(hi2c);
        HAL_I2C_Init(hi2c);
    }
}

//zmienne 
uint8_t i2cReceiveBuf[2]; // Bufor na dane z czujnika przepływu
float flowSLM = 0;        // Zmienna do przechowywania wartości przepływu









/*
// add to code

pid_data pidPEEP; // PID for PEEP valve

#define PID_PEEP_KP 2.0f
#define PID_PEEP_KI 0.01f
#define PID_PEEP_KD 0.1f
#define PWM_PEEP_MAX 1700
#define PWM_PEEP_MIN 1350

#define PWM_TURBINE_MIN 10



pid_init(&pidPEEP, PID_PEEP_KP, PID_PEEP_KI, PID_PEEP_KD, 0); //PID for PEEP init


void controlPEEP(void) {
    static uint16_t pwmPEEP = PWM_PEEP_MIN; // init value for pwmPEEP

    // count new pwmPEEP with PID
    float pidOutput = pid_calculate(&pidPEEP, PEEP, pressureCmH2O);

    // min-max pwmPEEP values
    pwmPEEP += (int16_t)pidOutput;
    if (pwmPEEP > PWM_PEEP_MAX) pwmPEEP = PWM_PEEP_MAX; // Max PWM value
    if (pwmPEEP < PWM_PEEP_MIN) pwmPEEP = PWM_PEEP_MIN; // Min PWM value

    // set new PWM value for PEEP valve
    __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, pwmPEEP);
}

void pressureMode(void){
		//breath control logic
		if(breathCounter == inhaleTime)	//start of exhale phase
		{
			pwmSpeed = PWM_TURBINE_MIN;
			__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, (uint16_t)pwmSpeed);
			controlPEEP();
			HAL_GPIO_WritePin(GPIOB, VALVE_IN_Pin, 1);
			breathCounter++;

			pid_reset(&pidData);
		}
		else if (breathCounter == (inhaleTime + exhaleTime))	//start of inhale phase
		{
			__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 1700); //zamknij zawór peep
			HAL_GPIO_WritePin(GPIOB, VALVE_IN_Pin, 0);
			breathCounter = 0;
		}
		else
		{
			if(breathCounter < inhaleTime)	// in inhale phase
			{
				pwmSpeed = pid_calculate(&pidData, 35, pressureCmH2O);

                if (pwmSpeed < PWM_TURBINE_MIN) {
                pwmSpeed = PWM_TURBINE_MIN;
                }
				__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, (uint16_t)pwmSpeed);
			}
			breathCounter++;
		}
}

void flowMode(void){
	flowRate = 30; //(1/inhaleTime)*MS_TO_M; // flow rate = (Volume[L] / Inhale Time[ms]) * 60000
	if(breathCounter == inhaleTime)	//start of exhale phase
			{
				pwmSpeed = PWM_TURBINE_MIN;
				__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, (uint16_t)pwmSpeed);
				controlPEEP();
				HAL_GPIO_WritePin(GPIOB, VALVE_IN_Pin, 1);
				breathCounter++;

				pid_reset(&pidData);
				volume = 0;

			}
			else if (breathCounter == (inhaleTime + exhaleTime))	//start of inhale phase
			{
				__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 1700); // zamknij zawór peep 
				HAL_GPIO_WritePin(GPIOB, VALVE_IN_Pin, 0);
				breathCounter = 0;
			}
			else
			{
				if(breathCounter < inhaleTime)	// in inhale phase
				{
					pwmSpeed = pid_calculate(&pidData, flowRate, flowSLM);

                    if (pwmSpeed < PWM_TURBINE_MIN) {
                    pwmSpeed = PWM_TURBINE_MIN;
                    }

					__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, (uint16_t)pwmSpeed); 
				}
				if(breathCounter == 1000) {
					volume += flowSLM;
				}
				breathCounter++;
			}
}

#define PWM_SAFE_MIN_PRESSURE 10
#define PWM_SAFE_MAX_PRESSURE 50

void safetyCheck(double pressure, double minPressure, double maxPressure) {
    if (pressure < minPressure) {
    	__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, PWM_SAFE_MAX_PRESSURE);
    } else if (pressure > maxPressure) {
    	__HAL_TIM_SET_COMPARE(&htim10, TIM_CHANNEL_1, PWM_SAFE_MIN_PRESSURE);
    }
    else {
        // Ciśnienie w normie
       
    }
} */