[Sergio Bertana]

In effetti ho verificato la comparsa dell’errore nella procedura di comparazione dei progetti.

E’ un problema di LogicLab, ho informato Axel del problema, attendo notizie.

[Sergio Bertana]

L’errore è generato dal FB AESDecryption presente nella libreria eLLabAESCryptLib, una delle variabili interne al FB è definita con il nome Step. Se nel tuo progetto non hai selezionato la compilazione Case-sensivity (Vedi screenshot), LogicLab considera tutte le definizioni come se fossero scritte in caratteri maiuscoli. Ecco perchè nell’errore il FB è riportato AESDECRYPTION tutto in maiuscolo.

In questa nuova versione di LogicLab il termine STEP è diventato un termine riservato quindi non è più possibile utilizarlo per definire variabili nel progetto. Quindi non avendo scelto di distinguere tra minuscole e maiuscole la variabile Step diventa STEP e quindi LogicLab ne impedisce l’utilizzo.

La soluzione consigliata è di abilitare la distinzione sul case delle lettere (Flag Case-sensivity attivo), questo potrebbe generarti problemi nel tuo programma se hai utilizzato lo stesso nome scritto in minuscolo e maiuscolo per la stessa variabile (Esempio Marcia e MARCIA). Oppure hai utilizzato in linguaggio ST la definizione degli operatori (IF, THEN, CASE, FOR, ecc) in minuscolo anzichè in maiuscolo.

Quindi se è troppo complesso attivare il Case-sensivity sul tuo progetto puoi eseguire il download della nuova versione beta del package PCK055a05_ in cui è stato corretto il problema e sostituirlo alla raccolta librerie definita nel tuo progetto (Vedi articolo).

[Sergio Bertana]

Le schede di estensione I/O sia logiche che analogiche si conettono al modulo CPU tramite bus di estensione e non vi è nessuna relazione con il processore utilizzato nel modulo CPU.

Non farti ingannare dal prefisso PCB che vedi nell’elenco, i moduli elencati sono moduli CPU forniti in versione OEM, cioè forniti senza contenitore. I moduli OEM sono il circuito stampato con i componenti che trovi all’interno del contenitore del modulo CPU. Per contraddistinguerli vengono da noi identificati con il prefisso PCB.

Il PCB137 è l’OEM del modulo CPU MPS054.

Il PCB141 è l’OEM del modulo CPU MPS056.

[Sergio Bertana]

I moduli CPU SlimLine CortexM7, sono basati sul processore SAME70N21x della Microchip, questo processore viene fornito in due versioni diversificate dalla lettera finale del codice, A o B. Le due versioni seppure identiche come caratteristiche hanno differenze nella configurazione interna, questo ci ha costretto a realizzare due versioni di software specifiche. Le due versioni sono incompatibili tra di loro quindi occorre eseguire l’upgrade con la versione corretta.

La procedura di aggiornamento che noi consigliamo da connessione telnet con il comando di update come riportata in questo articolo, prima di aggiornare il sistema controlla se il firmware indicato è corretto per il processore presente nel sistema, quindi non vi è pericolo di commettere errori. Se invece si esegue l’aggiornamento da porta seriale o USB non vi sono controlli quindi occorre prestare attenzione al firmware da utilizzare.

Le informazioni sulle ultime versioni di firmware disponibili si trovano nelle note di rilascio.

Per il processore SAME70N21A, codice prodotto: MPS054A**0, MPS054B**0, MPS056A**0, PCB137B**0, PCB137C**0, PCB141B**0
Occorre utilizzare il PCK051C010 che contiene: Firmware: SFW198F010 Bootloader: SFW200A220 Webpages: MDP020E050

Per il processore SAME70N21B, codice prodotto: MPS054C**0, MPS056B**0, PCB137D**0, PCB141C**o
Occore utilizzare il PCK054B010 che contiene: Firmware: SFW210C010 Bootloader: SFW209A000 Webpages: MDP020E050

[Sergio Bertana]

All’interno dell’ambiene di sviluppo LogicLab esistono già apposite procedure di esportazione/importazione variabili. Come vedi dallo screenshot con il tasto destro del mouse su di un gruppo di variabili è possibile esportarle sia in un file di libreria che in un file XML compatibile con PLCopen.

Analogamente con il tasto destro del muose sulla cartella programmi è possibile importare oggetti dal file di libreria o PLCopen precedentemente esportato.

Sia il file di libreria che il file PLCopen sono editabili con qualunque editor di testo e quindi possono essere facilmente modificabili per l’eventuale modifica del nome delle TAGs.

La soluzione più semplice ed è quella che preferisco per importare TAGs dai progetti e/o per duplicarle all’interno del progetto modificandone il nome, è attivare la visualizzazione a lista delle variabili e modificarle con l’editor di LogiLab e/o con editor esterni.

[Sergio Bertana]

Nella configurazione del campionamento dati devi scegliere Customized file handling, nei settings potrai definire il comando di trigger per la scrittura del file e le LW in cui definire il nome del file (Screenshot).

[Sergio Bertana]

Inizio con il ricordare che il modulo mixed I/O come da specifiche non è progettato per acquisire valori analogici negativi. Ma il modulo non legge le sue specifiche e quindi anche se utilizzato fuori da esse continua a funzionare. Ma non è un caso il suo funzionamento, vediamo di spiegarlo… Il modulo è basato sul microcontrollore ADUC845 della Analog Devices, che come da specifiche per gli ingressi analogici indica:

Analog Input Voltage to AGND –0.3 V to AVDD + 0.3 V

Quindi i suoi ingressi analogici accettano tensioni comprese tra -0.3V e +0.3V oltre la tensione di alimentazione. Gli ingressi analogici del modulo mixed I/O quando configurati per acquisizione 10V inseriscono un partitore di tensione tra il morsetto di ingresso e l’ingresso reale del microcontrollore. Grazie a questo partitore la tensione all’ingresso analogico del microntrollore è pari alla tensione al morsetto di ingresso VIn/8.021.

Visto il range di tensione negativa accettato dall’ingresso analogico del microntrollore (-0.3V) si deduce che la massima tensione negativa misurabile è: -0.3*8.021=-2.406V. Probabilmente il valore di -0.3 è un valore medio e quindi potrebbe essere diverso tra microcontrollori di diverse forniture e quindi ecco perchè puoi acquisire un po di più in negativo di questo valore.

Ora anche se non dovresti acquisire valori negativi, ma visto che lo hai sempre fatto, per aumentare il range di acquisizione non ti resta che aumentare il partitore in ingresso, puoi farlo semplicemente inserendo in serie al pin di ingresso una resistenza che ti porti ad avere al massimo -2.4V al valore massimo che devi acquisire. Inserendo una resistenza da 33KOhm dovresti poter acquisire circa -5V ma avendo falsato il partitore in ingresso il valore letto sarà diverso, quindi dovrai tenerne conto, puoi utilizzare la funzione ValueScale.

Nota: La scheda viene da noi tarata sul sistema ATE per il range positivo, nel range negativo di acquisizione potrebbe perdere di linearità, ti consiglio di fare una verifica ed eventualmente correggerla con la funzione Linearize.

 

[Sergio Bertana]

Quindi utilizzi il FB PWMOut per modulare variando il duty-cycle l’uscita di comando della resistenza. Ti ricordo che devi eseguire il programma nella task Fast che eseguita di default ogni 1mS ti permette di suddividere il periodo della frequenza di uscita (100mS) in 100 parti, ottenendo una risoluzione più che accettabile.

Veniamo ora alla domanda sul Mask, siccome le uscite sono gestite in immagine di processo nella task Slow, per permettere a task diverse dalla Slow di gestire le uscite in modo sincronizzato occorre abilitarne la gestione. Il parametro Mask del FB SysSetPhrDO serve proprio a questo, ogni modulo di uscita può gestire massimo 32 uscite, quindi settando il relativo bit nella DWORD di Mask ne viene abilitata la gestione da parte del FB. Ora se tu vuoi utilizzare l’uscita 1 del modulo di espansione con indirizzo 1 hai sbagliato il Mask, devi definire:

    DOut.Address:=1; //Module address
    DOut.Mask:=16#00000002; //Output mask

Hai sbagliato anche i valori in AND ed OR sulla gestione di DOut.Value, devono essere 16#FFFFFFFD e 16#00000002. Altro consiglio per gestire DOut.Value, puoi utilizzare semplicemetne l’operando bit in questo modo:

    DOut.Value.1:=Pwm.Out;

[Sergio Bertana]

Il gateway ADA-401WP CEL-MAR permette di utilizzare i sensori 1-Wire in ambienti industriale rendendoli accessibili tramite protocollo Modbus RTU in RS485. Grazie al protocollo Modbus è così possibile acquisire i sensori da programmi PC (SCADA), terminali operatore, sistemi PLC in questo articolo trovi informazioni sulla configurazione del prodotto.

Quindi se il PLC che utilizzi può gestire la connessioneModbus RTU non ci sono problemi nell’utilizzo.

Ricordo che nei ns sistemi SlimLine questo modulo CPU dispone nativamente della interfaccia 1-Wire e che in alternativa questo convertitore permette di collegare sensori 1-Wire ad una porta RS232 dei ns moduli CPU. Per l’ambiente di sviluppo LogicLab esiste il FB OWRdTemperature per l’acquisizione di temperatura ed il FB OWSearch esegue la ricerca degli ID dei dispositivi connessi alla rete1-Wire.

Una precisazione l’utilizzo del convertitore 1-Wire/RS232 da un qualsiasi PLC o PC non è trasparente, occorre gestire una serie di comandi complessi che nei nostri sistemi sono gestiti dal FB OWireCore.

[Sergio Bertana]

Dalle informazioni riportate sullo schema non si capisce se il tuo sensore è un sensore che si autoalimenta dall’uscita del segnale 4-20mA oppure se è un sensore alimentato e quindi in grado di generare autonomamente l’uscita 4-20mA. Sul modulo CPU si utilizza un ingresso 0-10V per acquisire la corrente, la resistenza di carico da 500Ohm serve a convertire i 4-20mA in 2-10V.

• Se il sensore si autoalimenta dall’uscita 4-20mA lo schema è corretto, devi sicuramente alimentarlo con una tensione di 24Vdc, perchè a 20mA di uscita come abbiamo visto cadono 10V sulla resistenza di carico quindi ne rimangono ancora 14 per l’alimentazione del sensore.
• Se il sensore và alimentato (E visti i segnali Tx, Rx, GND che mi fanno pensare ad una uscita seriale RS232) credo che si tratti di un sensore che richiede una sua alimentazione, in tal caso lo schema è errato. Il sensore è in grado di generare autonomamente i 4-20mA di uscita, quindi ti basta collgare l’uscita (18-) all’ingresso AGnd, e l’uscita (17+) all’ingresso Ai00, mantenendo tra i due morsetti la resistenza di carico di 500Ohm.

Se il sensore ha una uscita seriale perchè non utilizzarla per il collegamento, dalla connessione seriale sicuramente potrai ottenere più dati è maggiore precisione di una connessione analogica.

[Sergio Bertana]

Non dici che errore ti viene segnalato…

Se hai problemi nella compilazione di un progetto, puoi inviare alla nostra eMail di supporto il progetto oppure contattami telefonicamente così vediamo insieme qual’è il problema.

[Sergio Bertana]

Nella nuova versione FileMemoryDump_v1 è stato aggiunto parametro Mode per selezionare il modo in cui i dati sono presenti nel file. Ora definendo il modo FILEMDUMP_MODE#ASCII viene utilizzata una formattazione ascii che è più leggibile rispetto alla formattazione binaria.

E’ stato aggiunto anche il parametro FPOfs, che permette di utilizzare un offset sull’accesso in lettura/scrittura sul file definito, questo permette di accodare ad un file esistente altra memoria.

E’ stato modificato il nome ai parametri MBufferPtr che diventa MBAdd e MBufferSize che diventa MBSize.

Ecco un programma che utilizza la vecchia versione.

VAR
    DBuf : ARRAY[0..15] OF BYTE; (* Data buffer *)
    MDump : FileMemoryDump; (* FBinstance *)
END_VAR

    // -------------------------------------------------------------------------
    // MEMORY DUMP
    // -------------------------------------------------------------------------
    // On set by debug the Read or Write command the memory is read or write on
    // file. The command resets when operation is finished.

    MDump.MBufferPtr:=ADR(DBuf); //Dump memory address
    MDump.MBufferSize:=SIZEOF(DBuf); //Dump memory size
    MDump.Filename:=ADR('C:/MRetain.txt'); //Dump memory file
    MDump(); //Execute the FB
    IF (MDump.Done) THEN MDump.Read:=FALSE; MDump.Write:=FALSE; END_IF;

Ecco come si può modificarlo utilizzando la nuova versione.

VAR
    DBuf : ARRAY[0..15] OF BYTE; (* Data buffer *)
    MDump : FileMemoryDump_v1; (* FBinstance *)
END_VAR

    // -------------------------------------------------------------------------
    // MEMORY DUMP
    // -------------------------------------------------------------------------
    // On set by debug the Read or Write command the memory is read or write on
    // file. The command resets when operation is finished.

    MDump.MBAdd:=ADR(DBuf); //Dump memory address
    MDump.MBSize:=SIZEOF(DBuf); //Dump memory size
    MDump.Mode:=FILEMDUMP_MODE#BINARY; //Dump mode
    MDump.Filename:=ADR('C:/MRetain.txt'); //Dump memory file
    MDump.FPOfs:=0; //File offset
    MDump(); //Execute the FB
    IF (MDump.Done) THEN MDump.Read:=FALSE; MDump.Write:=FALSE; END_IF;

[Sergio Bertana]

No da tastiera esterna non esistono comandi per passare  da un campo all’altro.

Eventualmente in fase di programmazione da EasyBuilderPro puoi attivare l’intoduzione ordinata in modo che quando si inserisce i dati in un campo alla pressione del tasto invio ci si posiziona direttamente al campo successivo sino alla fine della sequenza o fino alla pressione deal tasto <ESC>.

[Sergio Bertana]

La soluzione è facilmente realizzabile con un MPS056, potrai realizzare una semplice pagina web che tramite il suo server integrato permetterà di visualizzare e gestire da browser gli I/O, in questo articolo esempi di realizzazione di pagine web dinamiche.

Per avere una idea del risultato puoi eseguire il download dei programmi DataExchange o DoorKeeper, dal quale potrai utilizzare le pagine modificandole per il tuo scopo. Come vedi dallo screenshot le pagine del programma DoorKeeper sono molto più curate la differenza stà nelle capacità grafiche di chi realizza le pagine.

Per quanto riguarda l’accesso da applicazione in Node-RED si può utilizzare una connessione Modbus TCP nativa nel sistema, oppure puoi realizzare un programma ad-hoc sul PLC che istanzia un server TCP ed un server comandi per gestire l’interfacciamento, questa soluzione è riportata in questo articolo.

Un’altra possibilità è di utilizzare il FB HTTPServer per creare delle API HTTP di interfaccia, in questo topic trovi ad esempio un programma che gestisce una API per allarmi da telecamere di sorveglianza.

Ricordo che per aiutare i clienti nello sviluppo delle applicazioni e/o per istruzione sulla programmazione dei sistemi forniamo un servizio di supporto tecnico on-line.

[Sergio Bertana]

Si certo il FB HTTPServer è stato pensato proprio per poter gestire richieste HTTP sia in GET che in POST, ecco il programma HTTPCamera, un esempio pronto all’uso.

PROGRAM HTTPCamera
VAR
    CameraNr : UDINT; (* Numero telecamera *)
    APtr : @STRING; (* Auxiliary pointer *)
    TxData : STRING[ 128 ]; (* Tx data *)
    TxHeader : STRING[ 128 ]; (* Tx header buffer *)
    HTTPSv : HTTPServer_v2; (* HTTP server *)
END_VAR

// *****************************************************************************
// PROGRAM "HTTPCamera"
// *****************************************************************************
// Gestione uscite allarme su richiesta GET da telecamera, la richiesta è:
// "http://xxx.xxx.xxx.xxx:2000/api/v1/nc/inputs/81/alarm"
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // INIZIALIZZAZIONI
    // -------------------------------------------------------------------------
    // Eseguo inizializzazioni.

    IF (SysFirstLoop) THEN
        HTTPSv.Enable:=TRUE; //Server enable
        HTTPSv.SpyOn:=TRUE; //Spy active
        HTTPSv.Port:=2000; //TCP Port
        HTTPSv.AConnections:=2; //Accepted connections
        HTTPSv.HTTPBSize:=1024; //HTTP buffer size
        HTTPSv.HPath:=ADR('C:/'); //Home path (Cortex M7)
        HTTPSv.PDefault:=ADR('Home.html'); //Default page
        HTTPSv.Timeout:=2.0; //Execution timeout (S)
        HTTPSv.Header:=eNULL;
        HTTPSv.CORSHeader:=eNULL;
        HTTPSv.pTxData:=ADR(TxData); //Pointer to Tx data
    END_IF;

    // -------------------------------------------------------------------------
    // HTTP SERVER
    // -------------------------------------------------------------------------
    // Gestione server ed attesa ricezione richiesta GET.

    HTTPSv(); //HTTP server
    HTTPSv.RAck:=FALSE; //Request acknowledge
    HTTPSv.RNAck:=FALSE; //Request not acknowledge
    IF NOT(HTTPSv.RRcvd) THEN RETURN; END_IF;
    HTTPSv.StatusCode:=eNULL; //Status code
    HTTPSv.TxDSize:=0; //Data to send size

    // -------------------------------------------------------------------------
    // ARRIVO SU RICHIESTA PAGINA
    // -------------------------------------------------------------------------
    // Spionaggio pagina richiesta per debug.
    // Spionaggio dati ricevuti con richiesta, (Non dovrebbero essercene).

    eTO_JUNK(SysWrSpyData(SPY_ASCII, 0, 16#00000001, ADR('Requested page'), HTTPSv.pPage));
    eTO_JUNK(SysWrSpyData(SPY_ASCII, 0, 16#00000001, ADR('Received data'), HTTPSv.pRxData));

    // Cerco percorso pagina fino al numero telecamera per verificare se pagina
    // corretta. In caso contrario ritorno HTTP status=404.

    APtr:=SysStrFind(HTTPSv.pPage, ADR('api/v1/nc/inputs/'), FIND_GET_END);
    IF (APtr = eNULL) THEN 
        HTTPSv.StatusCode:=ADR('HTTP/1.1 404 Not Found$r$n');
        HTTPSv.RNAck:=TRUE; //Request not acknowledge
        RETURN;
    END_IF;

    // Rilevo il numero di telecamera se errato ritorno HTTP status=400.

    IF NOT(SysVsscanf(APtr, ADR('%d'), UDINT_TYPE, ADR(CameraNr))) THEN
        HTTPSv.StatusCode:=ADR('HTTP/1.1 400 Bad request$r$n');
        HTTPSv.TxDSize:=TO_UDINT(SysVsnprintf(HTTPSv.pTxData, HTTPSv.HTTPBSize, ADR('%s'), STRING_TYPE, ADR('Wrong camera number')));
        HTTPSv.RAck:=TRUE; //Request acknowledge
        RETURN;
    END_IF;

    // Se non presente testo "alarm" ritorno HTTP status=400.

    APtr:=SysStrFind(APtr, ADR('/alarm'), FIND_GET_END);
    IF (APtr = eNULL) THEN 
        HTTPSv.StatusCode:=ADR('HTTP/1.1 400 Bad request$r$n');
        HTTPSv.TxDSize:=TO_UDINT(SysVsnprintf(HTTPSv.pTxData, HTTPSv.HTTPBSize, ADR('Alarm not found in camera %d message'), UDINT_TYPE, ADR(CameraNr)));
        HTTPSv.RAck:=TRUE; //Request acknowledge
        RETURN;
    END_IF;

    // Messaggio corretto, posso attivare l'uscita relativa al numero di camera.
    // La gestione delle uscite và realizzata in un programma ladder separato.

    HTTPSv.TxDSize:=TO_UDINT(SysVsnprintf(HTTPSv.pTxData, HTTPSv.HTTPBSize, ADR('Camera %d on alarm'), UDINT_TYPE, ADR(CameraNr)));
    HTTPSv.RAck:=TRUE; //Request acknowledge

// [End of file]

[Autore]

Post