Browse Source

Ajout d'un peu de documentation et de quelques cas de test.

Paul Florence 1 year ago
parent
commit
ad445ec3ec

+ 16
- 0
README.md View File

@@ -58,6 +58,22 @@ Pour cross-compiler vers windows tu vas avoir besoin de récupérer une nouvelle
58 58
 rustup target add x86_64-pc-windows-gnu
59 59
 ```
60 60
 
61
+## Analyse statique
62
+
63
+Il est possible d'utiliser [Clippy](https://github.com/rust-lang-nursery/rust-clippy) afin d'analyser le code à la recherche de motifs pouvant causer des bugs.
64
+Il faut commencer par installer Clippy :
65
+
66
+```bash
67
+cargo install clippy
68
+```
69
+
70
+On peut ensuite exécuter Clippy sur le projet `robot_core` (par exemple) en exécutant :
71
+
72
+```bash
73
+cd robot_core
74
+cargo clippy
75
+```
76
+
61 77
 # Ressources
62 78
 
63 79
 *As-tu besoin d'être convaincu par Rust ?* Tu peut toujours lire [ceci](https://brson.github.io/fireflowers/).

+ 1
- 0
robot_core/Cargo.toml View File

@@ -9,3 +9,4 @@ slog-stdlog="3.0"
9 9
 bufstream = "0.1"
10 10
 serde = "1.0"
11 11
 serde_derive ="1.0"
12
+serialport = "*"

+ 1
- 0
robot_core/src/lib.rs View File

@@ -11,6 +11,7 @@ extern crate bufstream;
11 11
 extern crate serde;
12 12
 #[macro_use]
13 13
 extern crate serde_derive;
14
+extern crate serialport;
14 15
 
15 16
 /// Gestion des trames.
16 17
 pub mod trame;

+ 52
- 2
robot_core/src/stream.rs View File

@@ -22,6 +22,8 @@ use std::net::TcpStream;
22 22
 
23 23
 use slog_stdlog;
24 24
 
25
+use serialport;
26
+
25 27
 use bufstream::BufStream;
26 28
 
27 29
 use slog::Drain;
@@ -57,6 +59,44 @@ where
57 59
     }
58 60
 }
59 61
 
62
+/// Permet d'ouvrir un stream vers une connection TCP ou une connection série.
63
+///
64
+/// # Exemple
65
+///
66
+/// Pour se connecter au simulateur on peut utiliser cette fonction ainsi.
67
+/// ```
68
+/// use robot_core::stream;
69
+/// // Connection au simulateur.
70
+/// let stream = stream::open_stream("127.0.0.1:1234", None);
71
+/// if let Ok(co) = stream {
72
+///     // Faire des trucs avec co
73
+/// }
74
+/// ```
75
+///
76
+/// Pour se connecter au robot, cela marche de la même façon.
77
+///
78
+/// ```
79
+/// use robot_core::stream;
80
+/// // Connection au robot
81
+/// let stream = stream::open_stream("/dev/ttyUS0", None);
82
+/// if let Ok(co) = stream {
83
+///     // Faire des trucs avec co
84
+/// }
85
+/// ```
86
+///
87
+pub fn open_stream<T: AsRef<str>, L: Into<Option<Logger>>>(
88
+    path: T,
89
+    logger: L,
90
+) -> Result<Box<TrameStream>, Box<Error>> {
91
+    if let Ok(tcp_stream) = TcpStream::connect(path.as_ref()) {
92
+        Ok(Box::new(BlockingStream::new(tcp_stream, logger)))
93
+    } else if let Ok(_) = serialport::open(path.as_ref()) {
94
+        Err(From::from("Serial connection is not supported yet."))
95
+    //Ok(Box::new(BlockingStream::new(serial_stream, logger)))
96
+    } else {
97
+        Err(From::from("Failed to open connection."))
98
+    }
99
+}
60 100
 
61 101
 /// Défini les fonctions pour envoyer et recevoir des `Trame`.
62 102
 pub trait TrameStream {
@@ -133,7 +173,7 @@ where
133 173
 /// Une interface bloquante pour envoyer des trames.
134 174
 impl<T> BlockingStream<T>
135 175
 where
136
-    T: Read + Write + ClonableStream + Send + Sync + 'static,
176
+    T: Read + Write + ClonableStream + Send + 'static,
137 177
 {
138 178
     /// Initialise un nouveau `BlockingStream` à partir d'un stream.
139 179
     pub fn new<L: Into<Option<Logger>>>(stream: T, logger: L) -> BlockingStream<T> {
@@ -253,10 +293,11 @@ mod test {
253 293
     use std::net::{TcpListener, TcpStream};
254 294
     use std::thread;
255 295
     use std::thread::JoinHandle;
256
-    use stream::{TrameStream, BlockingStream};
296
+    use stream::{TrameStream, BlockingStream, open_stream};
257 297
     use trame::Trame;
258 298
 
259 299
     const DEBUG_ADDRESS: &str = "127.0.0.1:8888";
300
+    const DEBUG_ADDRESS1: &str = "127.0.0.1:8887";
260 301
     const TEST_TRAME: Trame = Trame {
261 302
         id: 12,
262 303
         cmd: 99,
@@ -283,4 +324,13 @@ mod test {
283 324
         assert_eq!(trame, TEST_TRAME);
284 325
         handle.join().unwrap();
285 326
     }
327
+
328
+    #[test]
329
+    fn open() {
330
+        let handle = listen_and_accept(DEBUG_ADDRESS1);
331
+        let stream = open_stream(DEBUG_ADDRESS1, None);
332
+        assert!(stream.is_ok());
333
+        stream.unwrap().stop();
334
+        handle.join().unwrap();
335
+    }
286 336
 }

+ 22
- 0
robot_core/src/trame.rs View File

@@ -176,3 +176,25 @@ impl<'a> Into<Vec<u8>> for Trame {
176 176
         result
177 177
     }
178 178
 }
179
+
180
+#[cfg(test)]
181
+mod test {
182
+    use trame::Trame;
183
+
184
+    #[test]
185
+    fn test_ping() {
186
+        let ping = Trame::new_ping(0);
187
+        assert_eq!(
188
+            ping,
189
+            Trame::new_from_slice(0, 0x55, vec![0, 0, 0, 0, 0, 0, 0, 0].as_slice(), false)
190
+        );
191
+    }
192
+
193
+    #[test]
194
+    fn test_pong() {
195
+        let pong_trame =
196
+            Trame::new_from_slice(0, 0xAA, vec![0, 0, 0, 0, 0, 0, 0, 0].as_slice(), false);
197
+        assert!(pong_trame.is_pong());
198
+    }
199
+
200
+}

robot_debugger/gui.glade → robot_debugger/src/gui.glade View File


+ 2
- 1
robot_debugger/src/main.rs View File

@@ -432,7 +432,8 @@ fn main() {
432 432
 
433 433
     // --------------- Initialisation
434 434
     // La structure de donnée qui contiens la gui.
435
-    let gui = Builder::new_from_file("gui.glade");
435
+    let glade_src = include_str!("gui.glade");
436
+    let gui = Builder::new_from_string(glade_src);
436 437
     // La structure qui analyse les connections TCPIP et Séries.
437 438
     let analyzer = RefCell::new(connector::ConnectionAnalyzer::default());
438 439
     // Un booléen qui permet d'arrêter d'écouter une fois que l'on a commencé.

Loading…
Cancel
Save