W&T collega
Adattatori per TCP/IP, Ethernet, RS-232, RS-485, USB, 20 mA, Fibra ottica di vetro e plastica, http, SNMP, OPC, Modbus TCP, I/O digitale, I/O analogico, ISA, PCI

Applicazione al Web-IO digitale:

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


L’applicazione descritta di seguito permette di controllare il Web-IO in ambiente Linux. L’interfaccia di comando è stata composta con Qt-Designer versione 3.3.5.

Web-IO in ambiente Linux

Con il seguente esempio di programma C++ potete raffigurare il vostro Web-IO digitale con i suoi input e output in un’applicazione Linux. Inoltre potete collegare gli output del Web-IO.

Preparativi

Alimentate il vostro Web-IO con corrente

1. Composizione dei diversi elementi di comando e oggetti di visualizzazione in Qt-Designer

Qt-Designer

Per creare questa applicazione viene prodotto in Qt-Designer un nuovo progetto C++ al quale può essere assegnato un nome a piacere. Qui abbiamo optato per "Client". Nella fase successiva viene creata una main window nella quale vengono collocati gli elementi grafici che vengono nominati in base alle loro caratteristiche.

Per facilitarci la compilazione dell’applicazione in ambiente Unix System, creiamo due file che chiamiamo "Uic" e "Qmake". In tal modo otteniamo un testo sorgente C++ funzionante, perché si può compilare senza problemi con un makefile.

Si crea un nuovo file di testo e si scrivono le due seguenti righe. Quindi si salva il file con il nome "Uic".

Nota: le righe funzionano solo se viene utilizzato qt3 e se è installato nello stesso punto nel sistema. In caso contrario adattare le due righe.

/usr/lib/qt3/bin/uic $1.ui -o $1.h
/usr/lib/qt3/bin/uic -impl $1.h $1.ui -o $1.cpp
		

Ora si crea un ulteriore file di testo che quindi viene salvato con il nome "Qmake".

/usr/lib/qt3/bin/qmake -o Makefile $1.pro

Dopo avere creato i due file, essi vengono messi nella directory in cui si trova anche il progetto. Quindi si configurano i due file in modo tale che siano eseguibili. A tale scopo può essere utilizzato il comando chmod.

-> chmod a+x Dateiname

Successivamente il progetto può essere perfettamente convertito in codice sorgente C++ ed essere compilato. A tale scopo sono necessarie soltanto tre ulteriori fasi.

./Uic Dateiname(.ui)
./Qmake Projekt(.pro)
make

Ora la creazione di un file eseguibile, che si chiama esattamente come il progetto, è riuscita.

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

Inizializzazione degli elementi di comando

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

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

Creazione del collegamento

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!");
}
		
Collegamento realizzato

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);
}
Disinserzione del collegamento

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();
}
Azzeramento dei counter

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

Analisi e visualizzazione dei dati ricevuti
  • 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));
	}
}
Interrogazione ciclica di determinati valori

È 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();
}

Il programma esempio supporta tutte le comuni funzioni del Web-IO nella modalità stringa di comando, ottimizzata per il Web-IO 2x input digitale, 2x output digitale. Gli altri modelli Web-IO devono eventualmente essere adattati al programma. Ulteriori esempi di programma per la programmazione socket sono riportati nelle pagine del tool per il Web-IO. Una descrizione dettagliata sull’interfaccia socket dei modelli Web-IO digitali è riportata nel manuale di riferimento.

Download esempio di programma

Non disponete ancora di un Web-IO e desiderate semplicemente provarne il funzionamento come nell’esempio illustrato?

Nessun problema: vi mettiamo a disposizione gratuitamente per 30 giorni il Web-IO digitale 2x input, 2x output. Non dovete far altro che compilare l’ordinazione del campione e vi forniremo il Web-IO in prova in conto aperto. Se ci restituite l’apparecchio entro 30 giorni, vi accreditiamo completamente la fattura.

All’ordinazione del campione