Contatore Che Conti Da 0 A 50

[byt30]

Salve a tutti. Sono nuovo nel forum e sto imparando a programmare in step7. Ho un problema: devo creare un contatore che conti da 0 a 50 e quando arriva a 50, da 50 a 0, con passo 0,1 ogni 0.5Hz. (S7-300). Grazie in anticipo

[Livio Orsini]

Scusa, ma se non ci dici cosa devi contare, se è un conteggio di eventi esterni, etc., come possiamo darti una rispsota sensata?

[Lucky67]

Le soluzioni possono essere svariate. Una possibile può essere:

Devi crearti un timer con base tempo 2 secondi che si resetti al termine del tempo e ricominci a contare dopo ogni fine tempo: questa sarà il tuo clock.

Il contatore avendo passi 0.1 è un pò inusuale. Una soluzione può essere moltiplicare tutto per dieci così avrai a che fare solo con variabili intere tranne alla fine dove dovrai dividere per dieci e trovarti davanti ad un numero reale (quindi convertire l'intero in reale e dividere).

Detto questo puoi affrontare il tutto con delle istruzioni INC e DEC utilizzando i fronti di salita del fine tempo tel tuo temporizzatore base tempi. Dopo ogni operazione controlli se il risultato è uguale a 0 o a 500. Nel caso cambi da INC a DEC e viceversa. e così via. Detto così sembra un pò astruso ma è più facile a dirsi che a farsi.

[batta]

Potresti usare il contatore Up/Down (Z_RUECK in tedesco, S_CUD in inglese), oppure la funzione SFB2 "CTUD" che trovi nella libreria "Standard Library" --> "System Function Blocks".

Però i contatori contano sempre degli interi, e incrementano/decrementano sempre di una unità.

Quindi, se devi fare incrementi/decrementi di 0,1, la strada più semplice è costruirsi un contatore incrementando/decrementando una variabile di tipo REAL.

[byt30]

Devo usare numeri reali. Devo farlo creandomi un contatore. Devo utilizzare un merker di clock (ho scelto il 7.7) con un fronte di salita e con degli SPBN, solo non so come farlo. Sono ai primi passi per questo sono così inesperto. Grazie

[Lucky67]

con degli SPBN,

scusa cos'è un esercizio scolastico? Se così non fosse ti stai complicando la vita inutilmente.

[byt30]

Si, devo usare i salti, come da comando. grazie

[JumpMan]

Se vuoi puoi anche usare un contare normale da 0 a 500 e poi dividere il valore del contatore per 10

Ma io incrementerei una REAL di 0.1, anzi, quello 0.1 potrebbe essere una variabile il luogo di una costante:

... quando il contatore >= 50.0 inverti il segno di questa variabile (-0.1)

... quando il contatore <= 0.0 inverti di nuovo il segno (0.1)

[byt30]

Ho già provato così.. è una cosa del tipo:

U M 7.7

FP M 5.0

SPBN L001

L COUNT (variabile creata e richiamata da un DB)

L 50

>=R

S M 1.0

SPBN...................

....................

..........................

...................

........................

..............

L001: NOP 0

l'inizio è quello, poi non so più come proseguire! Devo sicuramente mettere altri SPBN in mezzo (credo che in tutto siano 4), fare lo stesso conto al contrario e usareanche (UN), ma non so come combinare il tutto! Serve il controllo per il count perchè magari inizialmente è un numero maggiore di 50, poi

bisogna fare anche il controllo per verificare se il count è <=0. Mi è difficile anche spiegarvelo......

Modificato: 19 settembre 2013 da byt30

[JumpMan]

Per prima cosa se COUNT è in una DB non l'hai aperta, poi se vuoi contare i decimali deve essere REAL (e L50 deve essere L 50.0)

Hai fatto il confronto per >= 50, fai anche quello per <=0 che resetta il bit 1.0

Poi, a seconda dello stato di M1.0 puoi gestire l'incremento o il decremento di COUNT.

Per me sarebbe più facile scriverti il codice, ma tu avresti copiato senza capire niente, e se è un esercizio scolastico non va bene...

ciao

p.s. se hai definito MB7 come clock devi usare M7.3, perchè M7.7 ha un ciclo di 2 secondi

Modificato: 19 settembre 2013 da JumpMan

[byt30]

Esatto, a seconda dello stato di M1.0 devo gestire il count...va bene grazie lostesso. Ciao

[batta]

Ma qui hai solo fatto il controllo del raggiungimento del valore massimo.

Dov'è la parte per l'incremento/decremento? E quella per il controllo del raggiungimento del valore minimo?

Inoltre ci sono anche errori:

1) se lavori con variabili di tipo REAL, la variabile "COUNT" sarà di tipo REAL. Ed infatti per il confronto utilizzi >=R. Però il confronto lo devi fare con "50.0" e non con "50". Se scrivi solo 50 il numero viene interpretato come INT, e non come REAL, e l'esito della comparazione sarà imprevedibile.

2) Se "COUNT" è una variabile dichiarata in un DB (e questo va benissimo), la sintassi sarà "Nome_DB".COUNT

L'idea poi di JumpMan di cambiare il segno alla variabile, è buona.

In questo modo tu dovresti fare col fronte di salita del clock sempre la stessa operazione (incremento di COUNT del valore STEP).

Poi, al raggiungimento dei limiti, modifichi il valore di STEP.

Risulta poi facilissimo impostare STEP = 0.1 quando devi salire da 0.0 a 50.0, e STEP = -0.1 quando devi scendere da 50.0 a 0.0.

Potresti anche impostare valori diversi (oltre al segno, intendo) in salita e in discesa.

N.B.: se segui questa strada, non dimenticarti di inizializzare il valore di "STEP". Se "STEP" vale 0.0 non funziona nulla.

Modificato: 19 settembre 2013 da batta

[byt30]

Si si lo so che mi mancano quelle parti. Per quanto riguarda le precisazioni che mi hai fatto, ho fatto anche io così, solo qua sul forum l'ho scritto male perchè non ci ho pensato, non avendo Step7 a casa. Va bene vi ringrazio, oggi provo a finirlo. Vi riferirò come lo avrò eseguito. Saluti!

[byt30]

C'è l'ho fatta!!

U M 7.0

FP M 5.0

SPBN L001

L"DB_TEST".contatore

L 100.0

>=

R

S M 1.0

L"DB_TEST".contatore

L 0.0

<=

R M 1.0

U M 1.0

SPBN L002

L"DB_TEST".contatore

L 0.1

-R

T "DB_TEST".contatore

L002: NOP 0

UN M 1.0

SPBN L003

L"DB_TEST".contatore

L 0.1

+R

T "DB_TEST".contatore.

L003: NOP 0

L001: NOP 0

[JumpMan]

Bene !

A parte qualche errore di battitura (una R andata a capo e una mancante nei confronti) è corretto ed hai usato gli SPBN e UN come richiesto.

Puoi anche togliere L003, l'ultimo SPBN lo punti su L001

Si potrebbero anche ridurre le righe di codice, ma se è un esercizio credo vada bene così...

M7.0 se fa parte del byte di clock definito nell'hardware non va bene, è troppo veloce, per 0.5Hz dovresti usare M7.3

[byt30]

si si ho sbagliato io a scrivere ma l'esercizio va benissimo, ho capito, grazie dei consigli. Ora il mio prossimo esercizio è quello di misurare quanti giri compie un motore elettrico in un minuto con un sensore di movimento collegato al plc.

[batta]

Io proporrei una piccola modifica, utile per imparare bene l'uso dei salti.

Leggendo lo stato di M1.0 decidi se fare l'incremento oppure il decremento. E questo va benissimo.

Poi che si decida di usare SPB o SPBN non ha importanza (ovviamente facendo attenzione a valutare lo stato di M 1.0 nel modo corretto).

Una volta però che hai deciso di usare M 1.0 per non fare il salto a L002 (ed eseguire quindi le istruzioni per il decremento), ti basta mettere un salto incondizionato prima dell'etichetta L002 (SPA L001).

In questo modo non hai più bisogno di testare nuovamente lo stato di M 1.0 per controllare se devi fare o meno l'incremento.

L'etichetta L003, come già detto da JumpMan, non serve.

Esempio:

U M 1.0
SPBN L002
L"DB_TEST".contatore
L 0.1
-R
T "DB_TEST".contatore
SPA L001
L002: L"DB_TEST".contatore
L 0.1
+R
T "DB_TEST".contatore.
L001: NOP 0

Volendo si potrebbero ridurre le istruzioni e usare il salto solo per decidere se fare +R oppure -R:

L"DB_TEST".contatore
L 0.1
U M1.0
SPB L001
+R
SPA L002
L001: -R
L002: T"DB_TEST".contatore

[JumpMan]

     U  M 7.0
     FP M 5.0
     SPBN _end
     
     L 100.0
     L "DB_TEST".contatore
     <=R
     SPB _dwn
     L 0.0
     <=R 
     L 0.1
     SPB _up
     SPA _cnt

_dwn:L -0.1
_up :T "DB_TEST".Step

_cnt:L "DB_TEST".contatore
     L "DB_TEST".Step
     +R
     T "DB_TEST".contatore

_end: NOP 0

Per completare ho riportato il codice riferito al mio post nr.#8

Ho lesinato al massimo nelle istruzioni, rendendolo forse meno comprensibile, come si faceva una volta con lo STEP 5

Il presupposto per il funzionamento di questo codice è che al momento della creazione della DB si imposti il valore iniziale di "DB_TEST".Step = 0.1 (altrimenti dovevo aggiungere altre istruzioni per fare questo)

[byt30]

Vi ringrazio per tutti gli aiuti e i suggerimenti, mi sono stati molto utili e sicuramente ne avrò ancora bisogno. Secondo me è molto difficile imparare a programmare con questo linguaggio rispetto a un C++ per esempio...

[Livio Orsini]

Da quando si impara a programamre solo con linguaggi ad alto livello usare linguaggi simili all'assembler sembra faticoso e difficile.

[batta]

Ora quasi tutti i PLC si possono programmare anche in linguaggio strutturato.

Personalmente non capisco perché si sia affermato il linguaggio strutturato come linguaggio ad alto livello in questo settore. Avrei preferito il C.

Riguardo l'AWL, io penso sia solo questione di un po' di abitudine.

Da un certo punto di vista, penso si potrebbe affermare che sia il più semplice.

Alla fine, ci sono ben poche cose da imparare: come valutare il risultato logico di operazioni booleane, e come operare con gli accumulatori.

Imparato questo, basta solo ragionare elaborando un'istruzione alla volta, come fa il processore.

[Livio Orsini]

Avrei preferito il C.

Anch'io, ma questo renderebbe i programmi PLC facilmente trasportabili tra PLC anche di marche differenti; ovviamente i costruttori di PLC questo non lo vogliono.

Modificato: 23 settembre 2013 da Livio Orsini

[byt30]

Confermo... incontro parecchie difficoltà, ma ce la metterò tutta!!