// function-thread (task), that serves requests from DMA1 iterrupt
//==============================================================================
void vSDTask( void* pvParameters )
{
S_Sd_Param_t message;
int state = 0; // sd card is off
while( 1 )
{
// waiting for messages from ISR or another sources
xQueueReceive( queu_to_sd, ( void* )&message, portMAX_DELAY );
switch( message.type )
{
case SD_EVENT:
{
if( state ) // if sd card is on
{
state = 0;
close_file();
de_init_TIM5();
//write_file(); //write close time
lock_send_message_to_sd_thread = 1; // disallow to send message from DMA 1 ch1 ISR to sd_thread
}
else // if sd card is off
{
if( init_sd() ) // if init of sd card is failed
{
de_init_TIM5();
break;
}
state = 1;
open_file();
//write_file(); //write open time
lock_send_message_to_sd_thread = 0; // allow to send message from DMA 1 ch1 ISR to sd_thread
}
}
break;
case SD_WRITE:
{
write_file( message.data, message.num );
}
break;
default: break;
}
} // while( 1 )
// destroy task, if exit from while was occured
vTaskDelete( NULL );
}
void init_qubit_ctx()
{
#ifdef LUFFA_SSE2_BROKEN
sph_luffa512_init(&qubit_ctx.luffa);
#else
init_luffa(&qubit_ctx.luffa,512);
#endif
cubehashInit(&qubit_ctx.cubehash,512,16,32);
sph_shavite512_init(&qubit_ctx.shavite);
init_sd(&qubit_ctx.simd,512);
#ifdef NO_AES_NI
sph_echo512_init(&qubit_ctx.echo);
#else
init_echo(&qubit_ctx.echo, 512);
#endif
};
void init_x14_ctx()
{
#ifdef NO_AES_NI
sph_groestl512_init(&x14_ctx.groestl);
sph_echo512_init(&x14_ctx.echo);
#else
init_echo(&x14_ctx.echo, 512);
init_groestl(&x14_ctx.groestl);
#endif
init_luffa(&x14_ctx.luffa,512);
cubehashInit(&x14_ctx.cubehash,512,16,32);
sph_shavite512_init(&x14_ctx.shavite);
init_sd(&x14_ctx.simd,512);
sph_hamsi512_init(&x14_ctx.hamsi);
sph_fugue512_init(&x14_ctx.fugue);
sph_shabal512_init(&x14_ctx.shabal);
};
void init_Xhash_contexts(){
//---luffa---
init_luffa(&base_contexts.luffa,512);
//--ch sse2---
cubehashInit(&base_contexts.cubehash,512,16,32);
//-------
sph_shavite512_init(&base_contexts.shavite1);
//---echo sphlib or AESNI-----------
#ifdef AES_NI
init_echo(&base_contexts.echo1, 512);
#else
sph_echo512_init(&base_contexts.echo1);
#endif
//---local simd var ---
init_sd(&base_contexts.ctx_simd1,512);
}
/*
* sd_write : writes to a file from a loaded sd card
*
* @args sd_file : file name and content to be written
*/
void sd_write( struct sd_file *sd )
{
if ( SD_CONNECTED == 0 ) {
init_sd();
}
// file handle for file to be written
short int fh;
if ( alt_up_sd_card_is_Present() && alt_up_sd_card_is_FAT16() ) {
fh = alt_up_sd_card_fopen( sd->name, false );
if (fh == -1) {
fh = alt_up_sd_card_fopen( sd->name, true );
}
if ( fh != -1 ) {
SD_OPEN = 1;
// write sd_file to sd card
int i = 0;
int length = strlen( sd->data );
for ( i = 0; i < length; i ++ ) {
if ( alt_up_sd_card_write( fh, sd->data[i] ) == false ) {
printf( "ERROR! failure during write to %s. Failure @ char #%d of %d\n", sd->name, i, length );
SD_ERROR = 1;
return;
}
}
// close file handle
alt_up_sd_card_fclose( fh );
SD_ERROR = 0;
SD_OPEN = 1;
printf( "SUCCESS! File written: %s\n", sd->name );
} else {
printf( "ERROR! could not write the file: %s\n", sd->name );
SD_ERROR = 1;
}
} else {
printf( "ERROR! SD card is either not present or is not FAT 16\n" );
SD_ERROR = 1;
}
}
/*
* sd_read : reads in a file from a loaded sd card
*
* @args file_name : file name relative to sd root folder
*/
char * sd_read( char *file_name )
{
if ( SD_CONNECTED == 0 ) {
init_sd();
}
// file handle for file being read
short int fh;
if ( alt_up_sd_card_is_Present() && alt_up_sd_card_is_FAT16() ) {
fh = alt_up_sd_card_fopen( file_name, false );
if (fh != -1) {
SD_OPEN = 1;
unsigned char *reading; // data read
char current; // current char read
int index = 0; // current position in file
// read in all chars
while ( ( current = alt_up_sd_card_read( fh ) ) >= 0 ) {
reading[ index ] = malloc(1);
reading[ index ] = current;
++index;
}
// close file handle
alt_up_sd_card_fclose( fh );
// print out file contents
return reading;
} else {
printf( "ERROR! can't open file: %s\n", file_name );
SD_ERROR = 1;
return "";
}
} else {
printf( "ERROR! SD card is either not present or is not FAT 16\n" );
SD_ERROR = 1;
return "";
}
}
void mmcsd_detect(void *param)
{
struct rt_mmcsd_host *host;
rt_uint32_t ocr;
rt_int32_t err;
while (1)
{
if (rt_mb_recv(&mmcsd_detect_mb, (rt_uint32_t*)&host, RT_WAITING_FOREVER) == RT_EOK)
{
if (host->card == RT_NULL)
{
mmcsd_host_lock(host);
mmcsd_power_up(host);
mmcsd_go_idle(host);
mmcsd_send_if_cond(host, host->valid_ocr);
err = sdio_io_send_op_cond(host, 0, &ocr);
if (!err) {
if (init_sdio(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
continue;
}
/*
* detect SD card
*/
err = mmcsd_send_app_op_cond(host, 0, &ocr);
if (!err)
{
if (init_sd(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
continue;
}
mmcsd_host_unlock(host);
}
}
}
}
/*----------------------------------------------------------------------------*/
u8 device_init(void)
{
u8 sector_sizeof512 = 1;
device_check();
if (device_active & device_online) ///<当前需要活动的设备在线
{
disp_port(MENU_SCAN_DISK);
stop_decode();
// deg_str("device init\n");
fs_fun_init();
if ((device_active & (~VIRTUAL_DEVICE)) == DEVICE_SDMMC0)
{
if (init_sd()) ///<sd 卡鉴定
{
f_init(win_buffer, (u16)sdmmc_read, 1);//get_usb_device_pkt_size()); ///<鉴定成功后 初始化文件系统参数
}
else
{
return 0xff; ///<鉴定失败
}
}
else if ((device_active & (~VIRTUAL_DEVICE)) == DEVICE_UDISK)
{
if (usb_host_emuerate_devcie(win_buffer)) ///<USB MASS STORAGE 枚举
{
sector_sizeof512 = get_usb_device_pkt_size();
f_init(win_buffer, (u16)read_usb, sector_sizeof512); ///<枚举成功后 初始化文件系统参数
}
else
{
return 0xff; ///<枚举失败
}
}
}
else
{
return 0xff;
}
// deg_str("fat init\n");
//if (!f_mount()) ///<文件系统初始化
if (!f_mount_bsp(sector_sizeof512))
{
if((RECODE_INIT == encode_status))
{
if(0 == f_write_init(device_active & (~VIRTUAL_DEVICE))) //初始化写设备的数据
{
return 0xfd;
}
else
{
return 0;
}
}
fs_ext_setting(file_type);
{
u16 break_point;
//get_rec_mem_info();
if ((device_active & (~VIRTUAL_DEVICE)) == DEVICE_SDMMC0)
{
//break_point = disk_mus_point[0 + encode_cnt].id0;
break_point = read_info(MEM_SD_PLAYPOINT_ID0);
break_point=break_point<<8;
break_point |= read_info(MEM_SD_PLAYPOINT_ID0+1);
}
else if ((device_active & (~VIRTUAL_DEVICE) ) == DEVICE_UDISK)
{
// break_point = disk_mus_point[1 + encode_cnt].id0;
break_point = read_info(MEM_USB_PLAYPOINT_ID0);
break_point=break_point<<8;
break_point |= read_info(MEM_USB_PLAYPOINT_ID0+1);
}
break_point_filenum = fs_scan_disk(break_point);
encode_fristfile = fs_msg_rec.firstfilenum; //录音文件总数
encode_filenum = fs_msg_rec.fileTotalInDir; //录音文件夹的第一个文件号
//if (break_point_filenum)
{
//break_point_filenum = filenum_phy_logic(break_point_filenum);
}
}
#if VIRTUAL_ENABLE
logic_fileTotal = fs_msg.fileTotal - encode_filenum; ///音乐文件总数
if(device_active & VIRTUAL_DEVICE)
{
logic_fileTotal = encode_filenum; //录音文件总数
}
#else
logic_fileTotal = fs_msg.fileTotal;
#endif
if(0 == logic_fileTotal)//if (fs_msg.fileTotal == 0)
{
return 0xfe;
}
return 0;
}
else
{
return 0xff; //无有效设备
}
}
int main()
{
arr = (unsigned int**)malloc(4377 * sizeof(unsigned int));
psController ps;
int velocity = 0;
int angle = 0;
long ii = 0;
int** collisionMatrix;
int ee;
int numfiles;
char * filenames[MAXFILES];
//init_VGA_Pixel();
initVGA(); //pixel
init_VGA_Char();
av_config_setup();
numfiles = init_sd(filenames);
init_wav(arr);
printf("timing audio\n");
//time_of_sound = time_audio(arr);
printf("looping audio\n");
audio_isr_k = 0;
alt_irq_register(AUDIO_IRQ, NULL, &audio_isr);
alt_up_audio_enable_write_interrupt(audio);
//====INITIALIZE AND DRAW TERRAIN USING BMP ===========================//
short int fd;
terrain background;
fd = alt_up_sd_card_fopen("bg.bmp", false);
initTerrain(fd, &background);
drawBackground(background);
alt_up_sd_card_fclose(fd);
terrain terrain;
fd = alt_up_sd_card_fopen("tr.bmp", false);
initTerrain(fd, &terrain);
drawTerrain(terrain);
alt_up_sd_card_fclose(fd);
//====INITIALIZE AND DRAW USER TANK USING BMP ===========================//
fd = alt_up_sd_card_fopen("tank.bmp", false);
tank user;
initUserTank(&user, fd);
drawTank(&user, background);
alt_up_sd_card_fclose(fd);
//====INITIALIZE AND DRAW ENEMY TANK USING BMP ===========================//
tank enemy;
fd = alt_up_sd_card_fopen("tk.bmp", false);
initEnemyTank1(&enemy, fd);
drawTank(&enemy,background);
alt_up_sd_card_fclose(fd);
//====SWAP BUFFERS =======================================================//
updateVGA();
drawBackground(background);
drawTerrain(terrain);
drawTank(&enemy, background);
for(ee=0;ee < 20;ee++)
{
moveTank(&user, RIGHT, 1);
drawTank(&user,background);
updateVGA();
drawTank(&user,background);
//delay();
}
//for(ii = 0; ii < 300000; ii++);
collisionMatrix = init_CollisionMatrix(XMAXSCREEN_RESOLUTION + 1, XMAXSCREEN_RESOLUTION + 1);
//alt_up_pixel_buffer_dma_draw_box(pixel_buffer, 0, 120, 340, 240, 0x7E0 , 0); //draw terrain
set_CollisionAtRectArea(collisionMatrix, 0 , 0, 340, 240, EMPTY);
set_CollisionAtRectArea(collisionMatrix, 0 , 161, 340, 240, TERRAIN_COLOR);//set the rectangular area drawn by terrain to filled with terrain
while(1){
//angle = 0;
velocity = 0;
set_UserTank(&angle, &velocity, ps, &user, &enemy, background); //reads controller to set angle, power, and shoot
shoot_Missile(angle, velocity,( user.x + user.t_VGA.width) - 1 , (240 - user.y + user.t_VGA.height) - 7, collisionMatrix, background);
}
clean_audio(arr);
return 0;
}
// main init function executed 1 time only at boot
void setup(){
init_pins();
init_sd();
load_os_msgs_from_sd();
load_drugs_from_sd();
}
/*----------------------------------------------------------------------------*/
u8 device_init(void)
{
usb_sd_dev_toc=0;
device_online = get_device_online_status();
if(playpoint_time.last_device != device_active)
{
write_playtime(&playpoint_time);
}
if (device_active & device_online) ///<当前需要活动的设备在线
{
flush_all_msg(); ///<清空全部消息
stop_decode(); ///<停止解码
#if FILE_ENCRYPTION
password_start(0);
#endif
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
if (device_active == BIT(USB_DISK))
{
if (usb_host_emuerate_devcie(win_buffer)) ///<USB MASS STORAGE 枚举
{
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
f_init(win_buffer, (u16)usb_otp_read, get_usb_device_pkt_size()); ///<枚举成功后 初始化文件系统参数
}
else
{
return 0xff; ///<枚举失败
}
}
else if (device_active == BIT(SDMMC))
{
if (init_sd()) ///<sd 卡鉴定
{
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
f_init(win_buffer, (u16)sdmmc_otp_read, 1);//get_usb_device_pkt_size()); ///<鉴定成功后 初始化文件系统参数
}
else
{
return 0xff; ///<鉴定失败
}
}
}
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
if (!f_mount()) ///<文件系统初始化
{
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
fs_ext_setting(file_type);
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
set_playpoint_info(read_playpoint_info(device_active));
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
fs_scan_disk();
#ifdef SYS_GPIO_SEL_FUNC
if( gpio_sel_func){
return 0xff;
}
#endif
playpoint_filenum = get_scan_filenumber(); //根据对应设备的起始簇找出有断点的文件号
/**/
usb_sd_dev_toc=1;
#ifdef DISABLE_USB_SD_BP_PLAY
playpoint_filenum=0;
#endif
if(0 == playpoint_filenum)
{
if(given_file_number)
given_file_number = 1;
}
if (fs_msg.fileTotal == 0)
{
return 0xfe;
}
#if ((USE_DEVICE == MEMORY_STYLE)&&(FAT_MEMORY))
check_reserve_sector(device_active);
#endif
return 0;
}
else
{
//无有效设备
return 0xff;
}
}
/*
* 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();
/*
* Activates the serial driver 2 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD6, NULL);
BaseSequentialStream *chp = (BaseSequentialStream *)&SD6;
chprintf(chp, "running main()\r\n");
chThdSleepMilliseconds(50);
#if STM32_USB_USE_OTG2
USBDriver *usb_driver = &USBD2;
#else
USBDriver *usb_driver = &USBD1;
#endif
/*
* Activates the card insertion monitor.
*/
init_sd();
chprintf(chp, "done starting SDC\r\n");
const bool_t sdcConnectStatus = sdcConnect(&SDCD1);
if( sdcConnectStatus != CH_SUCCESS ) {
chprintf(chp, "failed to connect to SD Card, sdcConnectStatus = %u\r\n", sdcConnectStatus);
for(;;) {
chThdSleepMilliseconds(3000);
}
}
chprintf(chp, "setting up MSD\r\n");
const usb_msd_driver_state_t msd_driver_state = msdInit(usb_driver, (BaseBlockDevice*)&SDCD1, &UMSD1, USB_MS_DATA_EP, USB_MSD_INTERFACE_NUMBER);
if( msd_driver_state != USB_MSD_DRIVER_OK ) {
chprintf(chp, "Error initing USB MSD, %d %s\r\n", msd_driver_state, usb_msd_driver_state_t_to_str(msd_driver_state));
}
UMSD1.chp = chp;
chprintf(chp, "Initializing SDU1...\r\n");
serusbcfg.usbp = usb_driver;
sduObjectInit(&SDU1);
/*Disconnect the USB Bus*/
usbDisconnectBus(usb_driver);
chThdSleepMilliseconds(200);
/*Start the useful functions*/
sduStart(&SDU1, &serusbcfg);
msdStart(&UMSD1);
usbStart(usb_driver, &msd_usb_config);
/*Connect the USB Bus*/
usbConnectBus(usb_driver);
/*
* Creates the blinker thread.
*/
chprintf(chp, "starting blinker thread\r\n");
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
while (TRUE) {
palTogglePad(GPIOC, GPIOC_LED);
chThdSleepMilliseconds(500);
}
}
int gpt_find_boot_partition(uint8_t* dest, uint32_t size)
{
int ret = init_sd();
if (ret != 0) {
print_uart("could not initialize sd... exiting\r\n");
return -1;
}
print_uart("sd initialized!\r\n");
// load LBA1
size_t block_size = 512;
uint8_t lba1_buf[block_size];
int res = sd_copy(lba1_buf, 1, 1);
if (res != 0)
{
print_uart("SD card failed!\r\n");
print_uart("sd copy return value: ");
print_uart_addr(res);
print_uart("\r\n");
return -2;
}
gpt_pth_t *lba1 = (gpt_pth_t *)lba1_buf;
print_uart("gpt partition table header:");
print_uart("\r\n\tsignature:\t");
print_uart_addr(lba1->signature);
print_uart("\r\n\trevision:\t");
print_uart_int(lba1->revision);
print_uart("\r\n\tsize:\t\t");
print_uart_int(lba1->header_size);
print_uart("\r\n\tcrc_header:\t");
print_uart_int(lba1->crc_header);
print_uart("\r\n\treserved:\t");
print_uart_int(lba1->reserved);
print_uart("\r\n\tcurrent lba:\t");
print_uart_addr(lba1->current_lba);
print_uart("\r\n\tbackup lda:\t");
print_uart_addr(lba1->backup_lba);
print_uart("\r\n\tpartition entries lba: \t");
print_uart_addr(lba1->partition_entries_lba);
print_uart("\r\n\tnumber partition entries:\t");
print_uart_int(lba1->nr_partition_entries);
print_uart("\r\n\tsize partition entries: \t");
print_uart_int(lba1->size_partition_entry);
print_uart("\r\n");
uint8_t lba2_buf[block_size];
res = sd_copy(lba2_buf, lba1->partition_entries_lba, 1);
if (res != 0)
{
print_uart("SD card failed!\r\n");
print_uart("sd copy return value: ");
print_uart_addr(res);
print_uart("\r\n");
return -2;
}
for (int i = 0; i < 4; i++)
{
partition_entries_t *part_entry = (partition_entries_t *)(lba2_buf + (i * 128));
print_uart("gpt partition entry ");
print_uart_byte(i);
print_uart("\r\n\tpartition type guid:\t");
for (int j = 0; j < 16; j++)
print_uart_byte(part_entry->partition_type_guid[j]);
print_uart("\r\n\tpartition guid: \t");
for (int j = 0; j < 16; j++)
print_uart_byte(part_entry->partition_guid[j]);
print_uart("\r\n\tfirst lba:\t");
print_uart_addr(part_entry->first_lba);
print_uart("\r\n\tlast lba:\t");
print_uart_addr(part_entry->last_lba);
print_uart("\r\n\tattributes:\t");
print_uart_addr(part_entry->attributes);
print_uart("\r\n\tname:\t");
for (int j = 0; j < 72; j++)
print_uart_byte(part_entry->name[j]);
print_uart("\r\n");
}
partition_entries_t *boot = (partition_entries_t *)(lba2_buf);
print_uart("copying boot image ");
print_uart("\r\n");
res = sd_copy(dest, boot->first_lba, size);
if (res != 0)
{
print_uart("SD card failed!\r\n");
print_uart("sd copy return value: ");
print_uart_addr(res);
print_uart("\r\n");
return -2;
}
print_uart(" done!\r\n");
return 0;
}
void mmcsd_detect(void *param)
{
struct rt_mmcsd_host *host;
rt_uint32_t ocr;
rt_int32_t err;
while (1)
{
if (rt_mb_recv(&mmcsd_detect_mb, (rt_uint32_t*)&host, RT_WAITING_FOREVER) == RT_EOK)
{
if (host->card == RT_NULL)
{
mmcsd_host_lock(host);
mmcsd_power_up(host);
mmcsd_go_idle(host);
mmcsd_send_if_cond(host, host->valid_ocr);
err = sdio_io_send_op_cond(host, 0, &ocr);
if (!err)
{
if (init_sdio(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
continue;
}
/*
* detect SD card
*/
err = mmcsd_send_app_op_cond(host, 0, &ocr);
if (!err)
{
if (init_sd(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
continue;
}
/*
* detect mmc card
*/
err = mmc_send_op_cond(host, 0, &ocr);
if (!err)
{
if (init_mmc(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
continue;
}
mmcsd_host_unlock(host);
}
else
{
/* card removed */
mmcsd_host_lock(host);
if (host->card->sdio_function_num != 0)
{
rt_kprintf("unsupport sdio card plug out!\n");
}
else
{
rt_mmcsd_blk_remove(host->card);
rt_free(host->card);
host->card = RT_NULL;
}
mmcsd_host_unlock(host);
}
}
}
}
