My other solution

  1. #![deny(unsafe_code)]
  2. #![no_main]
  3. #![no_std]
  5. #[macro_use]
  6. extern crate fixedvec;
  8. #[macro_use]
  9. extern crate pg;
  11. use core::ops::Not;
  13. use fixedvec::FixedVec;
  14. use pg::{Async, Future, Serial, Timer};
  15. use pg::led::LEDS;
  17. #[inline(never)]
  18. #[no_mangle]
  19. pub fn main() -> ! {
  20.     let mut timer = Timer::new().unwrap();
  21.     let Serial { mut rx, .. } = Serial::new().unwrap();
  23.     let mut periodic = timer.periodic(100);
  24.     let mut bytes = rx.bytes();
  26.     let mut memory = alloc_stack!([u8; 32]);
  27.     let mut buffer = FixedVec::new(&mut memory);
  28.     let mut direction = Direction::Clockwise;
  29.     let mut state = 0;
  30.     loop {
  31.         if let Async::Ready(()) = periodic.poll() {
  32.             match direction {
  33.                 Direction::Clockwise => {
  34.                     if state == 7 {
  35.                         LEDS[state].off();
  36.                         LEDS[0].on();
  38.                         state = 0;
  39.                     } else {
  40.                         LEDS[state].off();
  41.                         LEDS[state+1].on();
  43.                         state += 1;
  44.                     }
  45.                 }
  46.                 Direction::Counterclockwise => {
  47.                     if state == 0 {
  48.                         LEDS[state].off();
  49.                         LEDS[7].on();
  51.                         state = 7;
  52.                     } else {
  53.                         LEDS[state].off();
  54.                         LEDS[state-1].on();
  56.                         state -= 1;
  57.                     }
  58.                 }
  59.             }
  60.         }
  62.         if let Async::Ready(byte) = bytes.poll() {
  63.             if let Err(_) = buffer.push(byte) {
  64.                 // TODO report error
  65.                 buffer.clear();
  66.             } else if byte == '\r' as u8 {
  67.                 if buffer.as_slice() == b"reverse\r" {
  68.                     direction = !direction;
  69.                 }
  71.                 buffer.clear();
  72.             }
  73.         }
  74.     }
  75. }
  77. enum Direction {
  78.     Clockwise,
  79.     Counterclockwise,
  80. }
  82. impl Not for Direction {
  83.     type Output = Self;
  85.     fn not(self) -> Self {
  86.         match self {
  87.             Direction::Clockwise => Direction::Counterclockwise,
  88.             Direction::Counterclockwise => Direction::Clockwise,
  89.         }
  90.     }
  91. }