candid_server 0.3.0

A server for reading and relaying messages on a CAN bus
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! # CANdid Server
//!
//! Reads from the specified CAN bus and relays each frame to connected clients.
//!
//! # Usage
//!
//! ```
//! candid_server <ADDRESS> <INTERFACE>
//!
//! FLAGS:
//!     -h, --help       Prints help information
//!     -V, --version    Prints version information
//!
//! ARGS:
//!     <ADDRESS>      The address:port to bind to
//!     <INTERFACE>    The CAN interface to listen to
//! ```

extern crate candid_server;

use candid_server::{can_reader::CANReader, client_handler::new_client_handler};

use std::net::TcpListener;
use std::sync::mpsc;

use socketcan::CANSocket;

use clap::{App, Arg};

fn main() {
    let matches = App::new("CANdid Server")
        .version("0.1.0")
        .author("Alex van de Sandt <avandesa@purdue.edu>")
        .about("A server to read, parse, and relay messages from a CAN bus.")
        .arg(
            Arg::with_name("addr")
                .value_name("ADDRESS")
                .help("The address:port to bind to")
                .takes_value(true)
                .required(true),
        )
        .arg(
            Arg::with_name("bus")
                .value_name("INTERFACE")
                .help("The CAN interface to listen to")
                .takes_value(true)
                .required(true),
        )
        .get_matches();

    // Process commandline args
    let addr = matches.value_of("addr").unwrap();
    let can_interface = matches.value_of("bus").unwrap();

    // Open CAN Socket
    let can_socket = CANSocket::open(can_interface).expect("Could not open CAN socket");

    // Instantiate CANReader
    let (can_reader, _) = CANReader::new(can_socket);

    // Open TCPListener
    let listener = TcpListener::bind(addr).expect("Could not bind to address.");

    let mut clients = Vec::new();

    loop {
        // Listen for new connections
        if let Ok((socket, addr)) = listener.accept() {
            println!("New Client: {:?}", addr);

            // Create channel. Sender -> CANReader, Receiver -> ClientHandler.
            let (tx, rx) = mpsc::channel();
            can_reader.add_client(tx);

            // Create client handler
            clients.push(new_client_handler(
                socket,
                can_interface.clone().to_string(),
                rx,
            ));
        }
    }
}