Programma fifo con il plc - Riunite 2 discussioni sul medesimo argomento

2 ottobre 2007

ho un problema con il programma fifo con il plc siemens s7 300.. perchè quando lo provo con il simulatore funziona e mentre quando lo carico sul plc vero non va?? stesso programma..

2 ottobre 2007

Caro Riki87, dovresti essere più preciso, dare i dati. Cosa non va? Non va in run?; Non entra il dato? Non esce il dato? Memorizza il dato in posizioni errate? Se non dai le info, non potrai essere aiutato.

2 ottobre 2007

La sfera di cristallo mi si è guastata proprio ieri.

Per darti una risposta dovrei quindi tirare a caso.

Oppure alleghi un esempio del tuo programma e descrivi le prove che hai fatto e l'anomalia riscontrata.

2 ottobre 2007

quando carico sul plc, i dati entrano i modo sbagliato.. invece di fare un fifo mette in tutti i registri lo stesso numero.. ma con il simulatore funziona tutto.. mentre lo carico non va.. è questo il problema.. perchè???

2 ottobre 2007

Oppure alleghi un esempio del tuo programma

meglio

2 ottobre 2007

Ascolta, possibile che tu non riesca a scrivere più di una riga?

E' tutto gratis, non aver paura di consumare la tastiera.

Allega il codice e spiega bene anche come hai effettuato le prove.

Anche specificare marca e tipo di plc non sarebbe proprio una brutta idea.

Inoltre, per il futuro, evita di aprire discussioni con titoli come "aiuto". E' importante poter farsi subito un'idea dell'argomento, solo leggendo il titolo. Di solito discussioni con titoli banali vengono ignorate.

2 ottobre 2007

non avete un esempio di programma fifo??

2 ottobre 2007

Sto usando un plc siemens s7 300.. il programma è giustissimo.. l'ho provato con il simulatore del plc e funziona.. il problema è che quando lo carico sul plc vero non va più! perchè? può essere un problema di plc? come è possibile? se funziona con i lsimulatore perchè non va con quello vero?? quando forzo un valore nella tabella nei registri mi esce lo stesso numero.. invece di fare in sequenza. tipo 1234567.. fa 11111111.. mentre con il simulatore funziona tutto!!

2 ottobre 2007

RIKI87, invece di continuare a girare attorno all'argomento fai quello che ti hanno chiesto: inserisci il codice che hai scritto.

Come ti ha già detto Batta la sfero di cristallo non è in più funzione

2 ottobre 2007

Un passettino avanti l'abbiamo fatto: sappiamo che abbiamo a che fare con un S7-300.

Una domanda: ti costa proprio tanta fatica postare qualche riga di codice?

quando forzo un valore nella tabella nei registri mi esce lo stesso numero.. invece di fare in sequenza. tipo 1234567.. fa 11111111.. mentre con il simulatore funziona tutto!!

Come forzi il valore in tabella?

Come gestisci il registro FIFO?

Insomma, o fai uno sforzo e spieghi nei minimi dettagli quali sono le operazioni che compi (e non dimenticarti di allegare un po' di codice), specificando anche quali aree di memoria stai utilizzando (merker, DB, I/O...) oppure non vedo come sia possibile darti ulteriore aiuto.

2 ottobre 2007

non avete un esempio di programma fifo??

Certo!

      U     E      0.0
      SPBNB _003
      CALL  "FIFO"
       TABLE  :=P#DB1.DBX 10.0
       RET_VAL:=MW2
_003: U     BIE
      =     A      0.0

Tirato giù pari pari dall'aiuto in linea!

Non credo però questo possa esserti di aiuto.

Insisto: posta il tuo codice!

P.S. il tasto "o" è quello tra la "i" e la "p". Così puoi scrivere "non" al posto di un orribile "non".

Se leggi il regolamento ci trovi scritto che le abbreviazioni da sms non sono ammesse.

3 ottobre 2007

Sto usando un plc siemens s7 300 con cpu 315-2 DP.

Questi sono i programmi che ho scritto e che sto usando, simulano un buffer circolare.

Il mio problema è che provandoli con il simulatore della siemens funzionano.. fanno quello che devono fare, cioè simulano un programma FIFO. mentre quando li carico sul pc vero misteriosamente non vanno più. invece di scrivere la sequenza di numeri scrive lo stesso numero é possibile che con il simulatore funzionino e con il plc vero no? :huh: Perchè?

Ecco i programmi.. grazie

  LAR1  P##Source                   //Carica l'indirizzo iniziale del puntatore ANY in AR1

      L     B#16#10                     //Carica l'ID-sintassi e la trasferisce nel puntatore ANY
      T     LB [AR1,P#0.0]

      L     B#16#2                      //Carica tipo di dati byte e lo trasferisce nel puntatore ANY
      T     LB [AR1,P#1.0]

      L     #SIZE                       //Carica il numero di Byte e li trasferisce nel puntatore ANY.
      T     LW [AR1,P#2.0]

      L     #SOURCE_DB                  //Carica il DB sorgente
      T     LW [AR1,P#4.0]

      L     #SOURCE_INDEX               //Carica l'indice del DB da cui leggere i dati
      SLW   3
      T     LW [AR1,P#8.0]
      L     W#16#8400
      T     LW [AR1,P#6.0]



      LAR1  P##Destination              //Carica l'indirizzo iniziale del puntatore ANY in AR1

      L     B#16#10                     //Carica l'ID-sintassi e la trasferisce nel puntatore ANY
      T     LB [AR1,P#0.0]

      L     B#16#2                      //Carica tipo di dati byte e lo trasferisce nel puntatore ANY
      T     LB [AR1,P#1.0]

      L     #SIZE                       //Carica il numero di Byte e li trasferisce nel puntatore ANY
      T     LW [AR1,P#2.0]

      L     #DEST_DB                    //Carica il DB sorgente
      T     LW [AR1,P#4.0]

      L     #DEST_INDEX                 //Carica l'indice del DB da cui leggere i dati
      SLW   3
      T     LW [AR1,P#8.0]
      L     W#16#8400
      T     LW [AR1,P#6.0]

      CALL  SFC   20
       IN0    :=#Source
       RET_VAL:=#Res
       OUT1   :=#Destination

Programma copy

  U     "FIFO ->"
      SPBN  end1

//Move the recipe map
      CALL  "COPY"
       SOURCE_DB   :=6
       SOURCE_INDEX:=0
       DEST_DB     :=6
       DEST_INDEX  :=10
       SIZE        :=350

//Move the last data to the first position
      L     DB6.DBD  350
      T     DB6.DBD    0
      L     DB6.DBD  354
      T     DB6.DBD    4
      L     DB6.DBW  358
      T     DB6.DBW    8

//Reset the last data
      L     L#0
      T     DB6.DBD  350
      T     DB6.DBD  354
      T     DB6.DBD  356

//Reset move command
      R     "FIFO ->"

end1: NOP   0

Questo è il programma fifo non funzionante

0.0                               struct
+0.0     FIFO                 ARRAY  [0..35]			
*0.0	                   STRUCT			
+0.0     Rec_name        STRING[8]	''	Name of the recipe	
=10.0	                   END_STRUCT			
=360.0                         END_STRUCT

db6

DB6.DBD    2			CARATTERE		'uno1'
DB6.DBD   12			CARATTERE		'due2'
DB6.DBD   22			CARATTERE		'tre3'
DB6.DBD   32			CARATTERE		'quat'
DB6.DBD   42			CARATTERE		'cinq'
DB6.DBD   52			CARATTERE		'sei6'
DB6.DBD   62			CARATTERE		'sett'
DB6.DBD   72			CARATTERE		'otto'
DB6.DBD   82			CARATTERE		'nove'
DB6.DBD   92			CARATTERE		
M     20.0	"FIFO ->"	MOVE FIFO FORWARD	BOOL		
M     20.1	"FIFO <-"	MOVE FIFO BACKWARD	BOOL

In tutte le db6 mette lo stesso numero ad esempio 1. invece di fare la sequenza 123..

3 ottobre 2007

Avete un esempio di programma fifo? come DATA mi gestisca una string non una word.. non posso utilizzare fc84 e fc85 della libreria siemens. grazie

4 ottobre 2007

Un Esempio pultroppo in SCL V5.3

// FB “FIFO Register”

// This FB Executing a FIFO Register (12 Elements) of String (Length 12 Chr$):

FUNCTION_BLOCK FB10 // Routine Gestione FIFO

TITLE = 'FIFO_Reg'

VAR_INPUT

Load: BOOL ; // Bit Loading FIFO Register

UnLoad: BOOL ; // Bit UnLoading FIFO Register

Reset: BOOL ; // Bit Reset FIFO Register

Input_Str: STRING[12] ; // Imput String to FIFO Register

END_VAR

VAR_IN_OUT

Buffer: ARRAY[1..12]OF STRING[12]; // Buffer

Index: INT ; // Index Element of FIFO Register

END_VAR

VAR_OUTPUT

Empty: BOOL ; // Flag FIFO Empty

Full: BOOL ; // Flag FIFO Full

Error: BOOL ; // Flag FIFO Error

Out_Str: STRING[12] ; // Output String from FIFO

END_VAR

VAR

x: INT; // Auxiliary Flag

N_Element: INT; // Max Number of Buffer-Elements

END_VAR

LABEL

ByPass_Load; // Label for ByPass next Element when FIFO is Full

END_LABEL

BEGIN

N_Element:= 12;

// Check Limit Elements

IF Index >= N_Element THEN Index := N_Element; END_IF;

IF Index < 0 THEN Index := 0; END_IF;

IF Reset = true THEN //Reset FIFO

FOR x:=1 TO N_Element DO

Buffer[x] := ' '; // 12 Spaces

END_FOR;

Index :=0;

Error :=0;

END_IF;

IF Index = 0 THEN // FIFO Vuota

Full := False;

Empty := True;

END_IF;

IF Index > (N_Element-1) THEN // FIFO Empty

Full := True;

ELSE

Full := False;

END_IF;

IF Load = True THEN // FIFO LOAD

Index := Index + 1;

IF Index > N_Element THEN

Error := True;

Index := N_Element;

GOTO ByPass_Load;

END_IF;

Empty:= False;

FOR x :=Index TO 1 BY -1 DO

IF x <N_Element THEN

Buffer[x+1] := Buffer[x];

ELSE

Buffer[N_Element] := Buffer[x];

END_IF;

END_FOR;

Buffer[1]:= Input_Str;

END_IF;

ByPass_Load:

IF (UnLoad = True) AND (Index <0) THEN // FIFO UNLOAD

Empty := True;

Error := True;

Index := 0;

END_IF;

IF UnLoad = true AND Index>0 THEN

Out_Str := Buffer[index];

Buffer[index] := ' '; // 12 Spaces

Index := Index -1;

END_IF;

END_FUNCTION_BLOCK

Questo invece è un Registro LIFO per uno Stack

(*

Questa FB Esegue il Controllo di un Registro Stack o Buffer.

I Valori Trattati sono delle Stringhe String[12]

Può gestire una Profondità di 12 Elementi.

Con Il Comando di Load si Carica nello Stack la Stringa Presente in Input_Str

Questo Comando equivale ad un PUSH.

Con Il Comando di UnLoad si Scarica dallo Stack la Stringa Presente nel Buffer,

e verrà Posta in Uscita Output_Str,

Questo Comando equivale ad un PUSH.

Con Il Comando di Clear si Calcella e Resetta Intero Stack la Stringa di Uscita,

i Bit di Stato verrano Azzerati.

La Stringa Patter1-2 sarà la Stringa che Verrà Comparata alla Stringa di

Ingresso

Input_Str, e all' uscita del Buffer Output_Str.

Quando questo Patter è uguale a queste Strighe i Bit:

Patter1_I (Ingresso=Patter1)

Patter1_O (Uscita = Patter1)

Patter2_I (Ingresso=Patter2)

Patter2_O (Uscita = Patter2)

Elemento Buffer deve Essere un Array di 12 Elementi di Stringa da 12 Caratteri

Buffer: Array[1..12]of String[12];

Index è indice del Puntatore Interno, indica il Livello dello Stack

Può essere anche Forzato ad un Valore a Piacere da 1 a 12.

I Bits di Stato

Full = Baffer Pieno

Empty = Baffer Vuoto

Error = Quando il Buffer e Pieno e si Richiede un Ulteriore Load

oppure quando il Buffer è vuoto e si richiede UnLoad.

Il Comando Correct permette di Correggere un Elemento del Buffer.

Il Puntatore Pos_Correct indica quale elemento Correggere.

La Stringa di Ingresso sarà Trascritta nell' elemento puntato

*)

FUNCTION_BLOCK FB11

TITLE = 'LIFO_Reg'

VAR_INPUT

Load: BOOL; // LoadStack Buffer

Input_Str: STRING[12]; // Input String Buffer

UnLoad: BOOL; // UnLoad Stack Buffer

Clear: BOOL; // Clear Buffer

Patter1: STRING[12]; // Patter1 identification

Patter2: STRING[12]; // Patter2 identification

Correct: BOOL; // Enable Corection String

Pos_Correct: INT; // Number Element for Correction String

END_VAR

VAR_IN_OUT

Buffer: ARRAY[1..12]OF STRING[12]; // Buffer of Stack

Index: INT; // index of Stack

END_VAR

VAR_OUTPUT

Output_Str: STRING[12]; // Output String Buffer

Full: BOOL; // Buffer Full

Empty: BOOL; // Buffer Empty

Error: BOOL; // Buffer Error

Patter1_I: BOOL; // identification Patter 1 Inp

Patter1_O: BOOL; // identification Patter 1 Out

Patter2_I: BOOL; // identification Patter 2 Inp

Patter2_O: BOOL; // identification Patter 2 Out

END_VAR

VAR

X: INT; // Auxiliary Flag

N_Element: INT; // Max Number of Buffer-Elements

END_VAR

LABEL

ByPass_Load; // Label for ByPass next Element when Stack is Full

BEGIN

N_Element := 12; // NumMax Elements of Stack is 12

IF Index >= N_Element THEN Index := N_Element; END_IF; // Check Limit of Elements

IF Index < 0 THEN Index := 0; END_IF;

IF Clear = True THEN // Clear Buffer

Index := 0;

Full := False;

Error := False;

Output_Str:= ' ';

Patter1_I:=False; Patter1_O:=False;

Patter2_I:=False; Patter2_O:=False;

FOR x :=1 TO N_Element DO

Buffer[x] := ' ';

END_FOR;

END_IF;

IF Index = 0 THEN // Buffer Empty

Empty := True;

Full := False;

END_IF;

IF Index > (N_Element-1) THEN // Buffer Full

Full := True;

ELSE

Full := False;

END_IF;

IF Load = True THEN // Buffer LOAD

Index := Index + 1;

IF Index > N_Element THEN

Error := True;

Index := N_Element;

GOTO ByPass_Load;

END_IF;

Empty := False;

FOR X := Index TO 1 BY -1 DO

IF X <N_Element THEN

Buffer[X+1]:= Buffer[X];

ELSE

Buffer[N_Element] := Buffer[X];

END_IF;

END_FOR;

Buffer[1] := Input_Str;

END_IF;

ByPass_Load:

IF (UnLoad = True) AND (Index <=0) THEN // Buffer UNLOAD

Empty := True;

Error := True;

Index := 0;

Output_Str:= ' ';

END_IF;

IF (UnLoad = True) AND (Index>0) THEN

Output_Str := Buffer[1];

Buffer[12] := ' ';

FOR X := 2 TO N_Element DO

Buffer[X-1]:= Buffer[X];

END_FOR;

Index := Index -1;

END_IF;

IF Input_Str = Patter1 THEN // identification Patter 1 in Entry String of Buffer

Patter1_I := True;

ELSE

Patter1_I := false;

END_IF;

IF Output_Str = Patter1 THEN // identification Patter 1 in Output String of Buffer

Patter1_O := True;

ELSE

Patter1_O := false;

END_IF;

IF Input_Str = Patter2 THEN // identification Patter 2 in Entry String of Buffer

Patter2_I := True;

ELSE

Patter2_I := false;

END_IF;

IF Output_Str = Patter2 THEN // identification Patter 2 in Output String of Buffer

Patter2_O := True;

ELSE

Patter2_O := false;

END_IF;

// Correction Element of Buffer

IF (Pos_Correct <= N_Element) AND (Pos_Correct > 0) THEN

Buffer[Pos_Correct] := Input_Str;

END_IF;

END_FUNCTION_BLOCK

Modificato: 4 ottobre 2007 da Henon

4 ottobre 2007

Ho compilato l'esempio e lo salvato come sorgente AWL.

Cosi se lo importi come sorgente AWL, lo potrai subito provare.

Ecco la Sorgente in AWL del FB10, Registro FIFO per Stringhe (Massimo 12 Elementi Stringa, lunghi massimo 12 Caratteri):

FUNCTION_BLOCK FB 10

TITLE =

VERSION : 0.0

VAR_INPUT

Load : BOOL ; //Bit Loading FIFO Register

UnLoad : BOOL ; //Bit UnLoading FIFO Register

Reset : BOOL ; //Bit Reset FIFO Register

Input_Str : STRING [12 ]; //Imput String to FIFO Register

END_VAR

VAR_OUTPUT

Empty : BOOL ; //Flag FIFO Empty

Full : BOOL ; //Flag FIFO Full

Error : BOOL ; //Flag FIFO Error

Out_Str : STRING [12 ]; //Output String from FIFO

END_VAR

VAR_IN_OUT

Buffer : ARRAY [1 .. 12 ] OF //Buffer

STRING [12 ]; //Buffer

Index : INT ; //Index Element of FIFO Register

END_VAR

VAR

x : INT ; //Auxiliary Flag

N_Element : INT ; //Max Number of Buffer-Elements

END_VAR

BEGIN

NETWORK

TITLE =SCL network

//compiled by SCL compiler version: SCL V5.3 (C5.3.0.1)

SET ;

SAVE ;

= L 0.1;

L 12;

T #N_Element;

L #Index;

TAK ;

>=I ;

SPBN A7d0;

L #N_Element;

T #Index;

A7d0: L #Index;

L 0;

<I ;

SPBN A7d1;

T #Index;

A7d1: CLR ;

U #Reset;

SPBN A7d2;

L #N_Element;

L 1;

T #x;

TAK ;

T LW 2;

TAK ;

A7d3: L #x;

L LW 2;

<=I ;

SPBN A7d4;

L #x;

ITD ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I007;

SPA I008;

I007: CLR ;

= L 0.1;

I008: L L#112;

*D ;

SPO I009;

SPA I00a;

I009: CLR ;

= L 0.1;

I00a: L W#16#C0C;

T LD 8;

TAK ;

T LD 14;

TAK ;

L DIW [AR2,P#32.0];

T LW 12;

TAK ;

AUF DB [LW 12];

L DID [AR2,P#34.0];

L LD 14;

+D ;

LAR1 ;

L LD 8;

T W [AR1,P#0.0];

L DW#16#20202020;

T LD 8;

L DIW [AR2,P#32.0];

T LW 12;

TAK ;

AUF DB [LW 12];

L DID [AR2,P#34.0];

L LD 14;

+D ;

LAR1 ;

L LD 8;

T D [AR1,P#2.0];

L DW#16#20202020;

T LD 8;

L DIW [AR2,P#32.0];

T LW 12;

TAK ;

AUF DB [LW 12];

L DID [AR2,P#34.0];

L LD 14;

+D ;

LAR1 ;

L LD 8;

T D [AR1,P#6.0];

L DW#16#20202020;

T LD 8;

L DIW [AR2,P#32.0];

T LW 12;

TAK ;

AUF DB [LW 12];

L DID [AR2,P#34.0];

L LD 14;

+D ;

LAR1 ;

L LD 8;

T D [AR1,P#10.0];

L #x;

L 1;

+I ;

SPO I00b;

SPA I00c;

I00b: CLR ;

= L 0.1;

I00c: T #x;

SPA A7d3;

A7d4: L 0;

T #Index;

CLR ;

= #Error;

A7d2: L #Index;

L 0;

==I ;

SPBN A7d5;

CLR ;

= #Full;

SET ;

= #Empty;

A7d5: L #N_Element;

L 1;

-I ;

SPO I00d;

SPA I00e;

I00d: CLR ;

= L 0.1;

I00e: L #Index;

TAK ;

>I ;

SPBN A7d6;

SET ;

= #Full;

SPA A7d7;

A7d6: CLR ;

= #Full;

A7d7: CLR ;

U #Load;

SPBN A7d8;

L #Index;

L 1;

+I ;

SPO I00f;

SPA I010;

I00f: CLR ;

= L 0.1;

I010: T #Index;

L #Index;

L #N_Element;

>I ;

SPBN A7d9;

SET ;

= #Error;

L #N_Element;

T #Index;

SPA A000;

A7d9: CLR ;

= #Empty;

L #Index;

T #x;

A7da: L #x;

L 1;

>=I ;

SPBN A7db;

L #x;

L #N_Element;

<I ;

SPBN A7dc;

L #x;

L 1;

+I ;

SPO I011;

SPA I012;

I011: CLR ;

= L 0.1;

I012: ITD ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I013;

SPA I014;

I013: CLR ;

= L 0.1;

I014: L L#112;

*D ;

SPO I015;

SPA I016;

I015: CLR ;

= L 0.1;

I016: L #x;

ITD ;

TAK ;

T LD 2;

TAK ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I017;

SPA I018;

I017: CLR ;

= L 0.1;

I018: L L#112;

*D ;

SPO I019;

SPA I01a;

I019: CLR ;

= L 0.1;

I01a: L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

TAK ;

T LD 6;

TAK ;

+D ;

LAR1 ;

L D [AR1,P#1.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#1.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L D [AR1,P#5.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#5.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L D [AR1,P#9.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#9.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L B [AR1,P#13.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T B [AR1,P#13.0];

SPA A7dd;

A7dc: L #N_Element;

ITD ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I01b;

SPA I01c;

I01b: CLR ;

= L 0.1;

I01c: L L#112;

*D ;

SPO I01d;

SPA I01e;

I01d: CLR ;

= L 0.1;

I01e: L #x;

ITD ;

TAK ;

T LD 2;

TAK ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I01f;

SPA I020;

I01f: CLR ;

= L 0.1;

I020: L L#112;

*D ;

SPO I021;

SPA I022;

I021: CLR ;

= L 0.1;

I022: L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

TAK ;

T LD 6;

TAK ;

+D ;

LAR1 ;

L D [AR1,P#1.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#1.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L D [AR1,P#5.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#5.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L D [AR1,P#9.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T D [AR1,P#9.0];

L DIW [AR2,P#32.0];

T LW 14;

TAK ;

AUF DB [LW 14];

L DID [AR2,P#34.0];

L LD 6;

+D ;

LAR1 ;

L B [AR1,P#13.0];

T LD 14;

L DIW [AR2,P#32.0];

T LW 18;

TAK ;

AUF DB [LW 18];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L LD 14;

T B [AR1,P#13.0];

A7dd: L #x;

L -1;

+I ;

SPO I023;

SPA I024;

I023: CLR ;

= L 0.1;

I024: T #x;

SPA A7da;

A7db: L DID [AR2,P#3.0];

L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

LAR1 ;

TAK ;

T D [AR1,P#1.0];

L DID [AR2,P#7.0];

T D [AR1,P#5.0];

L DID [AR2,P#11.0];

T D [AR1,P#9.0];

L #Input_Str[12];

T B [AR1,P#13.0];

A7d8: CLR ;

A000: L #Index;

L 0;

<I ;

U #UnLoad;

SPBN A7de;

SET ;

= #Empty;

= #Error;

T #Index;

A7de: L #Index;

L 0;

>I ;

U #UnLoad;

SPBN A7df;

L #Index;

ITD ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I025;

SPA I026;

I025: CLR ;

= L 0.1;

I026: L L#112;

*D ;

SPO I027;

SPA I028;

I027: CLR ;

= L 0.1;

I028: L DIW [AR2,P#32.0];

T LW 2;

TAK ;

AUF DB [LW 2];

L DID [AR2,P#34.0];

TAK ;

T LD 2;

TAK ;

+D ;

LAR1 ;

L D [AR1,P#1.0];

T DID [AR2,P#19.0];

L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L D [AR1,P#5.0];

T DID [AR2,P#23.0];

L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L D [AR1,P#9.0];

T DID [AR2,P#27.0];

L DIW [AR2,P#32.0];

T LW 6;

TAK ;

AUF DB [LW 6];

L DID [AR2,P#34.0];

L LD 2;

+D ;

LAR1 ;

L B [AR1,P#13.0];

T #Out_Str[12];

L #Index;

ITD ;

L L#1;

>=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#12;

<=D ;

U L 0.1;

= L 0.1;

TAK ;

L L#-1;

+D ;

SPO I029;

SPA I02a;

I029: CLR ;

= L 0.1;

I02a: L L#112;

*D ;

SPO I02b;

SPA I02c;

I02b: CLR ;

= L 0.1;

I02c: L W#16#C0C;

T LD 6;

TAK ;

T LD 12;

TAK ;

L DIW [AR2,P#32.0];

T LW 10;

TAK ;

AUF DB [LW 10];

L DID [AR2,P#34.0];

L LD 12;

+D ;

LAR1 ;

L LD 6;

T W [AR1,P#0.0];

L DW#16#20202020;

T LD 6;

L DIW [AR2,P#32.0];

T LW 10;

TAK ;

AUF DB [LW 10];

L DID [AR2,P#34.0];

L LD 12;

+D ;

LAR1 ;

L LD 6;

T D [AR1,P#2.0];

L DW#16#20202020;

T LD 6;

L DIW [AR2,P#32.0];

T LW 10;

TAK ;

AUF DB [LW 10];

L DID [AR2,P#34.0];

L LD 12;

+D ;

LAR1 ;

L LD 6;

T D [AR1,P#6.0];

L DW#16#20202020;

T LD 6;

L DIW [AR2,P#32.0];

T LW 10;

TAK ;

AUF DB [LW 10];

L DID [AR2,P#34.0];

L LD 12;

+D ;

LAR1 ;

L LD 6;

T D [AR1,P#10.0];

L #Index;

L 1;

-I ;

SPO I02d;

SPA I02e;

I02d: CLR ;

= L 0.1;

I02e: T #Index;

A7df: CLR ;

U L 0.1;

SAVE ;

BE ;

END_FUNCTION_BLOCK

4 ottobre 2007

ok grazie mille. lo proverò subito :rolleyes:

15 giugno 2010

ciao henon,

ho trovato qui sul forum il codice della tua funzione l'ho copiata e compilata e stavo provando ad usarla per creare un registro accessi ad una pagina di un HMI , nello stesso hmi vorei creare una pagina dove poter leggere i nomi delle ultime 10 persone che hanno acceduto alla pagina del HMI, sono alle prime armi e autodidatta, ho provato a modificare il codice ,ma non ottengo nulla non sono nemmemo sicuro se quello che voglio fare sia possibile, chiedo quindi un piccolo aiuto e qualche dritta per poter realizzare il tutto

P.S. spero di non rubarti tempo

ti ringrazio in anticipo

saluti gravino

Accedi

Programma fifo con il plc - Riunite 2 discussioni sul medesimo argomento

Messaggi consigliati

Ospite RIKI87

Link al commento

Condividi su altri siti

floppydisco

Link al commento

Condividi su altri siti

batta

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

floppydisco

Link al commento

Condividi su altri siti

batta

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

Livio Orsini

Link al commento

Condividi su altri siti

batta

Link al commento

Condividi su altri siti

batta

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

Henon

Link al commento

Condividi su altri siti

Henon

Link al commento

Condividi su altri siti

Ospite RIKI87

Link al commento

Condividi su altri siti

gravino

Link al commento

Condividi su altri siti

Crea un account o accedi per commentare

Crea un account

Accedi

Naviga

Attività