updated flake and sem2

2sem_sem2/src/bin/main.rs

@@ -0,0 +1,126 @@
+// src/bin/main.rs
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use core::sync::atomic::{AtomicBool, Ordering};
+use embassy_executor::Spawner;
+use embassy_stm32::usart::{Config, Uart, UartRx, UartTx, InterruptHandler};
+use embassy_stm32::peripherals::{USART1, USART3};
+use embassy_stm32::bind_interrupts;
+use embassy_time::{Duration, Timer};
+use embassy_sync::channel::Channel;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    USART1 => InterruptHandler<USART1>;
+    USART3 => InterruptHandler<USART3>;
+});
+
+static PIPE: Channel<CriticalSectionRawMutex, u8, 64> = Channel::new();
+static SEND_ALLOWED: AtomicBool = AtomicBool::new(true);
+static REC_ALLOWED: AtomicBool = AtomicBool::new(true);
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    info!("tititititi");
+
+    let p = embassy_stm32::init(Default::default());
+
+    let config = Config::default();
+    let dev_usart = Uart::new(
+        p.USART1,
+        p.PA10,
+        p.PA9,
+        Irqs,
+        p.GPDMA1_CH0, // TX DMA
+        p.GPDMA1_CH1, // RX DMA
+        config,
+    ).unwrap();
+
+    let uart = Uart::new(
+        p.USART3,
+        p.PD9, // RX zo zariadenia
+        p.PD8, // TX do zariadenia
+        Irqs,
+        p.GPDMA1_CH2,
+        p.GPDMA1_CH3,
+        config,
+    ).unwrap();
+    let (mut tx, rx) = uart.split();
+    let (dev_tx, dev_rx) = dev_usart.split();
+    spawner.spawn(rx_task(rx, dev_tx)).unwrap();
+    spawner.spawn(toggle_rec_task()).unwrap();
+
+    let sender = PIPE.sender();
+    let receiver = PIPE.receiver();
+
+    info!("starting echo");
+
+    let data = b"filip\r\n";
+    let idle = &[0x13u8];
+
+    loop {
+        // rec_allowed = (start_time.elapsed().as_secs() / 2) % 2 == 0;
+        let current_send_allowed = SEND_ALLOWED.load(Ordering::Relaxed);
+        let current_rec_allowed = REC_ALLOWED.load(Ordering::Relaxed);
+        if current_rec_allowed == true {
+            if current_send_allowed {
+                if let Ok(stored_byte) = receiver.try_receive() {
+                    let _ = tx.write(&[stored_byte]).await;
+                } else {
+                    let _ = tx.write(data).await;
+                }
+            } else {
+                for b in data {
+                    let _ = sender.try_send(*b);
+                }
+            }
+        } else {
+            let _ = tx.write(idle).await;
+        }
+        let _ = Timer::after(Duration::from_millis(100));
+    }
+}
+
+#[embassy_executor::task]
+async fn rx_task(
+    mut rx: UartRx<'static, embassy_stm32::mode::Async>,
+    mut pc_tx: UartTx<'static, embassy_stm32::mode::Async>
+) {
+    let mut buf = [0u8; 1];
+    loop {
+        if rx.read(&mut buf).await.is_ok() {
+            match buf[0] {
+                0x11 => {
+                    SEND_ALLOWED.store(true, Ordering::Relaxed);
+                    info!("Vysielanie povolené");
+                }
+                0x13 => {
+                    SEND_ALLOWED.store(false, Ordering::Relaxed);
+                    info!("Vysielanie zakázané");
+                }
+                _ => {}
+            }
+            let _ = pc_tx.write(&buf).await;
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn toggle_rec_task() {
+    loop {
+        Timer::after(Duration::from_secs(2)).await;
+        // Načítame aktuálnu hodnotu a uložíme jej opak
+        let current = REC_ALLOWED.load(Ordering::Relaxed);
+        REC_ALLOWED.store(!current, Ordering::Relaxed);
+
+        if !current {
+            info!("REC_ALLOWED: true");
+        } else {
+            info!("REC_ALLOWED: false");
+        }
+    }
+}