aboutsummaryrefslogtreecommitdiffstats
path: root/sw/eval-clock-cw-tx/src/usb.rs
diff options
context:
space:
mode:
authorMatthias P. Braendli <matthias.braendli@mpb.li>2021-04-15 13:07:56 +0200
committerMatthias P. Braendli <matthias.braendli@mpb.li>2021-04-15 13:07:56 +0200
commit03ad81d7afaea119df607b6e65f19bd5362fab39 (patch)
tree38835bd11e550aa267acaf82dad2c63f5a566522 /sw/eval-clock-cw-tx/src/usb.rs
parent1a65830bbfc9ea4cfb999f43beb67e15947ef358 (diff)
downloadpicardy-03ad81d7afaea119df607b6e65f19bd5362fab39.tar.gz
picardy-03ad81d7afaea119df607b6e65f19bd5362fab39.tar.bz2
picardy-03ad81d7afaea119df607b6e65f19bd5362fab39.zip
Get FELDHELL to work
Diffstat (limited to 'sw/eval-clock-cw-tx/src/usb.rs')
-rw-r--r--sw/eval-clock-cw-tx/src/usb.rs318
1 files changed, 292 insertions, 26 deletions
diff --git a/sw/eval-clock-cw-tx/src/usb.rs b/sw/eval-clock-cw-tx/src/usb.rs
index e803c91..467c148 100644
--- a/sw/eval-clock-cw-tx/src/usb.rs
+++ b/sw/eval-clock-cw-tx/src/usb.rs
@@ -1,23 +1,96 @@
+use core::mem::MaybeUninit;
use core::fmt::Write;
-use stm32f1xx_hal::gpio;
-use stm32f1xx_hal::pac;
-use stm32f1xx_hal::pac::{interrupt, Interrupt};
+use stm32f1xx_hal::{
+ pac,
+ pac::{interrupt, Interrupt},
+ gpio,
+ timer::CountDownTimer,
+};
use stm32f1xx_hal::usb::{Peripheral, UsbBus, UsbBusType};
use usb_device::{bus::UsbBusAllocator, prelude::*};
use usbd_serial::{SerialPort, USB_CLASS_CDC};
+use arrayvec::{ArrayVec, ArrayString};
+
+/* Transmit 17.5 columns per second
+ * With 14 lines per column, this gives 245 lines per second
+ */
+pub const TIMER_FREQ_HZ : u32 = 245;
+
+const FELDHELL_PATTERN_LEN : usize = 16;
+const MESSAGE_LEN : usize = 64;
+
+static mut FELDHELL_TIMER: MaybeUninit<CountDownTimer<pac::TIM4>> = MaybeUninit::uninit();
+
+static mut SHARED_USB: MaybeUninit<USBSharedData> = MaybeUninit::uninit();
static mut USB_BUS: Option<UsbBusAllocator<UsbBusType>> = None;
static mut USB_SERIAL: Option<usbd_serial::SerialPort<UsbBusType>> = None;
static mut USB_DEVICE: Option<UsbDevice<UsbBusType>> = None;
-pub struct USB {
+
+/* Commands
+ * ========
+ * Commands end with \n
+ *
+ * Switch to transmit:
+ * tx
+ *
+ * Switch to receive:
+ * rx
+ *
+ * Set frequency:
+ * f10121000
+ *
+ * Append to transmit message
+ * mThe message to transmit
+ *
+ * Clear transmit message
+ * clear
+ *
+ * Set FELDHELL wide font
+ * fontw
+ *
+ * Set FELDHELL narrow font
+ * fontn
+*/
+
+
+#[derive(Clone, Copy)]
+enum Font {
+ Narrow,
+ Wide,
}
-impl USB {
+// Shared between application and interrupt context
+struct USBSharedData {
+ incoming_buf: ArrayVec::<[u8; MESSAGE_LEN]>,
+ message : ArrayString::<[u8; MESSAGE_LEN]>,
+ feldhell_pattern: ArrayVec::<[u16; FELDHELL_PATTERN_LEN]>, // FELDHELL columns to transmit
+}
+
+pub fn enable_interrupts() {
+ unsafe {
+ pac::NVIC::unmask(Interrupt::USB_HP_CAN_TX);
+ pac::NVIC::unmask(Interrupt::USB_LP_CAN_RX0);
+ pac::NVIC::unmask(Interrupt::TIM4);
+ }
+}
+
+pub struct USBData {
+ font : Font,
+ pub frequency : u32,
+ pub transmit : bool,
+
+ current_str : ArrayVec::<[u8; 96]>,
+ send_ix : usize,
+}
+
+impl USBData {
pub fn new(
- usb: stm32f1xx_hal::pac::USB,
+ timer4: CountDownTimer<pac::TIM4>,
+ usb: pac::USB,
pin_dm: gpio::gpioa::PA11<gpio::Input<gpio::Floating>>,
- pin_dp: gpio::gpioa::PA12<gpio::Input<gpio::Floating>>) -> Self {
+ pin_dp: gpio::gpioa::PA12<gpio::Input<gpio::Floating>>) -> USBData {
let peripheral = Peripheral {
usb,
@@ -25,32 +98,161 @@ impl USB {
pin_dp,
};
- unsafe {
- let bus = UsbBus::new(peripheral);
-
- USB_BUS = Some(bus);
+ {
+ let timer = unsafe { &mut *FELDHELL_TIMER.as_mut_ptr() };
+ *timer = timer4;
+ }
+ unsafe {
+ USB_BUS = Some(UsbBus::new(peripheral));
USB_SERIAL = Some(SerialPort::new(USB_BUS.as_ref().unwrap()));
-
- let usb_dev = UsbDeviceBuilder::new(USB_BUS.as_ref().unwrap(), UsbVidPid(0x1d50, 0x5120)) // Openmoko Neo1973 serial
+ let usb_device = UsbDeviceBuilder::new(USB_BUS.as_ref().unwrap(), UsbVidPid(0x1d50, 0x5120)) // Openmoko Neo1973 serial
.manufacturer("HB9EGM")
.product("Beep Machine")
.serial_number("1")
.device_class(USB_CLASS_CDC)
.build();
+ USB_DEVICE = Some(usb_device);
- USB_DEVICE = Some(usb_dev);
+ let shared_usb = &mut *SHARED_USB.as_mut_ptr();
+ *shared_usb = USBSharedData {
+ incoming_buf : ArrayVec::new(),
+ message : ArrayString::new(),
+ feldhell_pattern : ArrayVec::new(),
+ }
}
- USB{}
+ USBData {
+ font : Font::Narrow,
+ frequency : 10121000,
+ transmit : false,
+ current_str : ArrayVec::new(),
+ send_ix : 0,
+ }
}
- pub fn enable_interrupts(&self) {
- unsafe {
- pac::NVIC::unmask(Interrupt::USB_HP_CAN_TX);
- pac::NVIC::unmask(Interrupt::USB_LP_CAN_RX0);
+ pub fn handle(&mut self) {
+ let in_message = cortex_m::interrupt::free(|_cs| {
+ let shared_usb = unsafe { &mut *SHARED_USB.as_mut_ptr() };
+
+ if shared_usb.message.len() > 0 {
+ let mut outgoing = ArrayString::<[u8; MESSAGE_LEN]>::new();
+
+ if let Err(_) = write!(outgoing, "{}", &shared_usb.message) {
+ outgoing.clear();
+ write!(outgoing, "EXT FAIL\n").ok();
+ }
+ let serial = unsafe { USB_SERIAL.as_mut().unwrap() };
+ serial.write(outgoing.as_bytes()).ok();
+
+ let in_message = shared_usb.message.clone();
+ shared_usb.message.clear();
+ Some(in_message)
+ }
+ else {
+ None
+ }
+ });
+
+ let mut outgoing = ArrayVec::<[u8; MESSAGE_LEN]>::new();
+ if let Some(m) = in_message {
+ if m.as_str() == "tx\n" {
+ outgoing.try_extend_from_slice(b"TX ok\n").ok();
+ self.transmit = true;
+ }
+ else if m.as_str() == "rx\n" {
+ outgoing.try_extend_from_slice(b"RX ok\n").ok();
+ self.transmit = false;
+ }
+ else if m.chars().nth(0).unwrap() == 'm' {
+ self.current_str.clear();
+ for c in m.bytes().skip(1) {
+ self.current_str.push(c);
+ }
+ outgoing.try_extend_from_slice(b"m ok\n").ok();
+ }
+ else if m.as_str() == "clear\n" {
+ self.current_str.clear();
+ outgoing.try_extend_from_slice(b"clear ok\n").ok();
+ }
+ else if m.as_str() == "fontw\n" {
+ self.font = Font::Wide;
+ outgoing.try_extend_from_slice(b"fontw ok\n").ok();
+ }
+ else if m.as_str() == "fontn\n" {
+ self.font = Font::Narrow;
+ outgoing.try_extend_from_slice(b"fontn ok\n").ok();
+ }
+ else if m.chars().nth(0).unwrap() == 'f' {
+ let mut as_str = ArrayString::<[u8; MESSAGE_LEN]>::new();
+
+ for c in m.chars().skip(1) {
+ as_str.push(c);
+ }
+
+ match u32::from_str_radix(as_str.as_str().trim(), 10) {
+ Ok(val) => {
+ self.frequency = val;
+ outgoing.try_extend_from_slice(b"f ok\n").ok();
+ }
+ _ => {
+ outgoing.try_extend_from_slice(b"F").ok();
+ outgoing.try_extend_from_slice(as_str.as_bytes()).ok();
+ outgoing.try_extend_from_slice(b" err\n").ok();
+ }
+ }
+ }
+ else {
+ outgoing.try_extend_from_slice(b"no\n").ok();
+ }
+ }
+
+ let feldhell_pattern_length = cortex_m::interrupt::free(|_cs| {
+ let serial = unsafe { USB_SERIAL.as_mut().unwrap() };
+ serial.write(&outgoing).ok();
+
+ let shared_usb = unsafe { &mut *SHARED_USB.as_mut_ptr() };
+ shared_usb.feldhell_pattern.len()
+ });
+
+ if self.current_str.len() > 0 && feldhell_pattern_length < FELDHELL_PATTERN_LEN-8 {
+ match self.current_str.get(self.send_ix) {
+ Some(letter) => {
+ let fat = match self.font {
+ Font::Wide => true,
+ Font::Narrow => false,
+ };
+
+ match crate::feldhell_font::get_letter_by_columns(*letter, fat) {
+ Some(columns) => {
+ cortex_m::interrupt::free(|_cs| {
+ let shared_usb = unsafe { &mut *SHARED_USB.as_mut_ptr() };
+ shared_usb.feldhell_pattern.try_extend_from_slice(&columns).ok();
+ });
+
+ }
+ None => {}
+ }
+ }
+ None => {}
+ }
+
+ self.send_ix += 1;
+ if self.send_ix >= self.current_str.len() {
+ cortex_m::interrupt::free(|_cs| {
+ let serial = unsafe { USB_SERIAL.as_mut().unwrap() };
+ let mut outgoing = ArrayString::<[u8; 16]>::new();
+ write!(&mut outgoing, "FH sent {}\n", self.send_ix).ok();
+ serial.write(outgoing.as_bytes()).ok();
+ });
+
+ self.send_ix = 0;
+ self.current_str.clear();
+ }
}
}
+
+ pub fn is_transmit(&self) -> bool { self.transmit }
}
#[allow(non_snake_case)]
@@ -73,18 +275,82 @@ fn usb_interrupt() {
return;
}
- let mut buf = [0u8; 8];
- let mut string = arrayvec::ArrayString::<[_; 16]>::new();
+ let mut buf = [0u8; 64];
+
+ let shared_usb = unsafe { &mut *SHARED_USB.as_mut_ptr() };
match serial.read(&mut buf) {
Ok(count) if count > 0 => {
- // Echo back in upper case
- for c in buf[0..count].iter_mut() {
- write!(string, "{:02x}", *c).ok();
+ if count > 64 {
+ panic!("illegal count");
+ }
+ shared_usb.incoming_buf.try_extend_from_slice(&buf[0..count]).ok();
+
+ let mut split_at = None;
+ for (i, c) in shared_usb.incoming_buf.iter().enumerate() {
+ if *c == b'\n' {
+ split_at = Some(i);
+ break;
+ }
}
- serial.write(string.as_bytes()).ok();
- string.clear();
+
+ match split_at {
+ Some(i) if i+1 == shared_usb.incoming_buf.len() => {
+ write!(&mut shared_usb.message, "{}", core::str::from_utf8(&shared_usb.incoming_buf).unwrap()).ok();
+ shared_usb.incoming_buf.clear();
+ }
+ Some(i) => {
+ let (front, back) = shared_usb.incoming_buf.split_at(i+1);
+
+ write!(&mut shared_usb.message, "{}", core::str::from_utf8(front).unwrap()).ok();
+
+ let mut keep = ArrayVec::<[u8; MESSAGE_LEN]>::new();
+ keep.try_extend_from_slice(back).ok();
+
+ shared_usb.incoming_buf.clear();
+ shared_usb.incoming_buf.try_extend_from_slice(&keep).ok();
+ }
+ _ => { }
+ };
+
}
_ => {}
}
}
+
+#[allow(non_snake_case)]
+#[interrupt]
+fn TIM4() {
+ let timer = unsafe { &mut *FELDHELL_TIMER.as_mut_ptr() };
+ timer.clear_update_interrupt_flag();
+
+ let shared_usb = unsafe { &mut *SHARED_USB.as_mut_ptr() };
+ while shared_usb.feldhell_pattern.len() > 0 && shared_usb.feldhell_pattern.as_slice()[0] == 0 {
+ shared_usb.feldhell_pattern.pop_at(0);
+ }
+
+ if shared_usb.feldhell_pattern.len() > 0 {
+ let remove_first_element = {
+ let pat = shared_usb.feldhell_pattern.as_mut_slice().first_mut().unwrap();
+
+ let shared = unsafe { &mut *crate::SHARED.as_mut_ptr() };
+
+ use embedded_hal::digital::v2::OutputPin;
+
+ if shared.state.allow_feldhell_keying() && (*pat & 0b1) == 0b1 {
+ shared.cw_key_out_n.set_low().unwrap();
+ }
+ else {
+ shared.cw_key_out_n.set_high().unwrap();
+ }
+
+ *pat >>= 1;
+ assert_ne!(*pat, 0);
+ *pat == 0b1
+ };
+
+ if remove_first_element {
+ shared_usb.feldhell_pattern.pop_at(0);
+ }
+ }
+}