Accedere da Modbus al sistema

Le funzioni del protocollo accedono tutte alla memoria utente DB100, le funzioni supportate sono:

1. Nelle funzioni che accedono al bit singolo (In realtà ogni bit equivale ad un byte di memoria) si utilizza nel comando l’indirizzo della variabile, quindi dovendo accedere alla locazione DB100.50 utilizzeremo come indirizzo il valore 40050.
2. Nelle funzioni che accedono ai registri (16 Bits) occorre considerare l’indirizzo della variabile diviso per 2, quindi dovendo raggiungere da modbus la locazione DB100.50 utilizzeremo come indirizzo il valore 40025.

Lettura variabili

Per la lettura delle variabili si utilizza il comando Read holding registers (Codice 0x03). Ipotizzando di dover accedere in lettura ad una variabile DWORD allocata in memoria all’indirizzo MX100.64 calcoleremo l’indirizzo di lettura nel modo:
((Indirizzo variabile/2)+Offset)-1 → ((64/2)+40000)-1=40031 → 0x9C5F
Essendo una variabile DWORD dovremo leggere 2 registri consecutivi a partire dal suo indirizzo di allocazione, ipotizzando che il valore della variabile sia 0x12345678 avremo.

Frames modbus RTU
Stringa di comando: 01 03 9C 5F 00 02 DA 49
Stringa di risposta: 01 03 04 56 78 12 34 66 D5

Frames modbus TCP/IP
Stringa di comando: 00 00 00 00 00 06 01 03 9C 5F 00 02
Stringa di risposta: 00 00 00 00 00 07 01 03 04 56 78 12 34

La rappresentazione dei dati è nel formato Little-Endian, la numerazione inizia dal byte meno significativo per finire col più significativo, quindi come si nota dalla stringa di risposta il valore della variabile a 32 bits 0x12345678 viene ritornato suddiviso in due registri a 16 bits con i valori 0x5678, 0x1234.

Scrittura variabili

Per la scrittura delle variabili si utilizza il comando Preset multiple registers (Codice 0x10). Ipotizzando di dover accedere in scrittura ad una variabile DWORD allocata in memoria all’indirizzo MX100.64 calcoleremo l’indirizzo di scrittura nel modo:
((Indirizzo variabile/2)+Offset)-1 → ((64/2)+40000)-1=40031 → 0x9C5F
Essendo una variabile DWORD dovremo scrivere 2 registri consecutivi a partire dal suo indirizzo di allocazione, ipotizzando di dover scrivere nella variabile il valore 0x12345678 avremo.

Frames modbus RTU
Stringa di comando: 01 10 9C 5F 00 02 04 56 78 12 34 D3 33
Stringa di risposta: 01 10 9C 5F 00 02 5F 8A

Frames modbus TCP/IP
Stringa di comando: 00 00 00 00 00 0B 01 10 9C 5F 00 02 04 56 78 12 34
Stringa di risposta: 00 00 00 00 00 06 01 10 9C 5F 00 02

La rappresentazione dei dati in SlimLine è nel formato Little-Endian, la numerazione inizia dal byte meno significativo per finire col più significativo, quindi come si nota dalla stringa di comando il valore da scrivere a 32 bits 0x12345678 viene definito suddiviso in due registri a 16 bits con i valori 0x5678, 0x1234.

VAR_GLOBAL
    DiCPULow AT %MW100.0 : WORD; (* Di CPU module (From 00 to 15) [Modbus address 40000] *)
    DiCPUHigh AT %MW100.2 : WORD; (* Di CPU module (From 16 to 31) [Modbus address 40001] *)
    DiM00Low AT %MW100.4 : WORD; (* Di module 0 (From 00 to 15) [Modbus address 40002] *)
    DiM00High AT %MW100.6 : WORD; (* Di module 0 (From 16 to 31) [Modbus address 40003] *)
    DiM01Low AT %MW100.8 : WORD; (* Di module 1 (From 00 to 15) [Modbus address 40004] *)
    DiM01High AT %MW100.10 : WORD; (* Di module 1 (From 16 to 31) [Modbus address 40005] *)
    DoCPULow AT %MW100.32 : WORD; (* Do CPU module (From 00 to 15) [Modbus address 40016] *)
    DoCPUHigh AT %MW100.34 : WORD; (* Do CPU module (From 16 to 31) [Modbus address 40017] *)
    DoM00Low AT %MW100.36 : WORD; (* Do module 0 (From 00 to 15) [Modbus address 40018] *)
    DoM00High AT %MW100.38 : WORD; (* Do module 0 (From 16 to 31) [Modbus address 40019] *)
    DoM01Low AT %MW100.40 : WORD; (* Do module 1 (From 00 to 15) [Modbus address 40020] *)
    DoM01High AT %MW100.42 : WORD; (* Do module 1 (From 16 to 31) [Modbus address 40021] *)
    AiCPU AT %MD100.64 : ARRAY[0..1] OF REAL; (* Ai CPU module (From 0 to 1) [Modbus address 40032-40034] *)
    AiM00 AT %MD100.80 : ARRAY[0..4] OF REAL; (* Ai module 0 (From 0 to 4) [Modbus address 40040-40090] *)
END_VAR

PROGRAM DIOToModbus
VAR
    i : USINT; (* Auxiliary variable *)
    Ptr : @BOOL; (* Auxiliary pointer *)
END_VAR

// *****************************************************************************
// PROGRAM "DIOToModbus"
// *****************************************************************************
// The program transfers digital inputs from process image to memory words, and
// digital outputs from memory words to image process.
//
// The memory words can be allocated in DB100 area so they can be addressed by
// Modbus protocol
//
// Extension modules can have up to 32 I/Os, the program manages all the I/Os.
// To make easy modbus access to them they are splitted into 2 16 bits words.
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // CPU MODULE
    // -------------------------------------------------------------------------
    // Even if two words are defined the CPU module has only up to 6 inputs.

    FOR i:=0 TO 5 DO Ptr:=ADR(%IX255.0)+i; DiCPULow:=TO_WORD(VBitSet(@Ptr, DiCPULow, i)); END_FOR;

    // Even if two words are defined the CPU module has only up to 4 outputs.

    FOR i:=0 TO 3 DO Ptr:=ADR(%QX255.0)+i; @Ptr:=VBitTest(DoCPULow, i); END_FOR;

    // -------------------------------------------------------------------------
    // EXTENSION MODULE ADDRESS "0"
    // -------------------------------------------------------------------------
    // The DI from 0 to 31 are transferred on two 16 bits words.

    FOR i:=0 TO 15 DO Ptr:=ADR(%IX0.0)+i; DiM00Low:=TO_WORD(VBitSet(@Ptr, DiM00Low, i)); END_FOR;
    FOR i:=0 TO 15 DO Ptr:=ADR(%IX0.16)+i; DiM00High:=TO_WORD(VBitSet(@Ptr, DiM00High, i)); END_FOR;

    // Two 16 bits words are transferred to DO from 0 to 31.

    FOR i:=0 TO 15 DO Ptr:=ADR(%QX0.0)+i; @Ptr:=VBitTest(DoM00Low, i); END_FOR;
    FOR i:=0 TO 15 DO Ptr:=ADR(%QX0.16)+i; @Ptr:=VBitTest(DoM00High, i); END_FOR;

    // -------------------------------------------------------------------------
    // EXTENSION MODULE ADDRESS "1"
    // -------------------------------------------------------------------------
    // The DI from 0 to 31 are transferred on two 16 bits words.

    FOR i:=0 TO 15 DO Ptr:=ADR(%IX1.0)+i; DiM01Low:=TO_WORD(VBitSet(@Ptr, DiM01Low, i)); END_FOR;
    FOR i:=0 TO 15 DO Ptr:=ADR(%IX1.16)+i; DiM01High:=TO_WORD(VBitSet(@Ptr, DiM01High, i)); END_FOR;

    // Two 16 bits words are transferred to DO from 0 to 31.

    FOR i:=0 TO 15 DO Ptr:=ADR(%QX1.0)+i; @Ptr:=VBitTest(DoM01Low, i); END_FOR;
    FOR i:=0 TO 15 DO Ptr:=ADR(%QX1.16)+i; @Ptr:=VBitTest(DoM01High, i); END_FOR;
    
// [End of file]

PROGRAM AIOToModbus
VAR
    i : USINT; (* Auxiliary variable *)
    CIDx : ARRAY[0..1] OF USINT; (* Channel index *)
    CPUAcq : ARRAY[0..1] OF SysGetAnInp; (* Analog input CPU module *)
    M00Acq : ARRAY[0..4] OF SysGetAnInp; (* Analog input module  0 *)
END_VAR

// *****************************************************************************
// PROGRAM "AIOToModbus"
// *****************************************************************************
// The program acquires analog inputs and transfers to REAL memory variables.
//
// The REAL variables can be allocated in DB100 area so they can be addressed
// by Modbus protocol
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // CPU MODULE
    // -------------------------------------------------------------------------
    // Module and channel FB parametrization.

    IF (SysFirstLoop) THEN

        CPUAcq[0].Address:=255; //Module address
        CPUAcq[0].Channel:=0; //Module channel
        CPUAcq[0].Mode:=AI_MODE#AD_VOLT_0_10_COMMON; //Acquisition mode

        CPUAcq[1].Address:=255; //Module address
        CPUAcq[1].Channel:=1; //Module channel
        CPUAcq[1].Mode:=AI_MODE#AD_CURR_4_20_COMMON; //Acquisition mode
    END_IF;

    // Analog input multiplexing.

    CIDx[0]:=CIDx[0]+1; //Channel index
    IF (CIDx[0] > 1) THEN CIDx[0]:=0; END_IF;
    CPUAcq[CIDx[0]](); //Analog input acquisition
    IF (CPUAcq[CIDx[0]].Done) THEN AiCPU[CIDx[0]]:=CPUAcq[CIDx[0]].Value; END_IF;

    // -------------------------------------------------------------------------
    // EXTENSION MODULE ADDRESS "0"
    // -------------------------------------------------------------------------
    // Module and channel FB parametrization.

    IF (SysFirstLoop) THEN
        FOR i:=0 TO 4 DO
            M00Acq[i].Address:=0; //Module address
            M00Acq[i].Channel:=i; //Module channel

            // If all channels have same acquisition mode it's set here.

            M00Acq[i].Mode:=AI_MODE#AD_VOLT_0_10_COMMON; //Acquisition mode
        END_FOR;

        // Set acquisition mode for every channel.

        M00Acq[0].Mode:=AI_MODE#AD_VOLT_0_10_COMMON; //Acquisition mode
        M00Acq[1].Mode:=AI_MODE#AD_PT100_DIFFER; //Acquisition mode
        M00Acq[2].Mode:=AI_MODE#AD_CURR_4_20_COMMON; //Acquisition mode
        M00Acq[3].Mode:=AI_MODE#AD_THERMOCOUPLE_J; //Acquisition mode
        M00Acq[4].Mode:=AI_MODE#AD_VOLT_0_1_COMMON; //Acquisition mode
    END_IF;

    // Analog input multiplexing.

    CIDx[1]:=CIDx[1]+1; //Channel index
    IF (CIDx[1] > 4) THEN CIDx[1]:=0; END_IF;
    M00Acq[CIDx[1]](); //Analog input acquisition
    IF (M00Acq[CIDx[1]].Done) THEN AiM00[CIDx[1]]:=M00Acq[CIDx[1]].Value; END_IF;

// [End of file]