main.cpp

00001 #include "mbed.h"
00002 #include "SDFileSystem.h"
00003 #include "test_env.h"
00004 #include <algorithm>
00005 #include <stdlib.h>
00006 
00007 #if defined(TARGET_KL25Z)
00008 SDFileSystem sd(PTD2, PTD3, PTD1, PTD0, "sd");
00009 
00010 #elif defined(TARGET_KL46Z)
00011 SDFileSystem sd(PTD6, PTD7, PTD5, PTD4, "sd");
00012 
00013 #elif defined(TARGET_K64F) || defined(TARGET_K66F)
00014 SDFileSystem sd(PTE3, PTE1, PTE2, PTE4, "sd");
00015 
00016 #elif defined(TARGET_K22F)
00017 SDFileSystem sd(PTD6, PTD7, PTD5, PTD4, "sd");
00018 
00019 #elif defined(TARGET_K20D50M)
00020 SDFileSystem sd(PTD2, PTD3, PTD1, PTC2, "sd");
00021 
00022 #elif defined(TARGET_nRF51822)
00023 SDFileSystem sd(p12, p13, p15, p14, "sd");
00024 
00025 #elif defined(TARGET_NUCLEO_F030R8) || \
00026       defined(TARGET_NUCLEO_F070RB) || \
00027       defined(TARGET_NUCLEO_F072RB) || \
00028       defined(TARGET_NUCLEO_F091RC) || \
00029       defined(TARGET_NUCLEO_F103RB) || \
00030       defined(TARGET_NUCLEO_F302R8) || \
00031       defined(TARGET_NUCLEO_F303RE) || \
00032       defined(TARGET_NUCLEO_F334R8) || \
00033       defined(TARGET_NUCLEO_F401RE) || \
00034       defined(TARGET_NUCLEO_F410RB) || \
00035       defined(TARGET_NUCLEO_F411RE) || \
00036       defined(TARGET_NUCLEO_L053R8) || \
00037       defined(TARGET_NUCLEO_L073RZ) || \
00038       defined(TARGET_NUCLEO_L152RE)
00039 SDFileSystem sd(D11, D12, D13, D10, "sd");
00040 
00041 #elif defined(TARGET_DISCO_F051R8)
00042 SDFileSystem sd(SPI_MOSI, SPI_MISO, SPI_SCK, SPI_CS, "sd");
00043 
00044 #elif defined(TARGET_LPC2368)
00045 SDFileSystem sd(p11, p12, p13, p14, "sd");
00046 
00047 #elif defined(TARGET_LPC11U68)
00048 SDFileSystem sd(D11, D12, D13, D10, "sd");
00049 
00050 #elif defined(TARGET_LPC1549)
00051 SDFileSystem sd(D11, D12, D13, D10, "sd");
00052 
00053 #elif defined(TARGET_LPC11U37H_401)
00054 SDFileSystem sd(SDMOSI, SDMISO, SDSCLK, SDSSEL, "sd");
00055 
00056 #else
00057 SDFileSystem sd(p11, p12, p13, p14, "sd");
00058 #endif
00059 
00060 namespace {
00061 char buffer[1024];
00062 const int KIB_RW = 128;
00063 Timer timer;
00064 const char *bin_filename = "0:testfile.bin";
00065 }
00066 
00067 bool test_sf_file_write_fatfs(const char *filename, const int kib_rw) {
00068     FIL file;
00069     bool result = true;
00070     FRESULT res = f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
00071     if (res == FR_OK) {
00072         int byte_write = 0;
00073         unsigned int bytes = 0;
00074         timer.start();
00075         for (int i = 0; i < kib_rw; i++) {
00076             if (f_write(&file, buffer, sizeof(buffer), &bytes) != FR_OK) {
00077                 result = false;
00078                 f_close(&file);
00079                 printf("Write error!\r\n");
00080                 break;
00081             } else {
00082                 byte_write++;
00083             }
00084         }
00085         timer.stop();
00086         f_close(&file);
00087         double test_time_sec = timer.read_us() / 1000000.0;
00088         double speed = kib_rw / test_time_sec;
00089         printf("%d KiB write in %.3f sec with speed of %.4f KiB/s\r\n", byte_write, test_time_sec, speed);
00090         notify_performance_coefficient("write_kibps", speed);
00091     } else {
00092         printf("File '%s' not opened\r\n", filename);
00093         result = false;
00094     }
00095     timer.reset();
00096     return result;
00097 }
00098 
00099 bool test_sf_file_read_fatfs(const char *filename, const int kib_rw) {
00100     FIL file;
00101     bool result = true;
00102     FRESULT res = f_open(&file, filename, FA_READ | FA_OPEN_EXISTING);
00103     if (res == FR_OK) {
00104         timer.start();
00105         int byte_read = 0;
00106         unsigned int bytes = 0;
00107         do {
00108             res = f_read(&file, buffer, sizeof(buffer), &bytes);
00109             byte_read++;
00110         } while (res == FR_OK && bytes == sizeof(buffer));
00111         timer.stop();
00112         f_close(&file);
00113         double test_time_sec = timer.read_us() / 1000000.0;
00114         double speed = kib_rw / test_time_sec;
00115         printf("%d KiB read in %.3f sec with speed of %.4f KiB/s\r\n", byte_read, test_time_sec, speed);
00116         notify_performance_coefficient("fs_read_kibps", speed);
00117     } else {
00118         printf("File '%s' not opened\r\n", filename);
00119         result = false;
00120     }
00121     timer.reset();
00122     return result;
00123 }
00124 
00125 char RandomChar() {
00126     return rand() % 100;
00127 }
00128 
00129 int main() {
00130     MBED_HOSTTEST_TIMEOUT(15);
00131     MBED_HOSTTEST_SELECT(default_auto);
00132     MBED_HOSTTEST_DESCRIPTION(SD FatFS RW Speed);
00133     MBED_HOSTTEST_START("PERF_3");
00134 
00135     // Test header
00136     printf("\r\n");
00137     printf("SD Card FatFS Performance Test\r\n");
00138     printf("File name: %s\r\n", bin_filename);
00139     printf("Buffer size: %d KiB\r\n", (KIB_RW * sizeof(buffer)) / 1024);
00140 
00141     // Initialize buffer
00142     srand(testenv_randseed());
00143     char *buffer_end = buffer + sizeof(buffer);
00144     std::generate (buffer, buffer_end, RandomChar);
00145 
00146     bool result = true;
00147     for (;;) {
00148         printf("Write test...\r\n");
00149         if (test_sf_file_write_fatfs(bin_filename, KIB_RW) == false) {
00150             result = false;
00151             break;
00152         }
00153 
00154         printf("Read test...\r\n");
00155         if (test_sf_file_read_fatfs(bin_filename, KIB_RW) == false) {
00156             result = false;
00157             break;
00158         }
00159         break;
00160     }
00161     MBED_HOSTTEST_RESULT(result);
00162 }