Beispiel Maschine mit Microsoft Expression Blend

Der Microsoft Expression Blend ist ein Programm zum Erstellen von Programmoberflächen für C# und Visual Basic. In diesem Beispiel wird eine mit dem Programm erstellte Oberfläche mit dem Beispiel Machine verbunden. Dabei wurde die Programmiersprache C# verwendet.

Erforderliche Software:

Microsoft .NET Framework Version 3.0, mehr dazu unter www.microsoft.com
Microsoft Expression Blend, mehr dazu unter www.microsoft.com
Microsoft Visual Studio 2005
TwinCAT 2.10

Die ersten Schritte ...

Die Entwicklung eines Programms mit dem Microsoft Expression Blend und das Einbinden der TwinCAT ADS .NET Komponente wird anhand eines Beispiels beschrieben.

1. Neues Projekt erstellen:

Starten des Expression Blend und Erstellen einer neuen Oberfläche, über Menü -> File -> New Project... . Das Dialogfeld 'Create New Application' öffnet sich und es kann der Typ, der Name, die Location und die Programmiersprache ausgewählt werden. In diesem Fall bitte den Typ 'Standard Application', den Namen 'Machine' und die Programmiersprache 'C#' wählen.

Beispiel Maschine mit Microsoft Expression Blend 1:

2. Bedienungsoberfläche erstellen

Die Einstellungen der Oberfläche werden in der Datei Window1.xaml abgelegt.

Beispiel Maschine mit Microsoft Expression Blend 2:

Im oberen linken Bereich sehen Sie die beiden Ausgänge, die auch auf die Busklemmen ausgegeben werden. Unten links ist die Variable abgebildet, welche die Werkstücke zählt. Rechts können Sie mit dem Feld 'Speed' die Taktgeschwindigkeit des Motors verändern. Die Anzeige 'Steps' entspricht der Anzahl der Takte, die auf den Ausgang 1 ausgegeben werden.

3. Referenz hinzufügen

Nach dem Erstellen der Oberfläche muss zuerst eine Referenz namens TwinCAT.Ads.dll hinzugefügt werden. Die erfolgt über das Menü --> Project --> Add Reference.

Beispiel Maschine mit Microsoft Expression Blend 3:

4. Quelltext bearbeiten

Nach dem Erstellen der Oberfläche und das Einbinden der TwinCAT ADS Komponente kann zum C# Quelltext, der in Visual Studio angezeigt werden kann, gewechselt werden. In die oberste Zeile des Quelltextes werden die benötigten Namespaces 'System.IO' und 'TwinCAT.Ads' eingefügt.

using  System.IO;
using  TwinCAT.Ads;

Danach folgen die Deklarationen.

private TcAdsClient tcClient;
private AdsStream dataStream;
private BinaryReader binReader;
private int hEngine;
private int hDeviceUp;
private int hDeviceDown;
private int hSteps;
private int hCount;
private int hSwitchNotify;
private int hSwitchWrite;

Die erste Methode ist die Load Methode. In ihr werden Instanzen verschiedener Klassen erzeugt und eine Verbindung zum Port 801 hergestellt.

//-----------------------------------------------------//Wird als erstes beim Starten des Programms aufgerufen//-----------------------------------------------------private void Load(object sender, EventArgs e)
{
    try
    {
     // Eine neue Instanz der Klasse AdsStream erzeugen
     dataStream = new AdsStream(7);

     // Eine neue Instanz der Klasse BinaryReader erzeugen
     binReader = new BinaryReader(dataStream);

     // Eine neue Instanz der Klasse TcAdsClient erzeugen
     tcClient = new TcAdsClient();
     
     // Verbinden mit lokaler SPS - Laufzeit 1 - Port 801 
     tcClient.Connect(801);
    }
    catch
    {
     MessageBox.Show("Fehler beim Laden");
    }
     
    //...

Dann werden in der Methode Load die Variablen noch verbunden und mit einer Methode (siehe "Methode 'tcClient_OnNotification' schreiben") verbunden, die bei einer Änderung einer Variable aufgerufen wird.

try
    {
    // Initialisieren der Überwachung der SPS-Variablen
    hEngine = tcClient.AddDeviceNotification(".engine", dataStream, 0, 1, AdsTransMode.OnChange, 10, 0, null);
    hDeviceUp = tcClient.AddDeviceNotification(".deviceUp", dataStream, 1, 1, AdsTransMode.OnChange, 10, 0, null);
    hDeviceDown = tcClient.AddDeviceNotification(".deviceDown", dataStream, 2, 1, AdsTransMode.OnChange, 10, 0, null);
    hSteps = tcClient.AddDeviceNotification(".steps", dataStream, 3, 1, AdsTransMode.OnChange, 10, 0, null);
    hCount = tcClient.AddDeviceNotification(".count", dataStream, 4, 2, AdsTransMode.OnChange, 10, 0, null);
    hSwitchNotify = tcClient.AddDeviceNotification(".switch", dataStream, 6, 1,  AdsTransMode.OnChange, 10, 0, null);

    // Holen des Handles von "switch" - wird für das Schreiben des Wertes benötigt
    hSwitchWrite = tcClient.CreateVariableHandle(".switch");

    // Erstellen eines Events für Änderungen an den SPS-Variablen-Werten 
    tcClient.AdsNotification += newAdsNotificationEventHandler(tcClient_OnNotification);
    }
    catch (Exception ex)
    {
    MessageBox.Show(ex.Message);
    }
}

SPS Variablen verbinden:

Zum Verbinden der Variablen wurde die Methode AddDeviceNotification verwendet.

public int AddDeviceNotification(string variableName, AdsStream dataStream, int  offset, int length, AdsTransMode transMode, int cycleTime, int maxDelay, object userData);

variableName: Name der SPS Variablen.
dataStream: Der Datenstrom, der die Daten empfängt.
offset: Abstand im Datenstrom.
length: Länge im Datenstrom.
transMode: Das Ereignis, wenn sich die Variable ändert.
cycletime: Die Zeit (in ms) nach der der SPS-Server überprüft, ob sich die Variable geändert hat.
maxDelay: Die Zeit (in ms) nach der das Ereignis spätestens beendet ist.
userData: Das Objekt, das zum Ablegen bestimmter Daten verwendet werden kann.

Zum Verbinden der Variable hSwitchWrite wurde die Methode CreateVariableHandle verwendet.

int TcAdsClient.CreateVariableHandle(string variableName);

variableName: Name der SPS-Variablen.

Methode 'tcClient_OnNotification' schreiben:

Diese Methode wird aufgerufen, wenn sich eine der SPS-Variablen geändert hat.

//------------------------------------------------//wird bei Änderung einer SPS-Variablen aufgerufen//------------------------------------------------private void tcClient_OnNotification(object sender, AdsNotificationEventArgs e)
{
    try
    {
    // Setzen der Position von e.DataStream auf die des aktuellen benötigten Wertes
    e.DataStream.Position = e.Offset;

    // Ermittlung welche Variable sich geändert hatif(e.NotificationHandle == hDeviceUp)
    {
        //Die Farben der Grafiken entsprechened der Variablen anpassenif (binReader.ReadBoolean() == true)
        {
        DeviceUp_LED.Foreground = new SolidColorBrush(Colors.Red);
        }
        else
        {
        DeviceUp_LED.Foreground = new SolidColorBrush(Colors.White);
        }
    }
    else if(e.NotificationHandle == hDeviceDown)
    {
        if (binReader.ReadBoolean() == true)
        {
        DeviceDown_LED.Foreground = new SolidColorBrush(Colors.Red);
        }
        else
        {
        DeviceDown_LED.Foreground = new SolidColorBrush(Colors.White);
        }
    }
    else if(e.NotificationHandle == hSteps)
    {
        // Einstellen der ProgressBar auf den aktuellen Schritt
        prgSteps.Value = binReader.ReadByte();
    }
    else if(e.NotificationHandle == hCount)
    {
        // Anzeigen des "count"-Werts
        lblCount.Text = binReader.ReadUInt16().ToString();
    }
    else if(e.NotificationHandle == hSwitchNotify)
    {
        // Markieren des korrekten RadioButtonsif (binReader.ReadBoolean() == true)
        {
        optSpeedFast.IsChecked = true;
        }
        else
        {
        optSpeedSlow.IsChecked = true;
        }
    }
    }
    catch (Exception ex)
    {
    MessageBox.Show(ex.Message);
    }
}

Es fehlen noch zwei Methoden, mit denen die Maschine schneller oder langsamer fährt. In Ihnen wird ein virtueller Schalter umgelegt, hier wird ein Wert in die SPS-Variable switch geschrieben.

//------------------------------------------------------//wird aufgerufen, wenn das Feld 'slow' markiert wird//------------------------------------------------------private void optSpeedFast_Click(object sender, EventArgs e)
{
    try
    {
    tcClient.WriteAny(hSwitchWrite, true);
    }
    catch (Exception ex)
    {
    MessageBox.Show(ex.Message);
    }
}

//------------------------------------------------------//wird aufgerufen, wenn das Feld 'fast' markiert wird//------------------------------------------------------private void optSpeedSlow_Click(object sender, EventArgs e)
{
    try
    {
    tcClient.WriteAny(hSwitchWrite, false);
    }
    catch (Exception ex)
    {
    MessageBox.Show(ex.Message);
    }
}

Damit die Methoden beim richtigen Ereignis aufgerufen werden, muss in der Design Ansicht DocumentRoot markiert werden, bei Events auf add geklickt und loaded gewählt, und die Methode Load ausgewählt werden.

Gleiches gilt für die beiden RadioButtons, allerdings wird hier das Event 'Click' ausgewählt, sowie die Methode 'optSpeedFast_Click' bzw. 'optSpeedSlow_Click_Click'.

Notifications und Handles löschen:

In dem Close-Ereignis des Fensters werden die Verbindungen wieder mit der Methode DeleteDeviceNotification() freigegeben.

private void Close(object sender, EventArgs e)
{
    try
    {
    // Löschen der Notifications und Handles
    tcClient.DeleteDeviceNotification(hEngine);
    tcClient.DeleteDeviceNotification(hDeviceUp);
    tcClient.DeleteDeviceNotification(hDeviceDown);
    tcClient.DeleteDeviceNotification(hSteps);
    tcClient.DeleteDeviceNotification(hCount);
    tcClient.DeleteDeviceNotification(hSwitchNotify);

    tcClient.DeleteVariableHandle(hSwitchWrite);
    }
    catch (Exception ex)
    {
     MessageBox.Show(ex.Message);
    }
    tcClient.Dispose();
}

Das SPS Programm Machine_Final.pro sollte auf dem Laufzeitsystem 1 starten und das erstellte C#-Programm Machine.exe kann getestet werden.

Download:

Expression Blend Beispiel