From 5399983dfb81a4f02da0edd5c206928e35e3b95f Mon Sep 17 00:00:00 2001 From: Priec Date: Sun, 17 May 2026 16:26:33 +0200 Subject: [PATCH] split the codebase --- 2sem_sem2/Cargo.lock | 52 +++++++++--------- 2sem_sem2/Cargo.toml | 2 +- 2sem_sem2/src/bin/main.rs | 110 ++++---------------------------------- 2sem_sem2/src/lib.rs | 3 ++ 2sem_sem2/src/receive.rs | 71 ++++++++++++++++++++++++ 2sem_sem2/src/send.rs | 73 +++++++++++++++++++++++++ 6 files changed, 184 insertions(+), 127 deletions(-) create mode 100644 2sem_sem2/src/receive.rs create mode 100644 2sem_sem2/src/send.rs diff --git a/2sem_sem2/Cargo.lock b/2sem_sem2/Cargo.lock index e361bed..6597cf6 100644 --- a/2sem_sem2/Cargo.lock +++ b/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" diff --git a/2sem_sem2/Cargo.toml b/2sem_sem2/Cargo.toml index f263386..10291c0 100644 --- a/2sem_sem2/Cargo.toml +++ b/2sem_sem2/Cargo.toml @@ -1,6 +1,6 @@ [package] authors = ["Priec "] -name = "hal_rng" +name = "semestralka2" edition = "2024" version = "0.1.0" diff --git a/2sem_sem2/src/bin/main.rs b/2sem_sem2/src/bin/main.rs index 00db6e2..2560b0b 100644 --- a/2sem_sem2/src/bin/main.rs +++ b/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 = Channel::new(); static PIPE_REC: Channel = 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 = Vec::new(); + let mut v: Vec = 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) { - 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, 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; - } - } -} diff --git a/2sem_sem2/src/lib.rs b/2sem_sem2/src/lib.rs index 0c9ac1a..79668fa 100644 --- a/2sem_sem2/src/lib.rs +++ b/2sem_sem2/src/lib.rs @@ -1 +1,4 @@ #![no_std] + +pub mod receive; +pub mod send; diff --git a/2sem_sem2/src/receive.rs b/2sem_sem2/src/receive.rs new file mode 100644 index 0000000..824f7d5 --- /dev/null +++ b/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; + } + } +} diff --git a/2sem_sem2/src/send.rs b/2sem_sem2/src/send.rs new file mode 100644 index 0000000..8df3687 --- /dev/null +++ b/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) { + 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, + 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; + } +}