Untitled

(* Macchina che modella il funzionamento di un forno industriale *)


(* Dichiarazione delle Variabili *)

VAR
    ACCENDI_FORNO: BOOL := FALSE
    statoCorrente: ENUM {PreRiscaldamento, Cottura, Monitoraggio, Raffreddamento, FineCiclo};
    temperaturaCorrente: INT;
    tempoCottura: TIME;
    umiditaDesiderata: INT;
    tempoPreRiscaldamento: TIME := T#5m;
    temperaturaCottura: INT := 220; (* Temperatura di cottura in gradi Celsius *)
    umiditaAttuale: INT;
    allarmeTemperatura: BOOL := FALSE;
END_VAR

(* Logica di Controllo Principale *)
IF NOT ACCENDI_FORNO THEN
    ACCENDI_FORNO := TRUE (* Accendi il forno se non è già acceso *)
    statoCorrente := PreRiscaldamento; (* Imposta lo stato iniziale a PreRiscaldamento *)
END_IF

CASE statoCorrente OF
    PreRiscaldamento:
        SetTemperatura(temperaturaCottura); #################################
        Wait(tempoPreRiscaldamento); (* Attendi il tempo di pre-riscaldamento *) #################################
        statoCorrente := Cottura; (* Passa allo stato di Cottura *)
    
    Cottura:
        CominciaCicloCottura(tempoCottura); (* Avvia il ciclo di cottura *) #################################
        statoCorrente := Monitoraggio; (* Passa allo stato di Monitoraggio *)
    
    Monitoraggio:
        IF umiditaAttuale < umiditaDesiderata THEN
            IncrementaUmidita(umiditaDesiderata); (* Aumenta l'umidità se necessario *) #################################
        END_IF

        IF umiditaAttuale > umiditaDesiderata THEN
            DecrementaUmidita(umiditaDesiderata); (* Diminuisce l'umidità se necessario *) #################################
        END_IF

        IF temperaturaCorrente > temperaturaCottura + 10 OR temperaturaCorrente < temperaturaCottura - 10 THEN
            allarmeTemperatura := TRUE; (* Attiva l'allarme se la temperatura esce dai limiti *)
        END_IF

        IF ControllaseCotto() THEN #################################
            statoCorrente := Raffreddamento; (* Passo allo stato di Raffreddamento *)
        END_IF
    
    Raffreddamento:
        Raffresca(); (* Avvia il processo di raffreddamento *) #################################
        statoCorrente := FineCiclo (* Passa allo stato di Fine ciclo *)
    
    FineCiclo:
        ACCENDI_FORNO := FALSE; (* Spegni il forno *)

END_CASE


(* Funzioni di Supporto *)

(* Imposta la temperatura del forno *)
FUNCTION SetTemperatura: VOID
    VAR_INPUT
        TemperaturaDesiderata: INT; (* Temperatura desiderata in gradi Celsius *)
    END_VAR
    FornoController.TemperaturaSetPoint := TemperaturaDesiderata
END_FUNCTION

(* Attendi un determinato periodo *)
FUNCTION Wait: VOID
    VAR_INPUT
        TempoAttesa: TIME;
    END_VAR
    (* Implementazione di un delay, semplice timer *)
    DelayTimer(IN:=TRUE, PT:=TempoAttesa);
    IF DelayTimer.Q THEN
        DelayTimer(IN:=FALSE); (* Reset del timero dopo il completamento *)
    END_IF
END_FUNCTION

(* Avvia il ciclo di cottura *)
FUNCTION CominciaCicloCottura: VOID
    VAR_INPUT
        tempoCottura: TIME;
    END_VAR
    (* Inizia il ciclo di cottura imposta timer e condizioni di processo *)
    CookingTimer(IN:=TRUE, PT:=tempoCottura);
    IF CookingTimer.Q THEN
        CookingTimer(IN:=FALSE); (* Termina il ciclo di cottura *)
    END_IF
END_FUNCTION

(* Aumenta l'umidità nel forno *)
FUNCTION IncrementaUmidita: VOID
    VAR_INPUT
        umiditaDesiderata: INT; (* Umidità desiderata in percentuale *)
    END_VAR
    (* Codice per aumentare l'umidità, dipendente dal sistema di umidificazione del forno *)
    HumidifierControl.HumiditySetpoint := umiditaDesiderata;
END_FUNCTION

(* Verifica lo stato della cottura *)
FUNCTION ControllaseCotto: BOOL
    (* Determina se il pane ha raggiunto le condizioni di cottura desiderate *)
    RETURN (BakeSensor.DoneSignal); (* Simulato: segnale da un sensore di cottura completa *)
END_FUNCTION

(* Raffreddamento del forno *)
FUNCTION Raffresca: VOID
    (* Inizia il raffreddamento del forno *)
    CoolingSystem.Activate();
END_FUNCTION

(* Configurazione iniziale dei timer *)
FUNCTION_BLOCK