Buffer Read Issue with Vendor Class

[SpencerRiffle]

My university team and I are working with TinyUSB to implement communication between a custom etch-a-sketch type device and our host machine. We set the device up as a Vendor-type USB class because we wanted to be able to write our own driver for it.

Our goal is simply to be able to read data from it when we want, but we're having trouble reading when first connecting to the device. The order of events is:

1. Connect
2. Use Python to connect to the device
   a. import fcntl, os
   b. f = os.open("/dev/deviceName", os.O_RDWR)
3. We attempt to read data without turning the knobs of our device (as a note, when we turn the knobs, we use dev.write() in the firmware to send data to the buffer, and if the knobs aren't turned, we send default pre-initialized data.)
   a. print(os.read(f, 64))

Unfortunately, as long as we don't turn the knobs before reading data from the buffer, we get this error:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TimeoutError: [Errno 110] Connection timed out

We've tried writing data with dev.write() in setup, and we've checked to make sure that data is actually sending. What could we be missing? I've attached some reference code below. Any advice would be greatly appreciated!

Here's some of the header file code

#include <LittleFS.h>
#include "AiEsp32RotaryEncoder.h"
#include "Arduino.h"
#include "Adafruit_TinyUSB.h"
#include "FS.h"
#include "ListLib.h"
#include "USBVendor.h"

// True initializes the filesystem if it does not already exist
#define FORMAT_LITTLEFS_IF_FAILED true

// Set the polling delay
#define DELAY 15

#define TIMEOUT 30

#define rEncoderX_PIN_A 39
#define rEncoderX_PIN_B 40
#define rEncoderX_BUTTON_PIN 36

#define rEncoderY_PIN_A 38
#define rEncoderY_PIN_B 37
#define rEncoderY_BUTTON_PIN 35

#define ROTARY_ENCODER_VCC_PIN -1
#define ROTARY_ENCODER_STEPS 4
#define CIRLE_BOUNDARY true

// ...

// IOCTL modes
// ...

// Initialize USB components
USBVendor dev;

// Set up encoders using numbers above
AiEsp32RotaryEncoder rEncoderX = AiEsp32RotaryEncoder(rEncoderX_PIN_A, rEncoderX_PIN_B, rEncoderX_BUTTON_PIN, ROTARY_ENCODER_VCC_PIN, ROTARY_ENCODER_STEPS);
AiEsp32RotaryEncoder rEncoderY = AiEsp32RotaryEncoder(rEncoderY_PIN_A, rEncoderY_PIN_B, rEncoderY_BUTTON_PIN, ROTARY_ENCODER_VCC_PIN, ROTARY_ENCODER_STEPS);

// ... 

// USB communication constants
static const char *strRequestDirections[] = {"OUT", "IN"};
static const char *strRequestTypes[] = {"STANDARD", "CLASS", "VENDOR", "INVALID"};
static const char *strRequestRecipients[] = {"DEVICE", "INTERFACE", "ENDPOINT", "OTHER"};
static const char *strRequestStages[] = {"SETUP", "DATA", "ACK"};

// ...

And here is some of the main file's code:

bool vendorRequestCallback(uint8_t rhport, uint8_t requestStage, arduino_usb_control_request_t const *request) {

    bool result = false;

    // Accept connection
    if (request->bmRequestDirection == REQUEST_DIRECTION_OUT &&
        request->bmRequestType == REQUEST_TYPE_STANDARD &&
        request->bmRequestRecipient == REQUEST_RECIPIENT_INTERFACE &&
        request->bRequest == 0x0b)
    {
        if (requestStage == REQUEST_STAGE_SETUP) {
            // response with status OK
            result = dev.sendResponse(rhport, request);
        }
        else {
            result = true;
        }
    }
    // Implement Control Requests
    else if (request->bmRequestType == REQUEST_TYPE_VENDOR && request->bmRequestRecipient == REQUEST_RECIPIENT_DEVICE) {
        // ...

        // Handle IOCTL switch
        switch (request->bRequest) {
        // case ...
        case CONFIG_WRITE: {
            if (IOCTL_MODE != request->bRequest) { // Check current mode
                // isBuffered = true;
                clearInternalBuffer();
            }
            IOCTL_MODE = request->bRequest; // Update IOCTL_MODE
            dev.sendResponse(rhport, request);
            result = true;
            break;
        }
        default: {
            // stall unknown request
            result = false;
            break;
        }}
    }
    return result;
}

// ...

void loop() {
    unsigned long currentTime = millis();

    // handle everything here
    if (IOCTL_MODE == DATA_READ) {
        if (currentTime - lastCommunicationTime >= TIMEOUT) {
            sendCoordinates(coords);

            lastCommunicationTime = currentTime;
        } else {
            rotary_loop();
        }
    }
    delay(DELAY);
}

// ...

void rotary_loop() {
    /* Rotary dial handling */
    if (rEncoderX.encoderChanged()) {

        // Record value
        // X is reversed for some reason, so I fixed it
        sprintf(coords.x, "%ld", getReversed(rEncoderX));

        // Print results
        if (IOCTL_MODE == DATA_READ) {
            sendCoordinates(coords);
        }
    }
    // ...
}

// ...

void setup() {
    // Begin CDC communication
    Serial.begin(115200);
    dev.setRxBufferSize(128);
    dev.onRequest(vendorRequestCallback);

    // Set up file system
    LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);

    // Initialize files if needed
    if (!LittleFS.exists(configname)) {

        // Defaults
        // ...
    }
    // ...

    // Begin polling the controller
    rotarySetup();
}

// ...

void rotarySetup() {
    // Initialize coordinates
    coords.x[0] = '0';
    coords.y[0] = '0';

    // Initialize rotary encoders
    rEncoderX.begin();
    rEncoderX.setup(readEncoderISR);
    // minValue, maxValue, circleValues true|false (when max goes to min and vice-versa)
    rEncoderX.setBoundaries(0, 1000, CIRLE_BOUNDARY);
    rEncoderX.disableAcceleration();

    rEncoderY.begin();
    rEncoderY.setup(readEncoderISR);
    rEncoderY.setBoundaries(0, 1000, CIRLE_BOUNDARY);
    rEncoderY.disableAcceleration();
}

// ...

void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
    // Handle states
    switch (IOCTL_MODE) {
        case DATA_READ: {
            lastCommunicationTime = millis();

            // Clear buffer
            unbuffer(itf);

            // Send data
            sendCoordinates(coords);
            break;
        }
        // ...
}

// ...

void unbuffer(uint8_t itf) {
    if (isBuffered) {
        tud_vendor_n_write_flush(itf);
        isBuffered = false;
    }
}

// ...

void sendCoordinates(Coordinates &coords) {
    char string[10];
    sprintf(string, "%s:%s\n", coords.x, coords.y);
    dev.write((unsigned char *)string, strlen(string) + 1);
    // ...
}

// ...