Fc Parametrizzato - Errori sulle uscite

[ken]

Devo controllare la coerenza di alcuni dati inseriti in una tabella tramite OP. I dati vengono scritti in una tabella strutturata in 5 diversi DB. Ho 40 righe di dati da controllare per ogni DB.

Per fare questo lavoro ho creato un FC parametrizzato dove, tramite un puntatore vado a leggere i dati riga per riga, cella per cella. Il puntatore viene incrementato ad ogni scansione dell’FC.

Le variabili dichiarate sono:

Input:

*DB_number come Block_db

In_out:

*Riga attuale come int

*Controllo_in_corso come bool

Out:

*Error_bit01 come bool

*Error_bit02 come bool

*Error_bit03 come bool

Le colonne della tabella sono 2 (stringa con ID, larghezza materiale), restituisco un bit di errore a seconda della colonna che contiene l’errore (semplici confronti).

All’inizio del mio FC creo i puntatori per leggere le mie variabili dal blocco interessato.

Leggo i dati e faccio dei confronti.

Restituisco bit falso in caso di dato corretto, Restituisco bit vero in caso di dato errato. Se viene identificato un errore il controllo si ferma. Il controllo si ferma anche se trova un codice particolare nella cella con ID.

Per fare questo in cima al mio FC apro il DB interessato con un AUF. I bit in uscita sono all’interno del DB aperto.

Se fuori dal mio Fc parametrizzato dichiaro i bit di errore come DB??.DBX?.? mi vengono restituiti errori anche se non ce ne sono.

Se invece metto un merker qualsiasi oppure scrivo DBX?.? Il tutto funziona.

La CPU dove gira questo Fc è una 317T (DP-MPI + ETH).

Ho capito che mettendo DBX?.? Il discorso funziona forse perché non viene interrotto l’AUF del DB. Pensate che il problema sia li? La cosa stana è che alcuni mesi fa l’ho utilizzato pari pari con una 414 2DP e tutto funzionava a meraviglia.

Potrebbero esserci delle differenze negli indirizzamenti diretti-indiretti tra una 317 e una 414?

[Matteo Montanari]

il mio consiglio è quello di utilizzare entrambi i puntatori DB, se utilizzi un FC puoi aprire il DB di Istanza (chiamato DI) contemporaneamente al DB:

per esempio

inizio eleborazione

AUF DI 3

utilizzi i vari indirizzamenti

U M0.0

UN E5.6

= A8.3

...

U DB10.DBX4.5

...

come dato di ritorno

= DIX0.0

in questo modo non dovresti avere problemi.

Se fuori dal mio Fc parametrizzato dichiaro i bit di errore come DB??.DBX?.? mi vengono restituiti errori anche se non ce ne sono.

Se invece metto un merker qualsiasi oppure scrivo DBX?.? Il tutto funziona.

Ho capito che mettendo DBX?.? Il discorso funziona forse perché non viene interrotto l’AUF del DB.

esatto, dovresti mettere una condizione del genere:

AUF DB 3

utilizzi i vari indirizzamenti

U M0.0

UN E5.6

= A8.3

...

U DB10.DBX4.5

...

come dato di ritorno

AUF DB 3

= DBX0.0

[Gianmario Pedrani]

Il comando dbxx.dbx.y è uguale a auf dbxx l o W dbz.y se tu hai gia aperto con un comando auf la tua db interessata e poi sotto metti un comando come dbxx.dbx.y non fai altro che dire alla cpu di chiudere il blocco aperto con il tuo comando auf e poi aprire quello con dbxx.dbx.y

se invece non metti dbxx vai solo a putare al pbit della dbx.y nella tua db aperta con il comando auf....

spero di essermi spiegato...

ciaooooooooooooooooo

[ken]

Volevo evitare il db di istanza.

magari domani posto la sorgente dell'FC.

La cosa che però mi fa starno e che con la 400 va con la 300 si incarta.

ho fatto una modifica per fare lo scroll dei dati in modalità debug (dato per dato a mano) e si incarta sempre quando finisce.

è strano perchè se assegno:

*DB_number come Block_db DB111

In_out:

*Riga attuale come int 1

*Controllo_in_corso come bool db111.dbx1.0

Out:

*Error_bit01 come bool db111.dbx1.1

*Error_bit02 come bool db111.dbx1.2

*Error_bit03 come bool db111.dbx1.3

e all'interno come prima istruzione faccio auf db111 non va

se faccio invece

*DB_number come Block_db DB111

In_out:

*Riga attuale come int 1

*Controllo_in_corso come bool dbx1.0

Out:

*Error_bit01 come bool dbx1.1 (oppure m100.1)

*Error_bit02 come bool dbx1.2 (oppure m100.2)

*Error_bit03 come bool dbx1.3 (oppure m100.3)

funziona

[ken]

X Gianmario Pedrani.

questo è vero. ma all'inerno dell'FC. Se l'Fc che creo è parametrizzato e come uscita ci metto un'altro Db dovrebbe andare. Con la 400 sono sicuro che va. è con una 317 che mi è saltato all'occhio il baco.

[Gian74]

ciao Ken

Ho capito che mettendo DBX?.? Il discorso funziona

cosa significa? che vedi il bit della DB111.DBX?.? a uno in caso di errore?

Potrebbero esserci delle differenze negli indirizzamenti diretti-indiretti tra una 317 e una 414?

credo e spero di no...

forse è meglio che posti il codice...

[ken]

FUNCTION FC 133 : VOID
TITLE =CONTROLLO DATI BOBINA IN SCARICO
//Controlla:
//*Item bobina inserito
//*Larghezza bobina diversa da 0
//*Diametro esterno bobina
//
//Indirizzi interessati:
//DBW600 --> Puntatore ID bobina (stringa 8 byte)
//DBW602 --> Puntatore largheza coil 
//DBW604 --> Flag fine pacco
//
//Formule:
//Puntatore ID bobina DBW600 = (DW18 * 14) + 6
//Puntatore larghezza Coil DBW602 = DBW600 + 10
//Puntatore Fine pacco DBW604 = DBW600 + 12
AUTHOR : Mauro
FAMILY : Imballo
NAME : D_Check
VERSION : 1.0


VAR_INPUT
  DB_Nr : INT;    //Numero DB Braccio Giostra
END_VAR
VAR_OUTPUT
  ID_ERRATO : BOOL;    
  LARGHEZZA_ERRATA : BOOL;    
  DIAMETRO_ERRATO : BOOL;    
END_VAR
VAR_IN_OUT
  Item_da_controllare : INT;    //Codice bobina da controllare
  Controllo_in_corso : BOOL;    //Controllo in corso
END_VAR
VAR_TEMP
  Real_Item : INT;    
  puntatore_1 : INT;    
  puntatore_2 : INT;    
  puntatore_3 : INT;    
  puntatore_4 : INT;    
  puntatore_5 : INT;    
  puntatore_6 : INT;    
  puntatore_ID1 : DINT;    
  puntatore_ID2 : DINT;    
  puntatore_ID3 : DINT;    
  puntatore_ID4 : DINT;    
  puntatore_ID5 : DINT;    
  puntatore_Largh : DINT;    
  puntatore_DB : WORD;    
END_VAR
BEGIN
NETWORK
TITLE =CONTROLLO IN CORSO

      UN    #Controllo_in_corso; 
      SPBN  _str; 
      SET  ; 
      S     #Controllo_in_corso; 
NETWORK
TITLE =CONTROLLA COERENZA DATI INSERITI E CALCOLA INDIRIZZI
//Il numero bobina deve essere maggiore uguale a 1 e minore uguale a 40
//Controlla braccio allineato
//Se la giostra non è allineata il codice del DB è 0
//Codice DB uguale a 111,112,113,114 a seconda del braccio allineato
_str: L     #DB_Nr; 
      L     0; 
      ==I  ; 
      SPB   _501; 
//Braccio Allineato
      L     #DB_Nr; 
      T     #puntatore_DB; 

      AUF   DB [#puntatore_DB]; 

      L     #Item_da_controllare; 
      L     1; 
      >=I  ; 
      SPB   m001; 
      L     1; 
      T     #Real_Item; 
      SPA   m003; 
m001: L     #Item_da_controllare; 
      L     40; 
      <=I  ; 
      SPB   m002; 
      L     40; 
      T     #Real_Item; 
      SPA   m003; 
m002: L     #Item_da_controllare; 
      T     #Real_Item; 
m003: L     #Real_Item; 
      L     14; 
      *I   ; 
      L     6; 
      +I   ; 
      T     #puntatore_1; // 1°+2° carattere (non usati perchè string)
      L     2; 
      +I   ; 
      T     #puntatore_2; // 3°+4° carattere
      L     2; 
      +I   ; 
      T     #puntatore_3; // 5°+6° carattere
      L     2; 
      +I   ; 
      T     #puntatore_4; // 7°+8° carattere
      L     2; 
      +I   ; 
      T     #puntatore_5; // 9°+10° carattere
      L     2; 
      +I   ; 
      T     #puntatore_6; // Larghezza bobina         

NETWORK
TITLE =FORMAZIONE PUNTATORI

      L     #puntatore_1; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_ID1; 

      L     #puntatore_2; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_ID2; 

      L     #puntatore_3; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_ID3; 

      L     #puntatore_4; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_ID4; 

      L     #puntatore_5; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_ID5; 

      L     #puntatore_6; 
      ITD  ; 
      SLD   3; 
      T     #puntatore_Largh; 

NETWORK
TITLE =CONTROLLO ID CODICE PACCO
//Codice nullo = w#16#2020
//Almeno 2 cifre devono essere NON nulle.
// Non controllati perchè usati dalla istruzione string del monitor

      L     DBW [#puntatore_ID2]; //digit COIL ID
      L     W#16#2020; // ASCII "  "
      <>I  ; 
      SPB   _300; 
      L     DBW [#puntatore_ID3]; //digit COIL ID
      L     W#16#2020; // ASCII "  "
      <>I  ; 
      SPB   _300; 
      L     DBW [#puntatore_ID4]; //digit COIL ID
      L     W#16#2020; // ASCII "  "
      <>I  ; 
      SPB   _300; 
      L     DBW [#puntatore_ID5]; //digit COIL ID
      L     W#16#2020; // ASCII "  "
      <>I  ; 
      SPB   _300; 
      SET  ; 
      S     #ID_ERRATO; 
      R     #Controllo_in_corso; 
      L     1; 
      T     #Item_da_controllare; 
      SPA   _701; 

_300: SET  ; 
      R     #ID_ERRATO; 
      NOP   0; 
NETWORK
TITLE =CONTROLLO DIAMETRO ESTERNO
//Controllo diversificato a seconda del diametro interno.
      U(   ; 
      L     DBW   12; 
      L     610; 
      <I   ; 
      )    ; 
      U     DBX    0.0; 
      O    ; 
      U(   ; 
      L     DBW   12; 
      L     508; 
      <I   ; 
      )    ; 
      UN    DBX    0.0; 
      =     #DIAMETRO_ERRATO; 
NETWORK
TITLE =CONTROLLO PER FINE PROGRAMMA
//Il fine programma è identificato con "********"
//Il codice asterisco è 2A


      L     DBW [#puntatore_ID2]; // Digit COIL ID
      L     W#16#2A2A; // ASCII "**"
      <>I  ; 
      SPB   _400; 

      L     DBW [#puntatore_ID3]; // Digit COIL ID
      L     W#16#2A2A; // ASCII "**"
      <>I  ; 
      SPB   _400; 

      L     DBW [#puntatore_ID4]; // Digit COIL ID
      L     W#16#2A2A; // ASCII "**"
      <>I  ; 
      SPB   _400; 

      L     DBW [#puntatore_ID5]; // Digit COIL ID
      L     W#16#2A2A; // ASCII "**"
      <>I  ; 
      SPB   _400; 
_501: SET  ; 
      R     #Controllo_in_corso; // Controllo eseguito
      L     1; 
      T     #Item_da_controllare; 
      SPA   _701; 
_400: NOP   0; 

NETWORK
TITLE =CONTROLLO LARGHEZZA INSERITA CORRETTAMENTE

      L     DBW [#puntatore_Largh]; 
      L     0; 
      >I   ; 
      SPB   a400; 
      SET  ; 
      S     #LARGHEZZA_ERRATA; 
      R     #Controllo_in_corso; 
      L     1; 
      T     #Item_da_controllare; 
      SPA   _701; 
a400: SET  ; 
      R     #LARGHEZZA_ERRATA; 
      NOP   0; 
NETWORK
TITLE =TUTTI GLI ITEM CONTROLLATI

      L     #Item_da_controllare; 
      L     40; 
      >=I  ; 
      SPBN  _700; 
      L     1; 
      T     #Item_da_controllare; 
      SET  ; 
      R     #Controllo_in_corso; 
      SPA   _701; 

_700: L     #Item_da_controllare; 
      L     1; 
      +I   ; 
      T     #Item_da_controllare; 
_701: NOP   0; 


END_FUNCTION

ID_ERRATO

LARGHEZZA_ERRATA

DIAMETRO_ERRATO

sono le mie uscite. la cosa che succede è che se scrivo db111.dbx1.2 in uscita a LARGHEZZA_ERRATA vedo il bit a uno anche se metto // all'istruzione S #LARGHEZZA_ERRATA quando vedo tutti gli asterischi (e non dovrebbe nemmeno eseguire quel pezzo di programma perchè dico di salatare a _701 in caso di stringa piena di asterischi.

Se invece ci metto una mXXX oppure DBX1.2 funziona.

lo stesso blocco in una CPU414 2DP funziona senza il baco illustrato.

sembrerebbe che, come detto da altri sopra, quando trova l'istruzione che scrive poi in uscita sul DBX chiude e riapre il db.

Se quaeto è quello che succede sembrebbe che la CPU 414 scrive le uscite alla fine della scansione del blocco perciò Db aperto o chiuso fa lo stesso mentre, la 317 lke scrive in tempo reale, incartando perciò il programma.

è un'idea valida?

Ci tengo ad andare a fondo in questa storia. sono quelle cose che si risolvono con una stupidata che eprò lasciano alcune domande

[ken]

cosa significa? che vedi il bit della DB111.DBX?.? a uno in caso di errore?

il bit deve andare ad uno in caso di errore.

se assegno però al blocco in uscita un bit del tipo DB111.DBX?.? va ad uno anche quendo non deve mentre se scrivo DBX?.? funziona.

Il DBX è nello stesso db aperto nel blocco parametrizzato.