LogEtComUSB/msc_app.c

/*
 * 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 "tusb.h"
#include "ff.h"
#include "diskio.h"
#include "pico/time.h"
#include "stdlib.h"

//--------------------------------------------------------------------+
// MACRO TYPEDEF CONSTANT ENUM DECLARATION
//--------------------------------------------------------------------+
static scsi_inquiry_resp_t inquiry_resp;

//------------- Elm Chan FatFS -------------//
static FATFS fatfs[CFG_TUH_DEVICE_MAX]; // for simplicity only support 1 LUN per device
static volatile bool _disk_busy[CFG_TUH_DEVICE_MAX];

bool file_accessible = false;
FIL fp;

void log_to_usb(const char * message);

bool inquiry_complete_cb(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data)
{
  msc_cbw_t const* cbw = cb_data->cbw;
  msc_csw_t const* csw = cb_data->csw;
  FRESULT error;

  if (csw->status != 0)
  {
    printf("Inquiry failed\r\n");
    return false;
  }

  // Print out Vendor ID, Product ID and Rev
  printf("%.8s %.16s rev %.4s\r\n", inquiry_resp.vendor_id, inquiry_resp.product_id, inquiry_resp.product_rev);

  // Get capacity of device
  uint32_t const block_count = tuh_msc_get_block_count(dev_addr, cbw->lun);
  uint32_t const block_size = tuh_msc_get_block_size(dev_addr, cbw->lun);

  printf("Disk Size: %" PRIu32 " MB\r\n", block_count / ((1024*1024)/block_size));
  printf("Block Count = %" PRIu32 ", Block Size: %" PRIu32 "\r\n", block_count, block_size);


  printf("Monter le système de fichier avec FatFs\n");

  // Monter le système de fichier avec FatFs
  uint8_t const drive_num = dev_addr-1;
  char drive_path[3] = "0:";
  drive_path[0] += drive_num;
  printf("dev_addr: %d\ndrive_num: %d\n", dev_addr, drive_num);
  error = f_mount(&fatfs[drive_num], drive_path, 1);
  if ( error != FR_OK )
  {
    printf("FatFs mount failed, error: %d\n", error);
    return true;
  }
  
  const char buffer[]= "Ceci est le test de Poivron Robotique\n";
  char big_buffer[0x1000]; // 4 ko
  char big_big_buffer[0x10000]; // 16 ko
  int nb_byte_written;
  absolute_time_t current_time, start_time;
  char filepath[50];
  filepath[0] = drive_path[0];
  filepath[1] = ':';
  filepath[2] = '\0';
  strcat(filepath, "Poivron.txt");
  printf("filepath:%s\n", filepath);

  
  error = f_open(&fp, filepath, FA_WRITE | FA_OPEN_ALWAYS);
  if(error){
    printf("f_open: error %d\n", error);
  }
  file_accessible = true;

  // Ecrit petit buffer
  log_to_usb(buffer);
  // Ecrit gros buffer
  int size = 0;
  big_buffer[0]= '\0';
  while(size + strlen(buffer) < 0x1000){
    strcat(big_buffer, buffer);
    size += strlen(buffer);
  }
  log_to_usb(big_buffer);

  // Ecrit très gros buffer
  size = 0;
  big_big_buffer[0]= '\0';
  while(size + strlen(buffer) < 0x10000){
    strcat(big_buffer, buffer);
    size += strlen(buffer);
  }
  log_to_usb(big_big_buffer);



  f_close(&fp);
  printf("Fichier Poivron.txt cree avec succes\n");

  return true;
}

void log_to_usb(const char * message){
  int nb_byte_written;
  absolute_time_t current_time, start_time;
  start_time = get_absolute_time();
  FRESULT error;
  if(file_accessible){
    error = f_write(&fp, message, strlen(message), &nb_byte_written);
    if(error){
      printf("f_write: error %d\n", error);
      return;
    }
    f_sync(&fp);
    current_time = get_absolute_time();
    printf("Ecrit: %d octets en  %llu us\n", nb_byte_written, current_time - start_time);
  }
}

//------------- IMPLEMENTATION -------------//
void tuh_msc_mount_cb(uint8_t dev_addr)
{
  printf("A MassStorage device is mounted\r\n");

  uint8_t const lun = 0;
  tuh_msc_inquiry(dev_addr, lun, &inquiry_resp, inquiry_complete_cb, 0);
}

void tuh_msc_umount_cb(uint8_t dev_addr)
{
  file_accessible = false;
  (void) dev_addr;
  printf("A MassStorage device is unmounted\r\n");
}


//--------------------------------------------------------------------+
// DiskIO
//--------------------------------------------------------------------+

static void wait_for_disk_io(BYTE pdrv)
{
  while(_disk_busy[pdrv])
  {
    tuh_task();
  }
}

static bool disk_io_complete(uint8_t dev_addr, tuh_msc_complete_data_t const * cb_data)
{
  (void) dev_addr; (void) cb_data;
  _disk_busy[dev_addr-1] = false;
  return true;
}

DSTATUS disk_status (
	BYTE pdrv		/* Physical drive nmuber to identify the drive */
)
{
  uint8_t dev_addr = pdrv + 1;
  return tuh_msc_mounted(dev_addr) ? 0 : STA_NODISK;
}

DSTATUS disk_initialize (
	BYTE pdrv				/* Physical drive nmuber to identify the drive */
)
{
  (void) pdrv;
	return 0; // nothing to do
}

DRESULT disk_read (
	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
	BYTE *buff,		/* Data buffer to store read data */
	LBA_t sector,	/* Start sector in LBA */
	UINT count		/* Number of sectors to read */
)
{
	uint8_t const dev_addr = pdrv + 1;
	uint8_t const lun = 0;

	_disk_busy[pdrv] = true;
	tuh_msc_read10(dev_addr, lun, buff, sector, (uint16_t) count, disk_io_complete, 0);
	wait_for_disk_io(pdrv);

	return RES_OK;
}

#if FF_FS_READONLY == 0

DRESULT disk_write (
	BYTE pdrv,			/* Physical drive nmuber to identify the drive */
	const BYTE *buff,	/* Data to be written */
	LBA_t sector,		/* Start sector in LBA */
	UINT count			/* Number of sectors to write */
)
{
	uint8_t const dev_addr = pdrv + 1;
	uint8_t const lun = 0;

	_disk_busy[pdrv] = true;
	tuh_msc_write10(dev_addr, lun, buff, sector, (uint16_t) count, disk_io_complete, 0);
	wait_for_disk_io(pdrv);

	return RES_OK;
}

#endif

DRESULT disk_ioctl (
	BYTE pdrv,		/* Physical drive nmuber (0..) */
	BYTE cmd,		/* Control code */
	void *buff		/* Buffer to send/receive control data */
)
{
  uint8_t const dev_addr = pdrv + 1;
  uint8_t const lun = 0;
  switch ( cmd )
  {
    case CTRL_SYNC:
      // nothing to do since we do blocking
      return RES_OK;

    case GET_SECTOR_COUNT:
      *((DWORD*) buff) = (WORD) tuh_msc_get_block_count(dev_addr, lun);
      return RES_OK;

    case GET_SECTOR_SIZE:
      *((WORD*) buff) = (WORD) tuh_msc_get_block_size(dev_addr, lun);
      return RES_OK;

    case GET_BLOCK_SIZE:
      *((DWORD*) buff) = 1;    // erase block size in units of sector size
      return RES_OK;

    default:
      return RES_PARERR;
  }

	return RES_OK;
}

DWORD get_fattime (void){
  return 
    (2025-1970) << 25 |   // Année
    6 << 21 |             // Mois
    7 << 16 |             // jour du mois
    17 << 11 |            // Heures
    29 << 5 |             // Minutes
    30 << 0               // Secondes
    ;
}