Non è come il buon vecchio basic insomma.
Però vedevo un tizio su YouTube che svriveva un paio di righe le lanciava ed aveva a video il print
Ho scaricato una demo program dalla pagina di download di kinco. La struttura è di per sé un po’ complessa ma suppongo esista una specie di IDE o ambiente di sviluppo.
Il suggerimento è prendere il progetto demo che più si avvicina alle tue esigenze e modificarlo.
Per quel che riguarda le funzioni base ho fatto così, deve solo visualizzarmi dei parametri. Alcuni live altri solo come lettura o scrittura.
L’ unico problema ce l’ ho con quel valore live di cui ho fatto un grafico.
Se non ho capito male come funziona, devi aggiungere la macro, e inserire il codice all’interno della funziona MacroEntry(). Mi pare che la prima DEMO (Grid_demo) della pagina lì sopra sia pertinente.
#include "macrotypedef.h"
#include "math.h"
/*
Read,Write Local address function:
int ReadLocal( const char *type, int addr, int nRegs, void *buf, int flag );
int WriteLocal( const char *type, int addr, int nRegs, void *buf , int flag );
Parameter: type is the string of "LW","LB" etc;
address is the Operation address ;
nRegs is the length of read or write ;
buf is the buffer which store the reading or writing data;
flag is 0,then codetype is BIN,is 1 then codetype is BCD;
return value : 1 ,Operation success
0, Operation fail.
eg: read the value of local lw200 and write it to the lw202,with the codetype BIN,
The code is :
short buf[2] = {0};
ReadLocal("LW", 200, 2, (void*)buf, 0);
WriteLocal("LW", 202, 2, (void*)buf, 0);
*/
int MacroEntry()
{
// segue mille mila righe di codice spazzatura...}
return 0;
}
A naso devi usare ReadLocal e WriteLocal per leggere le variabili di ingresso e scrivere le uscite.
Si, si, qualsiasi funzione, tasto o lettura è data da una macro, non ci sono problemi.
L’ unico è solo quella formula del grafico.
Appena inserisco tutte le variabili la provo.
In che variabili sono gli input (a,b,c,d e x), hanno un nome? e Y? Di che tipo sono?
Dai che ti aiuto.
Non ci sono ancora, sono variabili dell’avvolgitore, devo ancora crearle, ci dovrei arrivare lunedì, oggi mi hanno dato un’ urgenza.
In pratica prenderò le variabili interne dell’inverter e le copio dentro a delle variabili dell’HMI, su queste poi verrà fatto il calcolo.
Dunque, potrei già nominarle adesso mentre mi sto prendendo il caffè di mezza mattina.
a=KG4_LW
b=KGF4_LW
c=DMIN4_LW
d=DMAX4_LW
x=DIAM4
In soldoni la macchina avvolge un tessuto con un tiro iniziale “a” e finisce con un tiro finale “b”.
Il campo è dato dalla variazione del diametro del rotolo compreso tra “c” (diametro iniziale) e “d” (diametro finale).
“x” è il valore del diametro letto da un sensore.
“Y” la chiamiamo TIRO_LW
Ho scaricato il manuale dei DTools, è tutto molto semplice.
Definisci come spiegato a pagina 373 e segg. tutte le variabili, definendo il tipo corretto. Su questo ci sono un po’ di considerazioni da fare però. Le vediamo dopo.
Intanto, devi sapere come il PLC formatta le variabili. Sostanzialmente saranno interi, decimali a virgola fissa, oppure a virgola mobile.
Per ora per semplicità supponiamo siano variabili a virgola mobile, di tipo float oppure double (IEEE758 a 32 o 64 bit rispettivamente).
La macro diventa:
int MacroEntry()
{
if (x < c) {
y = a;
} else if (x > d) {
y = b;
} else {
y = (b - a) / (d - c) * (x - c) + a;
}
return 0;
}
Se invece si tratta di interi o, in modo del tutto equivalente, decimali a virgola fissa, occorre fare una serie di considerazioni nel calcolo per non incorrere in overlow, underflow e perdita di precisione. Investighiamo il formato delle variabili e poi ne riparliamo, nel caso.
Interessante l’articolo di Attivissimo, su una ricerca sui Cookies: tutte le volte che i siti ti chiedono “Accetti o rifiuti” e poi una lunghissima pappardella che nessuno mai legge, se clicchi su"rifiuto", per 2 siti su 3 è “accetto”.
In definitiva, è una noiosa finestrella per prenderti per il culo.
2 Mi Piace
Ma infatti ormai alcuni browser sono predisposti per saltarla direttamente.
per chi se lo fosse perso, il podcast è qui
devo dire che, avendo sentito la voce di Attivissimo, non solo in altre trasmissioni ma anche dal vivo, sono un po’ perplesso: non sembra lui (gomblotto!)
Ciao, è sempre il vostro disinformatico che chiede aiuto.
Devo andare a testare bit per bit una double word e non so come fare.
Scrivo quello che vorrei fare, ma non so la sintassi:
pippo è una double word
if (pippo [15mo bit]==1 then pluto==1
else pluto==0
if (pippo [7mo bit]==1 then paperino==1
else paperino==0
Pluto = Pippo>>15 & 0x1;
Paperino = = Pippo>>7 & 0x1;
Due parole >> è operazione sui bit chiamata shift, ossia slitta di un intero di bit richiesto. Poi fai il controllo sul bit meno significativo, ossia una operazione AND di 0x1, che è una sfilza di zeri (quanti dipende dalla rappresentazione, qui doppia parola, 32 bit) con un singolo uno finale. L’operazione AND azzera dove ci sono gli zeri e restituisce il valore dove c’è l’uno.
Quindi stai controllando l’ultimo bit. Se è alto assegni 1, se basso assegni zero. Vista la congruenza, assegni direttamente il risultato.
2 Mi Piace
Ti ringrazio, ho capito come fai.
Al momento mi da errore, ho capito già che questo hmi non accetta tutta la sintassi C.
Ora cerco di shiftare o dividere per la potenza di 2 che mi serve e poi fare l’ AND con 00000000001
Rettifico, avevo scritto male una variabile.
Abbiate pietà 
1 Mi Piace
@Fedemone
Funziona perfettamente, grazie ancora.
Di nulla, ne ho visto un milione di casi simili. Una alternativa identica è fare slittare il bit.0x1 nella posizione che ti interessa (0x1<<15) e poi sempre AND.
Per ogni domanda, siamo qui
1 Mi Piace
Pero’ non sono esattamente equivalenti.
Questo statement
if ( (x >> 15) % 0x01) y = 1;
e’ al 100% equivalente a
y = (x >> 15) % 0x01;
In forza del fatto che stai facendo AND con 1: se per esempio x fosse 0b1001.0010.1000.1000, allora x >> 15 e’ 0000.0000.0000.0001.
E’ semanticamente simile se y e’ testato come un boolean:
y = x & (1 << 15);
ma se invece y e’ trattato come intero/bitmap, le due istruzioni NON sono equivalenti.
Nel primo caso, y == 0b0000.0000.0000.0001, nel secondo caso y = 0b1000.0000.0000.0000.
Diventa equivalente invece questa istruzione:
y = !!( x & (1 << 15) );
La prima negazione logica trasforma 0b1000.0000.0000.0000 in 0 e la seconda in 1.
La scelta tra le tre dipende da come viene trattato y.
1 Mi Piace
Verissimo, avevo giusto in mente un test booleano, ma effettivamente sono due risultati diversi.