Web-IO digitale con C++ in ambiente Linux controllo e monitoraggio

2. Creazione del file codice sorgente dell’interfaccia grafica

Se Qt-Designer viene avviato e si ha la main window aperta davanti a sé, facendo doppio clic sulla finestra viene creato un file codice sorgente .ui.h. Successivamente vengono descritte nel dettaglio le fasi necessarie per fare girare questa applicazione.

Per creare nuovi slot, facendo clic con il tasto destro sulla main window si può aprire una finestra delle proprietà e in essa scegliere la voce Slot. Qui ci si creano gli slot necessari che quindi con un contenuto vuoto compaiono automaticamente nel file .ui.h creato.

Ora includiamo anche alcuni file header necessari. Il clientDlg.h e il clientDlg.cpp vengono creati in base all’applicazione con ./Uic dal file .ui (main window). Per poter accedere agli elementi, il file header viene incluso qui.

#include "clientDlg.h"
#include <qsocket.h>
#include <qstring.h>
#include <qtextstream.h>
#include <qtimer.h>
#include <iostream>

Successivamente vengono dichiarate le variabili globali per un collegamento TCP e il polling che viene reso accessibile per ogni metodo della classe. Poiché non definiamo alcuno spazio del nome proprio, viene utilizzato lo spazio del nome standard.

using namespace std;

QSocket* client;
QTimer* output;
QTimer* input;
QTimer* counter;

3. Avvio del programma

Il gruppo con gli elementi di comando per il Web-IO viene innanzitutto bloccato per l’uso. Non appena viene realizzato un collegamento, tutti gli elementi necessari vengono abilitati. Inoltre nelle proprietà del GroupBox cb_io_control, nonché in tutti gli altri elementi, la funzione Enable può essere impostata su ’false’ o ’true’.

Il nome del relativo elemento di comando può essere derivato in base al contesto dall’elemento stesso. I primi due caratteri del nome indicano il tipo dell’elemento (cb -> checkbox, bt -> button, gb -> groupbox e le -> lineedit).

4. Controllo del collegamento

Indicando l’indirizzo IP del Web-IO nel campo di testo le_ip e della porta 80 nel campo di testo le_port può essere creato un collegamento azionando il pulsante bt_connect. Se non viene inserito alcun indirizzo IP o alcuna porta, compare un messaggio prodotto dall’applicazione nella barra di stato.

Per poter creare un collegamento TCP viene inizializzata la variabile socket già dichiarata. Se tutto è stato inserito correttamente, ha inizio un tentativo di creazione di un collegamento. Per sapere se il collegamento è stato realizzato, si aspetta un segnale del socket che indica una creazione riuscita del collegamento.

void clientDlg::onConnect()
{
	client = new QSocket(this);
	bool ok;
	connect(client,
	SIGNAL(connected()), SLOT(connectDone()));
	connect(client,
	SIGNAL(error(int)),
	SLOT(connectError(int)));

	if(le_ip->text() == "")
	le_statusBar->setText("No IP entered!");
	else if(le_port->text() == "")
	le_statusBar->setText("No port entered!");
	else
	client->connectToHost(le_ip->text(), (le_port->text()).toInt(&ok,10));
} 

In caso di errore durante la creazione di un collegamento, nella barra di stato viene visualizzato un messaggio.

void clientDlg::connectError(int)
{
	le_statusBar->setText("Error while connecting!");
}
		

Dopo la creazione riuscita di un collegamento vengono abilitati tutti gli elementi di comando utili dell’applicazione e viene disattivato il pulsante Connect. Inoltre l’applicazione inizia subito a spostarsi sulla modalità di pronto per la ricezione.

void clientDlg::connectDone()
{
	le_statusBar->setText("Connected to " + le_ip->text());
	connect(client, SIGNAL(readyRead()), SLOT(onReceive()));

	output = new QTimer(this);
	connect(output,
	SIGNAL(timeout()),
	SLOT(timerEvent()));

	input = new
	QTimer(this);
	connect(input,
	SIGNAL(timeout()),
	SLOT(timerEvent()));

	counter = new
	QTimer(this);
	connect(counter,
	SIGNAL(timeout()),
	SLOT(timerEvent()));

	gb_io_control->setEnabled(true);
	bt_disconnect->setEnabled(true);
	bt_connect->setEnabled(false);
}

Il collegamento rimane fino a quando non viene terminato dall’utente facendo clic sul pulsante Disconnect oppure dal Web-IO. Dopo avere premuto il tasto viene visualizzato un messaggio che indica che il collegamento è stato terminato.

void clientDlg::onDisconnect()
{
	client->close();

	output->stop();
	input->stop();
	counter->stop();

	gb_io_control->setEnabled(false);
	bt_disconnect->setEnabled(false);
	bt_connect->setEnabled(true);
	le_statusBar->setText("Disconnected!");
}

Al termine del collegamento tutti gli elementi vengono di nuovo bloccati per l’uso.

5. Utilizzo e comunicazione del lato client

Non appena viene realizzato un collegamento con il Web-IO, l’utente può inviare comandi al Web-IO utilizzando i corrispondenti elementi del programma.

Durante l’invio di un messaggio al Web-IO si lavora in modo asincrono. In tal modo l’applicazione non risulta bloccata durante la procedura di invio/ricezione.

Gli output del Web-IO possono essere commutati per mezzo delle due caselle di spunta cb_output0 e cb_output1.

Nella fase successiva si verifica se la casella di spunta è già stata impostata e se i corrispondenti output sono impostati su ON o OFF.

void clientDlg::onOutput0()
{
	QString message1 = "GET /outputaccess0?PW=" + le_password->text() + "&State=ON&";
	QString message2 = "GET /outputaccess0?PW=" + le_password->text() + "&State=OFF&";

	if(cb_output0->isChecked())
	client->writeBlock(message1, message1.length());
	else
	client->writeBlock(message2, message2.length());

	client->flush();
} 

void clientDlg::onOutput1()
{
	QString message1 = "GET /outputaccess1?PW=" + le_password->text() + "&State=ON&";
	QString message2 = "GET /outputaccess1?PW=" + le_password->text() + "&State=OFF&";

	if(cb_output1->isChecked())
	client->writeBlock(message1, message1.length());
	else
	client->writeBlock(message2, message2.length());

	client->flush();
} 

Interrogazione dello stato degli output/input

void clientDlg::onReadallOutputs()
{
	QString message = "GET /output?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
} 

void clientDlg::onReadallInputs()
{
	QString message = "GET /input?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
} 

Interrogazione dei counter

void clientDlg::onReadCounter0()
{
	QString message = "GET /counter0?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
} 

void clientDlg::onReadCounter1()
{
	QString message = "GET /counter1?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
}

Naturalmente gli stati di tutti i counter possono essere interrogati anche con un unico comando.

void clientDlg::onReadallCounter()
{
	QString message = "GET /counter?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
}

Inoltre è possibile impostare i contatori dopo la lettura su 0.

void clientDlg::onClearCounter0()
{
	QString message = "GET /counterclear0?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
}
		

void clientDlg::onClearCounter1()
{
	QString message = "GET /counterclear1?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
} 

Naturalmente è possibile azzerare anche tutti i counter con un comando.

void clientDlg::onClearallCounter()
{
	QString message = "GET /counterclear?PW=" + le_password->text() + "&";
	client->writeBlock(message, message.length());
	client->flush();
} 

Poiché gli stati di tutti i counter possono essere letti o azzerati con un comando, deve essere implementato un ulteriore metodo, che elabora la stringa di risposta del Web-IO e assegna a ogni computer nell’applicazione il suo stato specifico.

void clientDlg::readAndClearCounter(QString data)
{
	QString counter[12];
	int j = 0;
	int length = data.length();
	for(int i = 0; i < length; i++)
	{
	if(data[i] == ’;’)
			j++;
	else
			counter[j] += data[i];
	}
	le_counter0->setText(counter[0]);
	le_counter1->setText(counter[1]);
}

6. Ricezione dei dati dal Web-IO

• Tutti i comandi e le richieste al Web-IO vengono confermati con una stringa di risposta. Tali risposte hanno una struttura specifica in base al tipo.
• Per gli output: output;<valore binario dello stato degli output in formato esadecimale>
• Per un output specifico: outputx;<ON o OFF>
• Per gli input: input;<valore binario dello stato degli input in formato esadecimale>
• Per un input specifico: inputx;<ON o OFF>
• Quindi segue la stringa di risposta per un counter che appare come segue.
• Counter: counterx;<stato del conteggio decimale>
• oppure counter;<stato del conteggio decimale 0 >; <stato del conteggio decimale 0 >; ... se tutti i counter devono essere letti in un’unica volta.
• Tutte le stringe di risposta terminano con 0 byte.

Nella nostra applicazione viene richiamato il metodo OnReceive() per la ricezione di un tale messaggio. In questo metodo viene ricevuta ed elaborata la stringa di risposta. La particolarità in questo caso è che questa funzione si richiama da sé per tutto il tempo e in tal modo verifica ininterrottamente la presenza di messaggi che sono stati probabilmente inviati dal Web-IO. Ovviamente lo abbiamo stabilito direttamente dopo l’inizializzazione riuscita di un collegamento (connectDone()).

void clientDlg::onReceive()
{
	char buffer[50];
	client->readBlock(buffer, 49);
	QString rcv = buffer;
	bool ok;
	if(rcv[0] == ’o’)
	{
		int value = rcv.right(rcv.length()-7).toInt(&ok, 16);
	if((value & 1) == 1)
		cb_output0->setChecked(true);
	else
		cb_output0->setChecked(false);
	if((value & 2) == 2)
		cb_output1->setChecked(true);
	else
		cb_output1->setChecked(false);
	}
	if(rcv[0] == ’i’)
	{
		int value = rcv.right(rcv.length()-6).toInt(&ok, 16);
		if((value & 1) == 1)
		cb_input0->setChecked(true);
	else
		cb_input0->setChecked(false);
	if((value & 2) == 2)
	cb_input1->setChecked(true);
	else
	cb_input1->setChecked(false);
	}
	if(rcv[0] == ’c’)
	{
	if(rcv[7] == ’0’) le_counter0->setText(rcv.right(rcv.length()-9));
	if(rcv[7] == ’1’) le_counter1->setText(rcv.right(rcv.length()-9));
	if(rcv[7] == ’;’) readAndClearCounter(rcv.right(rcv.length()-8));
	}
}

È auspicabile che lo stato di un singolo componente si aggiorni da sé A tale scopo viene utilizzato in questo programma un timer che invia ciclicamente interrogazioni al Web-IO in un intervallo di tempo determinato dall’utente.

L’intervallo ciclico viene immesso nel campo le_interval.

Naturalmente viene intercettato anche il caso in cui l’utente ha inserito un’indicazione senza senso come ad es. un valore di tempo negativo. Segue subito un messaggio e il valore non viene naturalmente accettato.

7. Polling

bool clientDlg::checkRange()
{
	bool ok;
	int tmp = (le_interval->text()).toInt(&ok, 10);
	if(ok && tmp > 0)
	{
		le_statusBar->setText("Range changed to " + le_interval->text() + " ms!");
		return
		true;
	}
	else
	{
		le_statusBar->setText("Please type a positive integer value for the range of polling!");
		return
		false;
	}
} 

Per eseguire anche l’interrogazione ciclica degli stati del Web-IO, definita anche polling, è possibile scegliere tra polling degli output, degli input o dei counter.

Se si attiva la casella di spunta cb_polling_outputs, il polling viene utilizzato sugli output.

void clientDlg::onPollingOutputs()
{
if(checkRange())
	{
	if(cb_polling_outputs->isChecked())
		output->start((le_interval->text()).toInt(), false);
	else
		output->stop();
	}
}

Attivando la casella di spunta cb_polling_inputs il polling viene utilizzato sugli input.

void clientDlg::onPollingInputs()
{
	if(checkRange())
	{
	if(cb_polling_inputs->isChecked())
		input->start((le_interval->text()).toInt(), false);
	else
		input->stop();
	}
}

Se ora devono essere interrogati con il polling anche i counter, può essere utilizzata a tale scopo la casella di spunta cb_polling_counter.

void clientDlg::onPollingCounter()
{
	if(checkRange())
	{
	if(cb_polling_counter->isChecked())
	counter->start((le_interval->text()).toInt(),false);
	else
	counter->stop();
	}
}

Sono stati inizializzati tre diversi timer che nell’intervallo inserito attivano un’azione. Infatti per rilevare gli eventi deve essere implementato un ulteriore metodo.

void clientDlg::timerEvent()
{
	if(output->isActive()) onReadallOutputs();
	if(input->isActive()) onReadallInputs();
	if(counter->isActive()) onReadallCounter();
}