IOW40 Tasterabfrage (P0.0) C#

[metal-warrior]

Ich versuche schon seit mehreren Stunden den Taster an Port 0.0 in C# abzufragen aber komme auf keinen grünen Zweig. Könnte mir jemand ein Quelltextbeispiel schreiben, mit dem ich den Taster abfragen kann?

[Rumo]

Hallo metal-warrior,

ich habe hier die frühe Version einer Wrapper-Klasse, die ich unter C# nutze um die iowkit.dll von Robert Marquardt einzubinden. Das klappt wunderbar. Wenn Du mit der Doku Probleme hast, dann melde Dich halt nochmal. Die Funktionen sind so alle direkt aus C# ( also der CLR ) nutzbar. Die Geschwindigkeit ist anständig, die Zugriffe sicher. Um ganz sicher zu gehen, solltest Du natürlich mit try-catch-Blöcken arbeiten.

Lese die Doku über die iowkit.dll gründlich durch und du weißt, welche Parameter Du den einzelnen Funktionen übergeben musst. Wichtiger Hinweis: Geöffnete Geräte immer vorm Beenden der Anwendung wieder schließen ! Viel Erfolg.

Marc

Code: Select all

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace CustomTools.USB.IOWarrior
{
    /// <summary>
    /// Die Klasse IowKitFunctions kapselt die Funktionen der IowKit.dll. IowKit.dll wird
    /// von der Firma Codemercenaries bereitgestellt und wurde von Robert Martin Marquardt 
    /// entwickelt.
    /// </summary>
    public static class IowKitFunctions
    {
        /// <summary>
        /// Die Metode IowKitOpenDevice öffnet alle am USB erkannten IO-Warrior-Bausteine
        /// und liefert ein Handle für den zuerst gefundenen IO-Warrior zurück.
        /// </summary>
        /// <returns>Handle für IO-Warrior oder null bei Misserfolg.</returns>
        [DllImport("iowkit.dll")]
        public static extern IntPtr IowKitOpenDevice();
        /// <summary>
        /// Die Methode IowKitCloseDevice schließt den IO-Warrior der durch das 
        /// gegebene Handle kontrolliert wird. 
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        [DllImport("iowkit.dll")]
        public static extern void IowKitCloseDevice(IntPtr IowHandle);
        /// <summary>
        /// Fordert die Produkt-Identität (PID) des IO-Warrior Bausteines ab,
        /// der durch das gegebene Handle kontrolliert wird.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitGetProductId(IntPtr IowHandle);
        /// <summary>
        /// Zählt und nummeriert die am USB angeschlossenen IO-Warrior Bausteine.
        /// </summary>
        /// <returns></returns>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitGetNumDevs();
        /// <summary>
        /// Die Methode IowKitGetDeviceHandle arbeitet liefert zu dem Gerät mit
        /// der angegebenen Nummer ein gültiges Handle. Vorrausgesetzt, das Gerät
        /// mit der Nummer existiert. 
        /// IowKitGetDeviceHandle funktioniert nur nach einem erfolgreichen Aufruf
        /// von IowKitDeviceOpen. Erst dann sind alle Bausteine nummeriert.
        /// </summary>
        /// <param name="numDevice">Nummer des zu öffnenden Gerätes.</param>
        /// <returns>Ein gültiges Handle für das Gerät oder 0 bei Misserfolg.</returns>
        [DllImport("iowkit.dll")]
        public static extern IntPtr IowKitGetDeviceHandle(UInt32 numDevice);
        /// <summary>
        /// Liefert die Version der IoWarrior-Firmaware zurück. Die oberen 2 Byte sind immer 0.
        /// Es sind 4 Hex-Stellen gültig. Wäre die gegenwärtige Softwareversion 1.0.2.1 so wird
        /// 0x1021 zurückgegeben. Ältere IO-Warrior, die keine eigene Seriennummer haben, liefern
        /// eine Versionsnummer kleiner 1.0.1.0 zurück.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <returns>Die Softwareversion des IO-Warriors oder 0, wenn kein gültiges 
        /// Handle übergeben wurde.</returns>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitGetRevision(IntPtr IowHandle);
        /// <summary>
        /// Liest die Seriennummer aus dem durch ein gültiges Handle gesteuerten IO-Warrior
        /// heraus.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="SnTarget">Verweis auf ein Datenfeld, dass die Seriennummer speichert.
        /// Der Stringbuilder muss zuvor instanziert worden sein.</param>
        /// <returns>True, wenn die Seriennummer erfolgreich im angegebenen Datenfeld abgelegt
        /// werden konnte. False, wenn das Handle ungültig war, der IO-Warrior keine Seriennummer
        /// hat oder das Abspeichern der Nummer im übergebenen Ziel fehlgeschlagen ist.</returns>
        [DllImport("iowkit.dll", CharSet=CharSet.Unicode)]
        public static extern bool IowKitGetSerialNumber(IntPtr IowHandle, 
                                                         StringBuilder SnTarget);
        /// <summary>
        /// Liest Daten vom IO-Warrior. Die Funktion blockiert den aufrufenden Thread bis 
        /// eine Änderung an den Eingängen des IO-Warriors durch den Baustein regisriert wird.
        /// Ein nicht blockierendes Lesen kann über den Aufruf von IowKitReadNonBlocking()
        /// erfolgen. 
        /// Die Daten kommen in Form eines Reports an. Nähere Beschreibung der Reports ist
        /// im Datenblatt des jeweiligen IO-Warriors zu finden.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="numPipe">Datenkanal, aus dem gelesen werden soll. Reicht von 0 
        /// bis IOWKIT_MAX_PIPES-1</param>
        /// <param name="buffer">Ziel für Ablage der Daten.</param>
        /// <param name="Length">Anzahl der einzulesenden Bytes.</param>
        /// <returns>Anzahl tatsächlich eingelesener Bytes oder 0 bei Misserfolg.</returns>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitRead(IntPtr IowHandle,
                                                UInt32 numPipe,
                                                byte[] buffer,
                                                UInt32 Length);
        /// <summary>
        /// Liest Daten vom IO-Warrior. Der aufrufende Thread wird nicht blockiert, wenn 
        /// keine Daten zur Verfügung stehen, also keine Änderung an den Eingängen des
        /// IO-Warriors stattgefunden hat.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="numPipe">Datenkanal, aus dem gelesen werden soll. Reicht von 0 
        /// bis IOWKIT_MAX_PIPES-1</param>
        /// <param name="buffer">Ziel für Ablage der Daten.</param>
        /// <param name="Length">Anzahl der einzulesenden Bytes.</param>
        /// <returns>Anzahl tatsächlich eingelesener Bytes oder 0 bei Misserfolg.</returns>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitReadNonBlocking(IntPtr IowHandle,
                                                           UInt32 numPipe,
                                                           byte[] buffer,
                                                           UInt32 Length);
        /// <summary>
        /// Liest den Pinstatus der Eingänge des angeschlossenen IO-Warriors direkt aus.
        /// Die Funktion gibt True zurück, wenn zuvor eine Änderung an den Pins durch den
        /// Baustein registriert wurde. Gleichzeitig is im Ziel-Datenfeld ein Abbild der
        /// Eingänge als Wert verfügbar.
        /// Achtung!!: Diese Funktion arbeitet nicht mit dem IO-Warrior 56 zusammen. Der
        /// Baustein gibt mehr als 32-Bit zurück.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="IoPinStatus">Ziel-Datenfeld für das Abspeichern der Pin-Zustände.</param>
        /// <returns>True bei Erfolg, False wenn keine neuen Daten erfasst wurden oder 
        /// das übergebene Handle nicht funktioniert.</returns>
        [DllImport("iowkit.dll")]
        public static extern bool IowKitReadImmediate(IntPtr IowHandle,
                                                      byte[] IoPinStatus);
        /// <summary>
        /// Legt die Grenze für eine Zeitüberschreitung beim Lesezugriff auf den IO-Warrior fest.
        /// Ein Timeout während einer laufenden, noch nicht beendeten Leseaktion führt zu 
        /// Datenverlust (Reports gehen verloren). IowKitRead() schlägt fehl, wenn nicht innerhalb
        /// der gegebenen Grenze Daten vom IO-Warrior eingelesen werden können.
        /// Bei Zeitüberschreitung müssen alle vor bis zu dem Zeitpunkt bereits gesendeten
        /// aber noch nicht ausgeführten Aktionen erneut übermittelt werden (z.B. I2C-Bus schreiben
        /// oder lesen).
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="Timeout">Grenze für Zeitüberschreitung in Millisekunden. Empfohlen in 
        /// der iowkit.dll-Beschreibung sind 1000ms oder mehr.</param>
        /// <returns>True bei Erfolg oder False bei Fehlschlag.</returns>
        [DllImport("iowkit.dll")]
        public static extern bool IowKitSetTimeout(IntPtr IowHandle,
                                                    UInt32 Timeout);
        
        /// <summary>
        /// Legt die Grenze für eine Zeitüberschreitung beim Schreibzugriff auf den IO-Warrior fest.
        /// IowKitWrite() schlägt fehl, wenn Daten nicht innerhalb der vorgegebenen Grenze geschrieben
        /// werden können. Schreibfehler sind untypisch. Verbindungen und Hardware näher prüfen,
        /// wenn Fehler auftreten.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="Timeout">Grenze für Zeitüberschreitung in Millisekunden. Empfohlen in 
        /// der iowkit.dll-Beschreibung sind 1000ms oder mehr.</param>
        /// <returns>True bei Erfolg oder False bei Fehlschlag.</returns>
        [DllImport("iowkit.dll")]
        public static extern bool IowKitSetWriteTimeout(IntPtr IowHandle,
                                                         UInt32 Timeout);

        /// <summary>
        /// Beendet alle laufenden Datentransferaktionen auf dem angegebenen Datenkanal(Pipe).
        /// Der Einsatz dieser Methode erfordert im Regelfall einen eigenen Thread, da eine
        /// beipsielsweise laufende IowKitRead()-Funktion den aufrufenden Thread blockiert,
        /// bis eine Rückgabe empfangen werden konnte.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="numPipe">Nummer des Datenkanals.</param>
        /// <returns>True bei Erfolg, sonst false.</returns>
        [DllImport("iowkit.dll")]
        public static extern bool IowKitCancelIo(IntPtr IowHandle,
                                                  UInt32 numPipe);

        /// <summary>
        /// Schreibt "length" Bytes in den durch "numPipe" angegebenen Datenkanal des IO-Warriors.
        /// Wird etwas anderes als ein gültiger Report, bestehend aus einer korrekten Anzahl von 
        /// Bytes und einer vom gewählten Datenkanal akzeptierten Report-ID, gesendet, schlägt
        /// die Funktion fehl.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <param name="numPipe">Datenkanal, der beschickt werden soll.</param>
        /// <param name="buffer">Puffer, der die zu schreibenden Daten bereistellt.</param>
        /// <param name="length">Anzahl zu schreibender Bytes.</param>
        /// <returns>Bei erfolgreicher Durchführung ist die Anzahl geschriebener = 
        /// Anazahl zu schreibender Bytes.</returns>
        [DllImport("iowkit.dll")]
        public static extern UInt32 IowKitWrite(IntPtr IowHandle,
                                                 UInt32 numPipe,
                                                 byte[] buffer,
                                                 UInt32 length);

        /// <summary>
        /// Gibt den Handle des Threads zurück, der zum Lesen der I/O-Pins des
        /// IO-Warriors genutzt wird. Linux nutzt keie Threads um die Funktionen
        /// des IO-Warriors einzubinden und gibt daher immer 0 zurück.
        /// </summary>
        /// <param name="IowHandle">Gültiges Handle zum IO-Warrior.</param>
        /// <returns>Handle für den laufenden Thread oder 0 bei Misserfolg.</returns>
        [DllImport("iowkit.dll")]
        public static extern IntPtr IowKitGetThreadHandle(IntPtr IowHandle);

        /// <summary>
        /// Gibt die Version der iowkit.dll als string zurück.
        /// </summary>
        /// <returns>String mit der Versionsangabe.</returns>
        [DllImport("iowkit.dll")]
        public static extern string IowKitVersion();

        /// <summary>
        /// Öffnet einen IOWarrior40 dessen Firmware Revision älter 1.0.1.0 ist. Diese 
        /// Bausteine haben keine Seriennummer die ausgelesen werden kann. 
        /// </summary>
        /// <param name="legacyOpenMode">Simple oder Complex-Mode.</param>
        /// <returns>True bei Erfolg sonst false.</returns>
        [DllImport("iowkit.dll")]
        public static extern bool IowKitSetLegacyOpenMode(UInt32 legacyOpenMode);

        /// <summary>
        /// Liefert den zuletzt aufgetretenen Fehler zurück, der vom Kernel 
        /// registriert worden ist.
        /// </summary>
        /// <returns>Bei Fehlerfall eine Zahl ungleich 0.</returns>
        [DllImport("kernel32.dll")]
        public static extern uint GetLastError();

       
    }
}

[metal-warrior]

danke für die schnelle Antwort aber leider ist damit mein problem noch nicht gelöst

hätte mir jemand vielleicht ein konkretes beispiel dass ich direkt einbinden könnte um zu sehen ob es funktioniert

[friend-of-rq]

Hallo metal-warrior,

wenn Du nur erstmal testen willst ob eine Schaltung läuft.

Hab da was für Dich, ein Testprogramm ALL-in-ONE.

www.greinert-dud.de

mfg
R.Greinert

[Rumo]

Bei dem folgenden Beispiel gehe ich von dem Code aus, den ich in der zuvor geposteten Wrapper-Klasse verwendet habe.

Code: Select all

IntPtr IowHandle = CustomTools.USB.IOWarrior.IowKitFunctions.IowKitOpenDevice();
            if (IowHandle != IntPtr.Zero)
            {
                byte[] Iow40IoReport = new byte[5]; // Report ID + 4 Bytes für Portdaten. ReportID an [0]
                
                // Liest direkt den aktuellen Pin-Status des IO-Warriors.
                if(CustomTools.USB.IOWarrior.IowKitFunctions.IowKitReadImmediate(IowHandle, Iow40IoReport))
                {
                    // Aktion nach Einlesen des Reports.      
                }
            }

Dieses Beispiel sollte wie folgt arbeiten:

Nach öffnen des IO-Warriors sollte ein gültiges Handle im Datenfeld IowHandle zur Verfügung stehen (also ungleich 0). Dieses Handle kann dann verwendet werden, um direkt vom IOW40 die Pin-Zustände zu erfragen. Die Funktion ReadImmediate() gibt True zurück, wenn sich an den Leitungen des IO-Warriors etwas geändert hat. Die Daten selbst befinden sich dann in Iow40IoReport.

Hier eine andere Variante:

Code: Select all

IntPtr IowHandle = CustomTools.USB.IOWarrior.IowKitFunctions.IowKitOpenDevice();
            if (IowHandle != IntPtr.Zero)
            {
                byte[] Iow40IoReport = new byte[5]; // Report ID + 4 Bytes für Portdaten. ReportID an [0]

                if (CustomTools.USB.IOWarrior.IowKitFunctions.IowKitRead(IowHandle,
                                                                        0,
                                                                        Iow40IoReport,
                                                                        (uint)Iow40IoReport.Length) ==
                                                                        (uint)Iow40IoReport.Length)
                {
                    // Aktionen nach Einlesen des Ports ausführen...
                }
            }

Beim zweiten Beispiel wird die Funktion IowKitRead verwendet. Angenommen, du hast den Io-Warrior eingesteckt und Deinen Taster angeschlossen, aber noch nicht gedrückt, dann verharrt dein Programm solange in diesem Code-Teil (Bei Aufruf der Read-Funktion), bis es eine Änderung an den IO-Pins gegeben hat. Du drückst also den Taster und das Programm wird weiter ausgeführt. Da der Io-Warriror alle Leitungen "überwacht", bekommst Du in einem Report die Zustände aller Leitungen auf einmal zurück.

Möchtest Du nicht, dass Dein Programm an der Stelle stehen bleibt, dann rufst Du die Funktion IowKitReadNonBlocking() auf. Ich hoffe, dass Du hiermit weiterkommst.

Marc

[metal-warrior]

Danke für die schnelle Hilfe. Rumo deine Wrapper-Klasse hat mir sehr geholfen. Jetzt bleibt mir nur noch eine Frage:
Gibt es die Möglichkeit nur einen Port bzw. ein Bit eines Ports zu beschreiben ohne die anderen Ports auch wieder neu beschreiben zu müssen.

danke für eure Beteiligung und Hilfe

[towaibw]

Die gibt es nicht. Der entsprechende Report bedient alle Pins/Ports des IO-Warrior zur selben Zeit. Da hilft wohl nur das Zwischenspeichern des Pin-Zustandes in der Applikation.

Thomas

Reklame: Bei IOWJ (High-Level Interface für Java) gibt es natürlich Methoden, um nur einzelne Pins zu manipulieren. Aber unter der Haube wird sich der Status in der Klasse IowPort gemerkt.

[knarf]

Hallo,

wir haben das mehr Beispiel samt Wrapper mehr oder weniger erfolgreich getestet.
Leider kann ich das Bytearray zwar ändern, aber bei write wird nix geschrieben.

Wäre vielleicht jemand so nett und schreibt uns mal die eine oder zwei Zeilen Code auf, wie wir mit write bspw. die interne LED an Port 0.3 (beim IOW24) anschalten können?

Das würde uns ungemein weiter bringen!

Viele Grüße

[metal-warrior]

Hallo knarf

um einigermaßen gut mit dem IOW arbeiten zu können benötigst du die iowkit.dll und die IOW.NET.dll wenn du diese beiden DLLs dann kannst du einfacher auslesen und auch schreiben sonst hab ich dir hier nur was mit dem man auf dem IOW40 das licht an macht

{
int ioHandle = IOWarrior.IOWLib.IowKitOpenDevice();
int err;

byte[] byary = new byte[5];
byary[0] = 0x00; //ReportId
byary[1] = 0xff; //Port 0-3
byary[2] = 0xff;
byary[3] = 0xff;
byary[4] = 0x00; //PORT 3 LED´s mit HEX unterschiedliche Leuchtmuster z.B. 55h 0 10101010 || FFh = 00000000 || 00h = 11111111
err = IOWarrior.IOWLib.IowKitWrite(ioHandle, 0, ref byary[0], byary.Length);


IOWarrior.IOWLib.IowKitCloseDevice(ioHandle);
}

Wünsch dir viel spaß beim ausprobieren