ESP32C3 - Can UsbSerialJtag detect connection to terminal?

[aidengk-iris]

Dear all,

My application requires monitoring a pin's rising edge and send ONE Byte on the serial line to a computer immediately after seeing that edge.

I am using the UsbSerialJtag for sending that byte. However, the issue is that the attempt to write a byte from UsbSerialJtag seems to crash the whole program when the C3 is not connected with a serial terminal program.

In contrast, when I use esp-print instead of UsBSerialJtag, my program functions without issues. The catch is that I don't see any way to print just 1 Byte. When I try to print for example 0x80 with print!, I saw two bytes on the serial line on the oscilloscope.

Is it possible to check the connection status of the UsBSerialJtag? So that I only send data through UsBSerialJtag if the C3 is connected.

I appreciate any insight. Thank you very much.

I attached the current implementation (esp-hal version 0.21.1) in the followings.

#![no_std]
#![no_main]

use core::cell::RefCell;
use critical_section::Mutex;
use esp_backtrace as _;
use esp_hal::{gpio::{Event, Input, Io, Level, Output, Pull}, prelude::*, usb_serial_jtag::UsbSerialJtag, Blocking};
use esp_println::{print, println};

static BNC_TRIGGER_IN: Mutex<RefCell<Option<Input>>> = Mutex::new(RefCell::new(None));
static GPIO4: Mutex<RefCell<Option<Output>>> = Mutex::new(RefCell::new(None));
static USB_SERIAL: Mutex<RefCell<Option<UsbSerialJtag<'static, Blocking>>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());

    // get ready to use the usb jtag
    let mut usb_serial = UsbSerialJtag::new(peripherals.USB_DEVICE);
    
    let mut io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
    io.set_interrupt_handler(trigger_in_handler);

    let mut trigger_in_pin = Input::new(io.pins.gpio6, Pull::Down);

    // gpio4 is will be toggled after seeing a rising edge
    let mut gpio4_pin = Output::new(io.pins.gpio4, Level::Low);
    gpio4_pin.set_low();

    // replace the None in option types to actual pins and interfaces
    critical_section::with(|cs| {
        trigger_in_pin.listen(Event::RisingEdge);
        BNC_TRIGGER_IN.borrow_ref_mut(cs).replace(trigger_in_pin);
        GPIO4.borrow_ref_mut(cs).replace(gpio4_pin);
        USB_SERIAL.borrow_ref_mut(cs).replace(usb_serial);
    });

    loop {
    }
}

#[handler]
#[ram]
fn trigger_in_handler(){
    // check if BNC pin rising edge is the source of interrupt
    let mut has_trigger = false;
    critical_section::with(|cs|{
        let mut bnc_trigger_in = BNC_TRIGGER_IN.borrow_ref_mut(cs);
        let bnc_trigger_in = bnc_trigger_in.as_mut().unwrap();
        if bnc_trigger_in.is_interrupt_set(){
            has_trigger = true;
            bnc_trigger_in.clear_interrupt();
        }
    });

    if has_trigger{
        critical_section::with(|cs| { 

            // print the signal word
            let mut usb_serial = USB_SERIAL.borrow_ref_mut(cs);
            let usb_serial = usb_serial.as_mut().unwrap();
            usb_serial.write_bytes(&[0x80]).expect("Error writing to usb serial jtag");

            let mut gpio4_pin = GPIO4.borrow_ref_mut(cs);
            let gpio4_pin = gpio4_pin.as_mut().unwrap();
            // toggle the pin to check for interrupt delay on oscilloscope
            gpio4_pin.set_high();
            gpio4_pin.set_low();
         });
    }
}

[bjoernQ]

The driver should get a feature to not stall if there is nothing connected. (As you already noticed esp-println does that)

The catch is that I don't see any way to print just 1 Byte.

You can try this

let byte = 0x80
print!("{}", byte as char);

[aidengk-iris]

Thank you @bjoernQ , I see. So at the moment I should consider print! instead of the usb serial jtag.
I tried print!("{}", byte as char) but I still got 2 Bytes:

Thanks to your suggestion, I was inspired to change the printed value. By just using print!("A"), I can take advantage that an ASCII character in a string will be treated as 1 Byte. Then in the serial monitor program, I do see just one byte printed.

I will close the issue.