USB MSC/CDC not re-enumerating upon

[smessmacher]

Operating System

Others

Board

RP2040 Custom board

Firmware

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2019 Ha Thach (tinyusb.org)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

 #include "bsp/board_api.h"
 #include "tusb.h"
 #include <stdio.h>
 #include "pico/stdlib.h"
 #include "hardware/i2c.h"
 #include "ssd1306.h"
 #import "ff.h"
 #import "diskio.h"
 #include "hardware/uart.h"
 #include "msc_state.h"
 


 FATFS fatFs;
 FIL files; 
 FRESULT fr; 
 UINT bytes_written;
 FIL file;


 // I2C OLED Display Configuration
#define MY_I2C_INSTANCE i2c0
#define I2C_SDA_PIN 24
#define I2C_SCL_PIN 25
#define OLED_ADDRESS 0x3C  
#define UART_RX_PIN 1
#define UART_TX_PIN 0
#define BAUDRATE 9600


// Joystick Configuration
#define JOYSTICK_I2C_ADDR 0x3F  

int menuSelection = 0; // 0 = Download, 1 = Recieve, 2 = MSC
ssd1306_t disp;

typedef enum {
    STATE_IDLE,
    STATE_RECEIVING,
    STATE_MSC
} AppState;

AppState app_state = STATE_IDLE;


// Initialize I2C
void init_i2c() {
    i2c_init(MY_I2C_INSTANCE, 400000);
    gpio_set_function(I2C_SDA_PIN, GPIO_FUNC_I2C);
    gpio_set_function(I2C_SCL_PIN, GPIO_FUNC_I2C);
    gpio_pull_up(I2C_SDA_PIN);
    gpio_pull_up(I2C_SCL_PIN);
}

void check_for_start_file() {
    if (f_mount(&fatFs, "", 1) == FR_OK) {
        FILINFO fno;
        if (f_stat("start.txt", &fno) == FR_OK) {
            show_message("start.txt found", "Beginning transfer");
            sleep_ms(1000);

            f_unlink("start.txt");

            start_uart_transfer();
        }
        // f_mount(NULL, "", 0);  
    }
}

void start_uart_transfer() {
    uart_puts(uart0, "BEGIN_DOWNLOAD\n");
}



// Read Joystick State
uint8_t read_joystick_state() {
    uint8_t state = 0;
    i2c_read_blocking(MY_I2C_INSTANCE, JOYSTICK_I2C_ADDR, &state, 1, false);
    return state;
}

void show_message(const char* line1, const char* line2) {
    ssd1306_clear(&disp);
    ssd1306_draw_string(&disp, 0, 0, 2, line1);
    if (line2) ssd1306_draw_string(&disp, 0, 20, 2, line2);
    ssd1306_show(&disp);
}

void uart_recieve() {
    static uint32_t last_byte_time = 0;
    static uint8_t buffer[512];
    static size_t index =0;
    static uint32_t total_received = 0;
    static bool recieving = false;

    if (!recieving && uart_is_readable(uart0)){
        FRESULT res = f_open(&file, "received.bin", FA_WRITE | FA_CREATE_ALWAYS);
        if (res != FR_OK) {
            show_message("File open", "FAILED!");
            return;
        }
        recieving = true;
        index =0;
        total_received = 0; 
        last_byte_time = to_ms_since_boot(get_absolute_time());
        show_message("Receiving...", NULL);

    }
    if (recieving){
        while(uart_is_readable(uart0)){
            buffer[index++] = uart_getc(uart0);
            last_byte_time = to_ms_since_boot(get_absolute_time());
            total_received++;

            if (index >= sizeof(buffer)){
                f_write(&file, buffer, index, &bytes_written);
            index =0;
            }
        }

        if (to_ms_since_boot(get_absolute_time()) - last_byte_time > 2000) {
            if (index >0){
                f_write(&file, buffer, index, &bytes_written);
            }
            f_sync(&file);
            f_close(&file);
            f_mount(NULL, "0:", 0);
            ejected = true; // unmount
            tud_disconnect();
            show_message("USB disc","success");
            sleep_ms(1000);
            
            tusb_init();
            show_message("USB init","success");
            sleep_ms(1000);        
            
            tud_connect();
            show_message("USB con", tud_connected() ? "success" : "fail");
            sleep_ms(1000);         
            mount_sdcard();         
            ejected = false;
            recieving = false;
            app_state = STATE_MSC;
            show_message("USB Mode", "Active!");
        }
    }

}

void mount_sdcard(){
    disk_initialize(0);
    f_unmount("0:");
    FRESULT res = f_mount(&fatFs, "0:", 1);
    show_message("Mounting", res == FR_OK ? "Success" : "Failed");
    sleep_ms(1000); // Let user see result
}


void cdc_task(void);
 

 /*------------- MAIN -------------*/
 int main(void) {
    board_init();    
    tusb_init();
    stdio_init_all();
    sleep_ms(500);
    tud_connect();

    printf("Initializing OLED Display...\n");
    init_i2c();
    sleep_ms(100);

    uart_init(uart0, BAUDRATE);
    gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
    gpio_pull_up(UART_RX_PIN);
    gpio_pull_up(UART_TX_PIN);

    uart_set_hw_flow(uart0, false, false);
    uart_set_fifo_enabled(uart0, false);
    uart_set_fifo_enabled(uart0, true);

    disp.external_vcc = false;
    if (!ssd1306_init(&disp, 128, 64, OLED_ADDRESS, MY_I2C_INSTANCE)) {
        printf("Failed to initialize SSD1306 display!\n");
        return 1;
    }
 
   if (board_init_after_tusb) {
     board_init_after_tusb();
   }
   mount_sdcard();

   while (1) {
    tud_task();
    cdc_task();

    switch (app_state) {
        case STATE_IDLE:
            check_for_start_file();
            if (uart_is_readable(uart0)) {
                app_state = STATE_RECEIVING;
            }
            break;

        case STATE_RECEIVING:
            uart_recieve(); 
            break;

        case STATE_MSC:
            break;
    }
}

 }
 

 //--------------------------------------------------------------------+
 // USB CDC
 //--------------------------------------------------------------------+
 void cdc_task(void) {
   static char input_buff[64];
   static uint8_t idx =0;
   if (tud_cdc_connected() && tud_cdc_available()){
    char ch = tud_cdc_read_char();

    tud_cdc_write_char(ch);
    tud_cdc_write_flush();


    if (ch=='\n' || idx >= sizeof(input_buff) -1){
        input_buff[idx] = '\0';

        if ( strcmp(input_buff, "start") == 0){
            show_message("message", "recieved");
            sleep_ms(2000);
            show_message("Waiting", "for signal...");

            uart_puts(uart0, "READY_FOR_FILE\n");

            app_state = STATE_RECEIVING;

        }
        idx =0;
    } else {
        input_buff[idx++] = ch;
    }
   }

}
 
 // Invoked when cdc when line state changed e.g connected/disconnected
 void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts) {
   (void) itf;
   (void) rts;
 
   // TODO set some indicator
   if (dtr) {
    show_message("connected","success");
    sleep_ms(1500);
     // Terminal connected
   } else {
    show_message("disco","success");
    sleep_ms(1500);
     // Terminal disconnected
   }
 }
 
 // Invoked when CDC interface received data from host
 void tud_cdc_rx_cb(uint8_t itf) {
   (void) itf;
 }

What happened ?

I am setting up my rp2040 as an MSC/CDC device. All fucntions emulate a USB properly when drag/dropping and moving files. I want to send a file via UART to the pico (succesful) and have it refresh itself to show the new file on an iPad (unsuccesful). However, the same process works just fine on my windows computer.

Process after file is recieved:

1. tud_disconnect();
2. tud_init();
3. tud_connect();

What happens: pico disconnects from ipad but does not reconnect. I am attaching my custom main.c script to ilustrate better. Not sure if this is how to format it as it didn't let me attach .c files, hope this is ok.

How to reproduce ?

Just running a tud_disconnect and tud_connect should be enough to see what I mean, i dont care about the rest of the process as I know that works well. Just need to know how to show the new file on the iPad once downloaded

Debug Log as txt file (LOG/CFG_TUSB_DEBUG=2)

On my windows I see dosplayed on my oled screen

show_message("disco","success");

which menas it is accesing my callback tud_cdc_line_state_cb. However I dont see this on iOS so I am unsure as to what could cause that

Screenshots

No response

I have checked existing issues, dicussion and documentation

• I confirm I have checked existing issues, dicussion and documentation.