Cargo.lock

@@ -244,13 +244,11 @@ dependencies = [
  "log",
  "minimq",
  "nb 1.0.0",
- "nom",
  "panic-halt",
  "panic-itm",
  "scpi",
  "smoltcp",
  "stm32h7xx-hal",
- "uom 0.29.0",
 ]
 
 [[package]]
@@ -427,12 +425,6 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
 
-[[package]]
-name = "memchr"
-version = "2.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
-
 [[package]]
 name = "minimq"
 version = "0.1.0"
@@ -466,16 +458,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2178127478ae4ee9be7180bc9c3bffb6354dd7238400db567102f98c413a9f35"
 
-[[package]]
-name = "nom"
-version = "5.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
-dependencies = [
- "memchr",
- "version_check",
-]
-
 [[package]]
 name = "num-integer"
 version = "0.1.43"
@@ -619,7 +601,7 @@ dependencies = [
  "lexical-core",
  "libm",
  "scpi_derive",
- "uom 0.28.0",
+ "uom",
 ]
 
 [[package]]
@@ -798,16 +780,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "uom"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bb593f5252356bfb829112f8fca2d0982d48588d2d6bb5a92553b0dfc4c9aba"
-dependencies = [
- "num-traits",
- "typenum",
-]
-
 [[package]]
 name = "url"
 version = "2.1.1"

Cargo.toml

@@ -18,7 +18,6 @@ embedded-nal = "0.1.0"
 minimq = { git = "https://github.com/quartiq/minimq.git", branch = "master" }
 heapless = "0.5.5"
 arrayvec = { version = "0.5.1", default-features = false, features = [ "array-sizes-33-128", "array-sizes-129-255" ] }
-nom = { version = "5.1.2", default-features = false, features = [] }
 
 # Logging and Panicking
 panic-itm = "0.4.1"
@@ -33,10 +32,17 @@ branch = "issue-4"
 default-features = false
 features = [ "build-info", "unit-frequency", "unit-angle" ]
 
-[dependencies.uom]
+# [dependencies.uom]
-version = "0.29.0"
+# version = "0.29.0"
-default-features = false
+# default-features = false
-features = [ "autoconvert", "f32", "f64", "si" ]
+# features = [
+#     "autoconvert",
+#     "usize", "u8", "u16", "u32", "u64",
+#     "isize", "i8", "i16", "i32", "i64",
+#     "f32", "f64",
+#     "si",
+#     "try-from"
+# ]
 
 # Use below SCPI dependency when need to modify SCPI fork offline
 # [dependencies.scpi]

src/dds.rs

@@ -64,7 +64,7 @@ construct_bitmask!(DDSCFRMask; u32;
 const WRITE_MASK 	:u8 = 0x00;
 const READ_MASK		:u8 = 0x80;
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone)]
 pub enum RAMDestination {
 	Frequency = 0,
 	Phase = 1,
@@ -355,9 +355,14 @@ where
 		assert!(phase_offset >= 0.0 && phase_offset < 360.0);
 		assert!(amp_scale_factor >=0.0 && amp_scale_factor <= 1.0);
 
-		let ftw = self.frequency_to_ftw(f_out);
+		let resolutions :[u64; 3] = [1 << 32, 1 << 16, 1 << 14];
-		let pow = self.degree_to_pow(phase_offset);
+		let ftw = ((resolutions[0] as f64) * f_out / self.f_sys_clk) as u32;
-		let asf = self.amplitude_to_asf(amp_scale_factor);
+		let pow = ((resolutions[1] as f64) * phase_offset / 360.0) as u16;
+		let asf :u16 = if amp_scale_factor == 1.0 {
+			0x3FFF
+		} else {
+			((resolutions[2] as f64) * amp_scale_factor) as u16
+		};
 
 		// Setup configuration registers before writing single tone register
 		self.enable_single_tone_configuration()?;
@@ -385,7 +390,9 @@ where
 		// Setup configuration registers before writing single tone register
 		self.enable_single_tone_configuration()?;
 
-		let ftw = self.frequency_to_ftw(f_out);
+		// Calculate frequency tuning work (FTW)
+		let f_res: u64 = 1 << 32;
+		let ftw = ((f_res as f64) * f_out / self.f_sys_clk) as u32;
 
 		// Read existing amplitude/phase data
 		let mut register: [u8; 8] = [0; 8];
@@ -411,7 +418,9 @@ where
 		// Setup configuration registers before writing single tone register
 		self.enable_single_tone_configuration()?;
 
-		let pow = self.degree_to_pow(phase_offset);
+		// Calculate phase offset work (POW)
+		let phase_res: u64 = 1 << 16;
+		let pow = ((phase_res as f64) * phase_offset / 360.0) as u16;
 
 		// Read existing amplitude/frequency data
 		let mut register: [u8; 8] = [0; 8];
@@ -436,7 +445,12 @@ where
 		self.enable_single_tone_configuration()?;
 
 		// Calculate amplitude_scale_factor (ASF)
-		let asf = self.amplitude_to_asf(amp_scale_factor);
+		let amp_res: u64 = 1 << 14;
+		let asf :u16 = if amp_scale_factor == 1.0 {
+			0x3FFF
+		} else {
+			((amp_res as f64) * amp_scale_factor) as u16
+		};
 
 		// Read existing frequency/phase data
 		let mut register: [u8; 8] = [0; 8];
@@ -482,91 +496,16 @@ where
 		])
 	}
 
-	/*
-	 *	Configure a RAM mode profile, but with RAM data generated by a closure
-	 */
-	pub fn set_ram_profile_with_closure<F>(&mut self, profile: u8, start_addr: u16,
-		ram_dst: RAMDestination, no_dwell_high: bool, zero_crossing: bool,
-		op_mode: RAMOperationMode, playback_rate: f64, f: F) -> Result<(), Error<E>>
-	where
-		F: FnOnce() -> ArrayVec::<[f64; 2048]>
-	{
-		// Check the legality of the profile setup
-		assert!(profile < 7);
-		assert!(start_addr < 1024);
-		let mut vec = f();
-		if (ram_dst != RAMDestination::Polar && ((vec.len() as u16) + start_addr) < 1024) ||
-			((((vec.len()/2) as u16) + start_addr) < 1024) {
-			return Err(Error::DDSRAMError);
-		}
-
-		// TODO: Convert argument into bytes for RAM
-		let mut byte_vec: ArrayVec<[u8; 8192]> = ArrayVec::new();
-		match ram_dst {
-			RAMDestination::Frequency => {
-				for freq in vec.into_iter() {
-					let ftw = self.frequency_to_ftw(freq);
-					byte_vec.push(((ftw >> 24) & 0xFF) as u8);
-					byte_vec.push(((ftw >> 16) & 0xFF) as u8);
-					byte_vec.push(((ftw >>  8) & 0xFF) as u8);
-					byte_vec.push(((ftw >>  0) & 0xFF) as u8);
-				}
-			}
-			RAMDestination::Phase => {
-				for deg in vec.into_iter() {
-					let pow = self.degree_to_pow(deg);
-					byte_vec.push(((pow >>  8) & 0xFF) as u8);
-					byte_vec.push(((pow >>  0) & 0xFF) as u8);
-					byte_vec.push(0);
-					byte_vec.push(0);
-				}
-			}
-			RAMDestination::Amplitude => {
-				for amp in vec.into_iter() {
-					let asf = self.amplitude_to_asf(amp);
-					byte_vec.push(((asf >>  8) & 0xFF) as u8);
-					byte_vec.push(((asf <<  2) & 0xFC) as u8);
-					byte_vec.push(0);
-					byte_vec.push(0);
-				}
-			}
-			RAMDestination::Polar => {
-				// Alternate phase and amplitude
-				let mut phase = true;
-				for pol in vec.into_iter() {
-					if phase {
-						let pow = self.degree_to_pow(pol);
-						byte_vec.push(((pow >>  8) & 0xFF) as u8);
-						byte_vec.push(((pow >>  0) & 0xFF) as u8);
-						phase = false;
-					} else {
-						let asf = self.amplitude_to_asf(pol);
-						byte_vec.push(((asf >>  8) & 0xFF) as u8);
-						byte_vec.push(((asf <<  2) & 0xFC) as u8);
-						phase = true;
-					}
-				}
-				if phase {
-					return Err(Error::DDSRAMError);
-				}
-			}
-		}
-		let data = byte_vec.as_slice();
-		self.set_ram_profile(profile, start_addr, start_addr + (((data.len()/4) - 1) as u16),
-			ram_dst, no_dwell_high, zero_crossing, op_mode, playback_rate, data)
-	}
-
 	/*
 	 *	Configure a RAM mode profile
-	 *	TODO: Possibly remove redundant end_addr parameter.
+	 *
-	 *	This can be inferred by start_addr and data size.
 	 */
 	pub fn set_ram_profile(&mut self, profile: u8, start_addr: u16, end_addr: u16,
 		ram_dst: RAMDestination, no_dwell_high: bool, zero_crossing: bool,
 		op_mode: RAMOperationMode, playback_rate: f64, data: &[u8]
 	) -> Result<(), Error<E>> {
 
-		// Check the legality of the profile setup
+		// Check the legality of this setup
 		assert!(profile < 7);
 		assert!(end_addr >= start_addr);
 		assert!(end_addr < 1024);
@@ -574,8 +513,8 @@ where
 
 		// Calculate address step rate, and check legality
 		let step_rate = (self.f_sys_clk/(4.0 * playback_rate)) as u64;
-		if step_rate == 0 || step_rate > 0xFFFF {
+		if (step_rate == 0 || step_rate > 0xFFFF) {
-			return Err(Error::DDSRAMError);
+			return Err(Error::ParameterError);
 		}
 
 		// Before setting up RAM, disable RAM_ENABLE
@@ -594,7 +533,7 @@ where
 		])?;
 		
 		// Temporarily disable RAM mode while accessing into RAM
-		self.disable_ram_configuration()?;
+		self.disable_ram_configuration();
 		self.write_ram(data)?;
 
 		// Properly configure start_addr and end_addr
@@ -602,26 +541,8 @@ where
 
 	}
 
-	// Calculate ftw (frequency tuning word)
+	// Helper function to write data in RAM
-	fn frequency_to_ftw(&mut self, f_out: f64) -> u32 {
+	// Need address range for data size check
-		let f_res: u64 = 1 << 32;
-		((f_res as f64) * f_out / self.f_sys_clk) as u32
-	}
-
-	// Calculate pow (Phase Offset Word)
-	fn degree_to_pow(&mut self, phase_offset: f64) -> u16 {
-		// Calculate phase offset word (POW)
-		let phase_res: u64 = 1 << 16;
-		((phase_res as f64) * phase_offset / 360.0) as u16
-	}
-
-	// Calculate asf (Amplitude Scale Factor)
-	fn amplitude_to_asf(&mut self, amplitude: f64) -> u16 {
-		let amp_res: u64 = 0x3FFF;
-		((amp_res as f64) * amplitude) as u16
-	}
-
-	// Write data in RAM
 	fn write_ram(&mut self, data: &[u8]) -> Result<(), Error<E>> {
 		let mut vec: ArrayVec<[u8; 8192]> = ArrayVec::new();
 		vec.try_push(0x16)

src/lib.rs

@@ -43,11 +43,10 @@ pub enum Error<E> {
 	DDSCLKError,
 	DDSRAMError,
 	ParameterError,
-	MqttTopicError,
 	MqttCommandError,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum ClockSource {
 	OSC,
 	SMA,
@@ -176,18 +175,7 @@ where
 		}
 	}
 
-	fn set_clock(&mut self, source: ClockSource, frequency: f64, division: u8) -> Result<(), Error<E>> {
+	fn set_clock_source(&mut self, source: ClockSource, frequency: f64) -> Result<(), Error<E>> {
-		// Change clock source through configuration register
-		self.set_clock_source(source)?;
-
-		// Modify the master clock frequency
-		// Prevent redundunt call to change f_ref_clk
-		self.f_master_clk = frequency;
-
-		self.set_clock_division(division)
-	}
-
-	fn set_clock_source(&mut self, source: ClockSource) -> Result<(), Error<E>> {
 		// Change clock source through configuration register
 		match source {
 			ClockSource::OSC => self.config_register.set_configurations(&mut [
@@ -201,15 +189,19 @@ where
 			ClockSource::SMA => self.config_register.set_configurations(&mut [
 				(CFGMask::CLK_SEL0, 1),
 			]),
-		}.map(|_| ())
+		}?;
-	}
 
-	fn set_clock_frequency(&mut self, frequency: f64) -> Result<(), Error<E>> {
+		// Save the new master clock frequency
-		// Update master clock frequency
 		self.f_master_clk = frequency;
 		
-		// Update all DDS f_ref_clk
+		// Calculate reference clock frequency after clock division from configuration register
-		self.set_dds_ref_clk()
+		let f_ref_clk = self.f_master_clk / (self.config_register.get_configuration(CFGMask::DIV) as f64);
+
+		// Update all DDS chips on reference clock frequency
+		for dds_channel in 0..4 {
+			self.dds[dds_channel].set_ref_clk_frequency(f_ref_clk)?;
+		}
+		Ok(())
 	}
 
 	fn set_clock_division(&mut self, division: u8) -> Result<(), Error<E>> {
@@ -226,12 +218,8 @@ where
 			_ => Err(Error::ParameterError),
 		}?;
 
-		self.set_dds_ref_clk()
-	}
-
-	fn set_dds_ref_clk(&mut self) -> Result<(), Error<E>> {
 		// Calculate reference clock frequency after clock division from configuration register
-		let f_ref_clk = self.f_master_clk / (self.config_register.get_configuration(CFGMask::DIV) as f64);
+		let f_ref_clk = self.f_master_clk / (division as f64);
 
 		// Update all DDS chips on reference clock frequency
 		for dds_channel in 0..4 {
@@ -241,47 +229,28 @@ where
 	}
 
 	fn set_channel_attenuation(&mut self, channel: u8, attenuation: f32) -> Result<(), Error<E>> {
-		if channel >= 4 || attenuation < 0.0 || attenuation > 31.5 {
-			return Err(Error::ParameterError);
-		}
 		self.attenuator.set_channel_attenuation(channel, attenuation)
 	}
 
 	fn set_profile(&mut self, profile: u8) -> Result<(), Error<E>> {
-		if profile >= 8 {
-			return Err(Error::ParameterError);
-		}
 		self.config_register.set_configurations(&mut [
 			(CFGMask::PROFILE, profile.into())
 		]).map(|_| ())
 	}
 
 	fn set_channel_single_tone_profile(&mut self, channel: u8, profile: u8, frequency: f64, phase: f64, amplitude: f64) -> Result<(), Error<E>> {
-		if channel >= 4 || profile >= 8 || frequency < 0.0 || phase >= 360.0 ||
-			phase < 0.0 || amplitude < 0.0 || amplitude > 1.0 {
-			return Err(Error::ParameterError);
-		}
 		self.dds[usize::from(channel)].set_single_tone_profile(profile, frequency, phase, amplitude)
 	}
 
 	fn set_channel_single_tone_profile_frequency(&mut self, channel: u8, profile: u8, frequency: f64)-> Result<(), Error<E>> {
-		if channel >= 4 || profile >= 8 || frequency < 0.0 {
-			return Err(Error::ParameterError);
-		}
 		self.dds[usize::from(channel)].set_single_tone_profile_frequency(profile, frequency)
 	}
 
 	fn set_channel_single_tone_profile_phase(&mut self, channel: u8, profile: u8, phase: f64)-> Result<(), Error<E>> {
-		if channel >= 4 || profile >= 8 || phase >= 360.0 || phase < 0.0 {
-			return Err(Error::ParameterError);
-		}
 		self.dds[usize::from(channel)].set_single_tone_profile_phase(profile, phase)
 	}
 
 	fn set_channel_single_tone_profile_amplitude(&mut self, channel: u8, profile: u8, amplitude: f64)-> Result<(), Error<E>> {
-		if channel >= 4 || profile >= 8 || amplitude < 0.0 || amplitude > 1.0 {
-			return Err(Error::ParameterError);
-		}
 		self.dds[usize::from(channel)].set_single_tone_profile_amplitude(profile, amplitude)
 	}
 

src/mqtt_mux.rs

@@ -1,17 +1,4 @@
 use log::info;
-use nom::IResult;
-use nom::combinator::{value, map, map_res, not, opt, all_consuming};
-use nom::sequence::{terminated, preceded, pair, delimited, tuple};
-use nom::bytes::complete::{take, tag, tag_no_case, take_while};
-use nom::character::complete::digit1;
-use nom::character::is_space;
-use nom::branch::alt;
-use nom::number::complete::{float, double};
-
-use uom::si::f64::Frequency;
-use uom::si::frequency::{hertz, kilohertz, megahertz, gigahertz};
-
-use arrayvec::ArrayVec;
 
 use embedded_hal::blocking::spi::Transfer;
 use core::convert::TryInto;
@@ -20,41 +7,27 @@ use crate::ClockSource::*;
 use crate::Urukul;
 use crate::Error;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
-pub enum MqttTopic {
+pub enum MqttCommandType {
-    Reset,
+    // Urukul/Control/Clock/Source
-    Switch(u8),
+    ClockSource(UrukulClockSource),
-    Attenuation(u8),
+    // Urukul/Control/Clock/Division
-    Clock,
+    ClockDivision(u8),
-    ClockSource,
+    // Urukul/Control/ChannelX/Switch
-    ClockFrequency,
+    Switch(u8, bool),
-    ClockDivision,
+    // Urukul/Control/ChannelX/Attenuation
-    SystemClock(u8),
+    Attenuation(u8, f32),
-    Singletone(u8, u8),
+    // Urukul/Control/ChannelX/SystemClock
-    SingletoneFrequency(u8, u8),
+    SystemClock(u8, f64),
-    SingletoneAmplitude(u8, u8),
+    // Urukul/Control/ChannelX/ProfileY/Frequency
-    SingletonePhase(u8, u8),
+    SingleToneFrequency(u8, u8, f64),
-    Profile,
+    // Urukul/Control/ChannelX/ProfileY/Amplitude
+    SingleToneAmplitude(u8, u8, f64),
+    // Urukul/Control/ChannelX/ProfileY/Phase
+    SingleTonePhase(u8, u8, f64),
 }
 
-// Prossible change: Make this enum public to all comm protocol (if any)
+use crate::mqtt_mux::MqttCommandType::*;
-// Such that Urukul accepts the enum directly
-#[derive(Debug, Clone)]
-pub enum MqttCommand {
-    Reset,
-    Switch(u8, bool),
-    Attenuation(u8, f32),
-    Clock(UrukulClockSource, f64, u8),
-    ClockSource(UrukulClockSource),
-    ClockFrequency(f64),
-    ClockDivision(u8),
-    SystemClock(u8, f64),
-    Singletone(u8, u8, f64, f64, f64),
-    SingletoneFrequency(u8, u8, f64),
-    SingletoneAmplitude(u8, u8, f64),
-    SingletonePhase(u8, u8, f64),
-    Profile(u8)
-}
 
 pub struct MqttMux<SPI> {
     urukul: Urukul<SPI>
@@ -67,39 +40,17 @@ impl<SPI, E> MqttMux<SPI> where SPI: Transfer<u8, Error = E> {
         }
     }
 
-    pub fn process_mqtt(&mut self, topic: &str, message: &[u8]) -> Result<(), Error<E>> {
+    pub fn handle_command(&mut self, topic: &str, message: &[u8]) -> Result<(), Error<E>> {
-        let header = self.parse_topic(topic)
+        let command = self.parse(topic, message)?;
-            .map_err(|_| Error::MqttTopicError)?;
-        info!("{:?}", header);
-        let (_, command) = self.parse_message(header, message)
-            .map_err(|_| Error::MqttCommandError)?;
-        info!("{:?}", command);
         self.execute(command)
     }
-/*
+
-    fn parse_header<'a>(&mut self, topic: &'a str) -> IResult<&'a str, MqttTopic> {
+    // MQTT command are not case tolerant
-        preceded(
+    // If the command differs by case, space or delimiter, it is a wrong command
-            alt((
+    // A starting forward slash ("/") is acceptable, as per MQTT standard
-                tag("Urukul/Control/"),
+    // Topic should contain the appropriate command header
-                tag("/Urukul/Control/")
+    // Message should provide the parameter
-            )),
+    fn parse(&mut self, topic: &str, message: &[u8]) -> Result<MqttCommandType, Error<E>> {
-            alt((
-                switch,
-                attenuation,
-                clock,
-                clock_source,
-                clock_frequency,
-                clock_division,
-                singletone,
-                singletone_frequency,
-                singletone_amplitude,
-                singletone_phase,
-                profile
-            ))
-        )(topic)
-    }
-*/
-    fn parse_topic<'a>(&mut self, topic: &'a str) -> Result<MqttTopic, Error<E>> {
         let mut assigned_channel = false;
         let mut assigned_profile = false;
         let mut channel :u8 = 0;
@@ -141,7 +92,7 @@ impl<SPI, E> MqttMux<SPI> where SPI: Transfer<u8, Error = E> {
                                    .ok_or(Error::MqttCommandError)?;
                 },
 
-                _ if (header.starts_with("Profile") && assigned_channel) => {
+                _ if header.starts_with("Profile") => {
                     // MQTT command should only mention profile once appropriately
                     if assigned_profile {
                         return Err(Error::MqttCommandError);
@@ -167,53 +118,27 @@ impl<SPI, E> MqttMux<SPI> where SPI: Transfer<u8, Error = E> {
                                    .ok_or(Error::MqttCommandError)?;
                 },
 
-                "Reset" => {
-                    if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError);
-                    }
-                    return Ok(MqttTopic::Reset);
-                },
-
-                "Switch" => {
-                    // Switch is a channel specific topic
-                    if !(assigned_channel && !assigned_profile) {
-                        return Err(Error::MqttCommandError);
-                    }
-                    return Ok(MqttTopic::Switch(channel));
-                },
-
-                "Attenuation" => {
-                    // Attenuation is a channel specific topic
-                    if !(assigned_channel && !assigned_profile) {
-                        return Err(Error::MqttCommandError);
-                    }
-                    return Ok(MqttTopic::Attenuation(channel));
-                },
-
-                "Clock" => {
-                    if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError);
-                    }
-                    return Ok(MqttTopic::Clock);
-                },
-
                 "Clock/Source" => {
                     // Clock/Source refers to the Urukul clock source
                     // It should be common for all channels and profiles
                     if assigned_channel || assigned_profile {
                         return Err(Error::MqttCommandError);
                     }
-                    return Ok(MqttTopic::ClockSource);
+                    let source_string = core::str::from_utf8(message).unwrap();
-                },
 
-                "Clock/Frequency" => {
+                    return match source_string {
-                    // Clock/Frequency refers to the Urukul clock frequency
+                        _ if source_string.eq_ignore_ascii_case("OSC") => {
-                    // It should be common for all channels and profiles
+                            Ok(ClockSource(OSC))
-                    if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError);
-                    }
-                    return Ok(MqttTopic::ClockFrequency);
                         },
+                        _ if source_string.eq_ignore_ascii_case("SMA") => {
+                            Ok(ClockSource(SMA))
+                        },
+                        _ if source_string.eq_ignore_ascii_case("MMCX") => {
+                            Ok(ClockSource(MMCX))
+                        },
+                        _ => Err(Error::MqttCommandError),
+                    };
+                }
 
                 "Clock/Division" => {
                     // Clock/Division refers to the Urukul clock division
@@ -221,391 +146,52 @@ impl<SPI, E> MqttMux<SPI> where SPI: Transfer<u8, Error = E> {
                     if assigned_channel || assigned_profile {
                         return Err(Error::MqttCommandError);
                     }
-                    return Ok(MqttTopic::ClockDivision);
-                },
 
-                "SystemClock" => {
+                    let division = u8::from_str_radix(core::str::from_utf8(message).unwrap(), 10)
+                        .map_or_else(
+                            |_| Err(Error::MqttCommandError),
+                            |div| if div == 1 || div == 2 || div == 4 {
+                                Ok(div)
+                            } else {
+                                Err(Error::MqttCommandError)
+                            })?;
+                    return Ok(ClockDivision(division));
+                }
+
+                "Switch" => {
+                    // Switch is a channel specific topic
                     if !(assigned_channel && !assigned_profile) {
                         return Err(Error::MqttCommandError);
                     }
-                    return Ok(MqttTopic::SystemClock(channel));
-                }
 
-                "Singletone" => {
+                    let switch_string = core::str::from_utf8(message).unwrap();
-                    if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
-                    }
-                    return Ok(MqttTopic::Singletone(channel, profile));
-                }
 
-                "Singletone/Frequency" => {
+                    return match switch_string {
-                    if !(assigned_channel && assigned_profile) {
+                        _ if switch_string.eq_ignore_ascii_case("on") => {
-                        return Err(Error::MqttCommandError)
+                            Ok(Switch(channel, true))
-                    }
+                        },
-                    return Ok(MqttTopic::SingletoneFrequency(channel, profile));
+                        _ if switch_string.eq_ignore_ascii_case("off") => {
-                }
+                            Ok(Switch(channel, false))
+                        },
+                        _ => Err(Error::MqttCommandError),
+                    };
+                },
 
-                "Singletone/Amplitude" => {
+                // TODO: Cover all commands
-                    if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
-                    }
-                    return Ok(MqttTopic::SingletoneAmplitude(channel, profile));
-                }
-
-                "Singletone/Phase" => {
-                    if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
-                    }
-                    return Ok(MqttTopic::SingletonePhase(channel, profile));
-                }
-
-                "Profile" => {
-                    if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
-                    }
-                    return Ok(MqttTopic::Profile);
-                }
 
                 _ => return Err(Error::MqttCommandError),
             };
         }
     }
 
-    fn parse_message<'a>(&mut self, topic: MqttTopic, message: &'a [u8]) -> IResult<&'a [u8], MqttCommand> {
+    // TODO: Implement this
-        match topic {
+    // Only need to sort the command enum
-            MqttTopic::Reset => Ok((message, MqttCommand::Reset)),
+    // Obviously. This is what a MUX does
-            MqttTopic::Switch(ch) => switch_message(ch, message),
+    fn execute(&mut self, command_type: MqttCommandType) -> Result<(), Error<E>> {
-            MqttTopic::Attenuation(ch) => attenuation_message(ch, message),
+        info!("{:?}", command_type);
-            MqttTopic::Clock => clock_message(message),
+        match command_type {
-            MqttTopic::ClockSource => clock_source_message(message),
+            Switch(channel, status) => self.urukul.set_channel_switch(channel as u32, status),
-            MqttTopic::ClockFrequency => clock_frequency_message(message),
+            _ => Ok(())
-            MqttTopic::ClockDivision => clock_division_message(message),
-            MqttTopic::SystemClock(ch) => system_clock_message(ch, message),
-            MqttTopic::Singletone(ch, prof) => singletone_message(ch, prof, message),
-            MqttTopic::SingletoneFrequency(ch, prof) => singletone_frequency_message(ch, prof, message),
-            MqttTopic::SingletoneAmplitude(ch, prof) => singletone_amplitude_message(ch, prof, message),
-            MqttTopic::SingletonePhase(ch, prof) => singletone_phase_message(ch, prof, message),
-            MqttTopic::Profile => profile_message(message),
-        }
-    }
-
-    fn execute(&mut self, command: MqttCommand) -> Result<(), Error<E>> {
-        match command {
-            MqttCommand::Reset => self.urukul.reset(),
-            MqttCommand::Switch(ch, state) => self.urukul.set_channel_switch(ch.into(), state),
-            MqttCommand::Attenuation(ch, ampl) => self.urukul.set_channel_attenuation(ch, ampl),
-            MqttCommand::Clock(src, freq, div) => self.urukul.set_clock(src, freq, div),
-            MqttCommand::ClockSource(src) => self.urukul.set_clock_source(src),
-            MqttCommand::ClockFrequency(freq) => self.urukul.set_clock_frequency(freq),
-            MqttCommand::ClockDivision(div) => self.urukul.set_clock_division(div),
-            MqttCommand::SystemClock(ch, freq) => self.urukul.set_channel_sys_clk(ch, freq),
-            MqttCommand::Singletone(ch, prof, freq, ampl, deg) => self.urukul.set_channel_single_tone_profile(ch, prof, freq, ampl, deg),
-            MqttCommand::SingletoneFrequency(ch, prof, freq) => self.urukul.set_channel_single_tone_profile_frequency(ch, prof, freq),
-            MqttCommand::SingletoneAmplitude(ch, prof, ampl) => self.urukul.set_channel_single_tone_profile_amplitude(ch, prof, ampl),
-            MqttCommand::SingletonePhase(ch, prof, deg) => self.urukul.set_channel_single_tone_profile_phase(ch, prof, deg),
-            MqttCommand::Profile(prof) => self.urukul.set_profile(prof),
         }
     }
 }
-
-// Topic separator parser
-fn topic_separator<'a>(topic: &'a str) -> IResult<&'a str, ()> {
-    value((), tag("/"))(topic)
-}
-
-// Message separator parser
-fn message_separator(message: &[u8]) -> IResult<&[u8], ()> {
-    value(
-        (),
-        preceded(
-            whitespace,
-            preceded(
-                tag("/"),
-                whitespace
-            )
-        )
-    )(message)
-}
-
-// Read whitespace
-fn whitespace(message: &[u8]) -> IResult<&[u8], ()> {
-    value((), take_while(is_space))(message)
-}
-
-// Reader for uom instances
-fn read_frequency(message: &[u8]) -> IResult<&[u8], f64> {
-    map(
-        pair(
-            double,
-            opt(
-                preceded(
-                    whitespace,
-                    alt((
-                        value(1.0, tag_no_case("hz")),
-                        value(1_000.0, tag_no_case("khz")),
-                        value(1_000_000.0, tag_no_case("mhz")),
-                        value(1_000_000_000.0, tag_no_case("ghz"))
-                    ))
-                )
-            )
-        ),
-        |(freq, unit): (f64, Option<f64>)| {
-            freq * unit.map_or(1.0, |mul| mul)
-        }
-    )(message)
-}
-
-// Parser for Switch Command Message
-fn switch_message(channel: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            alt((
-                value(true, tag("on")),
-                value(false, tag("off"))
-            )),
-            |switch| MqttCommand::Switch(channel, switch)
-        )
-    )(message)
-}
-
-// Parser for Attenuation Command Message
-fn attenuation_message(channel: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            terminated(
-                float,
-                opt(
-                    preceded(
-                        whitespace,
-                        tag_no_case("db")
-                    )
-                )
-            ),
-            |att: f32| MqttCommand::Attenuation(channel, att)
-        )
-    )(message)
-}
-
-// Parser for Clock Source Command Message
-fn clock_source_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        alt((
-            value(MqttCommand::ClockSource(UrukulClockSource::OSC), tag_no_case("OSC")),
-            value(MqttCommand::ClockSource(UrukulClockSource::MMCX), tag_no_case("MMCX")),
-            value(MqttCommand::ClockSource(UrukulClockSource::SMA), tag_no_case("SMA"))
-        ))
-    )(message)
-}
-
-// Parser for Clock Frequency Command Message
-fn clock_frequency_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            read_frequency,
-            |freq: f64| MqttCommand::ClockFrequency(freq)
-        )
-    )(message)
-}
-
-// Parser for Clock Division Command Message
-fn clock_division_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            digit1,
-            |div: &[u8]| MqttCommand::ClockDivision(
-                u8::from_str_radix(
-                    core::str::from_utf8(div).unwrap(),
-                    10
-                ).unwrap()
-            )
-        )
-    )(message)
-}
-
-// Parser for one-command master clock setup message
-fn clock_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            delimited(
-                tag("{"),
-                tuple((
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"source\":"),
-                            preceded(
-                                whitespace,
-                                terminated(
-                                    alt((
-                                        value(UrukulClockSource::OSC, tag_no_case("OSC")),
-                                        value(UrukulClockSource::MMCX, tag_no_case("MMCX")),
-                                        value(UrukulClockSource::SMA, tag_no_case("SMA"))
-                                    )),
-                                    tag(",")
-                                )
-                            )
-                        )
-                    ),
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"frequency\":"),
-                            preceded(
-                                whitespace,
-                                terminated(
-                                    read_frequency,
-                                    tag(",")
-                                )
-                            )
-                        )
-                    ),
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"division\":"),
-                            preceded(
-                                whitespace,
-                                terminated(
-                                    map_res(
-                                        digit1,
-                                        |div: &[u8]| u8::from_str_radix(core::str::from_utf8(div).unwrap(), 10)
-                                    ),
-                                    whitespace
-                                )
-                            )
-                        )
-                    )
-                )),
-                tag("}")
-            ),
-            |(src, freq, div): (UrukulClockSource, f64, u8)| MqttCommand::Clock(src, freq, div)
-        )
-    )(message)
-}
-
-// Message parser for f_sys_clk of any channels
-fn system_clock_message(channel: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            read_frequency,
-            |freq: f64| MqttCommand::SystemClock(channel, freq)
-        )
-    )(message)
-}
-
-// Parser for Singletone frequency Command Message
-fn singletone_frequency_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            read_frequency,
-            |freq: f64| MqttCommand::SingletoneFrequency(channel, profile, freq)
-        )
-    )(message)
-}
-
-// Parser for Singletone AMplitude Command Message
-fn singletone_amplitude_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            double,
-            |ampl: f64| MqttCommand::SingletoneAmplitude(channel, profile, ampl)
-        )
-    )(message)
-}
-
-// Parser for Phase Command Message
-fn singletone_phase_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            terminated(
-                double,
-                opt(
-                    preceded(
-                        whitespace,
-                        tag_no_case("deg")
-                    )
-                )
-            ),
-            |deg: f64| MqttCommand::SingletonePhase(channel, profile, deg)
-        )
-    )(message)
-}
-
-// Parser for one-command singletone profile Command
-// Using JSON like command structure
-// Possible enhancement: further modularize parsing of all separate fields
-fn singletone_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            tuple((
-                preceded(
-                    tag("{"),
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"frequency\":"),
-                            preceded(
-                                whitespace,
-                                read_frequency
-                            )
-                        )
-                    )
-                ),
-                preceded(
-                    tag(","),
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"amplitude\":"),
-                            preceded(
-                                whitespace,
-                                double
-                            )
-                        )
-                    )
-                ),
-                preceded(
-                    tag(","),
-                    preceded(
-                        whitespace,
-                        preceded(
-                            tag("\"phase\":"),
-                            preceded(
-                                whitespace,
-                                terminated(
-                                    double,
-                                    preceded(
-                                        opt(
-                                            preceded(
-                                                whitespace,
-                                                tag_no_case("deg")
-                                            )
-                                        ),
-                                        preceded(
-                                            whitespace,
-                                            tag("}")
-                                        )
-                                    )
-                                )
-                            )
-                        )
-                    )
-                )
-            )),
-            |(freq, ampl, phase): (f64, f64, f64)| MqttCommand::Singletone(channel, profile, freq, ampl, phase)
-        )
-    )(message)
-}
-
-fn profile_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            digit1,
-            |num: &[u8]| {
-                MqttCommand::Profile(
-                    u8::from_str_radix(core::str::from_utf8(num).unwrap(), 10).unwrap()
-                )
-            }
-        )
-    )(message)
-}