2 LIN-CAN-RS232-Gateway API (L2CAPI)

Transcrição

Handbuch
LIN2CAN API (L2CAPI)
The expert for industrial and automotive communication
IXXAT
Hauptsitz
IXXAT Automation GmbH
Leibnizstr. 15
D-88250 Weingarten
Geschäftsbereich USA
IXXAT Inc.
120 Bedford Center Road
USA-Bedford, NH 03110
Tel.: +49 (0)7 51 / 5 61 46-0
Fax: +49 (0)7 51 / 5 61 46-29
Internet: www.ixxat.de
e-Mail: [email protected]
Phone: +1-603-471-0800
Fax: +1-603-471-0880
Internet: www.ixxat.com
Support
Sollten Sie zu diesem, oder einem unserer anderen Produkte Support benötigen, wenden Sie sich bitte schriftlich an:
Fax: +49 (0)7 51 / 5 61 46-29
Copyright
Die Vervielfältigung (Kopie, Druck, Mikrofilm oder in anderer Form) sowie
die elektronische Verbreitung dieses Dokuments ist nur mit ausdrücklicher,
schriftlicher Genehmigung von IXXAT Automation erlaubt. IXXAT Automation behält sich das Recht zur Änderung technischer Daten ohne vorherige
Ankündigung vor. Es gelten die allgemeinen Geschäftsbedingungen sowie
die Bestimmungen des Lizenzvertrags. Alle Rechte vorbehalten.
Handbuchnummer: 4.01.0130.10100
Version: 1.5
Inhalt
1
Einleitung....................................................................................5
2
LIN-CAN-RS232-Gateway API (L2CAPI)........................................6
2.1 Prinzip ................................................................................. 6
2.2 Erstellen des API Objekts .................................................... 6
2.3 Übersicht Interfaces ............................................................ 7
2.4 Interface IUnknown ............................................................ 8
2.5 Interface ILIN2CAN_API_Ctrl ............................................... 9
2.6 Interface ILIN2CAN_GeneralConfig2................................. 10
2.7 Interface ILIN2CAN_GatewayConfig2 ............................... 12
2.8 Interface ILIN2CAN_SlaveConfig ....................................... 14
2.9 Interface ILIN2CAN_MasterConfig2 .................................. 15
2.10 Interface ILIN2CAN_LINMsgQueue2 .............................. 16
2.10.1 Fehlerübersicht....................................................................17
2.11
2.12
2.13
Interface ILIN2CAN_Master_Slave2 ............................... 18
Übersicht: Erlaubte API- Aufrufe / Betriebsart .............. 19
API Kurzübersicht .......................................................... 20
2.13.1
2.13.2
2.13.3
2.13.4
2.13.5
2.13.6
2.13.7
Interface: ILIN2CAN_GeneralConfig2....................................20
Interface: ILIN2CAN_GatewayConfig2 ..................................22
Interface: ILIN2CAN_SlaveConfig .........................................23
Interface: ILIN2CAN_MasterConfig2.....................................23
Interface: ILIN2CAN_LINMsgQueue2....................................24
Interface: ILIN2CAN_Master_Slave2 .....................................25
Datentypen Definitionen......................................................26
Copyright IXXAT Automation GmbH
3
L2C-API Handbuch V1.5
Einleitung
1 Einleitung
Die LIN 2 CAN Gateway API (kurz: L2CAPI) dient als Schnittstelle zur Konfiguration und Steuerung der LIN 2 CAN Gateway Hardware und zum Zugriff auf den
LIN- Nachrichtenverkehr. Über die LIN2CAN Gateway API sind alle Funktionen des
LIN2CAN- Gerätes in eigenen Applikation verwendbar. (Siehe hierzu auch Handbuch LIN2CAN- Gateway) Spezifische Testapplikationen oder auch PC- gestützte
Netzwerksimulationen können realisiert werden. Darüber hinaus kann das
LIN2CAN- Gerät mit der L2CAPI auch als Entwicklungsplattform genutzt werden.
Die Funktionen wurden in Funktionsgruppen zusammengefasst welche in Funktionsart bzw. Betriebsart zusammengehören.
5
LIN-CAN-RS232-Gateway API (L2CAPI)
2 LIN-CAN-RS232-Gateway API (L2CAPI)
2.1
Prinzip
Der Aufbau der API entspricht dem eines COM Objekts. Die API ist in Interfaces
unterteilt und besitzt einen Referenzzähler der zur Freigabe der API dient. Wird
ein Interface angefragt so wird der Zähler um eins erhöht. Wird ein Interface
nicht mehr benötigt so muss es mit Release freigegeben werden. Fällt der Zähler
dabei auf 0 so wird das L2CAPI Objekt gelöscht. Dazu ist jedes Interface von dem
Interface IUnknown abgeleitet. Dieses Interface enthält die Methoden QueryInterface, AddRef und Release.
Jede Methode der API (außer AddRef und Release) geben als Fehlercode einen
HRESULT Wert zurück. S_OK (0) steht dabei für Erfolg.
2.2
Erstellen des API Objekts
Um mit der API arbeiten zu können, werden folgende Dateien benötigt:
• L2CAPI.lib
• L2CAPI.dll
• L2CAPI.hpp
Die LIB Datei muss in das zu erstellende Programm eingebunden werden. Diese
lädt dann beim Programmstart die DLL Datei nach. In der HPP Datei sind die Methoden der API definiert.
Zusätzlich muss in einer CPP Datei des Projektes die Zeile #define INITGUID stehen
und die L2CAPI.hpp einbinden. Diese dient dazu Speicherbereich für die GUIDs
(Global Unique Identifiers) bereitzustellen. Jedes Interface der API besitzt eine dieser 128bit IDs zur Eindeutigen Bestimmung.
Als erstes muss mit L2CAPI_CreateInstance() das API Objekt erstellt werden. Als
Übergabeparameter werden die ID für das gewünschte Interface und einen Zeiger
für die Rückgabe des Interfaces übergeben. Der Aufruf sieht dann wie folgt aus:
HRESULT hResult = E_FAIL;
IUnknown* pIUnknown = NULL;
hResult = L2CAPI_CreateInstance(IID_IUnknown, (void**)&pIUnknown);
Bei Erfolg kann nun mit diesem Interfacezeiger jedes andere Interface der API abgerufen werden. War das Erstellen nicht erfolgreich so kann mit dem Aufruf
L2CAPI_FormatError() der Fehlercode in einen lesbaren String gewandelt werden.
Wird das Interface nicht mehr benötigt so wird dieses durch folgenden Aufruf
wieder freigegeben.
if(pIUnknown != NULL)
{
pIUnknown->Release();
pIUnknown = NULL;
}
6
Für den leichteren Einstieg in den Entwurf eines eigenes Programms wird ein Beispielprojekt (L2CAPI_CONSOLE_APP) und ein Vorlagenprojekt (L2CAPI_AppTemplate) mitgeliefert.
2.3
Übersicht Interfaces
Die API implementiert folgende Interfaces:
• ILIN2CAN_API_Ctrl
Dient dazu die API mit dem Device zu verbinden bzw. die Verbindung
zu trennen und den Verbindungsstatus abzufragen.
• ILIN2CAN_GeneralConfig2
Dient dazu die Grundsächlichen Einstellungen des Gerätes wie Name,
LIN Baudrate und Startup Operation abzufragen bzw. einzustellen.
• ILIN2CAN_GatewayConfig2
Dient dazu die für den Gateway-Modus nötigen Einstellungen vorzunehmen. Darunter fallen die CAN Baudrate und der CAN Transceivermode
und die Translation Tabelle für die Übersetzung der LIN in CAN Objekte und Umgekehrt.
• ILIN2CAN_SlaveConfig
Mit diesem Interface werden die Antworten auf die LIN Identifier festgelegt.
• ILIN2CAN_MasterConfig2
Hiermit wird die Schedule Tabelle für die Master Betriebsart festgelegt.
• ILIN2CAN_LINMsgQueue2
Dient dazu Nachrichten aus der LIN Nachrichten Queue auszulesen
und den LIN Queuestatus abzufragen.
• ILIN2CAN_Master_Slave2
Mit diesem Interface ist es möglich LIN IDs und LIN Objekte auf den
LIN Bus per PC Aufruf zu legen. Zusätzlich besteht die Möglichkeit ein
Wakeup Signal auf den LIN- Bus aufzuschalten.
Generell dürfen die Methoden der Interfaces nur dann aufgerufen werden, falls
sich das Gerät entweder im L2C_OP_MODE_SLAVE_PC oder im
L2C_OP_MODE_MASTER_PC Modus befindet!!!
7
2.4
Interface IUnknown
Dieses Interface besitzt folgende Methoden:
• HRESULT QueryInterface([in] REFIID riid, [out] LPVOID *ppvObj)
Mit QueryInterface kann eines der in 2.3 angegeben Interfaces angefragt werden. Der Aufruf ist gleich wie L2CAPI_CreateInstance nur das
hier keine neue Instanz der Klasse angelegt wird sondern ein Zeiger
des gewünschten Interfaces zurückgegeben wird. Durch den Aufruf
von QueryInterface wird der Referenzzähler automatisch um eins erhöht.
• ULONG AddRef()
AddRef dient dazu den Referenzzähler des Objektes um eins zu erhöhen. Der Rückgabewert ist der neue Stand des Referenzzählers. Dieser
Methode muss aufgerufen werden falls ein Interfacezeiger selbst geklont wird.
• ULONG Release()
Mit Release wird ein nicht mehr benötigtes Interface wieder freigegeben. Der neue Referenzzählerstand wird zurückgegeben.
8
2.5
Interface ILIN2CAN_API_Ctrl
In diesem Interface sind folgende Methoden enthalten:
• Connect([in] PCHAR pszName, [in] PCHAR pszMode)
Mit Connect verbindet sich die API per angegeben Schnittstelle mit
dem Device. In pszName wird der Name der zu benutzenden Schnittstelle angegeben z.B. „COM1“ oder „COM2“. In pszMode muss immer
„baud=115200 parity=N data=8 stop=1“ übergeben werden. War
der Verbindungsaufbau erfolgreich so wird S_OK zurückgegeben, ansonsten ein Fehlercode, der mit L2CAPI_FormatError() in einen lesbaren
String verwandelt werden kann.
• Disconnect()
Mit Disconnect wird die Verbindung zum Device wieder abgebaut.
• IsConnected()
Mit IsConnected kann abgefragt werden ob das Gerät noch verbunden
ist. Dies Funktion überprüft den Status der DSR Leitung. Somit kann
auch ein Ausstecken des Gerätes während des Betriebes erkannt werden.
9
2.6
Interface ILIN2CAN_GeneralConfig2
Folgende Methoden sind hierin implementiert:
• GetDeviceName([out] PSTRING psDeviceName)
• SetDeviceName([in] PSTRING psDeviceName)
Get/SetDevicename dienen dazu dem Gerät einen Namen zu geben. Es
sind 16 Zeichen erlaubt einschließlich „\0“.
• GetVersionInformation([out] PL2C_VersionInformation pVersionInfo);
Mit GetVersionInformation werden die Versionsinformationen des Gerätes angefragt. Die Struktur hat dabei folgenden Aufbau:
struct
{
char strFirmwareVersion[8];
char strHardwareVersion[8];
}L2C_VersionInformation, *PL2C_VersionInformation;
•
•
•
•
•
•
•
•
Wobei jeder String mit 0 terminiert ist.
GetLINBaudrate([out] PWORD pwBaudrate);
SetLINBaudrate([in] WORD wBaudrate);
Mit Get/SetLINBaudrate wird die Baudrate des LIN Busses festgelegt.
Folgende Werte sind möglich: 2400, 9600 und 19200 Baud.
GetOperationMode([out] PL2C_OperationMode pnOperationMode);
SetOperationMode([in] L2C_OperationMode nOperationMode);
Hiermit wird die aktuelle Betriebsart des Geräts festgelegt. Dabei sind
folgende Modi zulässig:
L2C_OP_MODE_SLAVE_PC
L2C_OP_MODE_MASTER_PC
GetStartUpOpMode([out] PL2C_OperationMode pnOperationMode);
SetStartUpOpMode ([in] L2C_OperationMode nOperationMode);
Mit diesen Funktionen wird das Startup verhalten des Gerätes festgelegt, falls beim Einschalten des Gateways das serielle Kabel zum PC
nicht angeschlossen ist. Folgende Startup Operation Modi sind zulässig:
L2C_OP_MODE_SLAVE
L2C_OP_MODE_MASTER
L2C_OP_MODE_GATEWAY_SLAVE
L2C_OP_MODE_GATEWAY_MASTER
GetStandbyTime([out] PWORD pwStandbyTime);
SetStandbyTime([in] WORD wStandbyTime);
Hiermit kann festgelegt werden, nach welcher Zeit in Sekunden sich
das Gerät ohne Busverkehr (LIN und CAN) in den Energiesparmodus
10
•
•
•
•
schaltet. Ist das Gerät am PC angeschlossen bleibt es immer „wach“.
Wird der Wert 0xFFFF übergeben so geht das Gerät nie in den Standby
Modus.
GetSystemTime([out] PDWORD pdwSystemTime);
SetSystemTime([in] DWORD dwSystemTime);
Diese Funktionen dienen dem Setzen und Abfragen der Systemzeit des
Gerätes. Die Systemzeit ist ein Zählerwert in Millisekunden der für die
Bildung des Zeitstempel für die LIN Nachrichten benutzt wird.
GetLinMessageConfig ([out] PL2C_MessageConfig pMsgConfig);
SetLinMessageConfig ([in] PL2C_MessageConfig pMsgConfig);
Mit diesen beiden Funktionen werden die Längen und die CRC Berechnungsmodi der LIN Nachrichten festgelegt bzw. abgefragt. Dazu wird
folgende Struktur verwendet:
struct
{
BYTE
bMsgLen[64];
L2C_MessageCrcType nMsgCrcType[64];
}L2C_MessageConfig, *PL2C_MessageConfig;
• LoadSettingsFromFlash();
Hiermit werden die Einstellung aus den Flash ausgelesen. Noch nicht
gespeicherte Einstellungen gehen dabei verloren.
• SaveSettingsToFlash;
Hiermit werden die aktuellen Einstellungen nicht flüchtig in Flash gespeichert. Dies betrifft die Einstellungen von GeneralConfig (ohne Systemzeit), GatewayConfig, SlaveConfig und MasterConfig.
11
2.7
Interface ILIN2CAN_GatewayConfig2
Hierin können folgende Einstellungen vorgenommen werden:
• GetCANConfig([out] PL2C_CAN_Config pCANConfig);
• SetCANConfig([in] PL2C_CAN_Config pCANConfig);
Hiermit wird die Einstellung des CAN Controllers festgelegt. Hierzu
wird folgenden Struktur verwendet:
struct
{
DWORD dwBaudrate;
L2C_CANTransceiverMode nTransceiverMode;
}L2C_CANConfig, *PL2C_CANConfig;
Folgende Baudraten in kBaud sind dabei zulässig:
10
20
50
100
125
250
500
1000
Der CAN Transceiver kann auf einen der folgenden Modi eingestellt werden:
L2C_CAN_TRANSCEIVER_LOWSPEED
L2C_CAN_TRANSCEIVER_HIGHSPEED
• GetGatewayTranslation([out] PL2C_TranslationConfig2 pTranslationConfig2)
• SetGatewayTranslation([in] PL2C_TranslationConfig2 pTranslationConfig2)
Diese beiden Funktionen dienen der Konfiguration der Übersetzungstabelle von LIN nach CAN und umgekehrt. Hier kann für jede LIN ID
eine CAN ID hinterlegt werden Die LIN ID entspricht dem Index von
IdentifierTranslation. Zusätzlich besteht die Möglichkeit einen LIN Fehler auf dem CAN Bus zu verschicken, eine CAN ID zu hinterlegen welche das Gateway aktiviert (Datenbytes der CAN Nachricht ungleich 0)
oder deaktiviert (Datenbytes gleich 0) und eine CAN ID zu hinterlegen
welche die aktive Schedule Tabelle im Gateway Master Modus umschalltet (Datenbyte 0 legt die Nummer der Scheduletabelle fest). Hierzu wird folgende Struktur verwendet:
12
struct
{
L2C_IdentifierTranslation stLIN_IdentifierTranslation[64];
L2C_IdentifierTranslation stLIN_ErrorTranslation;
L2C_IdentifierTranslation stGatewayActivation;
L2C_IdentifierTranslation stScheduleSwitching;
}L2C_TranslationConfig2, *PL2C_TranslationConfig2;
Jeder der 66 Einträge besitzt folgende Struktur:
struct
{
BOOL bValid;
L2C_TranslationDirection nTranslationDir;
BOOL b29BitIdentifier;
DWORD dwCANID;
}L2C_IdentifierTranslation, *PL2C_IdentifierTranslation;
Mit bValid kann festgelegt werden ob der Eintrag gültig ist (TRUE für
gültig).
Mit nTranslationDir wird die Richtung der Übersetzung festgelegt:
L2C_LIN_TO_CAN_TRANSLATION
L2C_CAN_TO_LIN_TRANSLATION
b29BitIdentifier legt fest ob es sich um eine 29Bit CAN ID handelt
(TRUE für 29bit).
Mit dwCANID wird schließlich noch der CAN Identifier festgelegt. Es
sollte darauf geachtet werden, dass eine CAN ID nicht doppelt vergeben wird.
13
2.8
Interface ILIN2CAN_SlaveConfig
Dieses Interface dient zum Konfigurieren der Aktionstabelle. Folgende Methoden
werden hierfür bereitgestellt:
• GetLINIDAction([in/out] PL2C_ActionEntry pActionEntry);
• SetLINIDAction([in] PL2C_ActionEntry pActionEntry);
Diese Methoden dienen dazu einen Eintrag der Aktionstabelle abzufragen bzw. zu setzen. Hierzu wird diese Struktur verwendet:
struct
{
BYTE bLINID;
L2C_LINIDAction nAction;
BYTE pbAddInfo[64];
BYTE bAddInfoLen;
}L2C_ActionEntry, *PL2C_ActionEntry;
Dabei ist bLINID immer ein [in] Parameter, damit wird festgelegt für
welche LIN ID die Aktion gesetzt bzw. abgefragt werden soll.
Mit nAction wird die auszuführende Aktion festgelegt. Folgende Einstellung sind gültig:
L2C_CAN_ACTION_IGNORE
L2C_CAN_ACTION_SEND_LINDATA
Ist die Action auf Ignore gestellt dürfen keine AddInfo Daten übergeben werden.
Ist Send_LINData gewählt so müssen in AddInfo die zu versendenden
Daten mit passender Länge entsprechend der LIN ID vorhanden sein.
Die Länge wird zusätzlich in bAddInfoLen übergeben.
14
2.9
Interface ILIN2CAN_MasterConfig2
Hiermit kann die Master Schedule Tabelle bearbeitet werden. Dazu stehen die
folgenden Methoden zur Verfügung:
• GetScheduleTable([in] BYTE bNumberScheduleTable, [out]
PL2C_ScheduleEntry pScheduleTable, [out] PBYTE pbNumberEntries);
• SetScheduleTable([in] BYTE bNumberScheduleTable, [in]
PL2C_ScheduleEntry pScheduleTable ,[in] BYTE bNumberEntries);
Durch bNumberScheduleTable wird festgelegt welche Scheduletabelle
gelesen oder beschrieben werden soll. Die Anzahl der unterstützten
Scheduletabellen kann mit GetScheduleTabelCount angefragt werden.
In die Schedule Tabelle können bis zu 64 Einträge geschrieben werden. Dazu dient folgende Struktur die in einem Feld übergeben wird.
Beim Abholen muss das Feld 64 (L2C_MAX_SCHEDULETABLE_SIZE)
Einträge groß sein. In pbNumberEntries erhält man dann die Anzahl
der Einträge die vorhanden waren. Beim Setzen muss die Anzahl der
Einträge mit der Größe des Feldes übereinstimmen und es dürfen nicht
mehr als 64 Einträge sein.
struct
{
BYTE bLINID;
BYTE bWaitingTime;
}L2C_ScheduleEntry, *PL2C_ScheduleEntry;
• GetScheduleTableCount([out] PBYTE pbScheduleTableCount);
Mit dieser Methode kann die Anzahl der vom Gerät unterstützen
Schedule Tabellen angefragt werden.
15
2.10 Interface ILIN2CAN_LINMsgQueue2
Dieses Interface dient dazu auf die LIN Nachrichten Queue zuzugreifen. Dazu
werden folgende Funktionen bereitgestellt.
• GetLINMsgQueueStatus([out] L2C_QueueStatus pQueueStatus);
Hiermit kann der Status der LIN Queue abgerufen werden.
struct
{
BOOL bOverrun;
BYTE bQueueSize;
BYTE bUsedEntries;
}L2C_QueueStatus, *PL2C_QueueStatus;
Ist ein Overrun in der LIN Nachrichten Queue aufgetreten so ist bOverrun auf TRUE gesetzt. Die Queuegröße wird in bQueueSize zurückgegeben und die aktuell belegten Einträge in bUsesEntries.
• ResetLINMsgQueueOverrun();
Um den Overrun Status der Queue wieder zurückzusetzen muss diese
Funktion aufgerufen werden.
• GetLINMsgQueueEntry([out] PL2C_LINMessage2 pLINMessage2);
Um eine Nachricht aus der Queue auszulesen muss diese Funktion aufgerufen werden. Hierbei wird dann folgende Struktur gefüllt:
struct
{
DWORD dwTimeStamp;
BYTE bLINID;
BYTE pbData[8];
BYTE bDataLen;
L2C_MessageCrcType nMsgCrcType;
}L2C_LINMessage2, *PL2C_LINMessage2;
In dwTimeStamp ist die Zeit in [ms] zu der das LIN Objekt empfangen
wurde enthalten. Der Zeitstempel basiert auf der Systemzeit des Gerätes welcher alle 48 Tage überläuft.
In bLINID steht die empfangene LIN ID oder 0x40 falls es sich um einen
Fehlercode handelt.
In pbData zusammen mit bDataLen stehen die LIN Daten und die Länge falls es sich um eine gültige LIN Nachricht handelt.
In nMsgCrcType steht der CRC Typ mit der die LIN Nachricht auf dem
LIN Netz übermittelt wurde.
Ist ein LIN Fehler aufgetreten so wird dies mit der ID 0x40 signalisiert.
Ein eventuell empfangene LIN ID steht dann in Datenbyte 0 (sonst
0xFF) und der Fehlercode steht in Datenbyte 1.
16
2.10.1 Fehlerübersicht
Datenbyte
1
Datenbyte
2
Erklärung
FF
FF
FF
01
02
03
FF
04
LIN-ID
05
LIN-ID
06
LIN-ID
07
LIN-ID
08
FF
09
FF
0A
FF
0B
Empfangene Daten sind kein gültiges Sync- Feld.
Empfangene Daten sind kein gültiges ID-Feld.
Es wurde nur ein Sync- Break vor dem Timeout
empfangen.
Es wurde nur ein Sync- Break und Sync- Feld vor
dem Timeout empfangen.
Es wurde nur ein Sync- Break, Sync- Feld und IDFeld vor dem Timeout empfangen. (Slave antwortet nicht!)
Es wurde nur ein Sync- Break, Sync- Feld, ID- Feld
und mindestens ein Datenbyte vor dem Timeout
empfangen.
Die berechnete Checksumme stimmt nicht mit der
empfangenen Checksumme überein. Falls das
LIN2CAN GW im LIN Spec. 2.0 Modus arbeitet
könnte diese Fehler durch eine Datenkollision
oder durch eine Fehlerhafte CRC Einstellung
hervorgerufen werden.
Die empfangenen Daten entsprechen nicht den
versendeten Daten. Dieser Fehler kann durch eine
Datenkollision im LIN Spec. 2.0 Modus hervorgerufen werden.
UART fehler, empfangenen Daten entsprechen
nicht dem UART Standart (z.B. „Fehlendes StopBit“)
Ein dominanter Pegel wurde auf dem LIN Bus versendet (Wakeup Signal)
Ein dominanter Pegel wurde auf dem LIN Bus empfangen, aber er war für einen Sync- Break zu kurz.
(Hinweis: Dieser Fehlercode ist nur im Slave Modus
verfügbar nachdem zumindest ein gültiger SyncBreak empfangen wurde. Falls ein andere Fehlercode zuvor empfangen wurde so hat dieser Fehler
keine Relevanz.)
17
2.11 Interface ILIN2CAN_Master_Slave2
Dieses Interface dient zur PC gestützten Master Emulation. Hierzu stehen folgende Funktionen bereit:
• SendLINID([in] BYTE bLINID);
Diese Funktion versendet die angegeben LIN ID auf dem Bus. Die LIN
ID muss zwischen 0x00 und 0x3F liegen.
• SendLINIDandData([in] PL2C_LINMessage2 pLINMessage2);
Diese Funktion versendet ein komplettest LIN Objekt auf den Bus. Die
Struktur ist unter 2.10 GetLINMsgQueueEntry beschrieben. Für das
versenden hat der Zeitstempel keine Bedeutung. Die Datenlänge kann
dabei unabhängig von der Konfiguration der LIN Länge im Gerät gewählt werden.
• SendWakeup([in] BYTE bSignalDuration);
Diese Funktion legt einen Dominanten Pegel gemäss der angegeben
Zeit auf den LIN Bus. Die Dauer bSignalDuration wird in [ms] zwischen
1 und 255 angegeben.
18
Master Stand
Alone
Gateway Slave
Slave Stand Alone
x
-
-
-
-
SetDeviceName
x
x
-
-
-
-
GetVersionInformation
x
x
-
-
-
-
GetLINBaudrate
x
x
-
-
-
-
SetLINBaudrate
x
x
-
-
-
-
GetOperationMode
x
x
x
x
x
x
SetOperationMode
x
x
-
-
-
-
GetStartUpOpMode
x
x
-
-
-
-
SetStartUpOpMode
x
x
-
-
-
-
GetStandbyTime
x
x
-
-
-
-
SetStandbyTime
x
x
-
-
-
-
GetSystemTime
x
x
-
-
-
-
SetSystemTime
x
x
-
-
-
-
GetLinMessageConfig
x
x
-
-
-
-
SetLinMessageConfig
x
x
-
-
-
-
LoadSettingsFromFlash
x
x
-
-
-
-
SaveSettingsToFlash
x
x
-
-
-
-
GetCANConfig
x
x
-
-
-
-
SetCANConfig
x
x
-
-
-
-
GetGatewayTranslation
x
x
-
-
-
-
SetGatewayTranslation
x
x
-
-
-
-
GetLINIDAction
x
x
-
-
-
-
SetLINIDAction
x
x
-
-
-
-
GetScheduleTable
x
x
-
-
-
-
SetScheduleTable
x
x
-
-
-
-
GetScheduleTableCount
x
x
-
-
-
-
GetLINMsgQueueStatus
x
x
-
-
-
-
ResetLINMsgQueueOverrun
x
x
-
-
-
-
GetLINMsgQueueEntry
x
x
-
-
-
-
SendLINID
-
x
-
-
-
-
SendLINIDandData
-
x
-
-
-
-
SendWakeup
-
x
-
-
-
-
Funktion
Master mit PC
x
Slave mit PC
GetDeviceName
Betriebsart
X
-
Gateway Master
2.12 Übersicht: Erlaubte API- Aufrufe / Betriebsart
Aufruf in dieser Betriebsart erlaubt.
Aufruf in dieser Betriebsart nicht erlaubt.
19
2.13 API Kurzübersicht
Alle Methoden geben einen HRESULT Fehlercode zurück
einen Windows Fehlercode
S_OK bei Erfolg sonst
2.13.1 Interface: ILIN2CAN_GeneralConfig2
• GetDeviceName([out] PSTRING psDeviceName)
Name des Geräts: Zeiger auf einen String mit maximal 16 Zeichen
Letztes gültige Zeichen ist „\0“
• SetDeviceName([in] PSTRING psDeviceName)
Name des Geräts: Zeiger auf einen String mit maximal 16 Zeichen
Letztes gültige Zeichen muss „\0“ sein
• GetVersionInformation([out] PL2C_VersionInformation pVersionInfo);
struct
{
char strFirmwareVersion[8];
char strHardwareVersion[8];
• GetLINBaudrate([out] PWORD pwBaudrate);
Baudraten: 2400, 9600, 19200
• SetLINBaudrate([in] WORD wBaudrate);
• GetOperationMode([out] PL2C_OperationMode pnOperationMode);
typedef BYTE L2C_OperationMode;
#define L2C_OP_MODE_SLAVE_PC 1
#define L2C_OP_MODE_MASTER_PC 2
20
• SetOperationMode([in] L2C_OperationMode nOperationMode);
• GetStartUpOpMode([out] PL2C_OperationMode pnOperationMode);
#define L2C_OP_MODE_SLAVE 4
#define L2C_OP_MODE_MASTER 5
#define L2C_OP_MODE_GATEWAY_SLAVE 3
#define L2C_OP_MODE_GATEWAY_MASTER 3
• SetStartUpOpMode ([in] L2C_OperationMode nOperationMode);
• GetStandbyTime([out] PWORD pwStandbyTime);
Auflösung in [s]
0xFFFF für nie
• SetStandbyTime([in] WORD wStandbyTime);
• GetSystemTime([out] PDWORD pdwSystemTime);
Zeit in [ms]
• SetSystemTime([in] DWORD dwSystemTime);
• GetLinMessageConfig([out] PL2C_MessageConfig pMsgConfig)
struct
{
BYTE bMsgLen[64];
• SetLinMessageConfig([in] PL2C_MessageConfig pMsgConfig)
• LoadSettingsFromFlash();
• SaveSettingsToFlash;
21
2.13.2 Interface: ILIN2CAN_GatewayConfig2
• GetCANConfig([out] PL2C_CAN_Config pCANConfig);
struct
{
DWORD dwBaudrate;
L2C_CANTransceiverMode nTransceiverMode;
}L2C_CANConfig, *PL2C_CANConfig;
CAN Transceiver Baudrate
10, 20, 50, 100, 125, 250, 500, 1000
CAN Transceiver Modi
#define L2C_CAN_TRANSCEIVER_LOWSPEED 0
#define L2C_CAN_TRANSCEIVER_HIGHSPEED 1
• SetCANConfig([in] PL2C_CAN_Config pCANConfig);
• GetGatewayTranslation([out] PL2C_TranslationConfig2 pTranslationConfig2)
struct
{
L2C_IdentifierTranslation stLIN_IdentifierTranslation[64];
struct
{
BOOL bValid;
L2C_TranslationDirection nTranslationDir;
DWORD dwCANID;
• SetGatewayTranslation([in] PL2C_TranslationConfig2 pTranslationConfig2)
22
2.13.3 Interface: ILIN2CAN_SlaveConfig
• GetLINIDAction([in/out] PL2C_ActionEntry pActionEntry);
[in] pActionEntry->bLINID
[out] „restliche“
struct
{
BYTE bLINID;
L2C_LINIDAction nAction;
BYTE pbAddInfo[64];
BYTE bAddInfoLen;
//*** Slave Mode (Standalone) LIN ID Actions
#define L2C_CAN_ACTION_IGNORE 4
#define L2C_CAN_ACTION_SEND_LINDATA 5
• SetLINIDAction([in] PL2C_ActionEntry pActionEntry);
2.13.4 Interface: ILIN2CAN_MasterConfig2
• GetScheduleTable([out] PL2C_ScheduleEntry pScheduleTable,
[out] PBYTE pbNumberEntries);
struct
{
BYTE bLINID;
BYTE bWaitingTime;
pbNumberEntries out
Anzahl der Einträge in der Schedule Tabelle
//*** Master Mode (Standalone) Schedule Table Size
#define L2C_MAX_SCHEDULETABLE_SIZE 64
• SetScheduleTable([in] PL2C_ScheduleEntry pScheduleTable,
[in] BYTE bNumberEntries);
• GetScheduleTableCount ([out] PBYTE pbScheduleTableCount);
23
2.13.5 Interface: ILIN2CAN_LINMsgQueue2
• GetLINMsgQueueStatus([out] L2C_QueueStatus pQueueStatus);
struct
{
BOOL bOverrun;
BYTE bQueueSize;
BYTE bUsedEntries;
• ResetLINMsgQueueOverrun();
• GetLINMsgQueueEntry([out] PL2C_LINMessage2 pLINMessage2);
struct
{
DWORD dwTimeStamp;
BYTE bLINID;
BYTE pbData[8];
BYTE bDataLen;
Ist ein LIN Fehler aufgetreten so wird er mit der ID 0x40 signalisiert. Ein
eventuell empfangene LIN ID steht dann in Datenbyte 0 (sonst 0xFF)
der Fehlercode steht in Datenbyte 1.
24
2.13.6 Interface: ILIN2CAN_Master_Slave2
• SendLINID([in] BYTE bLINID);
bLINID LIN ID zwischen 0x00 und 0x3F
• SendLINIDandData([in] PL2C_LINMessage2 pLINMessage2);
pLINMessage dwTimeStamp nicht benutzt
• SendWakeup([in] BYTE bSignalDuration);
bSignalDuration Dauer des Wakeup Signals in [ms] Wert zwischen 1
und 255
25
2.13.7 Datentypen Definitionen
/*****************************************************************************
** constants and macros
*****************************************************************************/
//*** Define LIN2CAN Error Facility Code
#define L2C_ERROR_FACILITY 0xE0670000
//*** max lenght of an error string
#define L2C_MAX_ERRORSTR
256
//*** LIN Message CRC Types
#define L2C_MSG_CRC_TYPE_DEFAULT
#define L2C_MSG_CRC_TYPE_SPEC_1_3
#define L2C_MSG_CRC_TYPE_SPEC_2_0
0
1
2
//*** Operation Modes
#define L2C_OP_MODE_SLAVE_PC
#define L2C_OP_MODE_MASTER_PC
#define L2C_OP_MODE_SLAVE
#define L2C_OP_MODE_MASTER
#define L2C_OP_MODE_GATEWAY_SLAVE
#define L2C_OP_MODE_GATEWAY_MASTER
1
2
4
5
3
6
//*** Gateway Mode (Standalone) CAN Transceiver Modes
#define L2C_CAN_TRANSCEIVER_LOWSPEED 0
#define L2C_CAN_TRANSCEIVER_HIGHSPEED 1
//*** Gateway Mode Translation Direction
#define L2C_LIN_TO_CAN_TRANSLATION 0
#define L2C_CAN_TO_LIN_TRANSLATION 1
//*** Slave Mode (Standalone) LIN ID Actions
#define L2C_LIN_ACTION_IGNORE
4
#define L2C_LIN_ACTION_SEND_LINDATA 5
//*** Master Mode (Standalone) Schedule Table Size
#define L2C_MAX_SCHEDULETABLE_SIZE 64
/*****************************************************************************
** structs and types
*****************************************************************************/
//*** LIN Message CRC type
typedef BYTE L2C_MessageCrcType, *PL2C_MessageCrcType;
//*** Operation Mode type
typedef BYTE L2C_OperationMode, *PL2C_OperationMode;
//*** Gateway Mode (Standalone) Transceiver Mode type
26
typedef BYTE L2C_CANTransceiverMode, *PL2C_CANTransceiverMode;
//*** Gateway Translation Mode
typedef BYTE L2C_TranslationDirection, *PL2C_TranslationDirection;
//*** Slave Mode (Standalone) Action type
typedef BYTE L2C_LINID_Action, *PL2C_LINID_Action;
//*** Version Information Structure
typedef struct
{
char strFirmwareVersion[8]; //Firmware Version String
char strHardwareVersion[8]; //Hardware Version String
//*** LIN Message Config
typedef struct
{
BYTE bMsgLen[64];
//LIN Data Length: 0 - 8 Bytes
//LIN CRC calculation type
//*** Gateway Mode (Standalone) CAN Controller Configuration Structure
typedef struct
{
DWORD
dwBaudrate;
//CAN Baudrate in [kBaud]
L2C_CANTransceiverMode nTransceiverMode; //Mode of CAN Transceiver
//(High or Lowspeed)
}L2C_CANConfig, *PL2C_CAN_Config;
//*** Gateway Mode (Standalone) Identifier Translation
typedef struct
{
BOOL bValid;
//Translation valid? (Valid = TRUE)
L2C_TranslationDirection nTranslationDir; //Translation Direction (LIN 2 CAN |
CAN 2 LIN)
//only valid for LIN Identifier
Translation
//Is CAN ID a 29 Bit Identifier
//
(29bit = TRUE)
DWORD dwCANID;
//CAN ID (0 - 2047
[11bit])
//
(0 - 536870911 [29bit])
27
//*** Gateway Mode (Standalone) Translation Configuration
typedef struct
{
L2C_IdentifierTranslation stLIN_IdentifierTranslation[64]; //Field for Identifier
Translation
//(LIN ID = Index)
//LIN Error to CAN ID
Translation
//Gateway Activation
CAN ID
L2C_IdentifierTranslation stScheduleSwitching;
//Master Schedule
table switching
CAN ID
//*** Slave Mode (Standalone) LINID Action Table entry Structure
typedef struct
{
BYTE
bLINID;
//LIN ID (0 - 63)
L2C_LINID_Action nAction;
//Action to perform on LINID
BYTE
pbAddInfo[64]; //Additional Info for Action
//LIN Data for instance
BYTE
bAddInfoLen;
//Length of pbAddInfo
//*** Master Mode (Standalone) Schedule Table entry Structure
typedef struct
{
BYTE bLINID;
//LIN ID (0 - 63)
BYTE bWaitingTime; //Time to wait before sending the next LIN Identifier
//*** Slave Mode (with PC) Queue Status Structure
typedef struct
{
BOOL bOverrun;
//Indicates a LIN Queue Overrun (TRUE = Overrun)
BYTE bQueueSize;
//Size of the LIN Message Queue
BYTE bUsedEntries; //Used Entries of the LIN Message Queue
//*** Master / Slave Mode (with PC) LIN Message Structure
typedef struct
{
DWORD
dwTimeStamp; //Timestamp of LIN Message in [ms]
BYTE
bLINID;
//LIN ID (0 - 63) LIN Error (64)
BYTE
pbData[8];
//LIN Data
BYTE
bDataLen;
//Length of pbData
L2C_MessageCrcType nMsgCrcType; //LIN CRC calculation type
28
//*** Error List Lookup Table Structure
typedef struct
{
BOOL fIdValid;
//Flag if ID is valid
BYTE bErrorCode;
//Error Code
char strErrorMessage[512]; //Human readable error string
}L2C_LINErrorLookupTable, *PL2C_LINErrorLookupTable;
//*** Error List Lookup Table Structure
#define L2C_LIN_ERROR_LOOKUP_TABLE_ENTRY_COUNT 12
const L2C_LINErrorLookupTable
L2C_k_stLINErrorLookupTable[L2C_LIN_ERROR_LOOKUP_TABLE_ENTRY_COUNT] =
{
{
FALSE,
0x00,
""
},
{
FALSE,
0x01,
"Received data is not a valid sync-field."
},
{
FALSE,
0x02,
"Received data is not a valid ID-field."
},
{
FALSE,
0x03,
"Only sync-break detected before timeout."
},
{
FALSE,
0x04,
"Only sync-break and sync-field detected before timeout."
},
{
TRUE,
0x05,
"Only sync-break, sync-field and ID-field detected before timeout.
(Slave does not respond!)"
},
{
TRUE,
0x06,
"Only sync-break, sync-field, ID-field and at least one data byte detected
before timeout."
},
29
{
TRUE,
0x07,
"The calculated checksum does not match the received checksum. If the LIN2CAN
GW is operating in LIN Spec. 2.0 mode, this error may occur due data collision
or invalid CRC mode setting."
},
{
TRUE,
0x08,
"The received data does not match the sent data. this error may occur due data
collision in LIN Spec. 2.0 mode."
},
{
FALSE,
0x09,
"UART error, received byte was not like UART standard (\"StopBit missing\" for
instance)."
},
{
FALSE,
0x0A,
"A dominant level was transmitted on the LIN BUS. (Wakeup signal)"
},
{
FALSE,
0x0B,
"A dominant level was received on the LIN BUS, but it was to short to be a
sync-break. (Note: This error code is only available in slave operation mode
after at least one valid sync-break was received. If an other error code was
received before, this error code has no relevance.)"
}
};
30
/*****************************************************************************
** LIN Error (LIN ID 0x40)
**
** An Error is signaled if bLINID is set to 0x40
** The LIN ID of the error message (if available) is stored in pbData[0]
** else it is 0xFF, while the errorcode is stored in pbData[1]
**
** Error Overview!
** - 0x01 Received data is not a valid sync-field.
** - 0x02 Received data is not a valid ID-field.
** - 0x03 Only sync-break detected before timeout.
** - 0x04 Only sync-break and sync-field detected before timeout.
** - 0x05 Only sync-break, sync-field and ID-field detected before timeout.
**
(Slave does not respond!)
** - 0x06 Only sync-break, sync-field, ID-field and at least one data byte
**
detected before timeout.
** - 0x07 The calculated checksum does not match the received checksum.
**
If the LIN2CAN GW is operating in LIN Spec. 2.0 mode, this error
**
may occur due data collision or invalid CRC mode setting.
** - 0x08 The received data does not match the sent data. this error may
**
occurre due data colission in LIN Spec. 2.0 mode.
** - 0x09 UART error, received byte was not like UART standard
**
("StopBit missing" for instance).
** - 0x0A A dominant level was transmitted on the LIN BUS. (Wakeup signal)
** - 0x0B A dominant level was received on the LIN BUS, but it was to short
**
to be a sync-break.
**
(Note: This error code is only available in slave operation
**
mode after at least one valid syncbreak was received. If an other
**
error code was received before, this error code has no relevance.)
*****************************************************************************/
31

2 LIN-CAN-RS232-Gateway API (L2CAPI)

Transcrição

Documentos relacionados

EICAR Test File kann ab sofort zur Überprüfung von Anti

Zweite Haut

draisinenrundweg

Hier die Überschrift

fashionkatalog_Inhalt_14-09-11_01_QX7:Layout 1

Netzsicherheit I, WS 2012 Übung 4

LED-Einsatz in der Straßenbeleuchtung

Soundkarte ultron PCI 7.1 Kanal Octosound retail Artikel

Valoisplatz + NordseePassage

Weltmeisterliche Mode Gala