Calcolare La Velocità Di Un Tappeto

[batta]

Flavio, è possibile che ti sia sfuggito qualcosa e che invece con questa cpu posso leggere lo stesso gli impulsi che arrivano dall'encoder?

Sì, è vero: ha un contatore veloce utilizzabile per conteggio impulsi o misura di frequenza.

Si tratta comunque di una cpu molto vecchia, con poca memoria, pochi merker, pochi timer... poco di tutto.

Sicuramente basta per fare semplici prove e piccoli progetti, ma non so se valga la pena spendere soldi per un prodotto così obsoleto.

[busanela]

Sicuramente basta per fare semplici prove e piccoli progetti, ma non so se valga la pena spendere soldi per un prodotto così obsoleto

Ciao Flavio,

il punto è proprio questo: al nostro amico tommy93 serve solo per didattica, Non credo dovrà mai utilizzarla per un pallettizzatore con navetta di carico/scarico martire!

... E poi, parlando anche dal punto di vista del genitore, costa senz'altro meno di una X-BOX! Scherzi a parte, per l'autodidattica necessaria a Tommy93, o riesce a trovare in rete a modico prezzo una FM350 o si "accontenta", per il momento di quanto disponibile. Mi sembra comunque strano che nell'istituto da lui frequentato non ci sia in programma l'insegnamento dell'implementazione di contatori veloci, così come di ingressi ed uscite analogiche, connessioni di rete anche se solo MPI, interfaccia con OP, etc., etc.

Magari avendo un pò di pazienza, queste prove le riuscirà a fare assieme alla classe anche se è sicuramente ammirevole la sua voglia di imparare, precorritrice dei tempi scolastici.

[tommy93]

Ciao ragazzi

Ho pensato di rimandare lo studio sugli ingressi veloci e dell'encoder a quando mi arriverà la cpu.

Tornando al calcolo della velocità, ho provato a incrementare una variabile con la temporanea OB1_PREV_CYCLE.

Bene, cioè male, non riesco a capire come "prenderla".

In OB1 ho scritto il seguente codice:

      L     #OB1_PREV_CYCLE
      FP    M      1.0
      SPB   _001
      BEA   
_001: L     MW    10
      L     1
      +I    
      T     MW    10

e quello che vedo dallo stato online è questo:

dove sbaglio?

[tommy93]

Ciao Flavio, con il metodo che mi hai descritto nel post #20 ho messo insieme queste istruzioni.

// in OB35, ogni 1000Ms, incremento la variabile MW10 

      L     MW    10                    // variabile del tempo
      +     1
      T     MW    10

// in OB1, ad ogni fronte di salita del micro, incremento il conteggio 
// degli impulsi e controllo la variabile del tempo.
// Se il tempo è < 1000Ms incremento il conteggio degli impulsi. 
// Se il tempo >= 1000Ms calcolo la velocità.

      U     E      0.0                  // impulsi micro
      FP    M      0.0
      SPBN  _001
      L     MW    16                    // Numero impulsi
      +     1
      T     MW    16

      L     MW    10                    // variabile del tempo
      L     1000                        // 1000Ms
      >=I   
      SPB   _002
      BEA   
_002: NOP   0
      L     MW    16                    //Numero d'impulsi
      ITD   
      DTR   
      L     MD    12                    //Spazio tra due impulsi
      *R    
      T     MD    20                    //Spazio totale di avanzamento mm/s

      L     0                           // azzero variabili del tempo e impulsi
      T     MW    10
      T     MW    16

_001: NOP   0

ho tradotto bene in awl?

Con il metodo della variabile locale OB1_PREV_CYCLE, non riesco proprio a capire come fare e nemmeno trovo qualche descrizione del funzionamento (esempio premendo F1 dal Simatic).

Modificato: 17 gennaio 2011 da tommy93

[batta]

Generalmente in OB1 non si scrive tanto codice, ma solo il richiamo alle varie FC e/o FB.

Per poter utilizzare all'interno di una FC il valore di OB1_PREV_CYCLE devi appoggiarlo ad una variabile globale, oppure passarlo alla FC come parametro.

Lasciamo perdere il parametro e vediamo come rendere OB1_PREV_CYCLE visibile a tutti:

L #OB1_PREV_CYCLE
T MW100    //Variabile contenente il tempo dell'ultima scansione in millisecondi

Ora in OB1 devi richiamare la funzione dove scriverai il codice per il calcolo della velocità (supponiamo FC10):

CALL FC10

Se la funzione è senza parametri al posto di "CALL" si può utilizzare l'istruzione "UC". Vediamo ora cosa si potrebbe scrivere in FC10:

//Incremento tempo trascorso
L MW102    //Tempo trascorso da ultimo calcolo velocità
L MW100    //Tempo ultimo ciclo
+I
T MW102    //Tempo aggiornato trascorso da ultimo calcolo velocità

Non voglio scrivere il resto del codice ma, se segui le istruzioni del post #20, una volta calcolato il tempo come sopra, aggiungi sempre in FC10 le istruzioni per il conteggio degli impulsi, per il calcolo della velocità e per l'azzeramento del conteggio impulsi e del tempo trascorso.

OB35, se utilizzi questo sistema, non ti serve più.

[walterword]

UC se la chiamata e' incondizionata , CC se invece c'e' una condizione per chiamare la FC .

L'uso di CC tiene in considerazione il risultato logico combinatorio (RCL)

ciao

walter

p.s. CALL se la FC o FB hanno dei parametri In o InOut o Out

[tommy93]

Ciao a tutti, dopo alcuni giorni dedicati ad altre materie sono tornato nuovamente a importunarvi con i miei esperimenti.

Sono sempre alle prese con il fantomatico esercizio per calcolare la velocità di avanzamento del tappeto, in più ora ho immaginato di aggiungere la possibilità di determinare la frequenza da inviare ad un inverter al fine di mantenere una velocità precedentemente impostata.

Le istruzioni che seguono ho provato a testarle controllando le variabili nelle tabelle VAT e sembrano funzionare.

O almeno questa è la mia impressione!

Vorrei gentilmente da voi un giudizio sulla funzionalità e anche sul metodo di scrittura che ho adottato, mi riferisco alla descrizione delle operazioni.

E visto che sono convinto che questo sarà il mio lavoro, i vostri consigli sono per me come manna dal cielo e la sicurezza di entrare in un nuovo mondo con il piede giusto.

Il blocco di programma che segue, cioè quello che richiama SFB47 l’ho scritto in OB1, mentre il successivo stà scritto in OB35 con richiamo ogni 1000Ms.

La cpu è la 313C-2DP mentre l’encoder è quello della foto precedente: eltra EH-EL63 10000 impulsi giro.

Nella speranza di aver scritto correttamente i codici resto in attesa dei vostri commenti/giudizi/critiche/consigli, insomma dritte di ogni genere sono per me costruttive.

// Comando del contatore con l'SFB 47 "COUNT" 
      CALL  "COUNT" , DB47
       LADDR   :=EW124                  // Preimpostazione di sistema; l'indirizzo è impostato nell'Hardware
       CHANNEL :=0                      // Numero del canale utilizzato.
       SW_GATE :=DB47.DBX4.0            // Abilito conteggio con stato 1; azzero contatore con stato 0
       CTRL_DO :=
       SET_DO  :=
       JOB_REQ :=
       JOB_ID  :=
       JOB_VAL :=
       STS_GATE:=
       STS_STRT:=
       STS_LTCH:=
       STS_DO  :=
       STS_C_DN:=
       STS_C_UP:=
       COUNTVAL:=DB100.DBD0             // Scrittura del valore attuale di conteggio
       LATCHVAL:=
       JOB_DONE:=
       JOB_ERR :=
       JOB_STAT:=

// Abilito il conteggio 
      UN    M      7.7                  // sempre FALSE
      S     DB47.DBX    4.0             // Abilito conteggio con stato 1;... azzero contatore con stato 0

//Entro ciclicamente in OB35 ogni 1000MS interrompendo l'elaborazione del programma. 
//Eseguo l'algoritmo per il calcolo dell'avanzamento e la frequenza nominale, poi torno
//all'esecuzione del programma normale dal punto in cui era stato interrotto.  

// Elenco delle variabili
// DB100.DBD0  = numero_impulsi (COUNTVAL da SFB47 ruota/encoder)
// DB100.DBD4  = spazio_impulso
// DB100.DBD8  = velocità_reale mm/s
// DB100.DBD12 = sviluppo_ruota (circonferenza in mm.)
// DB100.DBD16 = SET_avanzamento (richiesto dal cliente)
// DB100.DBD20 = rps_ruota
// DB100.DBD24 = rapporto_riduttore (se esiste, altrimenti scrivere 1)
// DB100.DBD28 = rps_motore giri per secondo
// DB100.DBD32 = rpm_motore giri per minuto
// DB100.DBD36 = rpm_motore_di_targa (dichiarati dal costruttore)
// DB100.DBD40 = Hz_Frequenza nominale
// DB100.DBD44 = Diametro_ruota


// INIZIO CON IL CALCOLO DELL'AVANZAMENTO IN mm. 
// Conoscendo il diametro della ruota, ricavo lo sviluppo in millimetri 
// applicando la formula D*pi
      L     DB100.DBD   44              // Diametro della ruota
      L     3.140000e+000
      *R    
      T     DB100.DBD   12              // Sviluppo della ruota

// Divido lo sviluppo della ruota per il numenro di impulsi e trovo 
// la distanza in mm.tra gli impulsi. 
      L     DB100.DBD   12              // Sviluppo della ruota
      L     1.000000e+004               // n° impulsi encoder
      /R    
      T     DB100.DBD    4              // spazio tra gli impulsi

// Da DB100.DBD0 vedo quanti impulsi ho contato in 1000MS(un secondo), 
// moltiplico per lo spazio in DB100.DBD4,
// il risulatato in DB100.DBD8 corrisponde all'avanzamento in mm/s
      L     DB100.DBD    0              // Numero di impulsi
      ITD   
      DTR   
      L     DB100.DBD    4              // spazio tra gli impulsi
      *R                                // Moltiplico ACCU 1 per ACCU 2 
      T     DB100.DBD    8              // Velocità di avanzamento

// Cancello gli impulsi in SFB47
      UN    M      7.7                  // sempre FALSE
      R     DB47.DBX    4.0             // SW_GATE in SFB47

//*******************************************************************************    
// CALCOLO LA FREQUENZA NOMINALE.
// Per il calcolo della velocità rps (giri al secondo) della ruota prendo il dato inserito  
// in DB100.DBD16 (velocità richiesta dal cliente) e lo divido per lo sviluppo della ruota.
      L     DB100.DBD   16              // velocità di avanzamento richiesto in mm/s
      L     DB100.DBD   12              // sviluppo della ruota in mm.
      /R    
      T     DB100.DBD   20              // rps ruota (giri per secondo)

// Ipotizzo di avere un riduttore 38:1
// per il calcolo della velocità rps del motore moltiplico rps ruota*rapporto riduttore
      L     DB100.DBD   20              // rps ruota (giri per secondo)
      L     DB100.DBD   24              // rapporto albero motore e riduttore (=1 se rapporto 1:1)
      *R    
      T     DB100.DBD   28              // rps motore (giri per secondo)

// Trasformo rps motore in rpm (giri minuto) con la formula rps*60
      L     DB100.DBD   28              // rps motore (giri per secondo)
      L     6.000000e+001               // unità di tempo in secondi
      *R    
      T     DB100.DBD   32              // rpm motore (giri per minuto)

// Ora conoscendo il dato rpm motore, il dato rpm1 di targa del costruttore e la frequenza di lavoro (50Hz)
// trovo la corrispondenza in Hz da inviare all'inverter.
// x=(rpm*50Hz)/rpm1
      L     DB100.DBD   32              // rpm motore (giri per minuto)
      L     5.000000e+001               // frequenza di lavoro (50Hz)
      *R    
      L     DB100.DBD   36              // rpm1 giri motore di targa (dato di targa es:1450giri)
      /R    
      T     DB100.DBD   40              // frequenza nominale

Grazie 1000 a tutti per la lettura

[tommy93]

Buona sera a tutti.

Sono riuscito a mettere insieme il necessario per provare il codice di programma.

Motore, inverter, plc, encoder e analogica.

Collegato il tutto e avviato il codice di programma, con mia grande sorpresa ho verificato che funziona.

Nel senso che il numero di giri che visualizzo in DB100.DBD8 corrisponde a quello che imposto nella variabile DB100.DBD16

NB: ho verificato anche con un misuratore di giri tipo quelli a rotella e i valori si differenziano di pochissimo, dunque l'uscita in frequenza calcolata con la formuletta x=(rpm*50Hz)/rpm1 corrisponde

Nel senso che ogni tanto, è molto casuale, il numero degli impulsi che leggo in DB100.DBD0 raggiunge un valore superiore a quello che normalmente mantiene durante il normale funzionamento.

Il sospetto è che non sempre l'ob35 non si elabora ogni 1000ms.

Infatti, se scrivo il codice in un'altro blocco e lo richiamo con un timer ogni secondo questo difetto scompare.

Vi è mai capitato una cosa simile, oppure è un'errore mio?

Spero di ricevere ancora qualche dritta, giudizio, critica o commento al lavoretto che grazie a voi sono riuscito a fare.

Vi aspetto presto, tommy

[Dragonfly]

Ragazzi siete veramente persone umili e con una pazienza infinita.grazie veramente Della disponinila 

[Dragonfly]

I would like always to find person like you

[Dragonfly]

Scusate Se mi intrometto Ma ci stava 

[Giuseppe Signorella]

Dragonfly, ti ringrazio a nome del forum per l'apprezzamento, ma in ogni caso hai infranto il regolamento.

Ti sei accodato ad una discussione esistente e ferma oramai da anni. 

No. No, non si fa....

 

 

*****************************Questa discussione è chiusa********************************

[walterword]

puoi fare il calcolo considerando la quantità di impulsi che viene prodotta in una quantità di tempo 

In pratica è una derivata , anche perchè in meccanica-cinematica la derivata prima dello spazio rispetto al tempo è la velocità e la derivata seconda dello spazio rispetto al tempo quadro è l'accelerazione (e quindi la derivata prima della velocità rispetto al tempo quadro = accelerazione) .

Se consideri il tempo ciclo cpu piu o meno stabile , anche se in realtà non lo è , puoi fare il ragionamento di cui sopra

Un altro metodo è quello di considerare un tempo fisso preciso ottenuto tramite interrupt che è molto più preciso e tecnicamente più appropriato.

In sostanza ti calcoli un deltaImpulsi ad ogni ciclo o meglio ad ogni richiamo di interrupt ,Considera che essendo il tempo di ciclo molto breve rischi di non vedere nulla mentre invece se richiami su interrupt in OB35 per esempio a 100 mS o piu allora vedi qualcosa .L'interrupt è piu preciso dei timer che sono asincroni cioe' dipendono dal tempo di ciclo cpu. Questo perche cosi metti a fuoco la teoria con la pratica visto che in 4° ITIS dovresti gia aver affrontato lo studio di analisi 1 ed aver gia superato fisica-meccanica.