Vai al contenuto
PLC Forum


Cavi Illuminazione Giardino


Ospite RIKI87

Messaggi consigliati

Ospite RIKI87

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..

Link al commento
Condividi su altri siti


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.

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

Ospite RIKI87

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è???

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

Ospite RIKI87

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!!

Link al commento
Condividi su altri siti

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

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

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.

Link al commento
Condividi su altri siti

Ospite RIKI87

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..

Link al commento
Condividi su altri siti

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: da Henon
Link al commento
Condividi su altri siti

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

Link al commento
Condividi su altri siti

  • 1 year later...

sto per fare un piccolo impianto per illuminare il giardino ho gia posato currugati rossi e pozzetti...vorrei mettere lampioncini con sfera...ho intenzione di mettere un cavo da interramento cioè a doppio isolamento (va bene FG7???)...un amico mi consigliava visto che ho usato currugati di usare i fili unipolari cosi come si fa nell'impianto interno ma io lo ritengo errato anche dal punto normativo...è giusta la mia riflessione?

Link al commento
Condividi su altri siti

domande :

- E' un terreno soggetto a congelamento?

- Presenza di roditori o simili? ( dovresti usare un cavo anti-roditore )

- Allagamenti pesanti e frequenti? ( dovresti usare un cavo adatto alla posa in acqua )

L'N07V-K non è ammesso per la posa interrata, sia diretta che con protezione meccanica, aspetta altri pareri pero' ....

Link al commento
Condividi su altri siti

Non credo di avere un terreno soggetto a congelamenti e allagamenti anche se quest'anno le piogge sono state piu del normale....il tipo di terreno è tufaceo e qualche roditore penso ci sia comunque visto che in campagna succede....le temperature che ho nella mia zona sono quelle piu o meno di roma in quanto sono nella provincia.

il mio dubbio piu grosso era se usare cavi unipolari come diceva il mio amico o cavi tipo fg7 con la guaina protettiva intorno ai 3 fili unipolari (2 + terra).

Link al commento
Condividi su altri siti

se hai in totale 50 mertri da cavi non ci pensare neanche metti FG7.

Se hai 300 metri il discorso cambia

Però mi raccomando un bel magneto/diff separato da tutto il resto dell'impianto.

Modificato: da rimonta
Link al commento
Condividi su altri siti

per quello che costa, se fai pochi metri meglio un doppio isolamento così sei tranquillo per sempre.

inoltre se per caso entra acqua nel corrugato con questo cavo non hai problemi.

Se però fai molti metri può diventare molto costoso rispetto alle normali cordine.

Modificato: da rimonta
Link al commento
Condividi su altri siti

Dunque se ho capito bene, correggetemi se sbaglio, un impianto piccolo si può fare bene anche se costa un po di più mentre un impianto grande con molti metri di cavo si può fare a c.... tanto chi se ne frega delle normative e della sicurezza.

Dico bene? :o :o :o :o :o

Modificato: da dama70
Link al commento
Condividi su altri siti

Crea un account o accedi per commentare

Devi essere un utente per poter lasciare un commento

Crea un account

Registrati per un nuovo account nella nostra comunità. è facile!

Registra un nuovo account

Accedi

Hai già un account? Accedi qui.

Accedi ora
×
×
  • Crea nuovo/a...