How can we handle read buffer overflow? #35
Description
I have an embedded project on an STM32F405 with USB serial configured and running with FreeRTOS (rust wrapper) as follows:
// Make USB serial device globally available
pub static G_USB_SERIAL: Mutex<RefCell<Option<SerialPort<UsbBus<USB>>>>> =
Mutex::new(RefCell::new(None));
// Make USB device globally available
pub static G_USB_DEVICE: Mutex<RefCell<Option<UsbDevice<UsbBus<USB>>>>> =
Mutex::new(RefCell::new(None));
pub unsafe fn usb_init(usb: USB) {
static mut EP_MEMORY: [u32; 1024] = [0; 1024];
static mut USB_BUS: Option<UsbBusAllocator<stm32f4xx_hal::otg_fs::UsbBusType>> = None;
USB_BUS = Some(stm32f4xx_hal::otg_fs::UsbBusType::new(usb, &mut EP_MEMORY));
let usb_bus = USB_BUS.as_ref().unwrap();
let serial_port = SerialPort::new(&usb_bus);
let usb_dev = UsbDeviceBuilder::new(&usb_bus, UsbVidPid(0x17c0, 0x28dd))
.manufacturer("University of Bern")
.product("Thermometry")
.serial_number("IceLab814")
.device_class(usbd_serial::USB_CLASS_CDC)
.build();
cortex_m::interrupt::free(|cs| {
*G_USB_SERIAL.borrow(cs).borrow_mut() = Some(serial_port);
*G_USB_DEVICE.borrow(cs).borrow_mut() = Some(usb_dev);
});
}
pub fn usb_read(message: &mut [u8; 1024]) -> bool {
cortex_m::interrupt::free(|cs| {
*message = [0; 1024];
return match G_USB_SERIAL.borrow(cs).borrow_mut().as_mut() {
None => false,
Some(serial) => match serial.read(message) {
Ok(a) => if a < 1024 {
true
} else {
false
},
Err(_) => false,
},
};
})
}
#[interrupt]
#[allow(non_snake_case)]
fn OTG_FS() {
cortex_m::interrupt::free(|cs| {
match G_USB_DEVICE.borrow(cs).borrow_mut().as_mut() {
None => {}
Some(usb_dev) => {
match G_USB_SERIAL.borrow(cs).borrow_mut().as_mut() {
None => {}
Some(serial) => {
// do this regularly to keep connection to USB host
usb_dev.poll(&mut [serial]);
}
}
}
}
});
}initialized in the main function like this:
let mut dp = pac::Peripherals::take().unwrap();
let rcc = dp.RCC.constrain();
let clocks = rcc
.cfgr
.use_hse(8.MHz())
.sysclk(48.MHz())
.hclk(48.MHz())
.require_pll48clk()
.pclk1(24.MHz())
.pclk2(24.MHz())
.freeze();
let gpioa = dp.GPIOA.split();
// initialize usb
let usb = USB {
usb_global: dp.OTG_FS_GLOBAL,
usb_device: dp.OTG_FS_DEVICE,
usb_pwrclk: dp.OTG_FS_PWRCLK,
pin_dm: gpioa.pa11.into_alternate(),
pin_dp: gpioa.pa12.into_alternate(),
hclk: clocks.hclk(),
};
unsafe {
usb_init(usb);
cortex_m::peripheral::NVIC::unmask(Interrupt::OTG_FS);
}my USB task (stack size 2048) does something like this:
loop {
let mut message_bytes = [0; 1024];
usb_read(&mut message_bytes);
// do something
// print something over usb
}I noticed that the SerialPort::new(&usb_bus) doc says: "Creates a new USB serial port with the provided UsbBus and 128 byte read/write buffers.". Whenever I send a message longer than 63 characters, the microcontroller gets stuck and requires a reset. How can I handle this case?