Banale If then else in ladder

[zepego]

Ciao ragazzi, dovrei realizzare un banale if then else, ma sono nuovo di questo linguaggio ed ho delle difficoltà.  Ieri non ho avuto il tempo di testarlo sul pc su cui ho i software ed ora non riesco a liberarmi dai dubbi.

Quello che devo fare è:

if A then

  if (B) then C

  else D

endif

 

Ovviamente il mio dubbio è legato al fatto che la B è una serie di altre condizioni e vorrei evitare di riscrivere tutte le condizioni negate.

Secondo voi come si potrebbe realizzare in Ladder? E' importante che la condizione D venga effettuata solo se B è falsa.

Secondo voi una cosa del genere potrebbe funzionare? Scusate il pessimo disegno.

 

   A     B      temp  temp                              C

--| |----| |------(L)-----| |----------------------------( )

                           |          |                          temp

                           |          |-----(timer 10s)---(U)

                           |

                           |       temp                       D

                           |--------|\|---------------------( )

 

Ho dei dubbi perchè temo che D valga 1 anche quando rilascio il latch e/o A e B sono 0.

 

Gazie a tutti

[rguaresc]

  A     B             C
-! !-+-! !-----------( )
     !
     !  B             D
     +-!/!-----------( )

prima ssegna  a B il suo valore.

[zepego]

Il problema, come ho scritto sopra, è che la B comprende una serie di altre condizioni e perciò cercavo un modo per evitare di riscrivere tutte le duali.

 

Nel codice che ho scritto sopra, secondo voi, cosa accade?  Forse valutando B in un altro ramo ed utilizzare una variabile d'appoggio per poi utilizzare la forma classica come indicato anche da rguaresc sarebbe meglio?

Tipo:

    B            temp

---| |-----------( )

    A    temp         C

---| |----| |-----------( )
        |
        |  temp            D
       +---|/|------------( )

 

 

[batta]

Per prima cosa, il codice IF THEN ELSE che hai scritto è sbagliato.

Immagino tu volessi scrivere:

if A then
	if B then 
		C := TRUE;
	else
		D := TRUE;
	end_if;
end_if;

 

In KOP questo equivale a:

    A      B     C
---┤ ├-┬--┤ ├---(S)
       |   B     D
       └--┤/├---(S)

 

[zepego]

Io ringrazio tutti per le risposte, però forse continuo a non farmi capire e quindi provo a spiegarmi meglio. Il codice in c che ho scritto era solo indicativo di quello che devo fare, C e D sono delle altre operazioni (spostamento di variabili) da effettuare solo quando altre istruzioni rappresentate da B sono vere o false (B comprende confronti con altre variabili tipo EQ, NEQ, <=, ...). Quindi C e D non sono true o false, ma devono fare o meno delle cose. Diciamo che tutto questo dettaglio non serve per la mia domanda originaria, solo che vorrei evitare di fare il negato di B (abbastanza lunga da fare).

Perciò stamattina avevo pensato di adattare il codice, ovviamente corretto, postato da rguaresc e batta in questo modo:

 

   B                    temp

---| |-----------------( )

 

 

    A    temp         C

---| |----| |-----------( )
        |
        |  temp         D
       +---|/|----------( )

 

 

In cui ribadisco che B rappresenta una serie di molte altre condizioni da valutare, non una singola condizione, e C e D sono operazioni di spostamento o altro.

Io penso che così possa andare riducendo molto il codice, evitandomi di riscrivere tutte le istruzioni opposte a quelle che rendono B vera...non so se sono stato abbastanza chiaro, scusate.

 

Grazie ancora

[lucios]

Quote

solo che vorrei evitare di fare il negato di B (abbastanza lunga da fare)

Forse non ho capito: tu hai tutta una serie di condizioni che ti danno B e, a seconda se B è vero o falso, devi fare C o D che, a loro volta, sono tutta un'altra serie di cose.

E' così? Se si perchè non ti crei una variabile intermedia B, risultato di tutte le condizioni, e poi non la usi diritta e negata come ti è stato proposto?

Perchè dici che è lunga?

Anche in linguaggi che usano l'if, se le condizioni sono tante, diventa lunga la cosa.

Anche se, indipendentemente dal linguaggio, se ci sono molte condizioni, le buone regole di programmazione suggeriscono di dividere le condizioni in sottocondizioni più semplici (nel caso del ladder usando variabili di appoggio con criteri logici), proprio per non avere troppi rami in serie/parallelo nella stessa rete.

Tutto ciò per ridurre gli errori e facilitare il debug.

[zepego]

infatti sarebbe la variabile "temp" quella di appoggio. 

[lucios]

Quote

infatti sarebbe la variabile "temp" quella di appoggio

Scusa mi era sfuggito... ma l'avevo letto sul cellulare. Comunque si il concetto è quello. Fare delle reti non troppo complesse.

Quindi, problema risolto?

[zepego]

si problema risolto... grazie a tutti