Rust is a compiled systems programming language rather than a scripting language. It targets many of the same application areas as C and C++, including software that requires predictable performance, direct control over resources, and close interaction with operating-system or hardware APIs.

Its defining feature is the ownership model. Every value has an owner, and the compiler checks how values are moved, borrowed, shared, and released. Lifetimes describe relationships between references so that invalid references can be rejected at compile time. These checks provide strong guarantees in safe Rust and are particularly useful in multithreaded programs, where Rust’s type system can prevent many data races.

Error handling follows a similarly explicit approach. Operations that can fail commonly return Result values, while optional values use Option. This encourages the calling code to handle success, failure, and absence deliberately instead of relying on unchecked return values or implicit exception paths.
Rust also includes Cargo, its standard build system and package manager. Cargo manages builds, dependencies, tests, examples, and documentation in a consistent workflow. For teams accustomed to assembling different build, dependency, and test tools around C or C++, this integrated developer experience can be a significant productivity benefit. 

Official Rust Website

mod PCANBasic;

use crate::PCANBasic::*;

fn main() {

   match Initialize(PCAN_USBBUS1, PCAN_BAUD_500K) {

       Ok(_) => println!("PCAN-USB initialized successfully."),

       Err(status) => println!("Error initializing PCAN-USB: {:?}", status)

   }

}

Figure 2: Rust provides strong safety guarantees in safe code. Calls across an FFI boundary must still respect the native API contract.
 

The following abbreviated example shows the application flow a developer should expect. It is intentionally presented as a workflow-oriented excerpt rather than a drop-in replacement for the official PEAK sample. Import paths, type names, and helper functions must be taken from the Rust FFI module delivered in the current PCAN-Basic package.

// Workflow excerpt - use the exact imports and declarations from the
// official Rust console sample supplied with PCAN-Basic 5.1.

fn main() {

   // 1. Select or discover an available PCAN channel.
   // 2. Initialize it for the required protocol and bit rate:
   //       CAN_Initialize(...)    for CAN CC
   //       CAN_InitializeFD(...)  for CAN FD
   //       CAN_InitializeXL(...)  for CAN XL
   // 3. Check the returned TPCANStatus before continuing.
   // 4. Create the protocol-specific message structure.
   // 5. Transmit with CAN_Write, CAN_WriteFD, or CAN_WriteXL.
   // 6. Read until the receive queue reports PCAN_ERROR_QRCVEMPTY,
   //    processing message data and the supplied receive timestamp.
   // 7. Query or format errors for diagnostics.
   // 8. Always release the channel with CAN_Uninitialize.
}

A production implementation should wrap this native call sequence in a small Rust abstraction that:

• Stores the selected channel and protocol mode together so that CAN CC, CAN FD, and CAN XL read/write functions cannot be mixed accidentally.
• Converts every TPCANStatus into a meaningful Rust error type and includes the PEAK error text in logs.
• Uses a guard object whose Drop implementation releases the channel, while still allowing explicit shutdown and error reporting.
• Validates frame IDs, message types, DLC/data lengths, and bit-rate strings before crossing the FFI boundary.
• Drains the receive queue after a notification because an event signals that data is available but does not replace the API read operation.
• Keeps unsafe code narrowly contained around the FFI calls and exposes safe application-level methods to the rest of the program.

Official example and download: PCAN-Basic product page

mod PCANBasic;
use crate::PCANBasic::*;
const BITRATE: TPCANBaudrate = PCAN_BAUD_500K;
const BITRATE_FD: &str = "\
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";
const BITRATE_XL: &str = "\
f_clock=160000000, brp=1, nom_tseg1=255, nom_tseg2=64, nom_sjw=64, \
fd_tseg1=63, fd_tseg2=16, fd_sjw=16, fd_ssp_offset=0, \
xl_tseg1=10, xl_tseg2=9, xl_sjw=9, xl_ssp_offset=10, xl_error_signaling=1, xl_transceiver_mode_switch=0";
const MESSAGE: TPCANMsg = TPCANMsg { ID: 0x100, MSGTYPE: PCAN_MESSAGE_EXTENDED, LEN: 8, DATA: [0; 8] };
const MESSAGE_FD: TPCANMsgFD = TPCANMsgFD { ID: 0x100, MSGTYPE: PCAN_MESSAGE_FD | PCAN_MESSAGE_BRS, DLC: 15, DATA: [0; 64] };
const MESSAGE_XL: TPCANMsgXL = TPCANMsgXL { PID: 0x100, VCID: 0, AF: 0, RRS: 0, SEC: 0, SDT: 0, MSGTYPE: PCAN_MESSAGE_XL, DLC: 2047, DATA: [0; 2048] };

fn main() {
   let parameters = format!("{}={}", LOOKUP_DEVICE_TYPE, "PCAN_USB");
   let handle: TPCANHandle = match LookUpChannel(&parameters){
       Ok(handle) => {
           println!("Looked up channel");
           handle
       }
       Err(status) => {
           println!("Error looking up channel: {}", status);
           return;
       }
   };

   let features: u32 = match GetValueInt32(handle, PCAN_CHANNEL_FEATURES) {
       Ok(features) => {
           println!("Retrieved features");
           features
       }
       Err(status) => {
           println!("Error retrieving features: {}", status);
           return;
       }
   };

   let is_fd = (features & FEATURE_FD_CAPABLE as u32) == FEATURE_FD_CAPABLE as u32;
   let is_xl = (features & FEATURE_XL_CAPABLE as u32) == FEATURE_XL_CAPABLE as u32;
   let initialize_result = match (is_xl, is_fd) {
       (true, _) => InitializeXL(handle, BITRATE_XL),
       (false, true) => InitializeFD(handle, BITRATE_FD),
       (false, false) => Initialize(handle, BITRATE),
   };

   match initialize_result {
       Ok(_) => println!("Initialized channel"),
       Err(status) => {
           println!("Error initializing channel: {}", status);
           return;
       }
   }

   let write_result = match (is_xl, is_fd) {
       (true, _) => WriteXL(handle, &mut MESSAGE_XL),
       (false, true) => WriteFD(handle, &mut MESSAGE_FD),
       (false, false) => Write(handle, &mut MESSAGE),
   };

   match write_result {
       Ok(_) => println!("Wrote message"),
       Err(status) => println!("Error writing message: {}", status),
   }

   loop {
       let result = match (is_xl, is_fd) {
           (true, _) => ReadXL(handle).map(|_| println!("Received XL message")),
           (false, true) => ReadFD(handle).map(|_| println!("Received FD message")),
           (false, false) => Read(handle).map(|_| println!("Received CC message")),
       };

       match result {
           Ok(_) => continue,
           Err(status) if status == PCAN_ERROR_QRCVEMPTY => break,
           Err(status) => {
               println!("Error reading message: {}", status);
               return;
           }
       }
   }

   match Uninitialize(handle){
       Ok(_) => println!("Uninitialized channel"),
       Err(status) => println!("Error uninitializing channel: {}", status),    
   }
}