예제 #1
0
파일: psas_sdclog.c 프로젝트: wa2tqi/stm32
/*!
 * \brief Card insertion event.
 *
 * Also use at power up to see if card was or remained
 * inserted while power unavailable.
 */
void sdc_insert_handler(eventid_t id) {
    FRESULT err;

    (void)id;

    /*! \todo generate a mailbox event here */

    /*! \todo test event message system */


    /*!
     * On insertion SDC initialization and FS mount.
     */
    if (sdcConnect(&SDCD1)) {
        if(sdcConnect(&SDCD1)) {   // why does it often fail the first time but not the second?
            return;
        }
    }

    err = f_mount(0, &SDC_FS);
    if (err != FR_OK) {
        err = f_mount(0, &SDC_FS);
        if (err != FR_OK) {
            sdcDisconnect(&SDCD1);
            return;
        }
    }
    sdc_reset_fp_index();
    fs_ready = TRUE;
    chEvtBroadcast(&sdc_start_event);
}
예제 #2
0
파일: kl_sd.cpp 프로젝트: Kreyl/nute
void sd_t::Init() {
    IsReady = FALSE;

    // Bus pins
    PinSetupAlterFunc(GPIOC,  8, omPushPull, pudPullUp, AF12, ps50MHz);
    PinSetupAlterFunc(GPIOC,  9, omPushPull, pudPullUp, AF12, ps50MHz);
    PinSetupAlterFunc(GPIOC, 10, omPushPull, pudPullUp, AF12, ps50MHz);
    PinSetupAlterFunc(GPIOC, 11, omPushPull, pudPullUp, AF12, ps50MHz);
    PinSetupAlterFunc(GPIOC, 12, omPushPull, pudNone,   AF12, ps50MHz);
    PinSetupAlterFunc(GPIOD,  2, omPushPull, pudPullUp, AF12, ps50MHz);
    // Power pin
    PinSetupOut(GPIOC, 4, omPushPull, pudNone);
    PinClear(GPIOC, 4); // Power on
    Delay_ms(450);

    FRESULT err;
    sdcInit();
    sdcStart(&SDCD1, NULL);
    if (sdcConnect(&SDCD1)) {
        Uart.Printf("SD connect error\r");
        return;
    }
    else {
        Uart.Printf("SD capacity: %u\r", SDCD1.capacity);
    }

    err = f_mount(0, &SDC_FS);
    if (err != FR_OK) {
        Uart.Printf("SD mount error\r");
        sdcDisconnect(&SDCD1);
        return;
    }
    IsReady = TRUE;
}
예제 #3
0
/*
 * SD card removal event.
 */
static void RemoveHandler(eventid_t id) {

  (void)id;
  if (sdcGetDriverState(&SDCD1) == SDC_ACTIVE)
    sdcDisconnect(&SDCD1);
  fs_ready = FALSE;
}
예제 #4
0
void poll_inserted() {
	const auto card_present_now = sdcIsCardInserted(&SDCD1);
	if( card_present_now != card_present ) {
		card_present = card_present_now;

		Status new_status { card_present ? Status::Present : Status::NotPresent };

		if( card_present ) {
			if( sdcConnect(&SDCD1) == CH_SUCCESS ) {
				if( mount() == FR_OK ) {
					new_status = Status::Mounted;
				} else {
					new_status = Status::MountError;
				}
			} else {
				new_status = Status::ConnectError;
			}
		} else {
			sdcDisconnect(&SDCD1);
		}

		status_ = new_status;
		status_signal.emit(status_);
	}
}
// Card removal event.
static void RemoveHandler( eventid_t id ) 
{
    (void)id;
    sdcDisconnect( &SDCD1 );
    
    DPRINT( 2, KYEL "[ FatFS ] Card removed\r\n" );
    fs_ready = FALSE;
}
예제 #6
0
파일: kb_writer.c 프로젝트: naniBox/kuroBox
//-----------------------------------------------------------------------------
// usually alreay too late to actually disconnect, but it's good to have
// things in a known state
static void
on_remove(void)
{
	sdcDisconnect(&SDCD1);
	kbs_setSDCFree(0);
	kbs_setFName(KUROBOX_BLANK_FNAME);
	kbs_err_setSD(0);
	fs_ready = FALSE;
}
예제 #7
0
파일: sdio.c 프로젝트: 2seasuav/paparuzzi
bool sdioDisconnect (void)
{
  if (cnxState == STOP)
    return true;
  if (sdcDisconnect(&SDCD1)) {
    return false;
  }
  sdcStop (&SDCD1);
  cnxState = STOP;
  return true;
}
예제 #8
0
/* SD Card Disconnect */
static void microsd_card_deinit() {

    /* Unmount File System */
    f_mount(0, "A", 0);

    /* Disconnect from card */
    sdcDisconnect(&SDCD1);

    /* Disable SDC peripheral */
    sdcStop(&SDCD1);
}
예제 #9
0
파일: psas_sdclog.c 프로젝트: wa2tqi/stm32
void sdc_haltnow(void) {
    bool  b_ret;

    chEvtBroadcast(&sdc_halt_event);

    chThdSleepMilliseconds(20);

    b_ret = sdcDisconnect(&SDCD1);
    if(b_ret) {
        SDCDEBUG("sdcDiscon fail\r\n");   // this happens a lot!
        b_ret = sdcDisconnect(&SDCD1);
        if(b_ret) {
            SDCDEBUG("sdcDiscon fail2\r\n");
        }
    }
    sdc_reset_fp_index();
    fs_ready = FALSE;

    SDCDEBUG("SDC card halted.\r\n");
}
예제 #10
0
bool_t sdioDisconnect (void)
{
  if (cnxState == STOP)
    return TRUE;
  if (sdcDisconnect(&SDCD1)) {
    return FALSE;
  }
  sdcStop (&SDCD1);
  cnxState = STOP;
  return TRUE;
}
예제 #11
0
파일: psas_sdclog.c 프로젝트: wa2tqi/stm32
/*!
 *  \brief Card removal event.
 */
void sdc_remove_handler(eventid_t id) {
    (void)id;
    bool_t ret;

    chEvtBroadcast(&sdc_halt_event);
    chThdSleepMilliseconds(5);

    /*! \todo generate a mailbox event here */

    /*! \todo test event message system */
    ret = sdcDisconnect(&SDCD1);
    if(ret) {
        SDCDEBUG("sdcDiscon fail\r\n");   // this happens a lot!
        ret = sdcDisconnect(&SDCD1);
        if(ret) {
            SDCDEBUG("sdcDiscon fail2\r\n");
        }
    }
    sdc_reset_fp_index();
    fs_ready = FALSE;
}
예제 #12
0
파일: microsd.cpp 프로젝트: barthess/u
/*
 * SD card removal event.
 */
static void remove_handler(void) {

  if (fs_ready == TRUE){
    f_mount(0, NULL);
    fs_ready = FALSE;
  }

  if ((&SDCD1)->state == BLK_ACTIVE){
    sdcDisconnect(&SDCD1);
    sdcStop(&SDCD1);
  }
  fs_ready = FALSE;
}
예제 #13
0
파일: sdcard.c 프로젝트: MaxPayne86/axoloti
/*
 * Card insertion event.
 */
static void InsertHandler(eventid_t id) {
  FRESULT err;

  (void)id;
  /*
   * On insertion SDC initialization and FS mount.
   */
  if (fs_ready) {
    sdcDisconnect(&SDCD1);
    fs_ready = FALSE;
  }

  if (sdcConnect(&SDCD1))
    return;

  err = f_mount(0, &SDC_FS);
  if (err != FR_OK) {
    sdcDisconnect(&SDCD1);
    return;
  }
  fs_ready = TRUE;
}
예제 #14
0
파일: microsd.cpp 프로젝트: barthess/u
/*
 * SD card insertion event.
 */
static void insert_handler(void) {
  FRESULT err;

  sdcStart(&SDCD1, &sdccfg);
  /*
   * On insertion SDC initialization and FS mount.
   */
  if (sdcConnect(&SDCD1))
    return;

  err = f_mount(0, &SDC_FS);
  if (err != FR_OK) {
    sdcDisconnect(&SDCD1);
    sdcStop(&SDCD1);
    return;
  }
  fs_ready = TRUE;
}
// Card insertion event.
static void InsertHandler( eventid_t id ) 
{
    FRESULT err;
    
    (void)id;
    // On insertion SDC initialization and FS mount.
    if( sdcConnect( &SDCD1 ) )
      return;
    
    err = f_mount( &SDC_FS, "/", 1 );
    if( FR_OK != err ) 
    {
        sdcDisconnect( &SDCD1 );
        return;
    }
    
    DPRINT( 2, KYEL "[ FatFS ] Card inserted\r\n" );
    fs_ready = TRUE;
}
예제 #16
0
파일: main.c 프로젝트: 0x00f/ChibiOS
void cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
  (void)argc;
  (void)argv;
  FRESULT err;
  uint32_t clusters;
  FATFS *fsp;
  FIL FileObject;
  //FILINFO FileInfo;
  size_t bytes_written;
  struct tm timp;

#if !HAL_USE_RTC
  chprintf(chp, "ERROR! Chibios compiled without RTC support.");
  chprintf(chp, "Enable HAL_USE_RCT in you halconf.h");
  chThdSleepMilliseconds(100);
  return;
#endif

  chprintf(chp, "Trying to connect SDIO... ");
  chThdSleepMilliseconds(100);

  if (!sdcConnect(&SDCD1)) {
    chprintf(chp, "OK\r\n");
    chprintf(chp, "Register working area for filesystem... ");
    chThdSleepMilliseconds(100);
    err = f_mount(0, &SDC_FS);
    if (err != FR_OK){
      chSysHalt();
    }
    else{
      fs_ready = TRUE;
      chprintf(chp, "OK\r\n");
    }

    chprintf(chp, "Mounting filesystem... ");
    chThdSleepMilliseconds(100);
    err = f_getfree("/", &clusters, &fsp);
    if (err != FR_OK) {
      chSysHalt();
    }
    chprintf(chp, "OK\r\n");
    chprintf(chp,
             "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
             clusters, (uint32_t)SDC_FS.csize,
             clusters * (uint32_t)SDC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);

    rtcGetTimeTm(&RTCD1, &timp);
    chprintf(chp, "Current RTC time is: ");
    chprintf(chp, "%u-%u-%u %u:%u:%u\r\n",
      timp.tm_year+1900, timp.tm_mon+1, timp.tm_mday, timp.tm_hour, timp.tm_min,
      timp.tm_sec);

    chprintf(chp, "Creating empty file 'tmstmp.tst'... ");
    chThdSleepMilliseconds(100);
    err = f_open(&FileObject, "0:tmstmp.tst", FA_WRITE | FA_OPEN_ALWAYS);
    if (err != FR_OK) {
      chSysHalt();
    }
    chprintf(chp, "OK\r\n");

    chprintf(chp, "Write some data in it... ");
    chThdSleepMilliseconds(100);
    err = f_write(&FileObject, "tst", sizeof("tst"), (void *)&bytes_written);
    if (err != FR_OK) {
      chSysHalt();
    }
    else
      chprintf(chp, "OK\r\n");

    chprintf(chp, "Closing file 'tmstmp.tst'... ");
    chThdSleepMilliseconds(100);
    err = f_close(&FileObject);
    if (err != FR_OK) {
      chSysHalt();
    }
    else
      chprintf(chp, "OK\r\n");

//    chprintf(chp, "Obtaining file info ... ");
//    chThdSleepMilliseconds(100);
//    err = f_stat("0:tmstmp.tst", &FileInfo);
//    if (err != FR_OK) {
//      chSysHalt();
//    }
//    else{
//      chprintf(chp, "OK\r\n");
//      chprintf(chp, "    Timestamp: %u-%u-%u %u:%u:%u\r\n",
//                         ((FileInfo.fdate >> 9) & 127) + 1980,
//                         (FileInfo.fdate >> 5) & 15,
//                         FileInfo.fdate & 31,
//                         (FileInfo.ftime >> 11) & 31,
//                         (FileInfo.ftime >> 5) & 63,
//                         (FileInfo.ftime & 31) * 2);
//    }

    chprintf(chp, "Umounting filesystem... ");
    f_mount(0, NULL);
    chprintf(chp, "OK\r\n");

    chprintf(chp, "Disconnecting from SDIO...");
    chThdSleepMilliseconds(100);
    if (sdcDisconnect(&SDCD1))
      chSysHalt();
    chprintf(chp, " OK\r\n");
    chprintf(chp, "------------------------------------------------------\r\n");
    chprintf(chp, "Now you can remove memory card and check timestamp on PC.\r\n");
    chThdSleepMilliseconds(100);
  }
  else{
    chSysHalt();
  }
}
예제 #17
0
파일: main.c 프로젝트: pfhnr/stm32
/*
 * Card removal event.
 */
static void RemoveHandler(eventid_t id) {

  (void)id;
  sdcDisconnect(&SDCD1);
  fs_ready = FALSE;
}
예제 #18
0
파일: main.c 프로젝트: AlexShiLucky/ChibiOS
void cmd_sdc(BaseSequentialStream *chp, int argc, char *argv[]) {
  static const char *mode[] = {"SDV11", "SDV20", "MMC", NULL};
  systime_t start, end;
  uint32_t n, startblk;

  if (argc != 1) {
    chprintf(chp, "Usage: sdiotest read|write|erase|all\r\n");
    return;
  }

  /* Card presence check.*/
  if (!blkIsInserted(&SDCD1)) {
    chprintf(chp, "Card not inserted, aborting.\r\n");
    return;
  }

  /* Connection to the card.*/
  chprintf(chp, "Connecting... ");
  if (sdcConnect(&SDCD1)) {
    chprintf(chp, "failed\r\n");
    return;
  }

  chprintf(chp, "OK\r\n\r\nCard Info\r\n");
  chprintf(chp, "CSD      : %08X %8X %08X %08X \r\n",
           SDCD1.csd[3], SDCD1.csd[2], SDCD1.csd[1], SDCD1.csd[0]);
  chprintf(chp, "CID      : %08X %8X %08X %08X \r\n",
           SDCD1.cid[3], SDCD1.cid[2], SDCD1.cid[1], SDCD1.cid[0]);
  chprintf(chp, "Mode     : %s\r\n", mode[SDCD1.cardmode & 3U]);
  chprintf(chp, "Capacity : %DMB\r\n", SDCD1.capacity / 2048);

  /* The test is performed in the middle of the flash area.*/
  startblk = (SDCD1.capacity / MMCSD_BLOCK_SIZE) / 2;

  if ((strcmp(argv[0], "read") == 0) ||
      (strcmp(argv[0], "all") == 0)) {

    /* Single block read performance, aligned.*/
    chprintf(chp, "Single block aligned read performance:           ");
    start = chVTGetSystemTime();
    end = start + MS2ST(1000);
    n = 0;
    do {
      if (blkRead(&SDCD1, startblk, buf, 1)) {
        chprintf(chp, "failed\r\n");
        goto exittest;
      }
      n++;
    } while (chVTIsSystemTimeWithin(start, end));
    chprintf(chp, "%D blocks/S, %D bytes/S\r\n", n, n * MMCSD_BLOCK_SIZE);

    /* Multiple sequential blocks read performance, aligned.*/
    chprintf(chp, "16 sequential blocks aligned read performance:   ");
    start = chVTGetSystemTime();
    end = start + MS2ST(1000);
    n = 0;
    do {
      if (blkRead(&SDCD1, startblk, buf, SDC_BURST_SIZE)) {
        chprintf(chp, "failed\r\n");
        goto exittest;
      }
      n += SDC_BURST_SIZE;
    } while (chVTIsSystemTimeWithin(start, end));
    chprintf(chp, "%D blocks/S, %D bytes/S\r\n", n, n * MMCSD_BLOCK_SIZE);

#if STM32_SDC_SDIO_UNALIGNED_SUPPORT
    /* Single block read performance, unaligned.*/
    chprintf(chp, "Single block unaligned read performance:         ");
    start = chVTGetSystemTime();
    end = start + MS2ST(1000);
    n = 0;
    do {
      if (blkRead(&SDCD1, startblk, buf + 1, 1)) {
        chprintf(chp, "failed\r\n");
        goto exittest;
      }
      n++;
    } while (chVTIsSystemTimeWithin(start, end));
    chprintf(chp, "%D blocks/S, %D bytes/S\r\n", n, n * MMCSD_BLOCK_SIZE);

    /* Multiple sequential blocks read performance, unaligned.*/
    chprintf(chp, "16 sequential blocks unaligned read performance: ");
    start = chVTGetSystemTime();
    end = start + MS2ST(1000);
    n = 0;
    do {
      if (blkRead(&SDCD1, startblk, buf + 1, SDC_BURST_SIZE)) {
        chprintf(chp, "failed\r\n");
        goto exittest;
      }
      n += SDC_BURST_SIZE;
    } while (chVTIsSystemTimeWithin(start, end));
    chprintf(chp, "%D blocks/S, %D bytes/S\r\n", n, n * MMCSD_BLOCK_SIZE);
#endif /* STM32_SDC_SDIO_UNALIGNED_SUPPORT */
  }

  if ((strcmp(argv[0], "write") == 0) ||
      (strcmp(argv[0], "all") == 0)) {
    unsigned i;

    memset(buf, 0xAA, MMCSD_BLOCK_SIZE * 2);
    chprintf(chp, "Writing...");
    if(sdcWrite(&SDCD1, startblk, buf, 2)) {
      chprintf(chp, "failed\r\n");
      goto exittest;
    }
    chprintf(chp, "OK\r\n");

    memset(buf, 0x55, MMCSD_BLOCK_SIZE * 2);
    chprintf(chp, "Reading...");
    if (blkRead(&SDCD1, startblk, buf, 1)) {
      chprintf(chp, "failed\r\n");
      goto exittest;
    }
    chprintf(chp, "OK\r\n");

    for (i = 0; i < MMCSD_BLOCK_SIZE; i++)
      buf[i] = i + 8;
    chprintf(chp, "Writing...");
    if(sdcWrite(&SDCD1, startblk, buf, 2)) {
      chprintf(chp, "failed\r\n");
      goto exittest;
    }
    chprintf(chp, "OK\r\n");

    memset(buf, 0, MMCSD_BLOCK_SIZE * 2);
    chprintf(chp, "Reading...");
    if (blkRead(&SDCD1, startblk, buf, 1)) {
      chprintf(chp, "failed\r\n");
      goto exittest;
    }
    chprintf(chp, "OK\r\n");
  }

  if ((strcmp(argv[0], "erase") == 0) ||
      (strcmp(argv[0], "all") == 0)) {
    /**
     * Test sdcErase()
     * Strategy:
     *   1. Fill two blocks with non-constant data
     *   2. Write two blocks starting at startblk
     *   3. Erase the second of the two blocks
     *      3.1. First block should be equal to the data written
     *      3.2. Second block should NOT be equal too the data written (i.e. erased).
     *   4. Erase both first and second block
     *      4.1 Both blocks should not be equal to the data initially written
     * Precondition: SDC_BURST_SIZE >= 2
     */
    memset(buf, 0, MMCSD_BLOCK_SIZE * 2);
    memset(buf2, 0, MMCSD_BLOCK_SIZE * 2);
    /* 1. */
    unsigned int i = 0;
    for (; i < MMCSD_BLOCK_SIZE * 2; ++i) {
      buf[i] = (i + 7) % 'T'; //Ensure block 1/2 are not equal
    }
    /* 2. */
    if(sdcWrite(&SDCD1, startblk, buf, 2)) {
      chprintf(chp, "sdcErase() test write failed\r\n");
      goto exittest;
    }
    /* 3. (erase) */
    if(sdcErase(&SDCD1, startblk + 1, startblk + 2)) {
      chprintf(chp, "sdcErase() failed\r\n");
      goto exittest;
    }
    sdcflags_t errflags = sdcGetAndClearErrors(&SDCD1);
    if(errflags) {
      chprintf(chp, "sdcErase() yielded error flags: %d\r\n", errflags);
      goto exittest;
    }
    if(sdcRead(&SDCD1, startblk, buf2, 2)) {
      chprintf(chp, "single-block sdcErase() failed\r\n");
      goto exittest;
    }
    /* 3.1. */
    if(memcmp(buf, buf2, MMCSD_BLOCK_SIZE) != 0) {
      chprintf(chp, "sdcErase() non-erased block compare failed\r\n");
      goto exittest;
    }
    /* 3.2. */
    if(memcmp(buf + MMCSD_BLOCK_SIZE,
              buf2 + MMCSD_BLOCK_SIZE, MMCSD_BLOCK_SIZE) == 0) {
      chprintf(chp, "sdcErase() erased block compare failed\r\n");
      goto exittest;
    }
    /* 4. */
    if(sdcErase(&SDCD1, startblk, startblk + 2)) {
      chprintf(chp, "multi-block sdcErase() failed\r\n");
      goto exittest;
    }
    if(sdcRead(&SDCD1, startblk, buf2, 2)) {
      chprintf(chp, "single-block sdcErase() failed\r\n");
      goto exittest;
    }
    /* 4.1 */
    if(memcmp(buf, buf2, MMCSD_BLOCK_SIZE) == 0) {
      chprintf(chp, "multi-block sdcErase() erased block compare failed\r\n");
      goto exittest;
    }
    if(memcmp(buf + MMCSD_BLOCK_SIZE,
              buf2 + MMCSD_BLOCK_SIZE, MMCSD_BLOCK_SIZE) == 0) {
      chprintf(chp, "multi-block sdcErase() erased block compare failed\r\n");
      goto exittest;
    }
    /* END of sdcErase() test */
  }
  
  /* Card disconnect and command end.*/
exittest:
  sdcDisconnect(&SDCD1);
}
예제 #19
0
파일: kb_writer.c 프로젝트: naniBox/kuroBox
//-----------------------------------------------------------------------------
// the SD card has been inserted, do the necessary steps to get a sane system
static int
on_insert(void)
{
	FRESULT stat;

	kbs_setFName(KUROBOX_LOADING_NAME);
	if (!sdcConnect(&SDCD1))
	{
		kbs_setFName(KUROBOX_ERR1);
		return KB_NOT_OK;
	}

	stat = f_mount(&SDC_FS, "/", 1);
	if (stat != FR_OK)
	{
		kbs_setFName(KUROBOX_ERR2);
		sdcDisconnect(&SDCD1);
		return KB_NOT_OK;
	}

	chThdSleepMilliseconds(100);
	uint32_t clusters;
	FATFS * fsp = NULL;
	stat = f_getfree("/", &clusters, &fsp);
	if (stat != FR_OK)
	{
		kbs_setFName(KUROBOX_ERR3);
		sdcDisconnect(&SDCD1);
		return KB_NOT_OK;
	}
	uint64_t cardsize = clusters * (((uint32_t)fsp->csize * (uint32_t)MMCSD_BLOCK_SIZE) / 1024);
	cardsize_MB = cardsize / 1024;

	// @TODO: this can be moved to above the check for free space
	fs_write_protected = sdc_lld_is_write_protected(&SDCD1);
	if ( fs_write_protected )
	{
		// -1 means that it's write protected, display that
		kbs_setSDCFree(-1);
		kbs_setFName(KUROBOX_WP_NAME);
		return KB_NOT_OK;
	}
	kbs_setSDCFree(cardsize_MB);

	stat = make_dirs();
	if (stat != FR_OK)
	{
		kbs_setFName(KUROBOX_ERR4);
		sdcDisconnect(&SDCD1);
		return KB_NOT_OK;
	}

	stat = new_file();
	if (stat != FR_OK)
	{
		kbs_setFName(KUROBOX_ERR5);
		sdcDisconnect(&SDCD1);
		return KB_NOT_OK;
	}

	fs_ready = TRUE;
	logger_state = LS_RUNNING;

	kbs_err_setSD(1);

	return KB_OK;
}
예제 #20
0
파일: main.c 프로젝트: CNCBASHER/ChibiOS
void cmd_sdiotest(BaseSequentialStream *chp, int argc, char *argv[]){
  (void)argc;
  (void)argv;
  uint32_t i = 0;

  chprintf(chp, "Trying to connect SDIO... ");
  chThdSleepMilliseconds(100);

  if (!sdcConnect(&SDCD1)) {

    chprintf(chp, "OK\r\n");
    chprintf(chp, "*** Card CSD content is: ");
    chprintf(chp, "%X %X %X %X \r\n", (&SDCD1)->csd[3], (&SDCD1)->csd[2],
                                      (&SDCD1)->csd[1], (&SDCD1)->csd[0]);

    chprintf(chp, "Single aligned read...");
    chThdSleepMilliseconds(100);
    if (sdcRead(&SDCD1, 0, inbuf, 1))
      chSysHalt();
    chprintf(chp, " OK\r\n");
    chThdSleepMilliseconds(100);


    chprintf(chp, "Single unaligned read...");
    chThdSleepMilliseconds(100);
    if (sdcRead(&SDCD1, 0, inbuf + 1, 1))
      chSysHalt();
    if (sdcRead(&SDCD1, 0, inbuf + 2, 1))
      chSysHalt();
    if (sdcRead(&SDCD1, 0, inbuf + 3, 1))
      chSysHalt();
    chprintf(chp, " OK\r\n");
    chThdSleepMilliseconds(100);


    chprintf(chp, "Multiple aligned reads...");
    chThdSleepMilliseconds(100);
    fillbuffers(0x55);
    /* fill reference buffer from SD card */
    if (sdcRead(&SDCD1, 0, inbuf, SDC_BURST_SIZE))
      chSysHalt();
    for (i=0; i<1000; i++){
      if (sdcRead(&SDCD1, 0, outbuf, SDC_BURST_SIZE))
        chSysHalt();
      if (memcmp(inbuf, outbuf, SDC_BURST_SIZE * MMCSD_BLOCK_SIZE) != 0)
        chSysHalt();
    }
    chprintf(chp, " OK\r\n");
    chThdSleepMilliseconds(100);


    chprintf(chp, "Multiple unaligned reads...");
    chThdSleepMilliseconds(100);
    fillbuffers(0x55);
    /* fill reference buffer from SD card */
    if (sdcRead(&SDCD1, 0, inbuf + 1, SDC_BURST_SIZE))
      chSysHalt();
    for (i=0; i<1000; i++){
      if (sdcRead(&SDCD1, 0, outbuf + 1, SDC_BURST_SIZE))
        chSysHalt();
      if (memcmp(inbuf, outbuf, SDC_BURST_SIZE * MMCSD_BLOCK_SIZE) != 0)
        chSysHalt();
    }
    chprintf(chp, " OK\r\n");
    chThdSleepMilliseconds(100);

#if SDC_DATA_DESTRUCTIVE_TEST

    chprintf(chp, "Single aligned write...");
    chThdSleepMilliseconds(100);
    fillbuffer(0xAA, inbuf);
    if (sdcWrite(&SDCD1, 0, inbuf, 1))
      chSysHalt();
    fillbuffer(0, outbuf);
    if (sdcRead(&SDCD1, 0, outbuf, 1))
      chSysHalt();
    if (memcmp(inbuf, outbuf, MMCSD_BLOCK_SIZE) != 0)
      chSysHalt();
    chprintf(chp, " OK\r\n");

    chprintf(chp, "Single unaligned write...");
    chThdSleepMilliseconds(100);
    fillbuffer(0xFF, inbuf);
    if (sdcWrite(&SDCD1, 0, inbuf+1, 1))
      chSysHalt();
    fillbuffer(0, outbuf);
    if (sdcRead(&SDCD1, 0, outbuf+1, 1))
      chSysHalt();
    if (memcmp(inbuf+1, outbuf+1, MMCSD_BLOCK_SIZE) != 0)
      chSysHalt();
    chprintf(chp, " OK\r\n");

    chprintf(chp, "Running badblocks at 0x10000 offset...");
    chThdSleepMilliseconds(100);
    if(badblocks(0x10000, 0x11000, SDC_BURST_SIZE, 0xAA))
      chSysHalt();
    chprintf(chp, " OK\r\n");
#endif /* !SDC_DATA_DESTRUCTIVE_TEST */


    /**
     * Now perform some FS tests.
     */

    FRESULT err;
    uint32_t clusters;
    FATFS *fsp;
    FIL FileObject;
    uint32_t bytes_written;
    uint32_t bytes_read;
    FILINFO filinfo;
    uint8_t teststring[] = {"This is test file\r\n"};

    chprintf(chp, "Register working area for filesystem... ");
    chThdSleepMilliseconds(100);
    err = f_mount(0, &SDC_FS);
    if (err != FR_OK){
      chSysHalt();
    }
    else{
      fs_ready = TRUE;
      chprintf(chp, "OK\r\n");
    }


#if SDC_DATA_DESTRUCTIVE_TEST
    chprintf(chp, "Formatting... ");
    chThdSleepMilliseconds(100);
    err = f_mkfs (0,0,0);
    if (err != FR_OK){
      chSysHalt();
    }
    else{
      chprintf(chp, "OK\r\n");
    }
#endif /* SDC_DATA_DESTRUCTIVE_TEST */


    chprintf(chp, "Mount filesystem... ");
    chThdSleepMilliseconds(100);
    err = f_getfree("/", &clusters, &fsp);
    if (err != FR_OK) {
      chSysHalt();
    }
    chprintf(chp, "OK\r\n");
    chprintf(chp,
             "FS: %lu free clusters, %lu sectors per cluster, %lu bytes free\r\n",
             clusters, (uint32_t)SDC_FS.csize,
             clusters * (uint32_t)SDC_FS.csize * (uint32_t)MMCSD_BLOCK_SIZE);


    chprintf(chp, "Create file \"chtest.txt\"... ");
    chThdSleepMilliseconds(100);
    err = f_open(&FileObject, "0:chtest.txt", FA_WRITE | FA_OPEN_ALWAYS);
    if (err != FR_OK) {
      chSysHalt();
    }
    chprintf(chp, "OK\r\n");
    chprintf(chp, "Write some data in it... ");
    chThdSleepMilliseconds(100);
    err = f_write(&FileObject, teststring, sizeof(teststring), (void *)&bytes_written);
    if (err != FR_OK) {
      chSysHalt();
    }
    else
      chprintf(chp, "OK\r\n");

    chprintf(chp, "Close file \"chtest.txt\"... ");
    err = f_close(&FileObject);
    if (err != FR_OK) {
      chSysHalt();
    }
    else
      chprintf(chp, "OK\r\n");

    chprintf(chp, "Check file size \"chtest.txt\"... ");
    err = f_stat("0:chtest.txt", &filinfo);
    chThdSleepMilliseconds(100);
    if (err != FR_OK) {
      chSysHalt();
    }
    else{
      if (filinfo.fsize == sizeof(teststring))
        chprintf(chp, "OK\r\n");
      else
        chSysHalt();
    }

    chprintf(chp, "Check file content \"chtest.txt\"... ");
    err = f_open(&FileObject, "0:chtest.txt", FA_READ | FA_OPEN_EXISTING);
    chThdSleepMilliseconds(100);
    if (err != FR_OK) {
      chSysHalt();
    }
    uint8_t buf[sizeof(teststring)];
    err = f_read(&FileObject, buf, sizeof(teststring), (void *)&bytes_read);
    if (err != FR_OK) {
      chSysHalt();
    }
    else{
      if (memcmp(teststring, buf, sizeof(teststring)) != 0){
        chSysHalt();
      }
      else{
        chprintf(chp, "OK\r\n");
      }
    }

    chprintf(chp, "Umount filesystem... ");
    f_mount(0, NULL);
    chprintf(chp, "OK\r\n");

    chprintf(chp, "Disconnecting from SDIO...");
    chThdSleepMilliseconds(100);
    if (sdcDisconnect(&SDCD1))
      chSysHalt();
    chprintf(chp, " OK\r\n");
    chprintf(chp, "------------------------------------------------------\r\n");
    chprintf(chp, "All tests passed successfully.\r\n");
    chThdSleepMilliseconds(100);
  }
  else{
    chSysHalt();
  }
}
예제 #21
0
파일: main.c 프로젝트: nistumpe/Workspace
/*
 * Application entry point.
 */
int main(void) {

    /*
     * System initializations.
     * - HAL initialization, this also initializes the configured device drivers
     *   and performs the board-specific initializations.
     * - Kernel initialization, the main() function becomes a thread and the
     *   RTOS is active.
     */
    halInit();
    chSysInit();

    /*
     * Initializes the SDIO drivers.
     */
    sdcStart(&SDCD1, &sdccfg);
    if (!sdcConnect(&SDCD1)) {
        int i;

        /* Single aligned read.*/
        if (sdcRead(&SDCD1, 0, blkbuf, 1))
            chSysHalt();

        /* Single unaligned read.*/
        if (sdcRead(&SDCD1, 0, blkbuf + 1, 1))
            chSysHalt();

        /* Multiple aligned read.*/
        if (sdcRead(&SDCD1, 0, blkbuf, 4))
            chSysHalt();

        /* Multiple unaligned read.*/
        if (sdcRead(&SDCD1, 0, blkbuf + 1, 4))
            chSysHalt();

        /* Repeated multiple aligned reads.*/
        for (i = 0; i < 1000; i++) {
            if (sdcRead(&SDCD1, 0, blkbuf, 4))
                chSysHalt();
        }

        /* Repeated multiple unaligned reads.*/
        for (i = 0; i < 1000; i++) {
            if (sdcRead(&SDCD1, 0, blkbuf + 1, 4))
                chSysHalt();
        }

        /* Repeated multiple aligned writes.*/
        for (i = 0; i < 100; i++) {
            if (sdcRead(&SDCD1, 0x10000, blkbuf, 4))
                chSysHalt();
            if (sdcWrite(&SDCD1, 0x10000, blkbuf, 4))
                chSysHalt();
            if (sdcWrite(&SDCD1, 0x10000, blkbuf, 4))
                chSysHalt();
        }

        /* Repeated multiple unaligned writes.*/
        for (i = 0; i < 100; i++) {
            if (sdcRead(&SDCD1, 0x10000, blkbuf + 1, 4))
                chSysHalt();
            if (sdcWrite(&SDCD1, 0x10000, blkbuf + 1, 4))
                chSysHalt();
            if (sdcWrite(&SDCD1, 0x10000, blkbuf + 1, 4))
                chSysHalt();
        }

        if (sdcDisconnect(&SDCD1))
            chSysHalt();
    }

    /*
     * Normal main() thread activity.
     */
    while (TRUE) {
        chThdSleepMilliseconds(500);
    }
}
예제 #22
0
파일: kb_writer.c 프로젝트: naniBox/kuroBox
//-----------------------------------------------------------------------------
// main writer thread function - is called when SD card is ready and we're just
// going to keep writing until SD card is ejected.
// @TODO: when file exceeds 1GB, start a new file
static uint8_t
writing_run(void)
{
	uint8_t ret = 1;
	uint32_t writer_buffers_written = 0;
	while(LS_RUNNING == logger_state)
	{
		if (chThdShouldTerminateX())
		{
			logger_state = LS_EXITING;
			f_sync(&kbfile);
			f_close(&kbfile);
			sdcDisconnect(&SDCD1);
			break;
		}

		int8_t idx = new_write_buffer_idx_to_write();
		if ( idx == -1 )
		{
			// no more buffers to write, go to sleep, wait to be notified
			chSysLock();
				writerThreadForSleep = chThdGetSelfX();
			    chSchGoSleepS(CH_STATE_SUSPENDED);
			chSysUnlock();

			// we can get woken up by either a buffer ready to be written
			// or a request to terminate, either way, back to the start
			// of the loop to check.
			continue;
		}

		//----------------------------------------------------------------------
		// start of write
		kbg_setLED1(1);

		// here we have a full buffer ready to write
		write_buffer_t * buf = &write_buffers[idx];

		UINT bytes_written = 0;
		FRESULT stat = FR_OK;

		DEBG_WRITER_TIME_WRITES_TIMER(0);
		stat = f_write(&kbfile, buf->buffer, sizeof(buf->buffer), &bytes_written);
		DEBG_WRITER_TIME_WRITES_TIMER(1);

		kbg_setLED1(0);
		// end of write
		//----------------------------------------------------------------------

		if (bytes_written != sizeof(buf->buffer) || stat != FR_OK)
			current_msg.write_errors++;

		//----------------------------------------------------------------------
		// start of flush
		//kbg_setLED2(1);
		
		DEBG_WRITER_TIME_WRITES_TIMER(2);
		stat = f_sync(&kbfile);
		DEBG_WRITER_TIME_WRITES_TIMER(3);

		if (stat != FR_OK)
			current_msg.write_errors++;

		// we're done, return it
		return_write_buffer_idx_after_writing(idx);

		//kbg_setLED2(0);
		// end of flush
		//----------------------------------------------------------------------

#ifdef DEBG_WRITER_TIME_WRITES
		chprintf(DEBG, "%12f, %12f, %12f, %d, %6d, 0x%.8d\n",
				(t1-t0) / 168000.0f, (t3-t2) / 168000.0f, (t3-t0) / 168000.0f,
				idx, bytes_written, buf->buffer);
#endif // DEBG_WRITER_TIME_WRITES

		kbs_setWriteCount(current_msg.msg_num);
		kbs_setWriteErrors(current_msg.write_errors);

		// after X buffers, start a new file. this has to be in sync with
		// the logger thread, so that you both do roll over at the same time
		writer_buffers_written++;
		if ( writer_buffers_written > MAX_BUFFERS_PER_FILE )
		{
			writer_buffers_written = 0;
			// we've hit the file size limit, close the old, open a new file
			if ( new_file() != FR_OK )
			{
				// no new file? that's bad!!
				logger_state = LS_WAIT_FOR_SD;
				break;
			}
		}

		sd_card_status();
		if (LS_RUNNING != logger_state)
			break;

	}
	return ret;
}
예제 #23
0
static int sdc_done(const fstab_entry_t *dev) {
	(void) dev;
	return (sdcDisconnect(&SDCD1) == CH_FAILED) ? -1 : 0;
}