split the codebase

2sem_sem2/Cargo.lock

@@ -616,32 +616,6 @@ dependencies = [
  "pin-utils",
 ]
 
-[[package]]
-name = "hal_rng"
-version = "0.1.0"
-dependencies = [
- "cortex-m",
- "cortex-m-rt",
- "defmt 1.0.1",
- "defmt-rtt",
- "embassy-executor",
- "embassy-futures",
- "embassy-stm32",
- "embassy-sync",
- "embassy-time",
- "embassy-usb",
- "embedded-graphics",
- "embedded-hal 1.0.0",
- "embedded-io",
- "embedded-io-async",
- "heapless 0.9.1",
- "micromath",
- "panic-halt",
- "panic-probe",
- "static_cell",
- "tinybmp",
-]
-
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -836,6 +810,32 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b328e2cb950eeccd55b7f55c3a963691455dcd044cfb5354f0c5e68d2c2d6ee2"
 
+[[package]]
+name = "semestralka2"
+version = "0.1.0"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+ "defmt 1.0.1",
+ "defmt-rtt",
+ "embassy-executor",
+ "embassy-futures",
+ "embassy-stm32",
+ "embassy-sync",
+ "embassy-time",
+ "embassy-usb",
+ "embedded-graphics",
+ "embedded-hal 1.0.0",
+ "embedded-io",
+ "embedded-io-async",
+ "heapless 0.9.1",
+ "micromath",
+ "panic-halt",
+ "panic-probe",
+ "static_cell",
+ "tinybmp",
+]
+
 [[package]]
 name = "semver"
 version = "0.9.0"

2sem_sem2/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 authors = ["Priec <filippriec@gmail.com>"]
-name = "hal_rng"
+name = "semestralka2"
 edition = "2024"
 version = "0.1.0"
 

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, Timer};
-use embassy_time::{Duration, Ticker, 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_send(tx, sender_receiver)).unwrap();
-    spawner.spawn(bit_receive(rx, receiver_sender)).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;
-        }
-    }
-}

2sem_sem2/src/lib.rs

@@ -1 +1,4 @@
 #![no_std]
+
+pub mod receive;
+pub mod send;

2sem_sem2/src/receive.rs

@@ -0,0 +1,71 @@
+use defmt::info;
+use embassy_stm32::exti::ExtiInput;
+use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Receiver};
+use embassy_time::Timer;
+
+#[embassy_executor::task]
+pub async fn bit_receive_and_decode(mut pin: ExtiInput<'static>) {
+    loop {
+        pin.wait_for_falling_edge().await;
+
+        let t1 = embassy_time::Instant::now();
+
+        pin.wait_for_rising_edge().await;
+        let bit_time = embassy_time::Instant::now().duration_since(t1);
+
+        let _ = Timer::after(bit_time).await;
+
+        let mut message_buffer = [0u8; 8]; // sprava
+        let mut byte_idx = 0;
+        let mut frame_active = true;
+
+        while frame_active && byte_idx < message_buffer.len() {
+            let mut current_byte = 0u8;
+
+            for _ in 0..8 {
+                let bit = if pin.is_high() { 1 } else { 0 };
+                current_byte = (current_byte << 1) | bit;
+                Timer::after(bit_time).await;
+            }
+
+            if current_byte == 0xAA {
+                frame_active = false;
+            } else {
+                message_buffer[byte_idx] = current_byte;
+                byte_idx += 1;
+            }
+        }
+
+        if let Ok(s) = core::str::from_utf8(&message_buffer[..byte_idx]) {
+            info!("sprava: {}", s);
+        }
+    }
+}
+
+#[embassy_executor::task]
+pub async fn bit_decode(receiver: Receiver<'static, CriticalSectionRawMutex, u8, 64>) {
+    let mut buffer = 0u64;
+    loop {
+        let bit = receiver.receive().await;
+        buffer = (buffer << 1) | (bit as u64);
+
+        // sync 0xAA + start 0xAB
+        if (buffer & 0xFFFF) == 0xAAAB {
+            info!("frame");
+            let mut message = [0u8; 4];
+
+            for byte in message.iter_mut() {
+                for _ in 0..8 {
+                    let b = receiver.receive().await;
+                    *byte = (*byte << 1) | b;
+                }
+            }
+
+            if let Ok(s) = core::str::from_utf8(&message) {
+                info!("Received: {}", s);
+            }
+
+            buffer = 0;
+        }
+    }
+}

2sem_sem2/src/send.rs

@@ -0,0 +1,73 @@
+// src/send.rs
+
+use core::sync::atomic::{AtomicBool, Ordering};
+use defmt::info;
+use embassy_stm32::gpio::Output;
+use embassy_sync::{
+    blocking_mutex::raw::CriticalSectionRawMutex,
+    channel::{Receiver, Sender},
+};
+use embassy_time::{Duration, Ticker};
+use heapless::Vec;
+
+static SEND_ALLOWED: AtomicBool = AtomicBool::new(true);
+
+pub fn encode(word: &str, v: &mut 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;
+            }
+        }
+    }
+}
+
+pub 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]
+pub async fn bit_send(
+    mut pin: Output<'static>,
+    receiver: Receiver<'static, CriticalSectionRawMutex, u8, 64>,
+) {
+    let mut ticker = Ticker::every(Duration::from_millis(10));
+    loop {
+        let bit = receiver.receive().await;
+        if bit == 1 {
+            pin.set_high();
+        } else {
+            pin.set_low();
+        }
+        // bitrate
+        ticker.next().await;
+    }
+}