main.cpp

00001 #include "mbed.h"
00002 #include "stm32746g_discovery_sd.h"
00003 
00004 #define BLOCK_START_ADDR         0     /* Block start address      */
00005 #define NUM_OF_BLOCKS            5     /* Total number of blocks   */
00006 #define BUFFER_WORDS_SIZE        ((BLOCKSIZE * NUM_OF_BLOCKS) >> 2) /* Total data size in bytes */
00007 
00008 uint32_t aTxBuffer[BUFFER_WORDS_SIZE];
00009 uint32_t aRxBuffer[BUFFER_WORDS_SIZE];
00010 
00011 /* Private function prototypes -----------------------------------------------*/
00012 void SD_main_test(void);
00013 void SD_Detection(void);
00014 
00015 static void Fill_Buffer(uint32_t *pBuffer, uint32_t uwBufferLenght, uint32_t uwOffset);
00016 static uint8_t Buffercmp(uint32_t *pBuffer1, uint32_t *pBuffer2, uint16_t BufferLength);
00017 
00018 int main()
00019 {
00020     uint8_t SD_state = MSD_OK;
00021     static uint8_t prev_status = SD_PRESENT;
00022 
00023     printf("\n\nSD example start:\n");
00024 
00025     SD_state = BSP_SD_Init();
00026     if (SD_state != MSD_OK) {
00027         if (SD_state == MSD_ERROR_SD_NOT_PRESENT) {
00028             printf("SD shall be inserted before running test\n");
00029         } else {
00030             printf("SD Initialization : FAIL.\n");
00031         }
00032         printf("SD Test Aborted.\n");
00033     } else {
00034         printf("SD Initialization : OK.\n");
00035 
00036         SD_state = BSP_SD_Erase(BLOCK_START_ADDR, (BLOCK_START_ADDR + NUM_OF_BLOCKS - 1));
00037 
00038         /* Wait until SD card is ready to use for new operation */
00039         while (BSP_SD_GetCardState() != SD_TRANSFER_OK) {
00040         }
00041         if (SD_state != MSD_OK) {
00042             printf("SD ERASE : FAILED.\n");
00043             printf("SD Test Aborted.\n");
00044         } else {
00045             printf("SD ERASE : OK.\n");
00046 
00047             /* Fill the buffer to write */
00048             Fill_Buffer(aTxBuffer, BUFFER_WORDS_SIZE, 0x2300);
00049 
00050             SD_state = BSP_SD_WriteBlocks(aTxBuffer, BLOCK_START_ADDR, NUM_OF_BLOCKS, 10000);
00051             /* Wait until SD card is ready to use for new operation */
00052             while (BSP_SD_GetCardState() != SD_TRANSFER_OK) {
00053             }
00054 
00055             if (SD_state != MSD_OK) {
00056                 printf("SD WRITE : FAILED.\n");
00057                 printf("SD Test Aborted.\n");
00058             } else {
00059                 printf("SD WRITE : OK.\n");
00060 
00061                 SD_state = BSP_SD_ReadBlocks(aRxBuffer, BLOCK_START_ADDR, NUM_OF_BLOCKS, 10000);
00062                 /* Wait until SD card is ready to use for new operation */
00063                 while (BSP_SD_GetCardState() != SD_TRANSFER_OK) {
00064                 }
00065 
00066                 if (SD_state != MSD_OK) {
00067                     printf("SD READ : FAILED.\n");
00068                     printf("SD Test Aborted.\n");
00069                 } else {
00070                     printf("SD READ : OK.\n");
00071                     if (Buffercmp(aTxBuffer, aRxBuffer, BUFFER_WORDS_SIZE) > 0) {
00072                         printf("SD COMPARE : FAILED.\n");
00073                         printf("SD Test Aborted.\n");
00074                     } else {
00075                         printf("SD Test : OK.\n");
00076                         printf("SD can be removed.\n");
00077                     }
00078                 }
00079             }
00080         }
00081     }
00082 
00083     while (1) {
00084         if (BSP_SD_IsDetected() != SD_PRESENT) {
00085             if (prev_status != SD_NOT_PRESENT) {
00086                 BSP_SD_Init();
00087                 prev_status = SD_NOT_PRESENT;
00088                 printf("SD removed\n");
00089             }
00090         } else if (prev_status != SD_PRESENT) {
00091             printf("SD detected\n");
00092             prev_status = SD_PRESENT;
00093         }
00094     }
00095 }
00096 
00097 /**
00098   * @brief  Fills buffer with user predefined data.
00099   * @param  pBuffer: pointer on the buffer to fill
00100   * @param  uwBufferLenght: size of the buffer to fill
00101   * @param  uwOffset: first value to fill on the buffer
00102   * @retval None
00103   */
00104 static void Fill_Buffer(uint32_t *pBuffer, uint32_t uwBufferLength, uint32_t uwOffset)
00105 {
00106     uint32_t tmpIndex = 0;
00107 
00108     /* Put in global buffer different values */
00109     for (tmpIndex = 0; tmpIndex < uwBufferLength; tmpIndex++) {
00110         pBuffer[tmpIndex] = tmpIndex + uwOffset;
00111     }
00112 }
00113 
00114 /**
00115   * @brief  Compares two buffers.
00116   * @param  pBuffer1, pBuffer2: buffers to be compared.
00117   * @param  BufferLength: buffer's length
00118   * @retval 1: pBuffer identical to pBuffer1
00119   *         0: pBuffer differs from pBuffer1
00120   */
00121 static uint8_t Buffercmp(uint32_t *pBuffer1, uint32_t *pBuffer2, uint16_t BufferLength)
00122 {
00123     while (BufferLength--) {
00124         if (*pBuffer1 != *pBuffer2) {
00125             return 1;
00126         }
00127 
00128         pBuffer1++;
00129         pBuffer2++;
00130     }
00131 
00132     return 0;
00133 }
00134