RKS+CAN - Software / eigene Applikation

Hallo,

Ich habe Interesse am RKS+CAN Adapter und hätte dazu ein paar Fragen.

1. Mit welcher Software - abgesehen vom KCAN Monitor - kann ich das Kabel nutzen?

2. Ich möchte das Kabel für eine eigene Applikation nutzen.
Wie genau sieht die DLL aus? Welche API-Funktionen gibt es?
Habe ich die Möglichkeit in der DLL "dem Kabel" eine Benutzerdefinierte Adresse zu geben damit es z.B. wie ein selbst-entwickeltes Türsteuergerät arbeitet und unter dessen ID Nachrichten sendet?

lg
Gerald

Hallo Gerald,

Es gibt verschiedene Programme, die über die virtuelle serielle Schnittstelle angesprochen werden können. Details dazu können Sie gerne per privater Nachricht erfragen.
Explizite Programme für die Schnittstelle sind derzeit KCANMonitor und KOBD2Check.

Die Hardware bietet zwei USB-Schnittstellen.
- Virtuelle serielle Schnittstelle mit ASCII-Befehlssatz - USB-Schnittstellen-DLL, die entweder mit dem ASCII-Befehlssatz oder mit beliebigen Programmiersprachen verwendet werden kann, die DLLs einbinden und nutzen können.

Mit welcher Programmiersprache und/oder IDE möchtest du genau was realisieren?

Am Ende von http://www.canhack.de/viewtopic.php?t=137 findest du eine Beispielanwendung mit Visual C++ (Example.rar).
In diesem Fall könnte eine an der Schnittstelle angeschlossene Software die Funktionen deines Türsteuergeräts übernehmen.

Die API der Schnittstelle sieht wie folgt aus:

Zitat:

// RKS-USB.h : Hauptheader-Datei für die RKS-USB-DLL // #pragma once #ifndef __AFXWIN_H__ #fehler "Bitte 'stdafx.h' vor dieser Datei einbinden, um die Precompiled Header-Funktionalität zu nutzen." #endif // CAN-Rahmentypen #define FRAME_TYPE_NORMAL 0x1 #define FRAME_TYPE_RTR 0x2 #define FRAME_TYPE_NORMAL_EXT 0x3 #define FRAME_TYPE_RTR_EXT 0x4 #define FRAME_TYPE_ERR 0x5 // Datenstruktur für CAN. typedef struct } DWORD dwID; BYTE von DLC; BYTE abyData[8]; // Maximal 8 Databytes. } can_data_t; // Struktur für CAN-Fehlerinformationen typedef struct } BYTE byError; } kann_err_t; // CAN-Informationsstruktur typedef union } `can_data_t sData;` `can_err_t sErr;` } can_union_t; // Die endgültige CAN-Rahmenstruktur, die zum Senden/Empfangen verwendet wird. typedef struct } BYTE byType; DWORD dwTimeStamp; `can_union_t uFrm;` } can_msg_t; // DLL-Exporte // Initialisiert den USB-Treiber und öffnet eine Verbindung zur RKS+CAN-Hardware. Gibt TRUE bei Erfolg zurück. // Dieser Befehl muss einmal vor dem Aufruf jeder anderen RKS...-Funktion ausgeführt werden, außer... // RKSDeviceConnected. extern "C" __declspec(dllexport) BOOL RKSInitialize(void); // Kostenloser USB-Treiber und RKS+CAN-Hardware. Sollte aufgerufen werden, um die Schnittstelle/den Treiber freizugeben. extern "C" __declspec(dllexport) void RKSFree(void); // Überprüft, ob das RKS+CAN mit dem Computer verbunden ist. Gibt TRUE bei Erfolg zurück. pcBufIfGUID kann NULL sein. // Wenn pcBufIfGUID nicht NULL ist, wird die DeviceInterfaceGUID der RKS+CAN-Hardware dorthin kopiert. // Wenn Sie einfach nur prüfen möchten, ob RKS+CAN verbunden ist, wird empfohlen, es mit pcBufIfGUID = NULL aufzurufen. extern "C" __declspec(dllexport) BOOL RKSDeviceConnected(LPSTR pcBufIfGUID, DWORD dwBufSize); // Legt die Zeitüberschreitungen für das Lesen/Schreiben von Daten an die RKS+CAN-Schnittstelle fest. Die Software wartet maximal... // Gegebene Werte für Lese-/Schreiboperationen, um den Abschluss zu gewährleisten. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSSetTimeouts(DWORD dwMsTimeoutRead, DWORD dwMsTimeoutWrite); // Direkter Zugriff auf Hardware-USB-Kanäle (niedrigere Ebene). Nicht für den direkten Anwendungsgebrauch empfohlen, wenn Sie nicht wissen, was Sie tun. cpp extern "C" __declspec(dllexport) BOOL RKSReadPipe(PUCHAR pucBuffer, DWORD dwBufferLength, DWORD* pdwLengthTransferred, LPOVERLAPPED pOverlapped); // Direkter Zugriff auf Hardware-USB-Kanäle (niedrigste Ebene). Nicht für den direkten Anwendungsgebrauch empfohlen, wenn Sie nicht genau wissen, was Sie tun. extern "C" __declspec(dllexport) BOOL RKSWritePipe(PUCHAR pucBuffer, DWORD dwBufferLength, DWORD* pdwLengthTransferred, LPOVERLAPPED pOverlapped); // Liest Daten von der Hardware und verwendet den angegebenen Timeout-Wert als maximale Zeit, um die Operation abzuschließen. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSRead(PUCHAR pucBuffer, DWORD dwBufferLength, DWORD* pdwLengthTransferred); // Schreibt Daten auf die Hardware und verwendet den angegebenen Timeout-Wert als maximale Zeit, um die Operation abzuschließen. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSWrite(PUCHAR pucBuffer, DWORD dwBufferLength, DWORD* pdwLengthTransferred); // Ruft die Versionsnummer der RKS+CAN-Hardware ab. Gibt TRUE bei Erfolg zurück. cpp extern "C" __declspec(dllexport) BOOL RKSGetVersion(PUCHAR pucBuffer, DWORD dwBufferLength); // Ruft die Seriennummer der RKS+CAN-Hardware ab (aufgedruckt auf dem Kabelgehäuse). Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSGetSerial(PUCHAR pucBuffer, DWORD dwBufferLength); // Gibt die Zeit seit der Initialisierung des RKS-USB-Treibers zurück. `bReInit` kann verwendet werden, um den Wert auf Null zurückzusetzen. // Kann verwendet werden, um relativ genaue Zeitinformationen zu erhalten. Die Zeit wird in Sekunden zurückgegeben. extern "C" __declspec(dllexport) double RKSGetTimeSinceInit(BOOL bReInit = FALSE); // Ruft den Fehlerstatus der RKS+CAN-Schnittstelle in pbyStatus ab. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANGetLastStatus(BYTE* pbyStatus); // Setzt die RKS+CAN-Hardware in den reinen Empfangsmodus. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANSetListenOnly(BOOL bEnabled); // Set time stamp mode of the RKS+CAN hardware. 0, 1 oder 2. // Für mögliche Werte, siehe die ASCII-Schnittstellendokumentation. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANSetTimeStamp(BYTE byMode); // Ruft den Zeitstempel-Modus ab. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANGetTimeStamp(BYTE* pbyMode); // Ruft die Versorgungsspannung der RKS+CAN-Hardware ab. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANGetUb(DWORD* pdwVoltage_mV); // Setzt die Hardware-Filterung des CAN-Controllers von RKS+CAN. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANSetFilter(DWORD dwCode, DWORD dwMask); // Öffnet den CAN-Bus mit der gewünschten Übertragungsrate. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANOpen(DWORD dwBitrate); // Schließt den CAN-Bus. Gibt TRUE (WAHR) bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANClose(void); // Ruft eine CAN-Nachricht aus der Empfangswarteschlange ab. Die Funktion RKSCANOpen(...) muss vorher aufgerufen worden sein. // wurde bereits aufgerufen. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANRx(can_msg_t* pMsg); // Füge eine CAN-Nachricht zur Sendewarteschlange hinzu. `RKSCANOpen(...)` muss vorher aufgerufen werden. // wurde bereits aufgerufen. Gibt TRUE bei Erfolg zurück. extern "C" __declspec(dllexport) BOOL RKSCANTx(can_msg_t* pMsg);

Die eigenständige Ausführung von gespeicherten Programmen auf dem RKS+CAN ist geplant, macht aber derzeit aufgrund fehlender Ein-/Ausgangspins nur bedingt Sinn, da alle Eingaben entweder über CAN oder USB erfolgen müssten.

Viele Grüße, Rainer.

Hallo Rainer,

Danke für deine umfangreiche Antwort.

> Was genau mit welcher Programmiersprache bzw. IDE willst Du realisieren?
Das steht noch nicht fest. Microsoft Visual Studio mit C oder C++ wäre angedacht.

Auf jeden Fall möchte ich die Hardware für zwei Verwendungszwecke nutzen:
* Mit dem KCANMonitor CAN Nachrichten mitprotokollieren und eigene erstellen
* Eigene Applikation am PC
- Simulation eines Steuergerätes (z.B. in naher Zukunft für ein Uni-Projekt: Aufsperren der Türen über CAN-Bus)
- Entwicklung eigener Steuergeräte. Die Hauptfunktionalität auf der Kommunikationsebene sollte zuerst komfortabel in C implementiert werden. Die daraus generierte Funktionalität soll dann auf einen µController übertragen werden.

> Die selbständige Abarbeitung von gespeichterten Programmen auf dem RKS+CAN ist angedacht, macht aber zur Zeit wegen keinen I/O Pins nur bedingt Sinn, da alle Eingaben entweder über CAN oder USB kommen müssten.
Das würde z.B. Sinn machen um dem RKS+CAN eine Nachricht(ensequenz) abzuspeichern die in einem Intervall (z.B. 100ms) gesendet werden sollte.
Dann bräuchte man sich in der eigenen Applikation nicht mehr um die Einhaltung der Intervalle kümmern. Auf dem RKS+CAN wäre das kein Problem (sofern ihr noch genug freie Timer habt ).

lg
Gerald