split the codebase

2sem_sem2/src/bin/main.rs

@@ -2,7 +2,6 @@
 #![no_std]
 #![no_main]
 
-use core::sync::atomic::{AtomicBool, Ordering};
 use defmt::info;
 use embassy_executor::Spawner;
 use embassy_stm32::exti::ExtiInput;
@@ -10,15 +9,15 @@ use embassy_stm32::gpio;
 use embassy_stm32::gpio::{Output, Pull};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::channel::Channel;
-use embassy_sync::channel::Sender;
-use embassy_time::{Duration, Ticker, Timer};
+use embassy_time::{Duration, Timer};
 use heapless::Vec;
+use semestralka2::receive::{bit_decode, bit_receive_and_decode};
+use semestralka2::send::*;
 
 use {defmt_rtt as _, panic_probe as _};
 
 static PIPE: Channel<CriticalSectionRawMutex, u8, 64> = Channel::new();
 static PIPE_REC: Channel<CriticalSectionRawMutex, u8, 64> = Channel::new();
-static SEND_ALLOWED: AtomicBool = AtomicBool::new(true);
 // static REC_ALLOWED: AtomicBool = AtomicBool::new(true);
 
 #[embassy_executor::main]
@@ -31,19 +30,22 @@ async fn main(spawner: Spawner) {
 
     // let config = Config::default();
     let sender = PIPE.sender();
+    let sender_receiver = PIPE.receiver();
     let receiver_sender = PIPE_REC.sender();
+    let receiver_reader = PIPE_REC.receiver();
     // let receiver = PIPE.receiver();
 
-    spawner.spawn(bit_send(tx)).unwrap();
-    spawner.spawn(bit_receive(rx, receiver_sender)).unwrap();
+    spawner.spawn(bit_send(tx, sender_receiver)).unwrap();
+    spawner.spawn(bit_receive_and_decode(rx)).unwrap();
+    spawner.spawn(bit_decode(receiver_reader)).unwrap();
 
     info!("starting echo");
-    let v: Vec<u8, 38, u8> = Vec::new();
+    let mut v: Vec<u8, 38, u8> = Vec::new();
 
     loop {
         let slovko = "ahoj";
         info!("slovo: {}", slovko);
-        let vektorik = encode(slovko, v.clone());
+        let vektorik = encode(slovko, &mut v);
         info!("slovo: {:#?}", vektorik);
 
         info!("enkodovane, posielame do pipy...");
@@ -53,95 +55,3 @@ async fn main(spawner: Spawner) {
         embassy_time::block_for(Duration::from_millis(1000));
     }
 }
-
-fn encode(word: &str, mut v: Vec<u8, 38, u8>) {
-    v.clear();
-    for byte in word.bytes() {
-        for bit in 0..8 {
-            let bit_value = (byte >> (7 - bit)) & 1;
-            if v.push(bit_value).is_err() {
-                info!("we panick boyz");
-                return;
-            }
-        }
-    }
-}
-
-async fn nrz(enkodovany: &Vec<u8, 38, u8>, sender: &Sender<'_, CriticalSectionRawMutex, u8, 64>) {
-    if !SEND_ALLOWED.load(Ordering::Relaxed) {
-        return;
-    }
-    let sync_hod: u8 = 0xAA;
-    let start_bits: u8 = 0xAB;
-    let sequence = [sync_hod, start_bits];
-
-    for byte in sequence {
-        for i in (0..8).rev() {
-            sender.send((byte >> i) & 1).await;
-        }
-    }
-
-    for &bit in enkodovany {
-        sender.send(bit).await;
-    }
-
-    for i in (0..8).rev() {
-        sender.send((sync_hod >> i) & 1).await;
-    }
-
-    // idle
-    sender.send(1).await;
-}
-
-#[embassy_executor::task]
-async fn bit_send(mut pin: Output<'static>) {
-    let mut ticker = Ticker::every(Duration::from_millis(10));
-    let receiver = PIPE.receiver();
-    loop {
-        let bit = receiver.receive().await;
-        if bit == 1 {
-            pin.set_high();
-        } else {
-            pin.set_low();
-        }
-        // bitrate
-        ticker.next().await;
-    }
-}
-
-#[embassy_executor::task]
-async fn bit_receive(
-    mut pin: ExtiInput<'static>,
-    sender: Sender<'static, CriticalSectionRawMutex, u8, 64>,
-) {
-    let mut last_tick = embassy_time::Instant::now();
-    let mut measured_bit_time = 0;
-
-    loop {
-        pin.wait_for_any_edge().await;
-
-        let now = embassy_time::Instant::now();
-        let diff = now.duration_since(last_tick).as_ticks();
-        last_tick = now;
-
-        if diff == 0 {
-            continue;
-        }
-
-        if measured_bit_time == 0 {
-            measured_bit_time = diff;
-            let bit_val = if pin.is_high() { 0 } else { 1 };
-            sender.send(bit_val).await;
-            continue;
-        }
-
-        let count = (diff + (measured_bit_time / 2)) / measured_bit_time;
-
-        let bit_val = if pin.is_high() { 0 } else { 1 };
-
-        for _ in 0..count {
-            info!("{}", bit_val);
-            sender.send(bit_val).await;
-        }
-    }
-}