/*******************************************************************************
* 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;
}
}
}
