CANOpenMaster, manages the CANopen master

Vai all indice del manuale di programmazione

Questo blocco funzione esegue la gestione del protocollo CANOpen, questo è un blocco funzione protetto per utilizzarlo occorre richiedere il codice di protezione, vedi protezione funzioni e blocchi funzione. E’ comunque possibile utilizzarlo liberamente in modo test per 15 Min.

Il CAN è un bus di campo progettato come rete di comunicazione ed il protocollo CANopen è diventato uno standard nel settore industriale specialmente quando servono requisiti real-time. Questo FB rappresenta il cuore della comunicazione CANopen eseguendo tutte le funzioni richieste da un sistema master.

Per gestire la comunicazione occorre istanziarlo nel proprio programma ed il suo indirizzo di allocazione passato ai FB CANOpenMNode di gestione dei moduli, i parametri sono gestiti direttamente dai vari FBs collegati.

Il parametro PHBeatTime permette di definire il tempo di invio del messaggio di heartbeat a tutti i nodi del bus. Ogni nodo ne controlla la ricezione ed in caso di mancata ricezione và in errore (Vedi configurazione registro 16#1029).

Approfondimenti

In questo topic informazioni su errore ricezione messaggi CAN.

Upgrade list

Se l’oggetto aggiornato non è nell’ultima versione del package, vedi capitolo “Aggiornamento librerie” in questo articolo.
Gli oggetti obsoleti sono inseriti nella libreria eLLabObsoleteLib fare riferimento al relativo manuale ed al manuale programmazione in formato pdf.

CANOpenMaster

Gestiva internamente l’impostazione del controller CAN, ora è eseguita da programma utente, eliminati ingressi Enable, BRate e Mode. Eliminata definizione CANOMMODE il nuovo modulo (Object oriented) ha una serie di metodi per gestire i modi operativi.

Descrizione

SpyOn (BOOL) Se attivo permette di spiare i messaggi CAN in transito sul bus in base al filtro definito, vedi esempi di filtro.
SpyID (WORD) Definizione ID messaggi da spiare (Vedi filtro spionaggio).
SpyMask (WORD) Definizione maschera messaggi da spiare (Vedi filtro spionaggio).
Sync (BOOL) Sul fronte di attivazione viene inviato il messaggio di SYNC sulla rete CANOpen.
NodeID (BYTE) ID nodo master (Default 127).
CANTx (SYSCANMESSAGE) Messaggio CAN da trasmettere (Gestito dai FBs collegati).
PHBeatTime (UINT) Definizione tempo invio heartbeat (mS) (Vedi Meccanismo Heartbeat in CANOpenMNode).
Fault (BOOL) Settato per un loop in caso di errore nella gestione.
RxD (BOOL) Settato per un loop su ricezione messaggio CAN (Gestito dai FBs collegati).
CANRx (SYSCANMESSAGE) Messaggio CAN ricevuto (Gestito dai FBs collegati).
RxCount (UDINT) Counter messaggi ricevuti.
TxCount (UDINT) Counter messaggi trasmessi.

Esempi di filtro

Viene eseguito lo spionaggio di tutti i messaggi che soddisfano il controllo COB-ID AND SpyMask = SpyID, di seguito alcune configurazioni:

Spionaggio di tutti i messaggi relativi al nodo 16#08: SpyMask:=16#007F, SpyID:=16#0008.
Spionaggio messaggi Sync e Emergency: SpyMask:=16#0080, SpyID:=16#0080.
Spionaggio messaggi Emergency da nodo 16#10: SpyMask:=16#00FF, SpyID:=16#0090.
Spionaggio messaggi NMT da nodo 16#01: SpyMask:=16#0FFF, SpyID:=16#0701.

Metodi disponibili

MTx

Questo metodo esegue trasmissione del messaggio CANTx.

Il metodo ritorna (BOOL), TRUE comando eseguito.

RPDOTx

Questo metodo esegue la trasmissione di un RPDO (Process Data Object) verso un nodo CAN slave.

COBID (WORD) Communication Object ID.
DBuffer (PVOID) Indirizzo buffer dati da inviare.
DLength (UDINT) Lunghezza dati da inviare (Da 1 a 8).

Il metodo ritorna (BOOL), TRUE comando eseguito.

TPDORx

Questo metodo esegue la ricezione di un TPDO (Process Data Object) trasmesso da un nodo CAN slave.

COBID (WORD) Communication Object ID.
DBuffer (PVOID) Indirizzo buffer trasferimento dati ricevuti.

Il metodo ritorna (USINT) con la lunghezza del PDO ricevuto (Da 1 a 8). 0 se nessuna ricezione.

Spionaggio funzionamento

Se SpyOn attivo è possibile utilizzare la console di spionaggio per verificare il funzionamento della FB. Sono previsti vari livelli di triggers.

Trigger di spionaggio

Trigger	Descrizione
16#00000001	Rx: Messaggi CAN ricevuti.
16#00000002	Tx: Messaggi CAN trasmessi.
16#10000000	*Lg:* Messaggi di log
16#40000000	*Er:* Errori funzionamento

Filtro spionaggio

Il numero di messaggi in transito sul bus CAN è elevato ed è impossibile spiarli in modo completo, quindi è stato inserito un filtro basato su SpyMask e SpyID che permette di definire quali messaggi si vogliono spiare. In pratica il valore di COB-ID viene messo in AND con SpyMask e se uguale a SpyID il messaggio è inviato in console spionaggio. Ecco alcuni esempi di impostazione filtro.

SpyMak	SpyID	Descrizione
16#00FF	16#0001	Spionaggio di tutti i messaggi relativi al nodo 1
16#00FF	16#007F	Spionaggio di tutti i messaggi relativi al nodo 127
16#0FFF	16#0201	Spionaggio messaggi trasmessi a RPDO1 nodo 1 CANOpenMaster:Tx\|[COB-ID:200-01] [C0 -- -- -- -- -- -- --] -> RPDO1 [01]

Di seguito alcuni esempi di messaggi CAN trasmessi al nodo slave e ricevuti dal nodo slave cosi come visualizzati nella console di spionaggio.

Inizializzazione nodo 1.

16:35:46.970610|CANOpenMNode:Lg|-------------------------------------------------------------[Reset node [01]]--
16:35:46.970810|CANOpenMaster:Tx|[COB-ID:000-00] [81 01 -- -- -- -- -- --] -> NMT [01] Go to reset node
16:35:47.971018|CANOpenMaster:Tx|[COB-ID:000-00] [82 01 -- -- -- -- -- --] -> NMT [01] Go to reset communication
.... PDO mapping
16:35:51.837634|CANOpenMaster:Tx|[COB-ID:000-00] [01 01 -- -- -- -- -- --] -> NMT [01] Go to operational
16:35:51.837675|CANOpenMNode:Lg|-------------------------------------------------------[Node operational [01]]--

Messaggio SDO su nodo 1, Index 1400 Sub-Index 1, lettura DWORD, e ricezione risposta con valore letto 16#201.

16:35:51.010649|CANOpenMaster:Tx|[COB-ID:600-01] [40 00 14 01 00 00 00 00] -> SDO [01] 1400 Sub:1 Read
16:35:51.012426|CANOpenMaster:Rx|[COB-ID:580-01] [43 00 14 01 01 02 00 00] <- SDO [01] 1400 Sub:1 Read [4] 00000201

Messaggio SDO su nodo 1, Index 100C Sub-Index 0, scrittura DWORD con valore 16#80000201, e ricezione risposta Ok.

16:35:51.111964|CANOpenMaster:Tx|[COB-ID:600-01] [23 00 14 01 01 02 00 80] -> SDO [01] 1400 Sub:1 Write [4] 80000201
16:35:51.114571|CANOpenMaster:Rx|[COB-ID:580-01] [60 00 14 01 01 02 00 00] <- SDO [01] 1400 Sub:1 Write Ok (Not zeroed)

Communication Objects

Sul bus CANopen si possono trasmettere solo pacchetti brevi costituiti da un ID a 11 bit e da 0 a 8 byte di dati. Lo standard CANopen divide l’ID frame CAN a 11 bit in un codice funzione a 4 bit e un ID nodo CANopen a 7 bit. Ciò limita il numero di dispositivi in una rete CANopen a 127 (0 essendo riservato per la trasmissione).

Tabella communication objects

+---------------+-------------------------+--------------+
| COB-ID(s)     | Communication object    | Direction    |
+---------------+-------------------------+--------------+
| 16#000        | NMT node control        | Master->Node |
| 16#001        | Global failsafe command |              |
| 16#080        | Sync                    | Master->Node |
| 16#080+NodeID | Emergency               | Node->Master |
| 16#100        | Timestamp               | Master->Node |
| 16#180+NodeID | TPDO1                   | Node->Master |
| 16#200+NodeID | RPDO1                   | Master->Node |
| 16#280+NodeID | TPDO2                   | Node->Master |
| 16#300+NodeID | RPDO2                   | Master->Node |
| 16#380+NodeID | TPDO3                   | Node->Master |
| 16#400+NodeID | RPDO3                   | Master->Node |
| 16#480+NodeID | TPDO4                   | Node->Master |
| 16#500+NodeID | RPDO4                   | Master->Node |
| 16#580+NodeID | SDO                     | Node->Master |
| 16#600+NodeID | SDO                     | Master->Node |
| 16#700+NodeID | NMT node monitoring     | Node|>Master |
+---------------+-------------------------+--------------+

Messaggi SDO

I messaggi SDO (Service Data Objects) forniscono l’accesso ai dizionari degli oggetti in ogni dispositivo. Sono utilizzati per la configurazione dei dispositivi. Ma è anche possibile ottenere valori di dati “di processo” interrogando tramite SDO la voce del dizionario degli oggetti appropriata. Il protocollo SDO conferma sempre l’operazione di lettura/scrittura, in caso di errore ritorna un codice di ABORT.

Formato messaggi SDO

    Invio Request SDO da master.
    +----------+-[1 Byte]-+-[2 Bytes]-+-[1 Byte]-+-[4 Bytes]-+
    | 0x600+ID | Request  | Index     | Sub Index| Data      |
    +----------+----------+-----+-----+----------+--+--+--+--+
    Request codes:
    16#40: Accesso in read.  
    16#2F: Scrittura di 1 byte
    16#2B: Scrittura di 2 bytes
    16#23: Scrittura di 4 bytes

    Response SDO da nodo.
    Il messaggio di risposta è sempre lungo 8 bytes.
    +----------+-[1 Byte]-+-[2 Bytes]-+-[1 Byte]-+-[4 Bytes]-+
    | 0x580+ID | Response | Index     | Sub Index| Data      |
    +----------+----------+-----+-----+----------+--+--+--+--+
    Response codes:
    16#60: Ok scrittura, i 4 bytes dati "0".
    16#4F: Lettura di 1 byte, primo byte contiene valore, altri "0"
    16#4B: Lettura di 2 bytes, primi 2 bytes contengono valore, altri "0"
    16#43: Lettura di 4 bytes

Codici di ABORT

Se un messaggio di SDO inviato al nodo contiene un indice o un valore non corretto o non accettato il modulo slave risponde con un messaggio di abort, la gestione del nodo si arresta è andando a spiare i pacchetti scambiati con il nodo è possibile risalire alla causa del problema. Ecco lo spionaggio dell’invio al nodo 1 di un messaggio SDO e ricezione messaggio di risposta ABORT con codice 06070010 (Tabella codici di abort).

17:12:02.149407|CANOpenMaster:Tx|[COB-ID:600-01] [40 99 09 00 00 00 00 00] -> SDO [01] 0999 Sub:0 Read
17:12:02.150889|CANOpenMaster:Rx|[COB-ID:580-01] [80 99 09 00 00 00 02 06] <- SDO [01] 0999 Sub:0 <<< Abort >>> 06020000

Esempi

Come utilizzare gli esempi.

ST_CANOpenSniffer
Utilizzando questo programma su un impianto connesso ad un bus CANOpen è possibile visualizzare sulla console di spionaggio tutti i messaggi in transito sul bus.

LogicLab (Ptp184, ST_CANOpenSniffer)

PROGRAM ST_CANOpenSniffer
VAR
    COMaster : CANOpenMaster_v1; (* CANOpen master *)
END_VAR

// *****************************************************************************
// PROGRAM "ST_CANOpenSniffer"
// *****************************************************************************
// By using this program on a system connected to a CANOpen bus it's possible
// to display on the spy console all messages on transit on the bus
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // INITIALIZATION
    // -------------------------------------------------------------------------
    // Define settings for the used FBs.

    IF (SysFirstLoop) THEN
        COMaster.SpyOn:=TRUE; //SpyOn
        COMaster.SpyID:=16#0000; //Spy ID
        COMaster.SpyMask:=16#0000; //Spy mask
        // i:=SysCANSetMode(CAN_250KBIT, 16#00000000, 16#00000000); //Accept all 11 and 29 bits messages
        eTO_JUNK(SysCANSetMode(CAN_250KBIT, 16#000007FF, 16#00000000)); //Accept only 11 bits messages
    END_IF;

    // -------------------------------------------------------------------------
    // SNIFF THE CANOPEN BUS
    // -------------------------------------------------------------------------
    // Sniff all messages related two nodes on the CANOpen bus.

    WHILE (TRUE) DO
        COMaster(); //CANOpen master
        IF NOT(COMaster.RxD) THEN EXIT; END_IF;
    END_WHILE;

// [End of file]

ST_CANOpenMaster
Sono gestiti due moduli di I/O su bus CANOpen e viene comandato il lampeggio di una uscita su ogni modulo. I FB di gestione modulo vanno creati in base alla documentazione del tipo di modulo da gestire. In questo articolo trovate degli esempi.

LogicLab (Ptp184, ST_CANOpenMaster)

PROGRAM ST_CANOpenMaster
VAR
    Blink : eTON; (* Blink timer *)
    CDoModule : CanDOut; (* Can digital outputs module *)
    WNModule : iRCop; (* Weintek I/O module *)
    COMaster : CANOpenMaster_v1; (* CANOpen master *)
END_VAR

// *****************************************************************************
// PROGRAM "ST_CANOpenMaster"
// *****************************************************************************
// Is managed a CANOpen bus with two modules attached.
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // INITIALIZATION
    // -------------------------------------------------------------------------
    // Define settings for the used FBs.

    IF (SysFirstLoop) THEN
        COMaster.SpyOn:=FALSE; //SpyOn
        COMaster.SpyID:=16#0001; //Spy ID
        COMaster.SpyMask:=16#007F; //Spy mask
        COMaster.NodeID:=127; //Master node ID
        COMaster.PHBeatTime:=150; //Producer Heartbeat Time (mS)

        //i:=SysCANSetMode(CAN_250KBIT, 16#00000000, 16#00000000); //Accept all 11 and 29 bits messages
        eTO_JUNK(SysCANSetMode(CAN_250KBIT, 16#000007FF, 16#00000000)); //Accept only 11 bits messages

        // Can digital outputs module settings

        CDoModule.SpyOn:=TRUE; //SpyOn
        CDoModule.NodeID:=16#01; //Node ID
        CDoModule.PHBeatTime:=200; //Producer Heartbeat Time (mS)
        CDoModule.COMaster:=ADR(COMaster); //CANOpen master

        // Weintek iRCop module settings.

        WNModule.SpyOn:=FALSE; //SpyOn
        WNModule.NodeID:=16#02; //Node ID
        WNModule.PHBeatTime:=200; //Producer Heartbeat Time (mS)
        WNModule.COMaster:=ADR(COMaster); //CANOpen master
    END_IF;

    // -------------------------------------------------------------------------
    // MANAGE THE CANOPEN BUS
    // -------------------------------------------------------------------------
    // Manage CANOpen and all the attached modules.

    WHILE (TRUE) DO
        COMaster(); //CANOpen master
        CDoModule(); //Deditec COS-REL8 module
        WNModule(); //Weintek iRCop module
        IF NOT(COMaster.RxD) THEN EXIT; END_IF;
    END_WHILE;

    // -------------------------------------------------------------------------
    // GESTIONE CAN OPEN BUS
    // -------------------------------------------------------------------------
    // Blink outputs on both slave modules.

    Blink(IN:=NOT(Blink.Q), PT:=1000);
    IF NOT(Blink.Q) THEN RETURN; END_IF;
    WNModule.Output:=WNModule.Output+1; //Outputs to module
    CDoModule.Output:=CDoModule.Output+1; //Outputs to module

// [End of file]

Was this article helpful?

Yes No