Vai al contenuto

Sergio Bertana

Risposte nei forum create

Stai visualizzando 15 post - dal 136 a 150 (di 4,303 totali)
  • Autore
    Post
  • Sergio Bertana
    Amministratore del forum

    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;
    in risposta a: Utilizzo tastiera esterna USB #80518
    Sergio Bertana
    Amministratore del forum

    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>.

    in risposta a: Gestione I/O logici da pagina web e connessione con Node-RED #80506
    Sergio Bertana
    Amministratore del forum

    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.

    in risposta a: Decodifica allarmi da richiesta HTTP #80494
    Sergio Bertana
    Amministratore del forum

    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]
    in risposta a: Disabilitazione messaggio Pop-Up su inserimento chiave USB #80489
    Sergio Bertana
    Amministratore del forum

    Si il pop-up di dispositivo connesso non è disattivabile, quindi devi accettare che compaia per un attimo.

    in risposta a: Acquisizione lettore Wiegand #80485
    Sergio Bertana
    Amministratore del forum

    Tra i moduli di estensione quelli che prevedono una gestione counter al momento sono:

    • PCB124B010 SlimLine Modulo esp. I/O uscite statiche 16In 8Out + Gestione Counter/Encoder avanzata (4 counters)
    • PCB124B000 SlimLine Modulo esp. I/O uscite statiche 16In 8Out (2 counters)

    Tutti e due i moduli dispongono di 4 ingressi (Di12~Di15) high speed, e con possibilità di settare l’ingresso a 5Vdc. Questo è importante perchè i segnali Wiegand sono a 5Vdc e quindi possono essere acquisiti solo da questi ingressi digitali o dagli ingressi digitali del modulo CPU.

    in risposta a: Acquisizione lettore Wiegand #80470
    Sergio Bertana
    Amministratore del forum

    L’esempio a cui fai riferimento utilizza il FB WiegandDcd che permette di decodificare un codice Wiegand a 26 bits,. Fornendo al FB il numero di bits che compongono il codice ed il codice Wiegand da decodificare il FB darà in uscita il Facillity e IDNumber del codice decodificato.

    Nell’esempio a cui fai riferimento un program eseguito in una task Fast, con tempo di esecuzione settato a 1mS viene acquisito il dato Wiegand da un lettore connesso a due ingressi digitali di un modulo CPU. Come vedi dalle specifiche del protocollo l’ampiezza dell’impulso del segnale Wiegand è compresa tra 20 uS e 100 uS e l’intervallo tra impulsi è compreso tra 200 uS e 20 mS.

    Quindi nell’esempio per poter acquisire ingressi cosi veloci sono stati utilizzati due counters, alla transizione dei due segnali Wiegand si ha un incremento del relativo counter. Ora essendo l’intervallo tra gli impulsi compreso tra 200 uS e 20 mS è importante che il programma esegua il controllo sulla variazione degli ingressi in questo tempo.

    Quindi il tempo di esecuzione del programma và impostato rilevando qual’è il tempo di intervallo degli impulsi del tuo lettore, nel caso del lettore utilizzato nel programma ST_WiegandDcd era necessario controllare gli impulsi ogni 1mS.

    Venendo alla tua domanda se possibile utilizzare gli I/O delle estensioni, precisando che comunque devi utilizzare ingressi counter, devi tenere presente il tempo di acquisizione di un counter da modulo di estensione. Se acquisire un counter sul modulo CPU richiede qualche uS, l’acquisizione da modulo di estensione richiede 300uS dovendo acquisirne 2 sono necessari 600uS. Ora se il programma viene eseguito ogni 1mS utilizziamo più della metà del tempo solo per acquisire i moduli di estensione e questo essendo la task Fast la più prioritaria rallenta l’esecuzione sia della Slow che della Back.

    Quindi la risposta è se il tuo lettore Wiegand ha un intervallo tra impulsi di qualche mS puoi tranquillamente rallentare l’escuzione della task Fast e gestire gli I/O anche da modulo di estensione.

    in risposta a: Importa oggetti su ultima versione LogicLab #80411
    Sergio Bertana
    Amministratore del forum

    La gestione degli oggetti nella nuova versione è uguale alle versioni precedenti. Nella compilazione gli oggetti (FB, funzioni, definizioni, ecc) utilizzati nei programmi seguono questo ordine di ricerca:

    1. Oggetti presenti nel tree di progetto.
    2. Oggetti presenti nelle librerie importate nel progetto.
    3. Oggetti presenti nella raccolta (Package) librerie.

    Quindi se si hanno oggetti “personali” singoli o contenuti in una o più librerie personali è sempre possibile importarli nel progetto. La voce di menù Project->Import Object si abilita/disabilita in base al focus del progetto. Se punti con il mouse il nome del progetto o una cartella nel tree vedrai che l avoce si abilita, ma puoi anche con il tasto destro del mouse eseguire l’import. Nello screenshot si può vedere un esempio di utilizzo di oggetti:

    • Il FB FBStartStop fà parte del progetto.
    • Nel progetto ho incluso una mia libreria MyLib.
    • Nel progetto ho collegato il package di librerie Pck055a040.

    Come si vede dalle warning nel package vi sono oggetti che sono già presenti nel progetto, in questo caso si trovano nella libreria MyLib, quindi nel momento in cui collego il package di librerie questi oggetti vengono ignorati. Nella compilazione saranno utilizzati quelli presenti in MyLib.

    Per poter definire nel progetto o includere librerie che hanno oggetti con lo stesso nome di oggetti presenti nel package occorre eliminare la definizione di package, definire l’oggetto e/o includere la libreria e solo al termine definire il package.

    in risposta a: Disabilitazione messaggio Pop-Up su inserimento chiave USB #80407
    Sergio Bertana
    Amministratore del forum

    E’ possibile deisabilitare la comparsa del Pop-Up tramite i settings sul pannello stesso o tramite bit di sistema LB9063.

    LB-9063 disable(set ON)/enable(set OFF) popping information dialog while finding an USB disk

    in risposta a: Gestione stringhe ascii #80383
    Sergio Bertana
    Amministratore del forum

    Sinceramente non hoi mai trovato questo tipo di problema…

    L’oggetto impostazione/visualizzazione Ascii come hai detto giustamente tu opera su WORD quindi ogni WORD contiene due caratteri Ascii. Se sul tuo PLC la variabile stringa ad esempio è di 16 caratteri tu dovrai definire nell’oggetto la lunghezza di 8 WORDs.

    E nella visualizzazione e/o impostazione non ci saranno spazi, ma il testo verrà visualizzato esattamente come scritto nel PLC (Questo salvo che il PLC non tratti le stringhe in modo particolare), Quello che ho scritto vale sicuramente per i ns sistemi SlimLine ma anche per moltissimi altri PLC con cui i nostri clienti si sono connessi.

    Attenzione al codice tappo, le stringhe Ascii sul PLC possono essere terminate con il codice tappo (16#00) quindi solitamente se definisci una variabile STRING[16] in realtà nella memoria vengono allocati 17 bytes (Uno per il tappo) quindi devo definire lunghezza 9 WORDs. Nessun problema in visualizzazione, quando viene acquisito il valore il codice tappo termina la stringa. Ma in inputazione vegono inviati al PLC 18 bytes e quindi vado a sporcare anche i primo bytes della variabile allocata dopo la variabile STRING, in tal caso occorre lasciare un byte libero o allocare stringhe di lunghezza dispari in  modo che il byte aggiuntivo di tappo le renda di lunghezza pari.

    in risposta a: Come allegare immagini atopic/risposte sul forum #80378
    Sergio Bertana
    Amministratore del forum

    Puoi caricare l’immagine da inviare su un sito di condivisione immagini come ImgBB, PostImage, oppure imgur. Caricata l’immagine ti verrà dato un link che potrai inserire nel tuo messaggio.

    in risposta a: Gestione lampada multistato con codici predefiniti #80373
    Sergio Bertana
    Amministratore del forum

    La soluzione più semplice è utilizzare l’oggetto Multi-State Switch, questo oggetto permette la definizione di una mappa di stati in cui puoi definire a che stato corrisponde il valore della variabile collegata (Screenshot). Nel tuo caso avremo:

    • Valore 2: Stato 0, in cui definirai l’etichetta “Guasto”
    • Valore 4: Stato 1, in cui definirai l’etichetta “Disinserito”
    • Valore 257: Stato 2, in cui definirai l’etichetta “In Allarme”

    Siccome si tratta di unop switch multistato, alla pressione dell’oggetto sullo schermo corrisponde una azione, nell’esempio sarà un JOG-, quindi ad ogni pressione verrà scritto nella variabile indirizzata il valore corrispondente allo stato precedente. Se la variabile vale 257 alla pressione scriverò 4 ed alla prossima pressione scriverò 2.

    Siccome mi sembra di capire nel tuo caso devi solo visualizzare gli stati e non impostarli, come workaround puoi definire lettura/scrittura ad indirizzi diversi, ed eseguire la lettura dal sistema di allarme mentre la scrittura la puoi indirizzare in una LW del pannello che non utilizzi.

    in risposta a: Installazione VPN su router Milesight e costo abbonamento #80350
    Sergio Bertana
    Amministratore del forum

    Milesight ha pubblicato questo articolo in cui riporta indicazioni su come configurare un client OpenVPN nei proprii routers.

    Il servizio si basa sul server di CloudConnexa che permette fino a 3 connessioni contemporanee gratuite. Puoi direttamente verificare sul sito quali sono le condizioni economiche per aggiungere ulteriori connessioni.

    in risposta a: Gestire invio di SMS su router UR32 #80345
    Sergio Bertana
    Amministratore del forum

    Il router Milesight UR32 permette di realizzare applicazioni in python per le esigenze più disparate, rimando a questo articolo per ulteriori informazioni. Per permettere lo sviluppo di applicazioni Python è necessario installare la scheda micro SDCard nel router.

    Riguardo alla tua applicazione specifica ho chiesto a Milesight se avevano un qualche esempio di invio SMS da Python mi hanno inviato un link a questa loro guida applicativa, spero possa essere di aiuto.

    in risposta a: Warning T8209: Impossibile scaricare il file sorgente #79990
    Sergio Bertana
    Amministratore del forum

    Il programma sorgente (File Project.rsm)  viene trasferito nel file system dello SlimLine sul disco C nella cartella C:\Plc. La warning stà ad indicare che sul disco non vi è lo spazio sufficente a memorizzare il file sorgente, quindi non viene trasferito.

    Il programma eseguibile è comunque sempre trasferito ed è per questo che il programma funziona correttamente, ma non essendoci il file sorgente ecco che non è possibile effettuarne l’upload dal PLC.

    Ho dato una occhiata al tuo progetto, e l’errore è nella definizione delle librerie, come vedi dallo screenshot, nel tuo progetto in errore hai incluso tutte le librerie ed inoltre hai definito il percorso di più raccolte di librerie. Nel progetto corretto devi solo includere l’ultima raccolta di librerie disponibile.

    Le librerie presenti nella finestra superiore Libraries, sono incluse nel progetto ed inviate al PLC con il codice sorgente del tuo progetto, e siccome sono molte generano un file sorgente molto grande che supera lo spazio disponibile nel disco.

    Le librerie presenti nella finestra inferiore Libraries directories invece sono utilizzate per la compilazione del programma e non vengono inviate al PLC rendendo il programma sorgente molto più compatto, velocizzando anche i tempi di download.

Stai visualizzando 15 post - dal 136 a 150 (di 4,303 totali)