diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index db1e20156d78c951c233e3b80949689fa3b148f3..f6c0cd5b4adceb252cc032aee6b56c9c3f269231 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -330,7 +330,7 @@
         {
             "type": "shell",
             "label": "cargo build --example bare10 --release",
-            "command": "cargo build --example bare10 --release --features \"hal rtfm\"",
+            "command": "cargo build --example bare10 --release --features \"hal rtfm-tq\"",
             "problemMatcher": [
                 "$rustc"
             ],
diff --git a/examples/bare10.rs b/examples/bare10.rs
index e3702997b603842cd2e954af14ce0912366fac5d..55eb8648c42fb6da3ffda0eb135ef980c90a8c33 100644
--- a/examples/bare10.rs
+++ b/examples/bare10.rs
@@ -15,9 +15,9 @@ 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::gpio::{PushPull, Output, gpioa::PA5};
 use nb::block;
-use rtfm::app;
+use rtfm::{app, Instant};
 
 // Our error type
 #[derive(Debug)]
@@ -33,9 +33,12 @@ 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");
@@ -49,6 +52,9 @@ const APP: () = {
 
         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,
@@ -67,6 +73,8 @@ const APP: () = {
         TX = tx;
         RX = rx;
 
+        PA5 = pa5out;
+
         // For debugging
         ITM = core.ITM;
     }
@@ -79,6 +87,90 @@ const APP: () = {
         }
     }
 
+    #[task(priority = 1, capacity = 10, resources = [is_on, ITM], spawn = [on, off, setFreq])]
+    fn interpreter(byte: u8){
+        static mut B: [u8; 10] = [0u8; 10];
+        static mut i: usize = 0;
+        let stim = &mut resources.ITM.stim[0];
+        
+        B[*i] = byte;
+        *i = *i + 1;
+
+        if (B[0] == 'o' as u8) && (B[1] == 'n' as u8) && (B[2] == 10){
+            resources.is_on.lock(|is_on| {
+            *is_on = true;
+            });
+            spawn.on().unwrap();
+            iprintln!(stim, "On {}");
+            B.iter_mut().for_each(|x| *x = 0);
+            *i = 0;
+        }
+        else if (B[0] == 'o' as u8) && (B[1] == 'f' as u8) && (B[2] == 'f' as u8) && (B[3] == 10){
+            spawn.off().unwrap();
+            iprintln!(stim, "Off {}");
+            B.iter_mut().for_each(|x| *x = 0);
+            *i = 0;
+        }
+        else if (B[0] == 's' as u8) && (B[1] == 'e' as u8) && (B[2] == 't' as u8){
+            let mut value: u32 = 0;        
+            if B.contains(&(' ' as u8)) && (B.contains(&13) || B.contains(&10)) {
+                for n in &B[4..*i-1] {
+                    if n.is_ascii_digit() {
+                        value = value * 10;
+                        value = value + (u32::from(*n-48));
+                    }
+                }
+                if value != 0 {
+                    iprintln!(stim, "Set {}", value);
+                    spawn.setFreq(value).unwrap();
+                    B.iter_mut().for_each(|x| *x = 0);
+                    *i = 0;
+                }
+                
+            }
+        }
+        else if (B.contains(&13) || B.contains(&10)){
+            //Resets B!
+            B.iter_mut().for_each(|x| *x = 0);
+            *i = 0;
+        }
+    }
+
+    #[task(priority = 4, schedule = [on], resources = [PA5, TIMEOFFSET, is_on], spawn = [on])]
+    fn on(){
+        static mut light_toggle: bool = true;
+        let mut time: u32 = 0;
+        resources.TIMEOFFSET.lock(|timeoffset| {
+            time = *timeoffset;
+        });
+        if *resources.is_on{
+            if *light_toggle{
+                resources.PA5.set_high();
+            }
+            else{
+                resources.PA5.set_low();
+            }
+            *light_toggle = !*light_toggle;
+            schedule.on(Instant::now() + (8_000_000/time).cycles()).unwrap();
+        }
+        else{
+            resources.PA5.set_low();
+            *light_toggle = false;
+        }        
+    }
+    
+    #[task(priority = 4, resources = [is_on])]
+    fn off(){
+        *resources.is_on = false;
+    }
+
+    #[task(priority = 2, resources = [TIMEOFFSET])]
+    fn setFreq(freq: u32){
+        resources.TIMEOFFSET.lock(|timeoffset| {
+            *timeoffset = freq;
+        });
+    }
+
     #[task(priority = 1, capacity = 3, resources = [ITM])]
     fn trace_data(byte: u8) {
         let stim = &mut resources.ITM.stim[0];
@@ -101,17 +193,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 = [trace_error, echo, interpreter])]
     fn USART2() {
         let rx = resources.RX;
 
         match rx.read() {
             Ok(byte) => {
                 let _ = spawn.echo(byte);
-                if spawn.trace_data(byte).is_err() {
+                if spawn.interpreter(byte).is_err() {
                     let _ = spawn.trace_error(Error::RingBufferOverflow);
                 }
             }
@@ -126,6 +217,7 @@ const APP: () = {
     extern "C" {
         fn EXTI0();
         fn EXTI1();
+        fn EXTI2();
     }
 };