Moved max6675 code to own files

src/main.rs

@@ -20,35 +20,38 @@ use hcl::platform::dma;
 use hcl::dma::*;
 
 mod printer;
+mod max6675;
+
 
 use printer::UsartPrinter;
 
+
 fn configure_clocks(rcc: &mut rcc::RCC) {
     rcc.clock_control.set_hse_on(true);
-    while !rcc.clock_control.hse_ready() {
+    while !rcc.clock_control.hse_ready() {}
-    }
 
-    rcc.clock_config.configure(|c| c
+    rcc.clock_config
-        .set_pll_multiplier(10)
+        .configure(|c| {
-        .set_pll_source(rcc::PllSource::HsiDiv2));
+                       c.set_pll_multiplier(10)
+                           .set_pll_source(rcc::PllSource::HsiDiv2)
+                   });
 
     rcc.clock_control.set_pll_on(true);
-    while !rcc.clock_control.pll_ready() {
+    while !rcc.clock_control.pll_ready() {}
-    }
 
-    rcc.clock_config.switch_clock_source(rcc::SystemClockSource::Pll);
+    rcc.clock_config
+        .switch_clock_source(rcc::SystemClockSource::Pll);
 }
 
 fn configure_peripherals(rcc: &mut hcl::platform::rcc::RCC,
-                                gpio: &mut gpio::GPIO,
+                         gpio: &mut gpio::GPIO,
-                                usart: &mut usart::USART) {
+                         usart: &mut usart::USART) {
-    rcc.apb2_enable.configure(|a| a
+    rcc.apb2_enable
-        .set_gpio_a(true)
+        .configure(|a| a.set_gpio_a(true).set_spi1(true));
-        .set_spi1(true));
+    rcc.apb1_enable.configure(|a| a.set_usart2(true));
-    rcc.apb1_enable.configure(|a| a
-        .set_usart2(true));
 
-    gpio.configure(|g| g
+    gpio.configure(|g| {
+        g
         .set_mode(2, gpio::PinMode::Output50MHz)
         .set_output_config(2, gpio::OutputConfig::AfPushPull)
         .set_mode(3, gpio::PinMode::Output50MHz)
@@ -63,12 +66,14 @@ fn configure_peripherals(rcc: &mut hcl::platform::rcc::RCC,
         .set_mode(6, gpio::PinMode::Input)
         // NSS1
         .set_mode(4, gpio::PinMode::Output50MHz)
-        .set_output_config(4, gpio::OutputConfig::PushPull));
+        .set_output_config(4, gpio::OutputConfig::PushPull)
+    });
 
-    usart.configure(|u| u
+    usart.configure(|u| {
-        .set_enabled(true)
+                        u.set_enabled(true)
-        .set_tx_enabled(true)
+                            .set_tx_enabled(true)
-        .set_baudgen((21, 11))); // 115.2 kbaud
+                            .set_baudgen((21, 11))
+                    }); // 115.2 kbaud
 }
 
 
@@ -81,31 +86,22 @@ fn run(mut scs: scs::Instance, mut p: hcl::platform::Instance) {
 
     let mut printer = UsartPrinter::init(p.usart2);
 
-    let mut spi = p.spi1;
+
-    spi.configure(|s| s
+    let spi = &mut p.spi1;
-        .set_enabled(true)
+    let gpio = &mut p.gpio_a;
-        .set_master_mode(true)
+
-        .set_bidi_tx(false)
-        .set_clock_divider(128)
-        .set_data_16bit(true)
-        .set_clock_idles_high(false)
-        .set_lsb_first(false)
-        .set_clock_skip_first(true));
 
     loop {
         for i in 0u16..0xffff {
-            let x = format!("> {}\r\n", i).into_bytes();
 
-            p.gpio_a.set_bit(4);
+            let res = max6675::read(spi, gpio, 4);
-            spi.set_data(i.into());
 
-            while spi.busy() {
+            let msg = match res {
+                Ok(temp) => format!("> {}\r\n", temp).into_bytes(),
+                Err(err) => format!("Error > {}\r\n", err).into_bytes(),
+            };
 
-            }
+            printer.print(msg);
-            p.gpio_a.reset_bit(4);
-
-
-            printer.print(x);
         }
     }
 }
@@ -113,7 +109,7 @@ fn run(mut scs: scs::Instance, mut p: hcl::platform::Instance) {
 
 entry_point!(main);
 fn main(scs: scs::Instance, p: hcl::platform::Instance) {
-    declare_thread_stack!(stack, 512);
+    declare_thread_stack!(stack, 3072);
 
     unsafe {
         hcl::set_process_stack(&stack);

src/max6675.rs

@@ -0,0 +1,40 @@
+use hcl::platform::PeripheralRef;
+use hcl::platform::Location;
+use hcl::platform::spi;
+use hcl::platform::gpio;
+
+pub fn read<SPIAddr, GPIOAddr>(spi: &mut PeripheralRef<spi::SPI, SPIAddr>,
+                               nss_gpio: &mut PeripheralRef<gpio::GPIO, GPIOAddr>,
+                               nss_idx: u32)
+                               -> Result<f32, &'static str>
+    where SPIAddr: Location,
+          GPIOAddr: Location
+{
+    spi.configure(|s| {
+                      s.set_enabled(true)
+                          .set_master_mode(true)
+                          .set_software_slave_select(true)
+                          .set_clock_divider(128)
+                          .set_data_16bit(true)
+                          .set_clock_skip_first(true)
+                  });
+
+    nss_gpio.reset_bit(nss_idx);
+
+    spi.set_data(0x0000);
+    while !spi.rx_buffer_not_empty() {}
+    let raw_result = spi.data();
+
+    while spi.busy() {}
+
+    nss_gpio.set_bit(nss_idx);
+    spi.set_enabled(false);
+
+
+    if raw_result & (1 << 2) != 0 {
+        Err("MAX6675: Termocouple measures open")
+    } else {
+        let result = ((raw_result >> 3) as f32) * 0.25;
+        Ok(result)
+    }
+}

src/printer.rs

@@ -10,25 +10,24 @@ use alloc::vec::Vec;
 
 
 
-pub struct UsartPrinter<Addr> where
+pub struct UsartPrinter<Addr>
-    Addr : hcl::platform::Location, {
+    where Addr: hcl::platform::Location
-    usart: PeripheralRef<usart::USART, Addr>
+{
+    usart: PeripheralRef<usart::USART, Addr>,
 }
 
-impl<Addr> UsartPrinter<Addr> where Addr : hcl::platform::Location {
+impl<Addr> UsartPrinter<Addr>
-
+    where Addr: hcl::platform::Location
+{
     pub fn init(usart: PeripheralRef<usart::USART, Addr>) -> UsartPrinter<Addr> {
-        UsartPrinter {
+        UsartPrinter { usart: usart }
-            usart: usart,
-        }
     }
 
     pub fn print(&mut self, data: Vec<u8>) -> () {
         for byte in data {
             self.usart.clear_tx_complete();
             self.usart.set_data(byte.into());
-            while !self.usart.tx_complete() {
+            while !self.usart.tx_complete() {}
-            };
         }
     }
 }