Indirizzamento Indiretto Rslogix5000 - spero di aver capito male io...

[Ecup]

Premessa: fino a qualche mese fa ho utilizzato sempre e solo SLC500, ma è giunta ora di passare a ControlLogix e mi trovo alle prese con la conversione di alcune parti di programma che considero standard e basilari per tutti i miei lavori (tant'è che sono fatte pressoché nello stesso modo su tutti i PLC).

Il problema risiede nell'indirizzamento indiretto: dal mio supervisore mandavo all'SLC un comando tipo:

-scrivi [$valore] nel file [$nr_file] alla word [$nr_word]

-e nell'SLC (dopo i dovuti controlli) facevo un bel "MOV [$valore] N[$nr_file]:[$nr_word]"

Ora i file N non ci sono più, e vabbé, sotto certi aspetti è anche meglio, ma per motivi di compatibilità nello scambio dati col supervisore (non uso OPC server) mi sono comunque mappato degli array come SLC Mapping sui rispettivi files (per intenderci, il vecchio file N7 è diventato un array N7[256])

Il problema è che l'indirizzamento come prima non lo posso più fare!!! Cioé, posso accedere indirettamente all'indice dell'array, ma ma se ho bene capito (spero di aver capito male...) non c'è modo di accedere indirettamente alla variabile!!!

Onestamente mi pare un passo indietro nella programmazione: possibile che non ci sia altro modo? Non c'è un'istruzione che mi restituisce, per esempio, la locazione di memoria di una determinata variabile, in modo tale che ci possa accedere per altre vie? Devo per forza scrivere il nome rininciando a qualsiasi possibilità di puntamento indiretto???

[Nazari Luca]

Ciao.

Se vuoi indirizzare una parola nel tuo arry puoi faro utilizando N[$nr_word]

Se invece vuoi puntare come nell'esempio che hai riportato devi avere una matrice bidimensionale INT[10,10].

Per l'esempio che hai ripotato puoi farl nel seguente modo. MOV [$valore] N[$nr_file,$nr_word]

Spero di essere stato chiaro....

Modificato: 18 dicembre 2007 da Nazari Luca

[Henon]

Volevi dire questo forse ?

Tu intendi accedere al indice di eventuali Data-File

Per esempio:

N7, N9,N10,N11, e quindi gli indici che tu intendi sono rispettivamente 7,9,10,11 (Questa è la Domanda )? (Ti serviva come un dataBase interno nel SLC ?)

e Poi accedere al singolo elemento Word ad esempio

N9:10 N9:100 etc ?

e Possibilmente anche al SubElemento Boolean

N9:10/1 oppure N9:100/15 ?

Come ho letto, tu giustamente hai mappato in "Logic/Map PLC/SLC Messages...." il tuo Array N7[256]

questo va benissimo (Quando vuoi accedere esternamente a tali elementi come valore N7 (tipo PanelView o interfacciarti con un SLC o PLC5))

A cosa ti serve Mappare questi Array ?

Forse per poterli accedere con PanelView300 o qualche altro modello, oppure per

Scambiarti dei dati con un SLC500, e quindi ti serve questa mappatura Logica ?

In definitiva

Per intenderci una cosa come questa (in SLC) ?

XIC B3:1/2 OTE N[N200:0]:[N200:1]/[N200:2]

Oppure cosi ?

MOV N200:0 N[b3:1]: [b3:2]

Potresti crearti un Array a 2 Dimensioni ad esempio N di INT[10,256]

N[indice_File, Indice_Word]

Dove :

Indice_File (per N7 sarà Indice_File =7 ; per N9 sarà Indice_File =9 )

Indice_Word (l'indice esprime gli elementi da 0 a 256)

Ecco una cosa che puoi fare:

MOV N200[0] N[index_Elem,indexW] equivale MOV N200:0 N[b3:1]: [b3:2] nel SLC

XIC B3[1].2 OTE N[index_Elem,indexW].[index_Bool]

Equivale a XIC B3:1/2 OTE N[N200:0]:[N200:1]/[N200:2] nel SLC

Ora ti sorgerà questo dilemma.

Come faccio a metterli nella Mappatura Logica per interscambio dati con un SLC o PLC5 ?

Per Leggere dagli elementi Mappati N7,N9 e poi trascriverli del Array usa:

COP N7[0] N[0,0] 256 COP N9[0] N[9,0] 256

Per Scriverli negli elementi Mappati N7 e N9 usa :

COP N[0,0] N7[0] 256 COP N[9,0] N9[0] 256

Ecco in questa maniera quando esternamente di serve aggiornare gli N7 oppure i N9,

e nel contempo andare anche a leggere questi elementi, la procedura è la seguente:

In Breve un esempio

Rung 00 := COP N7[0] N[0,0] 256 COP N9[0] N[9,0] 256 ' Qui aggiorni Array da esterno

Rung 01 := MOV N9[0] N[index_Elem,indexW] ' Qui Operi un Trasferimento

Rung 02 := XIC B3[1].2 OTE N[index_Elem,indexW].[index_Bool] ' Operazione Bool

Rung 03 := COP N[0,0] N7[0] 256 COP N[9,0] N9[0] 256 ' Qui Leggi esternamenti dal Array

Una Curiosità a cosa ti deve servire, questa cosa qua ?

Non Potevi gestire la stessa cosa in maniera più semplice, perché ti devi complicare

Le cose in questa maniera?

A volte è più conveniente rivedere la conversione, e rifarla in maniera più semplice usando

Le nuove potenzialità che il sistema ti offre.

Se non ti serviva una mappatura Logica, poteva diventare cosi:

Rung 00 := MOV N9[0] N[index_Elem,indexW] ' Qui Operi un Trasferimento

Rung 01 := XIC B3[1].2 OTE N[index_Elem,indexW].[index_Bool] ' Operazione Bool

Ciao e buon divertimento.

[Ecup]

[Henon]

Ho letto che utilizzi la medessima modalità di accesso, per SLC e S7.

I quanto punti un Elemento in Memoria PLC :

N X:Y dove X= Elemento DataBase (N7) e Y Elemento Word (N:10] == N7:10

DB X,Y dove X= Elemento DataBase (DB7) e Y Elemento Word (DBW10] == DB7:DBW10

Bene nella Famiglia Logix è lo stesso

N [X,Y] dove X= Elemento DataBase ( N[7,Y] ) e Y Elemento Word ( N[Y,10] ) == N[7,10]

In pratica è la medesima Cosa.

Se poi vuoi per forza usare la Mappatura Logica come SLC, non è conveniente, e a nulla ti Serve.

Se hai Già scritto il Codice anche per S7, ti conviene Modificare semplicemente la Sintassi per per X..Logix

Usi il Protocollo CIP oppure usi un OPC Server ? (Come RsLinx o KepServer o altri ? )

Se usi RsLinx la Sintassi è facilissima, e non devi inventarti di usare i data-File Mappati come un SLC.

Se ho un attimo di tempo cercerò di scoprire, se c'è qualche altra Via.

Forse chiedendo alla Rockwell e spiegando questo problema, la prossima volta ti sistemerano il problema

(Nella Prossima Release del RsLogix5000, chiedere e lecito)

[Henon]

Puoi fare cosi :

Ecco un esempio in cui ho creato solamenti 10 tags da N10 a N20 definite INT[256] e Mappate come Logica SLC

N10

N11

N12

N13

N14

N15

N16

N17

N18

N19

N20

Perciò puoi vedere questi dati tramite il Tuo Programma in C++

Poi io ho fatto una piccola SubRoutine di Esempio per poter leggere o Scrive un Singolo Elemento in uno di Questi

Tag da N10 a N20.

ecco la SubRoutine in ST:

(* Example for Read & Write Element to Matrix

Matrix N10...N20

Whit N def INT[256]

*)

Sbr(Index1,Index2,Element_Inp,Write_Int,Read_Int);

Error :=0;

// Write data Element (Integer) to Matrix

if Write_Int then

case Index1 Of

10: N10[index2]:= Element_Inp;

11: N11[index2]:= Element_Inp;

12: N12[index2]:= Element_Inp;

13: N13[index2]:= Element_Inp;

14: N14[index2]:= Element_Inp;

15: N15[index2]:= Element_Inp;

16: N16[index2]:= Element_Inp;

17: N17[index2]:= Element_Inp;

18: N18[index2]:= Element_Inp;

19: N19[index2]:= Element_Inp;

20: N20[index2]:= Element_Inp;

Else Error [:=]1;

end_case;

End_if;

// Read data Element (Integer) from Matrix

if Read_Int then

case Index1 Of

10: Element_Out:= N10[index2];

11: Element_Out:= N11[index2];

12: Element_Out:= N12[index2];

13: Element_Out:= N13[index2];

14: Element_Out:= N14[index2];

15: Element_Out:= N15[index2];

16: Element_Out:= N16[index2];

17: Element_Out:= N17[index2];

18: Element_Out:= N18[index2];

19: Element_Out:= N19[index2];

20: Element_Out:= N20[index2];

Else Error [:=]2;

end_case;

End_if;

Ret(Element_Out,Error); // Return the Element Output from Matrix

Ti Basta richiamare questa SubRoutine che sfrutta in CASE per poter eseguire le tue Operazioni di Lettura oppure di Scrittura.

Richiamo SubRoutine in Ladder :

JSR ArraytoMatrix 5 Index1 Index2 Element_Inp Write_Int Read_Int Element_Out Error

Index1,Index2 : Integer

Write_Int,Read_Int : Bool

Element_Out, Element_Inp : Integer

Error : Integer

Se ti fai anche una SubRoutine con una Lista di File N da 10 a 256 (Cioè molto Lunga)

Il Risultanto è OK ed inoltre con istruzione Case non perdi velocità di elaborazione (Invece se lo facessi in Ladder SI)

Richiamo della Stessa SubRoutine fatta in ST:

JSR(ArraytoMatrix,5,Index1,Index2,Element_Inp,Write_Int,Read_Int,Element_Out,Err

r);

Se richiami questa SubRoutine anche da più parti eviti le Operazioni di Scrittura in Contemporanea

"Race Condiction"

Ciao.

[Ecup]

Ti ringrazio per l'impegno, comunque avevo già risolto anch'io facendo un CASE, solo che è una cosa "stupida": in SLC avevo la possibilità di fare un doppio indirizzamento indiretto e qui non posso... (cioè, posso ma solo con una matrice bidimensionale, il che non mi va bene per la modalità con cui accedo ai dati col supervisore)

Per inciso, il problema non è tanto come accedo al PLC da supervisore... il problema è che sono solito, da supervisore, mandare istruzioni tipo:

-scrivi [$valore] nel file [$nr_file] alla word [$nr_word]

o al limite:

-scrivi [$valore] all'indirizzo di memoria [$nr_%M]

Cn RSLogix5000 il primo non lo posso fare perché non esiste [$nr_file] (ho risolto con un CASE ma non mi fa impazzire), e il secondo non mi risulta si possa fare perché non c'è (se c'è non l'ho ancora trovata) modo di ricavare un indirizzo di memoria della variabile.

Ora vedo se affrontare il problema per altre vie, tipo riorganizzare tutti i dati su matrice bidimensionale, e accedere dal supervisore in un altro modo (devo interpellare il mio collaboratore esperto della parte Visual C / comunicazione)

grazie ancora e ciao