From 1b274d996fe0e9e8de4d3c33165617c134b295ca Mon Sep 17 00:00:00 2001 From: "goprife@gmail.com" Date: Thu, 27 Dec 2012 08:26:35 +0000 Subject: [PATCH] format code style with astyle in bsp/simulator git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2535 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- bsp/simulator/applications/platform.c | 6 +- bsp/simulator/applications/startup.c | 62 +-- bsp/simulator/drivers/board.c | 40 +- bsp/simulator/drivers/board.h | 2 +- bsp/simulator/drivers/nanddrv_file.c | 362 +++++++------- bsp/simulator/drivers/sd_sim.c | 166 +++---- bsp/simulator/drivers/sdl_fb.c | 390 +++++++-------- bsp/simulator/drivers/serial.c | 186 +++---- bsp/simulator/drivers/serial.h | 8 +- bsp/simulator/drivers/sst25vfxx_mtd.h | 30 +- bsp/simulator/drivers/sst25vfxx_mtd_sim.c | 156 +++--- bsp/simulator/drivers/usart_sim.c | 134 ++--- bsp/simulator/rtgui_demo/snake/snake.c | 542 ++++++++++----------- bsp/simulator/rtgui_demo/snake/snake.h | 12 +- bsp/simulator/rtgui_demo/snake/snake_gui.c | 50 +- 15 files changed, 1074 insertions(+), 1072 deletions(-) diff --git a/bsp/simulator/applications/platform.c b/bsp/simulator/applications/platform.c index 1f7f0e1a8..375882ff2 100644 --- a/bsp/simulator/applications/platform.c +++ b/bsp/simulator/applications/platform.c @@ -9,11 +9,11 @@ void rt_platform_init(void) #if defined(RT_USING_MTD_NAND) rt_hw_mtd_nand_init(); -#endif +#endif #if defined(RT_USING_MTD_NOR) sst25vfxx_mtd_init("nor", 0, RT_UINT32_MAX); -#endif +#endif #endif /* RT_USING_DFS */ @@ -24,7 +24,7 @@ void rt_platform_init(void) #ifdef WIN32 - rt_thread_idle_sethook(rt_hw_win32_low_cpu); + rt_thread_idle_sethook(rt_hw_win32_low_cpu); #endif rt_thread_delay(50); rt_device_init_all(); diff --git a/bsp/simulator/applications/startup.c b/bsp/simulator/applications/startup.c index 94a39914a..2056d5afb 100644 --- a/bsp/simulator/applications/startup.c +++ b/bsp/simulator/applications/startup.c @@ -26,67 +26,67 @@ extern int rt_application_init(void); #ifdef RT_USING_FINSH extern void finsh_system_init(void); -extern void finsh_set_device(const char* device); +extern void finsh_set_device(const char *device); #endif -extern rt_uint8_t * heap; +extern rt_uint8_t *heap; /** * This function will startup RT-Thread RTOS. */ void rtthread_startup(void) { - /* init board */ - rt_hw_board_init(); + /* init board */ + rt_hw_board_init(); - /* show version */ - rt_show_version(); + /* show version */ + rt_show_version(); - /* init tick */ - rt_system_tick_init(); + /* init tick */ + rt_system_tick_init(); - /* init kernel object */ - rt_system_object_init(); + /* init kernel object */ + rt_system_object_init(); - /* init timer system */ - rt_system_timer_init(); + /* init timer system */ + rt_system_timer_init(); #ifdef RT_USING_HEAP - /* init memory system */ - rt_system_heap_init((void*)heap, (void*)&heap[HEAP_SIZE-1]); + /* init memory system */ + rt_system_heap_init((void *)heap, (void *)&heap[HEAP_SIZE - 1]); #endif - /* init scheduler system */ - rt_system_scheduler_init(); + /* init scheduler system */ + rt_system_scheduler_init(); - /* init all device */ + /* init all device */ #ifdef RT_USING_DEVICE - rt_device_init_all(); + rt_device_init_all(); #endif - /* init application */ - rt_application_init(); + /* init application */ + rt_application_init(); /* init timer thread */ rt_system_timer_thread_init(); - /* init idle thread */ - rt_thread_idle_init(); + /* init idle thread */ + rt_thread_idle_init(); - /* start scheduler */ - rt_system_scheduler_start(); + /* start scheduler */ + rt_system_scheduler_start(); - /* never reach here */ - return ; + /* never reach here */ + return ; } int main(void) { - /* disable interrupt first */ - rt_hw_interrupt_disable(); + /* disable interrupt first */ + rt_hw_interrupt_disable(); - /* startup RT-Thread RTOS */ - rtthread_startup(); + /* startup RT-Thread RTOS */ + rtthread_startup(); - return 0; + return 0; } /*@}*/ diff --git a/bsp/simulator/drivers/board.c b/bsp/simulator/drivers/board.c index 703aa1144..d85f5945f 100644 --- a/bsp/simulator/drivers/board.c +++ b/bsp/simulator/drivers/board.c @@ -21,23 +21,23 @@ /** * @addtogroup simulator on win32 */ -rt_uint8_t * heap; +rt_uint8_t *heap; -rt_uint8_t * rt_hw_sram_init(void) +rt_uint8_t *rt_hw_sram_init(void) { - rt_uint8_t * heap; - heap = malloc(HEAP_SIZE); - if (heap == RT_NULL) - { - rt_kprintf("there is no memory in pc."); - _exit(1); - } - return heap; + rt_uint8_t *heap; + heap = malloc(HEAP_SIZE); + if (heap == RT_NULL) + { + rt_kprintf("there is no memory in pc."); + _exit(1); + } + return heap; } void rt_hw_win32_low_cpu(void) { - Sleep(1000); + Sleep(1000); } #if defined(RT_USING_FINSH) @@ -52,24 +52,24 @@ _CRTIMP void __cdecl abort(void); #include void rt_hw_exit(void) { - rt_kprintf("RT-Thread, bye\n"); - exit(0); + rt_kprintf("RT-Thread, bye\n"); + exit(0); } -FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt-thread); +FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt - thread); #endif /* RT_USING_FINSH */ /** - * This function will initial win32 + * This function will initial win32 */ void rt_hw_board_init() { - /* init system memory */ - heap = rt_hw_sram_init(); + /* init system memory */ + heap = rt_hw_sram_init(); #if defined(RT_USING_CONSOLE) - rt_hw_usart_init(); - rt_hw_serial_init(); - rt_console_set_device(RT_CONSOLE_DEVICE_NAME); + rt_hw_usart_init(); + rt_hw_serial_init(); + rt_console_set_device(RT_CONSOLE_DEVICE_NAME); #endif } /*@}*/ diff --git a/bsp/simulator/drivers/board.h b/bsp/simulator/drivers/board.h index 8fb381347..b84d90f9a 100644 --- a/bsp/simulator/drivers/board.h +++ b/bsp/simulator/drivers/board.h @@ -15,7 +15,7 @@ #ifndef __BOARD_H__ #define __BOARD_H__ void rt_hw_board_init(void); -rt_uint8_t * rt_hw_sram_init(void); +rt_uint8_t *rt_hw_sram_init(void); /* SD Card init function */ void rt_hw_sdcard_init(void); diff --git a/bsp/simulator/drivers/nanddrv_file.c b/bsp/simulator/drivers/nanddrv_file.c index 79edf2e9d..8d6c5b750 100644 --- a/bsp/simulator/drivers/nanddrv_file.c +++ b/bsp/simulator/drivers/nanddrv_file.c @@ -5,38 +5,38 @@ #define NAND_SIM "nand.bin" #if 1 -#define OOB_SIZE 64 -#define PAGE_SIZE (2048 + 64) -#define PAGE_PER_BLOCK 64 -#define BLOCK_SIZE (PAGE_SIZE * PAGE_PER_BLOCK) -#define BLOCK_NUM 512 -// #define BLOCK_NUM 2048 +#define OOB_SIZE 64 +#define PAGE_SIZE (2048 + 64) +#define PAGE_PER_BLOCK 64 +#define BLOCK_SIZE (PAGE_SIZE * PAGE_PER_BLOCK) +#define BLOCK_NUM 512 +// #define BLOCK_NUM 2048 #else -#define OOB_SIZE 16 -#define PAGE_SIZE (512 + OOB_SIZE) -#define PAGE_PER_BLOCK 32 -#define BLOCK_SIZE (PAGE_SIZE * PAGE_PER_BLOCK) -#define BLOCK_NUM 512 +#define OOB_SIZE 16 +#define PAGE_SIZE (512 + OOB_SIZE) +#define PAGE_PER_BLOCK 32 +#define BLOCK_SIZE (PAGE_SIZE * PAGE_PER_BLOCK) +#define BLOCK_NUM 512 #endif static unsigned char block_data[BLOCK_SIZE]; static struct rt_mtd_nand_device _nanddrv_file_device; -static FILE* file = NULL; +static FILE *file = NULL; static rt_uint8_t CountBitsInByte(rt_uint8_t byte) { - rt_uint8_t count = 0; + rt_uint8_t count = 0; - while (byte > 0) - { - if (byte & 1) - { - count++; - } - byte >>= 1; - } + while (byte > 0) + { + if (byte & 1) + { + count++; + } + byte >>= 1; + } - return count; + return count; } static void Compute256(const rt_uint8_t *data, rt_uint8_t *code) @@ -50,7 +50,7 @@ static void Compute256(const rt_uint8_t *data, rt_uint8_t *code) // Xor all bytes together to get the column sum; // At the same time, calculate the even and odd line codes - for (i=0; i < 256; i++) + for (i = 0; i < 256; i++) { columnSum ^= data[i]; @@ -93,7 +93,7 @@ static void Compute256(const rt_uint8_t *data, rt_uint8_t *code) // At this point, we have the line parities, and the column sum. First, We // must caculate the parity group values on the column sum. - for (i=0; i < 8; i++) + for (i = 0; i < 8; i++) { if (columnSum & 1) { @@ -113,7 +113,7 @@ static void Compute256(const rt_uint8_t *data, rt_uint8_t *code) code[1] = 0; code[2] = 0; - for (i=0; i < 4; i++) + for (i = 0; i < 4; i++) { code[0] <<= 2; code[1] <<= 2; @@ -164,11 +164,11 @@ static void Compute256(const rt_uint8_t *data, rt_uint8_t *code) code[2] = (~(rt_uint32_t)code[2]); } -void ecc_hamming_compute256x(const rt_uint8_t *pucData, rt_uint32_t dwSize, rt_uint8_t* puCode ) +void ecc_hamming_compute256x(const rt_uint8_t *pucData, rt_uint32_t dwSize, rt_uint8_t *puCode) { - while ( dwSize > 0 ) + while (dwSize > 0) { - Compute256( pucData, puCode ) ; + Compute256(pucData, puCode) ; pucData += 256; puCode += 3; @@ -177,222 +177,222 @@ void ecc_hamming_compute256x(const rt_uint8_t *pucData, rt_uint32_t dwSize, rt_u } /* read chip id */ -static rt_uint32_t nanddrv_file_read_id(struct rt_mtd_nand_device* device) +static rt_uint32_t nanddrv_file_read_id(struct rt_mtd_nand_device *device) { - return 0x00; + return 0x00; } /* read/write/move page */ -static rt_err_t nanddrv_file_read_page(struct rt_mtd_nand_device* device, - rt_off_t page, - rt_uint8_t *data, rt_uint32_t data_len, - rt_uint8_t *spare, rt_uint32_t spare_len) +static rt_err_t nanddrv_file_read_page(struct rt_mtd_nand_device *device, + rt_off_t page, + rt_uint8_t *data, rt_uint32_t data_len, + rt_uint8_t *spare, rt_uint32_t spare_len) { - rt_uint32_t offset; - rt_uint8_t oob_buffer[OOB_SIZE]; - rt_uint8_t oob_ecc [OOB_SIZE]; + rt_uint32_t offset; + rt_uint8_t oob_buffer[OOB_SIZE]; + rt_uint8_t oob_ecc [OOB_SIZE]; - page = page + device->block_start * device->pages_per_block; + page = page + device->block_start * device->pages_per_block; - if (page/device->pages_per_block > device->block_end) - { - return -RT_EIO; - } + if (page / device->pages_per_block > device->block_end) + { + return -RT_EIO; + } - /* write page */ - offset = page * PAGE_SIZE; - if (data != NULL) - { - fseek(file, offset, SEEK_SET); - fread(data, data_len, 1, file); - } + /* write page */ + offset = page * PAGE_SIZE; + if (data != NULL) + { + fseek(file, offset, SEEK_SET); + fread(data, data_len, 1, file); + } - offset = page * PAGE_SIZE + (PAGE_SIZE - OOB_SIZE); - fseek(file, offset, SEEK_SET); - fread(oob_buffer, OOB_SIZE, 1, file); - if (spare != NULL) - { - memcpy(spare, oob_buffer, spare_len); - } + offset = page * PAGE_SIZE + (PAGE_SIZE - OOB_SIZE); + fseek(file, offset, SEEK_SET); + fread(oob_buffer, OOB_SIZE, 1, file); + if (spare != NULL) + { + memcpy(spare, oob_buffer, spare_len); + } - /* verify ECC */ - if (data != RT_NULL) - { - ecc_hamming_compute256x(data, PAGE_SIZE - OOB_SIZE, &oob_ecc[0]); - if (memcmp(&oob_ecc[0], &oob_buffer[0], OOB_SIZE - device->oob_free) != 0) return -RT_MTD_EECC; - } + /* verify ECC */ + if (data != RT_NULL) + { + ecc_hamming_compute256x(data, PAGE_SIZE - OOB_SIZE, &oob_ecc[0]); + if (memcmp(&oob_ecc[0], &oob_buffer[0], OOB_SIZE - device->oob_free) != 0) return -RT_MTD_EECC; + } - return RT_EOK; + return RT_EOK; } -static rt_err_t nanddrv_file_write_page(struct rt_mtd_nand_device* device, - rt_off_t page, - const rt_uint8_t* data, rt_uint32_t data_len, - const rt_uint8_t* oob, rt_uint32_t spare_len) +static rt_err_t nanddrv_file_write_page(struct rt_mtd_nand_device *device, + rt_off_t page, + const rt_uint8_t *data, rt_uint32_t data_len, + const rt_uint8_t *oob, rt_uint32_t spare_len) { - rt_uint32_t offset; - rt_uint8_t oob_buffer[OOB_SIZE]; + rt_uint32_t offset; + rt_uint8_t oob_buffer[OOB_SIZE]; - page = page + device->block_start * device->pages_per_block; - if (page/device->pages_per_block > device->block_end) - { - return -RT_EIO; - } + page = page + device->block_start * device->pages_per_block; + if (page / device->pages_per_block > device->block_end) + { + return -RT_EIO; + } - /* write page */ - offset = page * PAGE_SIZE; - if (data != NULL) - { - fseek(file, offset, SEEK_SET); - fwrite(data, PAGE_SIZE - OOB_SIZE, 1, file); - } + /* write page */ + offset = page * PAGE_SIZE; + if (data != NULL) + { + fseek(file, offset, SEEK_SET); + fwrite(data, PAGE_SIZE - OOB_SIZE, 1, file); + } - offset = page * PAGE_SIZE + (PAGE_SIZE - OOB_SIZE); - fseek(file, offset, SEEK_SET); + offset = page * PAGE_SIZE + (PAGE_SIZE - OOB_SIZE); + fseek(file, offset, SEEK_SET); - memset(oob_buffer, 0xff, sizeof(oob_buffer)); - ecc_hamming_compute256x(data, PAGE_SIZE - OOB_SIZE, &oob_buffer[0]); - if (oob != RT_NULL) - { - memcpy(&oob_buffer[OOB_SIZE - device->oob_free], - &oob[OOB_SIZE - device->oob_free], - device->oob_free); - } - fwrite(oob_buffer, OOB_SIZE, 1, file); + memset(oob_buffer, 0xff, sizeof(oob_buffer)); + ecc_hamming_compute256x(data, PAGE_SIZE - OOB_SIZE, &oob_buffer[0]); + if (oob != RT_NULL) + { + memcpy(&oob_buffer[OOB_SIZE - device->oob_free], + &oob[OOB_SIZE - device->oob_free], + device->oob_free); + } + fwrite(oob_buffer, OOB_SIZE, 1, file); - return RT_EOK; + return RT_EOK; } -static rt_err_t nanddrv_file_move_page(struct rt_mtd_nand_device* device, rt_off_t from, rt_off_t to) +static rt_err_t nanddrv_file_move_page(struct rt_mtd_nand_device *device, rt_off_t from, rt_off_t to) { - rt_uint32_t offset; - rt_uint8_t page_buffer[PAGE_SIZE - OOB_SIZE]; - rt_uint8_t oob_buffer[OOB_SIZE]; + rt_uint32_t offset; + rt_uint8_t page_buffer[PAGE_SIZE - OOB_SIZE]; + rt_uint8_t oob_buffer[OOB_SIZE]; - from = from + device->block_start * device->pages_per_block; - to = to + device->block_start * device->pages_per_block; + from = from + device->block_start * device->pages_per_block; + to = to + device->block_start * device->pages_per_block; - if (from/device->pages_per_block > device->block_end || - to/device->pages_per_block > device->block_end) - { - return -RT_EIO; - } + if (from / device->pages_per_block > device->block_end || + to / device->pages_per_block > device->block_end) + { + return -RT_EIO; + } - if (device->plane_num > 1) - { - rt_uint32_t mask; - rt_uint16_t from_block, to_block; + if (device->plane_num > 1) + { + rt_uint32_t mask; + rt_uint16_t from_block, to_block; - from_block = (rt_uint16_t)(from / PAGE_PER_BLOCK); - to_block = (rt_uint16_t)(to / PAGE_PER_BLOCK); - mask = device->plane_num - 1; + from_block = (rt_uint16_t)(from / PAGE_PER_BLOCK); + to_block = (rt_uint16_t)(to / PAGE_PER_BLOCK); + mask = device->plane_num - 1; - if ((from_block & mask) != (to_block & mask)) - { - rt_kprintf("invalid page copy on the block. from [%d] --> to[%d]\n", from_block, to_block); - return -RT_EIO; - } - } + if ((from_block & mask) != (to_block & mask)) + { + rt_kprintf("invalid page copy on the block. from [%d] --> to[%d]\n", from_block, to_block); + return -RT_EIO; + } + } - /* read page */ - offset = from * PAGE_SIZE; - fseek(file, offset, SEEK_SET); - fread(page_buffer, sizeof(page_buffer), 1, file); - fread(oob_buffer, sizeof(oob_buffer), 1, file); + /* read page */ + offset = from * PAGE_SIZE; + fseek(file, offset, SEEK_SET); + fread(page_buffer, sizeof(page_buffer), 1, file); + fread(oob_buffer, sizeof(oob_buffer), 1, file); - /* write page */ - offset = to * PAGE_SIZE; - fseek(file, offset, SEEK_SET); - fwrite(page_buffer, sizeof(page_buffer), 1, file); - fwrite(oob_buffer, sizeof(oob_buffer), 1, file); + /* write page */ + offset = to * PAGE_SIZE; + fseek(file, offset, SEEK_SET); + fwrite(page_buffer, sizeof(page_buffer), 1, file); + fwrite(oob_buffer, sizeof(oob_buffer), 1, file); - return RT_EOK; + return RT_EOK; } /* erase block */ -static rt_err_t nanddrv_file_erase_block(struct rt_mtd_nand_device* device, rt_uint32_t block) +static rt_err_t nanddrv_file_erase_block(struct rt_mtd_nand_device *device, rt_uint32_t block) { - if (block > BLOCK_NUM) return -RT_EIO; + if (block > BLOCK_NUM) return -RT_EIO; - /* add the start blocks */ - block = block + device->block_start * device->pages_per_block; + /* add the start blocks */ + block = block + device->block_start * device->pages_per_block; - fseek(file, block * BLOCK_SIZE, SEEK_SET ); - fwrite(block_data, sizeof(block_data), 1, file); + fseek(file, block * BLOCK_SIZE, SEEK_SET); + fwrite(block_data, sizeof(block_data), 1, file); - return RT_EOK; + return RT_EOK; } -const static struct rt_mtd_nand_driver_ops _ops = +const static struct rt_mtd_nand_driver_ops _ops = { - nanddrv_file_read_id, - nanddrv_file_read_page, - nanddrv_file_write_page, - nanddrv_file_move_page, - nanddrv_file_erase_block + nanddrv_file_read_id, + nanddrv_file_read_page, + nanddrv_file_write_page, + nanddrv_file_move_page, + nanddrv_file_erase_block }; void nand_eraseall(void); void rt_hw_mtd_nand_init(void) { - rt_uint16_t ecc_size; - rt_uint32_t size; + rt_uint16_t ecc_size; + rt_uint32_t size; - memset(block_data, 0xff, sizeof(block_data)); - /* open file */ - file = fopen(NAND_SIM, "rb+"); - if (file == NULL) - { - file = fopen(NAND_SIM, "wb+"); - } - fseek(file, 0, SEEK_END); - size = ftell(file); + memset(block_data, 0xff, sizeof(block_data)); + /* open file */ + file = fopen(NAND_SIM, "rb+"); + if (file == NULL) + { + file = fopen(NAND_SIM, "wb+"); + } + fseek(file, 0, SEEK_END); + size = ftell(file); - fseek(file, 0, SEEK_SET ); - if (size < BLOCK_NUM * BLOCK_SIZE) - { - rt_uint32_t index; - fseek(file, 0, SEEK_SET ); - for (index = 0; index < BLOCK_NUM; index ++) - { - fwrite(block_data, sizeof(block_data), 1, file); - } - } - fseek(file, 0, SEEK_SET ); + fseek(file, 0, SEEK_SET); + if (size < BLOCK_NUM * BLOCK_SIZE) + { + rt_uint32_t index; + fseek(file, 0, SEEK_SET); + for (index = 0; index < BLOCK_NUM; index ++) + { + fwrite(block_data, sizeof(block_data), 1, file); + } + } + fseek(file, 0, SEEK_SET); - ecc_size = (PAGE_SIZE - OOB_SIZE) * 3/256; - _nanddrv_file_device.plane_num = 2; - _nanddrv_file_device.oob_size = OOB_SIZE; - _nanddrv_file_device.oob_free = OOB_SIZE - ecc_size; - _nanddrv_file_device.page_size = PAGE_SIZE - OOB_SIZE; - _nanddrv_file_device.pages_per_block = PAGE_PER_BLOCK; - _nanddrv_file_device.block_start = 0; - _nanddrv_file_device.block_end = BLOCK_NUM/2; - _nanddrv_file_device.block_total = _nanddrv_file_device.block_end - _nanddrv_file_device.block_start; - _nanddrv_file_device.ops = &_ops; + ecc_size = (PAGE_SIZE - OOB_SIZE) * 3 / 256; + _nanddrv_file_device.plane_num = 2; + _nanddrv_file_device.oob_size = OOB_SIZE; + _nanddrv_file_device.oob_free = OOB_SIZE - ecc_size; + _nanddrv_file_device.page_size = PAGE_SIZE - OOB_SIZE; + _nanddrv_file_device.pages_per_block = PAGE_PER_BLOCK; + _nanddrv_file_device.block_start = 0; + _nanddrv_file_device.block_end = BLOCK_NUM / 2; + _nanddrv_file_device.block_total = _nanddrv_file_device.block_end - _nanddrv_file_device.block_start; + _nanddrv_file_device.ops = &_ops; - rt_mtd_nand_register_device("nand0", &_nanddrv_file_device); + rt_mtd_nand_register_device("nand0", &_nanddrv_file_device); } #if defined(RT_USING_FINSH) #include void nand_eraseall() { - int index; - for (index = 0; index < _nanddrv_file_device.block_total; index ++) - { - nanddrv_file_erase_block(&_nanddrv_file_device, index); - } + int index; + for (index = 0; index < _nanddrv_file_device.block_total; index ++) + { + nanddrv_file_erase_block(&_nanddrv_file_device, index); + } } FINSH_FUNCTION_EXPORT(nand_eraseall, erase all of block in the nand flash); #if 0 void nand_log(int level) { - nftl_set_trace_level(level); + nftl_set_trace_level(level); } FINSH_FUNCTION_EXPORT(nand_log, set NFTL trace level); -#endif +#endif #endif //RT_USING_FINSH diff --git a/bsp/simulator/drivers/sd_sim.c b/bsp/simulator/drivers/sd_sim.c index 93538620e..47822d3e3 100644 --- a/bsp/simulator/drivers/sd_sim.c +++ b/bsp/simulator/drivers/sd_sim.c @@ -4,7 +4,7 @@ #include #include -// #define SD_TRACE rt_kprintf +// #define SD_TRACE rt_kprintf #define SD_TRACE(...) //#define SDCARD_SIM "F:\\Project\\tools\\SDCARD" @@ -13,12 +13,12 @@ struct sdcard_device { - struct rt_device parent; - FILE* file; + struct rt_device parent; + FILE *file; }; static struct sdcard_device _sdcard; -#define SDCARD_DEVICE(device) (( struct sdcard_device*)(device)) +#define SDCARD_DEVICE(device) (( struct sdcard_device*)(device)) static rt_mutex_t lock; @@ -26,79 +26,79 @@ static rt_mutex_t lock; static rt_err_t rt_sdcard_init(rt_device_t dev) { - return RT_EOK; + return RT_EOK; } static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag) { - return RT_EOK; + return RT_EOK; } static rt_err_t rt_sdcard_close(rt_device_t dev) { - return RT_EOK; + return RT_EOK; } /* position: block page address, not bytes address * buffer: * size : how many blocks */ -static rt_size_t rt_sdcard_read(rt_device_t device, rt_off_t position, void* buffer, rt_size_t size) +static rt_size_t rt_sdcard_read(rt_device_t device, rt_off_t position, void *buffer, rt_size_t size) { - struct sdcard_device * sd; - int result = 0; + struct sdcard_device *sd; + int result = 0; - SD_TRACE("sd read: pos %d, size %d\n", position, size); + SD_TRACE("sd read: pos %d, size %d\n", position, size); - rt_mutex_take(lock, RT_WAITING_FOREVER); + rt_mutex_take(lock, RT_WAITING_FOREVER); sd = SDCARD_DEVICE(device); - fseek(sd->file, position * SECTOR_SIZE, SEEK_SET); + fseek(sd->file, position * SECTOR_SIZE, SEEK_SET); - result = fread(buffer, size * SECTOR_SIZE, 1, sd->file); - if (result < 0) - goto _err; + result = fread(buffer, size * SECTOR_SIZE, 1, sd->file); + if (result < 0) + goto _err; - rt_mutex_release(lock); + rt_mutex_release(lock); return size; _err: - SD_TRACE("sd read errors!\n"); - rt_mutex_release(lock); - return 0; + SD_TRACE("sd read errors!\n"); + rt_mutex_release(lock); + return 0; } /* position: block page address, not bytes address * buffer: * size : how many blocks */ -static rt_size_t rt_sdcard_write(rt_device_t device, rt_off_t position, const void* buffer, rt_size_t size) +static rt_size_t rt_sdcard_write(rt_device_t device, rt_off_t position, const void *buffer, rt_size_t size) { - struct sdcard_device * sd; - int result = 0; + struct sdcard_device *sd; + int result = 0; - SD_TRACE("sst write: pos %d, size %d\n", position, size); + SD_TRACE("sst write: pos %d, size %d\n", position, size); - rt_mutex_take(lock, RT_WAITING_FOREVER); + rt_mutex_take(lock, RT_WAITING_FOREVER); sd = SDCARD_DEVICE(device); - fseek(sd->file, position * SECTOR_SIZE, SEEK_SET); + fseek(sd->file, position * SECTOR_SIZE, SEEK_SET); - result = fwrite(buffer, size * SECTOR_SIZE, 1, sd->file); - if (result < 0) - goto _err; + result = fwrite(buffer, size * SECTOR_SIZE, 1, sd->file); + if (result < 0) + goto _err; - rt_mutex_release(lock); + rt_mutex_release(lock); return size; _err: - SD_TRACE("sd write errors!\n"); - rt_mutex_release(lock); - return 0; + SD_TRACE("sd write errors!\n"); + rt_mutex_release(lock); + return 0; } static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args) { - struct sdcard_device * sd; - unsigned int size; + struct sdcard_device *sd; + unsigned int size; RT_ASSERT(dev != RT_NULL); @@ -114,72 +114,72 @@ static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args) geometry->bytes_per_sector = SECTOR_SIZE; geometry->block_size = SECTOR_SIZE; - fseek(sd->file, 0, SEEK_END); - size = ftell(sd->file); + fseek(sd->file, 0, SEEK_END); + size = ftell(sd->file); - geometry->sector_count = size/SECTOR_SIZE; + geometry->sector_count = size / SECTOR_SIZE; } - return RT_EOK; + return RT_EOK; } -rt_err_t rt_hw_sdcard_init(const char * spi_device_name) +rt_err_t rt_hw_sdcard_init(const char *spi_device_name) { - int size; + int size; rt_uint32_t id, total_block; - struct sdcard_device * sd; - struct rt_device * device; + struct sdcard_device *sd; + struct rt_device *device; sd = &_sdcard; - device = &(sd->parent); + device = &(sd->parent); - lock = rt_mutex_create("lock", RT_IPC_FLAG_FIFO); + lock = rt_mutex_create("lock", RT_IPC_FLAG_FIFO); - /* open sd card file, if not exist, then create it */ - sd->file = fopen(SDCARD_SIM, "rb+"); - if (sd->file == NULL) - { - /* create a file to simulate sd card */ - sd->file = fopen(SDCARD_SIM, "wb+"); + /* open sd card file, if not exist, then create it */ + sd->file = fopen(SDCARD_SIM, "rb+"); + if (sd->file == NULL) + { + /* create a file to simulate sd card */ + sd->file = fopen(SDCARD_SIM, "wb+"); - fseek(sd->file, 0, SEEK_END); - size = ftell(sd->file); + fseek(sd->file, 0, SEEK_END); + size = ftell(sd->file); - fseek(sd->file, 0, SEEK_SET ); - if (size < SDCARD_SIZE) - { - int i; - unsigned char* ptr; + fseek(sd->file, 0, SEEK_SET); + if (size < SDCARD_SIZE) + { + int i; + unsigned char *ptr; - ptr = (unsigned char*) malloc (1024 * 1024); - if (ptr == NULL) - { - SD_TRACE("malloc error, no memory!\n"); - return RT_ERROR; - } - memset(ptr, 0x0, 1024 * 1024); + ptr = (unsigned char *) malloc(1024 * 1024); + if (ptr == NULL) + { + SD_TRACE("malloc error, no memory!\n"); + return RT_ERROR; + } + memset(ptr, 0x0, 1024 * 1024); - fseek(sd->file, 0, SEEK_SET); + fseek(sd->file, 0, SEEK_SET); - for(i=0; i<(SDCARD_SIZE / (1024*1024)); i++) - fwrite(ptr, 1024 * 1024, 1, sd->file); + for (i = 0; i < (SDCARD_SIZE / (1024 * 1024)); i++) + fwrite(ptr, 1024 * 1024, 1, sd->file); - free(ptr); - } - } - fseek(sd->file, 0, SEEK_SET); + free(ptr); + } + } + fseek(sd->file, 0, SEEK_SET); - device->type = RT_Device_Class_Block; - device->init = rt_sdcard_init; - device->open = rt_sdcard_open; - device->close = rt_sdcard_close; - device->read = rt_sdcard_read; - device->write = rt_sdcard_write; - device->control = rt_sdcard_control; - device->user_data = NULL; + device->type = RT_Device_Class_Block; + device->init = rt_sdcard_init; + device->open = rt_sdcard_open; + device->close = rt_sdcard_close; + device->read = rt_sdcard_read; + device->write = rt_sdcard_write; + device->control = rt_sdcard_control; + device->user_data = NULL; - rt_device_register(device, "sd0", - RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); + rt_device_register(device, "sd0", + RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); return RT_EOK; } @@ -188,7 +188,7 @@ rt_err_t rt_hw_sdcard_init(const char * spi_device_name) #include void eraseall(void) { - printf("had not implemented yet!\n"); + printf("had not implemented yet!\n"); } FINSH_FUNCTION_EXPORT(eraseall, erase all block in SPI flash); #endif diff --git a/bsp/simulator/drivers/sdl_fb.c b/bsp/simulator/drivers/sdl_fb.c index 1c6436740..fca7e3ed7 100644 --- a/bsp/simulator/drivers/sdl_fb.c +++ b/bsp/simulator/drivers/sdl_fb.c @@ -4,132 +4,132 @@ #include #include -#define SDL_SCREEN_WIDTH 800 -#define SDL_SCREEN_HEIGHT 480 +#define SDL_SCREEN_WIDTH 800 +#define SDL_SCREEN_HEIGHT 480 struct sdlfb_device { - struct rt_device parent; + struct rt_device parent; - SDL_Surface *screen; - rt_uint16_t width; - rt_uint16_t height; + SDL_Surface *screen; + rt_uint16_t width; + rt_uint16_t height; }; struct sdlfb_device _device; /* common device interface */ static rt_err_t sdlfb_init(rt_device_t dev) { - return RT_EOK; + return RT_EOK; } static rt_err_t sdlfb_open(rt_device_t dev, rt_uint16_t oflag) { - return RT_EOK; + return RT_EOK; } static rt_err_t sdlfb_close(rt_device_t dev) { - SDL_Quit(); - return RT_EOK; + SDL_Quit(); + return RT_EOK; } static rt_mutex_t sdllock; static rt_err_t sdlfb_control(rt_device_t dev, rt_uint8_t cmd, void *args) { - struct sdlfb_device *device; + struct sdlfb_device *device; - rt_mutex_take(sdllock, RT_WAITING_FOREVER); - device = (struct sdlfb_device*)dev; - RT_ASSERT(device != RT_NULL); - RT_ASSERT(device->screen != RT_NULL); + rt_mutex_take(sdllock, RT_WAITING_FOREVER); + device = (struct sdlfb_device *)dev; + RT_ASSERT(device != RT_NULL); + RT_ASSERT(device->screen != RT_NULL); - switch (cmd) - { - case RTGRAPHIC_CTRL_GET_INFO: - { - struct rt_device_graphic_info *info; + switch (cmd) + { + case RTGRAPHIC_CTRL_GET_INFO: + { + struct rt_device_graphic_info *info; - info = (struct rt_device_graphic_info*) args; - info->bits_per_pixel = 16; - info->pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P; - info->framebuffer = device->screen->pixels; - info->width = device->screen->w; - info->height = device->screen->h; - } - break; - case RTGRAPHIC_CTRL_RECT_UPDATE: - { - struct rt_device_rect_info *rect; - rect = (struct rt_device_rect_info*)args; + info = (struct rt_device_graphic_info *) args; + info->bits_per_pixel = 16; + info->pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P; + info->framebuffer = device->screen->pixels; + info->width = device->screen->w; + info->height = device->screen->h; + } + break; + case RTGRAPHIC_CTRL_RECT_UPDATE: + { + struct rt_device_rect_info *rect; + rect = (struct rt_device_rect_info *)args; - /* SDL_UpdateRect(_device.screen, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h); */ - SDL_UpdateRect(_device.screen, 0, 0, device->width, device->height); - } - break; - case RTGRAPHIC_CTRL_SET_MODE: - { + /* SDL_UpdateRect(_device.screen, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h); */ + SDL_UpdateRect(_device.screen, 0, 0, device->width, device->height); + } + break; + case RTGRAPHIC_CTRL_SET_MODE: + { #if 0 - struct rt_device_rect_info* rect; + struct rt_device_rect_info *rect; - rect = (struct rt_device_rect_info*)args; - if ((_device.width == rect->width) && (_device.height == rect->height)) return -RT_ERROR; - - _device.width = rect->width; - _device.height = rect->height; - - if (_device.screen != RT_NULL) - { - SDL_FreeSurface(_device.screen); - - /* re-create screen surface */ - _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); - if ( _device.screen == NULL ) - { - fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); - exit(1); - } + rect = (struct rt_device_rect_info *)args; + if ((_device.width == rect->width) && (_device.height == rect->height)) return -RT_ERROR; - SDL_WM_SetCaption ("RT-Thread/GUI Simulator", NULL); - } + _device.width = rect->width; + _device.height = rect->height; + + if (_device.screen != RT_NULL) + { + SDL_FreeSurface(_device.screen); + + /* re-create screen surface */ + _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); + if (_device.screen == NULL) + { + fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); + exit(1); + } + + SDL_WM_SetCaption("RT-Thread/GUI Simulator", NULL); + } #endif - } - break; - } - rt_mutex_release(sdllock); - return RT_EOK; + } + break; + } + rt_mutex_release(sdllock); + return RT_EOK; } static void sdlfb_hw_init(void) { - /* set video driver for VC++ debug */ - //_putenv("SDL_VIDEODRIVER=windib"); + /* set video driver for VC++ debug */ + //_putenv("SDL_VIDEODRIVER=windib"); - //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0) - if (SDL_Init(SDL_INIT_EVERYTHING) < 0) - { + //if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_AUDIO) < 0) + if (SDL_Init(SDL_INIT_EVERYTHING) < 0) + { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); exit(1); } - _device.parent.init = sdlfb_init; - _device.parent.open = sdlfb_open; - _device.parent.close = sdlfb_close; - _device.parent.read = RT_NULL; - _device.parent.write = RT_NULL; - _device.parent.control = sdlfb_control; + _device.parent.init = sdlfb_init; + _device.parent.open = sdlfb_open; + _device.parent.close = sdlfb_close; + _device.parent.read = RT_NULL; + _device.parent.write = RT_NULL; + _device.parent.control = sdlfb_control; - _device.width = SDL_SCREEN_WIDTH; - _device.height = SDL_SCREEN_HEIGHT; - _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); + _device.width = SDL_SCREEN_WIDTH; + _device.height = SDL_SCREEN_HEIGHT; + _device.screen = SDL_SetVideoMode(_device.width, _device.height, 16, SDL_SWSURFACE | SDL_DOUBLEBUF); if (_device.screen == NULL) - { + { fprintf(stderr, "Couldn't set video mode: %s\n", SDL_GetError()); exit(1); } - SDL_WM_SetCaption ("RT-Thread/GUI Simulator", NULL); - rt_device_register(RT_DEVICE(&_device), "sdl", RT_DEVICE_FLAG_RDWR); + SDL_WM_SetCaption("RT-Thread/GUI Simulator", NULL); + rt_device_register(RT_DEVICE(&_device), "sdl", RT_DEVICE_FLAG_RDWR); - sdllock = rt_mutex_create("fb",RT_IPC_FLAG_FIFO); + sdllock = rt_mutex_create("fb", RT_IPC_FLAG_FIFO); } #include @@ -143,158 +143,158 @@ static void sdlfb_hw_init(void) static DWORD WINAPI sdl_loop(LPVOID lpParam) { - int quit = 0; - SDL_Event event; - int button_state = 0; + int quit = 0; + SDL_Event event; + int button_state = 0; - rt_device_t device; - sdlfb_hw_init(); + rt_device_t device; + sdlfb_hw_init(); - device = rt_device_find("sdl"); - rtgui_graphic_set_device(device); + device = rt_device_find("sdl"); + rtgui_graphic_set_device(device); - /* handle SDL event */ - while(!quit) - { - SDL_WaitEvent(&event); + /* handle SDL event */ + while (!quit) + { + SDL_WaitEvent(&event); - switch (event.type) - { - case SDL_MOUSEMOTION: + switch (event.type) + { + case SDL_MOUSEMOTION: #if 0 - { - struct rtgui_event_mouse emouse; - emouse.parent.type = RTGUI_EVENT_MOUSE_MOTION; - emouse.parent.sender = RT_NULL; - emouse.wid = RT_NULL; + { + struct rtgui_event_mouse emouse; + emouse.parent.type = RTGUI_EVENT_MOUSE_MOTION; + emouse.parent.sender = RT_NULL; + emouse.wid = RT_NULL; - emouse.x = ((SDL_MouseMotionEvent*)&event)->x; - emouse.y = ((SDL_MouseMotionEvent*)&event)->y; + emouse.x = ((SDL_MouseMotionEvent *)&event)->x; + emouse.y = ((SDL_MouseMotionEvent *)&event)->y; - /* init mouse button */ - emouse.button = button_state; + /* init mouse button */ + emouse.button = button_state; - /* send event to server */ - rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse)); - } + /* send event to server */ + rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse)); + } #endif - break; + break; - case SDL_MOUSEBUTTONDOWN: - case SDL_MOUSEBUTTONUP: - { - struct rtgui_event_mouse emouse; - SDL_MouseButtonEvent* mb; + case SDL_MOUSEBUTTONDOWN: + case SDL_MOUSEBUTTONUP: + { + struct rtgui_event_mouse emouse; + SDL_MouseButtonEvent *mb; - emouse.parent.type = RTGUI_EVENT_MOUSE_BUTTON; - emouse.parent.sender = RT_NULL; - emouse.wid = RT_NULL; + emouse.parent.type = RTGUI_EVENT_MOUSE_BUTTON; + emouse.parent.sender = RT_NULL; + emouse.wid = RT_NULL; - mb = (SDL_MouseButtonEvent*)&event; + mb = (SDL_MouseButtonEvent *)&event; - emouse.x = mb->x; - emouse.y = mb->y; + emouse.x = mb->x; + emouse.y = mb->y; - /* init mouse button */ - emouse.button = 0; + /* init mouse button */ + emouse.button = 0; - /* set emouse button */ - if (mb->button & (1 << (SDL_BUTTON_LEFT - 1)) ) - { - emouse.button |= RTGUI_MOUSE_BUTTON_LEFT; - } - else if (mb->button & (1 << (SDL_BUTTON_RIGHT - 1))) - { - emouse.button |= RTGUI_MOUSE_BUTTON_RIGHT; - } - else if (mb->button & (1 << (SDL_BUTTON_MIDDLE - 1))) - { - emouse.button |= RTGUI_MOUSE_BUTTON_MIDDLE; - } + /* set emouse button */ + if (mb->button & (1 << (SDL_BUTTON_LEFT - 1))) + { + emouse.button |= RTGUI_MOUSE_BUTTON_LEFT; + } + else if (mb->button & (1 << (SDL_BUTTON_RIGHT - 1))) + { + emouse.button |= RTGUI_MOUSE_BUTTON_RIGHT; + } + else if (mb->button & (1 << (SDL_BUTTON_MIDDLE - 1))) + { + emouse.button |= RTGUI_MOUSE_BUTTON_MIDDLE; + } - if (mb->type == SDL_MOUSEBUTTONDOWN) - { - emouse.button |= RTGUI_MOUSE_BUTTON_DOWN; - button_state = emouse.button; - } - else - { - emouse.button |= RTGUI_MOUSE_BUTTON_UP; - button_state = 0; - } + if (mb->type == SDL_MOUSEBUTTONDOWN) + { + emouse.button |= RTGUI_MOUSE_BUTTON_DOWN; + button_state = emouse.button; + } + else + { + emouse.button |= RTGUI_MOUSE_BUTTON_UP; + button_state = 0; + } - /* send event to server */ - rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse)); - } - break; + /* send event to server */ + rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse)); + } + break; - case SDL_KEYUP: - { - struct rtgui_event_kbd ekbd; - ekbd.parent.type = RTGUI_EVENT_KBD; - ekbd.parent.sender = RT_NULL; - ekbd.type = RTGUI_KEYUP; - ekbd.wid = RT_NULL; - ekbd.mod = event.key.keysym.mod; - ekbd.key = event.key.keysym.sym; + case SDL_KEYUP: + { + struct rtgui_event_kbd ekbd; + ekbd.parent.type = RTGUI_EVENT_KBD; + ekbd.parent.sender = RT_NULL; + ekbd.type = RTGUI_KEYUP; + ekbd.wid = RT_NULL; + ekbd.mod = event.key.keysym.mod; + ekbd.key = event.key.keysym.sym; - /* FIXME: unicode */ - ekbd.unicode = 0; + /* FIXME: unicode */ + ekbd.unicode = 0; - /* send event to server */ - rtgui_server_post_event(&ekbd.parent, sizeof(struct rtgui_event_kbd)); - } - break; + /* send event to server */ + rtgui_server_post_event(&ekbd.parent, sizeof(struct rtgui_event_kbd)); + } + break; - case SDL_KEYDOWN: - { - struct rtgui_event_kbd ekbd; - ekbd.parent.type = RTGUI_EVENT_KBD; - ekbd.parent.sender = RT_NULL; - ekbd.type = RTGUI_KEYDOWN; - ekbd.wid = RT_NULL; - ekbd.mod = event.key.keysym.mod; - ekbd.key = event.key.keysym.sym; + case SDL_KEYDOWN: + { + struct rtgui_event_kbd ekbd; + ekbd.parent.type = RTGUI_EVENT_KBD; + ekbd.parent.sender = RT_NULL; + ekbd.type = RTGUI_KEYDOWN; + ekbd.wid = RT_NULL; + ekbd.mod = event.key.keysym.mod; + ekbd.key = event.key.keysym.sym; - /* FIXME: unicode */ - ekbd.unicode = 0; + /* FIXME: unicode */ + ekbd.unicode = 0; - /* send event to server */ - rtgui_server_post_event(&ekbd.parent, sizeof(struct rtgui_event_kbd)); - } - break; + /* send event to server */ + rtgui_server_post_event(&ekbd.parent, sizeof(struct rtgui_event_kbd)); + } + break; - case SDL_QUIT: - SDL_Quit(); - quit = 1; - break; + case SDL_QUIT: + SDL_Quit(); + quit = 1; + break; - default: - break; - } + default: + break; + } - if (quit) - break; - } - //exit(0); - return 0; + if (quit) + break; + } + //exit(0); + return 0; } /* start sdl thread */ void rt_hw_sdl_start(void) { - HANDLE thread; - DWORD thread_id; + HANDLE thread; + DWORD thread_id; - /* create thread that loop sdl event */ + /* create thread that loop sdl event */ thread = CreateThread(NULL, 0, - (LPTHREAD_START_ROUTINE)sdl_loop, + (LPTHREAD_START_ROUTINE)sdl_loop, 0, CREATE_SUSPENDED, &thread_id); - if(thread == NULL) + if (thread == NULL) { //Display Error Message diff --git a/bsp/simulator/drivers/serial.c b/bsp/simulator/drivers/serial.c index 1555869a2..a5643a46d 100644 --- a/bsp/simulator/drivers/serial.c +++ b/bsp/simulator/drivers/serial.c @@ -1,7 +1,7 @@ /* ****************************************************************************** -* By : parai -* email:parai@foxmail.com +* By : parai +* email:parai@foxmail.com * 这并不是一个真的串口设备，只是为了能够让内核打印信息而创建 ****************************************************************************** */ @@ -20,141 +20,143 @@ extern struct serial_int_rx serial_rx; /** * This function initializes serial */ -static rt_err_t rt_serial_init (rt_device_t dev) +static rt_err_t rt_serial_init(rt_device_t dev) { - if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED)) - { - if (dev->flag & RT_DEVICE_FLAG_INT_RX) - { - rt_memset(serial_rx.rx_buffer, 0, - sizeof(serial_rx.rx_buffer)); - serial_rx.read_index = 0; - serial_rx.save_index = 0; - } + if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED)) + { + if (dev->flag & RT_DEVICE_FLAG_INT_RX) + { + rt_memset(serial_rx.rx_buffer, 0, + sizeof(serial_rx.rx_buffer)); + serial_rx.read_index = 0; + serial_rx.save_index = 0; + } - dev->flag |= RT_DEVICE_FLAG_ACTIVATED; - } - return RT_EOK; + dev->flag |= RT_DEVICE_FLAG_ACTIVATED; + } + return RT_EOK; } -static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag){ +static rt_err_t rt_serial_open(rt_device_t dev, rt_uint16_t oflag) +{ #if _DEBUG_SERIAL==1 - printf("in rt_serial_open()\n"); + printf("in rt_serial_open()\n"); #endif - return RT_EOK; + return RT_EOK; } static rt_err_t rt_serial_close(rt_device_t dev) { #if _DEBUG_SERIAL==1 - printf("in rt_serial_close()\n"); + printf("in rt_serial_close()\n"); #endif - return RT_EOK; + return RT_EOK; } -static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) +static rt_size_t rt_serial_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size) { - rt_uint8_t* ptr; - rt_err_t err_code; + rt_uint8_t *ptr; + rt_err_t err_code; - ptr = buffer; - err_code = RT_EOK; + ptr = buffer; + err_code = RT_EOK; - if (dev->flag & RT_DEVICE_FLAG_INT_RX) - { - /* interrupt mode Rx */ - while (size) - { - rt_base_t level; + if (dev->flag & RT_DEVICE_FLAG_INT_RX) + { + /* interrupt mode Rx */ + while (size) + { + rt_base_t level; - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - if (serial_rx.read_index != serial_rx.save_index) - { - /* read a character */ - *ptr++ = serial_rx.rx_buffer[serial_rx.read_index]; - size--; + if (serial_rx.read_index != serial_rx.save_index) + { + /* read a character */ + *ptr++ = serial_rx.rx_buffer[serial_rx.read_index]; + size--; - /* move to next position */ - serial_rx.read_index ++; - if (serial_rx.read_index >= SERIAL_RX_BUFFER_SIZE) - serial_rx.read_index = 0; - } - else - { - /* set error code */ - err_code = -RT_EEMPTY; + /* move to next position */ + serial_rx.read_index ++; + if (serial_rx.read_index >= SERIAL_RX_BUFFER_SIZE) + serial_rx.read_index = 0; + } + else + { + /* set error code */ + err_code = -RT_EEMPTY; - /* enable interrupt */ - rt_hw_interrupt_enable(level); - break; - } + /* enable interrupt */ + rt_hw_interrupt_enable(level); + break; + } - /* enable interrupt */ - rt_hw_interrupt_enable(level); - } - } + /* enable interrupt */ + rt_hw_interrupt_enable(level); + } + } - /* set error code */ - rt_set_errno(err_code); - return (rt_uint32_t)ptr - (rt_uint32_t)buffer; + /* set error code */ + rt_set_errno(err_code); + return (rt_uint32_t)ptr - (rt_uint32_t)buffer; } -static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size) +static rt_size_t rt_serial_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size) { #if _DEBUG_SERIAL==1 - printf("in rt_serial_write()\n"); + printf("in rt_serial_write()\n"); #endif - printf("%s",(char*)buffer); - return size; + printf("%s", (char *)buffer); + return size; } -static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args) +static rt_err_t rt_serial_control(rt_device_t dev, rt_uint8_t cmd, void *args) { - RT_ASSERT(dev != RT_NULL); + RT_ASSERT(dev != RT_NULL); - switch (cmd){ - case RT_DEVICE_CTRL_SUSPEND: - /* suspend device */ - dev->flag |= RT_DEVICE_FLAG_SUSPENDED; - break; + switch (cmd) + { + case RT_DEVICE_CTRL_SUSPEND: + /* suspend device */ + dev->flag |= RT_DEVICE_FLAG_SUSPENDED; + break; - case RT_DEVICE_CTRL_RESUME: - /* resume device */ - dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED; - break; - } + case RT_DEVICE_CTRL_RESUME: + /* resume device */ + dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED; + break; + } - return RT_EOK; + return RT_EOK; } /* * serial register */ -static rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag) +static rt_err_t rt_hw_serial_register(rt_device_t device, const char *name, rt_uint32_t flag) { - RT_ASSERT(device != RT_NULL); + RT_ASSERT(device != RT_NULL); #if _DEBUG_SERIAL==1 - printf("in rt_serial_register()\n"); + printf("in rt_serial_register()\n"); #endif - device->type = RT_Device_Class_Char; - device->rx_indicate = RT_NULL; - device->tx_complete = RT_NULL; - device->init = rt_serial_init; - device->open = rt_serial_open; - device->close = rt_serial_close; - device->read = rt_serial_read; - device->write = rt_serial_write; - device->control = rt_serial_control; - device->user_data = RT_NULL; + device->type = RT_Device_Class_Char; + device->rx_indicate = RT_NULL; + device->tx_complete = RT_NULL; + device->init = rt_serial_init; + device->open = rt_serial_open; + device->close = rt_serial_close; + device->read = rt_serial_read; + device->write = rt_serial_write; + device->control = rt_serial_control; + device->user_data = RT_NULL; - /* register a character device */ - return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag); + /* register a character device */ + return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag); } rt_err_t rt_hw_serial_init(void) { - return rt_hw_serial_register(&serial_device,RT_CONSOLE_DEVICE_NAME, - RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM); + return rt_hw_serial_register(&serial_device, RT_CONSOLE_DEVICE_NAME, + RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM); } \ No newline at end of file diff --git a/bsp/simulator/drivers/serial.h b/bsp/simulator/drivers/serial.h index fe82957b3..bd7fff655 100644 --- a/bsp/simulator/drivers/serial.h +++ b/bsp/simulator/drivers/serial.h @@ -4,8 +4,8 @@ * BANKED MEMORY MODEL * * File : rthw.c -* By : parai -* email:parai@foxmail.com +* By : parai +* email:parai@foxmail.com *******************************************************************************************************/ #ifndef __RT_HW_SERIAL_H__ @@ -14,8 +14,8 @@ #define SERIAL_RX_BUFFER_SIZE 80 struct serial_int_rx { - rt_uint8_t rx_buffer[SERIAL_RX_BUFFER_SIZE]; - rt_uint32_t read_index, save_index; + rt_uint8_t rx_buffer[SERIAL_RX_BUFFER_SIZE]; + rt_uint32_t read_index, save_index; }; rt_err_t rt_hw_serial_init(void); diff --git a/bsp/simulator/drivers/sst25vfxx_mtd.h b/bsp/simulator/drivers/sst25vfxx_mtd.h index 6b0866247..5b8a3c547 100644 --- a/bsp/simulator/drivers/sst25vfxx_mtd.h +++ b/bsp/simulator/drivers/sst25vfxx_mtd.h @@ -1,18 +1,18 @@ -/* - * File : sst25vfxx_mtd.h - * This file is part of RT-Thread RTOS - * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team - * - * The license and distribution terms for this file may be - * found in the file LICENSE in this distribution or at - * http://www.rt-thread.org/license/LICENSE - * - * Change Logs: - * Date Author Notes - * 2011-12-16 aozima the first version - * 2012-02-01 mbbill MTD driver version +/* + * File : sst25vfxx_mtd.h + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE + * + * Change Logs: + * Date Author Notes + * 2011-12-16 aozima the first version + * 2012-02-01 mbbill MTD driver version */ - + #ifndef SST25VFXX_MTD_H #define SST25VFXX_MTD_H @@ -21,4 +21,4 @@ rt_err_t sst25vfxx_mtd_init(const char *spi_device_name, rt_uint32_t block_start, rt_uint32_t block_end); -#endif +#endif diff --git a/bsp/simulator/drivers/sst25vfxx_mtd_sim.c b/bsp/simulator/drivers/sst25vfxx_mtd_sim.c index d2c411730..315cdf665 100644 --- a/bsp/simulator/drivers/sst25vfxx_mtd_sim.c +++ b/bsp/simulator/drivers/sst25vfxx_mtd_sim.c @@ -32,179 +32,179 @@ #define BLOCK_SIZE (64*1024) -#define SST25_MTD(device) ((struct sst25_mtd*)(device)) +#define SST25_MTD(device) ((struct sst25_mtd*)(device)) struct sst25_mtd { - struct rt_mtd_nor_device parent; - FILE * file; + struct rt_mtd_nor_device parent; + FILE *file; }; static struct sst25_mtd _sst25_mtd; static struct rt_mutex flash_lock; /* RT-Thread MTD device interface */ -static rt_uint32_t sst25vfxx_read_id(struct rt_mtd_nor_device* device) +static rt_uint32_t sst25vfxx_read_id(struct rt_mtd_nor_device *device) { - rt_uint8_t id_recv[3] = {MF_ID, MT_ID, MC_ID_SST25VF016}; + rt_uint8_t id_recv[3] = {MF_ID, MT_ID, MC_ID_SST25VF016}; - return (id_recv[0] << 16) | (id_recv[1] << 8) | id_recv[2]; + return (id_recv[0] << 16) | (id_recv[1] << 8) | id_recv[2]; } -static int sst25vfxx_read(struct rt_mtd_nor_device* device, rt_off_t position, rt_uint8_t *data, rt_size_t size) +static int sst25vfxx_read(struct rt_mtd_nor_device *device, rt_off_t position, rt_uint8_t *data, rt_size_t size) { struct sst25_mtd *sst25; - int result; + int result; sst25 = SST25_MTD(device); RT_ASSERT(sst25 != RT_NULL); - rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); + rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); - fseek(sst25->file, position, SEEK_SET); - result = fread(data, size, 1, sst25->file); - if (result < 0) - rt_kprintf("sst read error.\n"); + fseek(sst25->file, position, SEEK_SET); + result = fread(data, size, 1, sst25->file); + if (result < 0) + rt_kprintf("sst read error.\n"); - rt_mutex_release(&flash_lock); + rt_mutex_release(&flash_lock); return size; } -static int sst25vfxx_write(struct rt_mtd_nor_device* device, rt_off_t position, - const rt_uint8_t *data, rt_size_t size) +static int sst25vfxx_write(struct rt_mtd_nor_device *device, rt_off_t position, + const rt_uint8_t *data, rt_size_t size) { struct sst25_mtd *sst25; - int result; + int result; sst25 = SST25_MTD(device); RT_ASSERT(sst25 != RT_NULL); - rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); + rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); - fseek(sst25->file, position, SEEK_SET); - result = fwrite(data, size, 1, sst25->file); - if (result < 0) - rt_kprintf("sst write error.\n"); + fseek(sst25->file, position, SEEK_SET); + result = fwrite(data, size, 1, sst25->file); + if (result < 0) + rt_kprintf("sst write error.\n"); - rt_mutex_release(&flash_lock); + rt_mutex_release(&flash_lock); return size; } static char block_buffer[BLOCK_SIZE]; -static rt_err_t sst25vfxx_erase_block(struct rt_mtd_nor_device* device, rt_uint32_t block) +static rt_err_t sst25vfxx_erase_block(struct rt_mtd_nor_device *device, rt_uint32_t block) { struct sst25_mtd *sst25; - int result; + int result; sst25 = SST25_MTD(device); RT_ASSERT(sst25 != RT_NULL); - rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); + rt_mutex_take(&flash_lock, RT_WAITING_FOREVER); - memset(block_buffer, 0xFF, BLOCK_SIZE); - fseek(sst25->file, block, SEEK_SET); + memset(block_buffer, 0xFF, BLOCK_SIZE); + fseek(sst25->file, block, SEEK_SET); - result = fwrite(block_buffer, BLOCK_SIZE, 1, sst25->file); - if (result < 0) - rt_kprintf("sst write error.\n"); + result = fwrite(block_buffer, BLOCK_SIZE, 1, sst25->file); + if (result < 0) + rt_kprintf("sst write error.\n"); - rt_mutex_release(&flash_lock); + rt_mutex_release(&flash_lock); return RT_EOK; } const static struct rt_mtd_nor_driver_ops sst25vfxx_mtd_ops = { - sst25vfxx_read_id, - sst25vfxx_read, - sst25vfxx_write, - sst25vfxx_erase_block, + sst25vfxx_read_id, + sst25vfxx_read, + sst25vfxx_write, + sst25vfxx_erase_block, }; static rt_err_t sst25vfxx_hw_init(struct sst25_mtd *mtd) { - mtd = mtd; + mtd = mtd; return RT_EOK; } /** * SST25vfxx API */ -rt_err_t sst25vfxx_mtd_init(const char * nor_name, - rt_uint32_t block_start, - rt_uint32_t block_end) +rt_err_t sst25vfxx_mtd_init(const char *nor_name, + rt_uint32_t block_start, + rt_uint32_t block_end) { rt_uint32_t id, total_block; - struct sst25_mtd * sst25; + struct sst25_mtd *sst25; struct rt_mtd_nor_device *mtd; sst25 = &_sst25_mtd; - mtd = &(sst25->parent); + mtd = &(sst25->parent); /* set page size and block size */ mtd->block_size = 64 * 1024; /* 64kByte */ mtd->ops = &sst25vfxx_mtd_ops; /* initialize mutex */ - if (rt_mutex_init(&flash_lock, nor_name, RT_IPC_FLAG_FIFO) != RT_EOK) - { - rt_kprintf("init sd lock mutex failed\n"); - } + if (rt_mutex_init(&flash_lock, nor_name, RT_IPC_FLAG_FIFO) != RT_EOK) + { + rt_kprintf("init sd lock mutex failed\n"); + } /* initialize flash */ id = sst25vfxx_read_id(mtd); switch (id & 0xff) { case MC_ID_SST25VF016: - total_block = (16 * 1024 * 1024 / 8) / mtd->block_size; - break; + total_block = (16 * 1024 * 1024 / 8) / mtd->block_size; + break; case MC_ID_SST25VF032: - total_block = (32 * 1024 * 1024 / 8) / mtd->block_size; - break; + total_block = (32 * 1024 * 1024 / 8) / mtd->block_size; + break; case MC_ID_SST25VF064: - total_block = (64 * 1024 * 1024 / 8) / mtd->block_size; - break; + total_block = (64 * 1024 * 1024 / 8) / mtd->block_size; + break; default: - rt_kprintf("SST25 detection error, id: %x\n", id); - return -RT_ERROR; + rt_kprintf("SST25 detection error, id: %x\n", id); + return -RT_ERROR; } if ((block_end == RT_UINT32_MAX) || (block_end == 0)) { - block_end = total_block; + block_end = total_block; } else if (block_end > total_block) { - rt_kprintf("SST25 total block: %d, out of block\n", total_block); - return -RT_ERROR; + rt_kprintf("SST25 total block: %d, out of block\n", total_block); + return -RT_ERROR; } mtd->block_start = block_start; mtd->block_end = block_end; - /* open nor file, if not exist, then create it */ - sst25->file = fopen(NOR_SIM, "rb+"); - if (sst25->file == NULL) - { - int i; - /* create a file to simulate nor */ - sst25->file = fopen(NOR_SIM, "wb+"); + /* open nor file, if not exist, then create it */ + sst25->file = fopen(NOR_SIM, "rb+"); + if (sst25->file == NULL) + { + int i; + /* create a file to simulate nor */ + sst25->file = fopen(NOR_SIM, "wb+"); - memset(block_buffer, 0xFF, sizeof(block_buffer)); - for(i=0; ifile, i * BLOCK_SIZE, SEEK_SET); - fwrite(block_buffer, BLOCK_SIZE, 1, sst25->file); - } - } + memset(block_buffer, 0xFF, sizeof(block_buffer)); + for (i = 0; i < total_block; i++) + { + fseek(sst25->file, i * BLOCK_SIZE, SEEK_SET); + fwrite(block_buffer, BLOCK_SIZE, 1, sst25->file); + } + } - fseek(sst25->file, 0, SEEK_SET); + fseek(sst25->file, 0, SEEK_SET); /* initialize hardware */ sst25vfxx_hw_init(&_sst25_mtd); /* register MTD device */ - rt_mtd_nor_register_device("nor", mtd); + rt_mtd_nor_register_device("nor", mtd); return RT_EOK; } @@ -213,14 +213,14 @@ rt_err_t sst25vfxx_mtd_init(const char * nor_name, #include void nor_erase(void) { - rt_uint32_t index; + rt_uint32_t index; struct rt_mtd_nor_device *mtd; mtd = SST25_MTD(&_sst25_mtd); - for (index = mtd->block_start; index < mtd->block_end; index ++) - { - sst25vfxx_erase_block(mtd, index * mtd->block_size); - } + for (index = mtd->block_start; index < mtd->block_end; index ++) + { + sst25vfxx_erase_block(mtd, index * mtd->block_size); + } } FINSH_FUNCTION_EXPORT(nor_erase, erase all block in SPI flash); #endif diff --git a/bsp/simulator/drivers/usart_sim.c b/bsp/simulator/drivers/usart_sim.c index d77328bf3..7db37c848 100644 --- a/bsp/simulator/drivers/usart_sim.c +++ b/bsp/simulator/drivers/usart_sim.c @@ -17,17 +17,17 @@ static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam); void rt_hw_usart_init(void) { - /* - * create serial thread that revice key input from keyboard - */ + /* + * create serial thread that revice key input from keyboard + */ OSKey_Thread = CreateThread(NULL, - 0, - (LPTHREAD_START_ROUTINE)ThreadforKeyGet, - 0, - CREATE_SUSPENDED, - &OSKey_ThreadID); - if(OSKey_Thread == NULL) + 0, + (LPTHREAD_START_ROUTINE)ThreadforKeyGet, + 0, + CREATE_SUSPENDED, + &OSKey_ThreadID); + if (OSKey_Thread == NULL) { //Display Error Message @@ -47,85 +47,85 @@ void rt_hw_usart_init(void) } /* - * () 0xe04b - * () 0xe048 - * () 0xe04d - * () 0xe050 + * () 0xe04b + * () 0xe048 + * () 0xe04d + * () 0xe050 */ static int savekey(unsigned char key) { - /* save on rx buffer */ - { - rt_base_t level; + /* save on rx buffer */ + { + rt_base_t level; - /* disable interrupt */ + /* disable interrupt */ //ʱرжϣΪҪuartݽṹ - level = rt_hw_interrupt_disable(); + level = rt_hw_interrupt_disable(); - /* save character */ - serial_rx.rx_buffer[serial_rx.save_index] = key; - serial_rx.save_index ++; - //Ĵsave_indexǷѾβתͷΪһλ - if (serial_rx.save_index >= SERIAL_RX_BUFFER_SIZE) - serial_rx.save_index = 0; + /* save character */ + serial_rx.rx_buffer[serial_rx.save_index] = key; + serial_rx.save_index ++; + //Ĵsave_indexǷѾβתͷΪһλ + if (serial_rx.save_index >= SERIAL_RX_BUFFER_SIZE) + serial_rx.save_index = 0; //ʾתsave_index׷read_indexread_indexһɵ - /* if the next position is read index, discard this 'read char' */ - if (serial_rx.save_index == serial_rx.read_index) - { - serial_rx.read_index ++; - if (serial_rx.read_index >= SERIAL_RX_BUFFER_SIZE) - serial_rx.read_index = 0; - } + /* if the next position is read index, discard this 'read char' */ + if (serial_rx.save_index == serial_rx.read_index) + { + serial_rx.read_index ++; + if (serial_rx.read_index >= SERIAL_RX_BUFFER_SIZE) + serial_rx.read_index = 0; + } - /* enable interrupt */ - //uartݽṹѾɣʹж - rt_hw_interrupt_enable(level); - } + /* enable interrupt */ + //uartݽṹѾɣʹж + rt_hw_interrupt_enable(level); + } - /* invoke callback */ - if (serial_device.rx_indicate != RT_NULL) - { - rt_size_t rx_length; + /* invoke callback */ + if (serial_device.rx_indicate != RT_NULL) + { + rt_size_t rx_length; - /* get rx length */ - rx_length = serial_rx.read_index > serial_rx.save_index ? - SERIAL_RX_BUFFER_SIZE - serial_rx.read_index + serial_rx.save_index : - serial_rx.save_index - serial_rx.read_index; + /* get rx length */ + rx_length = serial_rx.read_index > serial_rx.save_index ? + SERIAL_RX_BUFFER_SIZE - serial_rx.read_index + serial_rx.save_index : + serial_rx.save_index - serial_rx.read_index; - serial_device.rx_indicate(&serial_device, rx_length); - } - return 0; + serial_device.rx_indicate(&serial_device, rx_length); + } + return 0; } static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam) { - unsigned char key; + unsigned char key; (void)lpParam; //prevent compiler warnings - for(;;) + for (;;) { - key = _getch();//getchar(); - if (key == 0xE0) - { - key = _getch(); + key = _getch();//getchar(); + if (key == 0xE0) + { + key = _getch(); - if (key == 0x48) //up key , 0x1b 0x5b 0x41 - { - savekey(0x1b); - savekey(0x5b); - savekey(0x41); - } - else if (key == 0x50)//0x1b 0x5b 0x42 - { - savekey(0x1b); - savekey(0x5b); - savekey(0x42); - } + if (key == 0x48) //up key , 0x1b 0x5b 0x41 + { + savekey(0x1b); + savekey(0x5b); + savekey(0x41); + } + else if (key == 0x50)//0x1b 0x5b 0x42 + { + savekey(0x1b); + savekey(0x5b); + savekey(0x42); + } - continue; - } + continue; + } - savekey(key); + savekey(key); } } /*** ThreadforKeyGet ***/ \ No newline at end of file diff --git a/bsp/simulator/rtgui_demo/snake/snake.c b/bsp/simulator/rtgui_demo/snake/snake.c index ae25352d1..a9f57e609 100644 --- a/bsp/simulator/rtgui_demo/snake/snake.c +++ b/bsp/simulator/rtgui_demo/snake/snake.c @@ -1,271 +1,271 @@ -#include -#include -#include -#include "snake.h" - -#define ASSERT_RET(x, ret) \ - do{ \ - if (x) \ - return ret; \ - }while(0) - -rt_list_t snake_head; -SNAKE_DIR prevdir, newdir; - -static SNAKE_DIR dir_adjust(SNAKE_DIR dir) -{ - if ( (SNAKE_DIR_UP == prevdir && SNAKE_DIR_DOWN != dir) - || (SNAKE_DIR_DOWN == prevdir && SNAKE_DIR_UP != dir) - || (SNAKE_DIR_LEFT == prevdir && SNAKE_DIR_RIGHT != dir) - || (SNAKE_DIR_RIGHT == prevdir && SNAKE_DIR_LEFT != dir) - ) - { - newdir = dir; - } - else - { - rt_kprintf("dirction change error\n\r"); - } - - return newdir; -} - -static void across_XY(point_t *node, const map_t *map) -{ - RT_ASSERT(node != RT_NULL && map != RT_NULL); - - // ȳǰ߿ԴԽǽ - node->x = (node->x + map->width) % map->width; - node->y = (node->y + map->height) % map->height; -} - -static SYS_STE node_update(snake_t *tail, const point_t *node, map_t *map) -{ - SYS_STE ret; - point_t *pos; - - RT_ASSERT(tail != RT_NULL && node != RT_NULL && map != RT_NULL); - - pos = map->snake_flush; - pos[0].x = pos[0].y = -1; - pos[1].x = pos[1].y = -1; - - ret = (SYS_STE)map->range[node->y * map->width + node->x]; - - if (FOOD == map->range[node->y * map->width + node->x]) - { - // һʳһڵ - snake_t *new = (snake_t*)rt_malloc(sizeof(snake_t)); - if (!new) - return NORMAL; - - pos[0] = *node; - new->body = *node; - rt_list_insert_after(&snake_head, &new->list); - } - else if (NORMAL == map->range[node->y * map->width + node->x]) - { - // β޸ĺõͷ - rt_list_remove(&tail->list); - map->range[tail->body.y * map->width + tail->body.x] = NORMAL; - - pos[0] = *node; - pos[1] = tail->body; - - tail->body = *node; - rt_list_insert_after(&snake_head, &tail->list); - } - - map->range[node->y * map->width + node->x] = OVER; - - if (ret != OVER) - prevdir = newdir; - - return ret; -} - - -map_t* map_init(rt_uint32_t width, rt_uint32_t heigth) -{ - map_t *map = rt_malloc(sizeof(map_t)); - - if (map != RT_NULL) - { - map->range = rt_malloc(heigth * width); - - if (!map->range) - { - rt_free(map); - map = RT_NULL; - } - else - { - map->width = width; - map->height = heigth; - memset(map->range, NORMAL, heigth * width); - } - } - - return map; -} - -// һָȵָ -rt_bool_t snake_init(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map) -{ - rt_int32_t i; - rt_int32_t inc_x, inc_y; - point_t old = *start; - - ASSERT_RET(!map || !start, RT_FALSE); - - rt_list_init(&snake_head); - - if (dir == SNAKE_DIR_UP || dir == SNAKE_DIR_DOWN) - { - if (map->height <= length) - return RT_FALSE; - - inc_x = 0; - inc_y = dir == SNAKE_DIR_DOWN ? 1 : -1; // ӳӣͷָλ - old.y -= inc_y; - } - else - { - if (map->width <= length) - return RT_FALSE; - - inc_y = 0; - inc_x = dir == SNAKE_DIR_RIGHT ? -1 : 1; - old.x -= inc_x; - } - - for (i=0; ibody.y = inc_y + old.y; - new->body.x = inc_x + old.x; - - // ȳǰ߿ԴԽǽ - across_XY(&new->body, map); - - map->range[new->body.y * map->width + new->body.x] = OVER; - - old = new->body; - rt_list_insert_before(&snake_head, &new->list); - } - - prevdir = dir; - - return RT_TRUE; -} - -// ʳ -rt_bool_t food_init(map_t *map, rt_uint32_t max_num) -{ - point_t food; - -#ifndef FOOD_TIMEOUT -#define FOOD_TIMEOUT 10 -#endif - - rt_uint32_t timeout, num; - - ASSERT_RET(!map, RT_FALSE); - - num = 0; - timeout = rt_tick_get(); - srand(rand()); - - map->food_flush[0].x = map->food_flush[0].y = -1; - - do - { - food.x = rand() % map->width; - food.y = rand() % map->height; - - if (map->range[food.y * map->width + food.x] == NORMAL) - { - map->food_flush[0] = food; - map->range[food.y * map->width + food.x] = FOOD; - num++; - } - } - while (num < max_num && rt_tick_get() - timeout < FOOD_TIMEOUT); - - return num; -} - -void map_deinit(map_t *map) -{ - if (map) - { - if (map->range) - { - rt_free(map->range); - map->range = RT_NULL; - } - rt_free(map); - } -} - -void snake_deinit(void) -{ - snake_t *node; - - while (!rt_list_isempty(&snake_head)) - { - node = rt_list_entry(snake_head.prev, snake_t, list); - rt_list_remove(&node->list); - rt_free(node); - } -} - -void food_deinit(void) -{ - -} - -SYS_STE snake_step(SNAKE_DIR dir, map_t *map) -{ - snake_t *tail, *head; - point_t node; - - ASSERT_RET(!map, RT_FALSE); - - dir = dir_adjust(dir); - - // ȡͷβڵ㣬ڵ㲻Ҫı - tail = rt_list_entry(snake_head.prev, snake_t, list); - head = rt_list_entry(snake_head.next, snake_t, list); - - node = head->body; - - // һµͷ - switch (dir) - { - case SNAKE_DIR_UP: - case SNAKE_DIR_DOWN: - node.y = head->body.y + (dir == SNAKE_DIR_DOWN ? -1 : 1); - break; - case SNAKE_DIR_LEFT: - case SNAKE_DIR_RIGHT: - node.x = head->body.x + (dir == SNAKE_DIR_RIGHT ? 1 : -1); - break; - } - across_XY(&node, map); - - return node_update(tail, &node, map); -} - -rt_bool_t snake_restart(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map) -{ - ASSERT_RET(!map || !start, RT_FALSE); - - snake_deinit(); - memset(map->range, NORMAL, map->width * map->height); - - return snake_init(start, length, dir, map); -} +#include +#include +#include +#include "snake.h" + +#define ASSERT_RET(x, ret) \ + do{ \ + if (x) \ + return ret; \ + }while(0) + +rt_list_t snake_head; +SNAKE_DIR prevdir, newdir; + +static SNAKE_DIR dir_adjust(SNAKE_DIR dir) +{ + if ((SNAKE_DIR_UP == prevdir && SNAKE_DIR_DOWN != dir) + || (SNAKE_DIR_DOWN == prevdir && SNAKE_DIR_UP != dir) + || (SNAKE_DIR_LEFT == prevdir && SNAKE_DIR_RIGHT != dir) + || (SNAKE_DIR_RIGHT == prevdir && SNAKE_DIR_LEFT != dir) + ) + { + newdir = dir; + } + else + { + rt_kprintf("dirction change error\n\r"); + } + + return newdir; +} + +static void across_XY(point_t *node, const map_t *map) +{ + RT_ASSERT(node != RT_NULL && map != RT_NULL); + + // ȳǰ߿ԴԽǽ + node->x = (node->x + map->width) % map->width; + node->y = (node->y + map->height) % map->height; +} + +static SYS_STE node_update(snake_t *tail, const point_t *node, map_t *map) +{ + SYS_STE ret; + point_t *pos; + + RT_ASSERT(tail != RT_NULL && node != RT_NULL && map != RT_NULL); + + pos = map->snake_flush; + pos[0].x = pos[0].y = -1; + pos[1].x = pos[1].y = -1; + + ret = (SYS_STE)map->range[node->y * map->width + node->x]; + + if (FOOD == map->range[node->y * map->width + node->x]) + { + // һʳһڵ + snake_t *new = (snake_t *)rt_malloc(sizeof(snake_t)); + if (!new) + return NORMAL; + + pos[0] = *node; + new->body = *node; + rt_list_insert_after(&snake_head, &new->list); + } + else if (NORMAL == map->range[node->y * map->width + node->x]) + { + // β޸ĺõͷ + rt_list_remove(&tail->list); + map->range[tail->body.y * map->width + tail->body.x] = NORMAL; + + pos[0] = *node; + pos[1] = tail->body; + + tail->body = *node; + rt_list_insert_after(&snake_head, &tail->list); + } + + map->range[node->y * map->width + node->x] = OVER; + + if (ret != OVER) + prevdir = newdir; + + return ret; +} + + +map_t *map_init(rt_uint32_t width, rt_uint32_t heigth) +{ + map_t *map = rt_malloc(sizeof(map_t)); + + if (map != RT_NULL) + { + map->range = rt_malloc(heigth * width); + + if (!map->range) + { + rt_free(map); + map = RT_NULL; + } + else + { + map->width = width; + map->height = heigth; + memset(map->range, NORMAL, heigth * width); + } + } + + return map; +} + +// һָȵָ +rt_bool_t snake_init(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map) +{ + rt_int32_t i; + rt_int32_t inc_x, inc_y; + point_t old = *start; + + ASSERT_RET(!map || !start, RT_FALSE); + + rt_list_init(&snake_head); + + if (dir == SNAKE_DIR_UP || dir == SNAKE_DIR_DOWN) + { + if (map->height <= length) + return RT_FALSE; + + inc_x = 0; + inc_y = dir == SNAKE_DIR_DOWN ? 1 : -1; // ӳӣͷָλ + old.y -= inc_y; + } + else + { + if (map->width <= length) + return RT_FALSE; + + inc_y = 0; + inc_x = dir == SNAKE_DIR_RIGHT ? -1 : 1; + old.x -= inc_x; + } + + for (i = 0; i < length; i++) + { + snake_t *new = (snake_t *)rt_malloc(sizeof(snake_t)); + if (!new) + return RT_FALSE; + + new->body.y = inc_y + old.y; + new->body.x = inc_x + old.x; + + // ȳǰ߿ԴԽǽ + across_XY(&new->body, map); + + map->range[new->body.y * map->width + new->body.x] = OVER; + + old = new->body; + rt_list_insert_before(&snake_head, &new->list); + } + + prevdir = dir; + + return RT_TRUE; +} + +// ʳ +rt_bool_t food_init(map_t *map, rt_uint32_t max_num) +{ + point_t food; + +#ifndef FOOD_TIMEOUT +#define FOOD_TIMEOUT 10 +#endif + + rt_uint32_t timeout, num; + + ASSERT_RET(!map, RT_FALSE); + + num = 0; + timeout = rt_tick_get(); + srand(rand()); + + map->food_flush[0].x = map->food_flush[0].y = -1; + + do + { + food.x = rand() % map->width; + food.y = rand() % map->height; + + if (map->range[food.y * map->width + food.x] == NORMAL) + { + map->food_flush[0] = food; + map->range[food.y * map->width + food.x] = FOOD; + num++; + } + } + while (num < max_num && rt_tick_get() - timeout < FOOD_TIMEOUT); + + return num; +} + +void map_deinit(map_t *map) +{ + if (map) + { + if (map->range) + { + rt_free(map->range); + map->range = RT_NULL; + } + rt_free(map); + } +} + +void snake_deinit(void) +{ + snake_t *node; + + while (!rt_list_isempty(&snake_head)) + { + node = rt_list_entry(snake_head.prev, snake_t, list); + rt_list_remove(&node->list); + rt_free(node); + } +} + +void food_deinit(void) +{ + +} + +SYS_STE snake_step(SNAKE_DIR dir, map_t *map) +{ + snake_t *tail, *head; + point_t node; + + ASSERT_RET(!map, RT_FALSE); + + dir = dir_adjust(dir); + + // ȡͷβڵ㣬ڵ㲻Ҫı + tail = rt_list_entry(snake_head.prev, snake_t, list); + head = rt_list_entry(snake_head.next, snake_t, list); + + node = head->body; + + // һµͷ + switch (dir) + { + case SNAKE_DIR_UP: + case SNAKE_DIR_DOWN: + node.y = head->body.y + (dir == SNAKE_DIR_DOWN ? -1 : 1); + break; + case SNAKE_DIR_LEFT: + case SNAKE_DIR_RIGHT: + node.x = head->body.x + (dir == SNAKE_DIR_RIGHT ? 1 : -1); + break; + } + across_XY(&node, map); + + return node_update(tail, &node, map); +} + +rt_bool_t snake_restart(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map) +{ + ASSERT_RET(!map || !start, RT_FALSE); + + snake_deinit(); + memset(map->range, NORMAL, map->width * map->height); + + return snake_init(start, length, dir, map); +} diff --git a/bsp/simulator/rtgui_demo/snake/snake.h b/bsp/simulator/rtgui_demo/snake/snake.h index 46310b40e..4892ad7de 100644 --- a/bsp/simulator/rtgui_demo/snake/snake.h +++ b/bsp/simulator/rtgui_demo/snake/snake.h @@ -14,7 +14,7 @@ typedef struct { rt_int32_t x, y; -}point_t; +} point_t; typedef struct { @@ -23,7 +23,7 @@ typedef struct rt_uint8_t *range; // map, map->range[y * map->width + x] point_t snake_flush[2]; point_t food_flush[1]; -}map_t; +} map_t; typedef enum { @@ -31,23 +31,23 @@ typedef enum SNAKE_DIR_DOWN, SNAKE_DIR_LEFT, SNAKE_DIR_RIGHT -}SNAKE_DIR; +} SNAKE_DIR; typedef enum { FOOD, // Եˮ OVER, // ҧ NORMAL // ж -}SYS_STE; +} SYS_STE; typedef struct { point_t body; rt_list_t list; -}snake_t; +} snake_t; // һͼ -map_t* map_init(rt_uint32_t width, rt_uint32_t heigth); +map_t *map_init(rt_uint32_t width, rt_uint32_t heigth); // һָȵָ rt_bool_t snake_init(const point_t *start, const int length, const SNAKE_DIR dir, map_t *map); diff --git a/bsp/simulator/rtgui_demo/snake/snake_gui.c b/bsp/simulator/rtgui_demo/snake/snake_gui.c index 9425513ca..e369fecca 100644 --- a/bsp/simulator/rtgui_demo/snake/snake_gui.c +++ b/bsp/simulator/rtgui_demo/snake/snake_gui.c @@ -24,7 +24,7 @@ static rt_size_t room_size_x, room_size_y; static rt_size_t lattice_size_x, lattice_size_y; static struct rtgui_rect room_rect, lattice_rect; -map_t* map; +map_t *map; SNAKE_DIR run_state; rt_int32_t snake_len; rt_int32_t food_num; @@ -67,7 +67,7 @@ static void snake_draw(struct rtgui_widget *widget) } /* get room size, run once frist. */ - if((room_size_x == 0) || (room_size_y == 0)) + if ((room_size_x == 0) || (room_size_y == 0)) { rt_size_t tmp; @@ -133,7 +133,7 @@ static void snake_draw(struct rtgui_widget *widget) RTGUI_DC_FC(dc) = WALL_COLOR; rtgui_dc_draw_rect(dc, &rect); - for(i=1; iheight; y++) + for (y = 0; y < map->height; y++) { - for (x=0; xwidth; x++) + for (x = 0; x < map->width; x++) { switch (map->range[y * map->width + x]) { @@ -207,9 +207,9 @@ static void snake_update(struct rtgui_widget *widget) snake_fill_lattice(dc, second_node.x, second_node.y, SNAKE_COLOR); second_node = map->snake_flush[0]; - for(i=0; i<3; i++) + for (i = 0; i < 3; i++) { - if(i < 2) + if (i < 2) { x = map->snake_flush[i].x; y = map->snake_flush[i].y; @@ -220,7 +220,7 @@ static void snake_update(struct rtgui_widget *widget) y = map->food_flush[0].y; } - if((x >= 0) && (y >= 0)) + if ((x >= 0) && (y >= 0)) { switch (map->range[(map->width * y) + x]) { @@ -246,9 +246,9 @@ static void snake_update(struct rtgui_widget *widget) static void snake_handler(struct rtgui_widget *widget, rtgui_event_t *event) { - struct rtgui_event_kbd* ekbd; + struct rtgui_event_kbd *ekbd; - ekbd = (struct rtgui_event_kbd*) event; + ekbd = (struct rtgui_event_kbd *) event; if (ekbd->type == RTGUI_KEYDOWN) { switch (ekbd->key) @@ -284,38 +284,38 @@ static rt_bool_t event_handler(struct rtgui_object *object, rtgui_event_t *event if (event->type == RTGUI_EVENT_PAINT) { rt_kprintf("RTGUI_EVENT_PAINT\r\n"); - rtgui_win_event_handler((struct rtgui_object*)object, event); + rtgui_win_event_handler((struct rtgui_object *)object, event); snake_draw(widget); rtgui_timer_start(timer); } else if (event->type == RTGUI_EVENT_SHOW) { rt_kprintf("RTGUI_EVENT_SHOW\r\n"); - rtgui_win_event_handler((struct rtgui_object*)object, event); + rtgui_win_event_handler((struct rtgui_object *)object, event); snake_draw(widget); rtgui_timer_start(timer); } else if (event->type == RTGUI_EVENT_HIDE) { rt_kprintf("RTGUI_EVENT_HIDE\r\n"); - rtgui_win_event_handler((struct rtgui_object*)object, event); + rtgui_win_event_handler((struct rtgui_object *)object, event); rtgui_timer_stop(timer); } else if (event->type == RTGUI_EVENT_WIN_DEACTIVATE) { rt_kprintf("RTGUI_EVENT_WIN_DEACTIVATE\r\n"); - rtgui_win_event_handler((struct rtgui_object*)object, event); + rtgui_win_event_handler((struct rtgui_object *)object, event); rtgui_timer_stop(timer); } else if (event->type == RTGUI_EVENT_KBD) { - rtgui_win_event_handler((struct rtgui_object*)object, event); + rtgui_win_event_handler((struct rtgui_object *)object, event); snake_handler(widget, event); } else { rt_kprintf("event->type:%d\r\n", event->type); - return rtgui_win_event_handler((struct rtgui_object*)object, event); + return rtgui_win_event_handler((struct rtgui_object *)object, event); } return RT_FALSE; @@ -325,7 +325,7 @@ static void timeout(struct rtgui_timer *timer, void *parameter) { struct rtgui_widget *widget; SYS_STE ret; - + if (!map) return; @@ -355,26 +355,26 @@ static void timeout(struct rtgui_timer *timer, void *parameter) food_init(map, 1); } - + widget = RTGUI_WIDGET(parameter); snake_update(widget); } void snake_main(void) { - struct rtgui_app* application; - struct rtgui_win* win; - rtgui_rect_t rect; + struct rtgui_app *application; + struct rtgui_win *win; + rtgui_rect_t rect; application = rtgui_app_create(rt_thread_self(), "sanke_app"); if (application != RT_NULL) { - rtgui_get_screen_rect(&rect); - rtgui_set_mainwin_rect(&rect); + rtgui_get_screen_rect(&rect); + rtgui_set_mainwin_rect(&rect); win = rtgui_mainwin_create(RT_NULL, "sanke_win", RTGUI_WIN_STYLE_MAINWIN | RTGUI_WIN_STYLE_DESTROY_ON_CLOSE); - if(win == RT_NULL) + if (win == RT_NULL) { rt_kprintf("sanke_win create fail!\r\n"); return;