W&T verbindet
Interfaces für TCP/IP, Ethernet, RS-232, RS-485, USB, 20mA, Glas- und Kunststoff-LWL, http, SNMP, OPC, Modbus TCP, I/O digital, I/O analog, ISA, PCI

Tutorial zum Web-IO Digital:

Web-IO Digital mit Visual C++ steuern und überwachen


Für das Erstellen von Windows-Anwendungen ist Visual C++ eine der meistgenutzten Entwicklungsplattformen.

Mit C++ steuern und überwachen

Mit dem folgenden C++ Programmbeispiel können Sie Ihr Web-IO Digital mit seinen Inputs und Outputs in einer Windows-Anwendung abbilden. Darüber hinaus können Sie die Outputs des Web-IO schalten.


Vorbereitungen


Zusammenstellen der verschiedenen Bedienelemente und Anzeigeobjekte im Visual-C++-Form

Visual C++ Form

Definition in der Header-Datei von MySocket und CWeb_IO_ClientDlg

Um die Eingaben in den Feldern IDC_IPTEXT, IDC_PORTTEXT, IDC_PASSWORDTEXT und IDC_POLLINGTEXT in privaten Membervariablen der Klasse CWeb_IO_ClientDlg zu speichern, werden in der Header-Datei einige Variablen definiert.

Um nicht für jede gesendete und empfangene Nachricht eine neue Variable zu erzeugen, werden im Header dafür auch private Variablen erzeugt. Der Eintrag in der Statusbar bekommt an dieser Stelle auch eine Variable.

						 
							private:
							CString m_ip;
							CString m_message1;
							CString m_message2;
							CString m_rcv;
							CString m_password;
							int m_port;
							int m_range;
							public:
							CStatusBarCtrl*
							m_statusBar; 
  						
  					

Ebenfalls werden im Header einige benötigte Methoden vordeklariert.

						
							public:
							void changeAccess(int i);
							void TryConnect();
							void OnConnect();
							void OnDisconnect();
							void checkpass();
							void OnReceive();
							void OnSend();
							void OnClose();
							void OnTimer(UINT nIDEvent);
							void readAndClearCounter(CString data)
						
					

Um nun auch eine Verbindung zu initialisieren, benötigen wir noch eine Klasse, welche sich um das Senden und Empfangen von Daten kümmert. Dazu wurde eine Datei namens MySocket erstellt, die von der Klasse CAsyncSocket erbt. Somit werden alle öffentlichen Methoden dieser Klasse an unsere Klasse vererbt und im Header nochmal deklariert. Um auf die Methoden der Klasse CWeb_IO_ClientDlg später zugreifen zu können, wird im Header ein Objekt deklariert.

						
							public:
							CWeb_IO_ClientDlg*
							m_client;

							public:
							virtual void OnReceive(int nErrorCode);
							virtual void OnSend(int nErrorCode);
							virtual void OnClose(int nErrorCode);
						
					

Definition in MySocket.cpp

Da die Klasse MySocket von der Klasse CAsyncSocket geerbt hat, werden einige der benötigten Methoden für eine laufende Verbindung überlagert. Somit kann die Applikation später sowohl einwandfrei Daten asynchron verschicken und empfangen, als auch auf die Terminierung der Verbindung von Seiten des Web-IO reagieren.


void MySocket::OnReceive(int nErrorCode)
{
  m_client->OnReceive();
  CAsyncSocket::OnReceive(nErrorCode);
}

void MySocket::OnSend(int nErrorCode)
{
  m_client->OnSend();
  CAsyncSocket::OnSend(nErrorCode);
}

void MySocket::OnClose(int nErrorCode)
{
  m_client->OnClose();
  CAsyncSocket::OnClose(nErrorCode);
}

void MySocket::OnConnect(int nErrorCode);
{
  if(nErrorCode == 0)
  {
    m_client->OnConnect();
    CAsyncSocket::OnConnect(nErrorCode);
  }
  else
  {
    m_client->OnDisconnect();
    m_client->m_statusBar->SetText("Error while connecting!", 0, 0);
  }
} 

Programmstart

Einrichten der Bedienelemente

Die Gruppe mit den Bedienelementen für das Web-IO wird zunächst für die Bedienung gesperrt. Sobald eine Verbindung zustande kommt, werden alle Elemente freigeschaltet, welche eine sinnvolle Ausführung besitzen.

Um Meldungen in einer Statusleiste auszugeben, wird in dieser Methode eine Statusbar erzeugt. Außerdem wird die Klasse der MySocket-Klasse übergeben, sodass beide miteinander verknüpft sind.

Um Variablen oder Methoden mit den Komponenten der Applikation zu verknüpfen, kann man sich die Hilfe des Klassen-Assistenten von Visual C++ zu Nutze machen, bzw. ab Visual Studio 2003 die entsprechende Funktionalität in den Klasseneigenschaften.


BOOL CWeb_IO_ClientDlg::OnInitDialog()
{
  CDialog::OnInitDialog();
  // weitere Implementierungen...

  m_statusBar = new CStatusBarCtrl;
  m_statusBar->Create(WS_CHILD|WS_VISIBLE, CRect(0, 0, 0, 0), this, 0);
  clientSocket.m_client = this;
  changeAccess(FALSE);
  SendMessage(DM_SETDEFID,
  IDC_CONNECT);

  return TRUE;
}					

void CWeb_IO_ClientDlg::changeAccess(bool b)
{
  if(b == TRUE)
  {
    GetDlgItem(IDC_CONNECT)->EnableWindow(FALSE);
    GetDlgItem(IDC_DISCONNECT)->EnableWindow(TRUE);
    GetDlgItem(IDC_OUTPUT0)->EnableWindow(TRUE);
    GetDlgItem(IDC_OUTPUT1)->EnableWindow(TRUE);
    GetDlgItem(IDC_READALL0)->EnableWindow(TRUE);
    GetDlgItem(IDC_READALL1)->EnableWindow(TRUE);
    GetDlgItem(IDC_POLLING0)->EnableWindow(TRUE);
    GetDlgItem(IDC_POLLING1)->EnableWindow(TRUE);
    GetDlgItem(IDC_POLLINGTEXT)->EnableWindow(TRUE);
    GetDlgItem(IDC_POLLINGCOUNTER)->EnableWindow(TRUE);
    GetDlgItem(IDC_READ0)->EnableWindow(TRUE);
    GetDlgItem(IDC_READ1)->EnableWindow(TRUE);
    GetDlgItem(IDC_CLEAR0)->EnableWindow(TRUE);
    GetDlgItem(IDC_CLEAR1)->EnableWindow(TRUE);
    GetDlgItem(IDC_READALL)->EnableWindow(TRUE);
    GetDlgItem(IDC_CLEARALL)->EnableWindow(TRUE);
  }
  else
  {
    GetDlgItem(IDC_CONNECT)->EnableWindow(TRUE);
    GetDlgItem(IDC_DISCONNECT)->EnableWindow(FALSE);
    GetDlgItem(IDC_OUTPUT0)->EnableWindow(FALSE);
    GetDlgItem(IDC_OUTPUT1)->EnableWindow(FALSE);
    GetDlgItem(IDC_INPUT0)->EnableWindow(FALSE);
    GetDlgItem(IDC_INPUT1)->EnableWindow(FALSE);
    GetDlgItem(IDC_READALL0)->EnableWindow(FALSE);
    GetDlgItem(IDC_READALL1)->EnableWindow(FALSE);
    GetDlgItem(IDC_POLLING0)->EnableWindow(FALSE);
    GetDlgItem(IDC_POLLING1)->EnableWindow(FALSE);
    GetDlgItem(IDC_POLLINGTEXT)->EnableWindow(FALSE);
    GetDlgItem(IDC_POLLINGCOUNTER)->EnableWindow(FALSE);
    GetDlgItem(IDC_COUNTERTEXT0)->EnableWindow(FALSE);
    GetDlgItem(IDC_COUNTERTEXT1)->EnableWindow(FALSE);
    GetDlgItem(IDC_READ0)->EnableWindow(FALSE);
    GetDlgItem(IDC_READ1)->EnableWindow(FALSE);
    GetDlgItem(IDC_CLEAR0)->EnableWindow(FALSE);
    GetDlgItem(IDC_CLEAR1)->EnableWindow(FALSE);
    GetDlgItem(IDC_READALL)->EnableWindow(FALSE);
    GetDlgItem(IDC_CLEARALL)->EnableWindow(FALSE);
  }
}
				

Die Verbindungskontrolle

Einleiten der Verbindung

Durch Eingabe der IP-Adresse des Web-IO in das Textfeld IDC_IPTEXT und dem Port 80 in das Textfeld IDC_PORTTEXT kann durch Betätigung des Buttons IDC_CONNECT eine Verbindung aufgebaut werden. Falls keine IP-Adresse oder kein Port eingetragen wird, erfolgt eine Meldung in der Statusleiste.


void CWeb_IO_ClientDlg::OnClickConnect()
{
  GetDlgItemText(IDC_IPTEXT, m_ip);
  GetDlgItemText(IDC_PORTTEXT, m_message2);
  sscanf(m_message2, "%d", &m_port);

  if(m_ip == "") 
  {
    m_statusBar->SetText("No IP entered!", 0, 0); 
  }
  else if(m_port == 0) 
  {
    m_statusBar->SetText("No port entered!", 0, 0);
  }
  else 
  {
    TryConnect(); 
  }
}
				
Verbindungsaufbau

Um nun eine TCP-Verbindung aufbauen zu können, verwenden wir in unserem Beispiel ein globales Objekt der Klasse MySocket, welches Methoden wie Create(), Connect() und Close() zur Verfügung stellt.

Sollte ein negativer Port eingegeben worden sein oder der Verbindungsaufbau fehlschlagen, so wird jeweils eine Meldung ausgegeben.

Da die Verbindung nicht aufgebaut werden konnte, wird der Socket auch wieder geschlossen, sodass eine neue Verbindung problemlos erneut gestartet werden kann.

Ist alles gut gegangen, werden alle Komponenten freigeschaltet, welche nach erfolgreichem Aufbau genutzt werden können, und der IDC_CONNECT Button wird gesperrt, um einen erneuten Verbindungsaufbau bei bestehender Verbindung zu vermeiden.


void CWeb_IO_ClientDlg::TryConnect()
{
  if(m_port < 0)
  {
    m_statusBar->SetText("No
    negative port allowed!", 0, 0);
    return;
  }
  clientSocket.Create();
  clientSocket.Connect(m_ip, m_port);
  GetDlgItem(IDC_CONNECT)->EnableWindow(FALSE);
}
				
Verbindung kommt zustande

Ist die Verbindung zustande gekommen, kann die Applikation mit dem Web-IO eine Kommunikation durchführen, für welche die verschiedenen Komponenten genutzt werden können.


void CWeb_IO_ClientDlg::OnConnect()
{
  m_statusBar->SetText("Connection made!", 0, 0);
  changeAccess(TRUE);
}
Trennen der Verbindung

Die Verbindung bleibt solange bestehen, bis sie vom Benutzer durch Klick auf den Disconnect-Button oder durch das Web-IO beendet wird. Wird die Verbindung beendet, so wird eine Meldung ausgegeben.


void CWeb_IO_ClientDlg::OnClickDisconnect()
{
  OnDisconnect();
}
        

Wenn die Verbindung abgebaut wird, müssen alle Elemente wieder in ihre Ausgangsstellung transformiert werden, denn es soll dann nicht mehr möglich sein, auf den IDC_DISCONNECT-Button klicken zu können.


void CWeb_IO_ClientDlg::OnDisconnect()
{
  clientSocket.Close();
  m_statusBar->SetText("Disconnected!", 0, 0);
  changeAccess(FALSE);
}
        

Nun ist die Verbindung wieder beendet und die Applikation auf ihren Ausgangszustand zurückgesetzt.

Bedienung und Kommunikation von Client-Seite

Sobald eine Verbindung mit dem Web-IO zustande gekommen ist, kann der Anwender durch Bedienung der entsprechenden Programmelemente Kommandos an das Web-IO senden.

Setzen der Outputs

Die Outputs des Web-IO können mit Hilfe der beiden Checkboxen IDC_OUTPUT0 und IDC_OUTPUT1 geschaltet werden. Die Checkbox vermerkt, wenn sie angeklickt wird und löst daraufhin eine Aktion aus. Um eine Anfrage an das Web-IO schicken zu können, wird als erstes geprüft, ob im Textfeld IDC_PASSWORDTEXT ein Passwort eingetragen worden ist, ohne welches das Web-IO keine Anfragen annehmen würde. Falls kein Passwort angegeben wurde, wird die Anfrage ohne Passwort abgeschickt.


void CWeb_IO_ClientDlg::checkpass()
{
  GetDlgItemText(IDC_PASSWORDTEXT, m_password);
}

        

Im nächsten Schritt wird geprüft, ob die Checkbox bereits gesetzt ist oder nicht, wobei daraufhin jeweils der Output entweder wieder zurückgesetzt oder gesetzt wird.


void CWeb_IO_ClientDlg::OnOutput0()
{
  checkpass();
  m_message1 = "GET /outputaccess0?PW=" + password + "&State=ON&";
  m_message2 = "GET /outputaccess0?PW=" + password + "&State=OFF&";
  if(IsDlgButtonChecked(IDC_OUTPUT0))
    clientSocket.Send(m_message1, m_message1.GetLength());
  else
    clientSocket.Send(m_message2, m_message2.GetLength());
}

void CWeb_IO_ClientDlg::OnOutput1()
{
  checkpass();
  m_message1 = "GET /outputaccess1?PW=" + password + "&State=ON&";
  m_message2 = "GET /outputaccess1?PW=" + password + "&State=OFF&";
  if(IsDlgButtonChecked(IDC_OUTPUT1))
    clientSocket.Send(m_message1, m_message1.GetLength());
  else
    clientSocket.Send(m_message2, m_message2.GetLength());
}
        
Output/Input-Status abfragen

Nun kann der Zustand der Outputs und Inputs auch überprüft werden, um jeweils die Kontrollkästchen in der Applikation zu aktualisieren. Der IDC_READALL0-Button liest den Zustand der Outputs und der IDC_READALL1-Button liest den Zustand der Inputs. Der Befehl zur Statusabfrage lautet ein wenig anders als der zum Setzen. Also kann man mit "GET /output?PW=&" den Status der Outputs abfragen.


void CWeb_IO_ClientDlg::OnClickReadall0()
{
  checkpass();
  m_message1 = "GET /output?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}

void CWeb_IO_ClientDlg::OnClickReadall1()
{
  checkpass();
  m_message1 = "GET /input?PW=" + password + "&";
  clientSocket.Send(m_message1,
  m_message1.GetLength());
}
        
Counter abfragen

Da eintreffende Input-Ereignisse nur im Web-IO selbst vermerkt werden und somit der innere Zähler hochgezählt wird, sollte dieser auch abgefragt werden können. Die folgende Methode sendet eine Anfrage an einen bestimmten Counter und fordert eine Antwort mit dem aktuellen Stand des Zählers. Aus der Antwort des Web-IO wird die Nummer des jeweiligen Counters und dessen Zählstand entnommen und in der Applikation angezeigt.


void CWeb_IO_ClientDlg::OnClickRead0()
{
  checkpass();
  m_message1 = "GET /counter0?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}

void CWeb_IO_ClientDlg::OnClickRead1()
{
  checkpass();
  m_message1 = "GET /counter1?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}
        

Natürlich können auch alle Counter-Zustände mit einem einzigen Kommando abgefragt werden.

 
void CWeb_IO_ClientDlg::OnClickReadall()
{
  checkpass();
  m_message1 = "GET /counter?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}
        
Counter zurücksetzen

Da man den Zählstand ja lesen kann, sollte es auch möglich sein, den Zähler auf 0 zu setzen. Dafür wird eine Nachricht an den jeweiligen Counter geschickt, welche diesen zurücksetzt.


void CWeb_IO_ClientDlg::OnClickClear0()
{
  checkpass();
  m_message1 = "GET /counterclear0?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}

void CWeb_IO_ClientDlg::OnClickClear1()
{
  checkpass();
  m_message1 = "GET /counterclear1?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}
        

Natürlich lassen sich auch alle Counter mit einem Kommando zurücksetzen.


void CWeb_IO_ClientDlg::OnClickClearall()
{
  checkpass();
  m_message1 = "GET /counterclear?PW=" + password + "&";
  clientSocket.Send(m_message1, m_message1.GetLength());
}
        

Da alle Counterzustände mit einem Kommando gelesen oder zurückgesetzt werden können, muss noch eine Methode implementiert werden, welche den Antwort-String des Web-IO bearbeitet und jedem Counter in der Applikation seinen spezifischen Zustand zuordnet.


void CWeb_IO_ClientDlg::readAndClearCounter(CString data)
{
  int j = 0;
  CString counter[12];

  for(int i = 0; i < data.GetLength(); i++)
  {
    if(data[i] == ';')
      j++;
    else
      counter[j]+= data[i];
  }

  SetDlgItemText(IDC_COUNTERTEXT0, counter[0]);
  SetDlgItemText(IDC_COUNTERTEXT1, counter[1]);
}
        

Datenempfang vom Web-IO

Auswerten und Anzeigen der empfangenen Daten
  • Alle Kommandos und Anfragen an das Web-IO werden mit einem Antwort-String quittiert. Dabei haben die Antworten je nach Type einen spezifischen Aufbau.
  • Man unterscheidet die Antwort von einem einzelnen Output bzw. Input und der aller Outputs und Inputs.
  • Für die Outputs: output;<Binärwert des Outputstatus im hexadezimalen Format>
  • Für einen speziellen Output: outputx;<ON oder OFF>
  • Für die Inputs: input;<Binärwert des Outputstatus im hexadezimalen Format>
  • Für einen speziellen Input: inputx;<ON oder OFF>
  • Dann gibt es noch den Antwort-String für einen Counter der folgendermaßen aussieht:
    counterx;<dezimaler Zählerstand>
    oder counter;<dezimaler Zählerstand 0 >; <dezimaler Zählerstand 1 >; ... wenn alle Counter auf einmal gelesen werden sollen.
    Alle Antwort-Strings sind mit einem 0-Byte abgeschlossen.
  • In unserer Applikation wird zum Empfang einer solchen Nachricht die Methode OnReceive() aufgerufen. In dieser Methode wird die Antwort des Web-IO verarbeitet.

void CWeb_IO_ClientDlg::OnReceive()
{
  clientSocket.Receive(m_rcv.GetBuffer(50),50);
  m_rcv.ReleaseBuffer();

  if(m_rcv.IsEmpty())
    OnDisconnect();
  else if(m_rcv.GetLength() > 1)
  {
    if(m_rcv[0] == 'o')
    {
      int i;
      sscanf(m_rcv.Right(m_rcv.GetLength() - 7), "%x", &i);
      if((i & 1) == 1) 
        CheckDlgButton(IDC_OUTPUT0, BST_CHECKED);
      else
        CheckDlgButton(IDC_OUTPUT0, BST_UNCHECKED);
      if((i & 2) == 2) 
        CheckDlgButton(IDC_OUTPUT1, BST_CHECKED);
      else
        CheckDlgButton(IDC_OUTPUT0, BST_UNCHECKED);
    }
    if(m_rcv[0] == 'i')
    {
      int i;
      sscanf(m_rcv.Right(m_rcv.GetLength() - 6), "%x", &i);
      if((i & 1) == 1) 
        CheckDlgButton(IDC_INPUT0, BST_CHECKED);
      else
        CheckDlgButton(IDC_INPUT0, BST_UNCHECKED);
      if((i & 2) == 2)
        CheckDlgButton(IDC_INPUT1, BST_CHECKED);
      else
        CheckDlgButton(IDC_INPUT1, BST_UNCHECKED);
    }
    if(m_rcv[0] == 'c')
    {
       if(m_rcv[7] == '0')
         SetDlgItemText(IDC_COUNTERTEXT0, m_rcv.Right(m_rcv.GetLength() - 9));
       if(m_rcv[7] == '1')
         SetDlgItemText(IDC_COUNTERTEXT1, m_rcv.Right(m_rcv.GetLength() - 9));
       if(m_rcv[7] == ';')
         readAndClearCounter(m_rcv.Right(m_rcv.GetLength() - 8));
     }
  }
} 
              

Polling

Zyklisches Abfragen bestimmter Werte

Nun ist es wünschenwert, dass sich der Status einer einzelnen Komponenten von selbst aktualisiert und somit die Applikation immer den aktuellen Stand aufweist. Dazu wird in diesem Progamm ein Timer verwendet, welcher in einem vom User bestimmten Zeitintervall zyklisch Abfragen an das Web-IO schickt.

Dazu kann als erstes ein Integer-Wert in dem Feld IDC_POLLINGTEXT eingegeben werden, der die Zeit in Millisekunden für die zyklische Abfrage definiert. Falls kein Wert eingetragen wird, ist die Zeit für das Intervall standardmäßig auf 1 Sekunde gesetzt (1000 ms).

Natürlich wird auch der Fall abgefangen, dass der Nutzer eine unsinnige Angabe macht, wie z.B. einen negativen Zeitwert. Darauf folgt sofort eine Meldung und der Wert wird natürlich nicht übernommen.


void CWeb_IO_ClientDlg::OnChangePollingtext()
{
  GetDlgItemText(IDC_POLLINGTEXT, m_message2);
  int check;
  sscanf(m_message2, "%d", &check);
  if(check <= 0)
  {
    m_statusBar->SetText("No negative
    value or character allowed!", 0, 0);
    return;
  }
  m_range = check;
  m_statusBar->SetText("Range
  changed!", 0, 0);
}
        

Um nun auch das zyklische Abfragen der Zustände des Web-IO durchzuführen, was auch als Polling bezeichnet wird, besteht die Auswahlmöglichkeit zwischen dem Polling der Outputs, der Inputs oder der Counter.

Je Polling-Variante wird ein eigener Timer initialisiert. Der Timeraufruf lautet dann jeweils "SetTimer(Nummer des Timers, Intervall, NULL)".

Betätigt man die Checkbox IDC_POLLING0 so wird das Polling auf die Outputs angewendet. Dabei wird ein Timer initialisiert, wenn sie gesetzt wird. Wird die Checkbox wieder zurückgesetzt, so wird der Timer mit der entsprechenden Nummer auch wieder zerstört.


void CWeb_IO_ClientDlg::OnPolling0()
{
  if(IsDlgButtonChecked(IDC_POLLING0))
    SetTimer(1, m_range, NULL);
  else
    KillTimer(1);
}
        

Beim Betätigen der Checkbox IDC_POLLING1 wird das Polling auf die Inputs angewendet. Dabei wird auch ein neuer Timer initialisiert, der dann von dieser Methode auch wieder zerstört werden kann.


void CWeb_IO_ClientDlg::OnPolling1()
{
  if(IsDlgButtonChecked(IDC_POLLING1))
    SetTimer(2, m_range, NULL);
  else
    KillTimer(2);
}
        

Sollen nun auch noch die Counter unter Polling abgefragt werden, so kann man dazu die Checkbox IDC_POLLINGCOUNTER verwenden.


void CWeb_IO_ClientDlg::OnPollingcounter()
{
  if(IsDlgButtonChecked(IDC_POLLINGCOUNTER))
    SetTimer(3,m_range, NULL);
  else
    KillTimer(3);
}
        

Nun wurden drei verschiedene Timer initialisiert, welche laut dem Intervall in bestimmten Zeitabschnitten eine Aktion auslösen, die bisher allerdings nicht gefangen wird. Um nämlich die Events zu fangen, muss noch eine Methode implementiert werden.

In dieser Methode wird das jeweilige Event des Timers, der sich gerade meldet, gefangen und einer bestimmten Aktion zu gewiesen.

Zur Erinnerung: In unserem Fall werden die Zustände der Outputs, der Inputs und der Counter je nach Event zyklisch abgefragt.


void CWeb_IO_ClientDlg::OnTimer(UINT nIDEvent)
{
  if(nIDEvent == 1) OnClickReadall0();
  if(nIDEvent == 2) OnClickReadall1();
  if(nIDEvent == 3) OnClickReadall();
  CDialog::OnTimer(nIDEvent);
}

        

Das gesamte Programm wird auf dieser Seite zur Verfügung gestellt, wobei es einige hier nicht erwähnte Dateien und Methoden zusätzlich enthält. Die MFC Anwendung unter Visual C++ erzeugt einen Overhead, der den graphischen Rahmen bildet, aber mit der Funktionalität nicht direkt in Verbindung steht. Die Methoden und Variablen, die Ihnen auf dieser Seite präsentiert worden sind, werden in den von Visual C++ erzeugten Rahmen implementiert und arbeiten dann als Einheit mit der graphischen Oberfläche.


Das Beispielprogramm unterstützt alle gängigen Funktionen des Web-IO im Kommando-String-Modus, optimiert für das Web-IO 2x Digital Input, 2x Digital Output PoE. Für die anderen Web-IO-Modelle müssen ggf. Anpassung am Programm vorgenommen werden. Weitere Programmbeispiele zur Socket-Programmierung finden Sie auf den Tool-Seiten zum Web-IO. Eine detaillierte Beschreibung zur Socket-Schnittstelle der Web-IO Digital Modelle finden Sie im Referenzhandbuch.

Programmbeispiel herunterladen


Produkte