From 2eaa561a0a161ae4b43c7c3f14b98d90b4bcbb08 Mon Sep 17 00:00:00 2001
From: "henthe-5@student.ltu.se" <henthe-5@student.ltu.se>
Date: Fri, 8 Mar 2019 13:48:08 +0100
Subject: [PATCH] bare10_3
---
examples/bare10.rs | 108 +++++++++++++++++++++++++++++++++++++++------
1 file changed, 95 insertions(+), 13 deletions(-)
diff --git a/examples/bare10.rs b/examples/bare10.rs
index bcce5c6..353561a 100644
--- a/examples/bare10.rs
+++ b/examples/bare10.rs
@@ -14,10 +14,10 @@ use cortex_m::{asm, iprintln};
extern crate stm32f4xx_hal as hal;
use crate::hal::prelude::*;
use crate::hal::serial::{config::Config, Event, Rx, Serial, Tx};
-use hal::stm32::ITM;
-
+use hal::stm32::{ITM};
+use hal::gpio::{PushPull, Output, gpioa::PA5};
use nb::block;
-use rtfm::app;
+use rtfm::{app, Instant};
// Our error type
#[derive(Debug)]
@@ -33,9 +33,11 @@ const APP: () = {
static mut TX: Tx<hal::stm32::USART2> = ();
static mut RX: Rx<hal::stm32::USART2> = ();
static mut ITM: ITM = ();
-
+ static mut TIMEOFFSET: u32 = 1;
+ static mut PA5: PA5<Output<PushPull>> = ();
+ static mut IS_ON: bool = true;
// init runs in an interrupt free section>
- #[init]
+ #[init(schedule = [on])]
fn init() {
let stim = &mut core.ITM.stim[0];
iprintln!(stim, "bare10");
@@ -44,11 +46,12 @@ const APP: () = {
// 16 MHz (default, all clocks)
let clocks = rcc.cfgr.freeze();
-
+
let gpioa = device.GPIOA.split();
let tx = gpioa.pa2.into_alternate_af7();
let rx = gpioa.pa3.into_alternate_af7(); // try comment out
+ let pa5out = gpioa.pa5.into_push_pull_output();
let mut serial = Serial::usart2(
device.USART2,
@@ -63,16 +66,19 @@ const APP: () = {
// Separate out the sender and receiver of the serial port
let (tx, rx) = serial.split();
+ schedule.on(Instant::now() + 8_000_000.cycles()).unwrap();
// Our split serial
TX = tx;
RX = rx;
+ PA5 = pa5out;
+
// For debugging
ITM = core.ITM;
}
// idle may be interrupted by other interrupt/tasks in the system
- #[idle]
+ #[idle(resources = [ITM])]
fn idle() -> ! {
loop {
asm::wfi();
@@ -83,9 +89,9 @@ const APP: () = {
fn trace_data(byte: u8) {
let stim = &mut resources.ITM.stim[0];
iprintln!(stim, "data {}", byte);
- for _ in 0..10000 {
- asm::nop();
- }
+ // for _ in 0..10000 {
+ // asm::nop();
+ // }
}
#[task(priority = 1, resources = [ITM])]
@@ -94,6 +100,82 @@ const APP: () = {
iprintln!(stim, "{:?}", error);
}
+ #[task(priority = 1, capacity = 10, resources = [ITM], spawn = [on, off, set_frequency])]
+ fn line_interpretor(byte: u8) {
+ static mut B: [u8; 10] = [0u8; 10];
+ static mut ITERATOR: usize = 0;
+ static mut IS_SET: bool = false;
+ B[*ITERATOR] = byte;
+ if *ITERATOR < B.len()-1 {
+ *ITERATOR += 1;
+ } else {
+ B.iter_mut().for_each(|x| *x = 0);
+ *ITERATOR = 0;
+ }
+
+ if B.starts_with(&['o' as u8, 'n' as u8, 13]) || B.starts_with(&['o' as u8, 'n' as u8, 10]) {
+ spawn.on().unwrap();
+ B.iter_mut().for_each(|x| *x = 0);
+ *ITERATOR = 0;
+ } else if B.starts_with(&['o' as u8, 'f' as u8, 'f' as u8, 13]) || B.starts_with(&['o' as u8, 'f' as u8, 'f' as u8, 10]) {
+ spawn.off().unwrap();
+ B.iter_mut().for_each(|x| *x = 0);
+ *ITERATOR = 0;
+ } else if B.starts_with(&['s' as u8, 'e' as u8, 't' as u8, ' ' as u8]) {
+ *IS_SET = true;
+ }
+
+ if B.contains(&13) || B.contains(&10) {
+ if *IS_SET {
+ let mut value: u32 = 0;
+ for i2 in &B[4..*ITERATOR-1] {
+ if i2.is_ascii_digit() {
+ value = value * 10;
+ value = value + (u32::from(*i2-48));
+ }
+ if value != 0 {
+ spawn.set_frequency(value).unwrap();
+ }
+ }
+ *IS_SET = false;
+ }
+ B.iter_mut().for_each(|x| *x = 0);
+ *ITERATOR = 0;
+ }
+ }
+
+ #[task(priority = 4, schedule = [on], resources = [PA5, TIMEOFFSET, IS_ON])]
+ fn on() {
+ static mut TOGGLE: bool = false;
+
+ if *TOGGLE {
+ resources.PA5.set_high();
+ } else {
+ resources.PA5.set_low();
+ }
+ *TOGGLE = !*TOGGLE;
+
+ if *resources.IS_ON {
+ schedule.on(Instant::now() + (8_000_000 / *resources.TIMEOFFSET).cycles()).unwrap();
+ } else {
+ resources.PA5.set_low();
+ *TOGGLE = false;
+ }
+ *resources.IS_ON = true;
+ }
+
+ #[task(priority = 4, schedule = [on], resources = [PA5, IS_ON, TIMEOFFSET], spawn = [set_frequency])]
+ fn off() {
+ *resources.IS_ON = false;
+ }
+
+ #[task(priority = 2, resources = [TIMEOFFSET])]
+ fn set_frequency(freq: u32) {
+ resources.TIMEOFFSET.lock(|timeoffset| {
+ *timeoffset = freq;
+ });
+ }
+
#[task(priority = 2, resources = [TX], spawn = [trace_error])]
fn echo(byte: u8) {
let tx = resources.TX;
@@ -101,17 +183,16 @@ const APP: () = {
if block!(tx.write(byte)).is_err() {
let _ = spawn.trace_error(Error::UsartSendOverflow);
}
-
}
- #[interrupt(priority = 3, resources = [RX], spawn = [trace_data, trace_error, echo])]
+ #[interrupt(priority = 3, resources = [RX], spawn = [line_interpretor, trace_error, echo])]
fn USART2() {
let rx = resources.RX;
match rx.read() {
Ok(byte) => {
let _ = spawn.echo(byte);
- if spawn.trace_data(byte).is_err() {
+ if spawn.line_interpretor(byte).is_err() {
let _ = spawn.trace_error(Error::RingBufferOverflow);
}
}
@@ -126,6 +207,7 @@ const APP: () = {
extern "C" {
fn EXTI0();
fn EXTI1();
+ fn EXTI2();
}
};
--
GitLab