Web-IO digitale con Visual C# controllo e monitoraggio

1. Collocazione dei diversi elementi di comando e oggetti di visualizzazione nel modulo

2. Importazione di risorse e dichiarazione di variabili locali

Come prima cosa vengono importate tutte le classi necessarie per il collegamento di rete e la GUI (Graphical User Interface).

							using System;
							using System.Drawing;
							using System.Collections;
							using System.ComponentModel;
							using System.Windows.Forms;
							using System.Data;
							using System.Net;
							using System.Net.Sockets;
							using System.Text; 

Successivamente i componenti dell’applicazione e le variabili importanti per un collegamento TCP vengono dichiarati variabili locali della classe e con ciò resi accessibili ai metodi della classe.

private System.Windows.Forms.CheckBox
				cb_Output0;
				private System.Windows.Forms.CheckBox
				cb_Output1;
				private System.Windows.Forms.CheckBox
				cb_Input0;
				private System.Windows.Forms.CheckBox
				cb_Input1;
				private System.Windows.Forms.CheckBox
				cb_Polling_Counter;
				private System.Windows.Forms.CheckBox
				cb_Polling_Outputs;
				private System.Windows.Forms.CheckBox
				cb_Polling_Inputs;
				private System.Windows.Forms.Button
				bt_Readall_Outputs;
				private System.Windows.Forms.Button
				bt_Readall_Inputs;
				private System.Windows.Forms.Button
				bt_Clear_Counter0;
				private System.Windows.Forms.Button
				bt_Clear_Counter1;
				private System.Windows.Forms.Button
				bt_Clearall_Counter;
				private System.Windows.Forms.Button
				bt_Read_Counter0;
				private System.Windows.Forms.Button
				bt_Read_Counter1;
				private System.Windows.Forms.Button
				bt_Readall_Counter;
				private System.Windows.Forms.Label
				lb_Counter0;
				private System.Windows.Forms.Label
				lb_Counter1;
				private System.Windows.Forms.Label
				lb_Intervall;
				private System.Windows.Forms.TextBox
				tb_Counter0;
				private System.Windows.Forms.TextBox
				tb_Counter1;
				private System.Windows.Forms.TextBox
				tb_Intervall;
				private System.Windows.Forms.Button
				bt_Connect;
				private System.Windows.Forms.Button
				bt_Disconnect;
				private System.Windows.Forms.TextBox
				tb_Password;
				private System.Windows.Forms.TextBox
				tb_Port;
				private System.Windows.Forms.TextBox
				tb_IP;
				private System.Windows.Forms.GroupBox
				gb_ioControlBox;
				private System.Windows.Forms.GroupBox
				gb_conControlBox;
				private System.Windows.Forms.StatusBar
				statusBar;
				private System.ComponentModel.Container
				components = null;
				private System.Windows.Forms.Timer
				counter;
				private System.Windows.Forms.Timer
				outputs;
				private System.Windows.Forms.Timer
				inputs;

				private Socket client;
				private string rcv;
				private int intervall;
				private byte[] buffer = new byte[256];

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, vengono abilitati tutti gli elementi per i quali ha senso l’abilitazione.

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 tb-> textbox).

public mainWindow()
				{
					InitializeComponent();

					gb_ioControlBox.Enabled = false;
					bt_Disconnect.Enabled = false;
					cb_Input0.Enabled = false;
					cb_Input1.Enabled = false;
					tb_Counter0.Enabled = false;
					tb_Counter1.Enabled = false;
				} 

4. Controllo del collegamento

Immettendo l’indirizzo IP del Web-IO nel campo di testo tb_IP e la porta 80 nel campo di testo ltb_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 ora creare un collegamento TCP viene inizializzata la variabile socket già dichiarata. Durante questa operazione alla variabile vengono forniti uno stream e il tipo di collegamento. Inoltre viene creata una variabile che memorizza la porta e l’indirizzo IP. Affinché il programma possa funzionare in modo asincrono, non aspetta gli eventi ma funziona con routine di callback. I metodi di callback vengono inizializzati se viene avviato e richiamato un processo, nel caso in cui compaia il corrispondente evento, pertanto ad es. nella creazione del collegamento, all’invio o alla ricezione.

private void bt_Connect_Click(object sender, System.EventArgs e)
				{
					try
					{
					if((tb_IP.Text != "") && (tb_Port.Text == "80"))
					{
						client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
						IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(tb_IP.Text), int.Parse(tb_Port.Text));
						client.BeginConnect(ipep, new AsyncCallback(connectCallback), client);
					}
					else
						statusBar.Text = "IP and Port needed!";
					}
					catch(SocketException)
					{
					statusBar.Text = "Connection not possible!";
					}
				} 

Di seguito viene rappresentata la routine di callback che viene richiamata alla realizzazione del collegamento. 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 passare in modalità di pronto per la ricezione. A tale scopo viene inizializzata la routine di callback "receiveCallback" che viene spiegata dettagliatamente più avanti.

private void connectCallback(IAsyncResult ar)
				{
					try
					{
					client = (Socket) ar.AsyncState;
					client.EndConnect(ar);
					statusBar.Text = "Connected!";

					gb_ioControlBox.Enabled = true;
					bt_Disconnect.Enabled = true;
					bt_Connect.Enabled = false;

					intervall = 1000;
					client.BeginReceive(buffer, 0, 255, SocketFlags.None, new AsyncCallback(receiveCallback), client);
					}
					catch(Exception)
					{
					disconnect(); statusBar.Text = "Error while connecting!";
					}
				}

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

private void bt_Disconnect_Click(object
				sender, System.EventArgs e)
				{
					disconnect();
				}

Se il collegamento viene terminato, tutti gli elementi devono essere riportati nella loro posizione iniziale. Non deve più essere possibile azionare il pulsante Disconnect.

private void disconnect()
				{
					try
					{
					client.Shutdown(SocketShutdown.Both);
					client.Close();
					statusBar.Text = "Disconnected!";

					gb_ioControlBox.Enabled = false;
					bt_Disconnect.Enabled = false;
					bt_Connect.Enabled = true;
					}
					catch(Exception)
					{
					statusBar.Text = "Not able to disconnect!";
					}
				} 

Ora il collegamento è stato di nuovo terminato e l’applicazione viene riportata al suo stato iniziale.

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.

All’invio di un messaggio al Web-IO viene richiamata una routine di Callback esattamente come alla ricezione.

private void sendCallback(IAsyncResult ar)
				{
					try
					{
					Socket tmp_client = (Socket) ar.AsyncState;
					int bytessend = tmp_client.EndSend(ar);
					}
					catch(Exception)
					{
					statusBar.Text = "Error while sending";
					}
				} 

Impostazione degli output
Gli output del Web-IO possono essere commutati per mezzo delle due caselle di spunta cb_Output0 e cb_Output1. Quando si fa clic sulla casella di spunta essa attiva un’azione. In base all’eventuale preimpostazione della casella di spunta, l’output viene impostato su On o su OFF.

private void cb_Output0_CheckedChanged(object sender, System.EventArgs e)
				{
					if(cb_Output0.Checked)
					send("GET /outputaccess0?PW=" + tb_Password.Text + "&State=ON&");
					else
					send("GET /outputaccess0?PW=" + tb_Password.Text + "&State=OFF&");
				}

private void cb_Output1_CheckedChanged(object sender, System.EventArgs e)
				{
					if(cb_Output1.Checked)
					send("GET /outputaccess1?PW=" + tb_Password.Text + "&State=ON&");
					else
					send("GET /outputaccess1?PW=" + tb_Password.Text + "&State=OFF&");
				}

Interrogazione dello stato degli output/input

private void bt_Readall_Outputs_Click(object sender, System.EventArgs e)
				{
					send("GET /output?PW=" + tb_Password.Text + "&");
				}

private void bt_Readall_Inputs_Click(object sender, System.EventArgs e)
				{
					send("GET /input?PW=" + tb_Password.Text + "&");
				} 

Il seguente metodo invia una richiesta di informazioni a un determinato counter e richiede una risposta con lo stato corrente del contatore.

private void bt_Read_Counter0_Click(object sender, System.EventArgs e)
				{
					send("GET /counter0?PW=" + tb_Password.Text + "&");
				} 

private void bt_Read_Counter1_Click(object sender, System.EventArgs e)
				{
					send("GET /counter1?PW=" + tb_Password.Text + "&");
				} 

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

private void bt_Readall_Counter_Click(object sender, System.EventArgs e)
				{
					send("GET /counter?PW=" + tb_Password.Text + "&");
				} 

Azzeramento dei counter

private void bt_Clear_Counter0_Click(object sender, System.EventArgs e)
				{
					send("GET /counterclear0?PW=" + tb_Password.Text + "&");
				} 

private void bt_Clear_Counter1_Click(object sender, System.EventArgs e)
				{
					send("GET /counterclear1?PW=" + tb_Password.Text + "&");
				} 

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

private void bt_Clearall_Counter_Click(object sender, System.EventArgs e)
				{
					send("GET /counterclear?PW=" + tb_Password.Text + "&");
				} 

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

private void readAndClearCounter(string data)
				{
					int j = 0;
					string[] counter = new string[12];
					for(int i = 0; i < data.Length-1; i++)
					{
					if((data[i].CompareTo(';')) == 0)
						j++;
					else
						counter[j] += data[i].ToString();
					}
					tb_Counter0.Text = counter[0];
					tb_Counter1.Text = 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. Le 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 receiveCallback() per la ricezione di un tale messaggio. In questo metodo viene letta ed elaborata la stringa di risposta. La particolarità di questa funzione è il richiamo controllato dagli eventi che avviene non appena il Web-IO invia dati all’applicazione.

private void receiveCallback(IAsyncResult ar)
				{
					int bytesRead;
				try
				{
					bytesRead = client.EndReceive(ar);
					rcv = string.Empty;
					rcv = Encoding.ASCII.GetString(buffer);

					client.BeginReceive(buffer, 0, 255, SocketFlags.None, new AsyncCallback(receiveCallback), client);
				}
				catch(Exception)
				{
					bytesRead = 0;
				}
				if(bytesRead == 0 && client.Connected)
					disconnect();
				else if(rcv != null)
				{
					if(rcv[0] == 'o')
					{
					int i = Int32.Parse(rcv.Substring(7), System.Globalization.NumberStyles.HexNumber);
					if((i & 1) == 1)
						cb_Output0.Checked = true;
					else
						cb_Output0.Checked = false;
					if((i & 2) == 2)
						cb_Output1.Checked = true;
					else
						cb_Output1.Checked = false;
					}
					if(rcv[0] == 'i')
					{
					int i = Int32.Parse(rcv.Substring(6), System.Globalization.NumberStyles.HexNumber);
					if((i & 1) == 1)
						cb_Input0.Checked = true;
					else
						cb_Input0.Checked = false;
					if((i & 2) == 2)
						cb_Input1.Checked = true;
					else
						cb_Input1.Checked = false;
					}
					if(rcv[0] == 'c')
					{
					if(rcv[7] == '0')
						tb_Counter0.Text = rcv.Substring(9);
					if(rcv[7] == '1')
						tb_Counter1.Text = rcv.Substring(9);
					if(rcv[7] == ';')
						readAndClearCounter(rcv.Substring(8));
					}
					}
				}

7. Polling

È auspicabile che lo stato di un singolo componente si aggiorni da sé e con ciò che l’applicazione presenti sempre il suo stato corrente. 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 di tempo può essere stabilito nel campo IDC_POLLINGTEXT.

Naturalmente viene intercettato anche il caso in cui l’utente ha inserito un’indicazione senza senso come ad es. un valore di tempo negativo.

private void tb_Intervall_TextChanged(object sender, System.EventArgs e)
				{
					try
					{
					if(Convert.ToInt32(tb_Intervall.Text) > 0)
					{
					intervall = Convert.ToInt32(tb_Intervall.Text);
					statusBar.Text = "New range: " + intervall.ToString() + " ms!";
					}
					else
					statusBar.Text = "Only positive Integer allowed!";
					}
					catch(Exception)
					{
					statusBar.Text = "Only positive Integer allowed!";
					}
				} 

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

Per ogni variante di polling viene inizializzato un proprio timer.

Se si attiva la casella di spunta cb_polling_outputs, il polling viene utilizzato sugli output. A tale scopo viene inizializzato il corrispondente timer.

private void cb_Polling_Outputs_CheckedChanged(object sender, System.EventArgs e)
				{
					if(cb_Polling_Outputs.Checked)
					{
					outputs = new System.Windows.Forms.Timer();
					outputs.Interval = intervall;
					outputs.Start();
					outputs.Tick += new EventHandler(timer_handler);
					}
					else
					outputs.Stop();
				} 

Lo stesso vale per gli input e i counter

private void cb_Polling_Inputs_CheckedChanged(object sender, System.EventArgs e)
				{
					if(cb_Polling_Inputs.Checked)
					{
					inputs = new System.Windows.Forms.Timer();
					inputs.Interval = intervall;
					inputs.Start();
					inputs.Tick += new EventHandler(timer_handler);
					}
					else
					inputs.Stop();
				} 

private void cb_Polling_Counter_CheckedChanged(object sender, System.EventArgs e)
				{
					if(cb_Polling_Counter.Checked)
					{
					counter = new System.Windows.Forms.Timer();
					counter.Interval = intervall;
					counter.Start();
					counter.Tick += new EventHandler(timer_handler);
					}
					else
					counter.Stop();
				} 

In questo metodo l’evento attuale del timer, appena segnalato, viene rilevato e assegnato a una determinata azione.

 private void timer_handler(object sender, System.EventArgs e)
				{
					if(sender == counter) bt_Readall_Counter_Click(sender, e);
					if(sender == outputs) bt_Readall_Outputs_Click(sender, e);
					if(sender == inputs)  bt_Readall_Inputs_Click (sender, e);
				}