Una applicazione REST in pratica

In questo articolo abbiamo visto come sia possibile in modo estremamente semplice implementare applicazioni cloud con i nostri sistemi SlimLine e Netsyst utilizzando l'architettura REST. Ora vediamo come sia altrettanto semplice realizzare un sito web che permette di storicizzare i dati in un database MySQL e di visualizzarli in forma tabellare o grafica. Abbiamo inserito nell'armadio del nostro datacenter un sistema Netsyst che ne monitorizza tramite un analizzatore di rete SDM120 i consumi. I dati acquisiti sono visualizzati sul display del prodotto ed inviati via REST ad un server nel cloud.

Il programma utilizzando i FB per la gestione dei contatore Eastron SDM120 esegue in un semplice programma FBD l'acquisizione dei dati di consumo, che, appoggiati a variabili globali sono visualizzati sul display ed inviati via REST al server cloud.

Lo script in linguaggio PHP sul server cloud riceve i dati in POST e li memorizza in un database, una pagina htm di consultazione permette di visualizzare i dati ricevuti su di una dashboard. Per la visualizzazione del grafico viene utilizzata la libreria open source Chart.js che permette di realizzare grafici in HTML5, ecco come si presenta la dashboard.

Programma di esempio

Come utilizzare gli esempi.
Viene fornito il progetto RESTLogger (Download intero progetto) con il programma dimostrativo che gestisce la dashboard visibile nell'esempio. Il progetto si compone di diversi programmi, di seguito riporto il listato dei più significativi che ne illustrano il funzionamento.

RESTLogger: Client eseguito su di un sistema SlimLine che acquisisce i dati da un misuratore di energia Eastron e li invia in REST al programma server.

RESTSvc: Script lato server eseguito su di un sistema LAMP che inserisce i dati ricevuti dal programma client nel database MySQL.

AjaxSvc: Script lato server eseguito sullo stesso sistema LAMP dove è eseguito RESTSvc, ritorna i dati dal database MySQL per visualizzare la dashboard con i dati aggiornati in tempo reale.

RESTLogger (Ptp145) RESTSvc.php (Ptp145) AjaxSvc.php (Ptp145)

RESTLogger (Ptp145)

PROGRAM RESTLogger
VAR
    DSCmd : BOOL; (* Debug send command *)
    i : UDINT; (* Auxiliary variable *)
    Fp : eFILEP; (* File pointer *)
    REST : RESTClient_v3; (* REST service client *)
    HTTP : HTTPClient_v2; (* HTTP client *)
    JDecode : JSONDecode_v2; (* JSON decode *)
    JEncode : JSONEncode_v1; (* JSON encode *)
    PageFile : STRING[ 32 ] := 'D:/Page.html'; (* Page file *)
    RESTRequest : STRING[ 128 ]; (* REST request *)
    FIFO : FIFOFile_v1; (* FIFO on file *)
    FIFOIDx : ARRAY[0..1] OF UDINT; (* FIFO indexes *)
    FIFOFile : STRING[ 32 ] := 'D:/REST.bin'; (* FIFO file *)
    UTCDateTime : UDINT; (* UTC Date/Time *)
END_VAR

// *****************************************************************************
// PROGRAM "RESTLogger"
// *****************************************************************************
// Eseguo gestione servizio REST sul web.
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // ESEGUO INIZIALIZZAZIONI
    // -------------------------------------------------------------------------
    // Eseguo inizializzazione variabili.

    IF (SysFirstLoop) THEN

        // Wear leveling, se i due indici sono uguali eseguo cancellazione
        // file così viene ricreato in una nuova posizione sul disco.

        IF (SysGetFileLen(ADR(FIFOFile)) <> -1) THEN
            IF (FIFOIDx[0] = FIFOIDx[1]) THEN i:=SysFileRemove(ADR(FIFOFile)); FIFOIDx[0]:=0; FIFOIDx[1]:=0; END_IF;
        END_IF;

        // Configurazione REST client.

        REST.SpyOn:=TRUE; //Spy On

        REST.FIFOFile:=ADR(FIFO); //FIFO on file
        REST.FIFOFilename:=ADR(FIFOFile); //Path and name of FIFO file
        REST.FIFOSize:=1000; //FIFO file size
        REST.FIFOIDx:=ADR(FIFOIDx); //FIFO indexes
        
        REST.HostAddress:=ADR('192.168.1.15'); //Host address server REST
        REST.HostName:=REST.HostAddress; //Host name server REST
        REST.Page:=ADR('/RESTLogger/RESTSvc.php'); //Pagina server REST
        REST.HostPort:=80; //Porta server REST
        
        REST.HTTPClient:=ADR(HTTP); //HTTP Client
        REST.HBitTime:=15; //Heartbeat time (S)
        REST.BLength:=512; //REST Request/Answer buffers length
    END_IF;

    // -------------------------------------------------------------------------
    // GESTIONE SERVIZIO REST
    // -------------------------------------------------------------------------
    // Eseguo gestione servizio REST.

    REST(Enable:=TRUE); //Eseguo gestione servizio REST

    // Se errore copio risposta su file per visualizzarla da browser.

    IF (REST.SvcError AND (REST.PBuffer <> NULL)) THEN
         i:=SysFileRemove(ADR(PageFile)); // Cancello file pagina
        Fp:=SysFfopen(ADR(PageFile), ADR('a')); // File pointer
        IF (Fp <> NULL) THEN
            i:=Sysfwrite(REST.PBuffer, TO_INT(Sysstrlen(REST.PBuffer)), 1, Fp);
            i:=Sysfclose(Fp); // Eseguo chiusura file
        END_IF;
    END_IF;

    // -------------------------------------------------------------------------
    // ACQUISIZIONE VALORE VARIABILI IN READ
    // -------------------------------------------------------------------------

//    IF (REST.SvcOk) THEN
//        JDecode(Object:=REST.PBuffer, Name:=ADR('RVariable'), VType:=UDINT_TYPE, VAddress:=ADR(RVariable), VSize:=SIZEOF(RVariable));
//    END_IF;

    // -------------------------------------------------------------------------
    // INVIO VALORI AL SERVER CLOUD
    // -------------------------------------------------------------------------
    // Eseguo temporizzazione invio.
    
    IF (SysGetUTCDateTime(TRUE) <> UTCDateTime) THEN
        UTCDateTime:=SysGetUTCDateTime(TRUE); //UTC Date/Time
        IF ((MOD(UTCDateTime, 60) = 0) OR (DSCmd)) THEN
            DSCmd:=FALSE; //Debug send command

            // Eseguo compilazione dati da inviare al server in JSON.

            i:=Sysmemset(ADR(RESTRequest), 0, SIZEOF(RESTRequest)); //REST request
            JEncode(Object:=ADR(RESTRequest), OSize:=SIZEOF(RESTRequest), Name:=ADR('Frequency'), VType:=REAL_TYPE, VAddress:=ADR(Frequency));
            JEncode(Object:=ADR(RESTRequest), OSize:=SIZEOF(RESTRequest), Name:=ADR('Voltage'), VType:=REAL_TYPE, VAddress:=ADR(Voltage));
            JEncode(Object:=ADR(RESTRequest), OSize:=SIZEOF(RESTRequest), Name:=ADR('AcPower'), VType:=REAL_TYPE, VAddress:=ADR(AcPower));
            JEncode(Object:=ADR(RESTRequest), OSize:=SIZEOF(RESTRequest), Name:=ADR('PwFactor'), VType:=REAL_TYPE, VAddress:=ADR(PwFactor));
            FIFO(In:=TRUE, Dp:=ADR(RESTRequest), Dls:=LEN(RESTRequest)); //Write record on FIFO
        END_IF;
    END_IF;

// [End of file]

RESTSvc.php (Ptp145)

<?php

// *****************************************************************************
// Project : PTP145A200
// Programmer : Sergio Bertana
// Date : 21/12/2020
// *****************************************************************************
// Script eseguito da sistema SlimLine da FB "RESTClient". Viene ricevuta
// una richiesta in HTTP POST il messaggio di richiesta puo' essere un heartbeat
// in questo caso non contiene dati ma ha solo l'header. Oppure un messaggio con
// dati a cui dopo l'header seguono i dati.
// -----------------------------------------------------------------------------
// Ecco alcuni esempi di messaggi REST ricevuti.

// {"MID":1234, "ST":0, "UID":10879070, "MV":"1.0", "FIFO":[{"Date":"09/06/2018 08:20:00", "Read":"WVariable"}]}
// {"MID":1234, "ST":0, "UID":10879070, "MV":"1.0", "FIFO":[{"Date":"09/06/2018 08:20:00","Write":"WVariable", "Value":100}]}

// Per il test da browser è possibile modificare la ricezione dei parametri.
// Ecco alcuni link possibili da browser.

// http://localhost/RESTLogger/RESTSvc.php?Post={"MID":1234, "ST":0, "UID":10879070, "MV":"1.0", "FIFO":[{"Date":"09/06/2018 08:20:00", "Value":{"Frequency":50.0}}]}

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// INCLUSIONE FILE
// -----------------------------------------------------------------------------
// Eseguo inclusione files.

$HomeDir=substr($_SERVER['SCRIPT_FILENAME'], 0, strrpos($_SERVER['SCRIPT_FILENAME'], "/")); //Rilevo Home directory
require_once $HomeDir."/ezSQL/ez_sql_core.php"; //Include ezSQL core
require_once $HomeDir."/ezSQL/ez_sql_pdo.php"; //Database PDO
require_once $HomeDir."/Include/Include.php"; //Inclusioni generali

// Da eseguire 1 sola volta per creare le tabelle nel database.

//require_once $HomeDir."/Include/CreateTables.php"; //Creazione tabelle database

// -----------------------------------------------------------------------------
// MODIFICA PER TESTARE RICHIESTA REST IN GET
// -----------------------------------------------------------------------------
// Per testare lo script da browser è possibile passare i parametri in GET.

if (isset($_REQUEST['Post']))
$RxMessage=$_REQUEST['Post']; //Messaggio REST ricevuto
else
$RxMessage=file_get_contents("php://input"); //Messaggio REST ricevuto

//echo $RxMessage;

// -----------------------------------------------------------------------------
// OPERAZIONI SCHEDULATE
// -----------------------------------------------------------------------------
// Lo script è eseguito ad ogni richiesta REST dei sistemi, utilizzo esecuzione
// per gestire operazioni schedulate.
// -----------------------------------------------------------------------------
// Elimino da tabella spionaggio dati più vecchi di 5 minuti.

$GLOBALS['Db']->query("DELETE FROM ".SPYDATA." WHERE DateTime < '".EpochToMySQLTime(GetTimeNow(false)-(5*60))."'");

// Elimino da tabella dati REST dati più vecchi di 7 giorni.

$GLOBALS['Db']->query("DELETE FROM ".RESTDATA." WHERE DateTime < '".EpochToMySQLTime(GetTimeNow(false)-(7*24*3600))."'");

// -----------------------------------------------------------------------------
// CONTROLLO RICHIESTA IN ARRIVO
// -----------------------------------------------------------------------------
// Acquisisco richiesta JSON ricevuta in POST.

$RESTRx=json_decode($RxMessage, true); //Converto in associative array
$RESTTx=array(); //Inizializzo array risposta REST

// La richiesta deve contenere i campi, MID, ST, UID, MV. Se errore esco.

if ($RESTRx == null ) exit("Wrong REST parameters, Received:[{$RxMessage}]");
if (!isset($RESTRx['MID'])) exit("MID not in message, Received:[{$RxMessage}]");
if (!isset($RESTRx['ST'])) exit("ST not in message, Received:[{$RxMessage}]");
if (!isset($RESTRx['UID'])) exit("UID not in message, Received:[{$RxMessage}]");
if (!isset($RESTRx['MV'])) exit("MV not in message, Received:[{$RxMessage}]");

// Controllo se campi numerici sono corretti.

if (!is_numeric($RESTRx['MID'])) exit("Wrong system MID, Received:[{$RxMessage}]");
if (!is_numeric($RESTRx['UID'])) exit("Wrong system UID, Received:[{$RxMessage}]");

// Per ogni sistema (Riconoscibile dal suo "UID") esiste un record nel database.
// Se sistema non presente in tabella lo aggiungo.

$GLOBALS['St']['SIDx']=$GLOBALS['Db']->get_row("SELECT * FROM ".SISTEMIDX." WHERE UID = {$RESTRx['UID']}");
if ($GLOBALS['St']['SIDx'] == NULL)
{
    $GLOBALS['Db']->query("INSERT INTO ".SISTEMIDX." (UID) VALUES ({$RESTRx['UID']})");
    $GLOBALS['St']['SIDx']=$GLOBALS['Db']->get_row("SELECT * FROM ".SISTEMIDX." WHERE UID = {$RESTRx['UID']}");
}

// Calcolo tempo di poll.

SpyData($RxMessage); //Eseguo spionaggio messaggio ricevuto
$GLOBALS['St']['SIDx']->RxMessage=$RxMessage; //Messaggio REST ricevuto
$GLOBALS['St']['SIDx']->DateTime=EpochToMySQLTime(GetTimeNow(false)); //Data/Ora aggiornamento
$GLOBALS['St']['SIDx']->PollTime=sprintf("%6.3f", GetuTime()-$GLOBALS['St']['SIDx']->Heartbeat); //Tempo poll sistema
$GLOBALS['St']['SIDx']->Heartbeat=GetuTime(); //Data/Ora ultimo heartbeat (UTC)

// -------------------------------------------------------------------------
// CONTROLLO ID MESSAGGIO
// -------------------------------------------------------------------------
// Controllo se ricevuto l'acknowledge dallo SlimLine del messaggio REST
// inviato precedentemente dal server. Controllo se il MID ricevuto e'
// corretto (Successivo al MID del messaggio precedente).

if ((($RESTRx['MID']-$GLOBALS['St']['SIDx']->MID)&0xFFFF) == 1)
{
    // Ricevuto MID successivo messaggio corretto (Nessun messaggio andato
    // perso) utilizzo MID ricevuto.

    $GLOBALS['St']['SIDx']->MID=$RESTRx['MID']; //Message ID
}
else
{
    // Errore ricezione messaggi, occorre eseguire una resincronizzazione
    // sistema, viene inviato un numero random che sara' utilizzato dal
    // sistema come prossimo MID. Non utilizzo i dati ricevuti perche' potrebbe
    // trattarsi di un messaggio inviato da hacker.

    $GLOBALS['St']['SIDx']->MID=rand(0, 65535); //Message ID
    $GLOBALS['St']['SIDx']->Resyncs++; //REST resyncronizations
}

// -----------------------------------------------------------------------------
// ACQUISIZIONE DATI MESSAGGIO
// -----------------------------------------------------------------------------
// Controllo se messaggio contiene i dati FIFO o se heartbeat.

if (!isset($RESTRx['FIFO'])) goto SENDDATA; //E' un heartbeat

// Messaggio con dati.

$GLOBALS['St']['SIDx']->DateTime=EpochToMySQLTime(FIFOToEpochTime($RESTRx['FIFO'][0]['Date'])); //DateTime dati ricevuti

// -----------------------------------------------------------------------------
// GESTIONE VARIABILI RICEVUTE
// -----------------------------------------------------------------------------
// Nel campo "RxMessage" il sistema SlimLine invia le variabili in una stringa
// codificata JSON. Eseguo conteggio variabili ricevute, viene einviato al
// client conb la risposta.

foreach ($RESTRx['FIFO'][0]['Value'] as $Key => $Value)
{
    RESTData($GLOBALS['St']['SIDx']->DateTime, $Key, $Value);
}

// -------------------------------------------------------------------------
// INVIO DATI AL SISTEMA
// -------------------------------------------------------------------------
// Salvo dati in database.

SENDDATA:
$RESTTx=array_merge(array("MID" => $GLOBALS['St']['SIDx']->MID), $RESTTx);
$GLOBALS['St']['SIDx']->TxMessage=json_encode($RESTTx);

$GLOBALS['Db']->query("UPDATE ".SISTEMIDX." SET
    UID={$GLOBALS['St']['SIDx']->UID},
    MID={$GLOBALS['St']['SIDx']->MID},
    DateTime='{$GLOBALS['St']['SIDx']->DateTime}',
    Heartbeat={$GLOBALS['St']['SIDx']->Heartbeat},
    PollTime={$GLOBALS['St']['SIDx']->PollTime},
    Resyncs={$GLOBALS['St']['SIDx']->Resyncs},
    RxMessage='{$GLOBALS['St']['SIDx']->RxMessage}',
    TxMessage='{$GLOBALS['St']['SIDx']->TxMessage}'
WHERE ID = {$GLOBALS['St']['SIDx']->ID}");

// Compilo messaggio di risposta che inizia con il MID. Il valore ritornato
// e' calcolato sommando il valore di UID. In questo modo si garantisce che
// il sistema che riceve il messaggio possa verificalo utilizzando il suo
// unique ID.

exit($GLOBALS['St']['SIDx']->TxMessage);

?>

AjaxSvc.php (Ptp145)

<?php

// *****************************************************************************
// Project : PTP145A200
// Programmer : Sergio Bertana
// Date : 21/12/2020
// *****************************************************************************
// Script eseguito da pagina web "Home" su richiesta ajax.
//
// Letteratura.
// http://www.html.it/articoli/chart-js-creare-grafici-interattivi/
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// INCLUSIONE FILE
// -----------------------------------------------------------------------------
// Eseguo inclusione files.

$HomeDir=substr($_SERVER['SCRIPT_FILENAME'], 0, strrpos($_SERVER['SCRIPT_FILENAME'], "/")); //Rilevo Home directory
require_once $HomeDir."/ezSQL/ez_sql_core.php"; //Include ezSQL core
require_once $HomeDir."/ezSQL/ez_sql_pdo.php"; //Database PDO
require_once $HomeDir."/Include/Include.php"; //Inclusioni generali

// -----------------------------------------------------------------------------
// CONTROLLO RICHIESTA IN ARRIVO
// -----------------------------------------------------------------------------
// La richiesta deve contenere i campi, UID, DOut. Se errore esco.

if (!isset($_REQUEST['Selector'])) exit("Wrong REST parameters");
$GLOBALS['St']['SID']=1; //System ID

// -----------------------------------------------------------------------------
// CREO ARRAY PER RITORNO VALORI
// -----------------------------------------------------------------------------
// Creo array per ritorno valori.

$Return=array
(
// Valori per console spionaggio.

"SpyConsole" => "", //Console spionaggio

// Valori istanteaei da visualizzare.

"Voltage" => 0, //Tensione linea
"Frequency" => 0, //Frequenza linea
"AcPower" => 0, //Potenza istantanea
"PwFactor" => 0, //Fattore di potenza

// Valori per gestione grafico

"Label" => $_REQUEST['Selector'], //Nome variabile
"Border" => "", //Colore linea
"Area" => "", //Colore area
"XAxis" => array(), //Riferimenti asse "X"
"YAxis" => array(), //Valori asse "Y"
);

// Impostazione colori grafico.

switch($_REQUEST['Selector'])
{
case "Voltage": $Return["Border"]="rgba(139, 195, 74, 1)"; $Return["Area"]="rgba(139, 195, 74, 0.2)"; break;
case "Frequency": $Return["Border"]="rgba(195, 66, 63, 1)"; $Return["Area"]="rgba(195, 66, 63, 0.2)"; break;
case "AcPower": $Return["Border"]="rgba(54, 162, 235, 1)"; $Return["Area"]="rgba(54, 162, 235, 0.2)"; break;
case "PwFactor": $Return["Border"]="rgba(139, 195, 74, 1)"; $Return["Area"]="rgba(139, 195, 74, 0.2)"; break;
}

// -----------------------------------------------------------------------------
// ESEGUO LETTURA DATI PER SPIONAGGIO
// -----------------------------------------------------------------------------
// Ritorno records di spionaggio.

$DbRes=$GLOBALS['Db']->get_results("SELECT * FROM ".SPYDATA." ORDER BY ID DESC LIMIT 20");
if ($DbRes == NULL) $Return["SpyConsole"]="No records";
foreach ($DbRes as $Result) {$Return["SpyConsole"].="[".date("H:i:s", MySQLToEpochTime($Result->DateTime))."] ".$Result->Report."<br>";}

// -----------------------------------------------------------------------------
// ESEGUO LETTURA DATI PER VISUALIZZAZIONE
// -----------------------------------------------------------------------------
// Lettura ultimo record per ogni variabile utilizzata in visualizzazione.

$DbRow=$GLOBALS['Db']->get_row("SELECT Value FROM ".RESTDATA." WHERE (SID = {$GLOBALS['St']['SID']} AND Field = 'Voltage') ORDER BY ID DESC LIMIT 1");
if ($DbRow != NULL) $Return["Voltage"]=sprintf("%5.1f",$DbRow->Value);

$DbRow=$GLOBALS['Db']->get_row("SELECT Value FROM ".RESTDATA." WHERE (SID = {$GLOBALS['St']['SID']} AND Field = 'Frequency') ORDER BY ID DESC LIMIT 1");
if ($DbRow != NULL) $Return["Frequency"]=sprintf("%5.1f", $DbRow->Value);

$DbRow=$GLOBALS['Db']->get_row("SELECT Value FROM ".RESTDATA." WHERE (SID = {$GLOBALS['St']['SID']} AND Field = 'AcPower') ORDER BY ID DESC LIMIT 1");
if ($DbRow != NULL) $Return["AcPower"]=sprintf("%5.1f", $DbRow->Value);

$DbRow=$GLOBALS['Db']->get_row("SELECT Value FROM ".RESTDATA." WHERE (SID = {$GLOBALS['St']['SID']} AND Field = 'PwFactor') ORDER BY ID DESC LIMIT 1");
if ($DbRow != NULL) $Return["PwFactor"]=sprintf("%1.2f", $DbRow->Value);

// -----------------------------------------------------------------------------
// ESEGUO LETTURA DATI PER GRAFICO
// -----------------------------------------------------------------------------
// Per ogni sistema (Riconoscibile dal suo "SID") esiste un record nel database.

$DbRes=$GLOBALS['Db']->get_results("SELECT MIN(ID) AS ID, AVG(Value) AS Value, MIN(DateTime) AS DateTime FROM ".RESTDATA." WHERE SID = {$GLOBALS['St']['SID']} AND Field = '{$_REQUEST['Selector']}' GROUP BY ID DIV 250");
if ($DbRes == NULL) exit("System not found");

// Eseguo loop inserimento riferimenti (Asse "X") e valori (Asse "Y").

foreach ($DbRes as $Result)
{
array_push($Return["XAxis"], gmdate("d-H:i", MySQLToEpochTime($Result->DateTime))); //Inserisco riferimenti
array_push($Return["YAxis"], sprintf("%6.2f", $Result->Value)); //Inserisco valori
}

echo json_encode($Return);
?>

Was this article helpful?

Yes No

Programma di esempio

Footer