Kithara »Serial Toolkit«

Das Base Module stellt vielfältige Werkzeuge bereit, z.B. Shared Memory für den Datenaustausch zwischen Anwendung und Kernel:

err = KS_createSharedMem(
        &pAppPtr,                // Application-Adresse
        &pSysPtr,                // Systemadresse des Speichers
        "MySharedMem",           // Global gültiger Name
        40 * MegaBytes,          // Länge in Bytes
        0);                      // Flags, hier 0

Zur Vereinfachung für regelmäßigen Datenaustausch ist eine Daten-Pipe ideal, die intern ebenfalls auf Shared Memory basiert:

err = KS_createPipe(
        &hPipe,                  // Adresse des Pipe-Handles
        "MyValuePipe",           // Name der Pipe
        2,                       // Datengröße (z.B. Messwerte)
        1000000,                 // max. Anzahl Datenelemente
        NULL,                    // reserviert
        0);                      // Flags, hier 0

Nun kann z.B. der Kernel ermittelte Messwerte in der Pipe ablegen:

err = KS_putPipe(
        hPipe,                   // Pipe-Handle
        valueBuffer,             // Zeiger auf Datenpuffer
        valueCount,              // Anzahl der Messwerte
        NULL,                    // hier nicht benutzt
        0);                      // Flags, hier 0

Die Anwendung kann nun die Messwerte aus der Pipe lesen:

err = KS_getPipe(
        hPipe,                   // Pipe-Handle
        buffer,                  // Zeiger auf Datenpuffer
        bufferSize,              // max. Größe des Puffers
        &filledSize,             // wieviel Werte gelesen?
        0);                      // Flags, hier 0

Daten mit variabler Länge (z.B. Messages) lassen sich optimal mit einer Message-Pipe verarbeiten. Diese ist sehr ähnlich zu verwenden.

Angenommen, Ihre Callback-Funktion für den Echtzeit-Timer sieht so aus:

int __stdcall myTimerCallback(
        void* pArgs,             // Adresse der Referenzdaten
        void* pContext);         // Adresse der Kontextdaten

Es gibt nun zwei Wege, um den Anwendercode auf die Kernel-Ebene zu bekommen:

err = KS_createCallBack(
        &hCallBack,              // Adresse des Handles
        myTimerCallback,         // Adresse der Funktion
        pSysAddrOfMyData,        // Referenzparameter
        KSF_KERNEL_EXEC,         // auf der Kernel-Ebene!
        0);                      // Anwendungspriorität, hier 0

Auf diese Weise wird die Funktion in den Kernel-Speicher geladen.

Alternativ lässt sich eine ganze DLL in den Kernel laden:

err = KS_loadKernel(
        &hKernel,                // Adresse des Handles
        "mykernel.dll",          // Dateiname der Kernel-DLL
        "myInitFunction",        // Name der Init-Routine
        pArgs,                   // Referenzparameter
        KSF_KERNEL_EXEC);        // Flags, in Kernel laden

Einmal in den Kernel geladen, kann nun ganz ähnlich ein Kernel-Callback erzeugt werden:

err = KS_createKernelCallBack(
        &hCallBack,              // Adresse des Handles
        hKernel,                 // Kernel-Handle
        "myTimerCallback",       // Name der Funktion
        pSysAddrOfMyData,        // Referenzparameter
        KSF_KERNEL_EXEC,         // auf der Kernel-Ebene!
        0);                      // Anwendungspriorität, hier 0

Die Callback-Handles lassen sich nun als Timer oder Interrupt-Handler anmelden oder z.B. zur Echtzeit-Signalisierung bei eintreffenden Ethernet-Frames.

Hinweis: Vollständige Projekte, die eine Rahmenanwendung in einer der Sprachen C++, C# oder Delphi sowie eine in den Kernel geladene DLL in C++ oder Delphi enthalten, sind Bestandteil jeder Software-Lieferung.

Wenn der direkte I/O-Port-Zugriff genutzt werden soll, ist zunächst der I/O-Bereich für den Direktzugriff freizuschalten:

err = KS_enableIoRange(
        myBaseAddress,           // Basisadresse der Hardware
        8,                       // Anzahl der I/O-Register
        KSF_SIZE_8_BIT);         // Flags, hier byte-weise

Nun können die freigegebenen Hardware-Register direkt adressiert werden:

byte value = KS_inpb(
        myBaseAddress + 2);      // Adresse, 1 Byte lesen
...                              // Byte auswerten
KS_outpb(
        myBaseAddress + 4,       // Adresse, 1 Byte schreiben
        value);                  // Byte schreiben

Wenn die I/O-Basisadresse einer PCI-Karte vom Plug&Play-Manager dynamisch vergeben wurde, kann diese ganz leicht ermittelt werden, indem entweder alle PCI-Baugruppen durchsucht werden, bis die gewünschte (anhand Vendor- und Device-ID) gefunden wird:

err = KS_getBusData(
        &pciData,                // Adresse der PCI-Struktur
        busNumber,               // Bus-Nummer
        slotNumber,              // Gerätenummer und Funktion
        0);                      // Flags, hier 0
if (pciData.vendorID == XXXX && pciData.deviceID == YYYY)
  ...

Oder es wird sofort die gewünschte ID-Kombination gesucht:

err = KS_getRessourceInfo(
        "PCI\\VENxxxx&DEVyyyy",  // ID-Kombination
        &resourceInfo);          // Adresse der Resourcen-Info

Die erhaltenen Datenstrukturen enthalten nun die benötigten Angaben über Interrupt-Leitung und benutzte I/O- oder Speicher-Basisadressen.

Verwenden Sie folgende Funktion, um alle COM-Ports aufzulisten:

err = KS_enumDevices(
        "COM",                   // nach COM-Ports suchen
        i,                       // Zähler, mit 0 beginnend
        portNameBuf,             // Puffer für COM-Port-Namen
        0);                      // Flags, hier 0

Die Schnittstelle lässt sich dann wie folgt öffnen:

KSResourceInfoEx info;
err = KS_openSerialPort(
        &hPort,                  // Adresse des Handles
        portNameBuf,             // Name des Ports (z.B. "COM1")
        "9600,n,8,1",            // Initialisierung
        KSF_KERNEL_EXEC);        // Kernel-Implementierung

So senden wir Daten, z.B. eine Messwertanforderung an eine Gerät:

err = KS_xmitPort(
        hPort,                   // Port-Handle
        NULL,                    // Signalisierung (Post Mode)
        message,                 // Pufferadresse
        0,                       // Länge, zu senden (auto)
        NULL,                    // Länge, gesendet
        KSF_DONT_WAIT);          // Flags: ohne Blockierung

Jederzeit lässt sich ermitteln, wie viele Zeichen bereits empfangen wurden:

err = KS_getPortState(
        hPort,                   // Port-Handle
        &state,                  // Adresse der Status-Struktur
        0);                      // Flags: here 0
printf("Es wurden %d Zeichen empfangen.\n", state.recvAvail);

Der Empfang kann folgendermaßen aussehen (im Wait-Mode auf der Anwendungsebene):

err = KS_recvPort(
        hPort,                   // Port-Handle
        NULL,                    // Signalisierung (Wait Mode)
        pBuffer,                 // Adresse des Datenpuffers
        state.recvAvail,         // Länge, zu empfangen
        &received,               // Länge, empfangen
        KSF_USE_TIMEOUTS);       // Flags: Timeout-Überwachung