/******************************************************************************* * Function Name : MAL_Init * Description : Initializes the Media on the STM32 * Input : None * Output : None * Return : None *******************************************************************************/ uint16_t MAL_Init(uint8_t lun) { uint16_t status = MAL_OK; switch (lun) { case 0: #ifdef USE_STM3210E_EVAL Status = SD_Init(); Status = SD_GetCardInfo(&SDCardInfo); Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16)); Status = SD_EnableWideBusOperation(SDIO_BusWide_4b); Status = SD_SetDeviceMode(SD_DMA_MODE); #else MSD_Init(); #endif break; #ifdef USE_FSMC_NAND case 1: status = NAND_Init(); break; #endif default: return MAL_FAIL; } return status; }
/******************************************************************************* * Function Name : MAL_Init * Description : Initializes the Media on the STM32 * Input : None * Output : None * Return : None *******************************************************************************/ uint16_t MAL_Init(uint8_t lun) { uint16_t status = MAL_OK; switch (lun) { case 0: #ifdef USE_STM3210E_EVAL Status = SD_Init(); Status = SD_GetCardInfo(&SDCardInfo); Status = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16)); Status = SD_EnableWideBusOperation(SDIO_BusWide_4b); Status = SD_SetDeviceMode(SD_DMA_MODE); if (Status == SD_OK) { //Status = SD_ReadMultiBlocks(0x00, Buffer_MultiBlock_Rx, BlockSize, NumberOfBlocks1); // printf("\r\nSD SDIO-4bit模式 测试TF卡读写成功! \n "); } if (Status == SD_OK) { // Read block of 512 bytes from address 0 Status = SD_ReadBlock(0x00, Buffer_Block_Rx, BlockSize); } if (Status == SD_OK) { // Check the corectness of written dada printf("\r\nSD SDIO-4bit模式 测试TF卡读写成功! \n "); } #else MSD_Init(); #endif break; #ifdef USE_STM3210E_EVAL case 1: status = NAND_Init(); break; #endif default: return MAL_FAIL; } return status; }
/******************************************************************************* * Function Name : Mass_Storage_Start * Description : Starts the mass storage demo. * Input : None * Output : None * Return : None *******************************************************************************/ void Mass_Storage_Start (void) { /* Disble the JoyStick interrupts */ IntExtOnOffConfig(DISABLE); /* Clear the LCD screen */ LCD_Clear(White); LCD_SetDisplayWindow(160, 223, 128, 128); LCD_DrawBMP(0x00647C00); /* Disable LCD Window mode */ LCD_WindowModeDisable(); /* Set the Back Color */ LCD_SetBackColor(Blue); /* Set the Text Color */ LCD_SetTextColor(White); if(MSD_Init() != 0x00) { LCD_DisplayStringLine(Line8, " No MSD Card Present"); LCD_DisplayStringLine(Line9, " To exit Press SEL "); /* Loop until SEL key pressed */ while(ReadKey() != SEL) { } } else { Get_Medium_Characteristics(); /* Display the " Plug the USB " message */ LCD_DisplayStringLine(Line8, " Plug the USB Cable "); LCD_DisplayStringLine(Line9, "Exit: Push JoyStick"); /* Intialize the USB cell */ USB_Init(); LCD_ClearLine(Line9); /* Display the "To stop Press SEL" message */ LCD_DisplayStringLine(Line8, " To stop Press SEL "); /* Loop until SEL key pressed */ while(ReadKey() != SEL) { } PowerOff(); } LCD_Clear(White); DisplayMenu(); IntExtOnOffConfig(ENABLE); /* Flush SPI1 Data Register */ SPI_I2S_ReceiveData(SPI1); }
void Mass_Storage_Device_Task(void) { /* task setup */ (void)MSD_Init(); /* Initialize the USB Test Application */ while(1) { /* Call the application task */ MSD_Task(); } }
///////////////////////////////////////////////////////////////////////////// // This task is called periodically each mS when USB MSD access is enabled ///////////////////////////////////////////////////////////////////////////// static void TASK_MSD(void *pvParameters) { u8 lun_available = 0; while( 1 ) { // using vTaskDelay instead of vTaskDelayUntil, since a periodical execution // isn't required, and this task could be invoked too often if it was blocked // for a long time vTaskDelay(1 / portTICK_RATE_MS); // MSD driver handling if( msd_state != MSD_DISABLED ) { MUTEX_SDCARD_TAKE; switch( msd_state ) { case MSD_SHUTDOWN: // switch back to USB MIDI MIOS32_USB_Init(1); msd_state = MSD_DISABLED; MUTEX_SDCARD_GIVE; vTaskSuspend(NULL); // will be resumed from TASK_MSD_EnableSet() MUTEX_SDCARD_TAKE; break; case MSD_INIT: // LUN not mounted yet lun_available = 0; // enable MSD USB driver if( MSD_Init(0) >= 0 ) msd_state = MSD_READY; else msd_state = MSD_SHUTDOWN; break; case MSD_READY: // service MSD USB driver MSD_Periodic_mS(); // this mechanism shuts down the MSD driver if SD card has been unmounted by OS if( lun_available && !MSD_LUN_AvailableGet(0) ) msd_state = MSD_SHUTDOWN; else if( !lun_available && MSD_LUN_AvailableGet(0) ) lun_available = 1; break; } MUTEX_SDCARD_GIVE; } } }
static void TaskSDCard(void *pvParameters) { uint16_t second_delay_ctr = 0; portTickType xLastExecutionTime; /* Initialise the xLastExecutionTime variable on task entry */ xLastExecutionTime = xTaskGetTickCount(); for(;;) { vTaskDelayUntil(&xLastExecutionTime, 1 / portTICK_RATE_MS); /* Each second: */ /* Check if SD card is available */ /* High-speed access if SD card was previously available */ if(++second_delay_ctr >= 1000) { second_delay_ctr = 0; uint8_t prev_sdcard_available = sdcard_available; sdcard_available = PIOS_SDCARD_CheckAvailable(prev_sdcard_available); if(sdcard_available && !prev_sdcard_available) { /* SD Card has been connected! */ /* Switch to mass storage device */ MSD_Init(0); } else if(!sdcard_available && prev_sdcard_available) { /* Re-init USB for HID */ PIOS_USB_Init(1); /* SD Card disconnected! */ } } /* Each millisecond: */ /* Handle USB access if device is available */ if(sdcard_available) { MSD_Periodic_mS(); } } }
DSTATUS disk_initialize ( BYTE drv /* Physical drive nmuber (0..) */ ) { int Status; switch (drv) { case 0 : Status = MSD_Init(); if(Status == 0) return 0; else return STA_NOINIT; case 1 : return STA_NOINIT; case 2 : return STA_NOINIT; } return STA_NOINIT; }
int main(void) { int flag; int i; //only for sd testing extern u8 sd_recv_buf[512]; extern u8 sd_send_buf[512]; u8 ret = 1; // only for sd testing RCC_Configuration(); RTC_Configuration(); GPIO_Configuration(); SPI_Configuration(); NVIC_Configuration(); USART_Configuration(); EXTI_cfg(); //only for sd testing ret = MSD_Init(); ret = MSD_GetMediumCharacteristics(); MSD_EarseBlock(0,Mass_Block_Count); //only for sd testing //system start working GPIO_SetBits(GPIOC,GPIO_Pin_14); //wait for the moment that the device has been fxed into the rocket // for (i=0;i<6*5;i++) {delay();} //delay 10 minutes //self-testing //first, test wireless data transmition Timedisplay=0; while (Timedisplay<10) { USART_SendData(USART3, 'A'); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); if ((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==66)) //except "B" { //static char Responce[]="Wireless data transmition test completed"; for (i=0;i<strlen(Responce);i++) { USART_SendData(USART3, Responce[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } break; } //USART_ClearFlag(USART3, USART_FLAG_RXNE); } if (Timedisplay==10) { GPIO_ResetBits(GPIOC,GPIO_Pin_14); //Write into SD:ERROR in data transmition //only for testing for (i=0;i<strlen(errorDatatransmition);i++) { sd_send_buf[i]=errorDatatransmition[i]; } ret = MSD_WriteBlock(sd_send_buf,0,512); //only for testing return(0); } //waiting for the continue order for (i=0;i<4000;i++); while (1) { if ((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==78)) //except "N" { break; } //USART_ClearFlag(USART3, USART_FLAG_RXNE); } //second,test GPS Timedisplay=0; flag=1; while ((Timedisplay<60*5) && (!((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==71)))) //except "G" { if ((USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET)) { flag=1; USART_SendData(USART3, USART_ReceiveData(USART1)); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } //USART_ClearFlag(USART1, USART_FLAG_RXNE); } if (flag==0) { GPIO_ResetBits(GPIOC,GPIO_Pin_14); for (i=0;i<strlen(errorGPS);i++) { USART_SendData(USART3, errorGPS[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } //Write into SD:ERROR in GPS for (i=0;i<strlen(errorGPS);i++) { sd_send_buf[i]=errorGPS[i]; } ret = MSD_WriteBlock(sd_send_buf,1,512); return(0); } //static char Responce2[]="GPS test completed"; for (i=0;i<strlen(Responce2);i++) { USART_SendData(USART3, Responce2[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } //waiting for the continue order for (i=0;i<4000;i++); while (1) { if ((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==78)) //except "N" { break; } //USART_ClearFlag(USART3, USART_FLAG_RXNE); } //third, test clock USART_SendData(USART3, 'C'); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); Timedisplay=0; flag=0; while ((Timedisplay<20) && (!((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==69)))); //except "E" if ((abs(Timedisplay-10)>2) && (USART_ReceiveData(USART3)==69)) { GPIO_ResetBits(GPIOC,GPIO_Pin_14); for (i=0;i<strlen(errorclock);i++) { USART_SendData(USART3, errorclock[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } //Write into SD:ERROR in timing //only for testing for (i=0;i<strlen(errorclock);i++) { sd_send_buf[i]=errorclock[i]; } ret = MSD_WriteBlock(sd_send_buf,2,512); //only for testing return(0); } //static char Responce3[]="clock test completed"; for (i=0;i<strlen(Responce3);i++) { USART_SendData(USART3, Responce3[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } //static char Responce4[]="ALL test completed,wait for launching signal"; for (i=0;i<strlen(Responce4);i++) { USART_SendData(USART3, Responce4[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } while (!((USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == SET) && (USART_ReceiveData(USART3)==76))); //except for "L" //delay(); //static char Responce5[]="Go! Good Luck!"; for (i=0;i<strlen(Responce5);i++) { USART_SendData(USART3, Responce5[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } /* Enable the USART Receive interrupt: this interrupt is generated when the USART1 receive data register is not empty */ USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); //USART_ITConfig(USART3, USART_IT_RXNE, ENABLE); Timedisplay=0; while(1) { if (Timedisplay>=OPEN_Parachute) { GPIO_SetBits(GPIOC,GPIO_Pin_6); //static char Responce6[]="The parachute is open@"; for (i=0;i<strlen(Responce6);i++) { USART_SendData(USART3, Responce6[i]); while(USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET); } } } return(0); }
///////////////////////////////////////////////////////////////////////////// //! This task is running endless in background ///////////////////////////////////////////////////////////////////////////// void APP_Background(void) { const u16 sdcard_check_delay = 1000; u16 sdcard_check_ctr = 0; u8 lun_available = 0; static u8 isInMainPage = 1; SCS_DisplayUpdateInMainPage(0); MBNG_LCD_SpecialCharsReInit(); u32 last_timestamp = MIOS32_TIMESTAMP_Get(); while( 1 ) { //vTaskDelay(1 / portTICK_RATE_MS); // Background task: use timestamp mechanism to generate delay while( MIOS32_TIMESTAMP_Get() == last_timestamp ); last_timestamp = MIOS32_TIMESTAMP_Get(); // call SCS handler MUTEX_LCD_TAKE; MIOS32_LCD_FontInit((u8 *)GLCD_FONT_NORMAL); SCS_Tick(); SCS_DisplayUpdateInMainPage((MBNG_EVENT_MidiLearnModeGet() || MBNG_EVENT_EventLearnIdGet()) ? 1 : 0); // LCD output in mainpage if( SCS_MenuStateGet() == SCS_MENU_STATE_MAINPAGE && !MBNG_EVENT_MidiLearnModeGet() && !MBNG_EVENT_EventLearnIdGet() ) { u8 force = isInMainPage == 0; if( force ) { // page change MBNG_LCD_SpecialCharsReInit(); MBNG_LCD_CursorSet(SCS_LCD_DeviceGet(), SCS_LCD_OffsetXGet(), SCS_LCD_OffsetYGet() + 0); MBNG_LCD_PrintSpaces(SCS_NumMenuItemsGet()*SCS_MENU_ITEM_WIDTH); MBNG_LCD_CursorSet(SCS_LCD_DeviceGet(), SCS_LCD_OffsetXGet(), SCS_LCD_OffsetYGet() + 1); MBNG_LCD_PrintSpaces(SCS_NumMenuItemsGet()*SCS_MENU_ITEM_WIDTH); } MBNG_EVENT_UpdateLCD(force); // handles .NGR file execution MBNG_FILE_R_CheckRequest(); isInMainPage = 1; // static reminder } else { if( isInMainPage && (MBNG_EVENT_MidiLearnModeGet() || MBNG_EVENT_EventLearnIdGet()) ) { SCS_LCD_Update(1); // force display update when learn mode is entered in mainpage } isInMainPage = 0; // static reminder } // handles .NGR file execution MBNG_FILE_R_CheckRequest(); MUTEX_LCD_GIVE; // -> keyboard handler KEYBOARD_Periodic_1mS(); // MIDI In/Out monitor MIDI_PORT_Period1mS(); // call MIDI event tick MBNG_EVENT_Tick(); // each second: check if SD Card (still) available if( msd_state == MSD_DISABLED && ++sdcard_check_ctr >= sdcard_check_delay ) { sdcard_check_ctr = 0; MUTEX_SDCARD_TAKE; s32 status = FILE_CheckSDCard(); if( status == 1 ) { DEBUG_MSG("SD Card connected: %s\n", FILE_VolumeLabel()); // stop sequencer SEQ_BPM_Stop(); // load all file infos MBNG_FILE_LoadAllFiles(1); // including HW info // select the first bank MBNG_EVENT_SelectedBankSet(1); // immediately go to next step sdcard_check_ctr = sdcard_check_delay; } else if( status == 2 ) { DEBUG_MSG("SD Card disconnected\n"); // invalidate all file infos MBNG_FILE_UnloadAllFiles(); // stop sequencer SEQ_BPM_Stop(); // change status MBNG_FILE_StatusMsgSet("No SD Card"); MUTEX_LCD_TAKE; MBNG_LCD_CursorSet(0, 0, 0); MBNG_LCD_PrintString("*** No SD Card *** "); MBNG_LCD_ClearScreenOnNextMessage(); MUTEX_LCD_GIVE; } else if( status == 3 ) { if( !FILE_SDCardAvailable() ) { DEBUG_MSG("SD Card not found\n"); MBNG_FILE_StatusMsgSet("No SD Card"); MUTEX_LCD_TAKE; MBNG_LCD_CursorSet(0, 0, 0); MBNG_LCD_PrintString("*** No SD Card *** "); MBNG_LCD_ClearScreenOnNextMessage(); MUTEX_LCD_GIVE; } else if( !FILE_VolumeAvailable() ) { DEBUG_MSG("ERROR: SD Card contains invalid FAT!\n"); MBNG_FILE_StatusMsgSet("No FAT"); MUTEX_LCD_TAKE; MBNG_LCD_CursorSet(0, 0, 0); MBNG_LCD_PrintString("* No FAT on SD Card * "); MBNG_LCD_ClearScreenOnNextMessage(); MUTEX_LCD_GIVE; } else { MBNG_FILE_StatusMsgSet(NULL); // create the default files if they don't exist on SD Card MBNG_FILE_CreateDefaultFiles(); } hw_enabled = 1; // enable hardware after first read... } MUTEX_SDCARD_GIVE; } // MSD driver if( msd_state != MSD_DISABLED ) { MUTEX_SDCARD_TAKE; switch( msd_state ) { case MSD_SHUTDOWN: // switch back to USB MIDI MIOS32_USB_Init(1); msd_state = MSD_DISABLED; break; case MSD_INIT: // LUN not mounted yet lun_available = 0; // enable MSD USB driver MUTEX_J16_TAKE; if( MSD_Init(0) >= 0 ) msd_state = MSD_READY; else msd_state = MSD_SHUTDOWN; MUTEX_J16_GIVE; break; case MSD_READY: // service MSD USB driver MSD_Periodic_mS(); // this mechanism shuts down the MSD driver if SD card has been unmounted by OS if( lun_available && !MSD_LUN_AvailableGet(0) ) msd_state = MSD_SHUTDOWN; else if( !lun_available && MSD_LUN_AvailableGet(0) ) lun_available = 1; break; } MUTEX_SDCARD_GIVE; } } }