@@ -42,7 +42,7 @@ use std::{
42
42
43
43
// TODO: Remove these on the next major ver update.
44
44
pub use crate :: id:: {
45
- id_from_raw, id_is_extended, id_to_canid_t, FdFlags , IdFlags , CANFD_BRS , CANFD_ESI ,
45
+ id_from_raw, id_is_extended, id_to_canid_t, FdFlags , IdFlags , CANFD_BRS , CANFD_ESI , CANFD_FDF ,
46
46
CANFD_MAX_DLEN , CAN_EFF_FLAG , CAN_EFF_MASK , CAN_ERR_FLAG , CAN_ERR_MASK , CAN_MAX_DLEN ,
47
47
CAN_RTR_FLAG , CAN_SFF_MASK , ERR_MASK_ALL , ERR_MASK_NONE ,
48
48
} ;
@@ -1014,7 +1014,7 @@ impl EmbeddedFrame for CanErrorFrame {
1014
1014
}
1015
1015
1016
1016
/// A slice into the actual data.
1017
- /// An error frame can alwaysacess the full 8-byte data payload.
1017
+ /// An error frame can alwaysaccess the full 8-byte data payload.
1018
1018
fn data ( & self ) ->& [ u8 ] {
1019
1019
& self . 0 . data [ ..]
1020
1020
}
@@ -1119,6 +1119,9 @@ const VALID_EXT_DLENGTHS: [usize; 7] = [12, 16, 20, 24, 32, 48, 64];
1119
1119
/// Payload data that is greater than 8 bytes and whose data length does
1120
1120
/// not match a valid CANFD data length is padded with 0 bytes to the
1121
1121
/// next higher valid CANFD data length.
1122
+ ///
1123
+ /// Note:
1124
+ /// - The FDF flag is forced on when created.
1122
1125
#[ derive( Clone , Copy ) ]
1123
1126
pub struct CanFdFrame ( canfd_frame ) ;
1124
1127
@@ -1139,7 +1142,7 @@ impl CanFdFrame {
1139
1142
nif n <=CANFD_MAX_DLEN =>{
1140
1143
let mut frame =canfd_frame_default ( ) ;
1141
1144
frame. can_id = can_id;
1142
- frame. flags = fd_flags. bits ( ) ;
1145
+ frame. flags =( fd_flags | FdFlags :: FDF ) . bits ( ) ;
1143
1146
frame. data [ ..n] . copy_from_slice ( data) ;
1144
1147
frame. len =Self :: next_valid_ext_dlen ( n) as u8 ;
1145
1148
Ok ( Self ( frame) )
@@ -1270,7 +1273,7 @@ impl EmbeddedFrame for CanFdFrame {
1270
1273
1271
1274
/// A slice into the actual data.
1272
1275
///
1273
- ///For normal CAN frames the slice will always be <= 8 bytes in length .
1276
+ ///This should only be one of the valid CAN FD data lengths .
1274
1277
fn data ( & self ) ->& [ u8 ] {
1275
1278
& self . 0 . data [ ..( self . 0 . len as usize ) ]
1276
1279
}
@@ -1310,7 +1313,9 @@ impl Frame for CanFdFrame {
1310
1313
impl Default for CanFdFrame {
1311
1314
/// The default FD frame has all fields and data set to zero, and all flags off.
1312
1315
fn default ( ) ->Self {
1313
- Self ( canfd_frame_default ( ) )
1316
+ let mut frame =canfd_frame_default ( ) ;
1317
+ frame. flags |=CANFD_FDF as u8 ;
1318
+ Self ( frame)
1314
1319
}
1315
1320
}
1316
1321
@@ -1337,14 +1342,16 @@ impl From<CanDataFrame> for CanFdFrame {
1337
1342
1338
1343
let mut fdframe =canfd_frame_default ( ) ;
1339
1344
fdframe. can_id = frame. id_word ( ) ;
1345
+ fdframe. flags =CANFD_FDF as u8 ;
1340
1346
fdframe. len = nas u8 ;
1341
1347
fdframe. data [ ..n] . copy_from_slice ( & frame. data ( ) [ ..n] ) ;
1342
1348
Self ( fdframe)
1343
1349
}
1344
1350
}
1345
1351
1346
1352
impl From < canfd_frame > for CanFdFrame {
1347
- fn from ( frame : canfd_frame ) ->Self {
1353
+ fn from ( mut frame : canfd_frame ) ->Self {
1354
+ frame. flags |=CANFD_FDF as u8 ;
1348
1355
Self ( frame)
1349
1356
}
1350
1357
}
@@ -1685,15 +1692,42 @@ mod tests {
1685
1692
}
1686
1693
1687
1694
#[ test]
1688
- fn test_frame_to_fd ( ) {
1689
- let frame =CanDataFrame :: new ( STD_ID , DATA ) . unwrap ( ) ;
1695
+ fn test_to_fd_frame ( ) {
1696
+ let data_frame =CanDataFrame :: new ( STD_ID , DATA ) . unwrap ( ) ;
1697
+
1698
+ let frame =CanFdFrame :: from ( data_frame) ;
1690
1699
1691
- let frame =CanFdFrame :: from ( frame) ;
1692
1700
assert_eq ! ( STD_ID , frame. id( ) ) ;
1693
1701
assert ! ( frame. is_standard( ) ) ;
1694
1702
assert ! ( frame. is_data_frame( ) ) ;
1695
1703
assert ! ( !frame. is_remote_frame( ) ) ;
1696
1704
assert ! ( !frame. is_error_frame( ) ) ;
1697
- assert_eq ! ( DATA , frame. data( ) ) ;
1705
+ assert ! ( frame. flags( ) . contains( FdFlags :: FDF ) ) ;
1706
+ assert_eq ! ( frame. len( ) , DATA_LEN ) ;
1707
+ assert_eq ! ( frame. data( ) . len( ) , DATA_LEN ) ;
1708
+ assert_eq ! ( frame. data( ) , DATA ) ;
1709
+
1710
+ let fdframe =canfd_frame_default ( ) ;
1711
+ let frame =CanFdFrame :: from ( fdframe) ;
1712
+ assert ! ( frame. flags( ) . contains( FdFlags :: FDF ) ) ;
1713
+ }
1714
+
1715
+ #[ test]
1716
+ fn test_fd_to_data_frame ( ) {
1717
+ let fdframe =CanFdFrame :: new ( STD_ID , DATA ) . unwrap ( ) ;
1718
+ assert ! ( fdframe. flags( ) . contains( FdFlags :: FDF ) ) ;
1719
+
1720
+ let frame =CanDataFrame :: try_from ( fdframe) . unwrap ( ) ;
1721
+
1722
+ assert_eq ! ( STD_ID , frame. id( ) ) ;
1723
+ assert_eq ! ( frame. len( ) , DATA_LEN ) ;
1724
+ assert_eq ! ( frame. data( ) . len( ) , DATA_LEN ) ;
1725
+ assert_eq ! ( frame. data( ) , DATA ) ;
1726
+
1727
+ // Make sure FD flags turned off
1728
+ let mut fdframe =canfd_frame_default ( ) ;
1729
+ crate :: as_bytes_mut ( & mut fdframe) [ ..size_of :: < can_frame > ( ) ]
1730
+ . clone_from_slice ( crate :: as_bytes ( & frame. 0 ) ) ;
1731
+ assert_eq ! ( fdframe. flags, 0 ) ;
1698
1732
}
1699
1733
}