Skip to content
GitLab
Select Git revision
  • master default
Find file BlameHistoryPermalink
can.rs 6.91 KiB
1 
extern crate generic_array;
2 
extern crate canlib_rs;
3 
extern crate canlib_sys;
4 
extern crate hex;
5
6 
use crate::communication_interface::*;
7 
use crate::protocol_interface::*;
8 
use crate::ring_buffer::RingBuffer;
9 
use crate::ring_buffer::RingBufferInterface;
10 
use generic_array::ArrayLength;
11 
use canlib_rs::*;
12 
use canlib_sys::canStatus;
13 
use std::u8;
14
15 
/// # CAN struct
16 
///
17 
///  Struct for one connection over the CAN bus.
18 
///  Currently this CAN implementation is focused for Kvaser hardware and CANlib.
19 
///
20 
/// * `send_buffer` - Internal send buffer. Use send() to add message to this buffer. Then tx() to transmit to CAN bus.
21 
/// * `recieve_buffer` - Internal receive buffer. Use rx() to read the CAN bus to this buffer. Then receive() to get the message.
22 
/// * `protocol_type` - Specifies what type of protocol to use. E.g. UartSimpleMessage<N>.
23 
/// * `can_settings` - Stores the settings for this specific instance.
24 
/// * `can_handle` - Handle Id for this instance. Used to seperate different instances of CAN. If only one is used, then can_handle = 0.
25 
///
26 
pub struct Can<N, T> where
27 
    N: ArrayLength<u8>,
28 
    T: ProtocolInterface<N>
29 
{
30 
    // Hardware independent variables
31 
    send_buffer: RingBuffer<N>,
32 
    receive_buffer: RingBuffer<N>,
33 
    protocol_type: T,
34 
    // Hardware dependent variables
35 
    can_settings: CanBusSettings,
36 
    handle: CanHandle,
37 
}
38
39 
pub trait CanTrait {
40 
    /// Initializes the CAN channel with given settings.
41 
    /// * `settings` The CanBusSettings to initialize the current CAN instance with.
42 
    fn init(&mut self, settings: CanBusSettings);
43 
    /// Terminates this CAN instance by turning off and closing the CAN bus for this handle.
44 
    fn terminate(&mut self);
45 
    /// Read CAN channel and add message to recieve_buffer.
46 
    /// There are queues and buffers implemented in Kvaser's hardware. Each read will get the message
47 
    /// with the highest priority in the mailbox.
48 
    fn rx(&mut self);
49 
    /// TODO: Implementation to talk to light modules.
50 
    fn tx(&mut self);
51 
}
52
53 
/// Settings for all types of CAN buses. Check the CANlib documentation for information of these variables.
54 
pub struct CanBusSettings {
55 
    // General
56 
    pub channel: i32,
57 
    pub flags: i32,
58 
    pub driver_type: CanDriver,
59 
    // For normal CAN
60 
    pub freq: CanBitrate,
61 
    pub tseg1: u32,
62 
    pub tseg2: u32,
63 
    pub sjw: u32,
64 
    pub no_samp: u32,
65 
    // For CAN-FD
66 
    pub can_fd: bool,
67 
    pub freq_brs: CanBitrate,
68 
    pub tseg1_brs: u32,
69 
    pub tseg2_brs: u32,
70 
    pub sjw_brs: u32,
7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
} impl<N, T> CommunicationInterface<N, T> for Can<N, T> where N: ArrayLength<u8>, T: ProtocolInterface<N> { /// Initialize the CAN instance with 'empty' settings. fn new() -> Self { let settings = CanBusSettings { channel: 0, flags: 0, driver_type: CanDriver::Off, freq: CanBitrate::_1M, tseg1: 0, tseg2: 0, sjw: 0, no_samp: 0, can_fd: false, freq_brs: CanBitrate::Fd1M, tseg1_brs: 0, tseg2_brs: 0, sjw_brs: 0, }; let init_handle: CanHandle = 0; Can { send_buffer: RingBufferInterface::new(), receive_buffer: RingBufferInterface::new(), protocol_type: T::new(), can_settings: settings, handle: init_handle, } } /// TODO: Not yet implemented. fn send(& mut self, mut p: T) -> bool { true } /// Returns the internal recieve buffer. fn receive(& mut self) -> T { let mut a : T = T::new(); a.deseralize(&mut self.receive_buffer); a } } impl<N, T> CanTrait for Can<N, T> where N: ArrayLength<u8>, T: ProtocolInterface<N> { fn init(&mut self, settings: CanBusSettings) { self.can_settings = settings; let handle = can_open_channel(self.can_settings.channel, self.can_settings.flags); self.handle = handle; // For CAN FD if self.can_settings.can_fd { can_set_bus_params( self.handle, self.can_settings.freq, self.can_settings.tseg1, self.can_settings.tseg2, self.can_settings.sjw,
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
self.can_settings.no_samp, ); canfd_set_bus_params( self.handle, self.can_settings.freq_brs, self.can_settings.tseg1_brs, self.can_settings.tseg2_brs, self.can_settings.sjw_brs, ); can_set_bus_output_control( self.handle, self.can_settings.driver_type, ); can_bus_on(self.handle); // For Normal CAN } else { can_set_bus_params( self.handle, self.can_settings.freq, self.can_settings.tseg1, self.can_settings.tseg2, self.can_settings.sjw, self.can_settings.no_samp, ); can_set_bus_output_control( self.handle, self.can_settings.driver_type, ); can_bus_on(self.handle); } } fn terminate(&mut self) { can_bus_off(self.handle); can_close(self.handle); } fn rx(&mut self) { let mut buffer = [0; 64]; // 64 bytes; maximum message size CAN FD //println!("CanHandle: {}", self.handle); if self.handle < 0 { println!("canOpenChannel failed!"); } else { // Variables the CAN hardware will read to. let mut id: i32 = 0; let mut dlc: u32 = 0; let mut flag: u32 = 0; let mut time: u32 = 0;; // Sync waits until a message is recieved. let sync_stat = can_read_sync(self.handle, 0xFFFFFFFF); // 0xFFFFFFFF = infinte long time if sync_stat as i32 != canStatus::canOK as i32 { println!("canWriteSync Error."); } else { //println!("canWriteSync Ok"); }