Properly parse the control byte

Lexicality · Lexicality · commit 2b81fe45e471 · 2024-04-21T14:40:46.000+01:00
For completeness if nothing else, but having this written out will be
useful for writing the encoding part later
diff --git a/src/bin/test_parse.rs b/src/bin/test_parse.rs
@@ -14,6 +14,9 @@ fn do_file(fname: &str) -> Result<(), Box<dyn error::Error>> {
 	let packet: Packet = Packet::parse
 		.parse(Bytes::new(&data[..]))
 		.map_err(|e| e.into_inner().to_string())?;
+
+	println!("{packet:?}");
+
 	match packet {
 		Packet::Long { data, .. } => {
 			let mut data = Bytes::new(data);
diff --git a/src/parse/link_layer.rs b/src/parse/link_layer.rs
@@ -2,28 +2,125 @@
 // Licensed under the EUPL-1.2
 
 use winnow::binary;
+use winnow::binary::bits;
 use winnow::combinator::{alt, cut_err, preceded};
 use winnow::error::{AddContext, ErrMode, ErrorKind, ParserError, StrContext};
 use winnow::prelude::*;
 use winnow::stream::Stream;
 use winnow::Bytes;
 
-use super::error::MBResult;
+use super::error::{MBResult, MBusError};
 
 const LONG_FRAME_HEADER: u8 = 0x68;
 const SHORT_FRAME_HEADER: u8 = 0x10;
 const FRAME_TAIL: u8 = 0x16;
 const ACK_FRAME: u8 = 0xE5;
 
+#[derive(Debug)]
+pub enum PrimaryControlMessage {
+	ResetRemoteLink,
+	ResetUserProcess,
+	SendUserDataConfirmed,
+	SendUserDataUnconfirmed,
+	RequestAccessDemand,
+	RequestLinkStatus,
+	RequestUserData1, // REQ UD1
+	RequestUserData2, // REQ UD2
+}
+
+#[derive(Debug)]
+pub enum SecondaryControlMessage {
+	ACK,
+	NACK,
+	UserData,
+	UserDataUnavailable,
+	Status, // "Status of link or access demand"
+	LinkNotFunctioning,
+	LinkNotImplemented,
+}
+
+#[derive(Debug)]
+pub enum DataFlowControl {
+	Continue, // "further messages are acceptable"
+	Pause,    // "further messages may cause data overflow"
+}
+
+#[derive(Debug)]
+pub enum Control {
+	Primary {
+		frame_count_bit: bool,
+		message: PrimaryControlMessage,
+	},
+	Secondary {
+		acess_demand: bool, // The secondary wants you to send it a REQ UD1 ASAP
+		data_flow_control: DataFlowControl,
+		message: SecondaryControlMessage,
+	},
+}
+
+impl Control {
+	fn parse(input: &mut &Bytes) -> MBResult<Self> {
+		bits::bits::<_, _, MBusError, _, _>((
+			bits::bool
+				.context(StrContext::Label("reserved"))
+				.verify(|v| !v)
+				.void(),
+			bits::bool.context(StrContext::Label("PRM")),
+			bits::bool.context(StrContext::Label("FCB/ACD")),
+			bits::bool.context(StrContext::Label("FCV/DFC")),
+			bits::take::<_, u8, _, _>(4_usize).context(StrContext::Label("function")),
+		))
+		.verify_map(|(_, prm, fcb_acd, fcv_dfc, function)| {
+			Some(if prm {
+				Self::Primary {
+					frame_count_bit: fcb_acd,
+					message: match (fcv_dfc, function) {
+						(false, 0) => PrimaryControlMessage::ResetRemoteLink,
+						(false, 1) => PrimaryControlMessage::ResetUserProcess,
+						(_, 2) => return None, // "Reserved for balanced transmission procedure"
+						(true, 3) => PrimaryControlMessage::SendUserDataConfirmed,
+						(false, 4) => PrimaryControlMessage::SendUserDataUnconfirmed,
+						(false, 8) => PrimaryControlMessage::RequestAccessDemand,
+						(false, 9) => PrimaryControlMessage::RequestLinkStatus,
+						(true, 10) => PrimaryControlMessage::RequestUserData1,
+						(true, 11) => PrimaryControlMessage::RequestUserData2,
+						_ => return None,
+					},
+				}
+			} else {
+				Self::Secondary {
+					acess_demand: fcb_acd,
+					data_flow_control: if fcv_dfc {
+						DataFlowControl::Pause
+					} else {
+						DataFlowControl::Continue
+					},
+					message: match function {
+						0 => SecondaryControlMessage::ACK,
+						1 => SecondaryControlMessage::NACK,
+						8 => SecondaryControlMessage::UserData,
+						9 => SecondaryControlMessage::UserDataUnavailable,
+						11 => SecondaryControlMessage::Status,
+						14 => SecondaryControlMessage::LinkNotFunctioning,
+						15 => SecondaryControlMessage::LinkNotFunctioning,
+						_ => return None,
+					},
+				}
+			})
+		})
+		.parse_next(input)
+	}
+}
+
 #[derive(Debug)]
 pub enum Packet<'a> {
 	Ack,
 	Short {
-		control: u8,
+		control: Control,
 		address: u8,
 	},
 	Long {
-		control: u8,
+		control: Control,
 		address: u8,
 		data: &'a [u8],
 	},
@@ -42,8 +139,11 @@ fn parse_variable<'a>(input: &mut &'a Bytes) -> MBResult<Packet<'a>> {
 		.void()
 		.context(StrContext::Label("frame marker"))
 		.parse_next(input)?;
-	let (control, address) = (
-		binary::u8.context(StrContext::Label("control byte")),
+	let ((control, raw_control), address) = (
+		Control::parse
+			.context(StrContext::Label("control byte"))
+			.with_recognized()
+			.map(|(control, raw_slice)| (control, raw_slice[0])),
 		binary::u8.context(StrContext::Label("address byte")),
 	)
 		.parse_next(input)?;
@@ -70,7 +170,7 @@ fn parse_variable<'a>(input: &mut &'a Bytes) -> MBResult<Packet<'a>> {
 		.copied()
 		.reduce(u8::wrapping_add)
 		.unwrap_or_default()
-		.wrapping_add(control)
+		.wrapping_add(raw_control)
 		.wrapping_add(address);
 
 	if sum != checksum {
@@ -92,15 +192,18 @@ fn parse_variable<'a>(input: &mut &'a Bytes) -> MBResult<Packet<'a>> {
 
 fn parse_fixed<'a>(input: &mut &'a Bytes) -> MBResult<Packet<'a>> {
 	// mbus's fixed length datagrams are 2 bytes long, only control & address
-	let (control, address, checksum, _) = (
-		binary::u8.context(StrContext::Label("control byte")),
+	let ((control, raw_control), address, checksum, _) = (
+		Control::parse
+			.context(StrContext::Label("control byte"))
+			.with_recognized()
+			.map(|(control, raw_slice)| (control, raw_slice[0])),
 		binary::u8.context(StrContext::Label("address byte")),
 		binary::u8.context(StrContext::Label("checksum")),
 		FRAME_TAIL.void().context(StrContext::Label("frame tail")),
 	)
 		.parse_next(input)?;
 
-	let sum = control.wrapping_add(address);
+	let sum = raw_control.wrapping_add(address);
 	if sum != checksum {
 		return Err(
 			ErrMode::from_error_kind(input, ErrorKind::Verify).add_context(
