Immagine di processo I/O

Gestendo gli ingressi tramite l’immagine di processo si garantisce che per tutto il ciclo di esecuzione del programma utente lo stato sia stabile anche se in realtà cambiano di stato in base alla situazione dell’impianto. Così il controllo del suo stato dà lo stesso risultato in ogni punto del programma.

Gestendo le uscite tramite l’immagine di processo si garantisce che se all’interno del programma l’uscita cambia di stato più volte, la reale attivazione sull’impianto avvenga solo a fine programma evitando comandi non corretti. Ecco un marcia arresto realizzato in linguaggio ST che illustra il concetto. E’ evidende che se attivi entrambi i comandi di Start e Stop senza immagine di processo Motor verrebbe attivato e poi disattivato.

    IF (Start) THEN Motor:=TRUE; END_IF;
    IF (Stop) THEN Motor:=FALSE; END_IF;

A volte può essere necessario gestire gli I/O logici direttamente da programma, per l’acquisizione degli ingressi è possibile utilizzare il FB SysGetPhrDI. Per la gestione delle uscite è possibile utilizzare il FB SysSetPhrDO.

In programmi strutturati può essere comodo accedere all’immagine di processo tramite puntatori di seguito un esempio, l’esempio funziona correttamente se eseguito nella stessa task dove è eseguita l’immagine di processo per garantire la gestione degli I/O in immagine di processo in tutte le task, LogicLab crea una immagine di processo degli I/O in ogni task. Quindi l’istruzione MyBOOLADR:=ADR(%IX0.0) tornerà indirizzi diversi in base alla task dove è eseguita, per utilizzarne il puntatore occorre prestare attenzione.

VAR
    MyBOOL : BOOL; (* BOOL value *)
    MyBOOLADR : @BOOL; (* BOOL pointer *)
END_VAR

    MyBOOLADR:=ADR(%IX0.0); //Punto l'ingresso nell'immagine di processo
    MyBOOL:=@MyBOOLADR; //Copio in MyBOOL lo stato dell'ingresso

Siccome è possibile accedere all’immagine di processo degli ingressi tramite puntatori, può essere comodo scrivere una funzione per acquisire l’intera immagine di processo di una scheda di ingressi. Un modulo di ingressi può avere al massimo 32 punti quindi la funzione ritorna una DWORD con lo stato di tutti gli ingressi. La funzione funziona correttamente se eseguita nella stessa task dove è eseguita l’immagine di processo.

FUNCTION IRead: DWORD
VAR
    i : UDINT; (* Auxiliary variable *)
END_VAR

VAR_INPUT
    IAddress : @BOOL; (* Input address *)
END_VAR

// *****************************************************************************
// FUNCTION "IRead"
// *****************************************************************************
// Sono gestiti 32 inputs immagine di processo a partire da quello indicato.
// Ecco un esempio di utilizzo:
//
// Module[0]:=IRead(ADR(%IX0.0)); //Lettura ingressi modulo 0
// Module[1]:=IRead(ADR(%IX1.0)); //Lettura ingressi modulo 1
// Module[2]:=IRead(ADR(%IX2.0)); //Lettura ingressi modulo 2
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // GESTIONE INGRESSI IN IMMAGINE DI PROCESSO
    // -------------------------------------------------------------------------
    // Gestione ingressi da immagine di processo.

    IRead:=16#00000000; //Function result    
    FOR i:=0 TO 31 DO
        IRead:=SHR(IRead, 1); //Function result
        IF (@IAddress) THEN IRead:=IRead OR 16#80000000; END_IF;
        IAddress:=IAddress+1; //Input address
    END_FOR;

// [End of file]

Siccome è possibile accedere all’immagine di processo delle uscite tramite puntatori, può essere comodo scrivere una funzione settare l’intera immagine di processo di una scheda di uscite. Un modulo di uscite può avere al massimo 32 punti quindi la funzione accetta una DWORD con lo stato di tutte le uscite. La funzione funziona correttamente se eseguita nella stessa task dove è eseguita l’immagine di processo.

FUNCTION OWrite: BOOL
VAR
    i : UDINT; (* Auxiliary variable *)
END_VAR

VAR_INPUT
    OAddress : @BOOL; (* Output address *)
    Value : DWORD; (* Set value *)
END_VAR

// *****************************************************************************
// FUNCTION "OWrite"
// *****************************************************************************
// Sono gestiti 32 output immagine di processo a partire da quello indicato.
// Ecco un esempio di utilizzo:
//
// i:=OWrite(ADR(%QX0.0), Module[0]); //Scrittura uscite modulo 0
// i:=OWrite(ADR(%QX1.0), Module[1]); //Scrittura uscite modulo 0
// i:=OWrite(ADR(%QX2.0), Module[2]); //Scrittura uscite modulo 0
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // GESTIONE USCITE IN IMMAGINE DI PROCESSO
    // -------------------------------------------------------------------------
    // Gestione uscite in immagine di processo.

    OWrite:=TRUE; //Function result    
    FOR i:=0 TO 31 DO
        @OAddress:=TO_BOOL(Value AND 16#00000001);
        OAddress:=OAddress+1; //Output address
        Value:=SHR(Value, 1); //Set value
    END_FOR;

// [End of file]