PCAN-Basic Dokumentation
Willkommen

Willkommen zur Dokumentation von PCAN-Basic,

der neuen Ausgabe des "kleinen" API (vormals PCAN-Light) von PEAK-System.

In den folgenden Kapiteln finden Sie ausführliche Informationen zu diesem API,

um in Ihren Anwendungen von der CAN-Hardware-Produktpalette der Firma PEAK-System

und dem CAN Protokoll bestmöglich profitieren zu können.

Einführung [image] DLL API Referenz [image] Weiterführende Information

Letzte Aktualisierung: 12.08.2022

Copyright (c) 2022. PEAK-System Technik GmbH. Alle Rechte vorbehalten.
Rückmeldung zu dieser Dokumentation senden


Einführung

Willkommen
Einführung

Willkommen zur Dokumentation von PCAN-Basic.

Das PCAN-System der Firma PEAK-System Technik GmbH besteht aus einem Paket von Windows Gerätetreibern, die mit Echtzeiteigenschaften eine Verbindung zwischen Windows-Anwendungen und der physikalischen Anbindung von CAN-Bussen an den PC ermöglichen.

PCAN-Basic (der Nachfolger von PCAN-Light) ist eine leicht zu erlernende Programmierschnittstelle zum PCAN-System. Über eine Laufzeitbibliothek (PCAN-Basic DLL) sind alle notwendigen Mechanismen zur Kommunikation zwischen selbsterstellten Anwendungen und den PCAN-Gerätetreibern, also indirekt zur PCAN-Hardware und dem CAN-Bus, zugreifbar.

In diesem Kapitel

Thema | Beschreibung
PCAN-Basic Grundlagen | Dieser Abschnitt enthält eine Einführung zur PCAN-Basic API.
Verwenden von Events | Erläuterungen zur Empfangsbenachrichtigung beim Eintreffen von CAN-Botschaften.
Lizenzbestimmungen | Rechtliche Vereinbarungen zur Benutzung dieser Software.
Kontakt-Information | Mit PEAK-System Technik GmbH in Kontakt treten.


PCAN-Basic Grundlagen

Willkommen
PCAN-Basic Grundlagen

PCAN-Basic ist eine Programmierschnittstelle (API) für CAN-Kommunikation mit PCAN-Geräte der Firma PEAK-Syste Technik GmbH. Es besteht aus einer Sammlung von Treibern, die ein schnelles und umfassendes Arbeiten mit dem CAN-Bus ermöglichen. PCAN-Basic unterstützt die gleichzeitige Verbindung mehrerer CAN-Kanäle von denselben oder unterschiedlichen Gerätetypen. Die folgende Liste zeigt die Obergrenzen:

 | PCAN-ISA | PCAN-Dongle | PCAN-PCI | PCAN-USB | PCAN-PC-Card | PCAN-LAN
Anzahl der Kanäle | 8 | 1 | 16 | 16 | 2 | 16

PCAN-Basic bietet einen leichten Weg, um in einer Anwendung mehrere PCAN-Kanäle zu bearbeiten. Der Ablauf der Kommunikation ist in drei Phasen eingeteilt: Initialisierung, Interaktion und Abschluss.

Initialisierung: Ein CAN-Kanal muss vor der Benutzung notwendigerweise initialisiert werden. Dies geschieht einfach durch Aufrufen der Funktion CAN_Initialize (Klassenmethode: Initialize), oder durch Aufrufen der Funktion CAN_InitializeFD (class-method: InitializeFD) falls FD Kommunikation gewünscht ist.

Interaktion: Nach erfolgreicher Initialisierung steht der CAN-Kanal zur Kommunikation mit der CAN-Hardware bzw. dem CAN-Bus bereit. Es sind keine weiteren Konfigurationsarbeiten erforderlich. Zum Lesen und Schreiben von CAN-Botschaften stehen die Funktionen CAN_Read und CAN_Write (Klassenmethoden: Read und Write) zur Verfügung. Wenn der verwendete Kanal FD-fähig ist und mit CAN_InitializeFD initialisiert wurde, dann sind die Funktionen CAN_ReadFD und CAN_WriteFD (Klassenmethoden: ReadFD and WriteFD) für das Lesen und Schreiben von Botschaften zu verwenden. Falls erwünscht, können zusätzliche Einstellungen vorgenommen werden, wie z. B. Botschaftsfilter zur Beschränkung auf bestimmte Botschafts-IDs.

Abschluss: Zum Beenden der Kommunikation sollte die Funktion CAN_Uninitialize (Klassenmethode: Uninitialize) aufgerufen werden, um z. B. die für den Kanal reservierten Ressourcen freizugeben. Außerdem wird so der Kanal als "Frei" markiert und steht anderen Applikationen zur Verfügung.

Hardware und Treiber

Übersicht über die aktuelle PCAN Hardware und die Gerätetreiber:

Hardware | Plug-and-Play fähig | Treiber
PCAN-Dongle | Nein | Pcan_dng.sys
PCAN-ISA | Nein | Pcan_isa.sys
PCAN-PC/104 | Nein | Pcan_isa.sys
PCAN-PCI | Ja | Pcan_pci.sys
PCAN-PCI Express | Ja | Pcan_pci.sys
PCAN-PCI Express FD | Ja | Pcan_pci.sys
PCAN-cPCI | Ja | Pcan_pci.sys
PCAN-miniPCI | Ja | Pcan_pci.sys
PCAN-miniPCIe | Ja | Pcan_pci.sys
PCAN-miniPCIe FD | Ja | Pcan_pci.sys
PCAN-M.2 | Ja | Pcan_pci.sys
PCAN-Chip PCIe FD | Ja | Pcan_pci.sys
PCAN-PC/104-Plus | Ja | Pcan_pci.sys
PCAN-PC/104-Plus Quad | Ja | Pcan_pci.sys
PCAN-PC/104-Express | Ja | Pcan_pci.sys
PCAN-PC/104-Express FD | Ja | Pcan_pci.sys
PCAN-ExpressCard | Ja | Pcan_pci.sys
PCAN-ExpressCard 34 | Ja | Pcan_pci.sys
PCAN-USB | Ja | Pcan_usb.sys
PCAN-USB FD | Ja | Pcan_usb.sys
PCAN-USB Pro | Ja | Pcan_usb.sys
PCAN-USB Pro FD | Ja | Pcan_usb.sys
PCAN-USB X6 | Ja | Pcan_usb.sys
PCAN-Chip USB | Ja | Pcan_usb.sys
PCAN-PC Card | Ja | Pcan_pcc.sys
PCAN-Ethernet Gateway DR | Ja | Pcan_lan.sys
PCAN-Wireless Gateway DR | Ja | Pcan_lan.sys
PCAN-Wireless Gateway | Ja | Pcan_lan.sys
PCAN-Wireless Automotive Gateway | Ja | Pcan_lan.sys
Siehe auch

PCAN-Grundlagen

PCAN-API


Verwenden von Events

Willkommen
Verwenden von Events

Ereignisse werden zur automatischen Benachrichtigung einer Anwendung (Client) bzgl. Empfang einer CAN-Botschaft verwendet. Das bietet folgende Vorteile:

  • Die Anwendung muss nicht mehr regelmäßig auf Empfangsbotschaften prüfen (Polling).
  • Die Reaktionszeit bei Empfang wird verkürzt.

Um mit Ereignissen arbeiten zu können, muss die Anwendung die Funktion CAN_SetValue (Klassenmethode: SetValue) aufrufen, um so den Parameter PCAN_RECEIVE_EVENT zu setzen. Damit wird ein "Griff" (handle) am Ereignisobjekt befestigt, damit die Anwendung es handhaben kann. Bei Empfang einer Botschaft setzt der Treiber den Zustand des Ereignisobjekts auf "Signaled".

Daher muss eine Parallelhandlung (thread) in der Anwendung stattfinden, die auf die Signalisierung bzgl. des Ereignisses wartet. Es wird eine Synchronisierungsfunktion des Win32-Betriebssystems verwendet (z.B. WaitForSingleObject), wodurch sich die Prozessorauslastung nicht erhöht. Sobald das Ereignis signalisiert wurde, kann der Empfangspuffer der Anwendung mit Hilfe der Funktion CAN_Read (Klassenmethode: Read) ausgelesen und die CAN-Botschaften verarbeitet werden.

Anmerkungen

Tipps für die Erstellung eines Ereignisobjekts:

Erzeugung des Events als "Auto-Reset"

  • Triggermodus "Set" (Standardeinstellung): Sobald der erste wartende thread ausgelöst wurde, wird der Zustand des Ereignisobjekts auf "non-signaled" gesetzt. Andere wartende threads werden nicht ausgelöst. Wenn kein thread wartet, bleibt der Zustand des Ereignisobjekts auf "signaled".
  • Triggermodus "Pulse": Nachdem der erste wartende Thread ausgelöst wurde, geht der Event in den Non-signaled Status, auch wenn weitere Threads warten, diese werden nicht ausgelöst. Ist beim Setzen des Signaled Status kein Thread in einer der Wait-Funktionen, wird der Event sofort wieder in den Non-signaled Status zurückgesetzt.

Erzeugung des Events als "Manual-Reset"

  • Triggermodus "Set" (Standardeinstellung): Das Event-Objekt bleibt solange im Signaled Zustand, bis die Win32-Funktion [image] ResetEvent aufgerufen wird. Eine beliebige Anzahl von Threads kann in dieser Zeit ausgelöst werden.
  • Triggermodus "Pulse": Alle wartenden Threads, die sofort ausgelöst werden können, werden ausgelöst, dann wird der Event in den Non-signaled Status zurückgesetzt. Ist beim Setzen des Signaled Status kein Thread in einer der Wait-Funktionen, wird der Event sofort wieder in den Non-signaled Status zurückgesetzt.
Siehe auch

CAN_SetValue (Klassenmethode: SetValue)

CAN_Read (Klassenmethode: Read)


Lizenzbestimmungen

Willkommen
Lizenzbestimmungen

Die Nutzung dieser Software unterliegt den Bedingungen der [image] Endbenutzer-Lizenzvereinbarung der PEAK-System Technik GmbH.

Die im Handbuch verwendeten Bezeichnungen für Erzeugnisse, die zugleich ein eingetragenes Warenzeichen darstellen, wurden nicht gesondert gekennzeichnet. Das Fehlen der R Markierung ist demzufolge nicht gleichbedeutend mit der Tatsache, dass die Bezeichnung als freier Warenname gilt. Ebenso wenig kann anhand der verwendeten Bezeichnung auf eventuell vorliegende Patente oder einen Gebrauchsmusterschutz geschlossen werden. Es sei ausdrücklich darauf verwiesen, dass die Firma PEAK-System Technik GmbH weder eine Garantie noch die juristische Verantwortung oder irgendeine Haftung für Folgeschäden übernimmt, die auf den Gebrauch der beiliegenden Software oder den Inhalt dieses Handbuches zurückzuführen sind. Die in diesem Handbuch enthaltenen Angaben können ohne vorherige Ankündigung geändert werden. Die Firma PEAK-System Technik GmbH geht damit keinerlei Verpflichtungen ein.

Copyright C 2000-2019 PEAK-System Technik GmbH

Alle Rechte vorbehalten.

Kein Teil dieses Hilfetextes darf in irgendeiner Form ohne schriftliche Genehmigung der Firma PEAK-System Technik GmbH unter Einsatz entsprechender Systeme reproduziert, verarbeitet, vervielfältigt oder verbreitet werden.

Siehe auch

Kontakt-Information


Kontakt-Information

Willkommen
Kontakt-Information

Diese Software ist ein Produkt von:

PEAK-System Technik GmbH

Otto-Röhm-Str. 69

64293 Darmstadt, Deutschland

Info: | info@peak-system.com
Support: | support@peak-system.com
Web: | www.peak-system.com


Referenz

Willkommen
Referenz

Dieser Abschnitt enthält Informationen über Datentypen (Klassen, Strukturen, Typen, Definitionen, Aufzählungen) und Funktionen des PCAN-Basic API.

In diesem Kapitel

Thema | Beschreibung
Namespaces | Listet die definierten Namespaces für Microsofts .NET Framework Programmierumgebung.
Module | Listet die definierten Module für die Python 2.6 Programmierumgebung.
Units | Listet die definierten Units für die Delphi Programmierumgebung.
Klassen | Listet die definierten Klassen, die das PCAN-Basic API abbilden.
Strukturen | Listet die definierten Datenstrukturen.
Typen | Listet die definierten Datentypen.
Methoden | Listet die definierten Klassenmethoden des PCAN-Basic API.
Funktionen | Listet die definierten Funktionen des PCAN-Basic API.
Definitionen | Listet die definierten Werte.


Namespaces

Willkommen
Namespaces

PEAK hat einige spezielle Programmierschnittstellen als Namespaces für die .NET Framework Programmierumgebung bereitgestellt. Folgende Namespaces stehen zur Verfügung:

Namespaces
 | Name | Beschreibung
{} | Peak | Enthält alle Namespaces, die Teil der "managed" Programmierumgebung von PEAK-System sind.
{} | Peak.Can | Enthält Typen und Klassen zur Verwendung mit dem PCAN API von PEAK-System.
{} | Peak.Can.Light | Enthält Typen und Klassen zur Verwendung mit dem PCAN-Light API von PEAK-System.
{} | Peak.Can.Basic | Enthält Typen und Klassen zur Verwendung mit dem PCAN-Basic API von PEAK-System.
{} | Peak.Lin | Enthält Typen und Klassen zur Handhabung von LIN Geräten von PEAK-System.
{} | Peak.RP1210A | Enthält Typen und Klassen zur Handhabung von CAN Geräten von PEAK-System, entnommen der "TMC Recommended Practices 1210", Version A, auch bekannt als RP1210(A).


Peak.Can.Basic

Willkommen
Peak.Can.Basic

Der Namespace "Peak.Can.Basic" enthält Typen und Klassen zur Verwendung des PCAN-Basic API mit der .NET Framework Programmierumgebung, um so PCAN-Geräte von PEAK-System zu handhaben

Anmerkungen

Für die Delphi Programmierumgebung sind diese Elemente in der PCANBasic-Unit zusammengefasst. Die Funktionalität aller Elemente ist dieselbe, jedoch verwendet Delphi nicht das .NET Framework, sondern greift direkt auf das Windows API zu (keine "managed" Programmierumgebung).

Pseudonymen
Name | Beschreibung
TPCANHandle | Beschreibt das handle zu einem PCAN-Hardware-Kanal.
TPCANBitrateFD | Beschreibt einen Bitrate mit Flexible Datenrate.
TPCANTimestampFD | Beschreibt den Zeitstempel einer CAN-Botschaft mit flexiblen Datenrate.
Klassen
Name | Beschreibung
PCANBasic | Beschreibt die Klasse, die das PCAN-Basic API darstellt.
Strukturen
Name | Beschreibung
TPCANMsg | Beschreibt eine CAN Botschaft.
TPCANTimestamp | Beschreibt den Zeitstempel einer CAN-Botschaft.
TPCANMsgFD | Beschreibt eine CAN Botschaft mit flexiblen Datenrate.
Aufzählungen
Name | Beschreibung
TPCANStatus | Beschreibt den PCAN Zustands-/Fehler-Code.
TPCANDevice | Beschreibt ein PCAN Gerät.
TPCANParameter | Beschreibt einen PCAN Parameter (Lesen und Schreiben).
TPCANMessageType | Beschreibt den Typ einer CAN-Botschaft.
TPCANType | Beschreibt den Typ einer "Non-Plug-And-Play" PCAN Hardware.
TPCANMode | Beschreibt eine PCAN Filter-Betriebsart.
TPCANBaudrate | Beschreibt einen PCAN Bitraten-Registerwert.


Module

Willkommen
Module

PEAK hat einige spezielle Programmierschnittstellen als Module für die Programmierung mit Python 2.6 bereitgestellt. Folgende Module stehen zur Verfügung:

Modul
 | Name | Beschreibung
{} | PCAN-Basic-Module | Python Modul zur Benutzung des PCAN-Basic API von PEAK-System.


PCANBasic-Modul

Willkommen
PCANBasic-Modul

Das PCANBasic-Modul enthält Typen und Klassen zur Verwendung des PCAN-Basic API mit der Python 2.6 Programmierumgebung, um so PCAN-Geräte von PEAK-System zu handhaben.

Klassen
Name | Beschreibung
PCANBasic | Beschreibt die Klasse, die das PCAN-Basic API darstellt
Strukturen
Name | Beschreibung
TPCANMsg | Beschreibt eine CAN Botschaft.
TPCANTimestamp | Beschreibt den Zeitstempel einer CAN-Botschaft.
TPCANMsgFD | Beschreibt eine CAN Botschaft mit flexiblen Datenrate.


Units

Willkommen
Units

PEAK hat einige spezielle Programmierschnittstellen als Funktionskapsel für die Delphi-Programmierumgebung bereitgestellt:

Units
 | Name | Beschreibung
{} | PCANBasic-Unit | Delphi Unit zur Benutzung des PCAN-Basic API von PEAK-System.


PCANBasic-Unit

Willkommen
PCANBasic-Unit

Die PCANBasic-Unit enthält Typen und Klassen zur Verwendung des PCAN-Basic API mit der Delphi Programmierumgebung, um so PCAN-Geräte von PEAK-System zu handhaben.

Anmerkungen

Für Microsofts .NET Framework Programmierumgebung sind diese Elemente im Namespace Peak.Can.Basic zusammengefasst. Die Funktionalität aller Elemente ist dieselbe, jedoch verwendet Delphi nicht das .NET Framework, sondern greift direkt auf das Windows API zu (keine "managed" Programmierumgebung).

Pseudonymen
Name | Beschreibung
TPCANHandle | Beschreibt das handle zu einem PCAN-Hardware-Kanal.
TPCANBitrateFD | Beschreibt einen Bitrate mit Flexible Datenrate.
TPCANTimestampFD | Beschreibt den Zeitstempel einer CAN-Botschaft mit flexiblen Datenrate.
Klassen
Name | Beschreibung
TPCANBasic | Beschreibt die Klasse, die das PCAN-Basic API darstellt.
Strukturen
Name | Beschreibung
TPCANMsg | Beschreibt eine CAN Botschaft.
TPCANTimestamp | Beschreibt den Zeitstempel einer CAN-Botschaft.
TPCANMsgFD | Beschreibt eine CAN Botschaft mit flexiblen Datenrate.
Aufzählungen
Name | Beschreibung
TPCANStatus | Beschreibt den PCAN Zustands-/Fehler-Code
TPCANDevice | Beschreibt ein PCAN Gerät.
TPCANParameter | Beschreibt einen PCAN Parameter (Lesen und Schreiben).
TPCANMessageType | Beschreibt den Typ einer CAN-Botschaft.
TPCANType | Beschreibt den Typ einer Nicht-"Plug-And-Play" PCAN Hardware.
TPCANMode | Beschreibt eine PCAN Filter-Betriebsart.
TPCANBaudrate | Beschreibt einen PCAN Bitraten-Registerwert.


Klassen

Willkommen
Klassen

Die folgenden Klassen sind für die Benutzung des PCAN-Basic API ("managed" oder "unmanaged") bereitgestellt.

Klassen
Name | Beschreibung
PCANBasic | Beschreibt eine Klasse zur Anwendung des PCAN-Basic API in Microsofts .NET Framework Programmierumgebung und in Python.
TPCANBasic | Beschreibt eine Klasse zur Anwendung des PCAN-Basic API in der Delphi Programmierumgebung.


PCANBasic

Willkommen
PCANBasic

Beschreibt eine Klasse zur Anwendung des PCAN-Basic API in Microsofts .NET Framework Programmierumgebung und in Python.

Syntax
C#
public static class PCANBasic
C++ / CLR
public ref class PCANBasic abstract sealed
Visual Basic
Public NotInheritable Class PCANBasic
Python
class PCANBasic
Anmerkungen

Die PCANBasic Klasse beinhaltet und kapselt alle Funktionen des PCAN-Basic API. Jede Methode wird identisch zur API Funktion aufgerufen, lediglich das Präfix "CAN_" wird weggelassen. Struktur und Funktionalität von Methode und API-Funktion sind identisch.

In Microsofts .NET Framework ist PCANBasic eine statische, nicht vererbbare Klasse. Sie kann nur direkt (ohne weitere Instanziierung) verwendet werden, z. B.:

TPCANStatus res;
// Statische Benutzung, keine Instanz
//
res = PCANBasic.Initialize(PCAN_USBBUS1,PCAN_BAUD_500K);

Zur Benutzung des APIs in Python muss eine Variable als Objekt vom Typ PCANBasic instanziiert werden.

# Objekt Instanziierung
#
objPCAN = PCANBasic()
res = objPCAN.Initialize(PCAN_USBBUS1, PCAN_BAUD_500K)

Achtung: In Delphi heißt diese Klasse TPCANBasic.

Siehe auch

Methoden

Definitionen

Delphi: TPCANBasic


TPCANBasic

Willkommen
TPCANBasic

Beschreibt eine Klasse zur Anwendung des PCAN-Basic API in der Delphi Programmierumgebung.

Syntax
Pascal OO
TPCANBasic = class
Anmerkungen

TPCANBasic ist eine Klasse, die lediglich Methoden und konstante Elemente enthält. Sie werden ohne die Erzeugung einer Objektvariablen (ähnlich einer statischen Klasse wie bei anderen Programmiersprachen) verwendet.

Die TPCANBasic Klasse beinhaltet und kapselt alle Funktionen des PCAN-Basic API. Jede Methode wird identisch zur API Funktion aufgerufen, lediglich das Präfix "CAN_" wird weggelassen. Struktur und Funktionalität von Methode und API-Funktion sind identisch.

Achtung: In Microsofts .NET Framework heißt diese Klasse PCANBasic.

Siehe auch

Methoden

Definitionen

.NET Framework: PCANBasic


Strukturen

Willkommen
Strukturen

Das PCAN-Basic API stellt folgende Datenstrukturen bereit:

Name | Beschreibung
TPCANMsg | Beschreibt eine CAN Botschaft.
TPCANTimestamp | Beschreibt den Zeitstempel einer CAN-Botschaft.
TPCANMsgFD | Beschreibt eine CAN Botschaft mit flexiblen Datenrate.
TPCANChannelInformation | Beschreibt einen verfügbaren PCAN-Kanal.
Siehe auch

Referenz


TPCANMsg

Willkommen
TPCANMsg

Beschreibt eine CAN Botschaft.

Syntax
C++
typedef struct
{
    DWORD ID;
    TPCANMessageType  MSGTYPE;
    BYTE LEN;
    BYTE DATA[8];
} TPCANMsg;
Pascal OO
TPCANMsg = record
    ID: Longword;
    MSGTYPE: TPCANMessageType;
    LEN: Byte;
    DATA: array[0..7] of Byte;
end;
C#
public struct TPCANMsg
{
    public uint ID;
    [MarshalAs(UnmanagedType.U1)]
    public TPCANMessageType MSGTYPE;
    public byte LEN;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
    public byte[] DATA;
}
C++ / CLR
public value struct TPCANMsg
{
    UInt32 ID;
    [MarshalAs(UnmanagedType.U1)]
    TPCANMessageType MSGTYPE;
    Byte LEN;
    [MarshalAs(UnmanagedType::ByValArray, SizeConst = 8)]
    array<Byte>^ DATA;
}
Visual Basic
Public Structure TPCANMsg
    Public ID As UInt32
    <MarshalAs(UnmanagedType.U1)> _
    Public MSGTYPE As TPCANMessageType
    Public LEN As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst := 8)> _
    Public DATA As Byte()
End Structure
Python
from ctypes import *
class TPCANMsg (Structure):
    _fields_ = [ ("ID",  c_uint),
                 ("MSGTYPE",  TPCANMessageType),
                 ("LEN",  c_ubyte),
                 ("DATA", c_ubyte * 8) ]
Anmerkungen

Jedes Element dieser Struktur ist auf die folgende Byte-Grenze ausgerichtet.

Felder
Name | Beschreibung
ID | 11/29-bit Botschafts Identifier.
MSGTYPE | Botschaftstyp. Bitmaske, die den Typ der Botschaft anzeigt. Es können mehrere Werte kombiniert sein.
LEN | Datenlänge innerhalb der CAN-Botschaft (0..8).
DATA | Dateninhalt der CAN-Botschaft (DATA[0]..DATA[7]).
Siehe auch

TPCANMessageType

CAN_Read (Klassenmethode: Read)

CAN_Write (Klassenmethode: Write)

TPCANTimestamp


TPCANTimestamp

Willkommen
TPCANTimestamp

Beschreibt den Zeitstempel einer CAN-Botschaft. Der Zeitstempel enthält die Anzahl der Mikrosekunden, die seit dem Start von Windows vergangenen sind.

Syntax
C++
typedef struct
{
    DWORD  millis;
    WORD   millis_overflow;
    WORD   micros;
} TPCANTimestamp;
Pascal OO
TPCANTimestamp = record
    millis: Longword;
    millis_overflow: Word;
    micros: Word;
end;
C#
public struct TPCANTimestamp
{
    public uint millis;
    public ushort millis_overflow;
    public ushort micros;
}
C++ / CLR
public value struct TPCANTimestamp
{
    UInt32 millis;
    UInt16 millis_overflow;
    UInt16 micros;
};
Visual Basic
Public Structure TPCANTimestamp
    Public millis As UInt32
    Public millis_overflow As UInt16
    Public micros As UInt16
End Structure
Python
from ctypes import *
class TPCANTimestamp (Structure):
    _fields_ = [ ("millis",  c_uint),
                 ("millis_overflow",  c_ushort),
                 ("micros",  c_ushort) ]
Anmerkungen

Jedes Element dieser Struktur ist auf die folgende Byte-Grenze ausgerichtet.

Berechnung der Gesamt-Mikrosekunden: micros + 1000 * millis + 0x100000000 * 1000 * millis_overflow

Felder
Name | Beschreibung
millis | Basiswert: Millisekunden: 0.. 2^32-1.
millis_overflow | Überlaufereignis des Millisekunden-Zählers.
micros | Mikrosekunden: 0..999.
Siehe auch

CAN_Write (Klassenmethode: Write)

TPCANMsg


TPCANMsgFD

Willkommen
TPCANMsgFD

Beschreibt eine CAN Botschaft mit flexiblen Datenrate.

Syntax
C++
typedef struct
{
    DWORD ID;
    TPCANMessageType MSGTYPE;
    BYTE DLC;
    BYTE DATA[64];
} TPCANMsgFD;
Pascal OO
TPCANMsgFD = record
    ID: Longword;
    MSGTYPE: TPCANMessageType;
    DLC: Byte;
    DATA: array[0..63] of Byte;
end;
C#
public struct TPCANMsgFD
{
    public uint ID;
    [MarshalAs(UnmanagedType.U1)]
    public TPCANMessageType MSGTYPE;
    public byte DLC;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
    public byte[] DATA;
}
C++ / CLR
public value struct TPCANMsgFD
{
    UInt32 ID;
    [MarshalAs(UnmanagedType::U1)]
    TPCANMessageType MSGTYPE;
    Byte DLC;
    [MarshalAs(UnmanagedType::ByValArray, SizeConst = 64)]
    array<Byte>^ DATA;
};
Visual Basic
Public Structure TPCANMsgFD
    Public ID As UInt32
    <MarshalAs(UnmanagedType.U1)> _
    Public MSGTYPE As TPCANMessageType
    Public DLC As Byte
    <MarshalAs(UnmanagedType.ByValArray, SizeConst:=64)> _
    Public DATA As Byte()
End Structure
Python
from ctypes import *
class TPCANMsgFD (Structure):
    _fields_ = [ ("ID",      c_uint),
                 ("MSGTYPE", TPCANMessageType),
                 ("DLC",     c_ubyte),
                 ("DATA",    c_ubyte * 64) ]
Anmerkungen

Jedes Element dieser Struktur ist auf die folgende Byte-Grenze ausgerichtet.

Längere Datenfeld mit CAN-FD Botschaften:

Die Länge der in einem CAN-Botschaft enthaltenen Datenbytes wird von der Datenlängecode (DLC) gegeben. Die Codierung des DLC innerhalb FD-Botschaften ist anders. Es gibt sieben zusätzliche Codes (9 bis 15), die einer FD-Botschaft den Transport von bis zu 64 Datenbytes ermöglichen. Die Beziehung zwischen den DLC und die Anzahl von Datenbytes ist wie folgt:

DLC | Datenbytes
0 | 0
1 | 1
2 | 2
3 | 3
4 | 4
5 | 5
6 | 6
7 | 7
8 | 8
9 | 12
10 | 16
11 | 20
12 | 24
13 | 32
14 | 48
15 | 64
Felder
Name | Description
ID | 11/29-bit Botschafts Identifier.
MSGTYPE | Botschaftstyp. Bitmaske, die den Typ der Botschaft anzeigt. Es können mehrere Werte kombiniert sein.
DLC | Datenlängecode der CAN-Botschaft (0..15).
DATA | Dateninhalt der CAN-Botschaft (DATA[0]..DATA[63]).
Siehe auch

TPCANMessageType

CAN_ReadFD (Klassenmethode: ReadFD)

CAN_WriteFD (Klassenmethode: WriteFD)

TPCANTimestampFD


TPCANChannelInformation

Willkommen
TPCANChannelInformation

Beschreibt einen verfügbaren PCAN-Kanal.

Syntax
C++
typedef struct
{
    TPCANHandle channel_handle;
    TPCANDevice device_type;
    BYTE controller_number;
    DWORD device_features;
    char device_name[MAX_LENGTH_HARDWARE_NAME];
    DWORD device_id;
    DWORD channel_condition;
}TPCANChannelInformation;
Pascal OO
TPCANChannelInformation = record
    channel_handle: TPCANHandle;
    device_type: TPCANDevice;
    controller_number: Byte;
    device_features: Longword;
    device_name: array [0..MAX_LENGTH_HARDWARE_NAME-1] of AnsiChar;
    device_id: Longword;
    channel_condition: Longword;
end;
C#
public struct TPCANChannelInformation
{
    [MarshalAs(UnmanagedType.U2)]
    public TPCANHandle channel_handle;
    [MarshalAs(UnmanagedType.U1)]
    public TPCANDevice device_type;
    public byte controller_number;
    public uint device_features;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = PCANBasic.MAX_LENGTH_HARDWARE_NAME)]
    public string device_name;
    public uint device_id;
    public uint channel_condition;
}
C++ / CLR
public value struct TPCANChannelInformation
{
    [MarshalAs(UnmanagedType::U2)]
    TPCANHandle channel_handle;
    [MarshalAs(UnmanagedType::U1)]
    TPCANDevice device_type;
    Byte controller_number;
    UInt32 device_features;
    [MarshalAs(UnmanagedType::ByValTStr, SizeConst = MAX_LENGTH_HARDWARE_NAME)]
    String^ device_name;
    UInt32 device_id;
    UInt32 channel_condition;
};
Visual Basic
Public Structure TPCANChannelInformation
    <MarshalAs(UnmanagedType.U2)> _
    Public channel_handle As TPCANHandle
    <MarshalAs(UnmanagedType.U1)> _
    Public device_type As TPCANDevice
    Public controller_number As Byte
    Public device_features As UInt32
    <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=PCANBasic.MAX_LENGTH_HARDWARE_NAME)> _
    Public device_name As String
    Public device_id As UInt32
    Public channel_condition As UInt32
End Structure
Python
from ctypes import *
class TPCANChannelInformation (Structure):
    _fields_ = [ ("channel_handle",    TPCANHandle),
                 ("device_type",       TPCANDevice),
                 ("controller_number", c_ubyte),
                 ("device_features",   c_uint),
                 ("device_name",       c_char * MAX_LENGTH_HARDWARE_NAME),
                 ("device_id",         c_uint),
                 ("channel_condition", c_uint) ]
Anmerkungen

Jedes Element dieser Struktur ist auf die folgende Byte-Grenze ausgerichtet.

Felder
Name | Description
channel_handle | Handle des PCAN-Kanals (siehe TPCANHandle).
device_type | Typ des Geräts, das vom PCAN-Kanal dargestellt wird (siehe TPCANDevice).
controller_number | Index des vom PCAN-Kanal dargestellten CAN-Controllers.
device_features | Besonderheiten eines PCAN-Kanals (siehe Feature-Werte flags).
device_name | Name des Geräts, das vom PCAN-Kanal dargestellt wird.
device_id | Identifikationsnummer des Geräts, zu dem der PCAN-Kanal gehört.
channel_condition | Verfügbarkeitsstatus des PCAN-Kanals (siehe Kanalverfügbarkeitswerte flags).
Siehe auch

CAN_GetValue(class-method: GetValue)

Parameter PCAN_ATTACHED_CHANNELS


Typen

Willkommen
Typen

Das PCAN-Basic API stellt folgende Datentypen bereit:

Name | Beschreibung
TPCANHandle | Beschreibt das handle zu einem PCAN-Hardware-Kanal.
TPCANStatus | Beschreibt den PCAN Zustands-/Fehler-Code.
TPCANDevice | Beschreibt ein PCAN Gerät.
TPCANParameter | Beschreibt einen PCAN Parameter (Lesen und Schreiben).
TPCANMessageType | Beschreibt den Typ einer CAN-Botschaft.
TPCANType | Beschreibt den Typ einer "Non-Plug-And-Play" PCAN Hardware.
TPCANMode | Beschreibt eine PCAN Filter-Betriebsart
TPCANBaudrate | Beschreibt einen PCAN Bitraten-Registerwert.
TPCANBitrateFD | Beschreibt einen Bitrate String mit Flexible Datenrate.
TPCANTimestampFD | Beschreibt den Zeitstempel einer CAN-Botschaft mit flexiblen Datenrate.


TPCANHandle

Willkommen
TPCANHandle

Beschreibt das handle zu einem PCAN-Hardware-Kanal.

Syntax
C++
#define TPCANHandle WORD
Pascal OO
TPCANHandle = Word;
C#
using TPCANHandle = System.UInt16;
C++ / CLR
#define TPCANHandle System::UInt16
Visual Basic
Imports TPCANHandle = System.UInt16
Python
TPCANHandle  = c_ushort
Anmerkungen

FD-fähige Hardware

Einige Hardware sind dazu fähig, eine Kommunikation mit flexibler Datenrate zu etablieren. Es gibt keine neue PCAN-Handles für das Kennzeichen von Hardware mit diese Fähigkeit. Ein neuer Parameter, PCAN_CHANNEL_FEATURES, wird dafür benutzt, Eigenschaften der Hardware zu lesen, u.a. ob diese FD fähig ist.

.NET Framework Programmiersprachen:

Das Pseudonym TPCANHandle wird verwendet, um ein Kanal-handle unter Microsofts .NET Framework darzustellen. Damit wird eine Gleichbehandlung für alle oben genannten Programmiersprachen erreicht. Die Pseudonymen sind im Namespace Peak.Can.Basic für die Benutzung in C# und VB .NET definiert.

Jedoch bedeutet das Einbinden (include) des Namespace nicht automatisch das Mit-Einbinden der Pseudonymen. Stattdessen müssen die Pseudonymen in die Arbeitsdatei hineinkopiert werden, direkt hinter dem Einbinden des Peak.Can.Basic Namespace. Man kann aber auch den Basis-Datentyp UInt16 verwenden.

C#:

using System;
using Peak.Can.Basic;
using TPCANHandle = System.UInt16; // Pseudonym (alias) Deklaration für System.UInt16

Visual Basic:

Imports System
Imports Peak.Can.Basic
Imports TPCANHandle = System.UInt16 ' Pseudonym (alias) Deklaration für System.UInt16
Siehe auch

Definition von PCAN-Handles


TPCANStatus

Willkommen
TPCANStatus

Beschreibt den PCAN-Zustands-/Fehler-Code. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANStatus DWORD

#define PCAN_ERROR_OK 0x00000
#define PCAN_ERROR_XMTFULL 0x00001
#define PCAN_ERROR_OVERRUN 0x00002
#define PCAN_ERROR_BUSLIGHT 0x00004
#define PCAN_ERROR_BUSHEAVY 0x00008
#define PCAN_ERROR_BUSWARNING  PCAN_ERROR_BUSHEAVY
#define PCAN_ERROR_BUSPASSIVE 0x40000
#define PCAN_ERROR_BUSOFF 0x00010
#define PCAN_ERROR_ANYBUSERR (PCAN_ERROR_BUSWARNING | PCAN_ERROR_BUSLIGHT | PCAN_ERROR_BUSHEAVY | PCAN_ERROR_BUSOFF | PCAN_ERROR_BUSPASSIVE)
#define PCAN_ERROR_QRCVEMPTY 0x00020
#define PCAN_ERROR_QOVERRUN 0x00040
#define PCAN_ERROR_QXMTFULL 0x00080
#define PCAN_ERROR_REGTEST 0x00100
#define PCAN_ERROR_NODRIVER 0x00200
#define PCAN_ERROR_HWINUSE 0x00400
#define PCAN_ERROR_NETINUSE 0x00800
#define PCAN_ERROR_ILLHW 0x01400
#define PCAN_ERROR_ILLNET 0x01800
#define PCAN_ERROR_ILLCLIENT 0x01C00
#define PCAN_ERROR_ILLHANDLE (PCAN_ERROR_ILLHW | PCAN_ERROR_ILLNET | PCAN_ERROR_ILLCLIENT)
#define PCAN_ERROR_RESOURCE 0x02000
#define PCAN_ERROR_ILLPARAMTYPE 0x04000
#define PCAN_ERROR_ILLPARAMVAL 0x08000
#define PCAN_ERROR_UNKNOWN 0x10000
#define PCAN_ERROR_ILLDATA 0x20000
#define PCAN_ERROR_ILLMODE 0x80000
#define PCAN_ERROR_CAUTION 0x2000000
#define PCAN_ERROR_INITIALIZE 0x4000000
#define PCAN_ERROR_ILLOPERATION 0x8000000
Pascal OO
{$Z4}
TPCANStatus = (
    PCAN_ERROR_OK = $00000,
    PCAN_ERROR_XMTFULL = $00001,
    PCAN_ERROR_OVERRUN = $00002,
    PCAN_ERROR_BUSLIGHT = $00004,
    PCAN_ERROR_BUSHEAVY = $00008,
    PCAN_ERROR_BUSHWARNING  = Byte(PCAN_ERROR_BUSHEAVY),
    PCAN_ERROR_BUSPASSIVE = $40000,
    PCAN_ERROR_BUSOFF = $00010,
    PCAN_ERROR_ANYBUSERR = Byte(PCAN_ERROR_BUSHWARNING) Or Byte(PCAN_ERROR_BUSLIGHT) Or Byte(PCAN_ERROR_BUSHEAVY) Or Byte(PCAN_ERROR_BUSOFF) Or Byte(PCAN_ERROR_BUSPASSIVE),
    PCAN_ERROR_QRCVEMPTY = $00020,
    PCAN_ERROR_QOVERRUN  = $00040,
    PCAN_ERROR_QXMTFULL = $00080,
    PCAN_ERROR_REGTEST = $00100,
    PCAN_ERROR_NODRIVER = $00200,
    PCAN_ERROR_HWINUSE = $00400,
    PCAN_ERROR_NETINUSE = $00800,
    PCAN_ERROR_ILLHW = $01400,
    PCAN_ERROR_ILLNET = $01800,
    PCAN_ERROR_ILLCLIENT = $01C00,
    PCAN_ERROR_ILLHANDLE = Byte(PCAN_ERROR_ILLHW) Or Byte(PCAN_ERROR_ILLNET) Or Byte(PCAN_ERROR_ILLCLIENT),
    PCAN_ERROR_RESOURCE = $02000,
    PCAN_ERROR_ILLPARAMTYPE = $04000,
    PCAN_ERROR_ILLPARAMVAL = $08000,
    PCAN_ERROR_UNKNOWN = $10000,
    PCAN_ERROR_ILLDATA = $20000,
    PCAN_ERROR_ILLMODE = $80000,
    PCAN_ERROR_CAUTION = $2000000,
    PCAN_ERROR_INITIALIZE = $4000000,
    PCAN_ERROR_ILLOPERATION = $8000000
);
C#
[Flags]
public enum TPCANStatus : uint
{
    PCAN_ERROR_OK = 0x00000,
    PCAN_ERROR_XMTFULL = 0x00001,
    PCAN_ERROR_OVERRUN = 0x00002,
    PCAN_ERROR_BUSLIGHT = 0x00004,
    PCAN_ERROR_BUSHEAVY = 0x00008,
    PCAN_ERROR_BUSWARNING   = PCAN_ERROR_BUSHEAVY,
    PCAN_ERROR_BUSPASSIVE   = 0x40000,
    PCAN_ERROR_BUSOFF = 0x00010,
    PCAN_ERROR_ANYBUSERR = (PCAN_ERROR_BUSWARNING | PCAN_ERROR_BUSLIGHT | PCAN_ERROR_BUSHEAVY | PCAN_ERROR_BUSOFF | PCAN_ERROR_BUSPASSIVE),
    PCAN_ERROR_QRCVEMPTY = 0x00020,
    PCAN_ERROR_QOVERRUN = 0x00040,
    PCAN_ERROR_QXMTFULL = 0x00080,
    PCAN_ERROR_REGTEST = 0x00100,
    PCAN_ERROR_NODRIVER = 0x00200,
    PCAN_ERROR_HWINUSE = 0x00400,
    PCAN_ERROR_NETINUSE = 0x00800,
    PCAN_ERROR_ILLHW = 0x01400,
    PCAN_ERROR_ILLNET = 0x01800,
    PCAN_ERROR_ILLCLIENT = 0x01C00,
    PCAN_ERROR_ILLHANDLE = (PCAN_ERROR_ILLHW | PCAN_ERROR_ILLNET | PCAN_ERROR_ILLCLIENT),
    PCAN_ERROR_RESOURCE = 0x02000,
    PCAN_ERROR_ILLPARAMTYPE = 0x04000,
    PCAN_ERROR_ILLPARAMVAL = 0x08000,
    PCAN_ERROR_UNKNOWN = 0x10000,
    PCAN_ERROR_ILLDATA = 0x20000,
    PCAN_ERROR_ILLMODE = 0x80000,
    PCAN_ERROR_CAUTION = 0x2000000,
    PCAN_ERROR_INITIALIZE = 0x4000000,
    PCAN_ERROR_ILLOPERATION = 0x8000000,
}
C++ / CLR
[Flags]
public enum class TPCANStatus : UInt32
{
    PCAN_ERROR_OK = 0x00000,
    PCAN_ERROR_XMTFULL = 0x00001,
    PCAN_ERROR_OVERRUN = 0x00002,
    PCAN_ERROR_BUSLIGHT = 0x00004,
    PCAN_ERROR_BUSHEAVY = 0x00008,
    PCAN_ERROR_BUSWARNING   = PCAN_ERROR_BUSHEAVY,
    PCAN_ERROR_BUSPASSIVE = 0x40000,
    PCAN_ERROR_BUSOFF = 0x00010,
    PCAN_ERROR_ANYBUSERR = (PCAN_ERROR_BUSWARNING | PCAN_ERROR_BUSLIGHT | PCAN_ERROR_BUSHEAVY | PCAN_ERROR_BUSOFF | PCAN_ERROR_BUSPASSIVE),
    PCAN_ERROR_QRCVEMPTY = 0x00020,
    PCAN_ERROR_QOVERRUN = 0x00040,
    PCAN_ERROR_QXMTFULL = 0x00080,
    PCAN_ERROR_REGTEST = 0x00100,
    PCAN_ERROR_NODRIVER = 0x00200,
    PCAN_ERROR_HWINUSE = 0x00400,
    PCAN_ERROR_NETINUSE = 0x00800,
    PCAN_ERROR_ILLHW = 0x01400,
    PCAN_ERROR_ILLNET = 0x01800,
    PCAN_ERROR_ILLCLIENT = 0x01C00,
    PCAN_ERROR_ILLHANDLE = (PCAN_ERROR_ILLHW | PCAN_ERROR_ILLNET | PCAN_ERROR_ILLCLIENT),
    PCAN_ERROR_RESOURCE = 0x02000,
    PCAN_ERROR_ILLPARAMTYPE = 0x04000,
    PCAN_ERROR_ILLPARAMVAL = 0x08000,
    PCAN_ERROR_UNKNOWN = 0x10000,
    PCAN_ERROR_ILLDATA = 0x20000,
    PCAN_ERROR_ILLMODE = 0x80000,
    PCAN_ERROR_CAUTION = 0x2000000,
    PCAN_ERROR_INITIALIZE = 0x4000000,
    PCAN_ERROR_ILLOPERATION = 0x8000000,
}
Visual Basic
<Flags()> _
Public Enum TPCANStatus As UInt32
    PCAN_ERROR_OK = &H0
    PCAN_ERROR_XMTFULL = &H1
    PCAN_ERROR_OVERRUN = &H2
    PCAN_ERROR_BUSLIGHT = &H4
    PCAN_ERROR_BUSHEAVY = &H8
    PCAN_ERROR_BUSWARNING = PCAN_ERROR_BUSHEAVY
    PCAN_ERROR_BUSPASSIVE = &H40000
    PCAN_ERROR_BUSOFF = &H10
    PCAN_ERROR_ANYBUSERR = (PCAN_ERROR_BUSWARNING Or PCAN_ERROR_BUSLIGHT Or PCAN_ERROR_BUSHEAVY Or PCAN_ERROR_BUSOFF Or PCAN_ERROR_BUSPASSIVE)
    PCAN_ERROR_QRCVEMPTY = &H20
    PCAN_ERROR_QOVERRUN = &H40
    PCAN_ERROR_QXMTFULL = &H80
    PCAN_ERROR_REGTEST = &H100
    PCAN_ERROR_NODRIVER = &H200
    PCAN_ERROR_HWINUSE = &H400
    PCAN_ERROR_NETINUSE = &H800
    PCAN_ERROR_ILLHW = &H1400
    PCAN_ERROR_ILLNET = &H1800
    PCAN_ERROR_ILLCLIENT = &H1C00
    PCAN_ERROR_ILLHANDLE = (PCAN_ERROR_ILLHW Or PCAN_ERROR_ILLNET Or PCAN_ERROR_ILLCLIENT)
    PCAN_ERROR_RESOURCE = &H2000
    PCAN_ERROR_ILLPARAMTYPE = &H4000
    PCAN_ERROR_ILLPARAMVAL = &H8000
    PCAN_ERROR_UNKNOWN = &H10000
    PCAN_ERROR_ILLDATA = &H20000
    PCAN_ERROR_ILLMODE = &H80000
    PCAN_ERROR_CAUTION = &H2000000
    PCAN_ERROR_INITIALIZE = &H4000000
    PCAN_ERROR_ILLOPERATION = &H8000000
End Enum
Python
TPCANStatus = int

PCAN_ERROR_OK = TPCANStatus(0x00000)
PCAN_ERROR_XMTFULL = TPCANStatus(0x00001)
PCAN_ERROR_OVERRUN = TPCANStatus(0x00002
PCAN_ERROR_BUSLIGHT = TPCANStatus(0x00004)
PCAN_ERROR_BUSHEAVY = TPCANStatus(0x00008)
PCAN_ERROR_BUSWARNING = TPCANStatus(PCAN_ERROR_BUSHEAVY)
PCAN_ERROR_BUSPASSIVE = TPCANStatus(0x40000)
PCAN_ERROR_BUSOFF = TPCANStatus(0x00010)
PCAN_ERROR_ANYBUSERR = TPCANStatus(PCAN_ERROR_BUSWARNING | PCAN_ERROR_BUSLIGHT | PCAN_ERROR_BUSHEAVY | PCAN_ERROR_BUSOFF | PCAN_ERROR_BUSPASSIVE)
PCAN_ERROR_QRCVEMPTY = TPCANStatus(0x00020)
PCAN_ERROR_QOVERRUN = TPCANStatus(0x00040)
PCAN_ERROR_QXMTFULL = TPCANStatus(0x00080)
PCAN_ERROR_REGTEST = TPCANStatus(0x00100)
PCAN_ERROR_NODRIVER = TPCANStatus(0x00200)
PCAN_ERROR_HWINUSE = TPCANStatus(0x00400)
PCAN_ERROR_NETINUSE = TPCANStatus(0x00800)
PCAN_ERROR_ILLHW = TPCANStatus(0x01400)
PCAN_ERROR_ILLNET = TPCANStatus(0x01800)
PCAN_ERROR_ILLCLIENT = TPCANStatus(0x01C00)
PCAN_ERROR_ILLHANDLE = TPCANStatus(PCAN_ERROR_ILLHW | PCAN_ERROR_ILLNET | PCAN_ERROR_ILLCLIENT)
PCAN_ERROR_RESOURCE = TPCANStatus(0x02000)
PCAN_ERROR_ILLPARAMTYPE = TPCANStatus(0x04000)
PCAN_ERROR_ILLPARAMVAL = TPCANStatus(0x08000)
PCAN_ERROR_UNKNOWN = TPCANStatus(0x10000)
PCAN_ERROR_ILLDATA = TPCANStatus(0x20000)
PCAN_ERROR_ILLMODE = TPCANStatus(0x80000)
PCAN_ERROR_CAUTION = TPCANStatus(0x2000000)
PCAN_ERROR_INITIALIZE = TPCANStatus(0x4000000)
PCAN_ERROR_ILLOPERATION = TPCANStatus(0x8000000)
Anmerkungen

Es kann vorkommen, dass ein Funktionsaufruf mehrere Rückgabewerte liefert. In diesem Fall werden die Fehlercodes bitweise kombiniert.

*Anmerkung: Den Wert von PCAN_ERROR_INITIALIZE und PCAN_ERROR_ILLOPERATION hat sich geändert!

PCAN_ERROR_INITIALIZE (0x40000) ist jetzt 0x4000000

PCAN_ERROR_ILLOPERATION (0x80000) ist jetzt 0x8000000

Werte
Name | Wert | Beschreibung
PCAN_ERROR_OK | 0x00000 (000000) | Kein Fehler. / Erfolgreich.
PCAN_ERROR_XMTFULL | 0x00001 (000001) | Sende-Puffer des CAN-Controllers ist voll.
PCAN_ERROR_OVERRUN | 0x00002 (000002) | CAN-Controller wurde zu spät ausgelesen.
PCAN_ERROR_BUSLIGHT | 0x00004 (000004) | Bus-Fehler: Ein Fehlerzähler hat die "light" Obergrenze erreicht bzw. überschritten.
PCAN_ERROR_BUSHEAVY | 0x00008 (000008) | Bus-Fehler: Ein Fehlerzähler hat die "heavy" Obergrenze erreicht bzw. überschritten.
PCAN_ERROR_BUSWARNING | 0x00008 (000008) | Bus-Fehler: Ein Fehlerzähler hat die "warning" Obergrenze erreicht bzw. überschritten.
PCAN_ERROR_BUSPASSIVE | 0x40000 (262144) | Bus-Fehler: Der CAN-Controller ist im passiven Fehlerzustand.
PCAN_ERROR_BUSOFF | 0x00010 (000016) | Bus-Fehler: Der CAN-Controller ist im BusOff- Zustand.
PCAN_ERROR_ANYBUSERR | 0x4001C (262172) | Maskierung für alle Bus-Fehler.
PCAN_ERROR_QRCVEMPTY | 0x00020 (000032) | Empfangs-Puffer der Software ist leer.
PCAN_ERROR_QOVERRUN | 0x00040 (000064) | Empfangs-Queue wurde zu spät ausgelesen.
PCAN_ERROR_QXMTFULL | 0x00080 (000128) | Sende-Queue der Software ist voll.
PCAN_ERROR_REGTEST | 0x00100 (000256) | Test der internen Register des CAN-Controllers nicht erfolgreich (Hardware nicht gefunden).
PCAN_ERROR_NODRIVER | 0x00200 (000512) | Gerätetreiber nicht geladen.
PCAN_ERROR_HWINUSE | 0x00400 (001024) | PCAN-Hardware bereits durch ein anderes PCAN-Netz belegt.
PCAN_ERROR_NETINUSE | 0x00800 (002048) | Ein PCAN-Client ist bereits mit dem PCAN-Netz verbunden.
PCAN_ERROR_ILLHW | 0x01400 (005120) | PCAN-Hardware handle ist ungültig.
PCAN_ERROR_ILLNET | 0x01800 (006144) | PCAN-Netz handle ist ungültig.
PCAN_ERROR_ILLCLIENT | 0x01C00 (007168) | PCAN-Client handle ist ungültig.
PCAN_ERROR_ILLHANDLE | 0x01C00 (007168) | Maskierung für alle handle-Fehler.
PCAN_ERROR_RESOURCE | 0x02000 (008192) | Ressource (FIFO, Client, timeout) kann nicht angelegt werden.
PCAN_ERROR_ILLPARAMTYPE | 0x04000 (016384) | Ungültiger Parameter.
PCAN_ERROR_ILLPARAMVAL | 0x08000 (032768) | Ungültiger Parameterwert.
PCAN_ERROR_UNKNOWN | 0x10000 (065536) | Unbekannter Fehler.
PCAN_ERROR_ILLDATA | 0x20000 (131072) | Ungültige Daten, Funktion oder Aktion.
PCAN_ERROR_ILLMODE | 0x80000 (524288) | Der Status des Treiberobjekts ist für den versuchten Vorgang falsch.
PCAN_ERROR_CAUTION | 0x2000000 (33554432) | Operation war erfolgreich, aber mit Unregelmäßigkeiten.
PCAN_ERROR_INITIALIZE* | 0x4000000 (67108864) | Kanal ist nicht initialisiert.
PCAN_ERROR_ILLOPERATION* | 0x8000000 (134217728) | Ungültiger Vorgang.


TPCANDevice

Willkommen
TPCANDevice

Beschreibt ein PCAN-Gerät. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANDevice BYTE

#define PCAN_NONE 0x00
#define PCAN_PEAKCAN 0x01
#define PCAN_ISA 0x02
#define PCAN_DNG 0x03
#define PCAN_PCI 0x04
#define PCAN_USB 0x05
#define PCAN_PCC 0x06
#define PCAN_VIRTUAL 0x07
#define PCAN_LAN 0x08
Pascal OO
{$Z1}
TPCANDevice = (
    PCAN_NONE = 0,
    PCAN_PEAKCAN = 1,
    PCAN_ISA = 2,
    PCAN_DNG = 3,
    PCAN_PCI = 4,
    PCAN_USB = 5,
    PCAN_PCC = 6,
    PCAN_VIRTUAL = 7,
    PCAN_LAN = 8
);
C#
public enum TPCANDevice : byte
{
    PCAN_NONE = 0,
    PCAN_PEAKCAN = 1,
    PCAN_ISA = 2,
    PCAN_DNG = 3,
    PCAN_PCI = 4,
    PCAN_USB = 5,
    PCAN_PCC = 6,
    PCAN_VIRTUAL = 7,
    PCAN_LAN = 8
}
C++ / CLR
public enum class TPCANDevice : Byte
{
    PCAN_NONE = 0,
    PCAN_PEAKCAN = 1,
    PCAN_ISA = 2,
    PCAN_DNG = 3,
    PCAN_PCI = 4,
    PCAN_USB = 5,
    PCAN_PCC = 6,
    PCAN_VIRTUAL = 7,
    PCAN_LAN = 8
};
Visual Basic
Public Enum TPCANDevice As Byte
    PCAN_NONE = 0
    PCAN_PEAKCAN = 1
    PCAN_ISA = 2
    PCAN_DNG = 3
    PCAN_PCI = 4
    PCAN_USB = 5
    PCAN_PCC = 6
    PCAN_VIRTUAL = 7
    PCAN_LAN = 8
End Enum
Python
TPCANDevice = c_ubyte

PCAN_NONE = TPCANDevice(0x00)
PCAN_PEAKCAN = TPCANDevice(0x01)
PCAN_ISA = TPCANDevice(0x02)
PCAN_DNG = TPCANDevice(0x03)
PCAN_PCI = TPCANDevice(0x04)
PCAN_USB = TPCANDevice(0x05)
PCAN_PCC = TPCANDevice(0x06)
PCAN_VIRTUAL = TPCANDevice(0x07)
PCAN_LAN = TPCANDevice(0x08)
Anmerkungen

Die PCAN-Geräte PCAN_PEAKCAN und PCAN_VIRTUAL werden im PCAN-Basic API nicht verwendet.

Werte
Name | Wert | Beschreibung
PCAN_NONE | 0 | Nicht definierte, unbekannte oder nicht ausgewählte PCAN Gerätedefinition.
PCAN_PEAKCAN | 1 | PCAN "Non-Plug And Play"-Geräte. Wird im PCAN-Basic API nicht verwendet.
PCAN_ISA | 2 | PCAN-ISA, PCAN-PC/104.
PCAN_DNG | 3 | PCAN-Dongle.
PCAN_PCI | 4 | PCAN-PCI, PCAN-cPCI, PCAN-miniPCI, PCAN-PC/104-Plus oder PCAN-PCI Express.
PCAN_USB | 5 | PCAN-USB oder PCAN-USB Pro.
PCAN_PCC | 6 | PCAN-PC Card.
PCAN_VIRTUAL | 7 | PCAN Virtual Hardware. Wird im PCAN-Basic API nicht verwendet.
PCAN_LAN | 8 | PCAN Gateway Geräte.


TPCANParameter

Willkommen
TPCANParameter

Beschreibt einen PCAN-Parameter oder eine PCAN-Definition zum Lesen oder Schreiben. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln. Bis auf wenige Ausnahmen muss ein Kanal immer zuerst initialisiert werden, bevor dessen Parameter gelesen oder gesetzt werden können.

Syntax
C++
#define TPCANParameter BYTE

#define PCAN_DEVICE_ID 0x01
#define PCAN_5VOLTS_POWER 0x02
#define PCAN_RECEIVE_EVENT 0x03
#define PCAN_MESSAGE_FILTER 0x04
#define PCAN_API_VERSION 0x05
#define PCAN_CHANNEL_VERSION 0x06
#define PCAN_BUSOFF_AUTORESET 0x07
#define PCAN_LISTEN_ONLY 0x08
#define PCAN_LOG_LOCATION 0x09
#define PCAN_LOG_STATUS 0x0A
#define PCAN_LOG_CONFIGURE 0x0B
#define PCAN_LOG_TEXT 0x0C
#define PCAN_CHANNEL_CONDITION 0x0D
#define PCAN_HARDWARE_NAME 0x0E
#define PCAN_RECEIVE_STATUS 0x0F
#define PCAN_CONTROLLER_NUMBER 0x10
#define PCAN_TRACE_LOCATION 0x11
#define PCAN_TRACE_STATUS 0x12
#define PCAN_TRACE_SIZE 0x13
#define PCAN_TRACE_CONFIGURE 0x14
#define PCAN_CHANNEL_IDENTIFYING 0x15
#define PCAN_CHANNEL_FEATURES 0x16
#define PCAN_BITRATE_ADAPTING 0x17
#define PCAN_BITRATE_INFO = 0x18
#define PCAN_BITRATE_INFO_FD = 0x19
#define PCAN_BUSSPEED_NOMINAL = 0x1A
#define PCAN_BUSSPEED_DATA = 0x1B
#define PCAN_IP_ADDRESS = 0x1C
#define PCAN_LAN_SERVICE_STATUS = 0x1D
#define PCAN_ALLOW_STATUS_FRAMES = 0x1E
#define PCAN_ALLOW_RTR_FRAMES = 0x1F
#define PCAN_ALLOW_ERROR_FRAMES = 0x20
#define PCAN_INTERFRAME_DELAY = 0x21
#define PCAN_ACCEPTANCE_FILTER_11BIT = 0x22
#define PCAN_ACCEPTANCE_FILTER_29BIT = 0x23
#define PCAN_IO_DIGITAL_CONFIGURATION = 0x24
#define PCAN_IO_DIGITAL_VALUE = 0x25
#define PCAN_IO_DIGITAL_SET = 0x26
#define PCAN_IO_DIGITAL_CLEAR = 0x27
#define PCAN_IO_ANALOG_VALUE = 0x28
#define PCAN_FIRMWARE_VERSION = 0x29
#define PCAN_ATTACHED_CHANNELS_COUNT = 0x2A
#define PCAN_ATTACHED_CHANNELS = 0x2B
#define PCAN_ALLOW_ECHO_FRAMES = 0x2C
#define PCAN_DEVICE_PART_NUMBER = 0x2D
Pascal OO
{$Z1}
TPCANParameter = (
    PCAN_DEVICE_ID = 1,
    PCAN_5VOLTS_POWER = 2,
    PCAN_RECEIVE_EVENT = 3,
    PCAN_MESSAGE_FILTER = 4,
    PCAN_API_VERSION = 5,
    PCAN_CHANNEL_VERSION = 6,
    PCAN_BUSOFF_AUTORESET = 7,
    PCAN_LISTEN_ONLY = 8,
    PCAN_LOG_LOCATION = 9,
    PCAN_LOG_STATUS = 10,
    PCAN_LOG_CONFIGURE = 11,
    PCAN_LOG_TEXT = 12,
    PCAN_CHANNEL_CONDITION = 13,
    PCAN_HARDWARE_NAME = 14,
    PCAN_RECEIVE_STATUS = 15,
    PCAN_CONTROLLER_NUMBER = 16,
    PCAN_TRACE_LOCATION = 17,
    PCAN_TRACE_STATUS = 18,
    PCAN_TRACE_SIZE = 19,
    PCAN_TRACE_CONFIGURE = 20,
    PCAN_CHANNEL_IDENTIFYING = 21,
    PCAN_CHANNEL_FEATURES = 22,
    PCAN_BITRATE_ADAPTING = 23,
    PCAN_BITRATE_INFO = 24,
    PCAN_BITRATE_INFO_FD = 25,
    PCAN_BUSSPEED_NOMINAL = 26,
    PCAN_BUSSPEED_DATA = 27,
    PCAN_IP_ADDRESS = 28,
    PCAN_LAN_SERVICE_STATUS = 29,
    PCAN_ALLOW_STATUS_FRAMES = 30,
    PCAN_ALLOW_RTR_FRAMES = 31,
    PCAN_ALLOW_ERROR_FRAMES = 32,
    PCAN_INTERFRAME_DELAY = 33,
    PCAN_ACCEPTANCE_FILTER_11BIT = 34,
    PCAN_ACCEPTANCE_FILTER_29BIT = 35,
    PCAN_IO_DIGITAL_CONFIGURATION = 36,
    PCAN_IO_DIGITAL_VALUE = 37,
    PCAN_IO_DIGITAL_SET = 38,
    PCAN_IO_DIGITAL_CLEAR = 39,
    PCAN_IO_ANALOG_VALUE = 40,
    PCAN_FIRMWARE_VERSION = 41,
    PCAN_ATTACHED_CHANNELS_COUNT = 42,
    PCAN_ATTACHED_CHANNELS = 43,
    PCAN_ALLOW_ECHO_FRAMES = 44,
    PCAN_DEVICE_PART_NUMBER = 45
);
C#
public enum TPCANParameter : byte
{
    PCAN_DEVICE_ID = 1,
    PCAN_5VOLTS_POWER = 2,
    PCAN_RECEIVE_EVENT = 3,
    PCAN_MESSAGE_FILTER = 4,
    PCAN_API_VERSION = 5,
    PCAN_CHANNEL_VERSION = 6,
    PCAN_BUSOFF_AUTORESET = 7,
    PCAN_LISTEN_ONLY = 8,
    PCAN_LOG_LOCATION = 9,
    PCAN_LOG_STATUS = 10,
    PCAN_LOG_CONFIGURE = 11,
    PCAN_LOG_TEXT = 12,
    PCAN_CHANNEL_CONDITION = 13,
    PCAN_HARDWARE_NAME = 14,
    PCAN_RECEIVE_STATUS = 15,
    PCAN_CONTROLLER_NUMBER = 16,
    PCAN_TRACE_LOCATION = 17,
    PCAN_TRACE_STATUS = 18,
    PCAN_TRACE_SIZE = 19,
    PCAN_TRACE_CONFIGURE = 20,
    PCAN_CHANNEL_IDENTIFYING = 21,
    PCAN_CHANNEL_FEATURES = 22,
    PCAN_BITRATE_ADAPTING = 23,
    PCAN_BITRATE_INFO = 24,
    PCAN_BITRATE_INFO_FD = 25,
    PCAN_BUSSPEED_NOMINAL = 26,
    PCAN_BUSSPEED_DATA = 27,
    PCAN_IP_ADDRESS = 28,
    PCAN_LAN_SERVICE_STATUS = 29,
    PCAN_ALLOW_STATUS_FRAMES = 30,
    PCAN_ALLOW_RTR_FRAMES = 31,
    PCAN_ALLOW_ERROR_FRAMES = 32,
    PCAN_INTERFRAME_DELAY = 33,
    PCAN_ACCEPTANCE_FILTER_11BIT = 34,
    PCAN_ACCEPTANCE_FILTER_29BIT = 35,
    PCAN_IO_DIGITAL_CONFIGURATION = 36,
    PCAN_IO_DIGITAL_VALUE = 37,
    PCAN_IO_DIGITAL_SET = 38,
    PCAN_IO_DIGITAL_CLEAR = 39,
    PCAN_IO_ANALOG_VALUE = 40,
    PCAN_FIRMWARE_VERSION = 41,
    PCAN_ATTACHED_CHANNELS_COUNT = 42,
    PCAN_ATTACHED_CHANNELS = 43,
    PCAN_ALLOW_ECHO_FRAMES = 44,
    PCAN_DEVICE_PART_NUMBER = 45,
}
C++ / CLR
public enum class TPCANParameter : Byte
{
    PCAN_DEVICE_ID = 1,
    PCAN_5VOLTS_POWER = 2,
    PCAN_RECEIVE_EVENT = 3,
    PCAN_MESSAGE_FILTER = 4,
    PCAN_API_VERSION = 5,
    PCAN_CHANNEL_VERSION = 6,
    PCAN_BUSOFF_AUTORESET = 7,
    PCAN_LISTEN_ONLY = 8,
    PCAN_LOG_LOCATION = 9,
    PCAN_LOG_STATUS = 10,
    PCAN_LOG_CONFIGURE = 11,
    PCAN_LOG_TEXT = 12,
    PCAN_CHANNEL_CONDITION = 13,
    PCAN_HARDWARE_NAME = 14,
    PCAN_RECEIVE_STATUS = 15,
    PCAN_CONTROLLER_NUMBER = 16,
    PCAN_TRACE_LOCATION = 17,
    PCAN_TRACE_STATUS = 18,
    PCAN_TRACE_SIZE = 19,
    PCAN_TRACE_CONFIGURE = 20,
    PCAN_CHANNEL_IDENTIFYING = 21,
    PCAN_CHANNEL_FEATURES = 22,
    PCAN_BITRATE_ADAPTING = 23,
    PCAN_BITRATE_INFO = 24,
    PCAN_BITRATE_INFO_FD = 25,
    PCAN_BUSSPEED_NOMINAL = 26,
    PCAN_BUSSPEED_DATA = 27,
    PCAN_IP_ADDRESS = 28,
    PCAN_LAN_SERVICE_STATUS = 29,
    PCAN_ALLOW_STATUS_FRAMES = 30,
    PCAN_ALLOW_RTR_FRAMES = 31,
    PCAN_ALLOW_ERROR_FRAMES = 32,
    PCAN_INTERFRAME_DELAY = 33,
    PCAN_ACCEPTANCE_FILTER_11BIT = 34,
    PCAN_ACCEPTANCE_FILTER_29BIT = 35,
    PCAN_IO_DIGITAL_CONFIGURATION = 36,
    PCAN_IO_DIGITAL_VALUE = 37,
    PCAN_IO_DIGITAL_SET = 38,
    PCAN_IO_DIGITAL_CLEAR = 39,
    PCAN_IO_ANALOG_VALUE = 40,
    PCAN_FIRMWARE_VERSION = 41,
    PCAN_ATTACHED_CHANNELS_COUNT = 42,
    PCAN_ATTACHED_CHANNELS = 43,
    PCAN_ALLOW_ECHO_FRAMES = 44,
    PCAN_DEVICE_PART_NUMBER = 45,
};
Visual Basic
Public Enum TPCANParameter As Byte
    PCAN_DEVICE_ID = 1
    PCAN_5VOLTS_POWER = 2
    PCAN_RECEIVE_EVENT = 3
    PCAN_MESSAGE_FILTER = 4
    PCAN_API_VERSION = 5
    PCAN_CHANNEL_VERSION = 6
    PCAN_BUSOFF_AUTORESET = 7
    PCAN_LISTEN_ONLY = 8
    PCAN_LOG_LOCATION = 9
    PCAN_LOG_STATUS = 10
    PCAN_LOG_CONFIGURE = 11
    PCAN_LOG_TEXT = 12
    PCAN_CHANNEL_CONDITION = 13
    PCAN_HARDWARE_NAME = 14
    PCAN_RECEIVE_STATUS = 15
    PCAN_CONTROLLER_NUMBER = 16
    PCAN_TRACE_LOCATION = 17
    PCAN_TRACE_STATUS = 18
    PCAN_TRACE_SIZE = 19
    PCAN_TRACE_CONFIGURE = 20
    PCAN_CHANNEL_IDENTIFYING = 21
    PCAN_CHANNEL_FEATURES = 22
    PCAN_BITRATE_ADAPTING = 23
    PCAN_BITRATE_INFO = 24
    PCAN_BITRATE_INFO_FD = 25
    PCAN_BUSSPEED_NOMINAL = 26
    PCAN_BUSSPEED_DATA = 27
    PCAN_IP_ADDRESS = 28
    PCAN_LAN_SERVICE_STATUS = 29
    PCAN_ALLOW_STATUS_FRAMES = 30
    PCAN_ALLOW_RTR_FRAMES = 31
    PCAN_ALLOW_ERROR_FRAMES = 32
    PCAN_INTERFRAME_DELAY = 33
    PCAN_ACCEPTANCE_FILTER_11BIT = 34
    PCAN_ACCEPTANCE_FILTER_29BIT = 35
    PCAN_IO_DIGITAL_CONFIGURATION = 36
    PCAN_IO_DIGITAL_VALUE = 37
    PCAN_IO_DIGITAL_SET = 38
    PCAN_IO_DIGITAL_CLEAR = 39
    PCAN_IO_ANALOG_VALUE = 40
    PCAN_FIRMWARE_VERSION = 41
    PCAN_ATTACHED_CHANNELS_COUNT = 42
    PCAN_ATTACHED_CHANNELS = 43
    PCAN_ALLOW_ECHO_FRAMES = 44
    PCAN_DEVICE_PART_NUMBER = 45
End Enum
Python
TPCANParameter = c_ubyte

PCAN_DEVICE_ID = TPCANParameter(0x01)
PCAN_5VOLTS_POWER = TPCANParameter(0x02)
PCAN_RECEIVE_EVENT = TPCANParameter(0x03)
PCAN_MESSAGE_FILTER = TPCANParameter(0x04)
PCAN_API_VERSION = TPCANParameter(0x05)
PCAN_CHANNEL_VERSION = TPCANParameter(0x06)
PCAN_BUSOFF_AUTORESET = TPCANParameter(0x07)
PCAN_LISTEN_ONLY = TPCANParameter(0x08)
PCAN_LOG_LOCATION = TPCANParameter(0x09)
PCAN_LOG_STATUS = TPCANParameter(0x0A)
PCAN_LOG_CONFIGURE = TPCANParameter(0x0B)
PCAN_LOG_TEXT = TPCANParameter(0x0C)
PCAN_CHANNEL_CONDITION = TPCANParameter(0x0D)
PCAN_HARDWARE_NAME = TPCANParameter(0x0E)
PCAN_RECEIVE_STATUS = TPCANParameter(0x0F)
PCAN_CONTROLLER_NUMBER = TPCANParameter(0x10)
PCAN_TRACE_LOCATION = TPCANParameter(0x11)
PCAN_TRACE_STATUS = TPCANParameter(0x12)
PCAN_TRACE_SIZE = TPCANParameter(0x13)
PCAN_TRACE_CONFIGURE = TPCANParameter(0x14)
PCAN_CHANNEL_IDENTIFYING = TPCANParameter(0x15)
PCAN_CHANNEL_FEATURES = TPCANParameter(0x16)
PCAN_BITRATE_ADAPTING = TPCANParameter(0x17)
PCAN_BITRATE_INFO = TPCANParameter(0x18)
PCAN_BITRATE_INFO_FD = TPCANParameter(0x19)
PCAN_BUSSPEED_NOMINAL = TPCANParameter(0x1A)
PCAN_BUSSPEED_DATA = TPCANParameter(0x1B)
PCAN_IP_ADDRESS = TPCANParameter(0x1C)
PCAN_LAN_SERVICE_STATUS = TPCANParameter(0x1D)
PCAN_ALLOW_STATUS_FRAMES = TPCANParameter(0x1E)
PCAN_ALLOW_RTR_FRAMES = TPCANParameter(0x1F)
PCAN_ALLOW_ERROR_FRAMES = TPCANParameter(0x20)
PCAN_INTERFRAME_DELAY = TPCANParameter(0x21)
PCAN_ACCEPTANCE_FILTER_11BIT = TPCANParameter(0x22)
PCAN_ACCEPTANCE_FILTER_29BIT = TPCANParameter(0x23)
PCAN_IO_DIGITAL_CONFIGURATION = TPCANParameter(0x24)
PCAN_IO_DIGITAL_VALUE = TPCANParameter(0x25)
PCAN_IO_DIGITAL_SET = TPCANParameter(0x26)
PCAN_IO_DIGITAL_CLEAR = TPCANParameter(0x27)
PCAN_IO_ANALOG_VALUE = TPCANParameter(0x28)
PCAN_FIRMWARE_VERSION = TPCANParameter(0x29)
PCAN_ATTACHED_CHANNELS_COUNT = TPCANParameter(0x2A)
PCAN_ATTACHED_CHANNELS = TPCANParameter(0x2B)
PCAN_ALLOW_ECHO_FRAMES = TPCANParameter(0x2C)
PCAN_DEVICE_PART_NUMBER = TPCANParameter(0x2D)
Werte

Name | Wert | Datentyp | Beschreibung
PCAN_DEVICE_ID | 1 | Integer | PCAN-Parameter "device ID".
PCAN_5VOLTS_POWER | 2 | Integer | PCAN-Parameter "5-volt power".
PCAN_RECEIVE_EVENT | 3 | Handle | PCAN receive event handler-Parameter.
PCAN_MESSAGE_FILTER | 4 | Integer | PCAN Botschaftsfilter-Parameter.
PCAN_API_VERSION | 5 | String | PCAN-Basic API Versionsparameter.
PCAN_CHANNEL_VERSION | 6 | String | PCAN device channel Versionsparameter.
PCAN_BUSOFF_AUTORESET | 7 | Integer | PCAN "reset on bus-off" -Parameter.
PCAN_LISTEN_ONLY | 8 | Integer | PCAN "listen-only" -Parameter.
PCAN_LOG_LOCATION | 9 | String | Verzeichnispfad für Debug-Dateien.
PCAN_LOG_STATUS | 10 | Integer | Aktivierungszustand der Debug-Ausgaben.
PCAN_LOG_CONFIGURE | 11 | Integer | Konfiguration der Debug-Ausgaben (LOG_FUNCTION_***).
PCAN_LOG_TEXT | 12 | String | Einfügen von eigenem Text in die Debug-Datei.
PCAN_CHANNEL_CONDITION | 13 | Integer | Verfügbarkeitszustand eines PCAN-Kanals.
PCAN_HARDWARE_NAME | 14 | String | PCAN "hardware name" parameter.
PCAN_RECEIVE_STATUS | 15 | Integer | "Receive Status" -Parameter für eingehende Nachrichten.
PCAN_CONTROLLER_NUMBER | 16 | Integer | Der Index eines CAN-Controllers in einem PCAN Gerät.
PCAN_TRACE_LOCATION | 17 | String | Verzeichnispfad für Trace-Dateien.
PCAN_TRACE_STATUS | 18 | Integer | Aktivierungszustand der Trace-Aufzeichnung.
PCAN_TRACE_SIZE | 19 | Integer | Konfiguration der maximalen Größe für eine Trace-Datei.
PCAN_TRACE_CONFIGURE | 20 | Integer | Konfiguration der Trace-Ausgabe (TRACE_FILE_***).
PCAN_CHANNEL_IDENTIFYING | 21 | Integer | Aktivierungszustand des USB-Kanal-Identifizierungsvorganges.
PCAN_CHANNEL_FEATURES | 22 | Integer | Fähigkeiten eines PCAN-Gerät (FEATURE_ ***).
PCAN_BITRATE_ADAPTING | 23 | Integer | Bindung an eine bestehende Verbindung mit unbekannten / verschiedene Bitrate.
PCAN_BITRATE_INFO | 24 | Integer | Aktuelle Bitrate als BTR0BTR1 Wert (Standard CAN).
PCAN_BITRATE_INFO_FD | 25 | String | Aktuelle Bitrate als FD String Wert (CAN-FD).
PCAN_BUSSPEED_NOMINAL | 26 | Integer | Aktuelle nominale CAN-Bus-Geschwindigkeit in Bit/Sekunde.
PCAN_BUSSPEED_DATA | 27 | Integer | Aktuelle CAN-Datengeschwindigkeit in Bits/Sekunde.
PCAN_IP_ADDRESS | 28 | String | Remote-Adresse als IPv4-formatierte String.
PCAN_LAN_SERVICE_STATUS | 29 | Integer | Ausführstatus des LAN-Dienstes (Virtual PCAN-Gateway)
PCAN_ALLOW_STATUS_FRAMES | 30 | Integer | "Receive Status" -Parameter für Statusmeldungen.
PCAN_ALLOW_RTR_FRAMES | 31 | Integer | "Receive Status" -Parameter für RTR-Botschaften.
PCAN_ALLOW_ERROR_FRAMES | 32 | Integer | "Receive Status" -Parameter für CAN Error-Frames.
PCAN_INTERFRAME_DELAY | 33 | Integer | Verzögerung, in Mikrosekunden, zwischen sendenden Frames.
PCAN_ACCEPTANCE_FILTER_11BIT | 34 | 64-Bit Integer | Akzeptanzfilter über Code und Maske für 11-Bit CAN IDs.
PCAN_ACCEPTANCE_FILTER_29BIT | 35 | 64-Bit Integer | Akzeptanzfilter über Code und Maske für 29-Bit CAN IDs.
PCAN_IO_DIGITAL_CONFIGURATION | 36 | Integer | Aktivierung aller digitalen Pins als digitale Ausgänge.
PCAN_IO_DIGITAL_VALUE | 37 | Integer | Setzen aller digitalen Pin-Werte.
PCAN_IO_DIGITAL_SET | 38 | Integer | Selektive Setzen des Werts von digitalen Pins auf "High".
PCAN_IO_DIGITAL_CLEAR | 39 | Integer | Selektive Setzen des Werts von digitalen Pins auf "Low".
PCAN_IO_ANALOG_VALUE | 40 | Integer | Wertablesung eines einzelnen analogen Pins.
PCAN_FIRMWARE_VERSION | 41 | String | PCAN device Firmware Versionsparameter.
PCAN_ATTACHED_CHANNELS_COUNT | 42 | Integer | Anzahl der verfügbaren PCAN-Kanäle, die an ein System angeschlossen sind.
PCAN_ATTACHED_CHANNELS | 43 | Array von TPCANChannelInformation | Informationen zu verfügbaren PCAN-Kanälen, die an ein System angeschlossen sind.
PCAN_ALLOW_ECHO_FRAMES | 44 | Integer | "Receive Status" -Parameter für Echo-CAN-Frames.
PCAN_DEVICE_PART_NUMBER | 45 | String | Geräte Teilenummer von PEAK (IPEH-Nummer).
Eigenschaften

PCAN_DEVICE_ID

Zugriff:

Kanalstatus:

  • Zum Lesen: Der Kanal kann initialisiert oder nicht-initialisiert sein.
  • Zum Schreiben: Der Kanal muss initialisiert sein, um diesen Parameter setzen zu können.

Beschreibung: Dieser Parameter dient zur Unterscheidung von 2 (oder mehr) gleichen PCAN-Geräten am selben PC. Der Parameterwert ist semipermanent, d.h. die Gerätenummer ist nach Trennen und Verbinden des Geräts immer noch /wieder vorhanden.

Wertebereich: Abhängig von der Firmware-Version hat dieser Parameter einen Wertebereich zw. [1..255] oder [1..4294967295].

Standardwert: Falls dieser Parameter bisher nicht versorgt wurde, wird der größtmögliche Wert verwendet (abhängig von der Firmware-Version), also bei 8-bits: 255 (FFh), bei 32 bits: 4294967295 (FFFFFFFFh).

PCAN-Gerät: PCAN-USB, PCAN-PCI, PCAN-LAN.

Anmerkungen:

  • Dieser Parameter hieß ursprünglich PCAN_DEVICE_NUMBER.
  • PCAN-PCI: Nur FPGA-basierte Geräte. Erfordert eine Gerätetreiberversion größer oder gleich 4.2.0.
  • PCAN-LAN: Nur Geräte mit einer Firmware-Version ab 2.8.2. Erfordert eine Gerätetreiberversion größer oder gleich 4.2.0.

PCAN_5VOLTS_POWER

Zugriff:

Kanalstatus:

  • Zum Lesen: Der Kanal kann initialisiert oder nicht-initialisiert sein.
  • Zum Schreiben: Der Kanal muss initialisiert sein, um diesen Parameter setzen zu können.

Beschreibung: Mit diesem Parameter kann bei der PCAN-PC Card eine Hilfsspannung von 5 Volt nach außen auf den DSub-9 Stecker (siehe Hardware-Handbuch) gelegt werden. Damit können externe Buskonverter direkt aufgesteckt und betrieben werden (z. B. AU-5790 / TJA-1054).

Wertebereich: Dieser Parameter kann folgende Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: PCAN-PC Card, PCAN-HUB.

PCAN_RECEIVE_EVENT

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter veranlasst einen PCAN-Gerätetreiber, eine Benachrichtigung der Anwendung vorzunehmen, wenn er eine Empfangsbotschaft in deren Empfangspuffer geschrieben hat. Dadurch können die Anwendungen schneller reagieren und gehen effizienter mit der Rechenzeit um.

Wertebereich: Dieser Parameter enthält entweder ein handle (das durch die Windows API Funktion [image] CreateEvent versorgt wird) zu einem Ereignisobjekt, oder es enthält den Wert 0 (IntPtr.Zero) in einer "managed" Laufzeitumgebung. Durch Schreiben des Parameterwerts 0 wird der Parameter im PCAN-Treiber zurückgesetzt. Wird beim Lesen eine 0 zurückgeliefert, heißt das, dass kein handle gesetzt ist. Weitergehende Informationen zu diesem Thema finden sich in Verwenden von Events.

Standardwert: Kein handle (0).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_MESSAGE_FILTER

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter gestattet ein einfaches Aktivieren des Botschaftsfilters für einen PCAN-Kanal. Damit kann man den Filter vollständig öffnen oder vollständig schließen.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_FILTER_OPEN, PCAN_FILTER_CLOSE. Beim Rücklesen ist ein dritter Wert möglich: PCAN_FILTER_CUSTOM zeigt an, dass ein bestimmter Empfangs-ID-Bereich eingestellt ist. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Vollständig offen (PCAN_FILTER_OPEN).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_API_VERSION

Zugriff:

Kanalstatus: -

Beschreibung: Dieser Parameter informiert über die Version der PCAN-Basic API Implementierung.

Wertebereich: Der Wert wird als null-terminierte Zeichenkette zurückgeliefert. Diese hat folgendes Format: x.x.x.x für Hauptversion, Nebenversion, Korrekturversion und laufende Kompilatsnummer. Es entspricht der binären Versionsinformation zur API in zwei 32-bit Integer-Zahlen, hier hinterlegt in vier 16-bit Integer-Zahlen. Die Länge der Zeichenkette beträgt maximal 24 bytes (vier 5 byte-Zahlen zur Darstellung der einzelnen Versionsnummern, drei Separatoren (, oder .) und den Null-Terminator.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte, einschließlich Kanal PCAN_NONEBUS.

PCAN_CHANNEL_VERSION

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter informiert über die Version des Gerätetreibers zu einem CAN-Kanal.

Wertebereich: Der Wert wird als null-terminierte Zeichenkette zurückgeliefert, die Versionsnummer, Treibername und Copyright-Information zum Treiber des gewünschten Kanals enthält. Die Länge der Zeichenkette beträgt maximal 256 bytes (inkl. des Null-Terminators) .

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_BUSOFF_AUTORESET

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter veranlasst den PCAN-Treiber zum automatischen Reset des CAN-Controllers, sobald ein Bus-Off-Zustand festgestellt wird. Da während dieses Zustands keine Kommunikation auf dem Bus stattfindet, kann bereits auf Treiberebene mit einem Reset reagiert werden, um die Anwendung nicht mit Behandlungsroutinen zu überfrachten.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Das Zurücksetzen der Hardware hat eine Laufzeit von ~ 500 Millisekunden. Nach Erhalt des PCAN_ERROR_BUSOFF Fehlers, sollte eine Anwendung dieser Zeit warten, bevor sie erneut versucht zu lesen oder zu schreiben.

PCAN_LISTEN_ONLY

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Mit diesem Parameter kann die CAN Hardware in den Listen-Only Zustand versetzt werden. Damit nimmt der CAN-Controller nicht aktiv am Busbetrieb teil (z.B. Senden von CAN Botschaften), sondern bleibt passiv (CAN Monitor), was zur Analyse des CAN-Verkehrs auf einem PCAN-Kanal genutzt werden kann. Weitere Information dazu findet man im Philips Data Sheet "SJA1000 Stand-alone CAN controller".

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Listen-Only ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte* (außer PCAN_NONEBUS Kanal) mit SJA-1000 CAN Controller.

Anmerkungen: Setzen Sie diesen Parameter, ohne vorher den Kanal initialisiert zu haben, um ihn als "vor-initialisiert" zu markieren. Dies bedeutet, das der Kanal so bald wie möglich in "Listen-Only" Zustand versetzt wird, nachdem er erfolgreich verbunden wurde, durch CAN_Initialize (Klassenmethode: Initialize). Sobald der Kanal wieder getrennt wird, werden weitere Initialisierungen dieses Kanal in normalen Modus ausgeführt. Es ist erforderlich diesen Parameter, vor jeder Initialisierungsvorgang zu setzen, wenn das oben beschriebene Verhalten gewünscht ist. Dies ist nützlich zur Vermeidung oder Minimierung von Schiedsverfahren Probleme beim anbinden von CAN-Netzwerken.

* Der Listen-Only-Modus kann für PCAN-LAN-Geräte über diesen Parameter nicht eingestellt werden. Diese Einstellung kann nur direkt am Gerät über seine Konfigurationsoberfläche vorgenommen werden.

PCAN_LOG_LOCATION

Zugriff:

Kanalstatus: -

Beschreibung: Mit diesem Parameter hat man Zugriff auf den Ablageort der Debug-Datei, die durch das PCAN-Basic API während einer Debug-Sitzung geschrieben wird. Durch Versorgen des Parameters wird die Aufzeichnung automatisch gestartet. Geschieht dies während einer laufenden Debug-Aufzeichnung, wird diese geschlossen und eine neue Aufzeichnung wird auf dem neuen Pfad eröffnet. Der Dateiname ist im API festgelegt: immer "PCANBasic.log".

Wertebereich: Der Wert muss ein vollqualifizierter und gültiger Pfad zu einem vorhandenen Verzeichnis auf dem PC sein. Die Länge des Pfadnamens ist nicht begrenzt, es wird aber die Einhaltung der Obergrenze MAX_PATH empfohlen. Weitere Information dazu siehe [image] Benennung von Dateien, Pfade und Namespaces (Englisch).

Standardwert: Verzeichnisname des aufrufenden Prozesses.

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_LOG_STATUS

Zugriff:

Kanalstatus: -

Beschreibung: Mit diesem Parameter wird der Aktivitätszustand einer Debugsitzung des PCAN-Basic API's gesteuert. Wird der Zustand des Loggers auf ON gesetzt, ohne dass ein Pfadname für das Logfile versorgt wurde, bzw. ohne dass die zu loggende Information spezifiziert wurde, werden die Standardeinstellungen verwendet.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_LOG_CONFIGURE

Zugriff:

Kanalstatus: -

Beschreibung: Mit diesem Parameter kann die zu loggende Information spezifiziert werden, die während einer Debug-Sitzung des PCAN-Basic API aufgezeichnet wird.

Wertebereich: Der Wert muss einer der folgenden (oder einer Kombination daraus) sein:

  • LOG_FUNCTION_DEFAULT: Dieser Wert ist immer aktiv. Er steht für die Standardinformation "unerwartete Ausnahme" (z. B. Speicherschutzverletzung), die immer aufgezeichnet wird. Solche Einträge werden mit dem Wort "EXCEPTION"* im Logfile gekennzeichnet. Durch Setzen dieses Wertes wird die Standardeinstellung wiederhergestellt.
  • LOG_FUNCTION_ENTRY: Diese Einstellung erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine API Funktion aufgerufen wurde. Solche Einträge werden mit dem Wort "ENTRY"* im Logfile gekennzeichnet.
  • LOG_FUNCTION_PARAMETERS: Diese Einstellung erzeugt einen zusätzlichen Eintrag im Logfile, der bei Aufruf einer API-Funktion den Funktionsnamen und die Funktionsparameter mit ihren Werten enthält. Solche Einträge werden mit dem Wort "PARAMETERS"* im Logfile gekennzeichnet.
  • LOG_FUNCTION_LEAVE: Diese Einstellung erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine API Funktion beendet wurde. Solche Einträge werden mit dem Wort "EXIT"* im Logfile gekennzeichnet.
  • LOG_FUNCTION_WRITE: Diese Einstellung erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine CAN-Botschaft mittels Funktion CAN_Write (Klassenmethode: Write) gesendet wurde. Solche Einträge werden mit dem Wort "CHANNEL 0xXX (OUT)"* im Logfile gekennzeichnet, wobei XX die Kanalnummer (hexadezimal) angibt. Die vollständige Botschaft wird ebenfalls als Text (hexadezimal) abgelegt.
  • LOG_FUNCTION_READ: Diese Einstellung erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine CAN-Botschaft mittels Funktion CAN_Read (Klassenmethode: Read) gelesen wurde. Solche Einträge werden mit dem Wort "CHANNEL 0xXX (IN)"* im Logfile gekennzeichnet, wobei XX die Kanalnummer (hexadezimal) angibt. Die vollständige Botschaft wird ebenfalls als Text (hexadezimal) abgelegt.

* Das PCAN-Basic API unterstützt mehrere Sprachen. Für die Log-Datei wird die Standardsprache des PCs verwendet. Sollte die PC-Einstellung vom API nicht unterstützt werden, wird Englisch verwendet.

Standardwert: Ausnahmen und Fehler (LOG_FUNCTION_DEFAULT).

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_LOG_TEXT

Zugriff:

Kanalstatus: -

Beschreibung: Mit diesem Parameter kann zusätzlicher Text in die Log-Datei eingefügt werden, die das PCAN-Basic API während einer Debug-Sitzung erzeugt. Durch Versorgen des Parameters wird die Aufzeichnung automatisch gestartet.

Diese Funktion ist nützlich, wenn man Spurpunkte bem Ablauf einer PCAN-Basic basierten Anwendung aufzeichnen will. Außerdem kann eine Anwendung so ihr eigenes Logfile generieren, indem sie nur die Defaulteinstellung LOG_FUNCTION_DEFAULT plus den zusätzlichen PCAN_LOG_TEXT verwendet. So wird nur vom Benutzer gewünschter Text ins Logfile geschrieben. Der Dateiname ist im API festgelegt: immer "PCANBasic.log".

Wertebereich: Es muss eine null-terminierte Zeichenkette angegeben werden. Die Länge der Zeichenkette ist nicht begrenzt, es wird aber die Einhaltung der Obergrenze MAX_PATH empfohlen. Weitere Information dazu siehe [image] Benennung von Dateien, Pfade und Namespaces (Englisch).

Standardwert: -

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_CHANNEL_CONDITION

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Bevor man sich mit einem PCAN-Kanal verbindet (connect), sollte mit diesem Parameter die an den PC angeschlossene PCAN-Hardware detektiert und geprüft werden. Zudem kann auf diese Weise dem Benutzer eine Auswahlliste der verfügbaren Kanäle für die folgende Sitzung präsentiert werden.

Wertebereich: Der Parameter kann folgende Werte zurückliefern: PCAN_CHANNEL_UNAVAILABLE, PCAN_CHANNEL_AVAILABLE, PCAN_CHANNEL_OCCUPIED, PCAN_CHANNEL_PCANVIEW.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_HARDWARE_NAME

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter informiert über den Namen der Hardware zu einem CAN-Kanal. Damit kann man zwischen verschiedene Modelle eines Geräts unterscheiden, z.B. PCAN-USB und PCAN-USB Pro.

Wertebereich: Der Wert wird als null-terminierte Zeichenkette zurückgeliefert. Diese enthält der Hardware-Name des angegebenen Kanal. Die Länge der Zeichenkette beträgt maximal 32 bytes (inkl. des Null-Terminators).

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_RECEIVE_STATUS

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Mit diesem Parameter kann der Benutzer den Empfang von Botschaften an einem Kanal ein- oder ausschalten, unabhängig vom Wert seines Empfangs-Filter. Wenn "Empfang-Status"aktiv ist (ON), werden eingehende Botschaften an den Benutzer, durch die Anwendung der CAN_Read Funktion (Klassenmethode: Read) weitergeleitet. Wenn "Empfangsstatus" deaktiviert ist (OFF), werden alle eingehende Botschaften aus dem Empfangspuffer gelöscht, und jede weiteren Aufruf der Funktion CAN_Read wird mit den Fehler PCAN_ERROR_QRCVEMPTY scheitern. Der Acceptance-Filter des Kanals bleibt unverändert (andere Anwendungen, die mit derselben PCAN-Hardware arbeiten, werden nicht gestört).

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Aktiviert (PCAN_PARAMETER_ON).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Setzen Sie diesen Parameter, ohne vorher den Kanal initialisiert zu haben, um ihn als "vor-initialisiert" zu markieren. Dies bedeutet, das der Kanal so bald wie möglich den "Empangsstatus" setzt, nachdem er erfolgreich verbunden wurde, durch CAN_Initialize (Klassenmethode: Initialize). Sobald der Kanal wieder getrennt wird, werden weitere Initialisierungen dieses Kanals den Standardwert des Parameters (ON) verwenden. Dies ist nützlich zur Vermeidung der Empfang von Botschaften, unmittelbar nach Anbindung von CAN-Netzwerken, oder vor der Einstellung des Empfangsfilter der Anwendung.

PCAN_CONTROLLER_NUMBER

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter beginnt bei 0 und nummeriert die CAN-Controller innerhalb einer Hardware. Der Index wird verwendet, um gezielt einen bestimmten CAN-Kanal in einem mehrkanaligen Gerät anzusprechen, z.B. "0" oder "1" bei einem PCAN-USB Pro.

Wertebereich: Ein Zähler im Bereich [0 ..n-1], wobei n die Zahl der verbauten CAN-Kanäle eines Geräts ist.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_TRACE_LOCATION

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Wert dient zum Festlegen des Speicherorts für die PCAN-Trace Datei, die während einer Aufzeichnung durch das PCAN-Basic API generiert wird. Das Kommando bewirkt außerdem, daß bei laufender Aufzeichnung durch das API die aktive Datei geschlossen und eine neue Datei am neuen Speicherort angelegt wird.

Wertebereich: Der Wert muss ein vollqualifizierter und gültiger Pfad zu einem vorhandenen Verzeichnis auf dem PC sein. Die Länge des Pfadnamens ist nicht begrenzt, es wird aber die Einhaltung der Obergrenze MAX_PATH empfohlen. Weitere Information dazu siehe [image] Benennung von Dateien, Pfade und Namespaces (Englisch). Wird ein leerer String übergeben ("", NULL-Wert), verwendet das API den Defaultwert für diesen Parameter.

Standardwert: Verzeichnisname des aufrufenden Prozesses.

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Der Dateiname kann nicht spezifiziert werden. Stattdessen wird der Name der aktuellen Verbindung und ein laufender Zähler verwendet (z.B. PCAN_PCIBUS1_1.trc). Eine Erweiterung dieses Namens kann jedoch mittels Kommando PCAN_TRACE_CONFIGURE vorgenommen werden.

PCAN_TRACE_STATUS

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Wert dient zur Steuerung des Aktivitätszustands einer Aufzeichnung des PCAN-Basic API. Wenn der Zustand auf ON gesetzt wird, ohne daß zuvor ein Speicherort für die PCAN-Trace Datei angegeben wurde, oder ohne daß die Speicherungsmethode konfiguriert wurde, startet der Aufzeichnungsprozeß mit den Defaultwerten. Eine Aufzeichnung kann nicht gestartet werden, wenn die Speichermethode "Überschreiben" nicht gesetzt ist und bereits eine Datei gleichen Namens existiert.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Damit Nachrichten in der Trace-Datei geschrieben werden, muss die Empfangsqueue aktiv gelesen werden, auch wenn die Anwendung nur sendet.

PCAN_TRACE_SIZE

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Wert dient zum Festlegen der maximalen Größe (in Megabyte), die für eine einzelne PCAN-Trace Datei zulässig ist. Setzen der Größe während einer laufenden Aufzeichnung ist nicht erlaubt.

Wertebereich: Eine Zahl in Bereich 1..100, die die Dateigröße in Megabyte angibt. Der Wert 0 veranlaßt das API zur Verwendung des Defaultwerts. Setzen eines größeren Werts als 100 ist nicht erlaubt.

Standardwert: 10 Megabyte.

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_TRACE_CONFIGURE

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Wert dient zur Konfiguration des Aufzeichnungsprozesses und der PCAN-Trace Datei, die während einer Aufzeichnung durch das PCAN-Basic API generiert wird. Konfigurieren einer Datei während einer laufenden Aufzeichnung ist nicht erlaubt.

Wertebereich: Der Wert muss aus der folgenden Auswahl (oder einer Kombination daraus) stammen:

  • TRACE_FILE_SINGLE: Dieser Wert repräsentiert die Defaultkonfiguration für ein Aufzeichnung. Dabei wird eine einzelne PCAN-Trace Datei zur Aufzeichnung verwendet. Diese Datei wird ab Prozeßstart beschrieben, bis die konfigurierte Maximalgröße erreicht ist (siehe PCAN_TRACE_SIZE). Dann wird die Aufzeichnung gestoppt.
  • TRACE_FILE_SEGMENTED: Dieser Wert veranlaßt das API, die Aufzeichnung in mehrere PCAN-Trace Dateien zu segmentieren. Wenn eine PCAN-Trace Datei die maximale konfigurierte Größe (see PCAN_TRACE_SIZE) erreicht, wird automatisch eine neue Datei angelegt, damit der Aufzeichnungsprozess fortgesetzt werden kann.
  • TRACE_FILEDATE: Dieser Wert veranlaßt das API, das Startdatum der Aufzeichnung in den Dateinamen mit aufzunehmen. Das verwendete Format ist YYYYMMDD, vier Digits für das Jahr, zwei für den Monat und zwei für den Tag, z.B. "20130228_PCAN_USBBUS_1" für den 28. Februar 2013. Falls zusätzlich TRACE_FILE_TIME konfiguriert wurde, startet der Name trotzdem immer mit dem Datum, z.B. "20130228140733_PCAN_USBBUS1_1.trc".
  • TRACE_FILE_TIME: Dieser Wert veranlaßt das API, die Startzeit der Aufzeichnung in den Dateinamen mit aufzunehmen. Das verwendete Format ist HHMMSS zwei Digits für die Stunde (24h Format), zwei für die Minuten und zwei für die Sekunden, z.B. "140733_PCAN_USBBUS_1" für den 14:07:33 Uhr. Falls zusätzlich TRACE_FILE_DATE konfiguriert wurde, startet der Name dann immer mit dem Datum, z.B. "20130228140733_PCAN_USBBUS1_1.trc".
  • TRACE_FILE_OVERWRITE: Dieser Wert bewirkt ein Überschreiben einer vorhandenen PCAN-Trace Datei, wenn eine neue Aufzeichnung startet. Ist dieser Wert nicht konfiguriert und eine PCAN-Trace Datei gleichen Namens existiert bereits, wird der Start der Aufzeichnung nicht erlaubt.

Standardwert: TRACE_FILE_SINGLE (einzelne Datei, nicht überschreibend, mit Standardbenennung).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_CHANNEL_IDENTIFYING

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Mit diesem Parameter wird der Aktivitätszustand eines "Identifizierungsvorganges" eines Kanals auf USB-Geräten gesteuert. Das Verfahren besteht darin, die dem angegebenen Kanal zugeordnete LED blinken zu lassen.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN-USB Geräte.

Anmerkungen: Dieses Identifizierungverfahren steht nur für USB-basierte Hardware (PCAN-USB, PCAN-USB Pro und PCAN-USB Hub) zur Verfügung. Je nach Art der verwendeten Hardware, kann das Blinken der LED unterschiedlich ausfallen (in Farbe und Blinkfrequenz). Nur ein Kanal darf gleichzeitig blinken.

PCAN_CHANNEL_FEATURES

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter informiert über die Besonderheiten eines PCAN-Kanals.

Wertebereich: Der Wert stammt aus der folgenden Auswahl (oder einer Kombination daraus):

  • FEATURE_FD_CAPABLE: Dieser Wert gibt an, ob eine Hardware FD fähig ist (flexible Datenrate unterstützt).
  • FEATURE_DELAY_CAPABLE: Dieser Wert gibt an, ob eine Hardware Verzögerungen zwischen sendenden Frames erlaubt.

Standardwert: Ein Wert von 0, was auf "keine Besonderheiten" hinweist.

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: FD-Hardware muss mit CAN_InitializeFD initialisiert werden (Klassenmethode: InitializeFD), um deren FD Fähigkeiten zu nutzen. Folglich, die Funktionen CAN_ReadFD (Klassenmethode: ReadFD) und CAN_WriteFD(Klassenmethode: WriteFD) müssen für die Datenübertragung verwendet werden.

PCAN_BITRATE_ADAPTING

Zugriff:

Kanalstatus:

  • Zum Lesen: Der Kanal kann initialisiert oder nicht-initialisiert sein.
  • Zum Schreiben: Der Kanal muss nicht-initialisiert sein, um diesen Parameter setzen zu können.

Beschreibung: Dieser Parameter wird verwendet, um eine Initialisierung zu erzwingen, auch wenn der PCAN-Kanal von einer PCAN-View Software mit einem anderen oder unbekannten Bitrate verwendet wird. Die Initialisierungsfunktion gibt ein Fehler PCAN_ERROR_CAUTION zurück, wenn die Bitrate, die als Parameter übergeben worden ist, anders ist als die, die verwendet wird.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Nach dem Verbinden, kann eine Anwendung die Bitrate ermitteln, die derzeit verwendet wird, durch Aufrufen der CAN_GetValue-Funktion (Klassenmethode: GetValue).

PCAN_BITRATE_INFO

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter wird verwendet, um den aktuell konfigurierten Kommunikations-Geschwindigkeit eines PCAN-Kanals zu lesen, der als standard CAN verwendet wird. Die Bitrate wird als BTR0-BTR1 Wert zurückgegeben.

Wertebereich: Eine Zahl in Bereich 0..65535 (WORD-Wert).

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_BITRATE_INFO_FD

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter wird verwendet, um den aktuell konfigurierten Kommunikations-Geschwindigkeit eines PCAN-Kanals zu lesen, der als CAN-FD verwendet wird. Die Bitrate wird als parametrisierter String (FD Bitrate String) zurückgegeben.

Wertebereich: Eine Zeichenkette, die eine FD-Bitrate darstellt. Siehe FD Bitrate für weitere Informationen.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_BUSSPEED_NOMINAL

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um den aktuell konfigurierten Nominal-Geschwindigkeit eines PCAN-Kanals zu lesen.

Wertebereich: Eine Zahl, die die Nominal-Geschwindigkeit, als die Anzahl Bits pro Sekunden, darstellt.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_BUSSPEED_DATA

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um den aktuell konfigurierten Geschwindigkeit für Datenübertragung (Bit Rate Switch) eines PCAN-Kanals zu lesen.

Wertebereich: Eine Zahl, die die Geschwindigkeit der Datenübertragung für BRS, als die Anzahl Bits pro Sekunden, darstellt.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Die für die Datenübertragung verwendete Geschwindigkeit ist die gleiche wie die Nominale für Geräte, die keine flexiblen Datenrate unterstützen.

PCAN_IP_ADDRESS

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter wird verwendet, um den konfigurierten Adresse für IP-Kommunikation eines PCAN-Kanals zu lesen.

Wertebereich: Eine Zeichenkette, die eine IPv4-Adresse darstellt.

Standardwert: -

PCAN-Gerät: PCAN-LAN (PCAN-Gateway Ethernet/Wireless Geräte).

PCAN_LAN_SERVICE_STATUS

Zugriff:

Kanalstatus: -

Beschreibung: Dieser Parameter wird verwendet, um den Ausführstatus des Systemdienstes zu erhalten, der Teil der Virtual PCAN-Gateway Lösung ist.

Wertebereich: Der Parameter kann folgende Werte zurückliefern: SERVICE_STATUS_RUNNING, SERVICE_STATUS_STOPPED.

Standardwert: -

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

Anmerkungen: Dieser Parameter ist nur relevant in PCAN-LAN-Umgebungen (Benutzung von PCAN-Gateway Ethernet/Wireless Geräte)

PCAN_ALLOW_STATUS_FRAMES

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter kann der Benutzer den Empfang von Botschaften vom Typ "PCAN_MESSAGE_STATUS" an einem Kanal ein- oder ausschalten. Wenn "PCAN_ALLOW_STATUS_FRAMES" aktiv ist (ON), werden generierte Statusmeldungen vom Treiber an den Benutzer, durch die Anwendung der CAN_Read/CAN_ReadFD Funktionen (Klassenmethoden: Read, ReadFD) weitergeleitet. Wenn "PCAN_ALLOW_STATUS_FRAMES" deaktiviert wird (OFF), wird der Empfang von Statusmeldungen im Treiber für diesen Benutzer deaktiviert.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Aktiviert (PCAN_PARAMETER_ON).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_ALLOW_RTR_FRAMES

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter kann der Benutzer den Empfang von Botschaften vom Typ "PCAN_MESSAGE_RTR" an einem Kanal ein- oder ausschalten. Wenn "PCAN_ALLOW_RTR_FRAMES" aktiv ist (ON), werden eingehende RTR-Botschaften vom Treiber an den Benutzer, durch die Anwendung der CAN_Read/CAN_ReadFD Funktionen (Klassenmethoden: Read, ReadFD) weitergeleitet. Wenn "PCAN_ALLOW_RTR_FRAMES" deaktiviert wird (OFF), wird der Empfang von RTR-Botschaften im Treiber für diesen Benutzer deaktiviert.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Aktiviert (PCAN_PARAMETER_ON).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_ALLOW_ERROR_FRAMES

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter kann der Benutzer den Empfang von Botschaften vom Typ "PCAN_MESSAGE_ERRFRAME" an einem Kanal ein- oder ausschalten. Wenn "PCAN_ALLOW_ERROR_FRAMES" aktiv ist (ON), werden generierte Error-Frames vom Treiber an den Benutzer, durch die Anwendung der CAN_Read/CAN_ReadFD Funktionen (Klassenmethoden: Read, ReadFD) weitergeleitet. Wenn "PCAN_ALLOW_ERROR_FRAMES" deaktiviert wird (OFF), wird der Empfang von Error-Frames im Treiber für diesen Benutzer deaktiviert.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_INTERFRAME_DELAY

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um eine Verzögerung in Mikrosekunden zwischen sendenden Frames zu konfigurieren. Wenn dieser Wert größer als 0 ist, fügt der Treiber diesen Wert als Pause zwischen jedem übertragenen CAN-Frame ein. Andersfall werden die CAN-Frames so schnell wie möglich gesendet.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..n], wobei n der maximale Wert ist, den die Fimrware unterstützt. Unterstützt die Firmware einen niedriger Wert als eingegeben, wird er begrenzt / abgeschnitten.

Standardwert: 0 (ausgeschaltet).

PCAN-Gerät: Alle FPGA basierte PCAN Geräte.

PCAN_ACCEPTANCE_FILTER_11BIT

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um der Empfangsfilter eines PCAN-Kanals mit einem spezifischen 11-Bit-Akzeptanzfilter (Code und Maske), wie für den Akzeptanzfilter des SJA1000 CAN-Controllers beschrieben, zu konfigurieren. Der Code und die Maske werden zusammen in einem 64-Bit-Wert codiert, wobei jeder von ihnen 4 Bytes verwendet (Intel- / Little-Endian-Format). Der Code wird in den bedeutendsten Bytes gespeichert (MSB).

Wertebereich: Beide Parameterteile, Code (4 Byte - MSB) und Maske (4 Byte - LSB), haben einen Wertebereich zwischen [0..16838]. Dies bedeutet, dass der Maximalwert dieses Parameters als 64-Bit-Wert 70364449226751 ist, d. h. hexadezimale 00003FFF 00003FFFh. Die Maske verwendet den Bitwert '1' als "don't care bit".

Standardwert: 00000000000007FFh (keine Filterung).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Dieser Parameter ist besonders an den CAN-Controller SJA1000 angepasst. Empfangsfilter können auch mit der Funktion CAN_FilterMessages (class-method: FilterMessages) konfiguriert werden. Bei der Initialisierung eines Kanals ist der Filterbereich zunächst voll geöffnet. Nach dem aktuellen Filter-Status, das Setzen dieses Parameters verhält sich wie folgt:

  • Filter-Status ist PCAN_FILTER_OPEN: Den Filter wird automatisch geschlossen und dann mit dem angegebenen Akzeptanzfilter konfiguriert.
  • Filter-Status ist PCAN_FILTER_CLOSE: Den Filter wird mit dem angegebenen Akzeptanzfilter konfiguriert.
  • Filter-Status ist PCAN_FILTER_CUSTOM: Den vorhandenen Filter wird, mit dem angegebenen Akzeptanzfilter, erweitern. Wenn ein anderer Akzeptanzcode erforderlich ist, anstatt den aktuellen zu erweitern, muss der Filter zuerst geschlossen werden, bevor der neue Akzeptanzfilter gesetzt wird. Dazu wird den Parameter PCAN_MESSAGE_FILTER verwendet.

PCAN_ACCEPTANCE_FILTER_29BIT

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um der Empfangsfilter eines PCAN-Kanals mit einem spezifischen 29-Bit-Akzeptanzfilter (Code und Maske), wie für den Akzeptanzfilter des SJA1000 CAN-Controllers beschrieben, zu konfigurieren. Der Code und die Maske werden zusammen in einem 64-Bit-Wert codiert, wobei jeder von ihnen 4 Bytes verwendet (Intel- / Little-Endian-Format). Der Code wird in den bedeutendsten Bytes gespeichert (MSB).

Wertebereich: Beide Parameterteile, Code und Maske, haben einen Wertebereich zwischen [0..4294967295]. Dies bedeutet, dass der Maximalwert dieses Parameters als 64-Bit-Wert 18446744073709551615 ist, d. h. hexadezimale FFFFFFFF FFFFFFFFh. Die Maske verwendet den Bitwert '1' als "don't care bit".

Standardwert: 000000001FFFFFFFh (keine Filterung).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Dieser Parameter ist besonders an den CAN-Controller SJA1000 angepasst. Empfangsfilter können auch mit der Funktion CAN_FilterMessages (class-method: FilterMessages) konfiguriert werden. Bei der Initialisierung eines Kanals ist der Filterbereich zunächst voll geöffnet. Nach dem aktuellen Filter-Status, das Setzen dieses Parameters verhält sich wie folgt:

  • Filter-Status ist PCAN_FILTER_OPEN: Den Filter wird automatisch geschlossen und dann mit dem angegebenen Akzeptanzfilter konfiguriert.
  • Filter-Status ist PCAN_FILTER_CLOSE: Den Filter wird mit dem angegebenen Akzeptanzfilter konfiguriert.
  • Filter-Status ist PCAN_FILTER_CUSTOM: Den vorhandenen Filter wird, mit dem angegebenen Akzeptanzfilter, erweitern. Wenn ein anderer Akzeptanzcode erforderlich ist, anstatt den aktuellen zu erweitern, muss der Filter zuerst geschlossen werden, bevor der neue Akzeptanzfilter gesetzt wird. Dazu wird den Parameter PCAN_MESSAGE_FILTER verwendet.

PCAN_IO_DIGITAL_CONFIGURATION

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um den Ausgabemodus aller digitalen Pins an einem PCAN-USB-Chip-Gerät zu konfigurieren.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..4294967295], wobei jedes Bit einen digitalen Eingang repräsentiert. Ein Bitwert von 1 bedeutet, dass der Pin als "digitaler Ausgang" arbeitet. 0 bedeutet "nur digitaler Eingang". Bit0, das niedrigstwertige Bit, entspricht Pin0; Bit1 entspricht Pin1, und so weiter bis Pin31.

Standardwert: 0 - keine digitalen Pin als Ausgang konfiguriert.

PCAN-Gerät: PCAN-USB Geräte der USB-Chip Familie.

Anmerkungen: Alle Pins fungieren als digitale Eingänge und zusätzlich als digitale Ausgänge, wenn sie als solche konfiguriert sind. Die aktuelle Version des PCAN-USB Chips implementiert 5 digitale Pins. Bitwerte von Bit5 bis Bit31 werden ignoriert.

PCAN_IO_DIGITAL_VALUE

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird verwendet, um die Werte einzustellen, die von allen digitalen Pins dargestellt werden, die als digitaler Ausgang eines PCAN-USB-Chip-Geräts konfiguriert sind.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..4294967295], wobei jedes Bit einen digitalen Eingang repräsentiert. Ein Bitwert von 0 bedeutet "Low", 1 bedeutet "High". Bit0, das niedrigstwertige Bit, entspricht Pin0; Bit1 entspricht Pin1, und so weiter bis Pin31.

Standardwert: 0 - alle digitalen Ausgangswerte sind auf "Low" gesetzt.

PCAN-Gerät: PCAN-USB Geräte der USB-Chip Familie.

Anmerkungen: Alle Pins fungieren als digitale Eingänge und zusätzlich als digitale Ausgänge, wenn sie als solche konfiguriert sind. Die aktuelle Version des PCAN-USB Chips implementiert 5 digitale Pins. Bitwerte von Bit5 bis Bit31 werden ignoriert.

PCAN_IO_DIGITAL_SET

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter können ausgewählte digitale Pins auf "High" gesetzt werden. Verbleibende Pins werden nicht neu konfiguriert.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..4294967295], wobei jedes Bit einen digitalen Eingang repräsentiert. Ein Bitwert von 1 markiert den Pin, welcher Wert auf "High" gesetzt werden muss. Ein Bitwert von 0 hat keine Auswirkung. Bit0, das niedrigstwertige Bit, entspricht Pin0; Bit1 entspricht Pin1, und so weiter bis Pin31.

Standardwert: -

PCAN-Gerät: PCAN-USB Geräte der USB-Chip Familie.

Anmerkungen: Alle Pins fungieren als digitale Eingänge und zusätzlich als digitale Ausgänge, wenn sie als solche konfiguriert sind. Die aktuelle Version des PCAN-USB Chips implementiert 5 digitale Pins. Bitwerte von Bit5 bis Bit31 werden ignoriert.

PCAN_IO_DIGITAL_CLEAR

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter können ausgewählte digitale Pins auf "Low" gesetzt werden. Verbleibende Pins werden nicht neu konfiguriert.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..4294967295], wobei jedes Bit einen digitalen Eingang repräsentiert. Ein Bitwert von 1 markiert den Pin, welcher Wert auf "Low" gesetzt werden muss. Ein Bitwert von 0 hat keine Auswirkung. Bit0, das niedrigstwertige Bit, entspricht Pin0; Bit1 entspricht Pin1, und so weiter bis Pin31.

Standardwert: -

PCAN-Gerät: PCAN-USB Geräte der USB-Chip Familie.

Anmerkungen: Alle Pins fungieren als digitale Eingänge und zusätzlich als digitale Ausgänge, wenn sie als solche konfiguriert sind. Die aktuelle Version des PCAN-USB Chips implementiert 5 digitale Pins. Bitwerte von Bit5 bis Bit31 werden ignoriert.

PCAN_IO_ANALOG_VALUE

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter wird zum Lesen von analoge Spannungen vom Analogeingang Pin eines PCAN-USB-Chip-Geräts verwendet.

Wertebereich: Der Parameter hat einen Wertebereich zwischen [0..4294967295].

Standardwert: -

PCAN-Gerät: PCAN-USB Geräte der USB-Chip Familie.

Anmerkungen: Die aktuelle Version des PCAN-USB Chips implementiert 1 analogen Pin. Der zurückgegebene Wert stellt den direkten Wert aus dem A/D-Wandler dar, der ein vorzeichenloser ganzzahliger Wert ist. Dieser Wert muss unter Berücksichtigung der externen Verdrahtung in einen vorzeichenbehafteten Wert konvertiert werden.

PCAN_FIRMWARE_VERSION

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Dieser Parameter informiert über die Firmware-Version des verwendeten PCAN-Geräts.

Wertebereich: Der Wert wird als null-terminierte Zeichenkette zurückgeliefert. Diese hat folgendes Format: x.x.x für Hauptversion, Nebenversion und Korrekturversion. Die Länge der Zeichenkette beträgt maximal 18 bytes (drei 5 byte-Zahlen zur Darstellung der einzelnen Versionsnummern, zwei Separatoren (, oder .) und den Null-Terminator.

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_ATTACHED_CHANNELS_COUNT

Zugriff:

Kanalstatus: -

Beschreibung: Dieser Parameter informiert über die Anzahl der PCAN-Kanäle, die an ein System angeschlossen sind, unabhängig von ihrer aktuellen Verfügbarkeit (siehe PCAN_CHANNEL_AVAILABLE).

Wertebereich: Der Wert kann eine Zahl im Bereich [0..n] sein, wobei n die Summe der maximal unterstützten Kanäle pro Gerätetyp in PCAN-Basic ist (siehe Anzahl der Kanäle).

Standardwert: -

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_ATTACHED_CHANNELS

Zugriff:

Kanalstatus: -

Beschreibung: Dieser Parameter ruft Informationen über alle vorhandenen PCAN-Kanäle auf einem System in einem einzigen Aufruf ab.

Wertebereich: Der Wert ist ein Array von TPCANChannelInformation-Elementen mit der Größe PCAN_AVAILABLE_CHANNELS_COUNT.

Standardwert: -

PCAN-Gerät: Nur mit dem Standardkanal (PCAN_NONEBUS) möglich.

PCAN_ALLOW_ECHO_FRAMES

Zugriff:

Kanalstatus: Der Kanal muss initialisiert sein, um Zugriff auf diesen Parameter zu erhalten.

Beschreibung: Mit diesem Parameter kann der Benutzer den Empfang von Botschaften vom Typ "PCAN_MESSAGE_ECHO" (selbst empfangene Botschaften) ein- oder ausschalten. Wenn "PCAN_ALLOW_ECHO_FRAMES" aktiv ist (ON), werden ausgehende CAN-Botschaften durch die Anwendung der CAN_Read/CAN_ReadFD Funktionen (Klassenmethoden: Read, ReadFD) selbst empfangen, sobald diese physikalisch gesendet wurden. Wenn "PCAN_ALLOW_ECHO_FRAMES" deaktiviert wird (OFF), wird der Empfang von Echo-Frames im Treiber für diesen Benutzer deaktiviert.

Wertebereich: Der Parameter kann nur 2 Werte annehmen: PCAN_PARAMETER_OFF, PCAN_PARAMETER_ON. Andere Werte sind ungültig und werden ignoriert.

Standardwert: Ausgeschaltet (PCAN_PARAMETER_OFF).

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

PCAN_DEVICE_PART_NUMBER

Zugriff:

Kanalstatus: Der Kanal kann initialisiert oder nicht-initialisiert sein.

Beschreibung: Dieser Parameter informiert über die Teilenummer des Geräts, das durch den PCAN-Kanal repräsentiert wird.

Wertebereich: Der Wert wird als null-terminierte Zeichenkette zurückgeliefert und kann als Referenznummer für die Bestellung von Geräten verwendet werden. Diese hat folgendes Format: IPEH-xxxxxx, wobei xxxxxx die sechsstellige zugehörige Teilenummer darstellt. Die Länge dieses Textes beträgt mindestens 12 Byte (11 Byte für die IPEH-Nummer plus Null-Terminator).

Standardwert: -

PCAN-Gerät: Alle PCAN Geräte (außer PCAN_NONEBUS Kanal).

Anmerkungen: Falls ein Gerät durch mehr als eine IPEH-Nummer repräsentiert wird, dann werden diese Nummern zusammen zurückgegeben, getrennt duch ein "/"-Zeichen. Ein klassisches PCAN-USB meldet beispielsweise den Wert "IPEH-002021/002022". Es wird empfohlen, einen Puffer zu verwenden, der groß genug ist, um in speziellen Fälle wie diesem den Erfolg zu garantieren.

Siehe auch

CAN_GetValue (Klassenmethode: GetValue)

CAN_SetValue (Klassenmethode: SetValue)

Parameterwert Definitionen

Benennung von Dateien, Pfade und Namespaces (Englisch)


TPCANMessageType

Willkommen
TPCANMessageType

Beschreibt den Typ einer PCAN-Botschaft. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANMessageType BYTE

#define PCAN_MESSAGE_STANDARD 0x00
#define PCAN_MESSAGE_RTR 0x01
#define PCAN_MESSAGE_EXTENDED 0x02
#define PCAN_MESSAGE_FD 0x04
#define PCAN_MESSAGE_BRS 0x08
#define PCAN_MESSAGE_ESI 0x10
#define PCAN_MESSAGE_ECHO 0x20
#define PCAN_MESSAGE_ERRFRAME 0x40
#define PCAN_MESSAGE_STATUS 0x80
Pascal OO
{$Z1}
TPCANMessageType = (
    PCAN_MESSAGE_STANDARD  = $00,
    PCAN_MESSAGE_RTR = $01,
    PCAN_MESSAGE_EXTENDED  = $02,
    PCAN_MESSAGE_FD = $04,
    PCAN_MESSAGE_BRS = $08,
    PCAN_MESSAGE_ESI = $10,
    PCAN_MESSAGE_ECHO = $20,
    PCAN_MESSAGE_ERRFRAME = $40,
    PCAN_MESSAGE_STATUS    = $80
);
C#
[Flags]
public enum TPCANMessageType : byte
{
    PCAN_MESSAGE_STANDARD  = 0x00,
    PCAN_MESSAGE_RTR = 0x01,
    PCAN_MESSAGE_EXTENDED  = 0x02,
    PCAN_MESSAGE_FD = 0x04,
    PCAN_MESSAGE_BRS = 0x08,
    PCAN_MESSAGE_ESI = 0x10,
    PCAN_MESSAGE_ECHO = 0x20,
    PCAN_MESSAGE_ERRFRAME = 0x40,
    PCAN_MESSAGE_STATUS = 0x80,
}
C++ / CLR
[Flags]
public enum class TPCANMessageType : Byte
{
    PCAN_MESSAGE_STANDARD  = 0x00,
    PCAN_MESSAGE_RTR = 0x01,
    PCAN_MESSAGE_EXTENDED  = 0x02,
    PCAN_MESSAGE_FD = 0x04,
    PCAN_MESSAGE_BRS = 0x08,
    PCAN_MESSAGE_ESI = 0x10,
    PCAN_MESSAGE_ECHO = 0x20,
    PCAN_MESSAGE_ERRFRAME = 0x40,
    PCAN_MESSAGE_STATUS = 0x80,
};
Visual Basic
<Flags()> _
Public Enum TPCANMessageType As Byte
    PCAN_MESSAGE_STANDARD = &H0
    PCAN_MESSAGE_RTR = &H1
    PCAN_MESSAGE_EXTENDED = &H2
    PCAN_MESSAGE_FD = &H4
    PCAN_MESSAGE_BRS = &H8
    PCAN_MESSAGE_ESI = &H10
    PCAN_MESSAGE_ECHO = &H20
    PCAN_MESSAGE_ERRFRAME = &H40
    PCAN_MESSAGE_STATUS = &H80
End Enum
Python
TPCANMessageType = c_ubyte

PCAN_MESSAGE_STANDARD = TPCANMessageType(0x00)
PCAN_MESSAGE_RTR = TPCANMessageType(0x01)
PCAN_MESSAGE_EXTENDED = TPCANMessageType(0x02)
PCAN_MESSAGE_FD = TPCANMessageType(0x04)
PCAN_MESSAGE_BRS = TPCANMessageType(0x08)
PCAN_MESSAGE_ESI = TPCANMessageType(0x10)
PCAN_MESSAGE_ECHO = TPCANMessageType(0x20)
PCAN_MESSAGE_ERRFRAME = TPCANMessageType(0x40)
PCAN_MESSAGE_STATUS = TPCANMessageType(0x80)
Anmerkungen

Es können mehrere der Werte kombiniert sein (Bitmaske).

Bitte beachten, dass Botschaften vom Typ PCAN_MESSAGE_FD, PCAN_MESSAGE_BRS, PCAN_MESSAGE_ESI oder eine Kombination diesen, können nur gesendet / empfangen werden, wenn die FD-Funktionen, CAN_ReadFD und CAN_WriteFD (Klassenmethode: ReadFD, WriteFD) verwendet werden.

Werte
Name | Wert | Beschreibung
PCAN_MESSAGE_STANDARD | 0 | Die PCAN Botschaft ist ein CAN Standard Frame (11-bit Identifier).
PCAN_MESSAGE_RTR | 1 | Die PCAN Botschaft ist ein CAN Remote-Transfer-Request Frame.
PCAN_MESSAGE_EXTENDED | 2 | Die PCAN Botschaft ist ein CAN Extended Frame (29-bit Identifier).
PCAN_MESSAGE_FD | 4 | Die PCAN Botschaft ist ein FD-Frame (in Bezug auf die CiA-Spezifikationen).
PCAN_MESSAGE_BRS | 8 | Die PCAN-Botschaft stellt einen FD Bitrate Schalter dar (CAN-Daten auf eine höhere Bitrate).
PCAN_MESSAGE_ESI | 16 | Die PCAN-Botschaft ist eine FD Fehlerstatus Botschaft (CAN-FD Sender war "Fehler aktiv").
PCAN_MESSAGE_ECHO | 32 | Die PCAN Botschaft ist ein Echo-CAN-Frame (selbst empfangener Botschaft).
PCAN_MESSAGE_ERRFRAME | 64 | Die PCAN-Botschaft ist ein Error Frame. Siehe Error Frames für mehr Information.
PCAN_MESSAGE_STATUS | 128 | Die PCAN Botschaft ist eine PCAN Status Botschaft.
Siehe auch

CAN_Read (Klassenmethode: Read)

CAN_ReadFD (Klassenmethode: ReadFD)

CAN_Write (Klassenmethode: Write)

CAN_WriteFD (Klassenmethode: WriteFD)


TPCANType

Willkommen
TPCANType

Beschreibt den zu initialisierenden Typ einer PCAN-Hardware (Non-Plug-And-Play). Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANType BYTE

#define PCAN_TYPE_ISA 0x01
#define PCAN_TYPE_ISA_SJA 0x09
#define PCAN_TYPE_ISA_PHYTEC 0x04
#define PCAN_TYPE_DNG 0x02
#define PCAN_TYPE_DNG_EPP 0x03
#define PCAN_TYPE_DNG_SJA 0x05
#define PCAN_TYPE_DNG_SJA_EPP 0x06
Pascal OO
{$Z1}
TPCANType = (
    PCAN_TYPE_ISA = $01,
    PCAN_TYPE_ISA_SJA = $09,
    PCAN_TYPE_ISA_PHYTEC = $04,
    PCAN_TYPE_DNG = $02,
    PCAN_TYPE_DNG_EPP = $03,
    PCAN_TYPE_DNG_SJA = $05,
    PCAN_TYPE_DNG_SJA_EPP = $06
);
C#
public enum TPCANType : byte
{
    PCAN_TYPE_ISA = 0x01,
    PCAN_TYPE_ISA_SJA = 0x09,
    PCAN_TYPE_ISA_PHYTEC = 0x04,
    PCAN_TYPE_DNG = 0x02,
    PCAN_TYPE_DNG_EPP = 0x03,
    PCAN_TYPE_DNG_SJA = 0x05,
    PCAN_TYPE_DNG_SJA_EPP = 0x06,
}
C++ / CLR
public enum class TPCANType : Byte
{
    PCAN_TYPE_ISA = 0x01,
    PCAN_TYPE_ISA_SJA = 0x09,
    PCAN_TYPE_ISA_PHYTEC = 0x04,
    PCAN_TYPE_DNG = 0x02,
    PCAN_TYPE_DNG_EPP = 0x03,
    PCAN_TYPE_DNG_SJA = 0x05,
    PCAN_TYPE_DNG_SJA_EPP = 0x06,
};
Visual Basic
Public Enum TPCANType As Byte
    PCAN_TYPE_ISA = &H1
    PCAN_TYPE_ISA_SJA = &H9
    PCAN_TYPE_ISA_PHYTEC = &H4
    PCAN_TYPE_DNG = &H2
    PCAN_TYPE_DNG_EPP = &H3
    PCAN_TYPE_DNG_SJA = &H5
    PCAN_TYPE_DNG_SJA_EPP = &H6
End Enum
Python
TPCANType = c_ubyte

PCAN_TYPE_ISA = TPCANType(0x01)
PCAN_TYPE_ISA_SJA = TPCANType(0x09)
PCAN_TYPE_ISA_PHYTEC = TPCANType(0x04)
PCAN_TYPE_DNG = TPCANType(0x02)
PCAN_TYPE_DNG_EPP = TPCANType(0x03)
PCAN_TYPE_DNG_SJA = TPCANType(0x05)
PCAN_TYPE_DNG_SJA_EPP = TPCANType(0x06)
Werte
Name | Wert | Beschreibung
PCAN_TYPE_ISA | 1 | PCAN-ISA 82C200.
PCAN_TYPE_ISA_SJA | 9 | PCAN-ISA SJA1000.
PCAN_TYPE_ISA_PHYTEC | 4 | PHYTEC ISA .
PCAN_TYPE_DNG | 2 | PCAN-Dongle 82C200.
PCAN_TYPE_DNG_EPP | 3 | PCAN-Dongle EPP 82C200.
PCAN_TYPE_DNG_SJA | 5 | PCAN-Dongle SJA1000.
PCAN_TYPE_DNG_SJA_EPP | 6 | PCAN-Dongle EPP SJA1000.
Siehe auch

CAN_Initialize (Klassenmethode: Initialize)


TPCANMode

Willkommen
TPCANMode

Beschreibt die PCAN Filter-Betriebsart. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANMode BYTE

#define PCAN_MODE_STANDARD PCAN_MESSAGE_STANDARD
#define PCAN_MODE_EXTENDED PCAN_MESSAGE_EXTENDED
Pascal OO
{$Z1}
TPCANMode = (
    PCAN_MODE_STANDARD = Byte(PCAN_MESSAGE_STANDARD),
    PCAN_MODE_EXTENDED = Byte(PCAN_MESSAGE_EXTENDED)
);
C#
public enum TPCANMode : byte
{
    PCAN_MODE_STANDARD = TPCANMessageType.PCAN_MESSAGE_STANDARD,
    PCAN_MODE_EXTENDED = TPCANMessageType.PCAN_MESSAGE_EXTENDED,
}
C++ / CLR
public enum class TPCANMode : Byte
{
    PCAN_MODE_STANDARD = TPCANMessageType::PCAN_MESSAGE_STANDARD,
    PCAN_MODE_EXTENDED = TPCANMessageType::PCAN_MESSAGE_EXTENDED,
};
Visual Basic
Public Enum TPCANMode As Byte
    PCAN_MODE_STANDARD = TPCANMessageType.PCAN_MESSAGE_STANDARD
    PCAN_MODE_EXTENDED = TPCANMessageType.PCAN_MESSAGE_EXTENDED
End Enum
Python
TPCANMode = c_ubyte

PCAN_MODE_STANDARD = PCAN_MESSAGE_STANDARD
PCAN_MODE_EXTENDED = PCAN_MESSAGE_EXTENDED
Werte
Name | Wert | Beschreibung
PCAN_MODE_STANDARD | 0 | Betriebsart ist Standard (11-bit identifier).
PCAN_MODE_EXTENDED | 2 | Betriebsart ist Extended (29-bit identifier).
Siehe auch

CAN_FilterMessages (Klassenmethode: FilterMessages)


TPCANBaudrate

Willkommen
TPCANBaudrate

Beschreibt die Werte für die PCAN Bitraten-Register. Abhängig von der Programmiersprache kann es sich dabei um eine Gruppe von Definitionen oder eine Aufzählung handeln.

Syntax
C++
#define TPCANBaudrate WORD

#define PCAN_BAUD_1M 0x0014
#define PCAN_BAUD_800K 0x0016
#define PCAN_BAUD_500K 0x001C
#define PCAN_BAUD_250K 0x011C
#define PCAN_BAUD_125K 0x031C
#define PCAN_BAUD_100K 0x432F
#define PCAN_BAUD_95K 0xC34E
#define PCAN_BAUD_83K 0x852B
#define PCAN_BAUD_50K 0x472F
#define PCAN_BAUD_47K 0x1414
#define PCAN_BAUD_33K 0x8B2F
#define PCAN_BAUD_20K 0x532F
#define PCAN_BAUD_10K 0x672F
#define PCAN_BAUD_5K 0x7F7F
Pascal OO
{$Z2}
TPCANBaudrate = (
    PCAN_BAUD_1M = $0014,
    PCAN_BAUD_800K = $0016,
    PCAN_BAUD_500K = $001C,
    PCAN_BAUD_250K = $011C,
    PCAN_BAUD_125K = $031C,
    PCAN_BAUD_100K = $432F,
    PCAN_BAUD_95K = $C34E,
    PCAN_BAUD_83K = $852B,
    PCAN_BAUD_50K = $472F,
    PCAN_BAUD_47K = $1414,
    PCAN_BAUD_33K = $8B2F,
    PCAN_BAUD_20K = $532F,
    PCAN_BAUD_10K = $672F,
    PCAN_BAUD_5K = $7F7F
);
C#
public enum TPCANBaudrate : ushort
{
    PCAN_BAUD_1M = 0x0014,
    PCAN_BAUD_800K = 0x0016,
    PCAN_BAUD_500K = 0x001C,
    PCAN_BAUD_250K = 0x011C,
    PCAN_BAUD_125K = 0x031C,
    PCAN_BAUD_100K = 0x432F,
    PCAN_BAUD_95K = 0xC34E,
    PCAN_BAUD_83K = 0x852B,
    PCAN_BAUD_50K = 0x472F,
    PCAN_BAUD_47K = 0x1414,
    PCAN_BAUD_33K = 0x8B2F,
    PCAN_BAUD_20K = 0x532F,
    PCAN_BAUD_10K = 0x672F,
    PCAN_BAUD_5K = 0x7F7F,
}
C++ / CLR
public enum class TPCANBaudrate : UInt16
{
    PCAN_BAUD_1M = 0x0014,
    PCAN_BAUD_800K = 0x0016,
    PCAN_BAUD_500K = 0x001C,
    PCAN_BAUD_250K = 0x011C,
    PCAN_BAUD_125K = 0x031C,
    PCAN_BAUD_100K = 0x432F,
    PCAN_BAUD_95K = 0xC34E,
    PCAN_BAUD_83K = 0x852B,
    PCAN_BAUD_50K = 0x472F,
    PCAN_BAUD_47K = 0x1414,
    PCAN_BAUD_33K = 0x8B2F,
    PCAN_BAUD_20K = 0x532F,
    PCAN_BAUD_10K = 0x672F,
    PCAN_BAUD_5K = 0x7F7F,
};
Visual Basic
Public Enum TPCANBaudrate As UInt16
    PCAN_BAUD_1M = &H14
    PCAN_BAUD_800K = &H16
    PCAN_BAUD_500K = &H1C
    PCAN_BAUD_250K = &H11C
    PCAN_BAUD_125K = &H31C
    PCAN_BAUD_100K = &H432F
    PCAN_BAUD_95K = &HC34E
    PCAN_BAUD_83K = &H852B
    PCAN_BAUD_50K = &H472F
    PCAN_BAUD_47K = &H1414
    PCAN_BAUD_33K = &H8B2F
    PCAN_BAUD_20K = &H532F
    PCAN_BAUD_10K = &H672F
    PCAN_BAUD_5K = &H7F7F
End Enum
Python
TPCANBaudrate = c_ushort

PCAN_BAUD_1M = TPCANBaudrate(0x0014)
PCAN_BAUD_800K = TPCANBaudrate(0x0016)
PCAN_BAUD_500K = TPCANBaudrate(0x001C)
PCAN_BAUD_250K = TPCANBaudrate(0x011C)
PCAN_BAUD_125K = TPCANBaudrate(0x031C)
PCAN_BAUD_100K = TPCANBaudrate(0x432F)
PCAN_BAUD_95K = TPCANBaudrate(0xC34E)
PCAN_BAUD_83K = TPCANBaudrate(0x852B)
PCAN_BAUD_50K = TPCANBaudrate(0x472F)
PCAN_BAUD_47K = TPCANBaudrate(0x1414)
PCAN_BAUD_33K = TPCANBaudrate(0x8B2F)
PCAN_BAUD_20K = TPCANBaudrate(0x532F)
PCAN_BAUD_10K = TPCANBaudrate(0x672F)
PCAN_BAUD_5K = TPCANBaudrate(0x7F7F)
Werte
Name | Wert | Beschreibung
PCAN_BAUD_1M | 20 | 1 MBit/s.
PCAN_BAUD_800K | 22 | 800 kBit/s.
PCAN_BAUD_500K | 28 | 500 kBit/s.
PCAN_BAUD_250K | 284 | 250 kBit/s.
PCAN_BAUD_125K | 796 | 125 kBit/s.
PCAN_BAUD_100K | 17199 | 100 kBit/s.
PCAN_BAUD_95K | 49998 | 95,238 kBit/s.
PCAN_BAUD_83K | 34091 | 83,333 kBit/s.
PCAN_BAUD_50K | 18223 | 50 kBit/s.
PCAN_BAUD_47K | 5140 | 47,619 kBit/s.
PCAN_BAUD_33K | 35631 | 33,333 kBit/s.
PCAN_BAUD_20K | 21295 | 20 kBit/s.
PCAN_BAUD_10K | 26415 | 10 kBit/s.
PCAN_BAUD_5K | 32639 | 5 kBit/s.
Siehe auch

CAN_Initialize (Klassenmethode: Initialize)


TPCANBitrateFD

Willkommen
TPCANBitrateFD

Beschreibt einen Bitrate String mit Flexible Datenrate (FD).

Syntax
C++
#define TPCANBitrateFD LPSTR

#define PCAN_BITRATE_SAE_J2284_4     "f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4"
#define PCAN_BITRATE_SAE_J2284_5     "f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4"
Pascal OO
TPCANBitrateFD = String;

const PCAN_BITRATE_SAE_J2284_4: String = 'f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4';
const PCAN_BITRATE_SAE_J2284_5: String = 'f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4';
C#
using TPCANBitrateFD = System.String;

public const string PCAN_BITRATE_SAE_J2284_4 = "f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4";
public const string PCAN_BITRATE_SAE_J2284_5 = "f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4";
C++ / CLR
#define TPCANBitrateFD System::String^

static const System::String^ PCAN_BITRATE_SAE_J2284_4 = "f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4";
static const System::String^ PCAN_BITRATE_SAE_J2284_5 = "f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4";
Visual Basic
Imports TPCANBitrateFD = System.String

Public Const PCAN_BITRATE_SAE_J2284_4 As String = "f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4"
Public Const PCAN_BITRATE_SAE_J2284_5 As String = "f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4"
Python
TPCANBitrateFD = c_char_p

PCAN_BITRATE_SAE_J2284_4      = TPCANBitrateFD("f_clock=80000000,nom_brp=2,nom_tseg1=63,nom_tseg2=16,nom_sjw=16,data_brp=2,data_tseg1=15,data_tseg2=4,data_sjw=4")
PCAN_BITRATE_SAE_J2284_5      = TPCANBitrateFD("f_clock=80000000,nom_brp=1,nom_tseg1=127,nom_tseg2=32,nom_sjw=32,data_brp=1,data_tseg1=11,data_tseg2=4,data_sjw=4")
Anmerkungen

.NET Framework Programmiersprachen:

Das Pseudonym TPCANBitrateFD wird verwendet, um eine flexible Datenrate unter Microsofts .NET Framework darzustellen. Damit wird eine Gleichbehandlung für alle oben genannten Programmiersprachen erreicht. Die Pseudonymen sind im Namespace Peak.Can.Basic für die Benutzung in C# und VB .NET definiert.

Jedoch bedeutet das Einbinden (include) des Namespace nicht automatisch das Mit-Einbinden der Pseudonymen. Stattdessen müssen die Pseudonymen in die Arbeitsdatei hineinkopiert werden, direkt hinter dem Einbinden des Peak.Can.Basic Namespace. Man kann aber auch den Basis-Datentyp String verwenden.

C#:

using System;
using Peak.Can.Basic;
using TPCANBitrateFD = System.String; // Pseudonym (alias) Deklaration für System.String

Visual Basic:

Imports System
Imports Peak.Can.Basic
Imports TPCANBitrateFD = System.String ' Pseudonym (alias) Deklaration für System.String
Werte
Name | Description
PCAN_BITRATE_SAE_J2284_4 | SAE J2284-4: "High-Speed CAN (HSC) for Vehicle Applications at 500 kbps with CAN FD Data at 2 Mbps"
PCAN_BITRATE_SAE_J2284_5 | SAE J2284-5: "High-Speed CAN (HSC) for Vehicle Applications at 500 kbps with CAN FD Data at 5 Mbps"
Siehe auch

FD Bitrate Parameter Definitionen


TPCANTimestampFD

Willkommen
TPCANTimestampFD

Beschreibt den Zeitstempel einer CAN-Botschaft mit flexiblen Datenrate. Der Zeitstempel enthält die Anzahl der Mikrosekunden, die seit dem Start von Windows vergangenen sind.

Syntax
C++
#define TPCANTimestampFD UINT64
Pascal OO
TPCANTimestampFD = UInt64;
C#
using TPCANTimestampFD = System.UInt64;
C++ / CLR
#define TPCANTimestampFD System::UInt64
Visual Basic
Imports TPCANTimestampFD = System.UInt64
Python
TPCANTimestampFD = c_ulonglong
Anmerkungen

.NET Framework Programmiersprachen:

Das Pseudonym TPCANTimestampFD wird verwendet, um den Zeitstempel der FD-Botschaften unter Microsofts .NET Framework darzustellen. Damit wird eine Gleichbehandlung für alle oben genannten Programmiersprachen erreicht. Die Pseudonymen sind im Namespace Peak.Can.Basic für die Benutzung in C# und VB .NET definiert.

Jedoch bedeutet das Einbinden (include) des Namespace nicht automatisch das Mit-Einbinden der Pseudonymen. Stattdessen müssen die Pseudonymen in die Arbeitsdatei hineinkopiert werden, direkt hinter dem Einbinden des Peak.Can.Basic Namespace. Man kann aber auch den Basis-Datentyp UInt64 verwenden.

C#:

using System;
using Peak.Can.Basic;
using TPCANTimestampFD = System.UInt64; // Pseudonym (alias) Deklaration für System.UInt64

Visual Basic:

Imports System
Imports Peak.Can.Basic
Imports TPCANTimestampFD = System.UInt64 ' Pseudonym (alias) Deklaration für System.UInt64


Methoden

Willkommen
Methoden

Die definierten Methoden der Klassen PCANBasic und TPCANBasic lassen sich in 4 Funktionsgruppen unterteilen. Mit Ausnahme der Python-Version sind alle diese Methoden statisch, d.h. sie können direkt mit dem Klassennamen aufgerufen werden (keine Instantiierung).

Verbindung
Name | Beschreibung
Initialize | Initialisiert einen PCAN-Kanal.
InitializeFD | Initialisiert einen FD fähigen PCAN-Kanal.
Uninitialize | Gibt einen PCAN-Kanal frei.
Konfiguration
Name | Beschreibung
SetValue | Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.
FilterMessages | Konfiguriert den Botschafts-Empfangsfilter eines PCAN-Kanals.
Information
Name | Beschreibung
GetValue | Liest eine Konfigurations- oder Dateninformation von einem PCAN-Kanal.
GetStatus | Liest den momentanen Bus-Zustand eines PCAN-Kanals.
GetErrorText | Liest den beschreibenden Text für einen Fehlercode.
LookUpChannel | Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.
Kommunikation
Name | Beschreibung
Read | Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines PCAN-Kanals.
ReadFD | Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.
Write | Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines PCAN-Kanals.
WriteFD | Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines FD fähige PCAN-Kanals.
Reset | Setzt Sende- und Empfangspuffer eines PCAN-Kanals zurück.


Initialize

Willkommen
Initialize

Initialisiert einen PCAN-Kanal.

Überladungen
Methode | Beschreibung
Initialize(TPCANHandle, TPCANBaudrate) | Initialisiert einen "Plug-And-Play" PCAN-Kanal.
Initialize(TPCANHandle, TPCANBaudrate, TPCANType, UInt32, UInt16) | Initialisiert einen "Non-Plug-And-Play" PCAN-Kanal.


Initialize(TPCANHandle, TPCANBaudrate)

Willkommen
Initialize(TPCANHandle, TPCANBaudrate)

Initialisiert einen "Plug-And-Play" PCAN-Kanal.

Syntax
Pascal OO
class function Initialize(
    Channel: TPCANHandle;
    Btr0Btr1: TPCANBaudrate
    ): TPCANStatus; overload;
C#
public static extern TPCANStatus Initialize(
    TPCANHandle Channel,
    TPCANBaudrate Btr0Btr1);
C++ / CLR
static TPCANStatus Initialize(
    TPCANHandle Channel,
    TPCANBaudrate Btr0Btr1);
Visual Basic
Public Shared Function Initialize( _
    ByVal Channel As TPCANHandle, _
    ByVal Btr0Btr1 As TPCANBaudrate) As TPCANStatus
End Function
Python
def Initialize(
    self,
    Channel,
    Btr0Btr1)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Btr0Btr1 | Die Übertragungsgeschwindigkeit (siehe TPCANBaudrate).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall wird PCAN_ERROR_OK zurückgegeben. Im Fehlerfall können folgende Werte zurückgegeben werden:

PCAN_ERROR_CAUTION:
Der Kanal wurde initialisiert, aber mit einer anderen Bitrate als die angegebene.
PCAN_ERROR_ILLHANDLE:
Der gewählte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_ILLHW:
Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLOPERATION:
Eine Aktion kann nicht ausgeführt werden, aufgrund der Zustand der Hardware. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal ist ein LAN-Kanal, der eine andere Bitrate verwendet als die angegebene.

PCAN_ERROR_ILLMODE:
Die Hardware arbeitet in einem anderen oder inkompatiblen Modus als angefordert. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal wird im CAN-FD-Modus betrieben.

PCAN_ERROR_INITIALIZE:
Der gewählte PCAN-Kanal ist bereits initialisiert und in Benutzung (PCAN-Basic / PCAN-Light Umgebung).
PCAN_ERROR_NETINUSE:
Der gewählte PCAN-Kanal ist bereits, mit ein anderen Bitrate, in Benutzung (PCAN-View).
PCAN_ERROR_HWINUSE:
Der gewählte PCAN-Kanal ist bereits in Benutzung (CanApi2 Verbindung).
PCAN_ERROR_NODRIVER:
Der Treiber zum Verbinden mit dem gewählte PCAN-Kanal ist nicht geladen.
Anmerkungen

Die Methode Initialize bereitet einen PCAN-Kanal für die Kommunikation mit dem angeschlossenen CAN Bus vor. Alle Methoden, die per handle auf einen nicht initialisierten Kanal (außer PCAN_NONEBUS) zugreifen, liefern einen Fehlercode zurück. Wird ein initialisierter Kanal nicht mehr benötigt, sollte er mit Uninitialize freigegeben werden.

Initialisieren bewirkt:

  • Reservierung eines Kanals für die aufrufende Applikation/den aufrufenden Prozess.
  • Bereitstellen von Ressourcen für den Kanal (z. B. Empfangs- und Sendepuffer).
  • Zuordnen einer Hardware zum Kanal-handle.
  • Überprüfung/Anpassung der Bus-Geschwindigkeit, wenn der Kanal bereits verwendet wird. (Nur wenn der Kanal vorher mit "Bitrate-Adapting"vor-konfiguriert wurde; siehe Bitrate-Adapting Parameter).
  • Versetzen eines Kanal in "Listen-Only" Modus. (Nur wenn der Kanal vorher vor-initialisiert wurde; siehe Listen-Only Parameter).
  • Öffnen des CAN-Botschaftsfilters.
  • Grundversorgung der Parameter mit Standardeinstellungen.
  • Einstellen des Empfang-Status eines Kanal. (Vor-initialisierten Wert; siehe Receive Status Parameter).

Der Initialisierungsprozess liefert einen Fehlercode zurück, wenn die Anwendung einen PCAN-Kanal initialisieren mochte, der von ihr bereits initialisiert wurde.

Bitte beachten Sie, dass die Initialisierung eines Kanals ein Reset des CAN-Hardware bewirkt, wenn Fehler auf den Bus vorliegen. Auf diese Weise Fehler wie BUSOFF, BUSHEAVY und BUSLIGHT, werden verschwinden.

PCAN-LAN Kanäle

Ein PCAN-LAN-Kanal erlaubt keine Änderung der Bitrate mittels PCAN-Basic. Um ein PCAN-LAN-Kanal zu verbinden ist es erforderlich, die Bitrate des PCAN-Gateway Geräts zu kennen, das durch diesen Kanal dargestellt wird. Wenn die Bitrate nicht bekannt ist, soll der Parameter Bitrate-Adapting verwendet werden.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
  • Plug-&-Play bzw. No-Plug-&-Play Hardware: Um einen Kanal zu einem Plug-And-Play PCAN Gerät zu initialisieren, sind das Kanal-handle und die Bitrate ausreichend.Weitere Parameter behalten ihre Standardeinstellungen. Bei Non-Plug-And-Play Geräten müssen alle Parameter versorgt werden.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Initialize- und Uninitialize-Methoden für ein Plug-And-Play-Gerät am Beispiel des PCAN_PCIBUS2 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C#:

TPCANStatus result;
StringBuilder strMsg;

// Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
//
result = PCANBasic.Initialize(PCANBasic.PCAN_PCIBUS2, TPCANBaudrate.PCAN_BAUD_500K);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = new StringBuilder(256);
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-PCI (Ch-2) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS);

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

// Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
//
result = PCANBasic::Initialize(PCANBasic::PCAN_PCIBUS2, TPCANBaudrate::PCAN_BAUD_500K);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = gcnew StringBuilder(256);
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-PCI (Ch-2) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic::Uninitialize(PCANBasic::PCAN_NONEBUS);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

' Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
'
result = PCANBasic.Initialize(PCANBasic.PCAN_PCIBUS2, TPCANBaudrate.PCAN_BAUD_500K)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    strMsg = New StringBuilder(256)
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-PCI (Ch-2) was initialized")
End If

' Alle initialisierte Kanäle werden freigegeben.
'
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS)

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin
    // Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
    //
    result := TPCANBasic.Initialize(TPCANBasic.PCAN_PCIBUS2, PCAN_BAUD_500K);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-PCI (Ch-2) was initialized','Success', MB_OK);

    // Alle initialisierte Kanäle werden freigegeben.
    //
    TPCANBasic.Uninitialize(TPCANBasic.PCAN_NONEBUS);
end;

Python:

# Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
#
objPCAN = PCANBasic()
result = objPCAN.Initialize(PCAN_PCIBUS2, PCAN_BAUD_500K)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-PCI (Ch-2) was initialized")

# Alle initialisierte Kanäle werden freigegeben.
#
objPCAN.Uninitialize(PCAN_NONEBUS)
Siehe auch

Uninitialize

GetValue

PCAN-Basic Grundlagen

Als reine Funktionsversion: CAN_Initialize


Initialize(TPCANHandle, TPCANBaudrate, TPCANType, UInt32, UInt16)

Willkommen
Initialize(TPCANHandle, TPCANBaudrate, TPCANType, UInt32, UInt16)

Initialisiert einen "Non-Plug-And-Play" PCAN-Kanal.

Syntax
Pascal OO
class function Initialize(
    Channel: TPCANHandle;
    Btr0Btr1: TPCANBaudrate;
    HwType: TPCANType;
    IOPort: LongWord;
    Interrupt: Word
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Initialize")]
public static extern TPCANStatus Initialize(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U2)]
    TPCANBaudrate Btr0Btr1,
    [MarshalAs(UnmanagedType.U1)]
    TPCANType HwType,
    UInt32 IOPort,
    UInt16 Interrupt);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Initialize")]
static TPCANStatus Initialize(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U2)]
    TPCANBaudrate Btr0Btr1,
    [MarshalAs(UnmanagedType::U1)]
    TPCANType HwType,
    UInt32 IOPort,
    UInt16 Interrupt);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_Initialize")> _
Public Shared Function Initialize( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U2)> _
    ByVal Btr0Btr1 As TPCANBaudrate, _
   <MarshalAs(UnmanagedType.U1)> _
   ByVal HwType As TPCANType, _
   ByVal IOPort As UInt32, _
   ByVal Interrupt As UInt16) As TPCANStatus
End Function
Python
def Initialize(
    self,
    Channel,
    Btr0Btr1,
    HwType = TPCANType(0),
    IOPort = c_uint(0),
    Interrupt = c_ushort(0))
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Btr0Btr1 | Die Übertragungsgeschwindigkeit (siehe TPCANBaudrate).
IOPort | Hardware-Typ und Betriebsart (siehe TPCANMode). Die E/A Adresse für den Parallelport.
Interrupt | Interruptnummer des Parallelports.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall wird PCAN_ERROR_OK zurückgegeben. Im Fehlerfall können folgende Werte zurückgegeben werden:

PCAN_ERROR_CAUTION:
Der Kanal wurde initialisiert, aber mit einer anderen Bitrate als die angegebene.
PCAN_ERROR_ILLHANDLE:
Der gewählte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_ILLHW:
Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLOPERATION:
Eine Aktion kann nicht ausgeführt werden, aufgrund der Zustand der Hardware. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal ist ein LAN-Kanal, der eine andere Bitrate verwendet als die angegebene.

PCAN_ERROR_ILLMODE:
Die Hardware arbeitet in einem anderen oder inkompatiblen Modus als angefordert. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal wird im CAN-FD-Modus betrieben.

PCAN_ERROR_REGTEST:
Ein Problem mit der Hardware-Erkennung: meist wegen nicht bzw. falsch versorgter Parameter 'HwType', 'IOPort' und 'Interrupt'.
PCAN_ERROR_INITIALIZE:
Der gewählte PCAN-Kanal ist bereits initialisiert und in Benutzung (PCAN-Basic / PCAN-Light Umgebung).
PCAN_ERROR_NETINUSE:
Der gewählte PCAN-Kanal ist bereits, mit ein anderen Bitrate, in Benutzung (PCAN-View).
PCAN_ERROR_HWINUSE:
Der gewählte PCAN-Kanal ist bereits in Benutzung (CanApi2 Verbindung).
PCAN_ERROR_NODRIVER:
Der Treiber zum Verbinden mit dem gewählte PCAN-Kanal ist nicht geladen.
Anmerkungen

Die Methode Initialize bereitet einen PCAN-Kanal für die Kommunikation mit dem angeschlossenen CAN Bus vor. Alle Methoden, die per handle auf einen nicht initialisierten Kanal (außer PCAN_NONEBUS) zugreifen, liefern einen Fehlercode zurück. Wird ein initialisierter Kanal nicht mehr benötigt, sollte er mit Uninitialize freigegeben werden.

Initialisieren bewirkt:

  • Reservierung eines Kanals für die aufrufende Applikation/den aufrufenden Prozess.
  • Bereitstellen von Ressourcen für den Kanal (z. B. Empfangs- und Sendepuffer).
  • Zuordnen einer Hardware zum Kanal-handle.
  • Überprüfung/Anpassung der Bus-Geschwindigkeit, wenn der Kanal bereits verwendet wird. (Nur wenn der Kanal vorher mit "Bitrate-Adapting"vor-konfiguriert wurde; siehe Bitrate-Adapting Parameter).
  • Versetzen eines Kanal in "Listen-Only" Modus. (Nur wenn der Kanal vorher vor-initialisiert wurde; siehe Listen-Only Parameter).
  • Öffnen des CAN-Botschaftsfilters.
  • Grundversorgung der Parameter mit Standardeinstellungen.
  • Einstellen des Empfang-Status eines Kanal. (Vor-initialisierten Wert; siehe Receive Status Parameter).

Der Initialisierungsprozess liefert einen Fehlercode zurück, wenn die Anwendung einen PCAN-Kanal initialisieren mochte, der von ihr bereits initialisiert wurde.

Bitte beachten Sie, dass die Initialisierung eines Kanals ein Reset des CAN-Hardware bewirkt, wenn Fehler auf den Bus vorliegen. Auf diese Weise Fehler wie BUSOFF, BUSHEAVY und BUSLIGHT, werden verschwinden.

PCAN-LAN Kanäle

Ein PCAN-LAN-Kanal erlaubt keine Änderung der Bitrate mittels PCAN-Basic. Um ein PCAN-LAN-Kanal zu verbinden ist es erforderlich, die Bitrate des PCAN-Gateway Geräts zu kennen, das durch diesen Kanal dargestellt wird. Wenn die Bitrate nicht bekannt ist, soll der Parameter Bitrate-Adapting verwendet werden.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
  • Plug-&-Play bzw. No-Plug-&-Play Hardware: Um einen Kanal zu einem Plug-And-Play PCAN Gerät zu initialisieren, sind das Kanal-handle und die Bitrate ausreichend.Weitere Parameter behalten ihre Standardeinstellungen. Bei Non-Plug-And-Play Geräten müssen alle Parameter versorgt werden.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Initialize- und Uninitialize-Methoden für einen Non-Plug-And-Play-Kanal am Beispiel des PCAN_DNGBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C#:

TPCANStatus result;
StringBuilder strMsg;

// Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
//
result = PCANBasic.Initialize(PCANBasic.PCAN_DNGBUS1, TPCANBaudrate.PCAN_BAUD_500K, TPCANType.PCAN_TYPE_DNG_SJA, 0x378, 7);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = new StringBuilder(256);
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-DNG (Ch-1) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS);

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

// Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
//
result = PCANBasic::Initialize(PCANBasic::PCAN_DNGBUS1, TPCANBaudrate::PCAN_BAUD_500K, TPCANType::PCAN_TYPE_DNG_SJA, 0x378, 7);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = gcnew StringBuilder(256);
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-DNG (Ch-1) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic::Uninitialize(PCANBasic::PCAN_NONEBUS);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

' Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
'
result = PCANBasic.Initialize(PCANBasic.PCAN_DNGBUS1, TPCANBaudrate.PCAN_BAUD_500K, TPCANType.PCAN_TYPE_DNG_SJA, &H378, 7)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    strMsg = New StringBuilder(256)
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-DNG (Ch-1) was initialized")
End If

' Alle initialisierte Kanäle werden freigegeben.
'
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS)

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin
    // Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
    //
    result := TPCANBasic.Initialize(TPCANBasic.PCAN_DNGBUS1, PCAN_BAUD_500K, PCAN_TYPE_DNG_SJA, $378, 7);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-DNG (Ch-1) was initialized','Success', MB_OK);

    // Alle initialisierte Kanäle werden freigegeben.
    //
    TPCANBasic.Uninitialize(TPCANBasic.PCAN_NONEBUS);
end;

Python:

# Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
#
objPCAN = PCANBasic()
result = objPCAN.Initialize(PCAN_DNGBUS1, PCAN_BAUD_500K, PCAN_TYPE_DNG_SJA, 0x378, 7)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-DNG (Ch-1) was initialized")

# Alle initialisierte Kanäle werden freigegeben.
#
objPCAN.Uninitialize(PCAN_NONEBUS)
Siehe auch

Uninitialize

GetValue

PCAN-Basic Grundlagen

Als reine Funktionsversion: CAN_Initialize


InitializeFD

Willkommen
InitializeFD

Initialisiert einen FD fähigen PCAN-Kanal.

Syntax
Pascal OO
class function InitializeFD(
    Channel: TPCANHandle;
    BitrateFD: TPCANBitrateFD
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_InitializeFD")]
public static extern TPCANStatus InitializeFD(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    TPCANBitrateFD BitrateFD);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_InitializeFD")]
static TPCANStatus InitializeFD(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    TPCANBitrateFD BitrateFD);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_InitializeFD")> _
Public Shared Function InitializeFD( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    ByVal BitrateFD As TPCANBitrateFD) As TPCANStatus
End Function
Python
def InitializeFD(
    self,
    Channel,
    BitrateFD)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
BitrateFD | Die Übertragungsgeschwindigkeit (siehe FD Bitrate String).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall wird PCAN_ERROR_OK zurückgegeben. Im Fehlerfall können folgende Werte zurückgegeben werden:

PCAN_ERROR_CAUTION:
Der Kanal wurde initialisiert, aber mit einer anderen Bitrate als die angegebene.
PCAN_ERROR_ILLHANDLE:
Der gewählte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_ILLHW:
Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLOPERATION:
Eine Aktion kann nicht ausgeführt werden, aufgrund der Zustand der Hardware. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal ist nicht FD fähig und kann mit dieser Methode nicht initialisiert werden.
  • Der gewählte PCAN-Kanal ist ein LAN-Kanal, der eine andere Bitrate verwendet als die angegebene.

PCAN_ERROR_ILLMODE:
Die Hardware arbeitet in einem anderen oder inkompatiblen Modus als angefordert. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal wird im CAN 2.0 A / B-Modus betrieben.

PCAN_ERROR_INITIALIZE:
Der gewählte PCAN-Kanal ist bereits initialisiert und in Benutzung (PCAN-Basic / PCAN-Light Umgebung).
PCAN_ERROR_NETINUSE:
Der gewählte PCAN-Kanal ist bereits, mit ein anderen Bitrate, in Benutzung (PCAN-View).
PCAN_ERROR_HWINUSE:
Der gewählte PCAN-Kanal ist bereits in Benutzung (CanApi Verbindung).
PCAN_ERROR_NODRIVER:
Der Treiber zum Verbinden mit dem gewählte PCAN-Kanal ist nicht geladen.
Anmerkungen

Hinweis zur Korrespondenz der Methoden:

Ein Kanal, der mit InitializeFD initialisiert wird, muss ReadFD und WriteFD für Datenübertragung verwenden. Aufrufe zu Read und/oder Write führen zu einer PCAN_ERROR_ILLOPERATION Fehler.

Die Methode InitializeFD bereitet einen FD fähigen PCAN-Kanal für die Kommunikation mit dem angeschlossenen CAN Bus vor. Alle Methoden, die per handle auf einen nicht initialisierten Kanal (außer PCAN_NONEBUS) zugreifen, liefern einen Fehlercode zurück. Wird ein initialisierter Kanal nicht mehr benötigt, sollte er mit Uninitialize freigegeben werden.

Initialisieren bewirkt:

  • Reservierung eines Kanals für die aufrufende Applikation/den aufrufenden Prozess.
  • Bereitstellen von Ressourcen für den Kanal (z. B. Empfangs- und Sendepuffer).
  • Zuordnen einer Hardware zum Kanal-handle.
  • Überprüfung/Anpassung der Bus-Geschwindigkeit, wenn der Kanal bereits verwendet wird. (Nur wenn der Kanal vorher mit "Bitrate-Adapting"vor-konfiguriert wurde; siehe Bitrate-Adapting Parameter).
  • Versetzen eines Kanal in "Listen-Only" Modus. (Nur wenn der Kanal vorher vor-initialisiert wurde; siehe Listen-Only Parameter).
  • Öffnen des CAN-Botschaftsfilters.
  • Grundversorgung der Parameter mit Standardeinstellungen.
  • Einstellen des Empfang-Status eines Kanal. (Vor-initialisierten Wert; siehe Receive Status Parameter).

Der Initialisierungsprozess liefert einen Fehlercode zurück, wenn die Anwendung einen PCAN-Kanal initialisieren mochte, der von ihr bereits initialisiert wurde.

Bitte beachten Sie, dass die Initialisierung eines Kanals ein Reset des CAN-Hardware bewirkt, wenn Fehler auf den Bus vorliegen. Auf diese Weise Fehler wie BUSOFF, BUSWARNING und BUSPASSIVE, werden verschwinden.

PCAN-LAN Kanäle

Ein PCAN-LAN-Kanal erlaubt keine Änderung der Bitrate mittels PCAN-Basic. Um ein PCAN-LAN-Kanal zu verbinden ist es erforderlich, die Bitrate des PCAN-Gateway Geräts zu kennen, das durch diesen Kanal dargestellt wird. Wenn die Bitrate nicht bekannt ist, soll der Parameter Bitrate-Adapting verwendet werden.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
  • Plug-&-Play bzw. No-Plug-&-Play Hardware: Um einen Kanal zu einem Plug-And-Play PCAN Gerät zu initialisieren, sind das Kanal-handle und die Bitrate ausreichend.Weitere Parameter behalten ihre Standardeinstellungen. Bei Non-Plug-And-Play Geräten müssen alle Parameter versorgt werden.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der InitializeFD- und Uninitialize-Methoden für ein Plug-And-Play-Gerät am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C#:

string bitrate;
TPCANStatus result;
StringBuilder strMsg;

// Definiert ein FD-Bitrate String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
//
bitrate = "f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1";

// Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
//
result = PCANBasic.InitializeFD(PCANBasic.PCAN_USBBUS1, bitrate);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = new StringBuilder(256);
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-USB Pro FD (Ch-1) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS);

C++/CLR:

String^ bitrate;
TPCANStatus result;
StringBuilder^ strMsg;

// Definiert ein FD-Bitrate String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
//
bitrate = "f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1";

// Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
//
result = PCANBasic::InitializeFD(PCANBasic::PCAN_USBBUS1, bitrate);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    strMsg = gcnew StringBuilder(256);
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-USB Pro FD (Ch-1) was initialized");

// Alle initialisierte Kanäle werden freigegeben.
//
PCANBasic::Uninitialize(PCANBasic::PCAN_NONEBUS);

Visual Basic:

Dim bitrate As String
Dim result As TPCANStatus
Dim strMsg As StringBuilder

' Definiert ein FD-Bitrate String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
'
bitrate = "f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1"

' Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
'
result = PCANBasic.InitializeFD(PCANBasic.PCAN_USBBUS1, bitrate)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    strMsg = New StringBuilder(256)
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-USB Pro FD (Ch-1) was initialized")
End If

' Alle initialisierte Kanäle werden freigegeben.
'
PCANBasic.Uninitialize(PCANBasic.PCAN_NONEBUS)

Pascal OO:

var
 bitrate: String;
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin
    // Definiert ein FD-Bitrate String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
    //
    bitrate := 'f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1';

    // Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
    //
    result := TPCANBasic.InitializeFD(TPCANBasic.PCAN_USBBUS1, bitrate);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-USB Pro FD (Ch-1) was initialized','Success', MB_OK);

    // Alle initialisierte Kanäle werden freigegeben.
    //
    TPCANBasic.Uninitialize(TPCANBasic.PCAN_NONEBUS);
end;

Python:

# Definiert ein FD-Bitrate Ascii-String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
#
bitrate = b"f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1"

# Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
#
objPCAN = PCANBasic()
result = objPCAN.InitializeFD(PCAN_USBBUS1, bitrate)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-USB Pro FD (Ch-1) was initialized")

# Alle initialisierte Kanäle werden freigegeben.
#
objPCAN.Uninitialize(PCAN_NONEBUS)
Siehe auch

Uninitialize

ReadFD

WriteFD

Als reine Funktionsversion: CAN_InitializeFD


Uninitialize

Willkommen
Uninitialize

Gibt einen PCAN Kanal frei.

Syntax
Pascal OO
class function Uninitialize(
    Channel: TPCANHandle
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Uninitialize")]
public static extern TPCANStatus Uninitialize(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Uninitialize")]
static TPCANStatus Uninitialize(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_Uninitialize")> _
Public Shared Function Uninitialize( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle) As TPCANStatus
End Function
Python
def Uninitialize(
    self,
    Channel)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus code. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Zur Freigabe eines Kanals gibt es folgende Möglichkeiten:

Single-Release: Wird mit einem PCAN-Kanal-handle aufgerufen, wobei der Kanal vorher mit der Methode Initialize initialisiert worden sein muss. Wenn der Kanal nicht gelistet ist, wird eine Fehlermeldung zurückgegeben.

Multiple-Release: Wenn man als handle den Wert PCAN_NONEBUS versorgt, wird damit das API angewiesen, alle von der aufrufenden Anwendung initialisierten Kanäle zu ermitteln und freizugeben. Hierbei kann kein Fehlercode zurückgegeben werden, da nur gelistete Kanäle freigegeben werden.

Hinweis bezüglich der Sende-Queue während der Beendigung: Wenn eine PCAN-Basic Channel-Verbindung beendet wird, wird die Sende-Queue der zugrunde liegenden Hardware nicht sofort verworfen. PCAN-Basic wird vor der endgültigen Finalisierung noch einige Zeit warten, sodass die Hardware Zeit zum Senden dieser Nachrichten hat. Wenn die Zeit abgelaufen ist (etwa 500 Millisekunden), wird der Rest der Nachrichten in der Warteschlange (sofern vorhanden) verworfen.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Initialize und Uninitialize (Single-Release)-Methoden am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Ein Beispiel zur Verwendung von Multiple-Release ist bei der Initialize Methode zu sehen.

C#:

TPCANStatus result;
StringBuilder strMsg;

strMsg = new StringBuilder(256);

// Der Plug & Play Kanal (PCAN-PCI) wird initialisiert.
//
result = PCANBasic.Initialize(PCANBasic.PCAN_PCIBUS1, TPCANBaudrate.PCAN_BAUD_500K);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-PCI (Ch-1) was initialized");

....

// Die PCI Kanal wird freigegeben.
//
result = PCANBasic.Uninitialize(PCANBasic.PCAN_PCIBUS1);

if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-PCI (Ch-1) was released");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

strMsg = gcnew StringBuilder(256);

// Der Plug & Play Kanal (PCAN-PCI) wird initialisiert.
//
result = PCANBasic::Initialize(PCANBasic::PCAN_PCIBUS1, TPCANBaudrate::PCAN_BAUD_500K);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-PCI (Ch-1) was initialized");

....

// Die PCI Kanal wird freigegeben.
//
result = PCANBasic::Uninitialize(PCANBasic::PCAN_PCIBUS1);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-PCI (Ch-1) was released");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

strMsg = New StringBuilder(256)

' Der Plug & Play Kanal (PCAN-PCI) wird initialisiert.
'
result = PCANBasic.Initialize(PCANBasic.PCAN_PCIBUS1, TPCANBaudrate.PCAN_BAUD_500K)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-PCI (Ch-1) was initialized")
End If

....

' Die PCI Kanal wird freigegeben.
'
result = PCANBasic.Uninitialize(PCANBasic.PCAN_PCIBUS1)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-PCI (Ch-1) was released")
End If

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin
    // Der Plug & Play Kanal (PCAN-PCI) wird initialisiert.
    //
    result := TPCANBasic.Initialize(TPCANBasic.PCAN_PCIBUS1, PCAN_BAUD_500K);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-PCI (Ch-1) was initialized','Success', MB_OK);

....

    // Die PCI Kanal wird freigegeben.
    //
    result := TPCANBasic.Uninitialize(TPCANBasic.PCAN_PCIBUS1);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-PCI (Ch-1) was released','Success', MB_OK);
end;

Python:

# Der Plug & Play Kanal (PCAN-PCI) wird initialisiert.
#
objPCAN = PCANBasic()
result = objPCAN.Initialize(PCAN_PCIBUS1, PCAN_BAUD_500K)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-PCI (Ch-1) was initialized")

....

# Die PCI Kanal wird freigegeben.
#
result = objPCAN.Uninitialize(PCAN_PCIBUS1)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-PCI (Ch-1) was released")
Siehe auch

Initialize

Als reine Funktionsversion: CAN_Uninitialize


Reset

Willkommen
Reset

Setzt Sende- und Empfangspuffer eines PCAN-Kanals zurück.

Syntax
Pascal OO
class function Reset(
    Channel: TPCANHandle
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Reset")]
public static extern TPCANStatus Reset(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Reset")]
static TPCANStatus Reset(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_Reset")> _
Public Shared Function Reset( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle) As TPCANStatus
End Function
Python
def Reset(
    self,
    Channel)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Der Aufruf dieser Methode löscht lediglich die Puffer (Software) eines Kanals. Der CAN-Controller wird nicht zurückgesetzt.

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset, aber nur, wenn keine weiteren Clients an diesen Kanal angeschlossen sind.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Reset-Methode am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;

strMsg = new StringBuilder(256);

......

// Der PCI Kanal wird zurückgesetzt.
//
result = PCANBasic.Reset(PCANBasic.PCAN_PCIBUS1);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("PCAN-PCI (Ch-1) was reset");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

strMsg = gcnew StringBuilder(256);

......

// Der PCI Kanal wird zurückgesetzt.
//
result = PCANBasic::Reset(PCANBasic::PCAN_PCIBUS1);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("PCAN-PCI (Ch-1) was reset");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

strMsg = New StringBuilder(256)

......

' Der PCI Kanal wird zurückgesetzt.
'
result = PCANBasic.Reset(PCANBasic.PCAN_PCIBUS1)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("PCAN-PCI (Ch-1) was reset")
End If

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin

......

    // Der PCI Kanal wird zurückgesetzt.
    //
    result := TPCANBasic.Reset(TPCANBasic.PCAN_PCIBUS1);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'PCAN-PCI (Ch-1) was reset','Success', MB_OK);

Python:

......

# Der PCI Kanal wird zurückgesetzt.
#
result = objPCAN.Reset(PCAN_PCIBUS1)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("PCAN-PCI (Ch-1) was reset")
Siehe auch

Read

Write

SetValue

Als reine Funktionsversion: CAN_Reset


GetStatus

Willkommen
GetStatus

Liest den momentanen Bus-Zustand eines PCAN-Kanals.

Syntax
Pascal OO
class function GetStatus(
    Channel: TPCANHandle
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetStatus")]
public static extern TPCANStatus GetStatus(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetStatus")]
static TPCANStatus GetStatus(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_GetStatus")> _
Public Shared Function GetStatus( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle) As TPCANStatus
End Function
Python
def GetStatus(
    self,
    Channel)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Es können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand.
PCAN_ERROR_OK: | Der Zustand des gewählten PCAN-Kanals ist OK.
Anmerkungen

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. die PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der GetStatus-Methode am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;

strMsg = new StringBuilder(256);

......

// Überprüfung des Status des PCI Kanals.
//
result = PCANBasic.GetStatus(PCANBasic.PCAN_PCIBUS1);
switch (result)
{
    case TPCANStatus.PCAN_ERROR_BUSLIGHT:
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...");
        break;
    case TPCANStatus.PCAN_ERROR_BUSHEAVY:
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...");
        break;
    case TPCANStatus.PCAN_ERROR_BUSOFF:
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-OFF status...");
        break;
    case TPCANStatus.PCAN_ERROR_OK:
        MessageBox.Show("PCAN-PCI (Ch-1): Status is OK");
        break;
    default:
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
        break;
}

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

strMsg = gcnew StringBuilder(256);

......

// Überprüfung des Status des PCI Kanals.
//
result = PCANBasic::GetStatus(PCANBasic::PCAN_PCIBUS1);
switch (result)
{
    case TPCANStatus::PCAN_ERROR_BUSLIGHT:
        MessageBox::Show("PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...");
        break;
    case TPCANStatus::PCAN_ERROR_BUSHEAVY:
        MessageBox::Show("PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...");
        break;
    case TPCANStatus::PCAN_ERROR_BUSOFF:
        MessageBox::Show("PCAN-PCI (Ch-1): Handling a BUS-OFF status...");
        break;
    case TPCANStatus::PCAN_ERROR_OK:
        MessageBox::Show("PCAN-PCI (Ch-1): Status is OK");
        break;
    default:
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
        break;
}

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

strMsg = New StringBuilder(256)

......

' Überprüfung des Status des PCI Kanals.
'
result = PCANBasic.GetStatus(PCANBasic.PCAN_PCIBUS1)
Select Case result
    Case TPCANStatus.PCAN_ERROR_BUSLIGHT
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...")
    Case TPCANStatus.PCAN_ERROR_BUSHEAVY
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...")
    Case TPCANStatus.PCAN_ERROR_BUSOFF
        MessageBox.Show("PCAN-PCI (Ch-1): Handling a BUS-OFF status...")
    Case TPCANStatus.PCAN_ERROR_OK
        MessageBox.Show("PCAN-PCI (Ch-1): Status is OK")
    Case Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString)
End Select

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin

......

// Überprüfung des Status des PCI Kanals.
//
result := TPCANBasic.GetStatus(TPCANBasic.PCAN_PCIBUS1);
case result of
    PCAN_ERROR_BUSLIGHT:
        MessageBox(0,'PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...','Status',MB_OK);
    PCAN_ERROR_BUSHEAVY:
        MessageBox(0,'PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...','Status',MB_OK);
    PCAN_ERROR_BUSOFF:
        MessageBox(0,'PCAN-PCI (Ch-1): Handling a BUS-OFF status...','Status',MB_OK);
    PCAN_ERROR_OK:
        MessageBox(0,'PCAN-PCI (Ch-1): Status is OK','Status',MB_OK);
    else
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end;
end;

Python:

......

# Überprüfung des Status des PCI Kanals.
#
result = objPCAN.GetStatus(PCAN_PCIBUS1)
if result == PCAN_ERROR_BUSLIGHT:
    print ("PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...")
elif result == PCAN_ERROR_BUSHEAVY:
    print ("PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...")
elif result == PCAN_ERROR_BUSOFF:
    print ("PCAN-PCI (Ch-1): Handling a BUS-OFF status...")
elif result == PCAN_ERROR_OK:
    print ("PCAN-PCI (Ch-1): Status is OK")
else:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
Siehe auch

Parameterwert Definitionen

TPCANParameter

Als reine Funktionsversion: CAN_GetStatus


Read

Willkommen
Read

Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines PCAN-Kanals.

Überladungen
Methode | Beschreibung
Read(TPCANHandle, TPCANMsg) | Liest eine CAN-Botschaft aus dem Empfangspuffer (Software).
Read(TPCANHandle, TPCANMsg, TPCANTimestamp) | Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).
Read(TPCANHandle) | Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).


Read(TPCANHandle, TPCANMsg)

Willkommen
Read(TPCANHandle, TPCANMsg)

Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines PCAN-Kanals.

Syntax
Pascal OO
class function Read(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsg
    ): TPCANStatus; overload;
C#
public static TPCANStatus Read(
    TPCANHandle Channel,
    out TPCANMsg MessageBuffer);
C++ / CLR
static TPCANStatus Read(
    TPCANHandle Channel,
    TPCANMsg %MessageBuffer);
Visual Basic
Public Shared Function Read( _
    ByVal Channel As TPCANHandle, _
    ByRef MessageBuffer As TPCANMsg) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsg zur Speicherung der CAN-Botschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsg zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Die Methode Read liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft Read aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information. Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Falls für die zu lesende Botschaft ein Zeitstempel benötigt wird, muss die überladene Methode Read verwendet werden.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der Read-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die Read-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von Read ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_BUSLIGHT | 0004h | Busfehler: Fehlerzähler erreichte 'Light'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSHEAVY | 0008h | Busfehler: Fehlerzähler erreichte 'Heavy'-Limit.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Read-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist, und dass der folgende Code eine OnTimer-event handler Methode ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsg msg;

strMsg = new StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic.Read(PCANBasic.PCAN_USBBUS1, out msg);
    if (result != TPCANStatus.PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox.Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus.PCAN_ERROR_QRCVEMPTY) != TPCANStatus.PCAN_ERROR_QRCVEMPTY);

C++CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsg msg;

strMsg = gcnew StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic::Read(PCANBasic::PCAN_USBBUS1, msg);
    if (result != TPCANStatus::PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox::Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus::PCAN_ERROR_QRCVEMPTY) != TPCANStatus::PCAN_ERROR_QRCVEMPTY);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsg

strMsg = New StringBuilder(256)

Do
    ' Prüfen den Empfangspuffer nach neue Nachrichten.
    '
    result = PCANBasic.Read(PCANBasic.PCAN_USBBUS1, msg)
    If result <> TPCANStatus.PCAN_ERROR_QRCVEMPTY Then
        ' Verarbeitung der ankommenden Nachricht.
        '
        MessageBox.Show("A message was received")
        ProcessMessage(msg)
    Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString())
        ' Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        ' (z.B. der Hardware befindet sich im bus-off Zustand).
        '
        HandleReadError(result);
    End If
' Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
' bis der Empfangspuffer leer ist.
'
Loop While ((result And TPCANStatus.PCAN_ERROR_QRCVEMPTY) <> TPCANStatus.PCAN_ERROR_QRCVEMPTY)

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsg;
begin
    repeat
        // Prüfen den Empfangspuffer nach neue Nachrichten.
        //
        result := TPCANBasic.Read(TPCANBasic.PCAN_USBBUS1, msg);
        If (result <> PCAN_ERROR_QRCVEMPTY) Then
        begin
            // Verarbeitung der ankommenden Nachricht.
            //
            MessageBox(0,'A message was received','Success', MB_OK);
            ProcessMessage(msg);
        end
        else
        begin
            // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
            //
            TPCANBasic.GetErrorText(result, 0, strMsg);
            MessageBox(0, strMsg, 'Error',MB_OK);
            // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
            // (z.B. der Hardware befindet sich im bus-off Zustand).
            //
            HandleReadError(result);
        end;
    // Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
    // bis der Empfangspuffer leer ist.
    //
    until ((TPCANStatus(Integer(result) AND Integer(PCAN_ERROR_QRCVEMPTY))) = PCAN_ERROR_QRCVEMPTY);
Siehe auch

Write

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_Read


Read(TPCANHandle, TPCANMsg, TPCANTimestamp)

Willkommen
Read(TPCANHandle, TPCANMsg, TPCANTimestamp)

Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).

Syntax
Pascal OO
class function Read(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsg;
    var TimestampBuffer: TPCANTimestamp
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Read")]
public static extern TPCANStatus Read(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    out TPCANMsg MessageBuffer,
    ref TPCANTimestamp TimestampBuffer);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Read")]
static TPCANStatus Read(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    TPCANMsg %MessageBuffer,
    TPCANTimestamp %TimestampBuffer);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_Read")> _
Public Shared Function Read( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    ByRef MessageBuffer As TPCANMsg, _
    ByRef TimestampBuffer As TPCANTimestamp) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsg zur Speicherung der CAN-Botschaft.
TimestampBuffer | Ein Puffer vom Typ TPCANTimestamp zur Speicherung der Empfangszeit.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsg zeigen. Der Wert für 'TimestampBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANTimestamp zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Die Methode Read liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft Read aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information. Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Falls für die zu lesende Botschaft kein Zeitstempel benötigt wird, muss die überladene Methode Read verwendet werden.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der Read-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die Read-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von Read ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_BUSLIGHT | 0004h | Busfehler: Fehlerzähler erreichte 'Light'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSHEAVY | 0008h | Busfehler: Fehlerzähler erreichte 'Heavy'-Limit.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Read-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist. und dass der folgende Code eine OnTimer-event handler Methode ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsg msg;
TPCANTimestamp time;

strMsg = new StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic.Read(PCANBasic.PCAN_USBBUS1, out msg, out time);
    if (result != TPCANStatus.PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox.Show("A message was received");
        ProcessMessage(msg, time);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus.PCAN_ERROR_QRCVEMPTY) != TPCANStatus.PCAN_ERROR_QRCVEMPTY);

C++CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsg msg;
TPCANTimestamp time;

strMsg = gcnew StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic::Read(PCANBasic::PCAN_USBBUS1, msg, time);
    if (result != TPCANStatus::PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox::Show("A message was received");
        ProcessMessage(msg, time);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus::PCAN_ERROR_QRCVEMPTY) != TPCANStatus::PCAN_ERROR_QRCVEMPTY);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsg
Dim time As TPCANTimestamp

strMsg = New StringBuilder(256)

Do
    ' Prüfen den Empfangspuffer nach neue Nachrichten.
    '
    result = PCANBasic.Read(PCANBasic.PCAN_USBBUS1, msg, time)
    If result <> TPCANStatus.PCAN_ERROR_QRCVEMPTY Then
        ' Verarbeitung der ankommenden Nachricht.
        '
        MessageBox.Show("A message was received")
        ProcessMessage(msg, time)
    Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString())
        ' Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        ' (z.B. der Hardware befindet sich im bus-off Zustand).
        '
        HandleReadError(result);
    End If
' Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
' bis der Empfangspuffer leer ist.
'
Loop While ((result And TPCANStatus.PCAN_ERROR_QRCVEMPTY) <> TPCANStatus.PCAN_ERROR_QRCVEMPTY)

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsg;
    time: TPCANTimestamp;
begin
    repeat
        // Prüfen den Empfangspuffer nach neue Nachrichten.
        //
        result := TPCANBasic.Read(TPCANBasic.PCAN_USBBUS1, msg, time);
        If (result <> PCAN_ERROR_QRCVEMPTY) Then
        begin
            // Verarbeitung der ankommenden Nachricht.
            //
            MessageBox(0,'A message was received','Success', MB_OK);
            ProcessMessage(msg, time);
        end
        else
        begin
            // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
            //
            TPCANBasic.GetErrorText(result, 0, strMsg);
            MessageBox(0, strMsg, 'Error',MB_OK);
            // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
            // (z.B. der Hardware befindet sich im bus-off Zustand).
            //
            HandleReadError(result);
        end;
    // Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
    // bis der Empfangspuffer leer ist.
    //
    until ((TPCANStatus(Integer(result) AND Integer(PCAN_ERROR_QRCVEMPTY))) = PCAN_ERROR_QRCVEMPTY);
Siehe auch

Write

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_Read


Read(TPCANHandle)

Willkommen
Read(TPCANHandle)

Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).

Syntax
Python
def Read(
    self,
    Channel)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist dreiteilig (3-tuple). Die Anordnung der Werte ist wie folgt:

[0]: Der Rückgabecode ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein Übergabeparameter für die Methode ist ungültig.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.

[1]: Eine TPCANMsg Struktur mit der gelesenen Botschaft.

[2]: Eine TPCANTimestamp Struktur mit der Empfangszeit.

Anmerkungen

Die Methode Read liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft Read aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information. Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der Read-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die Read-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die CAN-Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von Read ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_BUSLIGHT | 0004h | Busfehler: Fehlerzähler erreichte 'Light'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSHEAVY | 0008h | Busfehler: Fehlerzähler erreichte 'Heavy'-Limit.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel demonstriert die Verwendung der Read-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist, und dass der folgende Code periodisch durchlaufen wird.

Python:

readResult = PCAN_ERROR_OK,
while (readResult[0] & PCAN_ERROR_QRCVEMPTY) != PCAN_ERROR_QRCVEMPTY:
    # Prüfen den Empfangspuffer nach neue Nachrichten.
    #
    readResult = objPCAN.Read(PCAN_USBBUS1)
    if readResult[0] != PCAN_ERROR_QRCVEMPTY:
        # Verarbeitung der ankommenden Nachricht.
        #
        print ("A message was received")
        ProcessMessage(result[1],result[2])
    else:
        # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        #
        result = objPCAN.GetErrorText(readResult[0])
        print (result[1])
        HandleReadError(readResult[0])
Siehe auch

Write

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_Read


ReadFD

Willkommen
ReadFD

Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.

Overloads
Function | Description
ReadFD(TPCANHandle, TPCANMsgFD) | Liest eine CAN-Botschaft aus dem Empfangspuffer (Software).
ReadFD(TPCANHandle, TPCANMsgFD, TPCANTimestampFD) | Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).
ReadFD(TPCANHandle) | Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software).


ReadFD(TPCANHandle, TPCANMsgFD)

Willkommen
ReadFD(TPCANHandle, TPCANMsgFD)

Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.

Syntax
Pascal OO
class function ReadFD(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsgFD
    ):TPCANStatus; overload;
C#
public static TPCANStatus ReadFD(
    TPCANHandle Channel,
    out TPCANMsgFD MessageBuffer)
C++ / CLR
static TPCANStatus ReadFD(
    TPCANHandle Channel,
    TPCANMsgFD %MessageBuffer);
Visual Basic
Public Shared Function ReadFD( _
    ByVal Channel As TPCANHandle, _
    ByRef MessageBuffer As TPCANMsgFD) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsgFD zur Speicherung der CAN-Botschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsgFD zeigen.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSWARNING: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-warning Zustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_BUSPASSIVE: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im passiven Fehlerzustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall ist MessageBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Die Verwendung von Read - und ReadFD schließen sich gegenseitig aus. Der an diese Methode übergebene PCAN-Kanal, must mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Die Methode ReadFD liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft ReadFD aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information.

Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Falls für die zu lesende Botschaft ein Zeitstempel benötigt wird, muss die überladene Methode ReadFD verwendet werden.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der ReadFD-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die ReadFD-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, FD, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von ReadFD ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 00h | PCAN_ERROR_OK | 0000h | CAN-Controller wurde erfolgreich aktiviert.
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_WARNING | 0008h | Busfehler: Fehlerzähler erreichte 'Warning'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSPASSIVE | 40000h | Busfehler: Der CAN-Controller ist im passiven Fehlerzustand.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der ReadFD-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels InitializeFD initialisiert ist, und dass der folgende Code eine OnTimer-event handler Methode ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsgFD msg;

strMsg = new StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic.ReadFD(PCANBasic.PCAN_USBBUS1, out msg);
    if (result != TPCANStatus.PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox.Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus.PCAN_ERROR_QRCVEMPTY) != TPCANStatus.PCAN_ERROR_QRCVEMPTY);

C++CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsgFD msg;

strMsg = gcnew StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic::ReadFD(PCANBasic::PCAN_USBBUS1, msg);
    if (result != TPCANStatus::PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox::Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus::PCAN_ERROR_QRCVEMPTY) != TPCANStatus::PCAN_ERROR_QRCVEMPTY);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsgFD

strMsg = New StringBuilder(256)

Do
    ' Prüfen den Empfangspuffer nach neue Nachrichten.
    '
    result = PCANBasic.ReadFD(PCANBasic.PCAN_USBBUS1, msg)
    If result <> TPCANStatus.PCAN_ERROR_QRCVEMPTY Then
        ' Verarbeitung der ankommenden Nachricht.
        '
        MessageBox.Show("A message was received")
        ProcessMessage(msg)
    Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString())
        ' Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        ' (z.B. der Hardware befindet sich im bus-off Zustand).
        '
        HandleReadError(result)
    End If
' Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
' bis der Empfangspuffer leer ist.
'
Loop While ((result And TPCANStatus.PCAN_ERROR_QRCVEMPTY) <> TPCANStatus.PCAN_ERROR_QRCVEMPTY)

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsgFD;
begin
    repeat
        // Prüfen den Empfangspuffer nach neue Nachrichten.
        //
        result := TPCANBasic.ReadFD(TPCANBasic.PCAN_USBBUS1, msg);
        If (result <> PCAN_ERROR_QRCVEMPTY) Then
        begin
            // Verarbeitung der ankommenden Nachricht.
            //
            MessageBox(0,'A message was received','Success', MB_OK);
            ProcessMessage(msg);
        end
        else
        begin
            // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
            //
            TPCANBasic.GetErrorText(result, 0, strMsg);
            MessageBox(0, strMsg, 'Error',MB_OK);
            // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
            // (z.B. der Hardware befindet sich im bus-off Zustand).
            //
            HandleReadError(result);
        end;
    // Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
    // bis der Empfangspuffer leer ist.
    //
    until ((TPCANStatus(Integer(result) AND Integer(PCAN_ERROR_QRCVEMPTY))) = PCAN_ERROR_QRCVEMPTY);
Siehe auch

WriteFD

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_ReadFD


ReadFD(TPCANHandle, TPCANMsgFD, TPCANTimestampFD)

Willkommen
ReadFD(TPCANHandle, TPCANMsgFD, TPCANTimestampFD)

Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.

Syntax
Pascal OO
class function ReadFD(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsgFD;
    var TimestampBuffer: TPCANTimestampFD
    ):TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_ReadFD")]
public static extern TPCANStatus ReadFD(
     [MarshalAs(UnmanagedType.U1)]
     TPCANHandle Channel,
     out TPCANMsgFD MessageBuffer,
     out TPCANTimestampFD TimestampBuffer);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_ReadFD")]
static TPCANStatus ReadFD(
     [MarshalAs(UnmanagedType::U1)]
     TPCANHandle Channel,
     TPCANMsgFD %MessageBuffer,
     TPCANTimestampFD %TimestampBuffer);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_ReadFD")> _
Public Shared Function ReadFD( _
     <MarshalAs(UnmanagedType.U1)> _
     ByVal Channel As TPCANHandle, _
     ByRef MessageBuffer As TPCANMsgFD, _
     ByRef TimestampBuffer As TPCANTimestampFD) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsgFD zur Speicherung der CAN-Botschaft.
TimestampBuffer | Ein Puffer vom Typ TPCANTimestampFD zur Speicherung der Empfangszeit.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsgFD zeigen.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSWARNING: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-warning Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSPASSIVE: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im passiven Fehlerzustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Die Verwendung von Read - und ReadFD schließen sich gegenseitig aus. Der an diese Methode übergebene PCAN-Kanal, must mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Die Methode ReadFD liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft ReadFD aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information.

Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Falls für die zu lesende Botschaft ein Zeitstempel benötigt wird, muss die überladene Methode ReadFD verwendet werden.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der ReadFD-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die ReadFD-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, FD, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von ReadFD ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 00h | PCAN_ERROR_OK | 0000h | CAN-Controller wurde erfolgreich aktiviert.
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_WARNING | 0008h | Busfehler: Fehlerzähler erreichte 'Warning'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSPASSIVE | 40000h | Busfehler: Der CAN-Controller ist im passiven Fehlerzustand.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der ReadFD-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels InitializeFD initialisiert ist, und dass der folgende Code eine OnTimer-event handler Methode ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsgFD msg;
TPCANTimestampFD time;

strMsg = new StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic.ReadFD(PCANBasic.PCAN_USBBUS1, out msg, out time);
    if (result != TPCANStatus.PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox.Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus.PCAN_ERROR_QRCVEMPTY) != TPCANStatus.PCAN_ERROR_QRCVEMPTY);

C++CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsgFD msg;
TPCANTimestampFD time;

strMsg = gcnew StringBuilder(256);

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten.
    //
    result = PCANBasic::ReadFD(PCANBasic::PCAN_USBBUS1, msg, time);
    if (result != TPCANStatus::PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht.
        //
        MessageBox::Show("A message was received");
        ProcessMessage(msg);
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & TPCANStatus::PCAN_ERROR_QRCVEMPTY) != TPCANStatus::PCAN_ERROR_QRCVEMPTY);

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsgFD
Dim time As TPCANTimestampFD

strMsg = New StringBuilder(256)

Do
    ' Prüfen den Empfangspuffer nach neue Nachrichten.
    '
    result = PCANBasic.ReadFD(PCANBasic.PCAN_USBBUS1, msg, time)
    If result <> TPCANStatus.PCAN_ERROR_QRCVEMPTY Then
        ' Verarbeitung der ankommenden Nachricht.
        '
        MessageBox.Show("A message was received")
        ProcessMessage(msg)
    Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString())
        ' Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        ' (z.B. der Hardware befindet sich im bus-off Zustand).
        '
        HandleReadError(result)
    End If
' Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
' bis der Empfangspuffer leer ist.
'
Loop While ((result And TPCANStatus.PCAN_ERROR_QRCVEMPTY) <> TPCANStatus.PCAN_ERROR_QRCVEMPTY)

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsgFD;
    time: TPCANTimestampFD;
begin
    repeat
        // Prüfen den Empfangspuffer nach neue Nachrichten.
        //
        result := TPCANBasic.ReadFD(TPCANBasic.PCAN_USBBUS1, msg, time);
        If (result <> PCAN_ERROR_QRCVEMPTY) Then
        begin
            // Verarbeitung der ankommenden Nachricht.
            //
            MessageBox(0,'A message was received','Success', MB_OK);
            ProcessMessage(msg);
        end
        else
        begin
            // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
            //
            TPCANBasic.GetErrorText(result, 0, strMsg);
            MessageBox(0, strMsg, 'Error',MB_OK);
            // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
            // (z.B. der Hardware befindet sich im bus-off Zustand).
            //
            HandleReadError(result);
        end;
    // Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
    // bis der Empfangspuffer leer ist.
    //
    until ((TPCANStatus(Integer(result) AND Integer(PCAN_ERROR_QRCVEMPTY))) = PCAN_ERROR_QRCVEMPTY);
Siehe auch

WriteFD

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_ReadFD


ReadFD(TPCANHandle)

Willkommen
ReadFD(TPCANHandle)

Liest eine CAN-Botschaft mit Zeitstempel aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.

Syntax
Python
def ReadFD(
    self,
    Channel)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist dreiteilig (3-tuple). Die Anordnung der Werte ist wie folgt:

[0]: Der Rückgabecode ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein Übergabeparameter für die Methode ist ungültig.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSWARNING: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-warning Zustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_BUSPASSIVE: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im passiven Fehlerzustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: Alle Toupel sind in diesem Fall gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.

[1]: Ein Puffer vom Typ TPCANMsgFD mit der gelesenen Botschaft.

[2]: Ein Puffer vom Typ TPCANTimestampFD mit der Empfangszeit.

Anmerkungen

Die Verwendung von Read - und ReadFD schließen sich gegenseitig aus. Der an diese Methode übergebene PCAN-Kanal, must mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Die Methode ReadFD liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft ReadFD aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information.

Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Falls für die zu lesende Botschaft ein Zeitstempel benötigt wird, muss die überladene Methode ReadFD verwendet werden.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der ReadFD-Methode (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die ReadFD-Methode (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, FD, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von ReadFD ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 00h | PCAN_ERROR_OK | 0000h | CAN-Controller wurde erfolgreich aktiviert.
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_WARNING | 0008h | Busfehler: Fehlerzähler erreichte 'Warning'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSPASSIVE | 40000h | Busfehler: Der CAN-Controller ist im passiven Fehlerzustand.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der ReadFD-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels InitializeFD initialisiert ist, und dass der folgende Code periodisch durchlaufen wird.

Python:

readResult = PCAN_ERROR_OK,
while (readResult[0] & PCAN_ERROR_QRCVEMPTY) != PCAN_ERROR_QRCVEMPTY:
    # Prüfen den Empfangspuffer nach neue Nachrichten.
    #
    readResult = objPCAN.ReadFD(PCAN_USBBUS1)
    if readResult[0] != PCAN_ERROR_QRCVEMPTY:
        # Verarbeitung der ankommenden Nachricht.
        #
        print ("A message was received")
        ProcessMessage(result[1],result[2])
    else:
        # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        #
        result = objPCAN.GetErrorText(readResult[0])
        print (result[1])
        HandleReadError(readResult[0])
Siehe auch

WriteFD

Verwenden von Events

Error Frames

Als reine Funktionsversion: CAN_ReadFD


Write

Willkommen
Write

Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines PCAN-Kanals.

Syntax
Pascal OO
class function Write(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsg
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Write")]
public static extern TPCANStatus Write(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    ref TPCANMsg MessageBuffer);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_Write")]
static TPCANStatus Write(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    TPCANMsg %MessageBuffer);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_Write")> _
Public Shared Function Write( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    ByVal MessageBuffer As TPCANMsg) As TPCANStatus
End Function
Python
def Write(
    self,
    Channel,
    MessageBuffer)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsg zur Hinterlegung der Sendebotschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'MessageBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsg zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand
PCAN_ERROR_QXMTFULL: | Der Sendepuffer des PCAN-Kanals ist voll.
Anmerkungen

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der Write-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsg msg;

strMsg = new StringBuilder(256);

// Erzeugen einer CAN Nachricht. Das Datenfeld (8 Bytes)
// der Nachricht muss ebenfalls erstellt werden.
//
msg = new TPCANMsg();
msg.DATA = new Byte[8];

// Konfigurieren einer CAN Nachricht.
//
msg.ID = 0x100;
msg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD;
msg.LEN = 3;
msg.DATA[0] = 1;
msg.DATA[1] = 2;
msg.DATA[2] = 3;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = PCANBasic.Write(PCANBasic.PCAN_USBBUS1, ref msg);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("Message sent successfully");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsg^ msg;

strMsg = gcnew StringBuilder(256);

// Erzeugen einer CAN Nachricht. Das Datenfeld (8 Bytes)
// der Nachricht muss ebenfalls erstellt werden.
//
msg = gcnew TPCANMsg();
msg->DATA = gcnew array<Byte>(8);

// Konfigurieren einer CAN Nachricht.
//
msg->ID = 0x100;
msg->MSGTYPE = TPCANMessageType::PCAN_MESSAGE_STANDARD;
msg->LEN = 3;
msg->DATA[0] = 1;
msg->DATA[1] = 2;
msg->DATA[2] = 3;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = PCANBasic::Write(PCANBasic::PCAN_USBBUS1, *msg);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("Message sent successfully");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsg

strMsg = New StringBuilder(256)

' Erzeugen einer CAN Nachricht. Das Datenfeld (8 Bytes)
' der Nachricht muss ebenfalls erstellt werden.
'
msg = New TPCANMsg
msg.DATA = CType(Array.CreateInstance(GetType(Byte), 8), Byte())

' Konfigurieren einer CAN Nachricht.
'
msg.ID = &H100
msg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD
msg.LEN = 3
msg.DATA(0) = 1
msg.DATA(1) = 2
msg.DATA(2) = 3

' Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
'
result = PCANBasic.Write(PCANBasic.PCAN_USBBUS1, msg)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("Message sent successfully")
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsg;
begin
    // Konfigurieren einer CAN Nachricht.
    //
    msg.ID := $100;
    msg.MSGTYPE := PCAN_MESSAGE_STANDARD;
    msg.LEN := 3;
    msg.DATA[0] := 1;
    msg.DATA[1] := 2;
    msg.DATA[2] := 3;

    // Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
    //
    result := TPCANBasic.Write(TPCANBasic.PCAN_USBBUS1,msg);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'Message sent successfully','Success', MB_OK);

Python:

# Konfigurieren einer CAN Nachricht.
#
msg = TPCANMsg()
msg.ID = 0x100
msg.MSGTYPE = PCAN_MESSAGE_STANDARD
msg.LEN = 3
msg.DATA[0] = 1
msg.DATA[1] = 2
msg.DATA[2] = 3

# Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
#
result = objPCAN.Write(PCAN_USBBUS1,msg)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result)
else:
    print ("Message sent successfully")
Siehe auch

Read

SetValue

Als reine Funktionsversion: CAN_Write


WriteFD

Willkommen
WriteFD

Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines FD fähige PCAN-Kanals.

Syntax
Pascal OO
class function WriteFD(
    Channel: TPCANHandle;
    var MessageBuffer: TPCANMsgFD
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_WriteFD")]
public static extern TPCANStatus WriteFD(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    ref TPCANMsgFD MessageBuffer);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_WriteFD")]
static TPCANStatus WriteFD(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    TPCANMsgFD %MessageBuffer);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_WriteFD")> _
Public Shared Function WriteFD( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    ByRef MessageBuffer As TPCANMsgFD) As TPCANStatus
End Function
Python
def WriteFD(
    self,
    Channel,
    MessageBuffer)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsgFD zur Hinterlegung der Sendebotschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'MessageBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsgFD zeigen.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand
PCAN_ERROR_QXMTFULL: | Der Sendepuffer des PCAN-Kanals ist voll.
Anmerkungen

Die Verwendung von Write - und WriteFD schließen sich gegenseitig aus. Der an diese Methode übergebene PCAN-Kanal, must mit der Methode InitializeFD (Funktionsversion: CAN_InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der WriteFD-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels InitializeFD initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANMsgFD msg;

strMsg = new StringBuilder(256);

// Erzeugen einer CAN Nachricht. Das Datenfeld (64 Bytes)
// der Nachricht muss ebenfalls erstellt werden.
//
msg = new TPCANMsgFD();
msg.DATA = new Byte[64];

// Konfigurieren einer CAN Nachricht.
//
msg.ID = 0x100;
msg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD | TPCANMessageType.PCAN_MESSAGE_FD;

// DLC 9 bedeutet 12 Daten-Bytes
//
msg.DLC = 9;
for(byte i=0; i < 12; i++)
    msg.DATA[i] = i;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = PCANBasic.WriteFD(PCANBasic.PCAN_USBBUS1, ref msg);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("Message sent successfully");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANMsgFD^ msg;

strMsg = gcnew StringBuilder(256);

// Erzeugen einer CAN Nachricht. Das Datenfeld (64 Bytes)
// der Nachricht muss ebenfalls erstellt werden.
//
msg = gcnew TPCANMsgFD();
msg->DATA = gcnew array<Byte>(64);

// Konfigurieren einer CAN Nachricht.
//
msg->ID = 0x100;
msg->MSGTYPE = TPCANMessageType::PCAN_MESSAGE_STANDARD | TPCANMessageType::PCAN_MESSAGE_FD;

// DLC 9 bedeutet 12 Daten-Bytes
//
msg->DLC = 9;
for(Byte i=0; i < 12; i++)
    msg->DATA[i] = i;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = PCANBasic::WriteFD(PCANBasic::PCAN_USBBUS1, *msg);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("Message sent successfully");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim msg As TPCANMsgFD

strMsg = New StringBuilder(256)

' Erzeugen einer CAN Nachricht. Das Datenfeld (64 Bytes)
' der Nachricht muss ebenfalls erstellt werden.
'
msg = New TPCANMsgFD
msg.DATA = CType(Array.CreateInstance(GetType(Byte), 64), Byte())

' Konfigurieren einer CAN Nachricht.
'
msg.ID = &H100
msg.MSGTYPE = TPCANMessageType.PCAN_MESSAGE_STANDARD Or TPCANMessageType.PCAN_MESSAGE_FD

' DLC 9 bedeutet 12 Daten-Bytes
'
msg.DLC = 9
For i As Byte = 0 To 11
    msg.DATA(i) = i
Next

' Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
'
result = PCANBasic.WriteFD(PCANBasic.PCAN_USBBUS1, msg)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("Message sent successfully")
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    msg: TPCANMsgFD;
    I: Integer;
begin
    // Konfigurieren einer CAN Nachricht.
    //
    msg.ID := $100;
    msg.MSGTYPE := TPCANMessageType(Byte(PCAN_MESSAGE_STANDARD) OR Byte(PCAN_MESSAGE_FD));

    // DLC 9 bedeutet 12 Daten-Bytes
    //
    msg.DLC := 9;
    for I:=0 To 11 do
        msg.DATA[I] := I;

    // Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
    //
    result := TPCANBasic.WriteFD(TPCANBasic.PCAN_USBBUS1,msg);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0,'Message sent successfully','Success', MB_OK);

Python:

# Konfigurieren einer CAN Nachricht.
#
msg = TPCANMsgFD()
msg.ID = 0x100
msg.MSGTYPE = PCAN_MESSAGE_STANDARD.value | PCAN_MESSAGE_FD.value

# DLC 9 bedeutet 12 Daten-Bytes
#
msg.DLC = 9
for i in range(12):
    msg.DATA[i] = i

#  Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
#
result = objPCAN.WriteFD(PCAN_USBBUS1,msg)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result)
else:
    print ("Message sent successfully")
Siehe auch

ReadFD

SetValue

Als reine Funktionsversion: CAN_WriteFD


GetValue

Willkommen
GetValue

Liest eine Konfigurations- oder Dateninformation von einem PCAN-Kanal.

Überladungen
Methode | Beschreibung
GetValue(TPCANHandle,TPCANParameter) | Liest Informationen von einem PCAN-Kanal.
GetValue(TPCANHandle, TPCANParameter, UInt32, UInt32) | Liest Informationen von einem PCAN-Kanal in numerischer Form (32-Bit).
GetValue(TPCANHandle, TPCANParameter, UInt64, UInt32) | Liest Informationen von einem PCAN-Kanal in numerischer Form (64-Bit).
GetValue(TPCANHandle, TPCANParameter, String, TPCANChannelInformation[]) | Ruft ein Array von TPCANChannelInformation mit Informationen über die derzeit an das System angeschlossene Hardware ab.
GetValue(TPCANHandle, TPCANParameter, String, UInt32) | Liest Informationen von einem PCAN-Kanal in Textform.


GetValue(TPCANHandle,TPCANParameter)

Willkommen
GetValue(TPCANHandle,TPCANParameter)

Liest Informationen von einem PCAN-Kanal.

Syntax
Python
def GetValue(
    self,
    Channel,
    Parameter)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
Rückgabe

Der Rückgabewert ist zweiteilig (2-tuple). Die Anordnung der Werte ist wie folgt:

[0]: Der Rückgabecode ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.

[1]: Der Wert des gewählten Parameters.

Anmerkungen

Die Methode GetValue wird benutzt um Information über die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Vorhandensein eines Hardware-Kanals) zu bekommen. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel demonstriert die Verwendung der GetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

Python:

# Der Zustand des Botschaftsfilters des PCAN-USB Kanal-1 wird geprüft.
#
result = objPCAN.GetValue(PCAN_USBBUS1,PCAN_MESSAGE_FILTER)
if result[0] != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result[0])
    print (result)
else:
    # Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
    #
    if result[1] == PCAN_FILTER_OPEN:
        print ("The message filter for the PCAN-USB, channel 1, is completely opened.")
    elif result[1] == PCAN_FILTER_CLOSE:
        print ("The message filter for the PCAN-USB, channel 1, is closed.")
    elif result[1] == PCAN_FILTER_CUSTOM:
        print ("The message filter for the PCAN-USB, channel 1, is custom configured.")
Siehe auch

SetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_GetValue


GetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)

Willkommen
GetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)

Liest Informationen von einem PCAN-Kanal in numerischer Form.

Syntax
Pascal OO
class function GetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    NumericBuffer: PLongWord;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
public static extern TPCANStatus GetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    out UInt32 NumericBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
static TPCANStatus GetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    UInt32 %NumericBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_GetValue")> _
Public Shared Function GetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    ByRef NumericBuffer As UInt32, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
NumericBuffer | Der Puffer für einen numerischen Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'NumericBuffer' ist zu prüfen: er sollte auf einen Puffer vom typ Integer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
Anmerkungen

Die Methode GetValue wird benutzt um Information über die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Vorhandensein eines Hardware-Kanals) zu bekommen. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der GetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
UInt32 iBuffer;

strMsg = new StringBuilder(256);

// Der Zustand des Botschaftsfilters des PCAN-USB Kanal-1 wird geprüft.
//
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, out iBuffer, sizeof(UInt32));
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    // Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
    //
    switch(iBuffer)
    {
        case PCANBasic.PCAN_FILTER_OPEN:
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is completely opened.");
            break;
        case PCANBasic.PCAN_FILTER_CLOSE:
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is closed.");
            break;
        case PCANBasic.PCAN_FILTER_CUSTOM:
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is custom configured.");
            break;
    }

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
UInt32 iBuffer;

strMsg = gcnew StringBuilder(256);

// Der Zustand des Botschaftsfilters des PCAN-USB Kanal-1 wird geprüft.
//
result = PCANBasic::GetValue(PCANBasic::PCAN_USBBUS1, TPCANParameter::PCAN_MESSAGE_FILTER, iBuffer, sizeof(iBuffer));
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    // Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
    //
    switch(iBuffer)
    {
        case PCANBasic::PCAN_FILTER_OPEN:
            MessageBox::Show("The message filter for the PCAN-USB, channel 1, is completely opened.");
            break;
        case PCANBasic::PCAN_FILTER_CLOSE:
            MessageBox::Show("The message filter for the PCAN-USB, channel 1, is closed.");
            break;
        case PCANBasic::PCAN_FILTER_CUSTOM:
            MessageBox::Show("The message filter for the PCAN-USB, channel 1, is custom configured.");
            break;
    }

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim iBuffer As UInt32

strMsg = New StringBuilder(256)

' Der Zustand des Botschaftsfilters des PCAN-USB Kanal-1 wird geprüft.
'
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, iBuffer, Convert.ToUInt32(Len(iBuffer)))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString())
Else
    ' Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
    '
    Select Case iBuffer
        Case PCANBasic.PCAN_FILTER_OPEN
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is completely opened.")
        Case PCANBasic.PCAN_FILTER_CLOSE
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is closed.")
        Case PCANBasic.PCAN_FILTER_CUSTOM
            MessageBox.Show("The message filter for the PCAN-USB, channel 1, is custom configured.")
    End Select
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    iBuffer: LongWord;
begin
    // Der Zustand des Botschaftsfilters des PCAN-USB Kanal-1 wird geprüft.
    //
    result := TPCANBasic.GetValue(TPCANBasic.PCAN_USBBUS1, PCAN_MESSAGE_FILTER, PLongWord(@iBuffer), sizeof(iBuffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
    begin
        // Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
        //
        if iBuffer = TPCANBasic.PCAN_FILTER_OPEN then
                MessageBox(0, 'The message filter for the PCAN-USB, channel 1, is completely opened.', 'Success',MB_OK);
        if iBuffer = TPCANBasic.PCAN_FILTER_CLOSE then
                MessageBox(0, 'The message filter for the PCAN-USB, channel 1, is closed.', 'Success',MB_OK);
        if iBuffer = TPCANBasic.PCAN_FILTER_CUSTOM then
                MessageBox(0, 'The message filter for the PCAN-USB, channel 1, is custom configured.', 'Success',MB_OK);
    end;
Siehe auch

SetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_GetValue


GetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)

Willkommen
GetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)

Liest Informationen von einem PCAN-Kanal in numerischer Form.

Syntax
Pascal OO
class function GetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    NumericBuffer: PUInt64;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
public static extern TPCANStatus GetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    out UInt64 NumericBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
static TPCANStatus GetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    UInt64 %NumericBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_GetValue")> _
Public Shared Function GetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    ByRef NumericBuffer As UInt64, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
NumericBuffer | Der Puffer für einen numerischen 64-bit Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'NumericBuffer' ist zu prüfen: er sollte auf einen Puffer vom typ 64-bit Integer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
Anmerkungen

Die Methode GetValue wird benutzt um Information über die PCAN-Umgebung (z. B. Akzeptanzfilter) zu bekommen. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der GetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
UInt64 i64Buffer;
UInt32 iCode, iMask;

strMsg = new StringBuilder(256);

// Der Zustand des Akzeptanzfilters (11-Bit) des PCAN-USB Kanal-1 wird geprüft.
//
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_ACCEPTANCE_FILTER_11BIT, out i64Buffer, sizeof(UInt64));
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
{
    // Code und Maske werden aus dem 64-Bit-numerischen Wert extrahiert
    //
    iCode = Convert.ToUInt32((i64Buffer >> 32);
    iMask = Convert.ToUInt32(i64Buffer & UInt32.MaxValue);

    // Code und Maske werden als Text angezeigt
    //
    MessageBox.Show(string.Format("11-Bit Akzeptanzfilter: Code: {0:X8} | Maske: {1:X8}", iCode, iMask));
}

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
UInt64 i64Buffer;
UInt32 iCode, iMask;

strMsg = gcnew StringBuilder(256);

// Der Zustand des Akzeptanzfilters (11-Bit) des PCAN-USB Kanal-1 wird geprüft.
//
result = PCANBasic::GetValue(PCANBasic::PCAN_USBBUS1, TPCANParameter::PCAN_ACCEPTANCE_FILTER_11BIT, i64Buffer, sizeof(i64Buffer));
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
{
    // Code und Maske werden aus dem 64-Bit-numerischen Wert extrahiert
    //
    iCode = Convert::ToUInt32((i64Buffer >> 32);
    iMask = Convert::ToUInt32(i64Buffer & UInt32::MaxValue);

    // Code und Maske werden als Text angezeigt
    //
    MessageBox::Show(String::Format("11-Bit Akzeptanzfilter: Code: {0:X8} | Maske: {1:X8}", iCode, iMask));
}

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim i64Buffer As UInt64
Dim iCode As UInt32
Dim iMask As UInt32

strMsg = New StringBuilder(256)

' Der Zustand des Akzeptanzfilters (11-Bit) des PCAN-USB Kanal-1 wird geprüft.
'
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_ACCEPTANCE_FILTER_11BIT, i64Buffer, CType(System.Runtime.InteropServices.Marshal.SizeOf(i64Buffer), UInteger))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString())
Else
    ' Code und Maske werden aus dem 64-Bit-numerischen Wert extrahiert
    '
    iCode = Convert.ToUInt32(i64Buffer >> 32)
    iMask = Convert.ToUInt32(i64Buffer And UInt32.MaxValue)

    ' Code und Maske werden als Text angezeigt
    '
    MessageBox.Show(String.Format("11-Bit Akzeptanzfilter: Code: {0:X8} | Maske: {1:X8}", iCode, iMask))
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    i64Buffer: UInt64;
    iCode, iMask: LongWord;
begin
    // Der Zustand des Akzeptanzfilters (11-Bit) des PCAN-USB Kanal-1 wird geprüft.
    //
    result := TPCANBasic.GetValue(TPCANBasic.PCAN_USBBUS1, PCAN_ACCEPTANCE_FILTER_11BIT, PUInt64(@i64Buffer), sizeof(i64Buffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Fehler',MB_OK);
    end
    else
    begin
        // Code und Maske werden aus dem 64-Bit-numerischen Wert extrahiert
        //
        iCode := i64Buffer shr 32;
        iMask := (i64Buffer And $FFFFFFFF);

        // Code und Maske werden als Text angezeigt
        //
        MessageBox(0, PChar(Format(11-Bit Akzeptanzfilter: Code: %.8X | Maske: %.8X', [iCode, iMask])), 'Erfolg',MB_OK);
    end;
end;
Siehe auch

SetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_GetValue


GetValue(TPCANHandle, TPCANParameter, String, TPCANChannelInformation[])

Willkommen
GetValue(TPCANHandle, TPCANParameter, String, TPCANChannelInformation[])

Ruft ein Array von TPCANChannelInformation mit Informationen über die derzeit an das System angeschlossene Hardware ab.

Syntax
Pascal OO
class function GetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    ChannelsBuffer: PTPCANChannelInformation;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
public static TPCANStatus GetValue(
    TPCANHandle Channel,
    TPCANParameter Parameter,
    TPCANChannelInformation ChannelsBuffer);
C++ / CLR
static TPCANStatus GetValue(
    TPCANHandle Channel,
    TPCANParameter Parameter,
    array<TPCANChannelInformation> ^ChannelsBuffer);
Visual Basic
Public Shared Function GetValue( _
    ByVal Channel As TPCANHandle, _
    ByVal Parameter As TPCANParameter, _
    ByRef ChannelsBuffer() As TPCANChannelInformation) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
ChannelsBuffer | Der Puffer für ein Array von TPCANChannelInformation-Werten.
BufferLength | Die Grösse des Puffers (in bytes). Hinweis: Nur gültig für Pascal OO. Bei Verwendung einer .NET-Sprache wird die Größe automatisch anhand der Länge des ChannelsBuffer-Arrays berechnet.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'ChannelsBuffer' ist zu prüfen: er sollte auf einen Puffer vom Typ TPCANChannelInformation zeigen.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Nur PCAN_NONEBUS ist erlaubt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
Beispiel

Das folgende Beispiel zeigt die Verwendung der Methode GetValue auf dem Kanal PCAN_NONEBUS, um Informationen über die aktuell an den PC angeschlossenen Kanäle abzurufen. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C#:

StringBuilder strMsg = new StringBuilder(256);

// Die Anzahl der verfügbaren Kanäle wird abgefragt
//
TPCANStatus stsResult = PCANBasic.GetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_ATTACHED_CHANNELS_COUNT, out uint iChannelsCount, sizeof(uint));

if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(stsResult, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
{
    // Ein Puffer zum Speichern der Informationen wird erstellt
    //
    TPCANChannelInformation[] ciChannelInformation = new TPCANChannelInformation[iChannelsCount];

    // Die Informationen über angeschlossene Kanäle werden abgerufen
    //
    stsResult = PCANBasic.GetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_ATTACHED_CHANNELS, ciChannelInformation);

    // Die Informationen zu den angeschlossenen Kanälen werden angezeigt
    //
    if (stsResult == TPCANStatus.PCAN_ERROR_OK)
    {
        Console.WriteLine("-----------------------------------------------------------------------------------------");
        Console.WriteLine("Get PCAN_ATTACHED_CHANNELS:");

        foreach (TPCANChannelInformation currentChannelInformation in ciChannelInformation)
        {
            Console.WriteLine("---------------------------");
            Console.WriteLine("channel_handle:      " + currentChannelInformation.channel_handle);
            Console.WriteLine("device_type:         " + currentChannelInformation.device_type);
            Console.WriteLine("controller_number:   " + currentChannelInformation.controller_number);
            Console.WriteLine("device_features:     " + currentChannelInformation.device_features);
            Console.WriteLine("device_name:         " + currentChannelInformation.device_name);
            Console.WriteLine("device_id:           " + currentChannelInformation.device_id);
            Console.WriteLine("channel_condition:   " + currentChannelInformation.channel_condition);
        }
        Console.WriteLine();
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(stsResult, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
    }
}

C++/CLR:

StringBuilder^ strMsg = gcnew StringBuilder(256);

// Die Anzahl der verfügbaren Kanäle wird abgefragt
//
UInt32 iChannelsCount;
TPCANStatus stsResult = PCANBasic::GetValue(PCANBasic::PCAN_NONEBUS, TPCANParameter::PCAN_ATTACHED_CHANNELS_COUNT, iChannelsCount, sizeof(UInt32));

if (stsResult != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(stsResult, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
{
    // Ein Puffer zum Speichern der Informationen wird erstellt
    //
    array<TPCANChannelInformation>^ ciChannelInformation = gcnew array<TPCANChannelInformation>(iChannelsCount);

    // Die Informationen über angeschlossene Kanäle werden abgerufen
    //
    stsResult = PCANBasic::GetValue(PCANBasic::PCAN_NONEBUS, TPCANParameter::PCAN_ATTACHED_CHANNELS, ciChannelInformation);

    // Die Informationen zu den angeschlossenen Kanälen werden angezeigt
    //
    if (stsResult == TPCANStatus::PCAN_ERROR_OK)
    {
        Console::WriteLine("-----------------------------------------------------------------------------------------");
        Console::WriteLine("Get PCAN_ATTACHED_CHANNELS:");

        for each (TPCANChannelInformation^ currentChannelInformation in ciChannelInformation)
        {
            Console::WriteLine("---------------------------");
            Console::WriteLine("channel_handle:      " + currentChannelInformation->channel_handle);
            Console::WriteLine("device_type:         " + currentChannelInformation->device_type);
            Console::WriteLine("controller_number:   " + currentChannelInformation->controller_number);
            Console::WriteLine("device_features:     " + currentChannelInformation->device_features);
            Console::WriteLine("device_name:         " + currentChannelInformation->device_name);
            Console::WriteLine("device_id:           " + currentChannelInformation->device_id);
            Console::WriteLine("channel_condition:   " + currentChannelInformation->channel_condition);
        }
        Console::WriteLine();
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(stsResult, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
    }
}

Visual Basic:

Dim strMsg As StringBuilder = New StringBuilder(256)
Dim stsResult As TPCANStatus

' Die Anzahl der verfügbaren Kanäle wird abgefragt
'
Dim iChannelsCount As UInt32
stsResult = PCANBasic.GetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_ATTACHED_CHANNELS_COUNT, iChannelsCount, CType(System.Runtime.InteropServices.Marshal.SizeOf(iChannelsCount), UInteger))

If stsResult <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(stsResult, 0, strMsg)
    MessageBox.Show(strMsg.ToString())
Else
    ' Ein Puffer zum Speichern der Informationen wird erstellt
    '
    Dim ciChannelInformation(iChannelsCount - 1) As TPCANChannelInformation

    ' Die Informationen über angeschlossene Kanäle werden abgerufen
    '
    stsResult = PCANBasic.GetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_ATTACHED_CHANNELS, ciChannelInformation)

    ' Die Informationen zu den angeschlossenen Kanälen werden angezeigt
    '
    If (stsResult = TPCANStatus.PCAN_ERROR_OK) Then
        Console.WriteLine("-----------------------------------------------------------------------------------------")
        Console.WriteLine("Get PCAN_ATTACHED_CHANNELS:")

        For Each currentChannelInformation As TPCANChannelInformation In ciChannelInformation
            Console.WriteLine("---------------------------")
            Console.WriteLine("channel_handle:      " + currentChannelInformation.channel_handle)
            Console.WriteLine("device_type:         " + currentChannelInformation.device_type.ToString())
            Console.WriteLine("controller_number:   " + currentChannelInformation.controller_number.ToString())
            Console.WriteLine("device_features:     " + currentChannelInformation.device_features)
            Console.WriteLine("device_name:         " + currentChannelInformation.device_name)
            Console.WriteLine("device_id:           " + currentChannelInformation.device_id.ToString())
            Console.WriteLine("channel_condition:   " + currentChannelInformation.channel_condition)
        Next
        Console.WriteLine()
    Else
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(stsResult, 0, strMsg)
        MessageBox.Show(strMsg.ToString())
    End If
End If

Pascal OO:

var
  stsResult : TPCANStatus;
  iChannelsCount: Integer;
  ciChannelInformation: array of TPCANChannelInformation;
  I: Integer;
begin
  // Die Anzahl der verfügbaren Kanäle wird abgefragt
  //
  ciChannelInformation := nil;
  stsResult := TPCANBasic.GetValue(TPCANBasic.PCAN_NONEBUS, PCAN_ATTACHED_CHANNELS_COUNT, PLongWord(@iChannelsCount), SizeOf(iChannelsCount));

  If (stsResult <> PCAN_ERROR_OK) Then
  begin
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    TPCANBasic.GetErrorText(stsResult, 0, strMsg);
    MessageBox(0, strMsg, 'Error',MB_OK);
  end
  else
  begin
    // Ein Puffer zum Speichern der Informationen wird konfiguriert
    //
    SetLength(ciChannelInformation, iChannelsCount);

    // Die Informationen über angeschlossene Kanäle werden abgerufen
    //
    stsResult := TPCANBasic.GetValue(TPCANBasic.PCAN_NONEBUS, PCAN_ATTACHED_CHANNELS, PTPCANChannelInformation(ciChannelInformation), SizeOf(TPCANChannelInformation) * iChannelsCount);

    // Die Informationen zu den angeschlossenen Kanälen werden angezeigt
    //
    if (stsResult = TPCANStatus.PCAN_ERROR_OK) then
    begin
      writeln('-----------------------------------------------------------------------------------------');
      writeln('Get PCAN_ATTACHED_CHANNELS:');

      for I := 0 To iChannelsCount - 1 do
      begin
        writeln('---------------------------');
        writeln('channel_handle:      ' + IntToStr(ciChannelInformation[I].channel_handle));
        writeln('device_type:         ' + IntToStr(ciChannelInformation[I].device_type));
        writeln('controller_number:   ' + IntToStr(int64(ciChannelInformation[I].controller_number)));
        writeln('device_features:     ' + IntToStr(ciChannelInformation[I].device_features));
        writeln('device_name:         ' + ciChannelInformation[I].device_name);
        writeln('device_id:           ' + IntToStr(int64(ciChannelInformation[I].device_id)));
        writeln('channel_condition:   ' + IntToStr(ciChannelInformation[I].channel_condition));
      end;
    end;
  end
  else
  begin
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    TPCANBasic.GetErrorText(stsResult, 0, strMsg);
    MessageBox(0, strMsg, 'Error',MB_OK);
  end;
end;
Siehe auch

SetValue

TPCANParameter

TPCANChannelInformation

Als reine Funktionsversion: CAN_GetValue


GetValue(TPCANHandle, TPCANParameter, String, UInt32)

Willkommen
GetValue(TPCANHandle, TPCANParameter, String, UInt32)

Liest Informationen von einem PCAN-Kanal in Textform.

Syntax
Pascal OO
class function GetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    StringBuffer: PChar;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
public static extern TPCANStatus GetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    StringBuilder StringBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetValue")]
static TPCANStatus GetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    StringBuilder^ StringBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_GetValue")> _
Public Shared Function GetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    ByVal StringBuffer As StringBuilder, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
StringBuffer | Der Puffer für eine Zeichenfolge.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'StringBuffer' ist zu prüfen: er sollte auf einen Null-terminierten Zeichenpuffer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
Anmerkungen

Die Methode GetValue wird benutzt um Information über die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Vorhandensein eines Hardware-Kanals) zu bekommen. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der GetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;

strMsg = new StringBuilder(256);

// Die Version des PCAN-USB Kanal-1 wird abgefragt.
//
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_CHANNEL_VERSION,strMsg, 256 );
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    // Die Version wird angezeigt.
    //
    MessageBox.Show(strMsg.ToString());

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

strMsg = gcnew StringBuilder(256);

// Die Version des PCAN-USB Kanal-1 wird abgefragt.
//
result = PCANBasic::GetValue(PCANBasic::PCAN_USBBUS1, TPCANParameter::PCAN_CHANNEL_VERSION, strMsg, 256);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    // Die Version wird angezeigt.
    //
    MessageBox::Show(strMsg->ToString());

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

strMsg = New StringBuilder(256)

' Die Version des PCAN-USB Kanal-1 wird abgefragt.
'
result = PCANBasic.GetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_CHANNEL_VERSION, strMsg, 256)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString())
Else
    ' Die Version wird angezeigt.
    '
    MessageBox.Show(strMsg.ToString())
End If

Pascal OO:

var
    result: TPCANStatus;
    strMsg: array [0..256] of Char;
begin

    // Die Version des PCAN-USB Kanal-1 wird abgefragt.
    //
    result := TPCANBasic.GetValue(TPCANBasic.PCAN_USBBUS1, PCAN_CHANNEL_VERSION, strMsg, 256);
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        // Die Version wird angezeigt.
        //
        MessageBox(0, strMsg, 'Success',MB_OK);
Siehe auch

SetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_GetValue


SetValue

Willkommen
SetValue

Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.

Überladungen
Methode | Beschreibung
SetValue(TPCANHandle, TPCANParameter, Object) | Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.
SetValue(TPCANHandle, TPCANParameter, UInt32, UInt32) | Schreibt einen Konfigurations- oder Datenwert als numerischen Wert auf einen PCAN-Kanal (32-Bit).
SetValue(TPCANHandle, TPCANParameter, UInt64, UInt32) | Schreibt einen Konfigurations- oder Datenwert als numerischen Wert auf einen PCAN-Kanal (64-Bit).
SetValue(TPCANHandle, TPCANParameter, String, UInt32) | Schreibt einen Konfigurations- oder Datenwert als Zeichenfolge auf einen PCAN-Kanal.


SetValue(TPCANHandle, TPCANParameter, Object)

Willkommen
SetValue(TPCANHandle, TPCANParameter, Object)

Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.

Syntax
Python
def SetValue(
    self,
    Channel,
    Parameter,
    Buffer)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu schreibende Information (siehe TPCANParameter).
Buffer | Der Puffer für die zu schreibende Information.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'Buffer' ist zu prüfen: er sollte auf eine dem Konfigurationstyp entsprechende Struktur zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
PCAN_ERROR_ILLOPERATION: | Ein abhängiger Prozess, der durch den Aufruf dieser Funktion mit den aktuellen Parametern erzeugt wurde, ist vorübergehend nicht zulässig. Die Konfiguration in Verbindung mit dem verwendeten TPCANParameter ist zu überprüfen.
Anmerkungen

Die Methode SetValue wird benutzt um die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Zusatztext im PCANBasic-Logfile) zu konfigurieren. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel demonstriert die Verwendung der SetValue-Methode. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Der PCAN-Kanal muss nicht initialisiert sein, um die Log Funktionalität nutzen zu können.

Python:

# Der Pfad für die Log-Datei wird gesetzt.
# Beachten Sie, dass der Standard-Kanal (PCAN_NONEBUS)
# wird verwendet, um dieser Parameter einzustellen.
#
strBuffer = "C:\Users\Admin\Desktop"
result = objPCAN.SetValue(PCAN_NONEBUS,PCAN_LOG_LOCATION,strBuffer)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    print ("Log path was successfully set")
Siehe auch

GetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_SetValue


SetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)

Willkommen
SetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)

Schreibt einen Konfigurations- oder Datenwert als numerischen Wert auf einen PCAN-Kanal.

Syntax
Pascal OO
class function SetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    NumericBuffer: PLongWord;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
public static extern TPCANStatus SetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    ref UInt32 NumericBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
static TPCANStatus SetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    UInt32 %NumericBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_SetValue")> _
Public Shared Function SetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    ByRef NumericBuffer As UInt32, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
NumericBuffer | Der Puffer für einen numerischen Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'NumericBuffer' ist zu prüfen: er sollte auf einen Puffer vom typ Integer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
PCAN_ERROR_ILLOPERATION: | Ein abhängiger Prozess, der durch den Aufruf dieser Funktion mit den aktuellen Parametern erzeugt wurde, ist vorübergehend nicht zulässig. Die Konfiguration in Verbindung mit dem verwendeten TPCANParameter ist zu überprüfen.
Anmerkungen

Die Methode SetValue wird benutzt um die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Zusatztext im PCANBasic-Logfile) zu konfigurieren. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der SetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
UInt32 iBuffer;

strMsg = new StringBuilder(256);

// Der Botschaf-Empfangsfilter wird geschlossen.
//
iBuffer = PCANBasic.PCAN_FILTER_CLOSE;
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, ref iBuffer, sizeof(UInt32));
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("The filter was successfully closed");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
UInt32 iBuffer;

strMsg = gcnew StringBuilder(256);

// Der Botschaf-Empfangsfilter wird geschlossen.
//
iBuffer = PCANBasic::PCAN_FILTER_CLOSE;
result = PCANBasic::SetValue(PCANBasic::PCAN_USBBUS1,TPCANParameter::PCAN_MESSAGE_FILTER, iBuffer, sizeof(iBuffer));
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("The filter was successfully closed");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim iBuffer As UInt32

strMsg = New StringBuilder(256)

' Der Botschaf-Empfangsfilter wird geschlossen.
'
iBuffer = PCANBasic.PCAN_FILTER_CLOSE
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, iBuffer, Convert.ToUInt32(Len(iBuffer)))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("The filter was successfully closed")
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    iBuffer: LongWord;
begin
    // Der Botschaf-Empfangsfilter wird geschlossen.
    //
    iBuffer := TPCANBasic.PCAN_FILTER_CLOSE;
    result := TPCANBasic.SetValue(TPCANBasic.PCAN_USBBUS1,PCAN_MESSAGE_FILTER, PLongWord(@iBuffer), sizeof(iBuffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0, 'The filter was successfully closed', 'Error',MB_OK);
Siehe auch

GetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_SetValue


SetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)

Willkommen
SetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)

Schreibt einen Konfigurations- oder Datenwert als numerischen Wert auf einen PCAN-Kanal.

Syntax
Pascal OO
class function SetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    NumericBuffer: PUInt64;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
public static extern TPCANStatus SetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    ref UInt36 NumericBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
static TPCANStatus SetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    UInt64 %NumericBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_SetValue")> _
Public Shared Function SetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    ByRef NumericBuffer As UInt64, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
NumericBuffer | Der Puffer für einen 64-Bit numerischen Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'NumericBuffer' ist zu prüfen: er sollte auf einen Puffer vom typ 64-Bit Integer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
PCAN_ERROR_ILLOPERATION: | Ein abhängiger Prozess, der durch den Aufruf dieser Funktion mit den aktuellen Parametern erzeugt wurde, ist vorübergehend nicht zulässig. Die Konfiguration in Verbindung mit dem verwendeten TPCANParameter ist zu überprüfen.
Anmerkungen

Die Methode SetValue wird benutzt um die PCAN-Umgebung (z. B. Akzeptanzfilter) zu konfigurieren. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der SetValue-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
UInt64 i64Buffer;

strMsg = new StringBuilder(256);

// Code und Maske werden als 64-Bit-Wert gepackt
//
i64Buffer = 0x100;  // Akzeptanz Code
i64Buffer <<= 32;
i64Buffer |= 0x003; // Akzeptanz Maske
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_ACCEPTANCE_FILTER_11BIT, ref i64Buffer, sizeof(UInt64));
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("Der 11-Bit-Akzeptanzfilter wurde erfolgreich konfiguriert");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
UInt64 i64Buffer;

strMsg = gcnew StringBuilder(256);

// Code und Maske werden als 64-Bit-Wert gepackt
//
i64Buffer = 0x100;  // Akzeptanz Code
i64Buffer <<= 32;
i64Buffer |= 0x003; // Akzeptanz Maske
result = PCANBasic::SetValue(PCANBasic::PCAN_USBBUS1, TPCANParameter::PCAN_ACCEPTANCE_FILTER_11BIT, i64Buffer, sizeof(i64Buffer));
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("Der 11-Bit-Akzeptanzfilter wurde erfolgreich konfiguriert");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim i64Buffer As UInt64

strMsg = New StringBuilder(256)

' Code und Maske werden als 64-Bit-Wert gepackt
'
i64Buffer = &H100            ' Akzeptanz Code
i64Buffer <<= 32
i64Buffer = i64Buffer Or &H3 ' Akzeptanz Maske
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_ACCEPTANCE_FILTER_11BIT, i64Buffer, CType(System.Runtime.InteropServices.Marshal.SizeOf(i64Buffer), UInteger))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    MessageBox.Show("Der 11-Bit-Akzeptanzfilter wurde erfolgreich konfiguriert")
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    i64Buffer: UInt64;
begin
    // Code und Maske werden als 64-Bit-Wert gepackt
    //
    i64Buffer := $100;             // Akzeptanz Code
    i64Buffer := i64Buffer shl 32;
    i64Buffer := i64Buffer Or $3;  // Akzeptanz Maske
    result := TPCANBasic.SetValue(TPCANBasic.PCAN_USBBUS1,PCAN_ACCEPTANCE_FILTER_11BIT, PUInt64(@i64Buffer), sizeof(i64Buffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Fehler',MB_OK);
    end
    else
        MessageBox(0, Der 11-Bit-Akzeptanzfilter wurde erfolgreich konfiguriert', 'Erfolg',MB_OK);
end;
Siehe auch

GetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_SetValue


SetValue(TPCANHandle, TPCANParameter, String, UInt32)

Willkommen
SetValue(TPCANHandle, TPCANParameter, String, UInt32)

Schreibt einen Konfigurations- oder Datenwert als Zeichenfolge auf einen PCAN-Kanal.

Syntax
Pascal OO
class function SetValue(
    Channel: TPCANHandle;
    Parameter: TPCANParameter;
    StringBuffer: PChar;
    BufferLength: LongWord
    ): TPCANStatus; overload;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
public static extern TPCANStatus SetValue(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType.U1)]
    TPCANParameter Parameter,
    [MarshalAs(UnmanagedType.LPStr,SizeParamIndex=3)]
    string StringBuffer,
    UInt32 BufferLength);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_SetValue")]
static TPCANStatus SetValue(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    [MarshalAs(UnmanagedType::U1)]
    TPCANParameter Parameter,
    [MarshalAs(UnmanagedType::LPStr,SizeParamIndex=3)]
    String^ StringBuffer,
    UInt32 BufferLength);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_SetValue")> _
Public Shared Function SetValue( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Parameter As TPCANParameter, _
    <MarshalAs(UnmanagedType.LPStr, SizeParamIndex:=3)> _
    ByVal StringBuffer As String, _
    ByVal BufferLength As UInt32) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesenden Information (siehe TPCANParameter).
StringBuffer | Der Puffer für eine Zeichenfolge.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'StringBuffer' ist zu prüfen: er sollte auf einen Null-terminierten Zeichenpuffer zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
PCAN_ERROR_ILLOPERATION: | Ein abhängiger Prozess, der durch den Aufruf dieser Funktion mit den aktuellen Parametern erzeugt wurde, ist vorübergehend nicht zulässig. Die Konfiguration in Verbindung mit dem verwendeten TPCANParameter ist zu überprüfen.
Anmerkungen

Die Methode SetValue wird benutzt um die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Zusatztext im PCANBasic-Logfile) zu konfigurieren. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der SetValue-Methode am Beispiel des PCAN_NONEBUS Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Der PCAN-Kanal muss nicht initialisiert sein, um die Log Funktionalität nutzen zu können.

C#:

TPCANStatus result;
StringBuilder strMsg;
string strBuffer;

strMsg = new StringBuilder(256);

// Der Pfad für die Log-Datei wird gesetzt.
// Beachten Sie, dass der Standard-Kanal (PCAN_NONEBUS)
// wird verwendet, um dieser Parameter einzustellen.
//
strBuffer = "C:\\Users\\Admin\\Desktop";
result = PCANBasic.SetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_LOG_LOCATION, strBuffer, (UInt32)strBuffer.Length);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
    MessageBox.Show("Log path was successfully set");

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
String^ strBuffer;

strMsg = gcnew StringBuilder(256);

// Der Pfad für die Log-Datei wird gesetzt.
// Beachten Sie, dass der Standard-Kanal (PCAN_NONEBUS)
// wird verwendet, um dieser Parameter einzustellen.
//
strBuffer = "C:\\Users\\Admin\\Desktop";
result = PCANBasic::SetValue(PCANBasic::PCAN_NONEBUS, TPCANParameter::PCAN_LOG_LOCATION, strBuffer, strBuffer->Length);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
    MessageBox::Show("Log path was successfully set");

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim strBuffer As String

strMsg = New StringBuilder(256)

' Der Pfad für die Log-Datei wird gesetzt.
' Beachten Sie, dass der Standard-Kanal (PCAN_NONEBUS)
' wird verwendet, um dieser Parameter einzustellen.
'
strBuffer = "C:\Users\Admin\Desktop"
result = PCANBasic.SetValue(PCANBasic.PCAN_NONEBUS, TPCANParameter.PCAN_LOG_LOCATION, strBuffer, Convert.ToUInt32(strBuffer.Length))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString())
Else
    MessageBox.Show("Log path was successfully set")
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    strBuffer: string;
begin
    // Der Pfad für die Log-Datei wird gesetzt.
    // Beachten Sie, dass der Standard-Kanal (PCAN_NONEBUS)
    // wird verwendet, um dieser Parameter einzustellen.
    //
    strBuffer := 'C:\\Users\Keneth\Desktop';
    result := TPCANBasic.SetValue(TPCANBasic.PCAN_NONEBUS, PCAN_LOG_LOCATION, PChar(strBuffer), Length(strBuffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        MessageBox(0, 'Log path was successfully set', 'Success',MB_OK);
Siehe auch

GetValue

TPCANParameter

Parameterwert Definitionen

Als reine Funktionsversion: CAN_SetValue


FilterMessages

Willkommen
FilterMessages

Konfiguriert den Botschafts-Empfangsfilter für einen PCAN-Kanal.

Syntax
Pascal OO
class function FilterMessages(
    Channel: TPCANHandle;
    FromID: LongWord;
    ToID: LongWord;
    Mode: TPCANMode
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_FilterMessages")]
public static extern TPCANStatus FilterMessages(
    [MarshalAs(UnmanagedType.U1)]
    TPCANHandle Channel,
    UInt32 FromID,
    UInt32 ToID,
    [MarshalAs(UnmanagedType.U1)]
    TPCANMode Mode);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_FilterMessages")]
static TPCANStatus FilterMessages(
    [MarshalAs(UnmanagedType::U1)]
    TPCANHandle Channel,
    UInt32 FromID,
    UInt32 ToID,
    [MarshalAs(UnmanagedType::U1)]
    TPCANMode Mode);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_FilterMessages")> _
Public Shared Function FilterMessages( _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Channel As TPCANHandle, _
    ByVal FromID As UInt32, _
    ByVal ToID As UInt32, _
    <MarshalAs(UnmanagedType.U1)> _
    ByVal Mode As TPCANMode) As TPCANStatus
End Function
Python
def FilterMessages(
    self,
    Channel,
    FromID,
    ToID,
    Mode)
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
FromID | Die niedrigste ID, die empfangen werden soll.
ToID | Die höchste ID, die empfangen werden soll.
Mode | Der zu setzende Filter-Art (siehe TPCANMode).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Bei der Initialisierung eines Kanals ist der Filterbereich zunächst voll geöffnet. Nach dem aktuellen Filter-Status, den Aufruf dieser Methode verhält sich wie folgt:

  • Filter-Status ist PCAN_FILTER_OPEN: Den Filter wird automatisch geschlossen und dann mit dem angegebenen Filterbereich konfiguriert.
  • Filter-Status ist PCAN_FILTER_CLOSE: Den Filter wird mit dem angegebenen Filterbereich konfiguriert.
  • Filter-Status ist PCAN_FILTER_CUSTOM: Den vorhandenen Filter wird, mit dem angegebenen Filterbereich, erweitern.

Der Parameter 'Mode' leg fest, welche Art von ID für den Filter verwendet werden soll: Standard Frames (11-bit Identifier) oder Extended Frames (29-bit Identifier). Standard Frames nutzen die Bitposition 28 .. 18 in den Acceptance Mask Registern des SJA-1000 CAN-Controllers. Der Treiber für Geräte mit 82C200 CAN-Controllern muss diese Bits auf Position 10 .. 0 schieben.

Konfigurieren des CAN-Botschaftsfilters löst einen Reset des CAN-Controllers aus. Das kann Auswirkungen auf andere Anwendungen haben, die mit derselben PCAN-Hardware arbeiten.

Hinweis:

  1. Es gibt nur einen Filter für Standard und Extended CAN-Nachrichten. Standard Nachrichten werden so registriert als würde die ID in den Bits 18 bis 28 liegen. D.h. eine Standard-ID 400h wird auch durch Angabe einer Extended-ID 10000000h empfangen. Aus diesem Grund ist es nicht empfehlenswert, Standard und Extended Filter zu mischen, da das Risiko der Empfang unerwünschter Nachrichten erhöht wird.
  2. Mehrfache Aufrufe von FilterMessage erweitern den Empfangsfilter immer weiter.
  3. Es ist nicht garantiert, dass eine Anwendung nur die CAN-Nachrichten empfängt, die im Bereich von FromID bis ToID liegen. Dies ist durch die Funktionsweise des SJA1000-Akzeptanzfilers bedingt. Siehe hierzu Philips Data Sheet "SJA1000 Stand-alone CAN-controller".

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode nicht mit angegeben werden muss. Er wird automatisch mit der Objektinstanz der Methode versorgt.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der FilterMessages-Methode am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C#:

TPCANStatus result;
StringBuilder strMsg;
UInt32 iBuffer;

strMsg = new StringBuilder(256);

// Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
//
iBuffer = PCANBasic.PCAN_FILTER_CLOSE;
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, ref iBuffer, sizeof(UInt32));

if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
{
    // Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen.
    //
    result = PCANBasic.FilterMessages(PCANBasic.PCAN_USBBUS1, 2, 5, TPCANMode.PCAN_MODE_STANDARD);
    if (result != TPCANStatus.PCAN_ERROR_OK)
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox.Show(strMsg.ToString());
    }
    else
        MessageBox.Show("Filter successfully configured for IDs 2,3,4 and 5");
}

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
UInt32 iBuffer;

strMsg = gcnew StringBuilder(256);

// Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
//
iBuffer = PCANBasic::PCAN_FILTER_CLOSE;
result = PCANBasic::SetValue(PCANBasic::PCAN_USBBUS1,TPCANParameter::PCAN_MESSAGE_FILTER, iBuffer, sizeof(iBuffer));
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
{
    // Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen.
    //
    result = PCANBasic::FilterMessages(PCANBasic::PCAN_USBBUS1, 2, 5, TPCANMode::PCAN_MODE_STANDARD);
    if (result != TPCANStatus::PCAN_ERROR_OK)
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        PCANBasic::GetErrorText(result, 0, strMsg);
        MessageBox::Show(strMsg->ToString());
    }
    else
        MessageBox::Show("Filter successfully configured for IDs 2,3,4 and 5");
}

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim iBuffer As UInt32

strMsg = New StringBuilder(256)

' Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
'
iBuffer = PCANBasic.PCAN_FILTER_CLOSE
result = PCANBasic.SetValue(PCANBasic.PCAN_USBBUS1, TPCANParameter.PCAN_MESSAGE_FILTER, iBuffer, Convert.ToUInt32(Len(iBuffer)))
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    ' Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen.
    '
    result = PCANBasic.FilterMessages(PCANBasic.PCAN_USBBUS1, 2, 5, TPCANMode.PCAN_MODE_STANDARD)
    If result <> TPCANStatus.PCAN_ERROR_OK Then
        ' Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        '
        PCANBasic.GetErrorText(result, 0, strMsg)
        MessageBox.Show(strMsg.ToString)
    Else
        MessageBox.Show("Filter successfully configured for IDs 2,3,4 and 5")
    End If
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    iBuffer: LongWord;
begin
    // Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
    //
    iBuffer := TPCANBasic.PCAN_FILTER_CLOSE;
    result := TPCANBasic.SetValue(TPCANBasic.PCAN_USBBUS1,PCAN_MESSAGE_FILTER, PLongWord(@iBuffer), sizeof(iBuffer));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        TPCANBasic.GetErrorText(result, 0, strMsg);
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
    begin
        // Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen.
        //
        result := TPCANBasic.FilterMessages(TPCANBasic.PCAN_USBBUS1,2,5,PCAN_MODE_STANDARD);
        If (result <> PCAN_ERROR_OK) Then
        begin
            // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
            //
            TPCANBasic.GetErrorText(result, 0, strMsg);
            MessageBox(0, strMsg, 'Error',MB_OK);
        end
        else
            MessageBox(0,'Filter successfully configured for IDs 2,3,4 and 5','Success', MB_OK);
    end;

Python:

# Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
#
result = objPCAN.SetValue(PCAN_USBBUS1,PCAN_MESSAGE_FILTER,PCAN_FILTER_CLOSE)
if result != PCAN_ERROR_OK:
    # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    #
    result = objPCAN.GetErrorText(result)
    print (result[1])
else:
    # Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen.
    #
    result = objPCAN.FilterMessages(PCAN_USBBUS1,2,5,PCAN_MODE_STANDARD)
    if result != PCAN_ERROR_OK:
        # Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        #
        result = objPCAN.GetErrorText(result)
        print (result[1])
    else:
        print ("Filter successfully configured for IDs 2,3,4 and 5")
Siehe auch

SetValue

Als reine Funktionsversion: CAN_FilterMessages


GetErrorText

Willkommen
GetErrorText

Liest den beschreibenden Text für einen Fehlercode.

Überladungen
Methode | Beschreibung
GetErrorText(TPCANStatus, int) | Liest den beschreibenden Text für einen Fehlercode.
GetErrorText(TPCANStatus,UInt16,String) | Liest den beschreibenden Text für einen Fehlercode.


GetErrorText(TPCANStatus,UInt16,String)

Willkommen
GetErrorText(TPCANStatus,UInt16,String)

Liest den beschreibenden Text für einen Fehlercode.

Syntax
Pascal OO
class function GetErrorText(
    AnError: TPCANStatus;
    Language: Word;
    StringBuffer: PChar
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetErrorText")]
public static extern TPCANStatus GetErrorText(
    [MarshalAs(UnmanagedType.U4)]
    TPCANStatus AnError,
    UInt16 Language,
    StringBuilder StringBuffer);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_GetErrorText")]
static TPCANStatus GetErrorText(
    [MarshalAs(UnmanagedType::U4)]
    TPCANStatus AnError,
    UInt16 Language,
    StringBuilder^ StringBuffer);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_GetErrorText")> _
Public Shared Function GetErrorText( _
    <MarshalAs(UnmanagedType.U4)> _
    ByVal AnError As TPCANStatus, _
    ByVal Language As UInt16, _
    ByVal StringBuffer As StringBuilder) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
AnError | Ein Fehlercode vom Typ TPCANStatus.
Language | Gibt die "Primary language ID" an.
StringBuffer | Null-terminierter char-Array-Puffer mit einer Länge von 256.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'StringBuffer' ist zu prüfen: er sollte auf einen Null-terminierten Zeichenpuffer zeigen, der groß genug ist, um den Fehlermeldungstext aufzunehmen.
Anmerkungen

Die "Primary language IDs" wurden von Microsoft in Windows Betriebssystemen festgelegt, um menschliche Sprachen zu identifizieren. Das PCAN-Basic API unterstützt derzeit folgende Sprachen:

Sprache | Primary Language ID
Neutral (Systemeinstellung) | 00h (0)
Englisch | 09h (9)
Deutsch | 07h (7)
Französisch | 0Ch (12)
Italienisch | 10h (16)
Spanisch | 0Ah (10)

Anmerkung: Auch wenn derzeit nur kurze Texte definiert sind, kann die Zeichenfolge bis zu 255 Zeichen, plus Terminierung, lang sein. Daher muss die Länge des Puffers mindestens 256 Zeichen betragen.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der GetErrorText-Methode. Die Sprache des zurückgelieferten Texts ist die gleiche wie die Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch), oder Englisch bei nicht unterstützten Systemsprachen.

C#:

TPCANStatus result;
StringBuilder strMsg;

strMsg = new StringBuilder(256);

// Die System-Sprache (Neutral) wird benutzt, um den Fehlercode PCAN_ERROR_INITIALIZE in Text umzuwandeln.
//
result = PCANBasic.GetErrorText(TPCANStatus.PCAN_ERROR_INITIALIZE, 0, strMsg);
if (result != TPCANStatus.PCAN_ERROR_OK)
    // Ein Fehlertext ist angezeigt.
    //
    MessageBox.Show("Error when recovering Error-Code's description");
else
    MessageBox.Show(strMsg.ToString());

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;

strMsg = gcnew StringBuilder(256);

// Die System-Sprache (Neutral) wird benutzt, um den Fehlercode PCAN_ERROR_INITIALIZE in Text umzuwandeln.
//
result = PCANBasic::GetErrorText(TPCANStatus::PCAN_ERROR_INITIALIZE, 0, strMsg);
if (result != TPCANStatus::PCAN_ERROR_OK)
    // Ein Fehlertext ist angezeigt.
    //
    MessageBox::Show("Error when recovering Error-Code's description");
else
    MessageBox::Show(strMsg->ToString());

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder

strMsg = New StringBuilder(256)

' Die System-Sprache (Neutral) wird benutzt, um den Fehlercode PCAN_ERROR_INITIALIZE in Text umzuwandeln.
'
result = PCANBasic.GetErrorText(TPCANStatus.PCAN_ERROR_INITIALIZE, 0, strMsg)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' Ein Fehlertext ist angezeigt.
    '
    MessageBox.Show("Error when recovering Error-Code's description")
Else
    MessageBox.Show(strMsg.ToString)
End If

Pascal OO:

var
 result : TPCANStatus;
 strMsg: array [0..256] of Char;
begin

    // Die System-Sprache (Neutral) wird benutzt, um den Fehlercode PCAN_ERROR_INITIALIZE in Text umzuwandeln.
    //
    result := TPCANBasic.GetErrorText(PCAN_ERROR_INITIALIZE, 0, strMsg);
    If (result <> PCAN_ERROR_OK) Then
        // Ein Fehlertext ist angezeigt.
        //
        MessageBox(0, Error when recovering Error-Code's description','Error',MB_OK)
    else
        MessageBox(0,strMsg,'Success', MB_OK);
Siehe auch

Primary Language ID

Als reine Funktionsversion: CAN_GetErrorText


GetErrorText(TPCANStatus, int)

Willkommen
GetErrorText(TPCANStatus, int)

Liest den beschreibenden Text für einen Fehlercode.

Syntax
Python
def GetErrorText(
    self,
    Error,
    Language = 0)
Parameter
Parameter | Beschreibung
Error | Ein Fehlercode vom Typ TPCANStatus.
Language | Gibt die "Primary language ID" an.
Rückgabe

Der Rückgabewert ist zweiteilig (2-tuple). Die Anordnung der Werte ist wie folgt:

[0]: Der Rückgabecode ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'Error' ist zu prüfen: er sollte ein gültiger Fehlercode sein.

[1]: Der Fehlertext zum vorgegebenen TPCANStatus Fehlercode.

Anmerkungen

Die "Primary language IDs" wurden von Microsoft in Windows Betriebssystemen festgelegt, um menschliche Sprachen zu identifizieren. Das PCAN-Basic API unterstützt derzeit folgende Sprachen:

Sprache | Primary Language ID
Neutral (Systemeinstellung) | 00h (0)
Englisch | 09h (9)
Deutsch | 07h (7)
Französisch | 0Ch (12)
Italienisch | 10h (16)
Spanisch | 0Ah (10)

Anmerkungen für Python

  • Klassenmethode: Im Gegensatz zum .NET Framework muss bei Python eine Variable mit einem Objekt vom Typ PCANBasic instanziiert werden, damit die API-Funktionalität genutzt werden kann.
  • Die "first argument"-Konvention: Bei Python gibt es den Parameter'self' , der beim Aufruf einer Methode mit deren Objektinstanz versorgt werden muss.
Beispiel

Das folgende Beispiel demonstriert die Verwendung der GetErrorText-Methode. Die Sprache des zurückgelieferten Texts ist Spanisch.

Python:

# The ID für die Spanische Sprache wird benutzt, um den Fehlercode PCAN_ERROR_INITIALIZE in Text umzuwandeln.
#
objPCAN = PCANBasic()
result = objPCAN.GetErrorText(PCAN_ERROR_INITIALIZE, 10)
if result[0] != PCAN_ERROR_OK:
    # Ein Fehlertext ist angezeigt.
    #
    print ("Error when recovering Error-Code's description")
else:
    print (result[1])
Siehe auch

Primary Language ID

Als reine Funktionsversion: CAN_GetErrorText


LookUpChannel

Willkommen
LookUpChannel

Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.

Überladungen
Function | Description
LookUpChannel(String,TPCANHandle) | Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.
LookUpChannel(String) | Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.


LookUpChannel(String,TPCANHandle)

Willkommen
LookUpChannel(String,TPCANHandle)

Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.

Syntax
Pascal OO
class function LookUpChannel(
    Parameters: PAnsiChar,
    FoundChannel: PTPCANHandle
    ): TPCANStatus;
C#
[DllImport("PCANBasic.dll", EntryPoint = "CAN_LookUpChannel")]
public static extern TPCANStatus LookUpChannel(
    String Parameters,
    out TPCANHandle FoundChannel);
C++ / CLR
[DllImport("PCANBasic.dll", EntryPoint = "CAN_LookUpChannel")]
static TPCANStatus LookUpChannel(
    String^ Parameters,
    TPCANHandle %FoundChannel);
Visual Basic
<DllImport("PCANBasic.dll", EntryPoint:="CAN_LookUpChannel")>
Public Shared Function LookUpChannel(
    ByVal Parameters As String,
    ByRef FoundChannel As TPCANHandle) As TPCANStatus
End Function
Parameter
Parameter | Beschreibung
Parameters | Eine durch Kommas getrennte Zeichenfolge für Suchparameter, dh Paare von Namen / Werten, die mit einem PCAN-Basic-Kanals abgeglichen werden sollen.
FoundChannel | Puffer für die Rückgabe des PCAN-Basic-Kanals, wenn gefunden. Es enthält den Wert PCAN_NONEBUS, wenn kein Kanal gefunden wurde.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig.
Anmerkungen

Die Zeichenfolge 'Parameters' muss Name / Wert-Paare enthalten, die durch ein '=' getrennt sind.

Jedes Name / Wert-Paar muss durch ein ',' getrennt werden.

Die aktuell unterstützten Parameter und ihre Wertebereiche werden unter LookUp Parameter Definitionen beschrieben.

Beispiel

Das folgende Beispiel zeigt die Verwendung von CAN_LookUpChannel, um das Handle eines USB-Geräts mit der ID 7 zu finden. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C#:

TPCANStatus result;
StringBuilder strMsg;
TPCANHandle channelHandle;

strMsg = new StringBuilder(256);

// Try to find a PCAN-USB device with ID 7
//
result = PCANBasic.LookUpChannel("devicetype=pcan_usb, deviceid=7", out channelHandle);
if (result != TPCANStatus.PCAN_ERROR_OK)
{
    // An error occurred, get a text describing the error and show it
    //
    PCANBasic.GetErrorText(result, 0, strMsg);
    MessageBox.Show(strMsg.ToString());
}
else
{
    if(channelHandle != PCANBasic.PCAN_NONEBUS)
        MessageBox.Show("The channel handle for the PCAN-USB with ID=7 was found");
    else
        MessageBox.Show("A PCAN-USB device with ID=7 is not available");
}

C++/CLR:

TPCANStatus result;
StringBuilder^ strMsg;
TPCANHandle channelHandle;

strMsg = gcnew StringBuilder(256);

// Try to find a PCAN-USB device with ID 7
//
result = PCANBasic::LookUpChannel("devicetype=pcan_usb, deviceid=7", channelHandle);
if (result != TPCANStatus::PCAN_ERROR_OK)
{
    // An error occurred, get a text describing the error and show it
    //
    PCANBasic::GetErrorText(result, 0, strMsg);
    MessageBox::Show(strMsg->ToString());
}
else
{
    if (channelHandle != PCANBasic::PCAN_NONEBUS)
        MessageBox::Show("The channel handle for the PCAN-USB with ID=7 was found");
    else
        MessageBox::Show("A PCAN-USB device with ID=7 is not available");
}

Visual Basic:

Dim result As TPCANStatus
Dim strMsg As StringBuilder
Dim channelHandle As TPCANHandle

strMsg = New StringBuilder(256)

' Try to find a PCAN-USB device with ID 7
'
result = PCANBasic.LookUpChannel("devicetype=pcan_usb, deviceid=7", channelHandle)
If result <> TPCANStatus.PCAN_ERROR_OK Then
    ' An error occurred, get a text describing the error And show it
    '
    PCANBasic.GetErrorText(result, 0, strMsg)
    MessageBox.Show(strMsg.ToString)
Else
    If channelHandle <> PCANBasic.PCAN_NONEBUS Then
        MessageBox.Show("The channel handle for the PCAN-USB with ID=7 was found")
    Else
        MessageBox.Show("A PCAN-USB device with ID=7 is not available")
    End If
End If

Pascal OO:

var
    result : TPCANStatus;
    strMsg: array [0..256] of Char;
    channelHandle: TPCANHandle;
begin

    // Try to find a PCAN-USB device with ID 7
    //
    result := TPCANBasic.LookUpChannel('devicetype=pcan_usb, deviceid=7', PTPCANHAndle(@channelHandle));
    If (result <> PCAN_ERROR_OK) Then
    begin
        // An error occurred, get a text describing the error and show it
        //
        TPCANBasic.GetErrorText(result, 0, PAnsiChar(@strMsg));
        MessageBox(0, strMsg, 'Error',MB_OK);
    end
    else
        If (channelHandle <> TPCANBasic.PCAN_NONEBUS) Then
            MessageBox(0,'The channel handle for the PCAN-USB with ID=7 was found','Success', MB_OK)
        else
            MessageBox(0,'A PCAN-USB device with ID=7 is not available','Success', MB_OK)

  Siehe auch

LookUp Parameter Definitionen

Als reine Funktionsversion: CAN_LookUpChannel


LookUpChannel(String)

Willkommen
LookUpChannel(String)

Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.

Syntax
Python
def LookUpChannel(
        self,
        Parameter)
Parameter
Parameter | Beschreibung
Parameters | Eine durch Kommas getrennte Zeichenfolge für Suchparameter, dh Paare von Namen / Werten, die mit einem PCAN-Basic-Kanals abgeglichen werden sollen.
Rückgabe

Der Rückgabewert ist zweiteilig (2-tuple). Die Anordnung der Werte ist wie folgt:

[0]: Der Rückgabecode ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig.

[1]: Der PCAN-Basic-Kanal, falls gefunden, oder PCAN_NONEBUS, falls nicht.

Anmerkungen

Die Zeichenfolge 'Parameters' muss Name / Wert-Paare enthalten, die durch ein '=' getrennt sind.

Jedes Name / Wert-Paar muss durch ein ',' getrennt werden.

Die aktuell unterstützten Parameter und ihre Wertebereiche werden unter LookUp Parameter Definitionen beschrieben.

Beispiel

Das folgende Beispiel zeigt die Verwendung von CAN_LookUpChannel, um das Handle eines USB-Geräts mit der ID 7 zu finden. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Python:

# Try to find a PCAN-USB device with ID 7
#
result = objPCAN.LookUpChannel(b"devicetype=pcan_usb, deviceid=7")
if result[0] != PCAN_ERROR_OK:
    # An error occurred, get a text describing the error and show it
    #
    result = objPCAN.GetErrorText(result[0])
    print (result[1])
else:
    if result[1].value != PCAN_NONEBUS.value:
        print ("The channel handle for the PCAN-USB with ID=7 was found")
    else:
        print ("A PCAN-USB device with ID=7 is not available")
Siehe auch

LookUp Parameter Definitionen

Als reine Funktionsversion: CAN_LookUpChannel


Funktionen

Willkommen
Funktionen

Die definierten Funktionen der PCAN- Basic API 4 Gruppen unterteilen:

Verbindung
Name | Beschreibung
CAN_Initialize | Initialisiert einen PCAN Kanal.
CAN_InitializeFD | Initialisiert einen FD fähigen PCAN-Kanal.
CAN_Uninitialize | Gibt einen PCAN Kanal frei.
Konfiguration
Name | Beschreibung
CAN_SetValue | Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.
CAN_FilterMessages | Konfiguriert den Botschafts-Empfangsfilter eines PCAN-Kanals.
Information
Name | Beschreibung
CAN_GetValue | Liest eine Konfigurations- oder Dateninformation von einem PCAN-Kanal.
CAN_GetStatus | Liest den momentanen Bus-Zustand eines PCAN-Kanals.
CAN_GetErrorText | Liest den beschreibenden Text für einen Fehlercode.
CAN_LookUpChannel | Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.
Kommunikation
Name | Beschreibung
CAN_Read | Liest eine CAN-Botschaft aus dem Empfanspuffer (Software) eines PCAN-Kanals.
CAN_ReadFD | Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines FD fähige PCAN-Kanals.
CAN_Write | Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines PCAN-Kanals.
CAN_WriteFD | Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines FD fähige PCAN-Kanals.
CAN_Reset | Setzt Sende- und Empfangspuffer eines PCAN-Kanals zurück.


CAN_Initialize

Willkommen
CAN_Initialize

Initialisiert einen PCAN Kanal.

Syntax
C++
#ifdef __cplusplus
#define _DEF_ARG =0  // Verwendung von Standardargumente
#else
#define _DEF_ARG
#endif

TPCANStatus __stdcall CAN_Initialize(
        TPCANHandle Channel,
        TPCANBaudrate Btr0Btr1,
        TPCANType HwType _DEF_ARG,
        DWORD IOPort _DEF_ARG,
        WORD Interrupt _DEF_ARG
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Btr0Btr1 | Die Übertragungsgeschwindigkeit (siehe TPCANBaudrate).
HwType | (Nur bei Non-Plug-And-Play) Hardware-Typ und Betriebsart (siehe TPCANMode).
IOPort | (Nur bei Non-Plug-And-Play) Die E/A Adresse für den Parallelport.
Interrupt | (Nur bei Non-Plug-And-Play) Interruptnummer des Parallelports.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall wird PCAN_ERROR_OK zurückgegeben. Im Fehlerfall können folgende Werte zurückgegeben werden:

PCAN_ERROR_CAUTION:
Der Kanal wurde initialisiert, aber mit einer anderen Bitrate als die angegebene.
PCAN_ERROR_ILLHANDLE:
Der gewählte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_ILLHW:
Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLOPERATION:
Eine Aktion kann nicht ausgeführt werden, aufgrund der Zustand der Hardware. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal ist ein LAN-Kanal, der eine andere Bitrate verwendet als die angegebene.

PCAN_ERROR_ILLMODE:
Die Hardware arbeitet in einem anderen oder inkompatiblen Modus als angefordert. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal wird im CAN-FD-Modus betrieben.

PCAN_ERROR_REGTEST:
(Non-Plug-And-Play Only) Ein Problem mit der Hardware-Erkennung: meist wegen nicht bzw. falsch versorgter Werte in den Parametern 'HwType', 'IOPort' und 'Interrupt'.
PCAN_ERROR_INITIALIZE:
Der gewählte PCAN-Kanal ist bereits initialisiert und in Benutzung (PCAN-Basic / PCAN-Light Umgebung).
PCAN_ERROR_NETINUSE:
Der gewählte PCAN-Kanal ist bereits, mit ein anderen Bitrate, in Benutzung (PCAN-View).
PCAN_ERROR_HWINUSE:
Der gewählte PCAN-Kanal ist bereits in Benutzung (CanApi2 Verbindung).
PCAN_ERROR_NODRIVER:
Der Treiber zum Verbinden mit dem gewählte PCAN-Kanal ist nicht geladen.
Anmerkungen

Die Funktion CAN_Initialize bereitet einen PCAN-Kanal für die Kommunikation mit dem angeschlossenen CAN Bus vor. Alle Funktionen, die per handle auf einen nicht initialisierten Kanal (außer PCAN_NONEBUS) zugreifen, liefern einen Fehlercode zurück. Wird ein initialisierter Kanal nicht mehr benötigt, sollte er mit CAN_Uninitialize freigegeben werden.

Initialisieren bewirkt:

  • Reservierung eines Kanals für die aufrufende Applikation/den aufrufenden Prozess.
  • Bereitstellen von Ressourcen für den Kanal (z. B. Empfangs- und Sendepuffer).
  • Zuordnen einer Hardware zum Kanal-handle.
  • Überprüfung/Anpassung der Bus-Geschwindigkeit, wenn der Kanal bereits verwendet wird. (Nur wenn der Kanal vorher mit "Bitrate-Adapting"vor-konfiguriert wurde; siehe Bitrate-Adapting Parameter).
  • Versetzen eines Kanal in "Listen-Only" Modus. (Nur wenn der Kanal vorher vor-initialisiert wurde; siehe Listen-Only Parameter).
  • Öffnen des CAN-Botschaftsfilters.
  • Grundversorgung der Parameter mit Standardeinstellungen (siehe CAN_GetValue).
  • Einstellen des Empfang-Status eines Kanal. (Vor-initialisierten Wert; siehe Receive Status Parameter).

Im Unterschied zur PCAN-Light-API liefert der Initialisierungsprozess einen Fehlercode zurück, wenn die Anwendung einen PCAN-Kanal initialisieren mochte, der von ihr bereits initialisiert wurde.

Das PCAN-Basic API benutzt die gleiche Funktion zum Initialisieren sowohl von Plug-And-Play als auch von Non-Plug-And-Play Hardware. Zur Unterscheidung hat die CAN_Initialize Funktion drei Zusatz-Parameter, die nur zur Anbindung von Non-Plug-And-Play Hardware dienen. Bei Plug-And-Play Geräten müssen dagegen nur zwei Parameter versorgt werden, die restlichen drei werden nicht ausgewertet.

Bitte beachten Sie, dass die Initialisierung eines Kanals ein Reset des CAN-Hardware bewirkt, wenn Fehler auf den Bus vorliegen. Auf diese Weise Fehler wie BUSOFF, BUSHEAVY und BUSLIGHT, werden verschwinden.

PCAN-LAN Kanäle

Ein PCAN-LAN-Kanal erlaubt keine Änderung der Bitrate mittels PCAN-Basic. Um ein PCAN-LAN-Kanal zu verbinden ist es erforderlich, die Bitrate des PCAN-Gateway Geräts zu kennen, das durch diesen Kanal dargestellt wird. Wenn die Bitrate nicht bekannt ist, soll der Parameter Bitrate-Adapting verwendet werden.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_Initialize- und CAN_Uninitialize-Funktionen für einen Plug-And-Play Kanal (PCAN_PCIBUS2) und einen Non-Plug-And-Play-Kanal (PCAN_DNGBUS1). Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C++:

TPCANStatus result;
char strMsg[256];

// Der Plug & Play Kanal(PCAN-PCI) wird initialisiert.
//
result = CAN_Initialize(PCAN_PCIBUS2,PCAN_BAUD_500K);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-PCI (Ch-2) was initialized");

// Der nicht Plug & Play Kanal (PCAN-Dongle) wird initialisiert.
//
result = CAN_Initialize(PCAN_DNGBUS1, PCAN_BAUD_500K, PCAN_TYPE_DNG, 0x378, 7);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-Dongle (Ch-1) was initialized");

....

// Alle initialisierte Kanäle werden freigegeben.
//
CAN_Uninitialize(PCAN_NONEBUS);
Siehe auch

CAN_Uninitialize

CAN_GetValue

PCAN-Basic einsetzen

Klassenmethode: Initialize


CAN_InitializeFD

Willkommen
CAN_InitializeFD

Initialisiert einen FD fähigen PCAN-Kanal.

Syntax
C++
TPCANStatus __stdcall CAN_InitializeFD(
    TPCANHandle Channel,
    TPCANBitrateFD BitrateFD);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
BitrateFD | Die Übertragungsgeschwindigkeit (siehe FD Bitrate String).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall wird PCAN_ERROR_OK zurückgegeben. Im Fehlerfall können folgende Werte zurückgegeben werden:

PCAN_ERROR_CAUTION:
Der Kanal wurde initialisiert, aber mit einer anderen Bitrate als die angegebene.
PCAN_ERROR_ILLHANDLE:
Der gewählte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_ILLHW:
Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLOPERATION:
Eine Aktion kann nicht ausgeführt werden, aufgrund der Zustand der Hardware. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal ist nicht FD fähig und kann mit dieser Funktion nicht initialisiert werden.
  • Der gewählte PCAN-Kanal ist ein LAN-Kanal, der eine andere Bitrate verwendet als die angegebene.

PCAN_ERROR_ILLMODE:
Die Hardware arbeitet in einem anderen oder inkompatiblen Modus als angefordert. Mögliche Ursachen sind:

  • Der gewählte PCAN-Kanal wird im CAN 2.0 A / B-Modus betrieben.

PCAN_ERROR_INITIALIZE:
Der gewählte PCAN-Kanal ist bereits initialisiert und in Benutzung (PCAN-Basic / PCAN-Light Umgebung).
PCAN_ERROR_NETINUSE:
Der gewählte PCAN-Kanal ist bereits, mit ein anderen Bitrate, in Benutzung (PCAN-View).
PCAN_ERROR_HWINUSE:
Der gewählte PCAN-Kanal ist bereits in Benutzung (CanApi Verbindung).
PCAN_ERROR_NODRIVER:
Der Treiber zum Verbinden mit dem gewählte PCAN-Kanal ist nicht geladen.
Anmerkungen

Hinweis zur Korrespondenz der Funktionen:

Ein Kanal, der mit CAN_InitializeFD initialisiert wird, muss CAN_ReadFD und CAN_WriteFD für Datenübertragung verwenden. Aufrufe zu CAN_Read und/oder CAN_Write führen zu einer PCAN_ERROR_ILLOPERATION Fehler.

Die Funktion CAN_InitializeFD bereitet einen FD fähigen PCAN-Kanal für die Kommunikation mit dem angeschlossenen CAN Bus vor. Alle Funktionen, die per handle auf einen nicht initialisierten Kanal (außer PCAN_NONEBUS) zugreifen, liefern einen Fehlercode zurück. Wird ein initialisierter Kanal nicht mehr benötigt, sollte er mit Uninitialize freigegeben werden.

Initialisieren bewirkt:

  • Reservierung eines Kanals für die aufrufende Applikation/den aufrufenden Prozess.
  • Bereitstellen von Ressourcen für den Kanal (z. B. Empfangs- und Sendepuffer).
  • Zuordnen einer Hardware zum Kanal-handle.
  • Überprüfung/Anpassung der Bus-Geschwindigkeit, wenn der Kanal bereits verwendet wird. (Nur wenn der Kanal vorher mit "Bitrate-Adapting"vor-konfiguriert wurde; siehe Bitrate-Adapting Parameter).
  • Versetzen eines Kanal in "Listen-Only" Modus. (Nur wenn der Kanal vorher vor-initialisiert wurde; siehe Listen-Only Parameter).
  • Öffnen des CAN-Botschaftsfilters.
  • Grundversorgung der Parameter mit Standardeinstellungen.
  • Einstellen des Empfang-Status eines Kanal. (Vor-initialisierten Wert; siehe Receive Status Parameter).

Der Initialisierungsprozess liefert einen Fehlercode zurück, wenn die Anwendung einen PCAN-Kanal initialisieren mochte, der von ihr bereits initialisiert wurde.

Bitte beachten Sie, dass die Initialisierung eines Kanals ein Reset des CAN-Hardware bewirkt, wenn Fehler auf den Bus vorliegen. Auf diese Weise Fehler wie BUSOFF, BUSWARNING und BUSPASSIVE, werden verschwinden.

PCAN-LAN Kanäle

Ein PCAN-LAN-Kanal erlaubt keine Änderung der Bitrate mittels PCAN-Basic. Um ein PCAN-LAN-Kanal zu verbinden ist es erforderlich, die Bitrate des PCAN-Gateway Geräts zu kennen, das durch diesen Kanal dargestellt wird. Wenn die Bitrate nicht bekannt ist, soll der Parameter Bitrate-Adapting verwendet werden.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der CANInitializeFD- und CAN_Uninitialize-Funktionen für ein Plug-And-Play-Gerät am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C++:

TPCANStatus result;
char strMsg[256];
TPCANBitrateFD bitrate;

// Definiert ein FD-Bitrate String mit Nominal und Daten Bitrate festgelegt auf 1 MB.
//
bitrate = "f_clock_mhz=24, nom_brp=1, nom_tseg1=17, nom_tseg2=6, nom_sjw=1, data_brp=1, data_tseg1=16, data_tseg2=7, data_sjw=1";

// Der FD-fähigen Kanal (PCAN-USB Pro FD) wird initiiert.
//
result = CAN_InitializeFD(PCAN_USBBUS1,bitrate);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-USB Pro FD (Ch-1) was initialized");
Siehe auch

CAN_Uninitialize

CAN_ReadFD

CAN_WriteFD

Klassenmethode: InitializeFD


CAN_Uninitialize

Willkommen
CAN_Uninitialize

Gibt einen PCAN Kanal frei.

Syntax
C++
TPCANStatus __stdcall CAN_Uninitialize(
        TPCANHandle Channel
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus code. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Zur Freigabe eines Kanals gibt es folgende Möglichkeiten:

Single-Release: Wird mit einem PCAN-Kanal-handle aufgerufen, wobei der Kanal vorher mit der Funktion CAN_Initialize initialisiert worden sein muss. Wenn der Kanal nicht gelistet ist, wird eine Fehlermeldung zurückgegeben.

Multiple-Release: Wenn man als handle den Wert PCAN_NONEBUS versorgt, wird damit das API angewiesen, alle von der aufrufenden Anwendung initialisierten Kanäle zu ermitteln und freizugeben. Hierbei kann kein Fehlercode zurückgegeben werden, da nur gelistete Kanäle freigegeben werden.

Hinweis bezüglich der Sende-Queue während der Beendigung: Wenn eine PCAN-Basic Channel-Verbindung beendet wird, wird die Sende-Queue der zugrunde liegenden Hardware nicht sofort verworfen. PCAN-Basic wird vor der endgültigen Finalisierung noch einige Zeit warten, sodass die Hardware Zeit zum Senden dieser Nachrichten hat. Wenn die Zeit abgelaufen ist (etwa 500 Millisekunden), wird der Rest der Nachrichten in der Warteschlange (sofern vorhanden) verworfen.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_Initialize und CAN_Uninitialize (Single-Release)-Funktionen am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Ein Beispiel zur Verwendung von Multiple-Release ist bei der CAN_Initialize Methode zu sehen.

C++:

TPCANStatus result;
char strMsg[256];

// Der PCI Kanal wird initialisiert.
//
result = CAN_Initialize(PCAN_PCIBUS1,PCAN_BAUD_500K);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-PCI (Ch-1) was initialized");

....

// Die PCI Kanal wird freigegeben.
//
result = CAN_Uninitialize(PCAN_PCIBUS1);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-PCI (Ch-1) was released");
Siehe auch

CAN_Initialize

Klassenmethode: Uninitialize


CAN_Reset

Willkommen
CAN_Reset

Setzt Sende- und Empfangspuffer eines PCAN-Kanals zurück.

Syntax
C++
TPCANStatus __stdcall CAN_Reset(
        TPCANHandle Channel
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Der Aufruf dieser Funktion löscht lediglich die Puffer (Software) eines Kanals. Der CAN-Controller wird nicht zurückgesetzt.

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset, aber nur, wenn keine weiteren Clients an diesen Kanal angeschlossen sind.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_Reset-Funktion am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C++:

TPCANStatus result;
char strMsg[256];

// Der PCI Kanal wird zurückgesetzt.
//
result = CAN_Reset(PCAN_PCIBUS1);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("PCAN-PCI (Ch-1) was reset");
Siehe auch

CAN_Read

CAN_Write

CAN_SetValue

Klassenmethode: Reset


CAN_GetStatus

Willkommen
CAN_GetStatus

Liest den momentanen Bus-Zustand eines PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_GetStatus(
        TPCANHandle Channel
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Es können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand.
PCAN_ERROR_OK: | Der Zustand des gewählten PCAN-Kanals ist OK.
Anmerkungen

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. die PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_GetStatus-Funktion am Beispiel des PCAN_PCIBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C++:

TPCANStatus result;
char strMsg[256];

// Überprüfung des Status des PCI Kanals
//
result = CAN_GetStatus(PCAN_PCIBUS1);
switch(result)
{
    case PCAN_ERROR_BUSLIGHT:
        MessageBox("PCAN-PCI (Ch-1): Handling a BUS-LIGHT status...");
        break;
    case PCAN_ERROR_BUSHEAVY:
        MessageBox("PCAN-PCI (Ch-1): Handling a BUS-HEAVY status...");
        break;
    case PCAN_ERROR_BUSOFF:
        MessageBox("PCAN-PCI (Ch-1): Handling a BUS-OFF status...");
        break;
    case PCAN_ERROR_OK:
        MessageBox("PCAN-PCI (Ch-1): Status is OK");
        break;
    default:
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        CAN_GetErrorText(result, 0, strMsg);
        MessageBox(strMsg);
        break;
}
Siehe auch

Parameterwert Definitionen

TPCANParameter

Klassenmethode: GetStatus


CAN_Read

Willkommen
CAN_Read

Liest eine CAN-Botschaft aus dem Empfanspuffer (Software) eines PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_Read(
        TPCANHandle Channel,
        TPCANMsg* MessageBuffer,
        TPCANTimestamp* TimestampBuffer
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsg zur Speicherung der CAN-Botschaft.
TimestampBuffer | Ein Puffer vom Typ TPCANTimestamp zur Speicherung der Empfangszeit.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsg zeigen. Der Wert für 'TimestampBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANTimestamp zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSLIGHT: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-light Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSHEAVY: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-heavy Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Wird beim Parameter 'TimestampBuffer' ein Wert von NULL angegeben, wird die CAN-Botschaft ohne Zeitstempel gelesen.

Der Fehlercode PCAN_ERROR_ILLPARAMVAL wird zurückgegeben, wenn der Botschaftspuffer falsch deklariert ist oder der Zeitstempel-Puffer einen Wert ungleich NULL enthält. Dabei wird ein interner Fehler provoziert. z. B. bezüglich Speicherzugriff.

Die Funktion CAN_Read liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft CAN_Read aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information.

Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der CAN_Read-Funktion (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die CAN_Read-Funktion (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset, aber nur, wenn keine weiteren Clients an diesen Kanal angeschlossen sind.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von CAN_Read ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_BUSLIGHT | 0004h | Busfehler: Fehlerzähler erreichte 'Light'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSHEAVY | 0008h | Busfehler: Fehlerzähler erreichte 'Heavy'-Limit.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_Read-Funktion am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist, und dass der folgende Code eine OnTimer event-handler Funktion ist.

C++:

TPCANMsg msg;
TPCANTimestamp timestamp;
TPCANStatus result;
char strMsg[256];

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten
    //
    result = CAN_Read(PCAN_USBBUS1,&msg,&timestamp);
    if(result != PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht
        //
        MessageBox("A message was received");
        ProcessMessage(msg)
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        CAN_GetErrorText(result, 0, strMsg);
        MessageBox(strMsg);
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & PCAN_ERROR_QRCVEMPTY) != PCAN_ERROR_QRCVEMPTY);
Siehe auch

CAN_Write

Verwenden von Events

Error Frames

Klassenmethode: Read


CAN_ReadFD

Willkommen
CAN_ReadFD

Liest eine CAN-Botschaft aus dem Empfangspuffer (Software) eines PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_ReadFD(
    TPCANHandle Channel,
    TPCANMsgFD* MessageBuffer,
    TPCANTimestampFD *TimestampBuffer);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsgFD zur Speicherung der CAN-Botschaft.
TimestampBuffer | Ein Puffer vom Typ TPCANTimestampFD zur Speicherung der Empfangszeit.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für MessageBuffer ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsgFD zeigen.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Funktion CAN_InitializeFD (Klassenmethode: InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSWARNING: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-warning Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSPASSIVE: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im passiven Fehlerzustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand. Anmerkung: In diesem Fall sind MessageBuffer und TimestampBuffer gültig.
PCAN_ERROR_QRCVEMPTY: | Der Empfangspuffer des PCAN-Kanals ist leer.
PCAN_ERROR_ILLDATA: | Die gelesene Nachricht ist aufgrund der aktuellen Einstellungen nicht zulässig und wurde verworfen.
Anmerkungen

Die Verwendung von CAN_Read - und CAN_ReadFD schließen sich gegenseitig aus. Der an diese Funktion übergebene PCAN-Kanal, must mit der Funktion CAN_InitializeFD (Klassenmethode: InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Die Funktion CAN_ReadFD liefert empfangene Nachrichten oder auch Statusnachrichten aus der Empfangs-Queue. Es ist wichtig, dass man grundsätzlich so oft CAN_ReadFD aufruft, bis die Queue komplett leer gelesen ist. Ist die Queue leer, wird die Statusmeldung PCAN_ERROR_QRCVEMPTY zurückgegeben. Der Fehlercode PCAN_ERROR_QRCVEMPTY wird auch zurückgegeben, wenn den Empfang von Botschaften deaktiviert ist. Siehe Receive Status Parameter für mehr Information.

Die Empfang-Queue kann bis zu 32767 Nachrichten enthalten.

Es gibt zwei Verfahren zum Lesen einer CAN-Botschaft aus dem Empfangspuffer eines Kanals:

Time-Triggered Reading: Periodisches Auslesen mit der CAN_ReadFD-Funktion (Polling). Üblicherweise wird ein 50- oder 100-Millisekunden-Timer gestartet, der bei jedem Ablauf die CAN_ReadFD-Funktion (in einer Schleife) aufruft. Diese Schleife wird erst bei einem Rückgabewert von PCAN_ERROR_QRCVEMTY oder einem Fehlercode verlassen.

Event-Triggered Reading: Reagiert auf eine Benachrichtigung des PCAN-Treibers, sodass die Anwendung die Botschaft in ihren eigenen Puffer holen kann. Siehe Verwenden von Events für weitere Informationen zu diesem Thema.

Über Statusmeldungen:

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Der Botschaftstyp (siehe Feld TPCANMessageType) einer CAN-Botschaft gibt an, ob es sich um eine 11-Bit, 29-Bit, FD, RTR, Error- oder Statusbotschaft handelt, und sollte nach dem erfolgreichen Lesen einer CAN-Botschaft immer abgefragt werden.

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_ERRFRAME gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern ein Error-Frame (Siehe Error Frames).

Ist im Feld TPCANMsg.MSGTYPE das Bit PCAN_MESSAGE_STATUS gesetzt, ist die gelesene CAN-Botschaft keine Daten-Botschaft, sondern eine Statusmeldung. CAN-ID und Längencode einer solchen Statusmeldung dürfen nicht ausgewertet werden (sie enthalten undefinierte Werte). Die eigentliche Information über den Fehler lassen sich aus den ersten 4 Datenbytes der Nachricht herauslesen, wobei sich das MSB in Datenbyte 0 befindet, und das LSB in Datenbyte 3.

Bitte bemerken, wird eine Statusmeldung ausgelesen, ist der Rückgabewert von CAN_ReadFD ebenfalls der Fehlercode.

Beispiele:

Data0 | Data1 | Data2 | Data3 | Fehler | Fehlercode | Beschreibung
00h | 00h | 00h | 00h | PCAN_ERROR_OK | 0000h | CAN-Controller wurde erfolgreich aktiviert.
00h | 00h | 00h | 02h | PCAN_ERROR_OVERRUN | 0002h | CAN-Controller wurde zu spät gelesen.
00h | 00h | 00h | 04h | PCAN_ERROR_WARNING | 0008h | Busfehler: Fehlerzähler erreichte 'Warning'-Limit.
00h | 00h | 00h | 08h | PCAN_ERROR_BUSPASSIVE | 40000h | Busfehler: Der CAN-Controller ist im passiven Fehlerzustand.
00h | 00h | 00h | 10h | PCAN_ERROR_BUSOFF | 0010h | Busfehler: CAN_Controller ging 'Bus-Off'.
Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der CAN_ReadFD-Funktion am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels CAN_InitializeFD initialisiert ist, und dass der folgende Code eine OnTimer-event handler Funktion ist.

C++:

TPCANMsgFD msg;
TPCANTimestampFD timestamp;
TPCANStatus result;
char strMsg[256];

do
{
    // Prüfen den Empfangspuffer nach neue Nachrichten
    //
    result = CAN_ReadFD(PCAN_USBBUS1,&msg,&timestamp);
    if(result != PCAN_ERROR_QRCVEMPTY)
    {
        // Verarbeitung der ankommenden Nachricht
        //
        MessageBox("A message was received");
        ProcessMessage(msg)
    }
    else
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        CAN_GetErrorText(result, 0, strMsg);
        MessageBox(strMsg);
        // Den Fehler wird behandelt. Hier wird entschieden ob die Schleife beendet werden muss
        // (z.B. der Hardware befindet sich im bus-off Zustand).
        //
        HandleReadError(result);
    }
// Es wird versucht Nachrichten aus dem Empfangspuffer auszulesen,
// bis der Empfangspuffer leer ist.
//
}while((result & PCAN_ERROR_QRCVEMPTY) != PCAN_ERROR_QRCVEMPTY);
Siehe auch

CAN_InitializeFD

CAN_WriteFD

Verwenden von Events

Error Frames

Klassenmethode: ReadFD


CAN_Write

Willkommen
CAN_Write

Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_Write(
        TPCANHandle Channel,
        TPCANMsg* MessageBuffer
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsg zur Hinterlegung der Sendebotschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'MessageBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsg zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand.
PCAN_ERROR_QXMTFULL: | Der Sendepuffer des PCAN-Kanals ist voll.
Anmerkungen

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset, aber nur, wenn keine weiteren Clients an diesen Kanal angeschlossen sind.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_Write-Funktion am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C++:

TPCANMsg msg;
TPCANStatus result;
char strMsg[256];

// Konfigurieren einer CAN Nachricht
//
msg.ID = 0x100;
msg.MSGTYPE = PCAN_MESSAGE_STANDARD;
msg.LEN = 3;
msg.DATA[0] = 1;
msg.DATA[1] = 2;
msg.DATA[2] = 3;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = CAN_Write(PCAN_USBBUS1, msg);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("Message sent successfully");
Siehe auch

CAN_Read

CAN_SetValue

Klassenmethode: Write


CAN_WriteFD

Willkommen
CAN_WriteFD

Schreibt eine CAN-Botschaft in den Sendepuffer (Software) eines FD fähige PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_WriteFD(
    TPCANHandle Channel,
    TPCANMsgFD* MessageBuffer);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen FD fähige PCAN Kanal (siehe TPCANHandle).
MessageBuffer | Ein Puffer vom Typ TPCANMsgFD zur Hinterlegung der Sendebotschaft.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'MessageBuffer' ist zu prüfen: er sollte auf eine Struktur vom Typ TPCANMsgFD zeigen.
PCAN_ERROR_ILLOPERATION: | Der gewünschte PCAN Kanal wurde nicht mit der Funktion CAN_InitializeFD (Klassenmethode: InitializeFD) initiiert.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
PCAN_ERROR_BUSOFF: | Ein Bus-Fehler ist für den gewählten PCAN-Kanal aufgetreten. Die Hardware befindet sich im bus-off Zustand.
PCAN_ERROR_QXMTFULL: | Der Sendepuffer des PCAN-Kanals ist voll.
Anmerkungen

Die Verwendung von CAN_Write - und CAN_WriteFD schließen sich gegenseitig aus. Der an diese Funktion übergebene PCAN-Kanal, must mit der Funktion CAN_InitializeFD (Klassenmethode: InitializeFD) initiiert worden sein. Andernfalls wird der Fehler PCAN_ERROR_ILLOPERATION zurückgegeben.

Üblicherweise wird ein Reset des CAN-Controllers notwendig, wenn eine Bus-Off-Situation auftritt. Dabei kann die Anwendung solange nicht mehr über den Kanal kommunizieren, bis der CAN-Controller zurückgesetzt wurde. Es sollte ggf. der PCAN-Basic Eigenschaft PCAN_BUSOFF_AUTORESET eingesetzt werden, der bei Bus-Off das API zum automatischen Reset des CAN-Controllers veranlasst.

Ein anderer Weg, Fehler zurückzusetzen, besteht durch das Deinitialisieren und wieder Initialisieren des benutzten Kanals. Dies bewirkt einen Hardware-Reset.

Beispiel

Das folgende Beispiel (für verschiedene Programmiersprachen) demonstriert die Verwendung der CAN_WriteFD-Funktion am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits mittels CAN_InitializeFD initialisiert ist.

C++:

TPCANMsgFD msg;
TPCANStatus result;
char strMsg[256];

// Konfigurieren einer CAN Nachricht.
//
msg.ID = 0x100;
msg.MSGTYPE = PCAN_MESSAGE_STANDARD | PCAN_MESSAGE_FD;

// DLC 9 bedeutet 12 Daten-Bytes
//
msg.DLC = 9;
for(int i=0; i < 12; i++)
    msg.DATA[i] = i;

// Die Nachricht wird über den PCAN-USB Kanal-1 gesendet.
//
result = CAN_WriteFD(PCAN_USBBUS1, &msg);
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("Message sent successfully");
Siehe auch

CAN_InitializeFD

CAN_ReadFD

Klassenmethode: WriteFD


CAN_GetValue

Willkommen
CAN_GetValue

Liest eine Konfigurations- oder Dateninformation von einem PCAN-Kanal.

Syntax
C++
TPCANStatus __stdcall CAN_GetValue(
        TPCANHandle Channel,
        TPCANParameter Parameter,
        void* Buffer,
        WORD BufferLength
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesende Information (siehe TPCANParameter).
Buffer | Der Puffer für einen zu lesenden Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Funktion ist (sind) ungültig. Der Wert für 'Buffer' ist zu prüfen: er sollte auf eine gültige Struktur entsprechend dem Datentyp zeigen.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
Anmerkungen

Die Funktion CAN_GetValue wird benutzt um Information über die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Vorhandensein eines Hardware-Kanals). Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_GetValue-Funktion am Beispiel des PCAN_USBBUS1 Kanals (z.B. Prüfen ob der CAN-Botschaftsfilter vollständig geöffnet ist). Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C++:

int iBuffer;
TPCANStatus result;
char strMsg[256];

// Der Zustand des Botschaftsfilters der PCAN-USB Kanal-1 wird geprüft.
//
result = CAN_GetValue(PCAN_USBBUS1, PCAN_MESSAGE_FILTER, &iBuffer, sizeof(iBuffer));
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
{
    // Der aktuelle Zustand des Botschaftsfilters wird in Text umgewandelt und angezeigt.
    //
    switch(iBuffer)
    {
        case PCAN_FILTER_OPEN:
            MessageBox("The message filter for the PCAN-USB, channel 1, is completely opened.");
            break;
        case PCAN_FILTER_CLOSE:
            MessageBox("The message filter for the PCAN-USB, channel 1, is closed.");
            break;
        case PCAN_FILTER_CUSTOM:
            MessageBox("The message filter for the PCAN-USB, channel 1, is custom configured.");
            break;
    }
}
Siehe auch

CAN_SetValue

TPCANParameter

Parameterwert Definitionen

Klassenmethode: GetValue


CAN_SetValue

Willkommen
CAN_SetValue

Schreibt einen Konfigurations- oder Datenwert auf einen PCAN-Kanal.

Syntax
C++
TPCANStatus __stdcall CAN_SetValue(
        TPCANHandle Channel,
        TPCANParameter Parameter,
        void* Buffer,
        WORD BufferLength
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
Parameter | Der Code für die zu lesende Information (siehe TPCANParameter).
Buffer | Der Puffer für den zu schreibenden Wert.
BufferLength | Die Grösse des Puffers (in bytes).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL: | Ein (oder mehrere) Übergabeparameter für die Funktion ist (sind) ungültig. Der Wert für 'Buffer' ist zu prüfen: er sollte auf eine gültige Struktur entsprechend dem Datentyp zeigen.
PCAN_ERROR_CAUTION: | Die Konfiguration eines Parameters ist fehlgeschlagen aufgrund ein nicht mehr vorhandenen Kanal. Der Parameter wurde auf alle bestehenden Kanäle zurückgesetzt.
PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHW: | Der gewählte PCAN-Kanal ist nicht verfügbar.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig (die Liste der gültigen Kanäle ist zu prüfen), oder wird vom angegebenen Parameter nicht unterstützt.
PCAN_ERROR_ILLPARAMTYPE: | Die Information ist für den gewählten PCAN-Kanal nicht verfügbar. Der Wert für 'Parameter' ist zu prüfen: nicht alle Werte werden auf jeder Hardware unterstützt.
PCAN_ERROR_ILLOPERATION: | Ein abhängiger Prozess, der durch den Aufruf dieser Funktion mit den aktuellen Parametern erzeugt wurde, ist vorübergehend nicht zulässig. Die Konfiguration in Verbindung mit dem verwendeten TPCANParameter ist zu überprüfen.
Anmerkungen

Die Funktion CAN_SetValue wird benutzt um die PCAN-Umgebung (z. B. CAN-Botschaftsfilter, Zusatztext im PCANBasic-Logfile) zu konfigurieren. Man muss aber berücksichtigen, dass nicht jeder PCAN-Kanal alle Parameter unterstützt. Weitere Informationen über Parameter und Werte findet sich in TPCANParameter.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_SetValue-Funktion am Beispiel des PCAN_NONEBUS Kanals (z. B. Einfügen von Zusatztext ins PCAN-Basic Log-Datei). Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Kein PCAN-Kanal muss initialisiert sein, um die Log Funktionalität nutzen zu können.

C++:

TPCANStatus result;
char strMsg[256];

// Festlegen eines Textes, der in der Log-Datei hinzugefügt werden.
//
strcpy(strMsg, "This is a custom text from an application included in PCAN-BASIC's Log File");

// Hinzufügen des Textes in der Log-Datei.
// Anmerkung: Wenn die Log-Eigenschaft nicht eingeschaltet ist, sie wird durch
// den Aufruf dieser Funktion automatisch aktiviert.
//
result = CAN_SetValue(PCAN_NONEBUS, PCAN_LOG_TEXT, strMsg, strlen(strMsg));
if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
    MessageBox("The text was successfully logged in the PCAN-Basic's Log file.");
Siehe auch

CAN_GetValue

TPCANParameter

Parameterwert Definitionen

Klassenmethode: SetValue


CAN_FilterMessages

Willkommen
CAN_FilterMessages

Konfiguriert den Botschafts-Empfangsfilter eines PCAN-Kanals.

Syntax
C++
TPCANStatus __stdcall CAN_FilterMessages(
        TPCANHandle Channel,
        DWORD FromID,
        DWORD ToID,
        TPCANMode Mode
);
Parameter
Parameter | Beschreibung
Channel | Das handle für einen PCAN Kanal (siehe TPCANHandle).
FromID | Die niedrigste ID, die empfangen werden soll.
ToID | Die höchste ID, die empfangen werden soll.
Mode | Der zu setzende Filter-Art (siehe TPCANMode).
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_INITIALIZE: | Der gewünschte PCAN Kanal konnte nicht gefunden werden, da die Anwendung ihn nicht in der Liste der initialisierten Kanäle führt.
PCAN_ERROR_ILLHANDLE: | Der gewünschte PCAN-Kanal ist nicht gültig. Die Liste der gültigen Kanäle ist zu prüfen.
Anmerkungen

Bei der Initialisierung eines Kanals ist der Filterbereich zunächst voll geöffnet. Nach dem aktuellen Filter-Status, den Aufruf dieser Funktion verhält sich wie folgt:

  • Filter-Status ist PCAN_FILTER_OPEN: Den Filter wird automatisch geschlossen und dann mit dem angegebenen Filterbereich konfiguriert.
  • Filter-Status ist PCAN_FILTER_CLOSE: Den Filter wird mit dem angegebenen Filterbereich konfiguriert.
  • Filter-Status ist PCAN_FILTER_CUSTOM: Den vorhandenen Filter wird, mit dem angegebenen Filterbereich, erweitern.

Der Parameter 'Mode' leg fest, welche Art von ID für den Filter verwendet werden soll: Standard Frames (11-bit Identifier) oder Extended Frames (29-bit Identifier). Standard Frames nutzen die Bitposition 28 .. 18 in den Acceptance Mask Registern des SJA-1000 CAN-Controllers. Der Treiber für Geräte mit 82C200 CAN-Controllern muss diese Bits auf Position 10 .. 0 schieben.

Konfigurieren des CAN-Botschaftsfilters löst einen Reset des CAN-Controllers aus. Das kann Auswirkungen auf andere Anwendungen haben, die mit derselben PCAN-Hardware arbeiten.

Hinweis:

  1. Es gibt nur einen Filter für Standard und Extended CAN-Nachrichten. Standard Nachrichten werden so registriert als würde die ID in den Bits 18 bis 28 liegen. D.h. eine Standard-ID 400h wird auch durch Angabe einer Extended-ID 10000000h empfangen. Aus diesem Grund ist es nicht empfehlenswert, Standard und Extended Filter zu mischen, da das Risiko der Empfang unerwünschter Nachrichten erhöht wird.
  2. Mehrfache Aufrufe von CAN_FilterMessage erweitern den Empfangsfilter immer weiter.
  3. Es ist nicht garantiert, dass eine Anwendung nur die CAN-Nachrichten empfängt, die im Bereich von FromID bis ToID liegen. Dies ist durch die Funktionsweise des SJA1000-Akzeptanzfilers bedingt. Siehe hierzu Philips Data Sheet "SJA1000 Stand-alone CAN-controller".
Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_FilterMessages-Funktion am Beispiel des PCAN_USBBUS1 Kanals. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

Anmerkung: Es wird vorausgesetzt, dass dieser Kanal bereits initialisiert ist.

C++:

TPCANStatus result;
char strMsg[256];
DWORD iBuffer;

// Der Botschaft-Empfangsfilter ist zuerst geschlossen, um das Benutzen des neues Bereiches zu  gewährleisten.
//
iBuffer = PCAN_FILTER_CLOSE;
result = CAN_SetValue(PCAN_USBBUS1,PCAN_MESSAGE_FILTER,&iBuffer, sizeof(iBuffer));

if(result != PCAN_ERROR_OK)
{
    // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
{
    // Der Botschaf-Empfangsfilter wird eingestellt, um die IDs 2,3,4 und 5, zu empfangen
    //
    result = CAN_FilterMessages(PCAN_USBBUS1, 2,5,PCAN_MESSAGE_STANDARD);
    if(result != PCAN_ERROR_OK)
    {
        // Ein Fehler ist aufgetreten. Die Rückgabewert wird in Text umgewandelt und angezeigt.
        //
        CAN_GetErrorText(result, 0, strMsg);
        MessageBox(strMsg);
    }
    else
        MessageBox("Filter successfully configured for IDs 2,3,4 and 5");
}
Siehe auch

CAN_SetValue

Klassenmethode: FilterMessages


CAN_GetErrorText

Willkommen
CAN_GetErrorText

Liest den beschreibenden Text für einen Fehlercode.

Syntax
C++
TPCANStatus __stdcall CAN_GetErrorText(
        TPCANStatus Error,
        WORD Language,
        LPSTR Buffer
);
Parameter
Parameter | Beschreibung
Error | Ein Fehlercode vom Typ TPCANStatus.
Language | Gibt die "Primary language ID" an.
Buffer | Null-terminierter char-Array-Puffer mit einer Länge von 256.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig. Der Wert für 'Buffer' ist zu prüfen: er sollte auf einen Null-terminierten Zeichenpuffer zeigen, der groß genug ist, um den Fehlermeldungstext aufzunehmen.
Anmerkungen

Die "Primary language IDs" wurden von Microsoft in Windows Betriebssystemen festgelegt, um menschliche Sprachen zu identifizieren. Das PCAN-Basic API unterstützt derzeit folgende Sprachen:

Sprache | Primary Language ID
Neutral (Systemeinstellung) | 00h (0)
Englisch | 09h (9)
Deutsch | 07h (7)
Französisch | 0Ch (12)
Italienisch | 10h (16)
Spanisch | 0Ah (10)

Anmerkung: Auch wenn derzeit nur kurze Texte definiert sind, kann die Zeichenfolge bis zu 255 Zeichen, plus Terminierung, lang sein. Daher muss die Länge des Puffers mindestens 256 Zeichen betragen.

Beispiel

Das folgende Beispiel demonstriert die Verwendung der CAN_GetErrorText-Funktion. Die Sprache des zurückgelieferten Texts ist die gleiche wie die Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch), oder Englisch bei nicht unterstützten Systemsprachen.

C++:

TPCANStatus result;
char strMsg[256];

// Der Fehlercode PCAN_ERROR_INITIALIZE wird in Text, auf Englisch, umgewandelt.
//
result = CAN_GetErrorText(PCAN_ERROR_INITIALIZE, 0, strMsg);
if(result != PCAN_ERROR_OK)
    //  Ein Fehler ist aufgetreten. Ein Fehlertext ist angezeigt.
    //
    MessageBox("Error when recovering Error-Code's description");
else
    MessageBox(strMsg);
Siehe auch

Primary language IDs

Klassenmethode: GetErrorText


CAN_LookUpChannel

Willkommen
CAN_LookUpChannel

Findet das Handles eines PCAN-Basic-Kanals, der mit den angegebenen Parametern übereinstimmt.

Syntax
C++
TPCANStatus __stdcall CAN_LookUpChannel(
    LPSTR Parameters,
    TPCANHandle* FoundChannel
);
Parameter
Parameter | Beschreibung
Parameters | Eine durch Kommas getrennte Zeichenfolge für Suchparameter, dh Paare von Namen / Werten, die mit einem PCAN-Basic-Kanals abgeglichen werden sollen.
FoundChannel | Puffer für die Rückgabe des PCAN-Basic-Kanals, wenn gefunden. Es enthält den Wert PCAN_NONEBUS, wenn kein Kanal gefunden wurde.
Rückgabe

Der Rückgabewert ist vom Typ TPCANStatus. Im Erfolgsfall erhält man PCAN_ERROR_OK, andernfalls können folgende Fehlermeldungen auftreten:

PCAN_ERROR_ILLPARAMVAL:
Ein (oder mehrere) Übergabeparameter für die Methode ist (sind) ungültig.
Anmerkungen

Die Zeichenfolge 'Parameters' muss Name / Wert-Paare enthalten, die durch ein '=' getrennt sind.

Jedes Name / Wert-Paar muss durch ein ',' getrennt werden.

Die aktuell unterstützten Parameter und ihre Wertebereiche werden unter LookUp Parameter Definitionen beschrieben.

Beispiel

Das folgende Beispiel zeigt die Verwendung von CAN_LookUpChannel, um das Handle eines USB-Geräts mit der ID 7 zu finden. Im Fehlerfall wird der Rückgabewert gemäß der Systemsprache (Englisch, Deutsch, Italienisch, Französisch oder Spanisch) in Klartext umgewandelt und ausgegeben.

C++:

TPCANStatus result;
char strMsg[256];
TPCANHandle channelHandle;

// Try to find a PCAN-USB device with ID 7
//
result = CAN_LookUpChannel("devicetype=pcan_usb, deviceid=7", &channelHandle);
if(result != PCAN_ERROR_OK)
{
    // An error occurred, get a text describing the error and show it
    //
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
else
{
    if(channelHandle != PCAN_NONENBUS)
        MessageBox("The channel handle for the PCAN-USB with ID=7 was found");
    else
        MessageBox("A PCAN-USB device with ID=7 is not available");
}
Siehe auch

LookUp Parameter Definitionen

Klassenmethode: LookUpChannel


Definitionen

Willkommen
Definitionen

Das PCAN-Basic API stellt folgende Definitionen zur Verfügung:

Name | Beschreibung
PCAN Handle Definitionen | Beschreibt die handles für die verschiedenen PCAN Kanäle.
Parameterwert Definitionen | Definiert die gültigen Werte zum Lesen und Schreiben von Informationen der PCAN-Umgebung bei Verwendung der Funktionen CAN_SetValue und CAN_GetValue.
FD Bitrate Parameter Definitionen | Definiert die verschiedenen Konfigurations-Parameter, aus denen sich ein FlexibleDataRate String zusammensetzt, mit dem FD-fähige PCAN-Kanäle initialisiert werden.
LookUp Parameter Definitionen | Definiert die verschiedenen Parameter, die zur Suche nach PCAN-Basic-Kanälen verwendet werden.


PCAN Handle Definitionen

Willkommen
PCAN Handle Definitionen

Definiert handles für verschiedene CAN-Busse (Kanäle) innerhalb einer Klasse. Diese Werte können als Parameter verwendet werden, wann immer ein TPCANHandle benötigt wird.

Handles-Standardwert:

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_NONEBUS | 0 | Stellt einen Standard-PCAN-Kanal dar. Dieser Kanal kann nicht initialisiert werden.

Handles für den ISA Bus (Non Plug & Play):

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_ISABUS1 | 0x21 | PCAN-ISA Schnittstelle, Kanal 1.
TPCANHandle | PCAN_ISABUS2 | 0x22 | PCAN-ISA Schnittstelle, Kanal 2.
TPCANHandle | PCAN_ISABUS3 | 0x23 | PCAN-ISA Schnittstelle, Kanal 3.
TPCANHandle | PCAN_ISABUS4 | 0x24 | PCAN-ISA Schnittstelle, Kanal 4.
TPCANHandle | PCAN_ISABUS5 | 0x25 | PCAN-ISA Schnittstelle, Kanal 5.
TPCANHandle | PCAN_ISABUS6 | 0x26 | PCAN-ISA Schnittstelle, Kanal 6.
TPCANHandle | PCAN_ISABUS7 | 0x27 | PCAN-ISA Schnittstelle, Kanal 7.
TPCANHandle | PCAN_ISABUS8 | 0x28 | PCAN-ISA Schnittstelle, Kanal 8.

Handles für den Dongle Bus (Non Plug & Play):

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_DNGBUS1 | 0x31 | PCAN-Dongle/LPT Schnittstelle, Kanal 1.

Handles für den PCI Bus:

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_PCIBUS1 | 0x41 | PCAN-PCI Schnittstelle, Kanal 1.
TPCANHandle | PCAN_PCIBUS2 | 0x42 | PCAN-PCI Schnittstelle, Kanal 2.
TPCANHandle | PCAN_PCIBUS3 | 0x43 | PCAN-PCI Schnittstelle, Kanal 3.
TPCANHandle | PCAN_PCIBUS4 | 0x44 | PCAN-PCI Schnittstelle, Kanal 4.
TPCANHandle | PCAN_PCIBUS5 | 0x45 | PCAN-PCI Schnittstelle, Kanal 5.
TPCANHandle | PCAN_PCIBUS6 | 0x46 | PCAN-PCI Schnittstelle, Kanal 6.
TPCANHandle | PCAN_PCIBUS7 | 0x47 | PCAN-PCI Schnittstelle, Kanal 7.
TPCANHandle | PCAN_PCIBUS8 | 0x48 | PCAN-PCI Schnittstelle, Kanal 8.
TPCANHandle | PCAN_PCIBUS9 | 0x409 | PCAN-PCI Schnittstelle, Kanal 9.
TPCANHandle | PCAN_PCIBUS10 | 0x40A | PCAN-PCI Schnittstelle, Kanal 10.
TPCANHandle | PCAN_PCIBUS11 | 0x40B | PCAN-PCI Schnittstelle, Kanal 11.
TPCANHandle | PCAN_PCIBUS12 | 0x40C | PCAN-PCI Schnittstelle, Kanal 12.
TPCANHandle | PCAN_PCIBUS13 | 0x40D | PCAN-PCI Schnittstelle, Kanal 13.
TPCANHandle | PCAN_PCIBUS14 | 0x40E | PCAN-PCI Schnittstelle, Kanal 14.
TPCANHandle | PCAN_PCIBUS15 | 0x40F | PCAN-PCI Schnittstelle, Kanal 15.
TPCANHandle | PCAN_PCIBUS16 | 0x410 | PCAN-PCI Schnittstelle, Kanal 16.

Handles für den USB Bus:

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_USBBUS1 | 0x51 | PCAN-USB Schnittstelle, Kanal 1.
TPCANHandle | PCAN_USBBUS2 | 0x52 | PCAN-USB Schnittstelle, Kanal 2.
TPCANHandle | PCAN_USBBUS3 | 0x53 | PCAN-USB Schnittstelle, Kanal 3.
TPCANHandle | PCAN_USBBUS4 | 0x54 | PCAN-USB Schnittstelle, Kanal 4.
TPCANHandle | PCAN_USBBUS5 | 0x55 | PCAN-USB Schnittstelle, Kanal 5.
TPCANHandle | PCAN_USBBUS6 | 0x56 | PCAN-USB Schnittstelle, Kanal 6.
TPCANHandle | PCAN_USBBUS7 | 0x57 | PCAN-USB Schnittstelle, Kanal 7.
TPCANHandle | PCAN_USBBUS8 | 0x58 | PCAN-USB Schnittstelle, Kanal 8.
TPCANHandle | PCAN_USBBUS9 | 0x509 | PCAN-USB Schnittstelle, Kanal 9.
TPCANHandle | PCAN_USBBUS10 | 0x50A | PCAN-USB Schnittstelle, Kanal 10.
TPCANHandle | PCAN_USBBUS11 | 0x50B | PCAN-USB Schnittstelle, Kanal 11.
TPCANHandle | PCAN_USBBUS12 | 0x50C | PCAN-USB Schnittstelle, Kanal 12.
TPCANHandle | PCAN_USBBUS13 | 0x50D | PCAN-USB Schnittstelle, Kanal 13.
TPCANHandle | PCAN_USBBUS14 | 0x50E | PCAN-USB Schnittstelle, Kanal 14.
TPCANHandle | PCAN_USBBUS15 | 0x50F | PCAN-USB Schnittstelle, Kanal 15.
TPCANHandle | PCAN_USBBUS16 | 0x510 | PCAN-USB Schnittstelle, Kanal 16.

Handles für den PC_Card Bus:

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_PCCBUS1 | 0x61 | PCAN-PC Card Schnittstelle, Kanal 1.
TPCANHandle | PCAN_PCCBUS2 | 0x62 | PCAN-PC Card Schnittstelle, Kanal 2.

Handles für den LAN Bus:

Typ | Bezeichner | Wert | Beschreibung
TPCANHandle | PCAN_LANBUS1 | 0x801 | PCAN-LAN Schnittstelle, Kanal 1.
TPCANHandle | PCAN_LANBUS2 | 0x802 | PCAN-LAN Schnittstelle, Kanal 2.
TPCANHandle | PCAN_LANBUS3 | 0x803 | PCAN-LAN Schnittstelle, Kanal 3.
TPCANHandle | PCAN_LANBUS4 | 0x804 | PCAN-LAN Schnittstelle, Kanal 4.
TPCANHandle | PCAN_LANBUS5 | 0x805 | PCAN-LAN Schnittstelle, Kanal 5.
TPCANHandle | PCAN_LANBUS6 | 0x806 | PCAN-LAN Schnittstelle, Kanal 6.
TPCANHandle | PCAN_LANBUS7 | 0x807 | PCAN-LAN Schnittstelle, Kanal 7.
TPCANHandle | PCAN_LANBUS8 | 0x808 | PCAN-LAN Schnittstelle, Kanal 8.
TPCANHandle | PCAN_LANBUS9 | 0x809 | PCAN-LAN Schnittstelle, Kanal 9.
TPCANHandle | PCAN_LANBUS10 | 0x80A | PCAN-LAN Schnittstelle, Kanal 10.
TPCANHandle | PCAN_LANBUS11 | 0x80B | PCAN-LAN Schnittstelle, Kanal 11.
TPCANHandle | PCAN_LANBUS12 | 0x80C | PCAN-LAN Schnittstelle, Kanal 12.
TPCANHandle | PCAN_LANBUS13 | 0x80D | PCAN-LAN Schnittstelle, Kanal 13.
TPCANHandle | PCAN_LANBUS14 | 0x80E | PCAN-LAN Schnittstelle, Kanal 14.
TPCANHandle | PCAN_LANBUS15 | 0x80F | PCAN-LAN Schnittstelle, Kanal 15.
TPCANHandle | PCAN_LANBUS16 | 0x810 | PCAN-LAN Schnittstelle, Kanal 16.
Anmerkungen

Der Wert PCAN_NONEBUS wird zur Einstellung des Standardkanals benutzt. Er wird für alle möglichen Zwecke eingesetzt, z.B. zur Einstellung der Log-Eigenschaften von PCAN-Basic. Man kann damit auch alle initialisierte Kanäle einer PCAN-Basic Anwendung in einem einzigen Anruf freigeben.

Anmerkung: Diese Definitionen sind Konstanten in einer objektorientierten Umgebung (Delphi, .NET Framework), und Defines in C++.

Hardware Typ und Kanäle:

Non Plug And Play: Hardwarekanäle dieser Art werden separat belegt. Es ist also erlaubt, PCAN_ISABUS3 zu belegen, ohne vorher PCAN_ISA1 und PCAN_ISA2. Es bleibt dem Benutzer überlassen, wie er logische PCAN-Busnamen mit physikalischen Ressourcen (Port und Interrupt) verknüpft.

Plug And Play: Zum Abfragezeitpunkt wird die Anzahl der am PC verfügbaren Hardwarekanäle ermittelt und so die Anzahl Handles bestimmt. Damit wird dann auch der Bereich gültiger Bezeichner eingeschränkt. Werden z. B. vier PCAN-USB am PC angeschlossen, kann der Benutzer die PCAN-Kanal-Handles PCAN_USBBUS1 bis PCAN_USBBUS4 für Verbindungen nutzen. Die Zuordnung der PCAN-Kanäle zu einer Hardware geschieht intern

Python:

Die Definitionen dieser Werte haben die folgende Form: TPCANHandle(handle), wobei handle den Wert aus der Spalte gleichen Namens enthält. z. B. PCAN_PCCBUS1 ist hinterlegt als TPCANHandle (0x61).

Siehe auch

Parameterwert Definitionen


Parameterwert Definitionen

Willkommen
Parameterwert Definitionen

Definiert die gültigen Werte zum Lesen und Schreiben von Informationen der PCAN-Umgebung bei Verwendung der Funktionen CAN_SetValue und CAN_GetValue.

Aktivierungswerte:

Typ | Bezeichner | Wert | Beschreibung
Int32 | PCAN_PARAMETER_OFF | 0 | Der PCAN-Parameter ist nicht gesetzt (inaktiv).
Int32 | PCAN_PARAMETER_ON | 1 | Der PCAN-Parameter ist gesetzt (aktiv).

Filterwerte:

Typ | Bezeichner | Wert | Beschreibung
Int32 | PCAN_FILTER_CLOSE | 0 | Der PCAN Filter ist geschlossen. Es werden keine CAN-Botschaften empfangen.
Int32 | PCAN_FILTER_OPEN | 1 | Der PCAN Filter ist vollständig geöffnet. Alle CAN-Botschaften werden empfangen.
Int32 | PCAN_FILTER_CUSTOM | 2 | Der PCAN Filter ist spezifisch konfiguriert. Nur registrierte CAN-Botschaften werden empfangen..

Kanalverfügbarkeitswerte:

Typ | Bezeichner | Wert | Beschreibung
Int32 | PCAN_CHANNEL_UNAVAILABLE | 0 | Das PCAN-Kanal-Handle, d.H. die zugehörige Hardware, ist nicht verfügbar.
Int32 | PCAN_CHANNEL_AVAILABLE | 1 | Das PCAN-Kanal-handle ist gültig zum Verbinden/Initialisieren. Für Plug&Play Hardware bedeutet dies auch, dass die Hardware angeschlossen ist.
Int32 | PCAN_CHANNEL_OCCUPIED | 2 | Das PCAN-Kanal-handle ist gültig, und ist gerade in Benutzung.
Int32 | PCAN_CHANNEL_PCANVIEW | PCAN_CHANNEL_AVAILABLE Or PCAN_CHANNEL_OCCUPIED | Das PCAN-Kanal-handle wird gerade von einem PCAN-View Anwendung verwendet und ist gültig zum Verbinden.

Log-Konfigurationswerte*:

Typ | Bezeichner | Wert | Beschreibung
Int32 | LOG_FUNCTION_DEFAULT | 0x00 | Immer aktiv. Steht für die Standardinformation "unerwartete Ausnahme" (z. B. Speicherschutzverletzung), die immer aufgezeichnet wird. Durch Setzen dieses Wertes wird die Standardeinstellung wiederhergestellt.
Int32 | LOG_FUNCTION_ENTRY | 0x01 | Erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine API Funktion aufgerufen wurde.
Int32 | LOG_FUNCTION_PARAMETERS | 0x02 | Erzeugt einen zusätzlichen Eintrag im Logfile, der bei Aufruf einer API-Funktion den Funktionsnamen und die Funktionsparameter mit ihren Werten enthält.
Int32 | LOG_FUNCTION_LEAVE | 0x04 | Erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine API Funktion beendet wurde.
Int32 | LOG_FUNCTION_WRITE | 0x08 | Erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine CAN-Botschaft mittels CAN_Write gesendet wurde. Die vollständige Botschaft wird ebenfalls als Text (hexadezimal) abgelegt.
Int32 | LOG_FUNCTION_READ | 0x10 | Erzeugt einen zusätzlichen Eintrag im Logfile, wenn eine CAN-Botschaft mittels CAN_Read gelesen wurde. Die vollständige Botschaft wird ebenfalls als Text (hexadezimal) abgelegt.
Int32 | LOG_FUNCTION_ALL | 0xFFFF | Durch Setzen dieses Wertes werden alle vorhandenen Log-Optionen aktiviert.

*Diese Werte können unter Verwendung der bitweisen ODER-Verknüpfung kombiniert werden

Trace-Konfigurationswerte*:

Typ | Bezeichner | Wert | Beschreibung
Int32 | TRACE_FILE_SINGLE | 0x00 | Speichert die Aufzeichnung in eine einzelne PCAN-Trace Datei, bis die konfigurierte Maximalgröße erreicht ist.
Int32 | TRACE_FILE_SEGMENTED | 0x01 | Segmentiert die Aufzeichnung in mehrere PCAN-Trace Dateien.
Int32 | TRACE_FILE_DATE | 0x02 | Erweitert den Namen der PCAN-Trace Datei um die Datumsangabe.
Int32 | TRACE_FILE_TIME | 0x04 | Erweitert den Namen der PCAN-Trace Datei um die Zeitangabe.
Int32 | TRACE_FILE_OVERWRITE | 0x08 | Erzwingt Überschreiben einer bereits vorhandenen PCAN-Trace Datei gleichen Namens.

*Diese Werte können unter Verwendung der bitweisen ODER-Verknüpfung kombiniert werden

Feature-Werte*:

Type | Constant | Value | Description
Int32 | FEATURE_FD_CAPABLE | 1 | Der PCAN-Kanal stellt ein Gerät dar, das flexible Datenrate unterstützt (CAN-FD).
Int32 | FEATURE_DELAY_CAPABLE | 2 | Der PCAN-Kanal stellt ein Gerät dar, das eine Verzögerung zwischen sendenden Frames erlaubt (nur FPGA basierte Geräte).
Int32 | FEATURE_IO_CAPABLE | 4 | Der PCAN-Kanal stellt ein Gerät dar, das die Konfiguration von digitalen und/oder analogen IOs (Input / Output) zur Verwendung mit elektronischen Schaltungen unterstützt.

*Diese Werte können unter Verwendung der bitweisen ODER-Verknüpfung kombiniert werden

Dienst-Statuswerte:

Typ | Bezeichner | Wert | Beschreibung
Int32 | SERVICE_STATUS_STOPPED | 1 | Der Dienst wird nicht ausgeführt.
Int32 | SERVICE_STATUS_RUNNING | 4 | Der Dienst wird ausgeführt.
Anmerkungen

Diese Definitionen sind Konstanten in einer objektorientierten Umgebung (Delphi, .NET Framework), und Defines in C++.

Python:

Die Definitionen dieser Werte haben die folgende Form: TPCANParameter(value), wobei value den Wert aus der Spalte gleichen Namens enthält. z. B. LOG_FUNCTION_ENTRY ist hinterlegt als TPCANParameter (0x01).

Siehe auch

PCAN Handle Definitionen

TPCANParameter


FD Bitrate Parameter Definitionen

Willkommen
FD Bitrate Parameter Definitionen

Definiert die verschiedenen Konfigurations-Parameter, aus denen sich ein FlexibleDataRate String zusammensetzt, mit dem FD-fähige PCAN-Kanäle initialisiert werden. Diese Werte werden als Parameter für CAN_InitializeFD (Methode: InitializeFD) verwendet.

Parameter für Taktfrequenz:

Typ | Bezeichner | Wert | Beschreibung
String | PCAN_BR_CLOCK | "f_clock" | Taktfrequenz in Hertz (80000000, 60000000, 40000000, 30000000, 24000000, 20000000).
String | PCAN_BR_CLOCK_MHZ | "f_clock_mhz" | Taktfrequenz in Megahertz (80, 60, 40, 30, 24, 20).

Parameter für Nominale Bitrate:

Typ | Bezeichner | Wert | Beschreibung
String | PCAN_BR_NOM_BRP | "nom_brp" | Taktteiler für ein nominales Zeit-Quanta (1..1024).
String | PCAN_BR_NOM_TSEG1 | "nom_tseg1" | TSEG1-Segment für die nominale Bitrate in Zeit-Quantas (1..256).
String | PCAN_BR_NOM_TSEG2 | "nom_tseg2" | TSEG2-Segment für die nominale Bitrate in Zeit-Quantas (1..128).
String | PCAN_BR_NOM_SJW | "nom_sjw" | Synchronisations-Sprungweite für die nominale Bitrate in Zeit-Quantas (1..128).

Parameter für Daten-Bitrate:

Typ | Bezeichner | Wert | Beschreibung
String | PCAN_BR_DATA_BRP | "data_brp" | Taktteiler für ein Fast-Data Zeit-Quanta (1..1024).
String | PCAN_BR_DATA_TSEG1 | "data_tseg1" | TSEG1-Segment für die Fast-Data Bitrate in Zeit-Quantas (1..32).
String | PCAN_BR_DATA_TSEG2 | "data_tseg2" | TSEG2-Segment für die Fast-Data Bitrate in Zeit-Quantas (1..16).
String | PCAN_BR_DATA_SJW | "data_sjw" | Synchronisations-Sprungweite für die Fast-Data Bitrate in Zeit-Quantas (1..16).
Anmerkungen

Diese Werte sind als Konstanten in einer objektorientierten Programmierumgebung (Delphi, .NET Framework) verfügbar und sind als #defines in C++ deklariert (plain API).

Folgende Punkte müssen beachtet werden, um einen gültigen FD Bitraten String zu konstruieren:

  • Der String darf nur einen von 2 gültigen "Taktfrequenz-Parametern" enthalten, abhängig von der verwendeten Einheit (Hz oder MHz)
  • Die darin benutzte Frequenz muss einem der 6 gelisteten Werte des "Taktfrequenz-Parameter" entsprechen
  • Die Werte für jeden Parameter müssen mit einem ,=' separiert sein, z.B. "data_brp=1"
  • Jedes Parameter/Werte-Paar muss mit einem ',' separiert sein (Leerzeichen sind zulässig, aber nicht notwendig) , z.B. "f_clock_mhz=24, nom_brp=1, ..."
  • Enweder die nominelle, oder Beide Bitraten müssen im String definiert sein (PCAN_BR_DATA_* und PCAN_BR_NOM_*, oder nur PCAN_BR_NOM_*).

Beispiel - Nominelle Bitrate:

Ein gültiger String, jeweils 1 Mbit/sec. für nominale- und Daten-Bitrate:

"f_clock_mhz=20, nom_brp=5, nom_tseg1=2, nom_tseg2=1, nom_sjw=1"

Beispiel - Nominell- und Daten- Bitrate:

Ein gültiger String, 1 Mbit/sec. für nominale- und 2 Mbit/sec für Daten-Bitrate:

"f_clock_mhz=20, nom_brp=5, nom_tseg1=2, nom_tseg2=1, nom_sjw=1, data_brp=2, data_tseg1=3, data_tseg2=1, data_sjw=1"

Parameter | Wertebereich
f_clock | [80000000, 60000000, 40000000, 30000000, 24000000, 20000000]
f_clock_mhz | [80, 60, 40, 30, 24, 20]
nom_brp | 1 .. 1024
nom_tseg1 | 1 .. 256
nom_tseg2 | 1 .. 128
nom_sjw | 1 .. 128
data_brp | 1 .. 1024
data_tseg1 | 1 .. 32
data_tseg2 | 1 .. 16
data_sjw | 1 .. 16

Python:

Die Werte-Definitionen haben folgende Form: TPCANBitrateFD(string), wobei string ein Ascii-Literal ist, der im Werte-Abschnitt enthaltene ist, z. B. PCAN_BR_CLOCK wird definiert als TPCANBitrateFD (b"f_clock").

Siehe auch

CAN_InitializeFD (Klassenmethode: InitializeFD)


LookUp Parameter Definitionen

Willkommen
LookUp Parameter Definitionen

Definiert die verschiedenen Parameter, die zur Suche nach PCAN-Basic-Kanälen verwendet werden. Diese Werte werden als Parameter bei CAN_LookUpChannel verwendet (Klassenmethode: LookUpChannel).

LookUp Channel Werte:

Type | Constant | Value | Description
String | LOOKUP_DEVICE_TYPE | "devicetype" | Suche nach Gerätetyp (z.B. PCAN_USB).
String | LOOKUP_DEVICE_ID | "deviceid" | Suche nach Geräte-ID.
String | LOOKUP_CONTROLLER_NUMBER | "controllernumber" | Suche nach nullbasiertem CAN-Controller-Index.
String | LOOKUP_IP_ADDRESS | "ipaddress" | Suche nach IP-Adresse (nur für LAN Kanäle).
Anmerkungen

Diese Definitionen sind Konstanten in einer objektorientierten Umgebung (Delphi, .NET Framework), und Defines in C++.

Folgende Regeln sind zu berücksichtigen, um eine gültige Suchparameter-String zu erstellen:

  • Der Wert für jeden Parameter muss durch ein '=' getrennt werden. Beispiel: "deviceid=1"
  • Jedes Parameter / Wert Paar muss durch ein ',' getrennt werden. Leerzeichen sind zulässig, aber nicht erforderlich. Beispiel: "devicetype=pcan_usb, deviceid=1,"
  • Nicht definierte Parameter werden ignoriert, anstatt dass der Funktionsaufruf fehlschlägt. Beispiel: Dies würde gut funktionieren: "devicetype=pcan_usb,unknownparam=4"
  • Numerische Parameterwerte, die außerhalb des aktuell unterstützten Bereichs liegen, geben keine Ergebnisse zurück, anstatt dass die Funktion fehlschlägt. Beispiel: "controllernumber=2500"
  • Wiederholte Parameter innerhalb des Strings führen nicht zum Fehlschlagen der Funktion. Es werden nur die letzten Vorkommen wiederholter Parameter ausgewertet. Beispiel: Es werden nur PCI-Geräte nachgeschlagen: "devicetype=pcan_usb, devicetype=pcan_pci"
  • Wenn mehr als ein Kanal gefunden wird, wird der zuerst gefundene zurückgegeben. Beispiel: "devicetype=pcan_usb" (having more than one USB device attached)
  • Die Reihenfolge der Auswertung ist unabhängig von der Position der Parameter innerhalb des Strings festgelegt. Die Reihenfolge ist:
    1. Gerätetyp
    2. Geräte-ID
    3. CAN-Controller-Nummer
    4. IP-Adresse

Parameter und Wertebereiche:

Parameter | Value Range
LOOKUP_DEVICE_TYPE | Ein TPCANDevice-Wert. Die Eingabe kann numerisch (hexadezimal oder dezimal) oder eine Zeichenfolge sein, die einen TPCANDevice-Wertnamen angibt (Groß- und Kleinschreibung wird nicht berücksichtigt). Beispiele: "devicetype=1" "devicetype=pcan_usb" "devicetype=PCAN_USB"
LOOKUP_DEVICE_ID | Wert im Bereich eines Doppelworts (0 .. 4294967295) im Hexadezimal- oder Dezimalformat. Beispiele: "deviceid=10" "deviceid=Ah" "deviceid=0xA"
LOOKUP_CONTROLLER_NUMBER | Ein auf Null basierender Indexwert im Bereich eines Doppelworts (0 .. 4294967295) im Hexadezimal- oder Dezimalformat. Derzeit werden maximal 6 Kanäle pro Gerät unterstützt (Controller-Index im Bereich [0 .. 5]). Beispiele: "controllernumber=1" "controllernumber=1h" "controllernumber=0x1"
LOOKUP_IP_ADDRESS | Eine gültige Internetprotokoll-Adresszeichenfolge. Beispiel: "ipaddress=192.168.2.1"
Siehe auch

CAN_LookUpChannel (class-method: LookUpChannel)


Zusätzliche Informationen

Willkommen
Zusätzliche Informationen

PCAN ist die Grundlage von PCAN-Basic. Die folgenden Kapitel geben einen Überblick zu PCAN und zeigen den prinzipiellen Umgang mit der Schnittstellen-DLL CanApi2 (PCAN-API)

In diesem Kapitel

Thema | Beschreibung
PCAN-Grundlagen | Dieser Abschnitt gibt einen Einblick in PCAN.
PCAN-API | Dieser Abschnitt stellt das PCAN-Basic API und das PCAN-API gegenüber, zusammen mit einer Funktionsbeschreibung der PCAN-API.
Error Frames | Dieser Abschnitt enthält Informationen über CAN Error-Frames.
Logdatei-Erzeugung | Dieser Abschnitt enthält Informationen zur Protokollierung Debugdaten innerhalb PCAN-Basic.


PCAN-Grundlagen

Willkommen
PCAN-Grundlagen

PCAN ist die Abkürzung für PEAK CAN APPLICATIONS, einem flexiblen System zum Planen, Entwickeln und Benutzen von Controller Area Networks (CAN-Netzwerken). PCAN ist ein mächtiges Werkzeug für Entwickler und ein umfassendes Produkt für Anwender.

Das PCAN-System besteht aus einer Sammlung von Microsoft Windows Gerätetreibern, die mit Echtzeiteigenschaften eine Verbindung zwischen Windows-Anwendungen und der physikalischen Anbindung von CAN-Bussen an den PC ermöglichen. Die Schnittstelle zwischen Benutzer und CAN-Bus ist der PCAN-Client, der Prozessfaktoren steuert und visualisiert. Treiber können sich mit mehreren Clients verbinden, die dann mit den CAN-Bussen kommunizieren. Außerdem werden mehrere verschiedene PCAN-Geräte unterstützt, sofern sie über einen Philips SJA-1000 (kompatiblen) CAN-Controller verfügen.

Sogenannte Netze verlängern logisch den CAN-Bus in den PC hinein. Mehrere Clients können sich so an den (virtuellen) CAN-Bus anschließen. Die Verbindung zur Außenwelt geschieht dann über ein PCAN-Hardware-Interface, z. B. eine PCAN-PCIexpress-Karte oder einen PCAN-USB.

Die folgenden Abbildungen zeigen mögliche Konfigurationen:

Für PCAN Anwendungen (Clients), CAN-Netzwerke (Netze) und PCAN-Hardware (Gerät) gelten folgende Regeln:

  • Ein Client kann mit mehr als einem Netz verbunden sein.
  • Ein Netz kann mehrere Clients versorgen.
  • Eine Hardware gehört immer zu genau einem Netz.
  • Ein Netz kann auch ohne Hardware existieren (virtuelles Netz).
  • Wenn ein Client eine CAN-Botschaft sendet, wird sie an alle anderen Clients verteilt und auch über die Hardware an den angeschlossenen CAN-Bus weitergegeben.
  • Wenn eine Hardware eine CAN-Botschaft empfängt, wird sie an alle anderen Clients verteilt, sofern deren Acceptance-Filter die CAN-Botschaft durchlässt.
  • Separate Definition der Hardware und der Netze: Pro Hardware können mehrere Netze definiert werden, wobei aber immer nur ein Netz aktiv ist..
  • Clients verbinden sich mit Netzen über deren Netznamen.
  • Jede PCAN-Anwendung (Client) hat einen Sendepuffer, wo Sendebotschaften bis zum richtigen Sendezeitpunkt aufbewahrt werden. Dann werden sie in den Sendepuffer der Hardware übertragen und aus dem Sendepuffer der Anwendung entfernt.
  • Jede Hardware hat einen Empfangspuffer zum Zwischenspeichern eintreffender CAN-Botschaften.
Siehe auch

PCAN-Basic einsetzen


PCAN-API

Willkommen
PCAN-API

Die professionelle Programmierschnittstelle PCAN-API des PCAN-Developer-Entwicklungspakets ermöglicht die Realisierung komplexer Windows®-Anwendungen mit CAN- und CAN-FD-Unterstützung. Dafür stellt die API (Application Programming Interface) eine umfangreiche Funktions-Bibliothek über Interface-DLLs für 32- und 64-Bit-Systeme zur Verfügung.

Die CAN-Kommunikation erfolgt im Gegensatz zu PCAN-Basic über Clients und bietet damit bedeutende Vorteile. So können, anstelle von nur einer Anwendung, gleichzeitig mehrere auf einen physikalischen CAN-Kanal zugreifen. Es funktioniert aber auch ohne Hardware: Über virtuelle Verbindungen ermöglichen Clients eine simulierte CAN-Kommunikation zwischen den WindowsR-Anwendungen eines Computers.

Wichtige Unterschiede zu PCAN-Basic auf einen Blick:

  • Ermöglicht das Senden von CAN-Botschaften zu einem selbst festgelegten Zeitpunkt (Senden mit Zeitstempel).
  • Es können mehrere Anwendungen gleichzeitig an ein PCAN-Gerät angeschlossen werden.
  • Funktioniert mit virtueller Hardware und internen Netzen.
  • Die Verbindung zur Hardware erfolgt über einen Client und ein Netz, anstatt einen Pseudokanal zu verwenden.
Siehe auch

PCAN-Developer 4


Error Frames

Willkommen
Error Frames

Error Frames werden empfangen, wenn der verbundenen PCAN-Kanal den Parameter PCAN_ALLOW_ERROR_FRAMES aktiviert hat, mittels der Funktion CAN_SetValue (Klassenmethode: SetValue), um Error Frames zu erhalten.

Empfangene Error Frames werden, je nach Art der Initialisierung, in TPCANMsg- bzw. TPCANMsgFD-Struktur verpackt, wobei im Feld MSGTYPE dann das Bit PCAN_MESSAGE_ERRFRAME gesetzt ist.

Die folgende Liste zeigt die Elemente eines Error Frame:

Feld | Information aus... | Inhalt
ID | ECC-Register SJA1000 (Error Code Capture), Bit 6 und 7 (ERRC0, ERRC1) | 0: Die Nachricht übermittelt nur aktualisierte Werte der Fehlerzähler 1: Bit Fehler 2: Form Fehler 4: Stuff Fehler 8: Anderer Fehler
DATA [0] | ECC-Register, Bit 5 (DIR) | 0: Fehler ist beim Senden aufgetreten 1: Fehler ist beim Empfangen aufgetreten
DATA [1] | ECC-Register, Bits 0 bis 4 (SEG0 bis SEG4) | Aktuelle Position des Bit Stream Prozessors: 2: ID.28 bis ID.21 3: Start of frame 4: Bit SRTR 5: BIT IDE 6: ID.20 bis ID.18 7: ID.17 bis ID.13 8: CRC Sequence 9: Reserved Bit 0 10: Data field 11: Data Length Code 12: Bit RTR 13: Reserved Bit 1 14: ID.4 bis ID.0 15: ID.12 bis ID.5 17: Active Error Flag 18: Intermission 19: Tolerate dominant Bits 23: Error Delimiter 24: CRC Delimiter 25: Acknowledge Slot 26: End of Frame 27: Acknowledge Limiter 28: Overload Flag
DATA [2] | RX Error Counter Register (RXERR) | Aktueller Wert des Receive-Fehlerzählers
DATA [3] | TX Error Counter Register (TXERR) | Aktueller Wert des Transmit-Fehlerzählers
Anmerkungen

Weitere Informationen hierzu siehe Philips Data Sheet "SJA1000 Stand-alone CAN controller".


Logdatei-Erzeugung

Willkommen
Logdatei-Erzeugung

Um das Debuggen von Probleme zu unterstützen, die während der CAN-Kommunikation entstehen können, besteht bei der PCAN-Basic die Möglichkeit,eine Logdatei zu erzeugen, welche die Aufrufe aller API Funktionen protokolliert. Es gibt zwei verschiedene Möglichkeiten, diese Logging-Funktionalität zu konfigurieren und zu aktivieren:

  • Mithilfe der API.
  • Mithilfe der Windows-Registry.
Log-Konfiguration mithilfe der API

Um die Log-Funktionalität einzustellen biete PCAN-Basic API drei Parameter, die mit der Funktion CAN_SetValue (Klasse-Mhetode: SetValue) konfiguriert werden können. Diese Parameter sind:

  • PCAN_LOG_LOCATION, um den Speicherort der Logdatei festzulegen.
  • PCAN_LOG_CONFIGURE, um den Inhalt der Logdatei zu konfigurieren.
  • PCAN_LOG_STATUS, um das Loggen zu aktivieren/deaktivieren.

Beispiel:

Im folgenden Beispiel wird PCAN-Basic so konfiguriert, dass alle möglichen Informationen protokolliert werden (LOG_FUNCTION_ALL = 0xFFFF). Die Logdatei wird auf dem Desktop von einem Benutzer namens "admin" gespeichert.

C++:

TPCANStatus result;
char strMsg[MAX_PATH];

// Inhalt der Datei konfigurieren.
//
iBuffer = LOG_FUNCTION_ALL;
result = CAN_SetValue(PCAN_NONEBUS, PCAN_LOG_CONFIGURE, (void*)&iBuffer, sizeof(iBuffer));
if(result != PCAN_ERROR_OK)
{
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}

// Speicherort der Datei konfigurieren.
//
char *buffer = "C:\\users\\admin\\desktop";
result = CAN_SetValue(PCAN_NONEBUS, PCAN_LOG_LOCATION,buffer,strlen(buffer));
if(result != PCAN_ERROR_OK)
{
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}

// Das Loggen aktivieren.
//
int iBuffer = PCAN_PARAMETER_ON;
result = CAN_SetValue(PCAN_NONEBUS, PCAN_LOG_STATUS, (void*)&iBuffer, sizeof(iBuffer));
if(result != PCAN_ERROR_OK)
{
    CAN_GetErrorText(result, 0, strMsg);
    MessageBox(strMsg);
}
Log-Konfiguration mithilfe der Windows-Registry

Um das Erzeugen der Logdatei zu aktivieren, muss der folgende Registrierungsschlüssel erstellt werden:

HKEY_CURRENT_USER\SOFTWARE\PEAK-System\PCAN-Basic\Log

Die Existenz dieses Schlüssels ist analog zur Verwendung der Funktion CAN_SetValue (Klasse-Mhetode: SetValue), um der Parameter PCAN_LOG_STATUS auf "an" zu setzen. Wenn dieser Schlüssel nicht vorhanden ist, wird keine Logdatei generiert.

Konfiguration:

Wenn keine weitere Konfiguration vorgenommen wird, werden die Defaultwerte für PCAN_LOG_LOCATION und PCAN_LOG_CONFIGURE verwendet. Um den Speicherort und den Inhalt der Logdatei zu konfigurieren, werden zwei Registrierungswerte verwendet:

Flags: DWORD-Wert, der eine logische OR-Operation zwischen den LOG_FUNCTION_ * Werten darstellt. Diese Werte entsprechen die Information, die protokolliert werden soll. Der Wert LOG_FUNCTION_ALL bewirkt, dass alle möglichen Informationen protokolliert werden.

Path: String-Wert, der den Pfad zu einem Ordner auf dem Computer darstellt, in dem die Logdatei gespeichert wird.

Beispiel:

Im folgenden Beispiel wird PCAN-Basic so konfiguriert, dass alle Ein- und Ausgänge der Funktionen und deren Parameter aufgezeichnet werden (LOG_FUNCTION_ENTRY = 1, LOG_FUNCTION_LEAVE = 4, LOG_FUNCTION_PARAMETERS = 2). Die Logdatei wird im Ordner "Desktop" der Benutzer "admin" gespeichert.

[HKEY_CURRENT_USER\SOFTWARE\PEAK-System\PCAN-Basic\Log]
"Flags"=dword:00000007
"Path"="C:\\Users\\admin\\desktop"
Remarks:

Nach eine Debugsitzung soll der Registrierungsschlüssel gelöscht oder umbenannt werden. Andernfalls werden alle, unter demselben Benutzerkonto ausgeführte, PCAN-Basic Anwendungen weiterhin Daten auf Ihre Logdateien schreiben. Unter diesen Umständen kann Speicherplatz unnötig verwendet/blockiert werden.


Inhalt

Willkommen
Inhalt
PCAN-Basic Dokumentation
Einführung
PCAN-Basic Grundlagen
Verwenden von Events
Lizenzbestimmungen
Kontakt-Information
Referenz
Namespaces
Peak.Can.Basic
Module
PCANBasic-Modul
Units
PCANBasic-Unit
Klassen
PCANBasic
TPCANBasic
Strukturen
TPCANMsg
TPCANTimestamp
TPCANMsgFD
TPCANChannelInformation
Typen
TPCANHandle
TPCANStatus
TPCANDevice
TPCANParameter
TPCANMessageType
TPCANType
TPCANMode
TPCANBaudrate
TPCANBitrateFD
TPCANTimestampFD
Methoden
Initialize
Initialize(TPCANHandle, TPCANBaudrate)
Initialize(TPCANHandle, TPCANBaudrate, TPCANType, UInt32, UInt16)
InitializeFD
Uninitialize
Reset
GetStatus
Read
Read(TPCANHandle, TPCANMsg)
Read(TPCANHandle, TPCANMsg, TPCANTimestamp)
Read(TPCANHandle)
ReadFD
ReadFD(TPCANHandle, TPCANMsgFD)
ReadFD(TPCANHandle, TPCANMsgFD, TPCANTimestampFD)
ReadFD(TPCANHandle)
Write
WriteFD
GetValue
GetValue(TPCANHandle,TPCANParameter)
GetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)
GetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)
GetValue(TPCANHandle, TPCANParameter, String, TPCANChannelInformation[])
GetValue(TPCANHandle, TPCANParameter, String, UInt32)
SetValue
SetValue(TPCANHandle, TPCANParameter, Object)
SetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)
SetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)
SetValue(TPCANHandle, TPCANParameter, String, UInt32)
FilterMessages
GetErrorText
GetErrorText(TPCANStatus,UInt16,String)
GetErrorText(TPCANStatus, int)
LookUpChannel
LookUpChannel(String,TPCANHandle)
LookUpChannel(String)
Funktionen
CAN_Initialize
CAN_InitializeFD
CAN_Uninitialize
CAN_Reset
CAN_GetStatus
CAN_Read
CAN_ReadFD
CAN_Write
CAN_WriteFD
CAN_GetValue
CAN_SetValue
CAN_FilterMessages
CAN_GetErrorText
CAN_LookUpChannel
Definitionen
PCAN Handle Definitionen
Parameterwert Definitionen
FD Bitrate Parameter Definitionen
LookUp Parameter Definitionen
Zusätzliche Informationen
PCAN-Grundlagen
PCAN-API
Error Frames
Logdatei-Erzeugung


Index

Willkommen
Index
C | D | E | F | G | I | K | L | M | N | P | R | S | T | U | V | W | Z
C
CAN_FilterMessages
CAN_GetErrorText
CAN_GetStatus
CAN_GetValue
CAN_Initialize
CAN_InitializeFD
CAN_LookUpChannel
CAN_Read
CAN_ReadFD
CAN_Reset
CAN_SetValue
CAN_Uninitialize
CAN_Write
CAN_WriteFD
D
Definitionen
E
Einführung
Error Frames
F
FD Bitrate Parameter Definitionen
FilterMessages
Funktionen
G
GetErrorText
GetErrorText(TPCANStatus, int)
GetErrorText(TPCANStatus,UInt16,String)
GetStatus
GetValue
GetValue(TPCANHandle, TPCANParameter, String, TPCANChannelInformation[])
GetValue(TPCANHandle, TPCANParameter, String, UInt32)
GetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)
GetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)
GetValue(TPCANHandle,TPCANParameter)
I
Initialize
Initialize(TPCANHandle, TPCANBaudrate)
Initialize(TPCANHandle, TPCANBaudrate, TPCANType, UInt32, UInt16)
InitializeFD
K
Klassen
Kontakt-Information
L
Lizenzbestimmungen
Logdatei-Erzeugung
LookUp Parameter Definitionen
LookUpChannel
LookUpChannel(String)
LookUpChannel(String,TPCANHandle)
M
Methoden
Module
N
Namespaces
P
Parameterwert Definitionen
PCAN Handle Definitionen
PCAN-API
PCANBasic
PCAN-Basic Dokumentation
PCAN-Basic Grundlagen
PCANBasic-Modul
PCANBasic-Unit
PCAN-Grundlagen
Peak.Can.Basic
R
Read
Read(TPCANHandle)
Read(TPCANHandle, TPCANMsg)
Read(TPCANHandle, TPCANMsg, TPCANTimestamp)
ReadFD
ReadFD(TPCANHandle)
ReadFD(TPCANHandle, TPCANMsgFD)
ReadFD(TPCANHandle, TPCANMsgFD, TPCANTimestampFD)
Referenz
Reset
S
SetValue
SetValue(TPCANHandle, TPCANParameter, Object)
SetValue(TPCANHandle, TPCANParameter, String, UInt32)
SetValue(TPCANHandle, TPCANParameter, UInt32, UInt32)
SetValue(TPCANHandle, TPCANParameter, UInt64, UInt32)
Strukturen
T
TPCANBasic
TPCANBaudrate
TPCANBitrateFD
TPCANChannelInformation
TPCANDevice
TPCANHandle
TPCANMessageType
TPCANMode
TPCANMsg
TPCANMsgFD
TPCANParameter
TPCANStatus
TPCANTimestamp
TPCANTimestampFD
TPCANType
Typen
U
Uninitialize
Units
V
Verwenden von Events
W
Write
WriteFD
Z
Zusätzliche Informationen


Willkommen

Willkommen zur Dokumentation von PCAN-Basic,

der neuen Ausgabe des "kleinen" API (vormals PCAN-Light) von PEAK-System.

In den folgenden Kapiteln finden Sie ausführliche Informationen zu diesem API,

um in Ihren Anwendungen von der CAN-Hardware-Produktpalette der Firma PEAK-System

und dem CAN Protokoll bestmöglich profitieren zu können.

Einführung [image] DLL API Referenz [image] Weiterführende Information

Letzte Aktualisierung: 12.08.2022