diff --git a/build.rs b/build.rs
index 54a1a41..5c1aa73 100644
--- a/build.rs
+++ b/build.rs
@@ -2,9 +2,9 @@ use std::process::Command;
 
 fn main() {
     Command::new("python3")
-    		.arg("fpga/fpga_config.py")
-    		.spawn()
-    		.expect("FPGA bitstream file cannot be built!");
+        .arg("fpga/fpga_config.py")
+        .spawn()
+        .expect("FPGA bitstream file cannot be built!");
 
     println!("cargo:rerun-if-changed=fpga/fpga_config.py")
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 22512b8..6d05d22 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -3,4 +3,4 @@ channel = "nightly-2020-10-30"
 targets = [
   "thumbv7em-none-eabihf",
 ]
-profile = "minimal"
+profile = "default"
diff --git a/src/attenuator.rs b/src/attenuator.rs
index ca9eaba..95484c9 100644
--- a/src/attenuator.rs
+++ b/src/attenuator.rs
@@ -1,5 +1,5 @@
-use embedded_hal::blocking::spi::Transfer;
 use core::assert;
+use embedded_hal::blocking::spi::Transfer;
 
 use crate::urukul::Error;
 
@@ -10,7 +10,7 @@ pub struct Attenuator<SPI> {
 
 impl<SPI, E> Attenuator<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     pub fn new(spi: SPI) -> Self {
         Attenuator {
@@ -36,16 +36,21 @@ where
             // Set data as attenuation * 2
             // Flip data using bitwise XOR, active low data
             // Data is most signifant attenuator first
-            self.data[3-i] = (((atten * 2.0) as u8) ^ 0xFF) << 2
+            self.data[3 - i] = (((atten * 2.0) as u8) ^ 0xFF) << 2
         }
         let mut clone = self.data.clone();
         // Transmit SPI once to set attenuation
-        self.spi.transfer(&mut clone)
-                        .map(|_| ())
-                        .map_err(|_| Error::AttenuatorError)
+        self.spi
+            .transfer(&mut clone)
+            .map(|_| ())
+            .map_err(|_| Error::AttenuatorError)
     }
 
-    pub fn set_channel_attenuation(&mut self, channel: u8, attenuation: f32) -> Result<(), Error<E>> {
+    pub fn set_channel_attenuation(
+        &mut self,
+        channel: u8,
+        attenuation: f32,
+    ) -> Result<(), Error<E>> {
         assert!(channel < 4);
         let mut arr: [f32; 4] = self.get_attenuation()?;
         arr[channel as usize] = attenuation;
@@ -64,12 +69,12 @@ where
         let mut clone = self.data.clone();
         match self.spi.transfer(&mut clone).map_err(Error::SPI) {
             Ok(arr) => {
-                let mut ret :[f32; 4] = [0.0; 4];
+                let mut ret: [f32; 4] = [0.0; 4];
                 for index in 0..4 {
                     ret[index] = ((arr[3 - index] ^ 0xFC) as f32) / 8.0;
                 }
                 Ok(ret)
-            },
+            }
             Err(e) => Err(e),
         }
     }
@@ -82,16 +87,14 @@ where
         // Test attenuators by getting back the attenuation
         let mut error_count = 0;
         // Convert cached SPI data into attenuation floats
-        let att_floats :[f32; 4] = [
+        let att_floats: [f32; 4] = [
             ((self.data[3] ^ 0xFC) as f32) / 8.0,
             ((self.data[2] ^ 0xFC) as f32) / 8.0,
             ((self.data[1] ^ 0xFC) as f32) / 8.0,
             ((self.data[0] ^ 0xFC) as f32) / 8.0,
         ];
         // Set the attenuation to an arbitrary value, then read the attenuation
-        self.set_attenuation([
-            3.5, 9.5, 20.0, 28.5
-        ])?;
+        self.set_attenuation([3.5, 9.5, 20.0, 28.5])?;
         match self.get_attenuation() {
             Ok(arr) => {
                 if arr[0] != 3.5 {
@@ -106,7 +109,7 @@ where
                 if arr[3] != 28.5 {
                     error_count += 1;
                 }
-            },
+            }
             Err(_) => return Err(Error::AttenuatorError),
         };
         self.set_attenuation(att_floats)?;
@@ -116,7 +119,7 @@ where
 
 impl<SPI, E> Transfer<u8> for Attenuator<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     type Error = Error<E>;
 
diff --git a/src/config.rs b/src/config.rs
index ed483d5..50a8a92 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,16 +1,16 @@
-use smoltcp as net;
-use net::wire::IpCidr;
 use net::wire::EthernetAddress;
+use net::wire::IpCidr;
+use smoltcp as net;
 
 use embedded_nal as nal;
 use nal::IpAddr;
 
-use heapless::{ String, consts::* };
+use heapless::{consts::*, String};
 
-use serde::{ Serialize, Deserialize };
+use serde::{Deserialize, Serialize};
 
-use crate::urukul::ClockSource;
 use crate::flash_store::FlashStore;
+use crate::urukul::ClockSource;
 
 use core::str::FromStr;
 
@@ -72,7 +72,7 @@ pub fn get_net_config(store: &mut FlashStore) -> NetConfig {
         eth_addr: {
             match store.read_str("MAC").unwrap() {
                 Some(mac) => EthernetAddress::from_str(mac).unwrap(),
-                None => EthernetAddress::from_str("AC:6F:7A:DE:D6:C8").unwrap()
+                None => EthernetAddress::from_str("AC:6F:7A:DE:D6:C8").unwrap(),
             }
         },
         broker_ip: {
@@ -84,9 +84,9 @@ pub fn get_net_config(store: &mut FlashStore) -> NetConfig {
         name: {
             match store.read_str("Name").unwrap() {
                 Some(name) => String::from(name),
-                None => String::from("HumpbackDDS")
+                None => String::from("HumpbackDDS"),
             }
-        }
+        },
     };
     log::info!("Net config: {:?}", net_config);
     net_config
diff --git a/src/config_register.rs b/src/config_register.rs
index 879bd87..ae5f85f 100644
--- a/src/config_register.rs
+++ b/src/config_register.rs
@@ -1,6 +1,6 @@
-use embedded_hal::blocking::spi::Transfer;
 use crate::urukul::Error;
 use core::mem::size_of;
+use embedded_hal::blocking::spi::Transfer;
 
 // Bitmasks for CFG
 construct_bitmask!(CFGMask; u32;
@@ -23,7 +23,7 @@ construct_bitmask!(StatusMask; u32;
     SMP_ERR,      4,     4,
     PLL_LOCK,     8,     4,
     IFC_MODE,     12,    4,
-    PROTO_KEY,    16,    7    
+    PROTO_KEY,    16,    7
 );
 
 pub struct ConfigRegister<SPI> {
@@ -33,13 +33,10 @@ pub struct ConfigRegister<SPI> {
 
 impl<SPI, E> ConfigRegister<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     pub fn new(spi: SPI) -> Self {
-        ConfigRegister {
-            spi,
-            data: 0,
-        }
+        ConfigRegister { spi, data: 0 }
     }
 
     /*
@@ -47,16 +44,16 @@ where
      * Return status
      */
     fn set_all_configurations(&mut self) -> Result<u32, Error<E>> {
-        match self.spi.transfer(&mut [
-            ((self.data & 0x00FF0000) >> 16) as u8,
-            ((self.data & 0x0000FF00) >>  8) as u8,
-            ((self.data & 0x000000FF) >>  0) as u8,
-        ]).map_err(Error::SPI) {
-            Ok(arr) => Ok(
-                ((arr[0] as u32) << 16) |
-                ((arr[1] as u32) <<  8) |
-                arr[2] as u32
-            ),
+        match self
+            .spi
+            .transfer(&mut [
+                ((self.data & 0x00FF0000) >> 16) as u8,
+                ((self.data & 0x0000FF00) >> 8) as u8,
+                ((self.data & 0x000000FF) >> 0) as u8,
+            ])
+            .map_err(Error::SPI)
+        {
+            Ok(arr) => Ok(((arr[0] as u32) << 16) | ((arr[1] as u32) << 8) | arr[2] as u32),
             Err(e) => Err(e),
         }
     }
@@ -64,8 +61,8 @@ where
     /*
      * Set configuration bits according to supplied configs
      * Return status
-     */    
-    pub fn set_configurations(&mut self, configs: &mut[(CFGMask, u32)]) -> Result<u32, Error<E>> {
+     */
+    pub fn set_configurations(&mut self, configs: &mut [(CFGMask, u32)]) -> Result<u32, Error<E>> {
         for config in configs.into_iter() {
             config.0.set_data_by_arg(&mut self.data, config.1)
         }
@@ -113,7 +110,7 @@ where
 
 impl<SPI, E> Transfer<u8> for ConfigRegister<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     type Error = Error<E>;
 
@@ -121,4 +118,3 @@ where
         self.spi.transfer(words).map_err(Error::SPI)
     }
 }
-
diff --git a/src/cpld.rs b/src/cpld.rs
index 3f00e5a..5b3cabc 100644
--- a/src/cpld.rs
+++ b/src/cpld.rs
@@ -1,10 +1,7 @@
-use crate::urukul::Error;
 use crate::spi_slave::Parts;
+use crate::urukul::Error;
 
-use embedded_hal::{
-    digital::v2::OutputPin,
-    blocking::spi::Transfer,
-};
+use embedded_hal::{blocking::spi::Transfer, digital::v2::OutputPin};
 
 use core::cell;
 
@@ -35,20 +32,25 @@ where
         match chip & (1 << 0) {
             0 => self.chip_select.0.set_low(),
             _ => self.chip_select.0.set_high(),
-        }.map_err(|_| Error::CSError)?;
+        }
+        .map_err(|_| Error::CSError)?;
         match chip & (1 << 1) {
             0 => self.chip_select.1.set_low(),
             _ => self.chip_select.1.set_high(),
-        }.map_err(|_| Error::CSError)?;
+        }
+        .map_err(|_| Error::CSError)?;
         match chip & (1 << 2) {
             0 => self.chip_select.2.set_low(),
             _ => self.chip_select.2.set_high(),
-        }.map_err(|_| Error::CSError)?;
+        }
+        .map_err(|_| Error::CSError)?;
         Ok(())
     }
 
     pub(crate) fn issue_io_update(&mut self) -> Result<(), Error<E>> {
-        self.io_update.set_high().map_err(|_| Error::IOUpdateError)?;
+        self.io_update
+            .set_high()
+            .map_err(|_| Error::IOUpdateError)?;
         // I/O Update minimum pulse width: 1 SYNC_CLK cycle
         // 1 SYNC_CLK cycle = 4 REF_CLK cycle, where f_ref_clk is at least 3.2 MHz
         // Therefore the maximum required pulse length is 1.25 us,
@@ -69,20 +71,25 @@ where
     type Error = Error<E>;
 
     fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
-        self.data.try_borrow_mut().map_err(|_| Error::GetRefMutDataError)?.spi.transfer(words).map_err(Error::SPI)
+        self.data
+            .try_borrow_mut()
+            .map_err(|_| Error::GetRefMutDataError)?
+            .spi
+            .transfer(words)
+            .map_err(Error::SPI)
     }
 }
 
-impl<SPI, CS0, CS1, CS2, GPIO, E> CPLD<SPI, CS0, CS1, CS2, GPIO> where
+impl<SPI, CS0, CS1, CS2, GPIO, E> CPLD<SPI, CS0, CS1, CS2, GPIO>
+where
     SPI: Transfer<u8, Error = E>,
     CS0: OutputPin,
     CS1: OutputPin,
     CS2: OutputPin,
-    GPIO: OutputPin
+    GPIO: OutputPin,
 {
     // Constructor for CPLD
     pub fn new(spi: SPI, chip_select: (CS0, CS1, CS2), io_update: GPIO) -> Self {
-
         // Init data
         let data = CPLDData {
             spi,
diff --git a/src/dds.rs b/src/dds.rs
index 972f55d..e12db17 100644
--- a/src/dds.rs
+++ b/src/dds.rs
@@ -1,9 +1,9 @@
-use embedded_hal::blocking::spi::Transfer;
 use crate::urukul::Error;
-use core::mem::size_of;
 use core::convert::TryInto;
-use heapless::Vec;
+use core::mem::size_of;
+use embedded_hal::blocking::spi::Transfer;
 use heapless::consts::*;
+use heapless::Vec;
 use log::debug;
 
 /*
@@ -48,7 +48,7 @@ construct_bitmask!(DDSCFRMask; u32;
     DIGITAL_RAMP_NO_DWELL_HIGH,     18 +32,    1,
     DIGITAL_RAMP_ENABLE,            19 +32,    1,
     DIGITAL_RAMP_DEST,              20 +32,    2,
-    SYNC_CLK_ENABLE,                22 +32,    1,    
+    SYNC_CLK_ENABLE,                22 +32,    1,
     INT_IO_UPDATE_ACTIVE,           23 +32,    1,
     EN_AMP_SCALE_SINGLE_TONE_PRO,   24 +32,    1,
 
@@ -63,8 +63,8 @@ construct_bitmask!(DDSCFRMask; u32;
     DRV0,                           28 +64,    2
 );
 
-const WRITE_MASK   :u8 = 0x00;
-const READ_MASK    :u8 = 0x80;
+const WRITE_MASK: u8 = 0x00;
+const READ_MASK: u8 = 0x80;
 
 #[link_section = ".sram2.ram"]
 static mut RAM_VEC: Vec<u8, U8192> = Vec(heapless::i::Vec::new());
@@ -90,12 +90,12 @@ pub struct DDS<SPI> {
     spi: SPI,
     f_ref_clk: f64,
     f_sys_clk: f64,
-    ram_dest: RAMDestination
+    ram_dest: RAMDestination,
 }
 
 impl<SPI, E> DDS<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     pub fn new(spi: SPI, f_ref_clk: f64) -> Self {
         DDS {
@@ -109,7 +109,7 @@ where
 
 impl<SPI, E> Transfer<u8> for DDS<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     type Error = Error<E>;
 
@@ -118,18 +118,15 @@ where
     }
 }
 
-
 impl<SPI, E> DDS<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
     /*
      *  Implement init: Set SDIO to be input only, using LSB first
      */
     pub fn init(&mut self) -> Result<(), Error<E>> {
-        match self.write_register(0x00, &mut [
-            0x00, 0x00, 0x00, 0x02
-        ]) {
+        match self.write_register(0x00, &mut [0x00, 0x00, 0x00, 0x02]) {
             Ok(_) => Ok(()),
             Err(e) => Err(e),
         }
@@ -182,9 +179,7 @@ where
             // Reset PLL lock before re-enabling it
             (DDSCFRMask::PFD_RESET, 1),
         ])?;
-        self.set_configurations(&mut [
-            (DDSCFRMask::PFD_RESET, 0),
-        ])?;
+        self.set_configurations(&mut [(DDSCFRMask::PFD_RESET, 0)])?;
         self.f_sys_clk = self.f_ref_clk * (divider as f64);
         Ok(())
     }
@@ -204,13 +199,13 @@ where
             // Acquire N-divider, to adjust VCO if necessary
             (DDSCFRMask::N, 0),
             // Acquire REF_CLK divider bypass
-            (DDSCFRMask::REFCLK_IN_DIV_BYPASS, 0)
+            (DDSCFRMask::REFCLK_IN_DIV_BYPASS, 0),
         ];
 
         self.get_configurations(&mut configuration_queries)?;
         if configuration_queries[0].1 == 1 {
             // Recalculate sys_clk
-            let divider :f64 = configuration_queries[1].1.into();
+            let divider: f64 = configuration_queries[1].1.into();
             let f_sys_clk = self.f_ref_clk * divider;
             // Adjust VCO
             match self.get_VCO_no(f_sys_clk, divider as u8) {
@@ -221,24 +216,20 @@ where
                         // Reset PLL lock before re-enabling it
                         (DDSCFRMask::PFD_RESET, 1),
                     ])?;
-                    self.set_configurations(&mut [
-                        (DDSCFRMask::PFD_RESET, 0),
-                    ])?;
+                    self.set_configurations(&mut [(DDSCFRMask::PFD_RESET, 0)])?;
                     // Update f_sys_clk from recalculation
                     self.f_sys_clk = f_sys_clk;
                     Ok(())
-                },
+                }
                 Err(_) => {
                     // Forcibly turn off PLL, enable default clk tree (divide by 2)
                     self.enable_divided_ref_clk()
                 }
             }
-        }
-        else if configuration_queries[2].1 == 0 {
+        } else if configuration_queries[2].1 == 0 {
             self.f_sys_clk = self.f_ref_clk / 2.0;
             Ok(())
-        }
-        else {
+        } else {
             self.f_sys_clk = self.f_ref_clk;
             Ok(())
         }
@@ -269,7 +260,7 @@ where
     fn get_VCO_no(&mut self, f_sys_clk: f64, divider: u8) -> Result<u8, Error<E>> {
         // Select a VCO
         if divider == 1 {
-            Ok(6)    // Bypass PLL if no frequency division needed
+            Ok(6) // Bypass PLL if no frequency division needed
         } else if f_sys_clk > 1_150_000_000.0 {
             Err(Error::DDSCLKError)
         } else if f_sys_clk > 820_000_000.0 {
@@ -285,7 +276,7 @@ where
         } else if f_sys_clk > 370_000_000.0 {
             Ok(0)
         } else {
-            Ok(7)    // Bypass PLL if f_sys_clk is too low
+            Ok(7) // Bypass PLL if f_sys_clk is too low
         }
     }
 
@@ -300,16 +291,28 @@ where
         self.read_register(0x01, &mut cfr_reg[4..8])?;
         self.read_register(0x02, &mut cfr_reg[8..12])?;
         Ok([
-            (cfr_reg[0] as u32) << 24 | (cfr_reg[1] as u32) << 16 | (cfr_reg[2] as u32) << 8 | (cfr_reg[3] as u32),
-            (cfr_reg[4] as u32) << 24 | (cfr_reg[5] as u32) << 16 | (cfr_reg[6] as u32) << 8 | (cfr_reg[7] as u32),
-            (cfr_reg[8] as u32) << 24 | (cfr_reg[9] as u32) << 16 | (cfr_reg[10] as u32) << 8 | (cfr_reg[11] as u32)
+            (cfr_reg[0] as u32) << 24
+                | (cfr_reg[1] as u32) << 16
+                | (cfr_reg[2] as u32) << 8
+                | (cfr_reg[3] as u32),
+            (cfr_reg[4] as u32) << 24
+                | (cfr_reg[5] as u32) << 16
+                | (cfr_reg[6] as u32) << 8
+                | (cfr_reg[7] as u32),
+            (cfr_reg[8] as u32) << 24
+                | (cfr_reg[9] as u32) << 16
+                | (cfr_reg[10] as u32) << 8
+                | (cfr_reg[11] as u32),
         ])
     }
 
     /*
      *  Get a set of configurations using DDSCFRMask
      */
-    pub fn get_configurations<'w>(&mut self, mask_pairs: &'w mut[(DDSCFRMask, u32)]) -> Result<&'w [(DDSCFRMask, u32)], Error<E>> {
+    pub fn get_configurations<'w>(
+        &mut self,
+        mask_pairs: &'w mut [(DDSCFRMask, u32)],
+    ) -> Result<&'w [(DDSCFRMask, u32)], Error<E>> {
         let data_array = self.get_all_configurations()?;
         for index in 0..mask_pairs.len() {
             mask_pairs[index].1 = match mask_pairs[index].0.get_shift() {
@@ -327,12 +330,15 @@ where
      */
     fn set_all_configurations(&mut self, data_array: [u32; 3]) -> Result<(), Error<E>> {
         for register in 0x00..=0x02 {
-            self.write_register(register, &mut [
-                ((data_array[register as usize] >> 24) & 0xFF) as u8,
-                ((data_array[register as usize] >> 16) & 0xFF) as u8,
-                ((data_array[register as usize] >> 8 ) & 0xFF) as u8,
-                ((data_array[register as usize] >> 0 ) & 0xFF) as u8
-            ])?;
+            self.write_register(
+                register,
+                &mut [
+                    ((data_array[register as usize] >> 24) & 0xFF) as u8,
+                    ((data_array[register as usize] >> 16) & 0xFF) as u8,
+                    ((data_array[register as usize] >> 8) & 0xFF) as u8,
+                    ((data_array[register as usize] >> 0) & 0xFF) as u8,
+                ],
+            )?;
         }
         Ok(())
     }
@@ -340,17 +346,28 @@ where
     /*
      *  Set a set of configurations using DDSCFRMask
      */
-    pub fn set_configurations(&mut self, mask_pairs: &mut[(DDSCFRMask, u32)]) -> Result<(), Error<E>> {
+    pub fn set_configurations(
+        &mut self,
+        mask_pairs: &mut [(DDSCFRMask, u32)],
+    ) -> Result<(), Error<E>> {
         let mut data_array = self.get_all_configurations()?;
         for index in 0..mask_pairs.len() {
             // Reject any attempt to rewrite LSB_FIRST and SDIO_INPUT_ONLY
-            if mask_pairs[index].0 == DDSCFRMask::LSB_FIRST || mask_pairs[index].0 == DDSCFRMask::SDIO_IN_ONLY {
+            if mask_pairs[index].0 == DDSCFRMask::LSB_FIRST
+                || mask_pairs[index].0 == DDSCFRMask::SDIO_IN_ONLY
+            {
                 continue;
             }
             match mask_pairs[index].0.get_shift() {
-                0..=31 => mask_pairs[index].0.set_data_by_arg(&mut data_array[0], mask_pairs[index].1),
-                32..=63 => mask_pairs[index].0.set_data_by_arg(&mut data_array[1], mask_pairs[index].1),
-                64..=95 => mask_pairs[index].0.set_data_by_arg(&mut data_array[2], mask_pairs[index].1),
+                0..=31 => mask_pairs[index]
+                    .0
+                    .set_data_by_arg(&mut data_array[0], mask_pairs[index].1),
+                32..=63 => mask_pairs[index]
+                    .0
+                    .set_data_by_arg(&mut data_array[1], mask_pairs[index].1),
+                64..=95 => mask_pairs[index]
+                    .0
+                    .set_data_by_arg(&mut data_array[2], mask_pairs[index].1),
                 _ => panic!("Invalid DDSCFRMask!"),
             };
         }
@@ -366,12 +383,17 @@ where
      *  Frequency: Must be non-negative
      *  Amplitude: In a scale from 0 to 1, taking float
      */
-    pub fn set_single_tone_profile(&mut self, profile: u8, f_out: f64, phase_offset: f64, amp_scale_factor: f64) -> Result<(), Error<E>> {
-
+    pub fn set_single_tone_profile(
+        &mut self,
+        profile: u8,
+        f_out: f64,
+        phase_offset: f64,
+        amp_scale_factor: f64,
+    ) -> Result<(), Error<E>> {
         assert!(profile < 8);
         assert!(f_out >= 0.0);
         assert!(phase_offset >= 0.0 && phase_offset < 360.0);
-        assert!(amp_scale_factor >=0.0 && amp_scale_factor <= 1.0);
+        assert!(amp_scale_factor >= 0.0 && amp_scale_factor <= 1.0);
 
         let ftw = self.frequency_to_ftw(f_out);
         let pow = self.degree_to_pow(phase_offset);
@@ -379,44 +401,44 @@ where
 
         // Setup configuration registers before writing single tone register
         self.enable_single_tone_configuration()?;
-        
+
         // Transfer single tone profile data
-        self.write_register(0x0E + profile, &mut [
-            ((asf >> 8 ) & 0xFF) as u8,
-            ((asf >> 0 ) & 0xFF) as u8,
-            ((pow >> 8 ) & 0xFF) as u8,
-            ((pow >> 0 ) & 0xFF) as u8,
-            ((ftw >> 24) & 0xFF) as u8,
-            ((ftw >> 16) & 0xFF) as u8,
-            ((ftw >> 8 ) & 0xFF) as u8,
-            ((ftw >> 0 ) & 0xFF) as u8,
-        ])
+        self.write_register(
+            0x0E + profile,
+            &mut [
+                ((asf >> 8) & 0xFF) as u8,
+                ((asf >> 0) & 0xFF) as u8,
+                ((pow >> 8) & 0xFF) as u8,
+                ((pow >> 0) & 0xFF) as u8,
+                ((ftw >> 24) & 0xFF) as u8,
+                ((ftw >> 16) & 0xFF) as u8,
+                ((ftw >> 8) & 0xFF) as u8,
+                ((ftw >> 0) & 0xFF) as u8,
+            ],
+        )
     }
 
     /*
      *  Getter function for single tone profiles
      */
     pub fn get_single_tone_profile(&mut self, profile: u8) -> Result<(f64, f64, f64), Error<E>> {
-
         assert!(profile < 8);
 
         let mut profile_content: [u8; 8] = [0; 8];
         self.read_register(0x0E + profile, &mut profile_content)?;
 
         // Convert ftw, pow and asf to f_out, phase and amplitude factor
-        let ftw: u64 = (profile_content[4] as u64) << 24 |
-                       (profile_content[5] as u64) << 16 |
-                       (profile_content[6] as u64) <<  8 |
-                       (profile_content[7] as u64);
-        let f_out: f64 = ((ftw as f64)/(((1_u64) << 32) as f64))*self.f_sys_clk;
+        let ftw: u64 = (profile_content[4] as u64) << 24
+            | (profile_content[5] as u64) << 16
+            | (profile_content[6] as u64) << 8
+            | (profile_content[7] as u64);
+        let f_out: f64 = ((ftw as f64) / (((1_u64) << 32) as f64)) * self.f_sys_clk;
 
-        let pow: u64 = (profile_content[2] as u64) <<  8 |
-                       (profile_content[3] as u64);
-        let phase: f64 = ((pow as f64)/(((1_u64) << 16) as f64))*360.0;
+        let pow: u64 = (profile_content[2] as u64) << 8 | (profile_content[3] as u64);
+        let phase: f64 = ((pow as f64) / (((1_u64) << 16) as f64)) * 360.0;
 
-        let asf: u64 = ((profile_content[0] & 0x3F) as u64) <<  8 |
-                       (profile_content[1] as u64);
-        let amplitude: f64 = (asf as f64)/(((1_u64) << 14) as f64);
+        let asf: u64 = ((profile_content[0] & 0x3F) as u64) << 8 | (profile_content[1] as u64);
+        let amplitude: f64 = (asf as f64) / (((1_u64) << 14) as f64);
 
         Ok((f_out, phase, amplitude))
     }
@@ -426,8 +448,11 @@ where
      *  Frequency: Must be non-negative
      *  Keep other field unchanged in the register
      */
-    pub fn set_single_tone_profile_frequency(&mut self, profile: u8, f_out: f64) -> Result<(), Error<E>> {
-
+    pub fn set_single_tone_profile_frequency(
+        &mut self,
+        profile: u8,
+        f_out: f64,
+    ) -> Result<(), Error<E>> {
         // Setup configuration registers before writing single tone register
         self.enable_single_tone_configuration()?;
 
@@ -440,8 +465,8 @@ where
         // Overwrite FTW
         register[4] = ((ftw >> 24) & 0xFF) as u8;
         register[5] = ((ftw >> 16) & 0xFF) as u8;
-        register[6] = ((ftw >>  8) & 0xFF) as u8;
-        register[7] = ((ftw >>  0) & 0xFF) as u8;
+        register[6] = ((ftw >> 8) & 0xFF) as u8;
+        register[7] = ((ftw >> 0) & 0xFF) as u8;
 
         // Update FTW by writing back the register
         self.write_register(0x0E + profile, &mut register)
@@ -452,8 +477,11 @@ where
      *  Phase: Expressed in positive degree, i.e. [0.0, 360.0)
      *  Keep other field unchanged in the register
      */
-    pub fn set_single_tone_profile_phase(&mut self, profile: u8, phase_offset: f64) -> Result<(), Error<E>> {
-
+    pub fn set_single_tone_profile_phase(
+        &mut self,
+        profile: u8,
+        phase_offset: f64,
+    ) -> Result<(), Error<E>> {
         // Setup configuration registers before writing single tone register
         self.enable_single_tone_configuration()?;
 
@@ -464,8 +492,8 @@ where
         self.read_register(0x0E + profile, &mut register)?;
 
         // Overwrite POW
-        register[2] = ((pow >>  8) & 0xFF) as u8;
-        register[3] = ((pow >>  0) & 0xFF) as u8;
+        register[2] = ((pow >> 8) & 0xFF) as u8;
+        register[3] = ((pow >> 0) & 0xFF) as u8;
 
         // Update POW by writing back the register
         self.write_register(0x0E + profile, &mut register)
@@ -476,8 +504,11 @@ where
      *  Amplitude: In a scale from 0 to 1, taking float
      *  Keep other field unchanged in the register
      */
-    pub fn set_single_tone_profile_amplitude(&mut self, profile: u8, amp_scale_factor: f64) -> Result<(), Error<E>> {
-
+    pub fn set_single_tone_profile_amplitude(
+        &mut self,
+        profile: u8,
+        amp_scale_factor: f64,
+    ) -> Result<(), Error<E>> {
         // Setup configuration registers before writing single tone register
         self.enable_single_tone_configuration()?;
 
@@ -489,8 +520,8 @@ where
         self.read_register(0x0E + profile, &mut register)?;
 
         // Overwrite POW
-        register[0] = ((asf >>  8) & 0xFF) as u8;
-        register[1] = ((asf >>  0) & 0xFF) as u8;
+        register[0] = ((asf >> 8) & 0xFF) as u8;
+        register[1] = ((asf >> 0) & 0xFF) as u8;
 
         // Update POW by writing back the register
         self.write_register(0x0E + profile, &mut register)
@@ -499,16 +530,13 @@ where
     // Helper function to switch into single tone mode
     // Need to setup configuration registers before writing single tone register
     fn enable_single_tone_configuration(&mut self) -> Result<(), Error<E>> {
-        
         self.set_configurations(&mut [
             (DDSCFRMask::RAM_ENABLE, 0),
             (DDSCFRMask::DIGITAL_RAMP_ENABLE, 0),
             (DDSCFRMask::OSK_ENABLE, 0),
             (DDSCFRMask::PARALLEL_DATA_PORT_ENABLE, 0),
         ])?;
-        self.set_configurations(&mut [
-            (DDSCFRMask::EN_AMP_SCALE_SINGLE_TONE_PRO, 1),
-        ])
+        self.set_configurations(&mut [(DDSCFRMask::EN_AMP_SCALE_SINGLE_TONE_PRO, 1)])
     }
 
     // Helper function to configure the default frequency in the FTW register (0x07)
@@ -531,19 +559,18 @@ where
     pub fn get_default_ftw(&mut self) -> Result<f64, Error<E>> {
         let mut ftw_bytes: [u8; 4] = [0; 4];
         self.read_register(0x07, &mut ftw_bytes)?;
-        let ftw: u64 = (ftw_bytes[0] as u64) << 24 |
-                       (ftw_bytes[1] as u64) << 16 |
-                       (ftw_bytes[2] as u64) <<  8 |
-                       (ftw_bytes[3] as u64);
-        Ok(((ftw as f64)/(((1_u64) << 32) as f64))*self.f_sys_clk)
+        let ftw: u64 = (ftw_bytes[0] as u64) << 24
+            | (ftw_bytes[1] as u64) << 16
+            | (ftw_bytes[2] as u64) << 8
+            | (ftw_bytes[3] as u64);
+        Ok(((ftw as f64) / (((1_u64) << 32) as f64)) * self.f_sys_clk)
     }
 
     pub fn get_default_asf(&mut self) -> Result<f64, Error<E>> {
         let mut asf_register: [u8; 4] = [0; 4];
         self.read_register(0x09, &mut asf_register)?;
-        let asf: u64 = ((asf_register[2] as u64) << 6) |
-                       ((asf_register[3] as u64) >> 2);
-        Ok((asf as f64)/(((1_u64) << 14) as f64))
+        let asf: u64 = ((asf_register[2] as u64) << 6) | ((asf_register[3] as u64) >> 2);
+        Ok((asf as f64) / (((1_u64) << 14) as f64))
     }
 
     // Helper function to switch into RAM mode
@@ -558,38 +585,44 @@ where
     // Helper function to switch out of RAM mode
     // Need to setup configuration registers before writing into RAM profile register
     fn disable_ram_configuration(&mut self) -> Result<(), Error<E>> {
-        self.set_configurations(&mut [
-            (DDSCFRMask::RAM_ENABLE, 0),
-        ])
+        self.set_configurations(&mut [(DDSCFRMask::RAM_ENABLE, 0)])
     }
 
     // Setup a RAM profile
-    pub fn set_up_ram_profile(&mut self, profile: u8, start_addr: u16,
-        end_addr: u16, no_dwell_high: bool, zero_crossing: bool,
-        op_mode: RAMOperationMode, ramp_rate: u16
-    )-> Result<(), Error<E>>
-    {
+    pub fn set_up_ram_profile(
+        &mut self,
+        profile: u8,
+        start_addr: u16,
+        end_addr: u16,
+        no_dwell_high: bool,
+        zero_crossing: bool,
+        op_mode: RAMOperationMode,
+        ramp_rate: u16,
+    ) -> Result<(), Error<E>> {
         assert!(profile <= 7);
         assert!(end_addr >= start_addr);
         assert!(end_addr < 1024);
 
         self.enable_ram_configuration(self.ram_dest)?;
 
-        self.write_register(0x0E + profile, &mut [
-            0x00,
-            ((ramp_rate >> 8) & 0xFF).try_into().unwrap(),
-            ((ramp_rate >> 0) & 0xFF).try_into().unwrap(),
-            ((end_addr >> 2) & 0xFF).try_into().unwrap(),
-            ((end_addr & 0x3) << 6).try_into().unwrap(),
-            ((start_addr >> 2) & 0xFF).try_into().unwrap(),
-            ((start_addr & 0x3) << 6).try_into().unwrap(),
-            ((no_dwell_high as u8) << 5) | ((zero_crossing as u8) << 3) | (op_mode as u8)
-        ])
+        self.write_register(
+            0x0E + profile,
+            &mut [
+                0x00,
+                ((ramp_rate >> 8) & 0xFF).try_into().unwrap(),
+                ((ramp_rate >> 0) & 0xFF).try_into().unwrap(),
+                ((end_addr >> 2) & 0xFF).try_into().unwrap(),
+                ((end_addr & 0x3) << 6).try_into().unwrap(),
+                ((start_addr >> 2) & 0xFF).try_into().unwrap(),
+                ((start_addr & 0x3) << 6).try_into().unwrap(),
+                ((no_dwell_high as u8) << 5) | ((zero_crossing as u8) << 3) | (op_mode as u8),
+            ],
+        )
     }
 
     pub fn get_ram_profile(&mut self, profile: u8) -> Result<(u16, u16, u16, u8), Error<E>> {
         assert!(profile <= 7);
-        
+
         let mut buffer: [u8; 8] = [0; 8];
         self.read_register(0x0E + profile, &mut buffer)?;
         let start = u16::from_be_bytes([buffer[5], buffer[6]]) >> 6;
@@ -627,29 +660,42 @@ where
 
     // Write RAM bytes into DDS channel
     // Assume profile 7 is selected by the CPLD in prior
-    pub unsafe fn commit_ram_buffer(&mut self, start_addr: u16, ram_dest: RAMDestination) -> Result<(), Error<E>> {
-        let ram_size = ((RAM_VEC.len() - 1) as u16)/4;
-        if RAM_VEC.len() == 0 || RAM_VEC[0] != 0x16 ||
-            (start_addr + ram_size) > 1024 || start_addr >= 1024 {
-            return Err(Error::DDSRAMError)
+    pub unsafe fn commit_ram_buffer(
+        &mut self,
+        start_addr: u16,
+        ram_dest: RAMDestination,
+    ) -> Result<(), Error<E>> {
+        let ram_size = ((RAM_VEC.len() - 1) as u16) / 4;
+        if RAM_VEC.len() == 0
+            || RAM_VEC[0] != 0x16
+            || (start_addr + ram_size) > 1024
+            || start_addr >= 1024
+        {
+            return Err(Error::DDSRAMError);
         }
 
         let end_addr: [u8; 2] = ((ram_size + start_addr - 1) << 6).to_be_bytes();
 
         // Use profile 7 to setup a temperory RAM profile
         self.enable_ram_configuration(ram_dest.clone())?;
-        self.write_register(0x15, &mut [
-            0x00,
-            0x00, 0x01,
-            end_addr[0], end_addr[1],
-            ((start_addr >> 2) & 0xFF).try_into().unwrap(),
-            ((start_addr & 0x3) << 6).try_into().unwrap(),
-            0x00
-        ])?;
+        self.write_register(
+            0x15,
+            &mut [
+                0x00,
+                0x00,
+                0x01,
+                end_addr[0],
+                end_addr[1],
+                ((start_addr >> 2) & 0xFF).try_into().unwrap(),
+                ((start_addr & 0x3) << 6).try_into().unwrap(),
+                0x00,
+            ],
+        )?;
         self.disable_ram_configuration()?;
 
         log::info!("RAM buffer: {:?}", RAM_VEC);
-        self.spi.transfer(&mut RAM_VEC)
+        self.spi
+            .transfer(&mut RAM_VEC)
             .map(|_| ())
             .map_err(Error::SPI)?;
         RAM_VEC.clear();
@@ -664,10 +710,7 @@ where
     pub fn test(&mut self) -> Result<u32, Error<E>> {
         // Test configuration register by getting SDIO_IN_ONLY and LSB_FIRST.
         let mut error_count = 0;
-        let mut config_checks = [
-            (DDSCFRMask::SDIO_IN_ONLY, 1),
-            (DDSCFRMask::LSB_FIRST, 0)
-        ];
+        let mut config_checks = [(DDSCFRMask::SDIO_IN_ONLY, 1), (DDSCFRMask::LSB_FIRST, 0)];
         self.get_configurations(&mut config_checks)?;
         if config_checks[0].1 == 0 {
             error_count += 1;
@@ -688,7 +731,7 @@ where
     pub fn get_f_sys_clk(&mut self) -> f64 {
         self.f_sys_clk
     }
-    
+
     // Acquire real f_sys_clk
     pub fn get_sys_clk_frequency(&mut self) -> Result<f64, Error<E>> {
         // Calculate the new system clock frequency, examine the clock tree
@@ -698,19 +741,17 @@ where
             // Acquire N-divider, to adjust VCO if necessary
             (DDSCFRMask::N, 0),
             // Acquire REF_CLK divider bypass
-            (DDSCFRMask::REFCLK_IN_DIV_BYPASS, 0)
+            (DDSCFRMask::REFCLK_IN_DIV_BYPASS, 0),
         ];
 
         self.get_configurations(&mut configuration_queries)?;
         if configuration_queries[0].1 == 1 {
             // Recalculate sys_clk
-            let divider :f64 = configuration_queries[1].1.into();
+            let divider: f64 = configuration_queries[1].1.into();
             Ok(self.f_ref_clk * divider)
-        }
-        else if configuration_queries[2].1 == 0 {
+        } else if configuration_queries[2].1 == 0 {
             Ok(self.f_ref_clk / 2.0)
-        }
-        else {
+        } else {
             Ok(self.f_ref_clk)
         }
     }
@@ -772,26 +813,8 @@ macro_rules! impl_register_io {
 }
 
 impl_register_io!(
-    0x00,    4,
-    0x01,    4,
-    0x02,    4,
-    0x03,    4,
-    0x04,    4,
-    0x07,    4,
-    0x08,    2,
-    0x09,    4,
-    0x0A,    4,
-    0x0B,    8,
-    0x0C,    8,
-    0x0D,    4,
-    0x0E,    8,
-    0x0F,    8,
-    0x10,    8,
-    0x11,    8,
-    0x12,    8,
-    0x13,    8,
-    0x14,    8,
-    0x15,    8
+    0x00, 4, 0x01, 4, 0x02, 4, 0x03, 4, 0x04, 4, 0x07, 4, 0x08, 2, 0x09, 4, 0x0A, 4, 0x0B, 8, 0x0C,
+    8, 0x0D, 4, 0x0E, 8, 0x0F, 8, 0x10, 8, 0x11, 8, 0x12, 8, 0x13, 8, 0x14, 8, 0x15, 8
 );
 
 // Append bytes to the RAM buffer
diff --git a/src/flash.rs b/src/flash.rs
index f3229c9..e0fffa5 100644
--- a/src/flash.rs
+++ b/src/flash.rs
@@ -22,7 +22,7 @@ pub enum Error {
     ErrorCorrectionCode,
     ReadProtection,
     ReadSecure,
-    WriteError
+    WriteError,
 }
 
 /// Embedded flash memory.
@@ -45,46 +45,58 @@ impl Flash {
 
         // Unlock bank 1 if needed.
         if self.bank1_is_locked() {
-            self.registers.bank1_mut().keyr.write(|w| unsafe {
-                w.keyr().bits(0x45670123)
-            });
-            self.registers.bank1_mut().keyr.write(|w| unsafe {
-                w.keyr().bits(0xCDEF89AB)
-            });
+            self.registers
+                .bank1_mut()
+                .keyr
+                .write(|w| unsafe { w.keyr().bits(0x45670123) });
+            self.registers
+                .bank1_mut()
+                .keyr
+                .write(|w| unsafe { w.keyr().bits(0xCDEF89AB) });
         }
 
         // Unlock bank 2 if needed.
         if self.bank2_is_locked() {
-            self.registers.bank2_mut().keyr.write(|w| unsafe {
-                w.keyr().bits(0x45670123)
-            });
-            self.registers.bank2_mut().keyr.write(|w| unsafe {
-                w.keyr().bits(0xCDEF89AB)
-            });
+            self.registers
+                .bank2_mut()
+                .keyr
+                .write(|w| unsafe { w.keyr().bits(0x45670123) });
+            self.registers
+                .bank2_mut()
+                .keyr
+                .write(|w| unsafe { w.keyr().bits(0xCDEF89AB) });
         }
     }
 
     /// Unlocks the FLASH_OPTCR register
     pub fn unlock_optcr(&mut self) {
         if self.optcr_is_locked() {
-            self.registers.optkeyr_mut().write(|w| unsafe {
-                w.optkeyr().bits(0x08192A3B)
-            });
-            self.registers.optkeyr_mut().write(|w| unsafe {
-                w.optkeyr().bits(0x4C5D6E7F)
-            });
+            self.registers
+                .optkeyr_mut()
+                .write(|w| unsafe { w.optkeyr().bits(0x08192A3B) });
+            self.registers
+                .optkeyr_mut()
+                .write(|w| unsafe { w.optkeyr().bits(0x4C5D6E7F) });
         }
     }
 
     /// Locks the FLASH_CR1/2 register.
     pub fn lock(&mut self) {
-        self.registers.bank1_mut().cr.modify(|_, w| w.lock().set_bit());
-        self.registers.bank2_mut().cr.modify(|_, w| w.lock().set_bit());
+        self.registers
+            .bank1_mut()
+            .cr
+            .modify(|_, w| w.lock().set_bit());
+        self.registers
+            .bank2_mut()
+            .cr
+            .modify(|_, w| w.lock().set_bit());
     }
 
     /// Lock the FLASH_OPTCR register
     pub fn lock_optcr(&mut self) {
-        self.registers.optcr_mut().modify(|_, w| w.optlock().set_bit());
+        self.registers
+            .optcr_mut()
+            .modify(|_, w| w.optlock().set_bit());
     }
 
     // More literal methods to get bank status
@@ -106,7 +118,7 @@ impl Flash {
     fn is_busy(&self) -> bool {
         let (sr1, sr2) = (
             self.registers.bank1_mut().sr.read(),
-            self.registers.bank2_mut().sr.read()
+            self.registers.bank2_mut().sr.read(),
         );
         sr1.bsy().bit_is_set() || sr2.bsy().bit_is_set()
     }
@@ -115,7 +127,7 @@ impl Flash {
     fn is_queuing(&self) -> bool {
         let (sr1, sr2) = (
             self.registers.bank1_mut().sr.read(),
-            self.registers.bank2_mut().sr.read()
+            self.registers.bank2_mut().sr.read(),
         );
         sr1.qw().bit_is_set() || sr2.qw().bit_is_set()
     }
@@ -145,28 +157,26 @@ impl Flash {
         // 4. Set START1/2 bit in FLASH_CR1/2 register
         match bank_number {
             1 => {
-                self.registers.bank1_mut().cr.modify(|_, w| unsafe {
-                    w.ser()
-                        .set_bit()
-                        .snb()
-                        .bits(sector_number)
-                });
-                self.registers.bank1_mut().cr.modify(|_, w| {
-                    w.start().set_bit()
-                });
-            },
+                self.registers
+                    .bank1_mut()
+                    .cr
+                    .modify(|_, w| unsafe { w.ser().set_bit().snb().bits(sector_number) });
+                self.registers
+                    .bank1_mut()
+                    .cr
+                    .modify(|_, w| w.start().set_bit());
+            }
             2 => {
-                self.registers.bank2_mut().cr.modify(|_, w| unsafe {
-                    w.ser()
-                        .set_bit()
-                        .snb()
-                        .bits(sector_number)
-                });
-                self.registers.bank2_mut().cr.modify(|_, w| {
-                    w.start().set_bit()
-                });
-            },
-            _ => unreachable!()
+                self.registers
+                    .bank2_mut()
+                    .cr
+                    .modify(|_, w| unsafe { w.ser().set_bit().snb().bits(sector_number) });
+                self.registers
+                    .bank2_mut()
+                    .cr
+                    .modify(|_, w| w.start().set_bit());
+            }
+            _ => unreachable!(),
         }
         // Lock the flash CR again
         self.lock();
@@ -187,24 +197,20 @@ impl Flash {
         //       mass erase is invoked since it supersedes sector erase.
         match bank_number {
             1 => {
-                self.registers.bank1_mut().cr.modify(|_, w| {
-                    w.ber()
-                        .set_bit()
-                        .start()
-                        .set_bit()
-                });
+                self.registers
+                    .bank1_mut()
+                    .cr
+                    .modify(|_, w| w.ber().set_bit().start().set_bit());
                 while self.registers.bank1_mut().sr.read().qw().bit_is_set() {}
-            },
+            }
             2 => {
-                self.registers.bank2_mut().cr.modify(|_, w| {
-                    w.ber()
-                        .set_bit()
-                        .start()
-                        .set_bit()
-                });
+                self.registers
+                    .bank2_mut()
+                    .cr
+                    .modify(|_, w| w.ber().set_bit().start().set_bit());
                 while self.registers.bank2_mut().sr.read().qw().bit_is_set() {}
-            },
-            _ => unreachable!()
+            }
+            _ => unreachable!(),
         }
         // Lock the flash CR again
         self.lock();
@@ -219,9 +225,7 @@ impl Flash {
         self.unlock();
         self.unlock_optcr();
         // 3. Set MER in FLASH_OPTCR to 1, wait until both QW to clear
-        self.registers.optcr_mut().modify(|_, w| {
-            w.mer().set_bit()
-        });
+        self.registers.optcr_mut().modify(|_, w| w.mer().set_bit());
         while self.is_queuing() {}
         // Lock the flash CR and OPTCR again
         self.lock();
@@ -231,11 +235,7 @@ impl Flash {
 
     /// Program flash words (32-bytes).
     /// Flashing incomplete flash word is "tolerated", but you have been warned..
-    pub fn program<'a, 'b>(
-        &'a mut self,
-        start_offset: usize,
-        data: &'b [u8],
-    ) -> Result<(), Error> {
+    pub fn program<'a, 'b>(&'a mut self, start_offset: usize, data: &'b [u8]) -> Result<(), Error> {
         if (start_offset % 32 != 0) || (data.len() % 32 != 0) {
             log::warn!("Warning: This flash operation might not be supported...");
             log::warn!("Consider force writing the data in buffer...");
@@ -247,20 +247,19 @@ impl Flash {
         while remaining_data.len() != 0 {
             let single_write_size = 32 - (current_address % 32);
             // Determine the index that split the coming row and the remaining bytes.
-            let splitting_index = core::cmp::min(
-                single_write_size,
-                remaining_data.len()
-            );
+            let splitting_index = core::cmp::min(single_write_size, remaining_data.len());
             let single_row_data = &remaining_data[..splitting_index];
             // 1. Unlock FLASH_CR1/2 register if necessary
             self.unlock();
             // 2. Set PG bit in FLASH_CR1/2
-            self.registers.bank1_mut().cr.modify(|_, w| {
-                w.pg().set_bit()
-            });
-            self.registers.bank2_mut().cr.modify(|_, w| {
-                w.pg().set_bit()
-            });
+            self.registers
+                .bank1_mut()
+                .cr
+                .modify(|_, w| w.pg().set_bit());
+            self.registers
+                .bank2_mut()
+                .cr
+                .modify(|_, w| w.pg().set_bit());
             // 3. Check Protection
             // There should not be any data protection anyway...
             // 4. Write data byte by byte
@@ -268,22 +267,32 @@ impl Flash {
                 while self.is_busy() {}
                 match self.check_errors() {
                     Ok(_) => {
-                        let address: *mut u8 = unsafe {
-                            FLASH_BASE.add(current_address + index)
-                        };
+                        let address: *mut u8 = unsafe { FLASH_BASE.add(current_address + index) };
                         if address > MAX_FLASH_ADDRESS {
-                            self.registers.bank1_mut().cr.modify(|_, w| w.pg().clear_bit());
-                            self.registers.bank2_mut().cr.modify(|_, w| w.pg().clear_bit());
+                            self.registers
+                                .bank1_mut()
+                                .cr
+                                .modify(|_, w| w.pg().clear_bit());
+                            self.registers
+                                .bank2_mut()
+                                .cr
+                                .modify(|_, w| w.pg().clear_bit());
                             return Err(Error::WriteError);
                         } else {
                             unsafe {
                                 core::ptr::write_volatile(address, *byte);
                             }
                         }
-                    },
+                    }
                     Err(error) => {
-                        self.registers.bank1_mut().cr.modify(|_, w| w.pg().clear_bit());
-                        self.registers.bank2_mut().cr.modify(|_, w| w.pg().clear_bit());
+                        self.registers
+                            .bank1_mut()
+                            .cr
+                            .modify(|_, w| w.pg().clear_bit());
+                        self.registers
+                            .bank2_mut()
+                            .cr
+                            .modify(|_, w| w.pg().clear_bit());
                         return Err(error);
                     }
                 }
@@ -295,8 +304,14 @@ impl Flash {
             current_address += single_row_data.len();
         }
         // Reset PG1/2
-        self.registers.bank1_mut().cr.modify(|_, w| w.pg().clear_bit());
-        self.registers.bank2_mut().cr.modify(|_, w| w.pg().clear_bit());
+        self.registers
+            .bank1_mut()
+            .cr
+            .modify(|_, w| w.pg().clear_bit());
+        self.registers
+            .bank2_mut()
+            .cr
+            .modify(|_, w| w.pg().clear_bit());
         // Lock FLASH_CR1/2 register
         self.lock();
         Ok(())
@@ -304,27 +319,25 @@ impl Flash {
 
     /// Force empty the bytes buffer for flash programming
     /// Warning: It can invalidate the whole flash due to invalid CRC.
-    pub fn force_write<'a>(
-        &'a mut self
-    ) -> Result<(), Error> {
+    pub fn force_write<'a>(&'a mut self) -> Result<(), Error> {
         if self.bank1_is_buffering() {
-            self.registers.bank1_mut().cr.modify(
-                |_, w| w.fw().set_bit()
-            );
+            self.registers
+                .bank1_mut()
+                .cr
+                .modify(|_, w| w.fw().set_bit());
         }
         if self.bank2_is_buffering() {
-            self.registers.bank2_mut().cr.modify(
-                |_, w| w.fw().set_bit()
-            );
+            self.registers
+                .bank2_mut()
+                .cr
+                .modify(|_, w| w.fw().set_bit());
         }
         Ok(())
     }
 
     /// Read a slice from flash memory
     pub fn read(&self, start_offset: usize, len: usize) -> &'static [u8] {
-        let address = unsafe {
-            FLASH_BASE.add(start_offset)
-        };
+        let address = unsafe { FLASH_BASE.add(start_offset) };
         unsafe { core::slice::from_raw_parts(address, len) }
     }
 
@@ -337,7 +350,7 @@ impl Flash {
     fn check_errors(&self) -> Result<(), Error> {
         let (sr1, sr2) = (
             self.registers.bank1_mut().sr.read(),
-            self.registers.bank2_mut().sr.read()
+            self.registers.bank2_mut().sr.read(),
         );
 
         if sr1.wrperr().bit_is_set() || sr2.wrperr().bit_is_set() {
@@ -350,8 +363,11 @@ impl Flash {
             Err(Error::Inconsistency)
         } else if sr1.operr().bit_is_set() || sr2.operr().bit_is_set() {
             Err(Error::Operation)
-        } else if sr1.sneccerr1().bit_is_set() || sr1.dbeccerr().bit_is_set()
-                || sr2.sneccerr1().bit_is_set() || sr2.dbeccerr().bit_is_set() {
+        } else if sr1.sneccerr1().bit_is_set()
+            || sr1.dbeccerr().bit_is_set()
+            || sr2.sneccerr1().bit_is_set()
+            || sr2.dbeccerr().bit_is_set()
+        {
             Err(Error::ErrorCorrectionCode)
         } else if sr1.rdperr().bit_is_set() || sr2.rdperr().bit_is_set() {
             Err(Error::ReadProtection)
diff --git a/src/flash_store.rs b/src/flash_store.rs
index 89c097a..be8255d 100644
--- a/src/flash_store.rs
+++ b/src/flash_store.rs
@@ -1,8 +1,8 @@
-use crate::flash::Flash;
 use crate::flash::Error as FlashError;
+use crate::flash::Flash;
 
+use sfkv::{Store, StoreBackend};
 use stm32h7xx_hal::pac::FLASH;
-use sfkv::{ StoreBackend, Store };
 
 use log::error;
 
@@ -32,13 +32,13 @@ pub enum SFKVProcessType {
 // Idea: Forces BACKUP_SPACE to act as a cache.
 pub struct FakeFlashManager {
     // FSM: Track the type of data being programmed
-    process_type: SFKVProcessType
+    process_type: SFKVProcessType,
 }
 
 impl StoreBackend for FakeFlashManager {
     type Data = [u8];
 
-    // Return 
+    // Return
     fn data(&self) -> &Self::Data {
         unsafe { &BACKUP_SPACE }
     }
@@ -64,7 +64,7 @@ impl StoreBackend for FakeFlashManager {
             let cache_ptr: *const u8 = &BACKUP_SPACE[offset] as *const u8;
             let payload_ptr: *const u8 = &(*payload)[0] as *const u8;
 
-            BACKUP_SPACE[offset..(offset+payload.len())].copy_from_slice(payload);
+            BACKUP_SPACE[offset..(offset + payload.len())].copy_from_slice(payload);
 
             // This part program extra trailing termination bytes (4 0xFF s)
             // However, if the remaining space is too small, there is also no need to program these bytes
@@ -74,10 +74,11 @@ impl StoreBackend for FakeFlashManager {
             // then we can assert that no k-v pair were ditched
             // Then there is no concern of accidentally interpreting unused flash memory as malformatted.
             if (cache_ptr != payload_ptr)
-                && (offset+payload.len()+4 <= FLASH_SECTOR_SIZE)
+                && (offset + payload.len() + 4 <= FLASH_SECTOR_SIZE)
                 && self.process_type == SFKVProcessType::Data
             {
-                BACKUP_SPACE[(offset+payload.len())..(offset+payload.len()+4)].copy_from_slice(&[0xFF; 4]);
+                BACKUP_SPACE[(offset + payload.len())..(offset + payload.len() + 4)]
+                    .copy_from_slice(&[0xFF; 4]);
             }
         }
         self.advance_state();
@@ -98,18 +99,10 @@ impl FakeFlashManager {
 
     pub fn advance_state(&mut self) {
         self.process_type = match self.process_type {
-            SFKVProcessType::Length => {
-                SFKVProcessType::Type
-            },
-            SFKVProcessType::Type => {
-                SFKVProcessType::Space
-            },
-            SFKVProcessType::Space => {
-                SFKVProcessType::Data
-            },
-            SFKVProcessType::Data => {
-                SFKVProcessType::Length
-            }
+            SFKVProcessType::Length => SFKVProcessType::Type,
+            SFKVProcessType::Type => SFKVProcessType::Space,
+            SFKVProcessType::Space => SFKVProcessType::Data,
+            SFKVProcessType::Data => SFKVProcessType::Length,
         };
     }
 
@@ -127,9 +120,7 @@ fn init_flash_cache(flash: FLASH) -> Flash {
     // sfkv will perform in-place operation in cache
     // flash will only be updated after invoking `save()`
     unsafe {
-        BACKUP_SPACE.copy_from_slice(
-            flash.read(FLASH_SECTOR_OFFSET, FLASH_SECTOR_SIZE)
-        );
+        BACKUP_SPACE.copy_from_slice(flash.read(FLASH_SECTOR_OFFSET, FLASH_SECTOR_SIZE));
     }
     flash
 }
@@ -143,7 +134,8 @@ fn init_flash_store() -> FlashStore {
         Ok(_) => {}
         Err(e) => {
             error!("corrupt store, erasing. error: {:?}", e);
-            let _ = store.erase()
+            let _ = store
+                .erase()
                 .map_err(|e| error!("flash erase failed: {:?}", e));
         }
     }
@@ -166,6 +158,8 @@ pub fn update_flash(flash: &mut Flash, store: &FlashStore) -> Result<(), FlashEr
         flash_size + 0x20 - (flash_size % 0x20)
     };
     unsafe {
-        flash.program(FLASH_SECTOR_OFFSET, &BACKUP_SPACE[..save_size]).map(|_| ())
+        flash
+            .program(FLASH_SECTOR_OFFSET, &BACKUP_SPACE[..save_size])
+            .map(|_| ())
     }
-}
\ No newline at end of file
+}
diff --git a/src/fpga.rs b/src/fpga.rs
index 36c19a9..50ee796 100644
--- a/src/fpga.rs
+++ b/src/fpga.rs
@@ -1,7 +1,7 @@
 use embedded_hal::{
-    digital::v2::{OutputPin, InputPin},
-    blocking::spi::Transfer,
     blocking::delay::DelayUs,
+    blocking::spi::Transfer,
+    digital::v2::{InputPin, OutputPin},
 };
 
 #[derive(Debug)]
@@ -14,31 +14,38 @@ pub enum FPGAFlashError {
 const DATA: &'static [u8] = include_bytes!("../build/top.bin");
 
 // A public method to flash iCE40 FPGA on Humpback
-pub fn flash_ice40_fpga<SPI: Transfer<u8>,
-                        SS: OutputPin,
-                        RST: OutputPin,
-                        DELAY: DelayUs<u32>,
-                        DONE: InputPin>
-    (mut spi: SPI, mut ss: SS, mut creset: RST, cdone: DONE, mut delay: DELAY) -> Result<(), FPGAFlashError>
-{
+pub fn flash_ice40_fpga<
+    SPI: Transfer<u8>,
+    SS: OutputPin,
+    RST: OutputPin,
+    DELAY: DelayUs<u32>,
+    DONE: InputPin,
+>(
+    mut spi: SPI,
+    mut ss: SS,
+    mut creset: RST,
+    cdone: DONE,
+    mut delay: DELAY,
+) -> Result<(), FPGAFlashError> {
     // Data buffer setup
-    let mut dummy_byte :[u8; 1] = [0x00];
-    let mut dummy_13_bytes :[u8; 13] = [0x00; 13];
+    let mut dummy_byte: [u8; 1] = [0x00];
+    let mut dummy_13_bytes: [u8; 13] = [0x00; 13];
 
     // Drive CRESET_B low
-    creset.set_low()
-            .map_err(|_| FPGAFlashError::NegotiationError)?;
+    creset
+        .set_low()
+        .map_err(|_| FPGAFlashError::NegotiationError)?;
 
     // Drive SPI_SS_B low
-    ss.set_low()
-        .map_err(|_| FPGAFlashError::NegotiationError)?;
+    ss.set_low().map_err(|_| FPGAFlashError::NegotiationError)?;
 
     // Wait at least 200ns
     delay.delay_us(1_u32);
 
     // Drive CRESET_B high
-    creset.set_high()
-            .map_err(|_| FPGAFlashError::NegotiationError)?;
+    creset
+        .set_high()
+        .map_err(|_| FPGAFlashError::NegotiationError)?;
 
     // Wait at least another 1200us to clear internal config memory
     delay.delay_us(1200_u32);
@@ -46,7 +53,7 @@ pub fn flash_ice40_fpga<SPI: Transfer<u8>,
     // Before data transmission starts, check if C_DONE is truly low
     // If C_DONE is high, the FPGA reset procedure is unsuccessful
     match cdone.is_low() {
-        Ok(true) => {},
+        Ok(true) => {}
         _ => return Err(FPGAFlashError::ResetStatusError),
     };
 
@@ -59,8 +66,7 @@ pub fn flash_ice40_fpga<SPI: Transfer<u8>,
         .map_err(|_| FPGAFlashError::SPICommunicationError)?;
 
     // Drive SPI_SS_B low
-    ss.set_low()
-        .map_err(|_| FPGAFlashError::NegotiationError)?;
+    ss.set_low().map_err(|_| FPGAFlashError::NegotiationError)?;
 
     // Send the whole image without interruption
     for byte in DATA.into_iter() {
@@ -80,12 +86,12 @@ pub fn flash_ice40_fpga<SPI: Transfer<u8>,
     // Check the CDONE output from FPGA
     // CDONE needs to be high
     match cdone.is_high() {
-        Ok(true) => {},
+        Ok(true) => {}
         _ => return Err(FPGAFlashError::ResetStatusError),
     };
 
     // Send at least another 49 clock cycles to activate IO pins (choosing same 13 bytes)
-    spi.transfer(&mut dummy_13_bytes).map_err(|_| FPGAFlashError::SPICommunicationError)?;
+    spi.transfer(&mut dummy_13_bytes)
+        .map_err(|_| FPGAFlashError::SPICommunicationError)?;
     Ok(())
-
 }
diff --git a/src/logger.rs b/src/logger.rs
index b277fe9..939ceb6 100644
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -2,7 +2,7 @@
 pub unsafe fn enable_itm(
     dbgmcu: &stm32h7xx_hal::stm32::DBGMCU,
     dcb: &mut cortex_m::peripheral::DCB,
-    itm: &mut cortex_m::peripheral::ITM
+    itm: &mut cortex_m::peripheral::ITM,
 ) {
     // ARMv7-M DEMCR: Set TRCENA. Enables DWT and ITM units
     //unsafe { *(0xE000_EDFC as *mut u32) |= 1 << 24 };
@@ -56,23 +56,17 @@ use log::LevelFilter;
 pub use cortex_m_log::log::Logger;
 
 use cortex_m_log::{
-    destination::Itm as ItmDest,
-    printer::itm::InterruptSync,
-    modes::InterruptFree,
-    printer::itm::ItmSync
+    destination::Itm as ItmDest, modes::InterruptFree, printer::itm::InterruptSync,
+    printer::itm::ItmSync,
 };
 
 lazy_static! {
     static ref LOGGER: Logger<ItmSync<InterruptFree>> = Logger {
         level: LevelFilter::Info,
-        inner: unsafe {
-            InterruptSync::new(
-                ItmDest::new(cortex_m::Peripherals::steal().ITM)
-            )
-        },
+        inner: unsafe { InterruptSync::new(ItmDest::new(cortex_m::Peripherals::steal().ITM)) },
     };
 }
 
 pub fn init() {
     cortex_m_log::log::init(&LOGGER).unwrap();
-}
\ No newline at end of file
+}
diff --git a/src/main.rs b/src/main.rs
index dba1d44..154ea8b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,36 +4,36 @@
 #![feature(assoc_char_funcs)]
 #![feature(alloc_error_handler)]
 
-use log::{ trace, warn };
+use log::{trace, warn};
+use stm32h7xx_hal::ethernet;
 use stm32h7xx_hal::gpio::Speed;
 use stm32h7xx_hal::rng::Rng;
 use stm32h7xx_hal::{pac, prelude::*, spi};
-use stm32h7xx_hal::ethernet;
 
 use smoltcp as net;
 use SaiTLS as tls;
 
-use minimq::{ MqttClient, QoS };
+use minimq::{MqttClient, QoS};
 
+use alloc_cortex_m::CortexMHeap;
 use cortex_m;
 use cortex_m_rt::entry;
-use alloc_cortex_m::CortexMHeap;
+use rand_core::{CryptoRng, RngCore};
 use rtic::cyccnt::{Instant, U32Ext};
-use rand_core::{RngCore, CryptoRng};
 
-use tls::TlsRng;
-use tls::tls::TlsSocket;
-use tls::tcp_stack::NetworkStack;
-use heapless::{ String, consts, consts::* };
 use core::alloc::Layout;
+use heapless::{consts, consts::*, String};
+use tls::tcp_stack::NetworkStack;
+use tls::tls::TlsSocket;
+use tls::TlsRng;
 
 #[macro_use]
 pub mod bitmask_macro;
-pub mod spi_slave;
 pub mod cpld;
+pub mod spi_slave;
 use crate::cpld::CPLD;
-pub mod config_register;
 pub mod attenuator;
+pub mod config_register;
 pub mod dds;
 pub mod net_store;
 use crate::net_store::NetStorage;
@@ -43,8 +43,8 @@ pub mod mqtt_mux;
 use crate::mqtt_mux::MqttMux;
 pub mod urukul;
 use crate::urukul::Urukul;
-pub mod flash;
 pub mod config;
+pub mod flash;
 use crate::config::get_net_config;
 pub mod flash_store;
 use crate::flash_store::init_flash;
@@ -77,7 +77,7 @@ static mut TX_STORAGE: [u8; 8192] = [0; 8192];
 static mut RX_STORAGE: [u8; 8192] = [0; 8192];
 
 struct RngStruct {
-    rng: Rng
+    rng: Rng,
 }
 
 impl RngCore for RngStruct {
@@ -104,7 +104,6 @@ impl TlsRng for RngStruct {}
 
 #[entry]
 fn main() -> ! {
-
     // Initialize the allocator BEFORE you use it
     let start = cortex_m_rt::heap_start() as usize;
     let size = 32768; // in bytes
@@ -134,9 +133,9 @@ fn main() -> ! {
         .pll1_q_ck(48.mhz())
         .pll1_r_ck(400.mhz())
         .freeze(vos, &dp.SYSCFG);
-    
+
     let delay = cp.SYST.delay(ccdr.clocks);
-    
+
     cp.SCB.invalidate_icache();
     cp.SCB.enable_icache();
 
@@ -144,7 +143,7 @@ fn main() -> ! {
 
     // Instantiate random number generator
     let mut rng = RngStruct {
-        rng: dp.RNG.constrain(ccdr.peripheral.RNG, &ccdr.clocks)
+        rng: dp.RNG.constrain(ccdr.peripheral.RNG, &ccdr.clocks),
     };
 
     // Create sfkv store and flash storage manager
@@ -267,7 +266,7 @@ fn main() -> ! {
     let parts = switch.split();
 
     let urukul = Urukul::new(
-        parts.spi1, parts.spi2, parts.spi3, parts.spi4, parts.spi5, parts.spi6, parts.spi7
+        parts.spi1, parts.spi2, parts.spi3, parts.spi4, parts.spi5, parts.spi6, parts.spi7,
     );
 
     let mut mqtt_mux = MqttMux::new(urukul, flash, flash_store, net_config.name.as_str());
@@ -281,27 +280,17 @@ fn main() -> ! {
     next_ms += 400_000.cycles();
 
     let mut tls_socket_entries: [_; 1] = Default::default();
-    let mut tls_socket_set = tls::set::TlsSocketSet::new(
-        &mut tls_socket_entries[..]
-    );
+    let mut tls_socket_set = tls::set::TlsSocketSet::new(&mut tls_socket_entries[..]);
 
     let tx_buffer = net::socket::TcpSocketBuffer::new(unsafe { &mut TX_STORAGE[..] });
     let rx_buffer = net::socket::TcpSocketBuffer::new(unsafe { &mut RX_STORAGE[..] });
     let mut tcp_socket = net::socket::TcpSocket::new(rx_buffer, tx_buffer);
-    tcp_socket.set_keep_alive(
-        Some(net::time::Duration::from_secs(2))
-    );
+    tcp_socket.set_keep_alive(Some(net::time::Duration::from_secs(2)));
 
-    let tls_socket = TlsSocket::new(
-        tcp_socket,
-        &mut rng,
-        None
-    );
+    let tls_socket = TlsSocket::new(tcp_socket, &mut rng, None);
     let _ = tls_socket_set.add(tls_socket);
 
-    let tls_stack = NetworkStack::new(
-        tls_socket_set
-    );
+    let tls_stack = NetworkStack::new(tls_socket_set);
 
     let mut client = MqttClient::<consts::U2048, _>::new(
         net_config.broker_ip,
@@ -325,37 +314,35 @@ fn main() -> ! {
         // eth Poll if necessary
         // Do not poll if eth link is down
         while !eth_mac.phy_poll_link() {}
-        client.network_stack.poll(&mut net_interface, net::time::Instant::from_millis(time));
+        client
+            .network_stack
+            .poll(&mut net_interface, net::time::Instant::from_millis(time));
 
         // Process MQTT messages about Urukul/Control
-        let connection = match client
-            .poll(|_client, topic, message, _properties| {
-                mqtt_mux.process_mqtt_ingress(topic, message);
-            }) {
-                Ok(_) => true,
-                Err(e) => {
-                    log::info!("Warn: {:?}", e);
-                    false
-                },
-            };
-        
+        let connection = match client.poll(|_client, topic, message, _properties| {
+            mqtt_mux.process_mqtt_ingress(topic, message);
+        }) {
+            Ok(_) => true,
+            Err(e) => {
+                log::info!("Warn: {:?}", e);
+                false
+            }
+        };
+
         // Process MQTT response messages about Urukul
         for (topic, message) in mqtt_mux.process_mqtt_egress().unwrap() {
-            client.publish(
-                topic.as_str(),
-                message.as_bytes(),
-                QoS::AtMostOnce,
-                &[]
-            ).unwrap();
+            client
+                .publish(topic.as_str(), message.as_bytes(), QoS::AtMostOnce, &[])
+                .unwrap();
         }
-        
+
         if connection && !has_subscribed && tick {
             let mut str_builder: String<U128> = String::from(net_config.name.as_str());
             str_builder.push_str("/Control/#").unwrap();
             match client.subscribe(str_builder.as_str(), &[]) {
                 Ok(()) => has_subscribed = true,
-                Err(minimq::Error::NotReady) => {},
-                _e => {},
+                Err(minimq::Error::NotReady) => {}
+                _e => {}
             };
         }
 
@@ -363,4 +350,3 @@ fn main() -> ! {
         tick = false;
     }
 }
-
diff --git a/src/mqtt_mux.rs b/src/mqtt_mux.rs
index 7bd0871..b8ac5a8 100644
--- a/src/mqtt_mux.rs
+++ b/src/mqtt_mux.rs
@@ -1,22 +1,22 @@
-use nom::IResult;
-use nom::combinator::{value, map, map_res, opt, all_consuming};
-use nom::sequence::{terminated, preceded, pair};
+use crate::config::{ChannelConfig, ProfileSetup, SingleTone, UrukulConfig, RAM};
+use crate::dds::{RAMDestination, RAMOperationMode};
+use crate::flash::Flash;
+use crate::flash_store::{update_flash, FlashStore};
+use crate::urukul::ClockSource as UrukulClockSource;
+use crate::urukul::Error;
+use crate::urukul::Urukul;
+use core::convert::TryInto;
+use embedded_hal::blocking::spi::Transfer;
+use heapless::{consts::*, String, Vec};
+use nom::branch::{alt, permutation};
 use nom::bytes::complete::{tag, tag_no_case, take_while};
 use nom::character::complete::digit1;
 use nom::character::is_space;
-use nom::branch::{permutation, alt};
-use nom::number::complete::{float, double};
-use heapless::{ Vec, String, consts::* };
+use nom::combinator::{all_consuming, map, map_res, opt, value};
+use nom::number::complete::{double, float};
+use nom::sequence::{pair, preceded, terminated};
+use nom::IResult;
 use ryu;
-use embedded_hal::blocking::spi::Transfer;
-use core::convert::TryInto;
-use crate::urukul::ClockSource as UrukulClockSource;
-use crate::urukul::Urukul;
-use crate::urukul::Error;
-use crate::flash_store::{ FlashStore, update_flash };
-use crate::flash::Flash;
-use crate::config::{ UrukulConfig, ChannelConfig, ProfileSetup, SingleTone, RAM };
-use crate::dds::{ RAMDestination, RAMOperationMode };
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum MqttTopic {
@@ -78,11 +78,19 @@ pub struct MqttMux<'s, SPI> {
     float_buffer: ryu::Buffer,
 }
 
-const CHANNELS: [&str; 4] = [ "ch0", "ch1", "ch2", "ch3" ];
+const CHANNELS: [&str; 4] = ["ch0", "ch1", "ch2", "ch3"];
 static mut SERDE_BUFFER: [u8; 64] = [0; 64];
 
-impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
-    pub fn new(urukul: Urukul<SPI>, flash_controller: Flash, flash_store: FlashStore, name: &'s str) -> Self {
+impl<'s, SPI, E> MqttMux<'s, SPI>
+where
+    SPI: Transfer<u8, Error = E>,
+{
+    pub fn new(
+        urukul: Urukul<SPI>,
+        flash_controller: Flash,
+        flash_store: FlashStore,
+        name: &'s str,
+    ) -> Self {
         Self {
             urukul: urukul,
             yet_to_respond: None,
@@ -95,7 +103,8 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
 
     fn load_device(&mut self) -> Result<(), Error<E>> {
         self.urukul.reset()?;
-        let profile = match self.flash_store
+        let profile = match self
+            .flash_store
             .read_value::<UrukulConfig>("urukul")
             .unwrap()
         {
@@ -103,47 +112,38 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                 self.urukul.set_clock(
                     urukul_config.clk_src,
                     urukul_config.clk_freq,
-                    urukul_config.clk_div
+                    urukul_config.clk_div,
                 )?;
                 self.urukul.set_profile(urukul_config.profile)?;
                 urukul_config.profile
-            },
+            }
             None => 0,
         };
 
         for (channel, channel_tag) in CHANNELS.iter().enumerate() {
-            match self.flash_store
+            match self
+                .flash_store
                 .read_value::<ChannelConfig>(channel_tag)
                 .unwrap()
             {
                 Some(channel_config) => {
-                    self.urukul.set_channel_switch(
-                        channel as u32,
-                        channel_config.sw
-                    )?;
-                    self.urukul.set_channel_attenuation(
-                        channel as u8,
-                        channel_config.att
-                    )?;
-                    self.urukul.set_channel_sys_clk(
-                        channel as u8,
-                        channel_config.sys_clk
-                    )?;
-                    self.urukul.set_channel_default_ftw(
-                        channel as u8,
-                        channel_config.freq
-                    )?;
-                    self.urukul.set_channel_default_asf(
-                        channel as u8,
-                        channel_config.asf
-                    )?;
+                    self.urukul
+                        .set_channel_switch(channel as u32, channel_config.sw)?;
+                    self.urukul
+                        .set_channel_attenuation(channel as u8, channel_config.att)?;
+                    self.urukul
+                        .set_channel_sys_clk(channel as u8, channel_config.sys_clk)?;
+                    self.urukul
+                        .set_channel_default_ftw(channel as u8, channel_config.freq)?;
+                    self.urukul
+                        .set_channel_default_asf(channel as u8, channel_config.asf)?;
                     if let ProfileSetup::Singletone(singletone) = channel_config.profile {
                         self.urukul.set_channel_single_tone_profile(
                             channel as u8,
                             profile,
                             singletone.freq,
                             singletone.phase,
-                            singletone.asf
+                            singletone.asf,
                         )?;
                     } else if let ProfileSetup::RAM(ram) = channel_config.profile {
                         let op_mode = match ram.op_mode {
@@ -159,11 +159,11 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                             ram.start,
                             ram.end,
                             op_mode,
-                            ram.stride
+                            ram.stride,
                         )?;
                     }
-                },
-                None => ()
+                }
+                None => (),
             };
         }
         Ok(())
@@ -171,63 +171,50 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
 
     fn save_device(&mut self) -> Result<(), Error<E>> {
         let urukul_config = UrukulConfig {
-            clk_src: {
-                self.urukul.get_clock_source()?
-            },
-            clk_freq: {
-                self.urukul.get_clock_frequency()
-            },
-            clk_div: {
-                self.urukul.get_clock_division()?
-            },
-            profile: {
-                self.urukul.get_profile()?
-            }
+            clk_src: { self.urukul.get_clock_source()? },
+            clk_freq: { self.urukul.get_clock_frequency() },
+            clk_div: { self.urukul.get_clock_division()? },
+            profile: { self.urukul.get_profile()? },
         };
 
-        unsafe { self.flash_store.write_value("urukul", &urukul_config, &mut SERDE_BUFFER).unwrap(); }
+        unsafe {
+            self.flash_store
+                .write_value("urukul", &urukul_config, &mut SERDE_BUFFER)
+                .unwrap();
+        }
 
         for channel in 0..4 {
-            let ram  = self.urukul.get_channel_ram_mode_enabled(channel as u8)?;
+            let ram = self.urukul.get_channel_ram_mode_enabled(channel as u8)?;
             let profile_setup = if ram {
-                let (start, end, stride, op_mode) = self.urukul.get_channel_ram_profile(
-                    channel as u8,
-                    urukul_config.profile
-                )?;
+                let (start, end, stride, op_mode) = self
+                    .urukul
+                    .get_channel_ram_profile(channel as u8, urukul_config.profile)?;
                 let ram_profile = RAM {
-                    start, end, stride, op_mode
+                    start,
+                    end,
+                    stride,
+                    op_mode,
                 };
                 ProfileSetup::RAM(ram_profile)
             } else {
-                let (freq, phase, asf) = self.urukul.get_channel_single_tone_profile(
-                    channel as u8,
-                    urukul_config.profile
-                )?;
-                let singletone_profile = SingleTone {
-                    freq, phase, asf
-                };
+                let (freq, phase, asf) = self
+                    .urukul
+                    .get_channel_single_tone_profile(channel as u8, urukul_config.profile)?;
+                let singletone_profile = SingleTone { freq, phase, asf };
                 ProfileSetup::Singletone(singletone_profile)
             };
             let channel_config = ChannelConfig {
-                sw: {
-                    self.urukul.get_channel_switch_status(channel as u32)?
-                },
-                att: {
-                    self.urukul.get_channel_attenuation(channel as u8)?
-                },
-                sys_clk: {
-                    self.urukul.get_channel_sys_clk(channel as u8)?
-                },
-                freq: {
-                    self.urukul.get_channel_default_ftw(channel as u8)?
-                },
-                asf: {
-                    self.urukul.get_channel_default_asf(channel as u8)?
-                },
-                profile: profile_setup
+                sw: { self.urukul.get_channel_switch_status(channel as u32)? },
+                att: { self.urukul.get_channel_attenuation(channel as u8)? },
+                sys_clk: { self.urukul.get_channel_sys_clk(channel as u8)? },
+                freq: { self.urukul.get_channel_default_ftw(channel as u8)? },
+                asf: { self.urukul.get_channel_default_asf(channel as u8)? },
+                profile: profile_setup,
             };
             unsafe {
-                self.flash_store.write_value(CHANNELS[channel], &channel_config, &mut SERDE_BUFFER).unwrap();
+                self.flash_store
+                    .write_value(CHANNELS[channel], &channel_config, &mut SERDE_BUFFER)
+                    .unwrap();
             }
         }
 
@@ -251,7 +238,8 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
         let command = if topic == MqttTopic::AppendBytes {
             let length = message.len();
             if self.urukul.append_dds_ram_buffer(message).is_err() {
-                self.yet_to_respond = Some(MqttCommand::ProcessError("Cannot push bytes to buffer"));
+                self.yet_to_respond =
+                    Some(MqttCommand::ProcessError("Cannot push bytes to buffer"));
                 return;
             }
             MqttCommand::AppendBytes(length)
@@ -259,7 +247,8 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
             match self.parse_message(topic, message) {
                 Ok((_, cmd)) => cmd,
                 Err(_) => {
-                    self.yet_to_respond = Some(MqttCommand::ProcessError("Cannot parse MQTT message"));
+                    self.yet_to_respond =
+                        Some(MqttCommand::ProcessError("Cannot parse MQTT message"));
                     return;
                 }
             }
@@ -267,14 +256,16 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
 
         self.yet_to_respond = match self.execute(command.clone()) {
             Err(_) => Some(MqttCommand::ProcessError("Cannot execute MQTT command")),
-            Ok(()) => Some(command)
+            Ok(()) => Some(command),
         };
     }
 
     // Be sure to call egress function after each ingress.
     // Otherwise, response will be lost if successive valid MQTT messages were captured
     // without calling egress in between
-    pub fn process_mqtt_egress(&mut self) -> Result<Vec<(String<U128>, String<U64>), U4>, Error<E>> {
+    pub fn process_mqtt_egress(
+        &mut self,
+    ) -> Result<Vec<(String<U128>, String<U64>), U4>, Error<E>> {
         // Remove previously executed command, and process it afterwards
         let prev_cmd = self.yet_to_respond.clone();
         self.yet_to_respond = None;
@@ -286,12 +277,14 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Error")
+                            topic_string
+                                .push_str("/Feedback/Error")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
-                        String::from(e_str)
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        String::from(e_str),
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -299,17 +292,17 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Reset")
+                            topic_string
+                                .push_str("/Feedback/Reset")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
-                        String::from(
-                            match self.urukul.test() {
-                                Ok(0) => "Reset successful.",
-                                _ => "Reset error!",
-                            }
-                        )
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        String::from(match self.urukul.test() {
+                            Ok(0) => "Reset successful.",
+                            _ => "Reset error!",
+                        }),
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -317,24 +310,26 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Channel")
+                            topic_string
+                                .push_str("/Feedback/Channel")
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                            topic_string
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push_str("/Switch")
+                            topic_string
+                                .push_str("/Switch")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
-                            String::from(
-                                if self.urukul.get_channel_switch_status(ch.into())? {
-                                    "on"
-                                } else {
-                                    "off"
-                                }
-                            )
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                            String::from(if self.urukul.get_channel_switch_status(ch.into())? {
+                                "on"
+                            } else {
+                                "off"
+                            })
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -342,56 +337,53 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Channel")
+                            topic_string
+                                .push_str("/Feedback/Channel")
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                            topic_string
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push_str("/Attenuation")
+                            topic_string
+                                .push_str("/Attenuation")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             String::from(
-                                self.float_buffer.format_finite(
-                                    self.urukul.get_channel_attenuation(ch)?
-                                )
+                                self.float_buffer
+                                    .format_finite(self.urukul.get_channel_attenuation(ch)?),
                             )
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
                 MqttCommand::Clock(_, _, _) => {
-                    vec.push(
-                        self.get_clock_source_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
-                    vec.push(
-                        self.get_clock_frequency_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
-                    vec.push(
-                        self.get_clock_division_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_source_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_frequency_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_division_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
                 MqttCommand::ClockSource(_) => {
-                    vec.push(
-                        self.get_clock_source_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_source_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
                 MqttCommand::ClockFrequency(_) => {
-                    vec.push(
-                        self.get_clock_frequency_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_frequency_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
                 MqttCommand::ClockDivision(_) => {
-                    vec.push(
-                        self.get_clock_division_message()?
-                    ).map_err(|_| Error::VectorOutOfSpace)?;
+                    vec.push(self.get_clock_division_message()?)
+                        .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -399,33 +391,38 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Channel")
+                            topic_string
+                                .push_str("/Feedback/Channel")
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                            topic_string
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push_str("/SystemClock")
+                            topic_string
+                                .push_str("/SystemClock")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let mut message_str = String::from(
-                                self.float_buffer.format_finite(
-                                    self.urukul.get_channel_sys_clk(ch)?
-                                )
+                                self.float_buffer
+                                    .format_finite(self.urukul.get_channel_sys_clk(ch)?),
                             );
-                            message_str.push_str(" Hz")
+                            message_str
+                                .push_str(" Hz")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
-                MqttCommand::Singletone(ch, pr, _, _, _) |
-                MqttCommand::SingletoneFrequency(ch, pr, _) |
-                MqttCommand::SingletoneAmplitude(ch, pr, _) |
-                MqttCommand::SingletonePhase(ch, pr, _) => {
-                    let (f_out, phase, ampl) = self.urukul.get_channel_single_tone_profile(ch, pr)?;
+                MqttCommand::Singletone(ch, pr, _, _, _)
+                | MqttCommand::SingletoneFrequency(ch, pr, _)
+                | MqttCommand::SingletoneAmplitude(ch, pr, _)
+                | MqttCommand::SingletonePhase(ch, pr, _) => {
+                    let (f_out, phase, ampl) =
+                        self.urukul.get_channel_single_tone_profile(ch, pr)?;
                     vec.push(self.get_single_tone_frequency_message(ch, f_out)?)
                         .map_err(|_| Error::StringOutOfSpace)?;
                     vec.push(self.get_single_tone_phase_message(ch, phase)?)
@@ -439,18 +436,21 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Profile")
+                            topic_string
+                                .push_str("/Feedback/Profile")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let mut message_str = String::new();
                             let prof = self.urukul.get_profile()?;
-                            message_str.push(char::from_digit(prof.into(), 10).unwrap())
+                            message_str
+                                .push(char::from_digit(prof.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -458,12 +458,14 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Save")
+                            topic_string
+                                .push_str("/Feedback/Save")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
-                        String::from("Saved device.")
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        String::from("Saved device."),
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -471,12 +473,14 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Load")
+                            topic_string
+                                .push_str("/Feedback/Load")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
-                        String::from("Loaded from flash.")
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        String::from("Loaded from flash."),
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -484,24 +488,28 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Channel")
+                            topic_string
+                                .push_str("/Feedback/Channel")
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                            topic_string
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push_str("/Background/Frequency")
+                            topic_string
+                                .push_str("/Background/Frequency")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let freq = self.urukul.get_channel_default_ftw(ch)?;
-                            let mut message_str = String::from(
-                                self.float_buffer.format_finite(freq)
-                            );
-                            message_str.push_str(" Hz")
+                            let mut message_str =
+                                String::from(self.float_buffer.format_finite(freq));
+                            message_str
+                                .push_str(" Hz")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -509,22 +517,24 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Channel")
+                            topic_string
+                                .push_str("/Feedback/Channel")
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                            topic_string
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
-                            topic_string.push_str("/Background/Amplitude")
+                            topic_string
+                                .push_str("/Background/Amplitude")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let ampl = self.urukul.get_channel_default_asf(ch)?;
-                            let message_str = String::from(
-                                self.float_buffer.format_finite(ampl)
-                            );
+                            let message_str = String::from(self.float_buffer.format_finite(ampl));
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -532,19 +542,23 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Buffer/Append")
+                            topic_string
+                                .push_str("/Feedback/Buffer/Append")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let mut message_str = String::from("Pushed ");
-                            message_str.push_str(self.float_buffer.format_finite(len as f64))
-                                .map_err(|_| Error::StringOutOfSpace)?;
-                            message_str.push_str(" bytes to buffer.")
+                            message_str
+                                .push_str(self.float_buffer.format_finite(len as f64))
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                                .push_str(" bytes to buffer.")
+                                .map_err(|_| Error::StringOutOfSpace)?;
+                            message_str
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -552,17 +566,20 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/Buffer/Commit")
+                            topic_string
+                                .push_str("/Feedback/Buffer/Commit")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let mut message_str = String::from("Pushed bytes to channel ");
-                            message_str.push(char::from_digit(ch.into(), 10).unwrap())
+                            message_str
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
 
@@ -570,17 +587,20 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                     vec.push((
                         {
                             let mut topic_string = String::from(self.name);
-                            topic_string.push_str("/Feedback/RAM")
+                            topic_string
+                                .push_str("/Feedback/RAM")
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             topic_string
                         },
                         {
                             let mut message_str = String::from("Selected RAM profile for channel ");
-                            message_str.push(char::from_digit(ch.into(), 10).unwrap())
+                            message_str
+                                .push(char::from_digit(ch.into(), 10).unwrap())
                                 .map_err(|_| Error::StringOutOfSpace)?;
                             message_str
-                        }
-                    )).map_err(|_| Error::VectorOutOfSpace)?;
+                        },
+                    ))
+                    .map_err(|_| Error::VectorOutOfSpace)?;
                     Ok(vec)
                 }
             },
@@ -591,20 +611,24 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
     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;
-        let mut profile :u8 = 0;
+        let mut channel: u8 = 0;
+        let mut profile: u8 = 0;
 
         // Verify that the topic starts with <name>/Control/ or /<name>/Control/
         let mut header = {
             let mut topic_builder_with_slash: String<U128> = String::from("/");
-            topic_builder_with_slash.push_str(self.name)
+            topic_builder_with_slash
+                .push_str(self.name)
                 .map_err(|_| Error::StringOutOfSpace)?;
-            topic_builder_with_slash.push_str("/Control/")
+            topic_builder_with_slash
+                .push_str("/Control/")
                 .map_err(|_| Error::StringOutOfSpace)?;
-            let topic_builder: &str = topic_builder_with_slash.as_str()
-                                                    .strip_prefix("/")
-                                                    .ok_or(Error::StringOutOfSpace)?;
-            topic.strip_prefix(topic_builder_with_slash.as_str())
+            let topic_builder: &str = topic_builder_with_slash
+                .as_str()
+                .strip_prefix("/")
+                .ok_or(Error::StringOutOfSpace)?;
+            topic
+                .strip_prefix(topic_builder_with_slash.as_str())
                 .or_else(|| topic.strip_prefix(topic_builder))
                 .ok_or(Error::MqttCommandError)?
         };
@@ -620,25 +644,26 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     // Remove the "Channel" part of the subtopic
-                    header = header.strip_prefix("Channel")
-                                   .ok_or(Error::MqttCommandError)?;
+                    header = header
+                        .strip_prefix("Channel")
+                        .ok_or(Error::MqttCommandError)?;
                     // Remove the channel number at the end of the subtopic
                     // But store the channel as a char, so it can be removed easily
-                    let numeric_char :char = header.chars()
-                                                   .next()
-                                                   .ok_or(Error::MqttCommandError)?;
+                    let numeric_char: char =
+                        header.chars().next().ok_or(Error::MqttCommandError)?;
                     // Record the channel number
-                    channel = numeric_char.to_digit(10)
-                                          .ok_or(Error::MqttCommandError)?
-                                          .try_into()
-                                          .unwrap();
+                    channel = numeric_char
+                        .to_digit(10)
+                        .ok_or(Error::MqttCommandError)?
+                        .try_into()
+                        .unwrap();
                     assigned_channel = true;
-                    header = header.strip_prefix(numeric_char)
-                                   .ok_or(Error::MqttCommandError)?;
+                    header = header
+                        .strip_prefix(numeric_char)
+                        .ok_or(Error::MqttCommandError)?;
                     // Remove forward slash ("/")
-                    header = header.strip_prefix("/")
-                                   .ok_or(Error::MqttCommandError)?;
-                },
+                    header = header.strip_prefix("/").ok_or(Error::MqttCommandError)?;
+                }
 
                 _ if (header.starts_with("Profile") && assigned_channel) => {
                     // MQTT command should only mention profile once appropriately
@@ -646,32 +671,33 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     // Remove the "Profile" part of the subtopic
-                    header = header.strip_prefix("Profile")
-                                   .ok_or(Error::MqttCommandError)?;
+                    header = header
+                        .strip_prefix("Profile")
+                        .ok_or(Error::MqttCommandError)?;
                     // Remove the profile number at the end of the subtopic
                     // But store the profile as a char, so it can be removed easily
-                    let numeric_char :char = header.chars()
-                                                   .next()
-                                                   .ok_or(Error::MqttCommandError)?;
+                    let numeric_char: char =
+                        header.chars().next().ok_or(Error::MqttCommandError)?;
                     // Record the channel number
-                    profile = numeric_char.to_digit(10)
-                                          .ok_or(Error::MqttCommandError)?
-                                          .try_into()
-                                          .unwrap();
+                    profile = numeric_char
+                        .to_digit(10)
+                        .ok_or(Error::MqttCommandError)?
+                        .try_into()
+                        .unwrap();
                     assigned_profile = true;
-                    header = header.strip_prefix(numeric_char)
-                                   .ok_or(Error::MqttCommandError)?;
+                    header = header
+                        .strip_prefix(numeric_char)
+                        .ok_or(Error::MqttCommandError)?;
                     // Remove forward slash ("/")
-                    header = header.strip_prefix("/")
-                                   .ok_or(Error::MqttCommandError)?;
-                },
+                    header = header.strip_prefix("/").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
@@ -679,7 +705,7 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::Switch(channel));
-                },
+                }
 
                 "Attenuation" => {
                     // Attenuation is a channel specific topic
@@ -687,14 +713,14 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         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
@@ -703,7 +729,7 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::ClockSource);
-                },
+                }
 
                 "Clock/Frequency" => {
                     // Clock/Frequency refers to the Urukul clock frequency
@@ -712,7 +738,7 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::ClockFrequency);
-                },
+                }
 
                 "Clock/Division" => {
                     // Clock/Division refers to the Urukul clock division
@@ -721,7 +747,7 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
                         return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::ClockDivision);
-                },
+                }
 
                 "SystemClock" => {
                     if !(assigned_channel && !assigned_profile) {
@@ -732,84 +758,84 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
 
                 "Singletone" => {
                     if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::Singletone(channel, profile));
                 }
 
                 "Singletone/Frequency" => {
                     if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::SingletoneFrequency(channel, profile));
                 }
 
                 "Singletone/Amplitude" => {
                     if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::SingletoneAmplitude(channel, profile));
                 }
 
                 "Singletone/Phase" => {
                     if !(assigned_channel && assigned_profile) {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::SingletonePhase(channel, profile));
                 }
 
                 "Profile" => {
                     if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::Profile);
                 }
 
                 "Save" => {
                     if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::Save);
                 }
 
                 "Load" => {
                     if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::Load);
                 }
 
                 "Background/Frequency" => {
                     if !assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::DefaultFTW(channel));
                 }
 
                 "Background/Amplitude" => {
                     if !assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::DefaultASF(channel));
                 }
 
                 "Buffer/Append" => {
                     if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::AppendBytes);
                 }
 
                 "Buffer/Commit" => {
                     if assigned_channel || assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::CommitBuffer);
                 }
 
                 "RAM" => {
                     if !assigned_channel || !assigned_profile {
-                        return Err(Error::MqttCommandError)
+                        return Err(Error::MqttCommandError);
                     }
                     return Ok(MqttTopic::RAM(channel, profile));
                 }
@@ -819,7 +845,11 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
         }
     }
 
-    fn parse_message<'a>(&mut self, topic: MqttTopic, message: &'a [u8]) -> IResult<&'a [u8], MqttCommand> {
+    fn parse_message<'a>(
+        &mut self,
+        topic: MqttTopic,
+        message: &'a [u8],
+    ) -> IResult<&'a [u8], MqttCommand> {
         match topic {
             MqttTopic::Reset => Ok((message, MqttCommand::Reset)),
             MqttTopic::Switch(ch) => switch_message(ch, message),
@@ -830,15 +860,19 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
             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::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),
             MqttTopic::Save => Ok((message, MqttCommand::Save)),
             MqttTopic::Load => Ok((message, MqttCommand::Load)),
             MqttTopic::DefaultFTW(ch) => default_frequency_message(ch, message),
             MqttTopic::DefaultASF(ch) => default_amplitude_message(ch, message),
-            MqttTopic::AppendBytes => unreachable!(),   // This topic should not be parsed
+            MqttTopic::AppendBytes => unreachable!(), // This topic should not be parsed
             MqttTopic::CommitBuffer => commit_buffer_message(message),
             MqttTopic::RAM(ch, pr) => ram_message(ch, pr, message),
         }
@@ -855,20 +889,30 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
             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::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),
             MqttCommand::Save => self.save_device(),
             MqttCommand::Load => self.load_device(),
             MqttCommand::DefaultFTW(ch, freq) => self.urukul.set_channel_default_ftw(ch, freq),
             MqttCommand::DefaultASF(ch, ampl) => self.urukul.set_channel_default_asf(ch, ampl),
-            MqttCommand::AppendBytes(_) => Ok(()),     // The bytes were not parsed and pushed
-            MqttCommand::CommitBuffer(dest, start_addr, ch) => self.urukul.commit_ram_buffer_to_channel(ch, start_addr, dest),
-            MqttCommand::RAM(ch, pr, start_addr, end_addr, op_mode, ramp_rate) => {
-                self.urukul.set_channel_ram_profile(ch, pr, start_addr, end_addr, op_mode, ramp_rate)
-            }
+            MqttCommand::AppendBytes(_) => Ok(()), // The bytes were not parsed and pushed
+            MqttCommand::CommitBuffer(dest, start_addr, ch) => self
+                .urukul
+                .commit_ram_buffer_to_channel(ch, start_addr, dest),
+            MqttCommand::RAM(ch, pr, start_addr, end_addr, op_mode, ramp_rate) => self
+                .urukul
+                .set_channel_ram_profile(ch, pr, start_addr, end_addr, op_mode, ramp_rate),
         }
     }
 
@@ -876,37 +920,38 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Clock/Source")
+                topic_string
+                    .push_str("/Feedback/Clock/Source")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
-            self.urukul.get_clock_source().map(
-                |src| match src {
-                    UrukulClockSource::OSC => String::from("OSC"),
-                    UrukulClockSource::MMCX => String::from("MMCX"),
-                    UrukulClockSource::SMA => String::from("SMA")
-                }
-            )?
+            self.urukul.get_clock_source().map(|src| match src {
+                UrukulClockSource::OSC => String::from("OSC"),
+                UrukulClockSource::MMCX => String::from("MMCX"),
+                UrukulClockSource::SMA => String::from("SMA"),
+            })?,
         ))
     }
 
-    fn get_clock_frequency_message(&mut self) -> Result<(String<U128>, String<U64>), Error<E>> {        
+    fn get_clock_frequency_message(&mut self) -> Result<(String<U128>, String<U64>), Error<E>> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Clock/Frequency")
+                topic_string
+                    .push_str("/Feedback/Clock/Frequency")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
             {
                 let mut freq_str = String::from(
-                    self.float_buffer.format_finite(
-                        self.urukul.get_clock_frequency()
-                    )
+                    self.float_buffer
+                        .format_finite(self.urukul.get_clock_frequency()),
                 );
-                freq_str.push_str(" Hz").map_err(|_| Error::StringOutOfSpace)?;
                 freq_str
-            }
+                    .push_str(" Hz")
+                    .map_err(|_| Error::StringOutOfSpace)?;
+                freq_str
+            },
         ))
     }
 
@@ -914,99 +959,110 @@ impl<'s, SPI, E> MqttMux<'s, SPI> where SPI: Transfer<u8, Error = E> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Clock/Division")
+                topic_string
+                    .push_str("/Feedback/Clock/Division")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
             {
-                self.urukul.get_clock_division().map(
-                    |src| match src {
-                        1 => String::from("1"),
-                        2 => String::from("2"),
-                        4 => String::from("4"),
-                        _ => unreachable!()
-                    }
-                )?
-            }
+                self.urukul.get_clock_division().map(|src| match src {
+                    1 => String::from("1"),
+                    2 => String::from("2"),
+                    4 => String::from("4"),
+                    _ => unreachable!(),
+                })?
+            },
         ))
     }
 
-    fn get_single_tone_frequency_message(&mut self, ch: u8, f_out: f64) -> Result<(String<U128>, String<U64>), Error<E>> {
+    fn get_single_tone_frequency_message(
+        &mut self,
+        ch: u8,
+        f_out: f64,
+    ) -> Result<(String<U128>, String<U64>), Error<E>> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Channel")
+                topic_string
+                    .push_str("/Feedback/Channel")
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                topic_string
+                    .push(char::from_digit(ch.into(), 10).unwrap())
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push_str("/Singletone/Frequency")
+                topic_string
+                    .push_str("/Singletone/Frequency")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
             {
-                let mut message_str = String::from(
-                    self.float_buffer.format_finite(f_out)
-                );
-                message_str.push_str(" Hz")
+                let mut message_str = String::from(self.float_buffer.format_finite(f_out));
+                message_str
+                    .push_str(" Hz")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 message_str
-            }
+            },
         ))
     }
 
-    fn get_single_tone_amplitude_message(&mut self, ch: u8, ampl: f64) -> Result<(String<U128>, String<U64>), Error<E>> {
+    fn get_single_tone_amplitude_message(
+        &mut self,
+        ch: u8,
+        ampl: f64,
+    ) -> Result<(String<U128>, String<U64>), Error<E>> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Channel")
+                topic_string
+                    .push_str("/Feedback/Channel")
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                topic_string
+                    .push(char::from_digit(ch.into(), 10).unwrap())
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push_str("/Singletone/Amplitude")
+                topic_string
+                    .push_str("/Singletone/Amplitude")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
             {
-                let message_str = String::from(
-                    self.float_buffer.format_finite(ampl)
-                );
+                let message_str = String::from(self.float_buffer.format_finite(ampl));
                 message_str
-            }
+            },
         ))
     }
 
-    fn get_single_tone_phase_message(&mut self, ch: u8, phase: f64) -> Result<(String<U128>, String<U64>), Error<E>> {
+    fn get_single_tone_phase_message(
+        &mut self,
+        ch: u8,
+        phase: f64,
+    ) -> Result<(String<U128>, String<U64>), Error<E>> {
         Ok((
             {
                 let mut topic_string = String::from(self.name);
-                topic_string.push_str("/Feedback/Channel")
+                topic_string
+                    .push_str("/Feedback/Channel")
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push(char::from_digit(ch.into(), 10).unwrap())
+                topic_string
+                    .push(char::from_digit(ch.into(), 10).unwrap())
                     .map_err(|_| Error::StringOutOfSpace)?;
-                topic_string.push_str("/Singletone/Phase")
+                topic_string
+                    .push_str("/Singletone/Phase")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 topic_string
             },
             {
-                let mut message_str = String::from(
-                    self.float_buffer.format_finite(phase)
-                );
-                message_str.push_str(" deg")
+                let mut message_str = String::from(self.float_buffer.format_finite(phase));
+                message_str
+                    .push_str(" deg")
                     .map_err(|_| Error::StringOutOfSpace)?;
                 message_str
-            }
+            },
         ))
     }
 }
 
 // Read message parameter separator (optional comma and whitespace)
 fn message_separator(message: &[u8]) -> IResult<&[u8], ()> {
-    preceded(
-        opt(
-            tag(",")
-        ),
-        whitespace
-    )(message)
+    preceded(opt(tag(",")), whitespace)(message)
 }
 
 // Read whitespace
@@ -1019,387 +1075,312 @@ 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"))
-                    ))
-                )
-            )
+            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)
-        }
+        |(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)
+    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)
+    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)
+    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)
+    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()
-            )
+    all_consuming(map(digit1, |div: &[u8]| {
+        MqttCommand::ClockDivision(
+            u8::from_str_radix(core::str::from_utf8(div).unwrap(), 10).unwrap(),
         )
-    )(message)
+    }))(message)
 }
 
 // Parser for one-command master clock setup message
 fn clock_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            permutation((
+    all_consuming(map(
+        permutation((
+            preceded(
+                tag_no_case("source:"),
                 preceded(
-                    tag_no_case("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"))
-                            )),
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        alt((
+                            value(UrukulClockSource::OSC, tag_no_case("OSC")),
+                            value(UrukulClockSource::MMCX, tag_no_case("MMCX")),
+                            value(UrukulClockSource::SMA, tag_no_case("SMA")),
+                        )),
+                        message_separator,
+                    ),
                 ),
+            ),
+            preceded(
+                tag_no_case("frequency:"),
+                preceded(whitespace, terminated(read_frequency, message_separator)),
+            ),
+            preceded(
+                tag_no_case("division:"),
                 preceded(
-                    tag_no_case("frequency:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            read_frequency,
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |div: &[u8]| {
+                            u8::from_str_radix(core::str::from_utf8(div).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
                 ),
-                preceded(
-                    tag_no_case("division:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |div: &[u8]| u8::from_str_radix(core::str::from_utf8(div).unwrap(), 10)
-                            ),
-                            message_separator
-                        )
-                    )
-                )
-            )),
-            |(src, freq, div): (UrukulClockSource, f64, u8)| MqttCommand::Clock(src, freq, div)
-        )
-    )(message)
+            ),
+        )),
+        |(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)
+    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)
+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 default frequency Command Message
 fn default_frequency_message(channel: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            read_frequency,
-            |freq: f64| MqttCommand::DefaultFTW(channel, freq)
-        )
-    )(message)
+    all_consuming(map(read_frequency, |freq: f64| {
+        MqttCommand::DefaultFTW(channel, 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)
+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 Default Amplitude Command Message
 fn default_amplitude_message(channel: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            double,
-            |ampl: f64| MqttCommand::DefaultASF(channel, ampl)
-        )
-    )(message)
+    all_consuming(map(double, |ampl: f64| {
+        MqttCommand::DefaultASF(channel, 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)
+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
 fn singletone_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            permutation((
+    all_consuming(map(
+        permutation((
+            preceded(
+                tag_no_case("frequency:"),
+                preceded(whitespace, terminated(read_frequency, message_separator)),
+            ),
+            preceded(
+                tag_no_case("amplitude:"),
+                preceded(whitespace, terminated(double, message_separator)),
+            ),
+            opt(preceded(
+                tag_no_case("phase:"),
                 preceded(
-                    tag_no_case("frequency:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            read_frequency,
-                            message_separator
-                        )
-                    )
-                ),
-                preceded(
-                    tag_no_case("amplitude:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            double,
-                            message_separator
-                        )
-                    )
-                ),
-                opt(
-                    preceded(
-                        tag_no_case("phase:"),
+                    whitespace,
+                    terminated(
+                        double,
                         preceded(
-                            whitespace,
-                            terminated(
-                                double,
-                                preceded(
-                                    opt(
-                                        preceded(
-                                            whitespace,
-                                            tag_no_case("deg")
-                                        )
-                                    ),
-                                    message_separator
-                                )
-                            )
-                        )
-                    )
-                )
+                            opt(preceded(whitespace, tag_no_case("deg"))),
+                            message_separator,
+                        ),
+                    ),
+                ),
             )),
-            |(freq, ampl, phase): (f64, f64, Option<f64>)| MqttCommand::Singletone(channel, profile, freq, phase.unwrap_or(0.0), ampl)
-        )
-    )(message)
+        )),
+        |(freq, ampl, phase): (f64, f64, Option<f64>)| {
+            MqttCommand::Singletone(channel, profile, freq, phase.unwrap_or(0.0), ampl)
+        },
+    ))(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)
+    all_consuming(map(digit1, |num: &[u8]| {
+        MqttCommand::Profile(u8::from_str_radix(core::str::from_utf8(num).unwrap(), 10).unwrap())
+    }))(message)
 }
 
 fn commit_buffer_message(message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            permutation((
+    all_consuming(map(
+        permutation((
+            preceded(
+                tag_no_case("dest:"),
                 preceded(
-                    tag_no_case("dest:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            alt((
-                                value(RAMDestination::Frequency, tag_no_case("frequency")),
-                                value(RAMDestination::Amplitude, tag_no_case("amplitude")),
-                                value(RAMDestination::Phase, tag_no_case("phase")),
-                                value(RAMDestination::Polar, tag_no_case("polar")),
-                            )),
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        alt((
+                            value(RAMDestination::Frequency, tag_no_case("frequency")),
+                            value(RAMDestination::Amplitude, tag_no_case("amplitude")),
+                            value(RAMDestination::Phase, tag_no_case("phase")),
+                            value(RAMDestination::Polar, tag_no_case("polar")),
+                        )),
+                        message_separator,
+                    ),
                 ),
+            ),
+            preceded(
+                tag_no_case("start:"),
                 preceded(
-                    tag_no_case("start:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |start_addr: &[u8]| u16::from_str_radix(core::str::from_utf8(start_addr).unwrap(), 10)
-                            ),
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |start_addr: &[u8]| {
+                            u16::from_str_radix(core::str::from_utf8(start_addr).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
                 ),
+            ),
+            preceded(
+                tag_no_case("ch:"),
                 preceded(
-                    tag_no_case("ch:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |ch: &[u8]| u8::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
-                            ),
-                            message_separator
-                        )
-                    )
-                )
-            )),
-            |(dest, start_addr, ch): (RAMDestination, u16, u8)| {
-                MqttCommand::CommitBuffer(dest, start_addr, ch)
-            }
-        )
-    )(message)
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |ch: &[u8]| {
+                            u8::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
+                ),
+            ),
+        )),
+        |(dest, start_addr, ch): (RAMDestination, u16, u8)| {
+            MqttCommand::CommitBuffer(dest, start_addr, ch)
+        },
+    ))(message)
 }
 
 fn ram_message(channel: u8, profile: u8, message: &[u8]) -> IResult<&[u8], MqttCommand> {
-    all_consuming(
-        map(
-            permutation((
+    all_consuming(map(
+        permutation((
+            preceded(
+                tag_no_case("start:"),
                 preceded(
-                    tag_no_case("start:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |ch: &[u8]| u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
-                            ),
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |ch: &[u8]| {
+                            u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
                 ),
+            ),
+            preceded(
+                tag_no_case("end:"),
                 preceded(
-                    tag_no_case("end:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |ch: &[u8]| u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
-                            ),
-                            message_separator
-                        )
-                    )
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |ch: &[u8]| {
+                            u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
                 ),
+            ),
+            preceded(
+                tag_no_case("op_mode:"),
                 preceded(
-                    tag_no_case("op_mode:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            alt((
-                                value(RAMOperationMode::DirectSwitch, tag_no_case("DS")),
-                                value(RAMOperationMode::RampUp, tag_no_case("RU")),
-                                value(RAMOperationMode::BidirectionalRamp, tag_no_case("BDR")),
-                                value(RAMOperationMode::ContinuousBidirectionalRamp, tag_no_case("CBDR")),
-                                value(RAMOperationMode::ContinuousRecirculate, tag_no_case("CR")),
-                            )),
-                            message_separator
-                        )
-                    )
-                ),
-                preceded(
-                    tag_no_case("ramp:"),
-                    preceded(
-                        whitespace,
-                        terminated(
-                            map_res(
-                                digit1,
-                                |ch: &[u8]| u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
+                    whitespace,
+                    terminated(
+                        alt((
+                            value(RAMOperationMode::DirectSwitch, tag_no_case("DS")),
+                            value(RAMOperationMode::RampUp, tag_no_case("RU")),
+                            value(RAMOperationMode::BidirectionalRamp, tag_no_case("BDR")),
+                            value(
+                                RAMOperationMode::ContinuousBidirectionalRamp,
+                                tag_no_case("CBDR"),
                             ),
-                            message_separator
-                        )
-                    )
-                )
-            )),
-            |(start_addr, end_addr, op_mode, ramp_rate): (u16, u16, RAMOperationMode, u16)| {
-                MqttCommand::RAM(channel, profile, start_addr, end_addr, op_mode, ramp_rate)
-            }
-        )
-    )(message)
+                            value(RAMOperationMode::ContinuousRecirculate, tag_no_case("CR")),
+                        )),
+                        message_separator,
+                    ),
+                ),
+            ),
+            preceded(
+                tag_no_case("ramp:"),
+                preceded(
+                    whitespace,
+                    terminated(
+                        map_res(digit1, |ch: &[u8]| {
+                            u16::from_str_radix(core::str::from_utf8(ch).unwrap(), 10)
+                        }),
+                        message_separator,
+                    ),
+                ),
+            ),
+        )),
+        |(start_addr, end_addr, op_mode, ramp_rate): (u16, u16, RAMOperationMode, u16)| {
+            MqttCommand::RAM(channel, profile, start_addr, end_addr, op_mode, ramp_rate)
+        },
+    ))(message)
 }
diff --git a/src/spi_slave.rs b/src/spi_slave.rs
index 8859b08..e7e7328 100644
--- a/src/spi_slave.rs
+++ b/src/spi_slave.rs
@@ -1,11 +1,8 @@
-use embedded_hal::{
-    blocking::spi::Transfer,
-    digital::v2::OutputPin,
-};
 use crate::cpld::CPLD;
 use crate::urukul::Error;
+use embedded_hal::{blocking::spi::Transfer, digital::v2::OutputPin};
 
-pub struct SPISlave<'a, SPI, CS0, CS1, CS2, GPIO> (
+pub struct SPISlave<'a, SPI, CS0, CS1, CS2, GPIO>(
     // SPI device to be multiplexed
     &'a CPLD<SPI, CS0, CS1, CS2, GPIO>,
     // Channel of SPI slave
@@ -48,8 +45,12 @@ where
 {
     type Error = Error<E>;
 
-    fn transfer<'w>(&mut self, words: &'w mut[u8]) -> Result<&'w [u8], Self::Error> {
-        let mut dev = self.0.data.try_borrow_mut().map_err(|_| Error::GetRefMutDataError)?;
+    fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error> {
+        let mut dev = self
+            .0
+            .data
+            .try_borrow_mut()
+            .map_err(|_| Error::GetRefMutDataError)?;
         dev.select_chip(self.1).map_err(|_| Error::CSError)?;
         let result = dev.spi.transfer(words).map_err(Error::SPI)?;
         dev.select_chip(0).map_err(|_| Error::CSError)?;
diff --git a/src/urukul.rs b/src/urukul.rs
index 1878fee..cb9f4bc 100644
--- a/src/urukul.rs
+++ b/src/urukul.rs
@@ -1,15 +1,13 @@
 extern crate embedded_hal;
-use embedded_hal::{
-    blocking::spi::Transfer,
-};
+use embedded_hal::blocking::spi::Transfer;
 
-use serde::{ Serialize, Deserialize };
+use serde::{Deserialize, Serialize};
 
-use crate::config_register::ConfigRegister;
-use crate::config_register::CFGMask;
-use crate::config_register::StatusMask;
 use crate::attenuator::Attenuator;
-use crate::dds::{ DDS, RAMOperationMode, RAMDestination };
+use crate::config_register::CFGMask;
+use crate::config_register::ConfigRegister;
+use crate::config_register::StatusMask;
+use crate::dds::{RAMDestination, RAMOperationMode, DDS};
 
 /*
  * Enum for structuring error
@@ -30,7 +28,7 @@ pub enum Error<E> {
     MqttCommandError,
     VectorOutOfSpace,
     StringOutOfSpace,
-    WaitRetry,          // Prompt driver to just wait and retry
+    WaitRetry, // Prompt driver to just wait and retry
 }
 
 impl<E> Error<E> {
@@ -68,7 +66,15 @@ where
      *  Master constructor for the entire Urukul device
      *  Supply 7 SPI channels to Urukul and 4 reference clock frequencies
      */
-    pub fn new(spi1: SPI, spi2: SPI, spi3: SPI, spi4: SPI, spi5: SPI, spi6: SPI, spi7: SPI) -> Self {
+    pub fn new(
+        spi1: SPI,
+        spi2: SPI,
+        spi3: SPI,
+        spi4: SPI,
+        spi5: SPI,
+        spi6: SPI,
+        spi7: SPI,
+    ) -> Self {
         // Construct Urukul
         Urukul {
             config_register: ConfigRegister::new(spi1),
@@ -100,21 +106,21 @@ where
         self.config_register.set_configurations(&mut [
             (CFGMask::RST, 1),
             (CFGMask::IO_RST, 1),
-            (CFGMask::IO_UPDATE, 0)
+            (CFGMask::IO_UPDATE, 0),
         ])?;
         // Set 0 to all fields on configuration register.
         self.config_register.set_configurations(&mut [
-            (CFGMask::RF_SW,        0),
-            (CFGMask::LED,          0),
-            (CFGMask::PROFILE,      0),
-            (CFGMask::IO_UPDATE,    0),
-            (CFGMask::MASK_NU,      0),
-            (CFGMask::CLK_SEL0,     0),
-            (CFGMask::SYNC_SEL,     0),
-            (CFGMask::RST,          0),
-            (CFGMask::IO_RST,       0),
-            (CFGMask::CLK_SEL1,     0),
-            (CFGMask::DIV,          0),
+            (CFGMask::RF_SW, 0),
+            (CFGMask::LED, 0),
+            (CFGMask::PROFILE, 0),
+            (CFGMask::IO_UPDATE, 0),
+            (CFGMask::MASK_NU, 0),
+            (CFGMask::CLK_SEL0, 0),
+            (CFGMask::SYNC_SEL, 0),
+            (CFGMask::RST, 0),
+            (CFGMask::IO_RST, 0),
+            (CFGMask::CLK_SEL1, 0),
+            (CFGMask::DIV, 0),
         ])?;
         // Init all DDS chips. Configure SDIO as input only.
         for chip_no in 0..4 {
@@ -145,12 +151,13 @@ where
 
 impl<SPI, E> Urukul<SPI>
 where
-    SPI: Transfer<u8, Error = E>
+    SPI: Transfer<u8, Error = E>,
 {
-
     pub fn get_channel_switch_status(&mut self, channel: u32) -> Result<bool, Error<E>> {
         if channel < 4 {
-            self.config_register.get_status(StatusMask::RF_SW).map(|val| (val & (1 << channel)) != 0)
+            self.config_register
+                .get_status(StatusMask::RF_SW)
+                .map(|val| (val & (1 << channel)) != 0)
         } else {
             Err(Error::ParameterError)
         }
@@ -166,15 +173,20 @@ where
                     prev & (!(1 << channel))
                 }
             };
-            self.config_register.set_configurations(&mut [
-                (CFGMask::RF_SW, next),
-            ]).map(|_| ())
+            self.config_register
+                .set_configurations(&mut [(CFGMask::RF_SW, next)])
+                .map(|_| ())
         } else {
             Err(Error::ParameterError)
         }
     }
 
-    pub fn set_clock(&mut self, source: ClockSource, frequency: f64, division: u8) -> Result<(), Error<E>> {
+    pub fn set_clock(
+        &mut self,
+        source: ClockSource,
+        frequency: f64,
+        division: u8,
+    ) -> Result<(), Error<E>> {
         // Change clock source through configuration register
         self.set_clock_source(source)?;
 
@@ -188,30 +200,29 @@ where
     pub fn get_clock_source(&mut self) -> Result<ClockSource, Error<E>> {
         match (
             self.config_register.get_configuration(CFGMask::CLK_SEL0),
-            self.config_register.get_configuration(CFGMask::CLK_SEL1)
+            self.config_register.get_configuration(CFGMask::CLK_SEL1),
         ) {
             (0, 0) => Ok(ClockSource::OSC),
             (0, 1) => Ok(ClockSource::MMCX),
             (1, _) => Ok(ClockSource::SMA),
-            _ => Err(Error::ConfigRegisterError)
+            _ => Err(Error::ConfigRegisterError),
         }
     }
 
     pub 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 [
-                (CFGMask::CLK_SEL0, 0),
-                (CFGMask::CLK_SEL1, 0),
-            ]),
-            ClockSource::MMCX => self.config_register.set_configurations(&mut [
-                (CFGMask::CLK_SEL0, 0),
-                (CFGMask::CLK_SEL1, 1),
-            ]),
-            ClockSource::SMA => self.config_register.set_configurations(&mut [
-                (CFGMask::CLK_SEL0, 1),
-            ]),
-        }.map(|_| ())
+            ClockSource::OSC => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::CLK_SEL0, 0), (CFGMask::CLK_SEL1, 0)]),
+            ClockSource::MMCX => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::CLK_SEL0, 0), (CFGMask::CLK_SEL1, 1)]),
+            ClockSource::SMA => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::CLK_SEL0, 1)]),
+        }
+        .map(|_| ())
     }
 
     pub fn get_clock_frequency(&mut self) -> f64 {
@@ -228,24 +239,24 @@ where
 
     pub fn get_clock_division(&mut self) -> Result<u8, Error<E>> {
         match self.config_register.get_configuration(CFGMask::DIV) {
-            0| 3 => Ok(4),
+            0 | 3 => Ok(4),
             1 => Ok(1),
             2 => Ok(2),
-            _ => Err(Error::ConfigRegisterError)
+            _ => Err(Error::ConfigRegisterError),
         }
     }
 
     pub fn set_clock_division(&mut self, division: u8) -> Result<(), Error<E>> {
         match division {
-            1 => self.config_register.set_configurations(&mut [
-                (CFGMask::DIV, 1),
-            ]),
-            2 => self.config_register.set_configurations(&mut [
-                (CFGMask::DIV, 2),
-            ]),
-            4 => self.config_register.set_configurations(&mut [
-                (CFGMask::DIV, 3),
-            ]),
+            1 => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::DIV, 1)]),
+            2 => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::DIV, 2)]),
+            4 => self
+                .config_register
+                .set_configurations(&mut [(CFGMask::DIV, 3)]),
             _ => Err(Error::ParameterError),
         }?;
 
@@ -276,11 +287,16 @@ where
         self.attenuator.get_channel_attenuation(channel)
     }
 
-    pub fn set_channel_attenuation(&mut self, channel: u8, attenuation: f32) -> Result<(), Error<E>> {
+    pub 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)
+        self.attenuator
+            .set_channel_attenuation(channel, attenuation)
     }
 
     pub fn get_profile(&mut self) -> Result<u8, Error<E>> {
@@ -291,38 +307,70 @@ where
         if profile >= 8 {
             return Err(Error::ParameterError);
         }
-        self.config_register.set_configurations(&mut [
-            (CFGMask::PROFILE, profile.into())
-        ]).map(|_| ())
+        self.config_register
+            .set_configurations(&mut [(CFGMask::PROFILE, profile.into())])
+            .map(|_| ())
     }
 
-    pub 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 {
+    pub 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)
     }
-    
-    pub fn get_channel_single_tone_profile(&mut self, channel: u8, profile: u8) -> Result<(f64, f64, f64), Error<E>> {
+
+    pub fn get_channel_single_tone_profile(
+        &mut self,
+        channel: u8,
+        profile: u8,
+    ) -> Result<(f64, f64, f64), Error<E>> {
         self.dds[usize::from(channel)].get_single_tone_profile(profile)
     }
 
-    pub fn set_channel_single_tone_profile_frequency(&mut self, channel: u8, profile: u8, frequency: f64)-> Result<(), Error<E>> {
+    pub 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)
     }
 
-    pub fn set_channel_single_tone_profile_phase(&mut self, channel: u8, profile: u8, phase: f64)-> Result<(), Error<E>> {
+    pub 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)
     }
 
-    pub fn set_channel_single_tone_profile_amplitude(&mut self, channel: u8, profile: u8, amplitude: f64)-> Result<(), Error<E>> {
+    pub 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);
         }
@@ -330,18 +378,20 @@ where
     }
 
     pub fn append_dds_ram_buffer(&mut self, data: &[u8]) -> Result<(), Error<E>> {
-        unsafe {
-            Ok(crate::dds::append_ram_byte(data))
-        }
+        unsafe { Ok(crate::dds::append_ram_byte(data)) }
     }
 
     // Use profile 7 to write into the RAM
-    pub fn commit_ram_buffer_to_channel(&mut self, channel: u8, start_addr: u16, ram_dest: RAMDestination) -> Result<(), Error<E>> {
+    pub fn commit_ram_buffer_to_channel(
+        &mut self,
+        channel: u8,
+        start_addr: u16,
+        ram_dest: RAMDestination,
+    ) -> Result<(), Error<E>> {
         let profile = self.get_profile()?;
         self.set_profile(7)?;
         unsafe {
-            self.dds[usize::from(channel)]
-                .commit_ram_buffer(start_addr, ram_dest)?;
+            self.dds[usize::from(channel)].commit_ram_buffer(start_addr, ram_dest)?;
         }
         self.set_profile(profile)
     }
@@ -350,7 +400,11 @@ where
         self.dds[usize::from(channel)].set_default_ftw(frequency)
     }
 
-    pub fn set_channel_default_asf(&mut self, channel: u8, amplitude_scale: f64) -> Result<(), Error<E>> {
+    pub fn set_channel_default_asf(
+        &mut self,
+        channel: u8,
+        amplitude_scale: f64,
+    ) -> Result<(), Error<E>> {
         self.dds[usize::from(channel)].set_default_asf(amplitude_scale)
     }
 
@@ -362,14 +416,25 @@ where
         self.dds[usize::from(channel)].get_default_asf()
     }
 
-    pub fn set_channel_ram_profile(&mut self, channel: u8, profile: u8, start_addr: u16,
-        end_addr: u16, op_mode: RAMOperationMode, ramp_rate: u16
+    pub fn set_channel_ram_profile(
+        &mut self,
+        channel: u8,
+        profile: u8,
+        start_addr: u16,
+        end_addr: u16,
+        op_mode: RAMOperationMode,
+        ramp_rate: u16,
     ) -> Result<(), Error<E>> {
-        self.dds[usize::from(channel)]
-            .set_up_ram_profile(profile, start_addr, end_addr, true, false, op_mode, ramp_rate)
+        self.dds[usize::from(channel)].set_up_ram_profile(
+            profile, start_addr, end_addr, true, false, op_mode, ramp_rate,
+        )
     }
 
-    pub fn get_channel_ram_profile(&mut self, channel: u8, profile: u8) -> Result<(u16, u16, u16, u8), Error<E>> {
+    pub fn get_channel_ram_profile(
+        &mut self,
+        channel: u8,
+        profile: u8,
+    ) -> Result<(u16, u16, u16, u8), Error<E>> {
         self.dds[usize::from(channel)].get_ram_profile(profile)
     }
 
@@ -406,17 +471,28 @@ where
     // Note: If a channel is masked, io_update must be completed through configuration register (IO_UPDATE bit-field)
     // Implication: Deselect such channel if individual communication is needed.
     pub fn set_multi_channel_coverage(&mut self, channel: u8) -> Result<(), Error<E>> {
-        self.config_register.set_configurations(&mut [
-            (CFGMask::MASK_NU, channel.into())
-        ]).map(|_| ())
+        self.config_register
+            .set_configurations(&mut [(CFGMask::MASK_NU, channel.into())])
+            .map(|_| ())
     }
 
     // Difference from individual single tone setup function:
     // - Remove the need of passing channel
     // All selected channels must share the same f_sys_clk
-    pub fn set_multi_channel_single_tone_profile(&mut self, profile: u8, frequency: f64, phase: f64, amplitude: f64) -> Result<(), Error<E>> {
-        if profile >= 8 || frequency < 0.0 || phase >= 360.0 ||
-            phase < 0.0 || amplitude < 0.0 || amplitude > 1.0 {
+    pub fn set_multi_channel_single_tone_profile(
+        &mut self,
+        profile: u8,
+        frequency: f64,
+        phase: f64,
+        amplitude: f64,
+    ) -> Result<(), Error<E>> {
+        if profile >= 8
+            || frequency < 0.0
+            || phase >= 360.0
+            || phase < 0.0
+            || amplitude < 0.0
+            || amplitude > 1.0
+        {
             return Err(Error::ParameterError);
         }
         // Check f_sys_clk of all selected channels
@@ -434,18 +510,18 @@ where
             }
         }
         self.multi_dds.set_sys_clk_frequency(reported_f_sys_clk)?;
-        self.multi_dds.set_single_tone_profile(profile, frequency, phase, amplitude)?;
+        self.multi_dds
+            .set_single_tone_profile(profile, frequency, phase, amplitude)?;
         self.invoke_io_update()
     }
 
     // Generate a pulse for io_update bit in configuration register
     // This acts like io_update in CPLD struct, but for multi-dds channel
     fn invoke_io_update(&mut self) -> Result<(), Error<E>> {
-        self.config_register.set_configurations(&mut [
-            (CFGMask::IO_UPDATE, 1)
-        ])?;
-        self.config_register.set_configurations(&mut [
-            (CFGMask::IO_UPDATE, 0)
-        ]).map(|_| ())
+        self.config_register
+            .set_configurations(&mut [(CFGMask::IO_UPDATE, 1)])?;
+        self.config_register
+            .set_configurations(&mut [(CFGMask::IO_UPDATE, 0)])
+            .map(|_| ())
     }
 }