libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

change simulator directory organization 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2388 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
goprife@gmail.com 2012-11-04 05:49:49 +00:00
parent d0cba80c07
commit bfc30136ef
15 changed files with 54 additions and 1374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
bsp/simulator/SConscript
View File

@ -1,33 +1,12 @@
import rtconfig
Import('RTT_ROOT')
from building import *
src_bsp = ['application.c', 'startup.c', 'board.c', 'platform.c']
src_drv = ['serial.c', 'usart_sim.c']
cwd = GetCurrentDir()
objs = []
list = os.listdir(cwd)
if GetDepend('RT_USING_DFS'):
src_drv += ['sd_sim.c']
for d in list:
path = os.path.join(cwd, d)
if os.path.isfile(os.path.join(path, 'SConscript')):
objs = objs + SConscript(os.path.join(d, 'SConscript'))
if GetDepend('RT_USING_MTD_NAND'):
src_drv += ['nand_sim.c']
if GetDepend('RT_USING_MTD_NOR'):
src_drv += ['sst25vfxx_mtd_sim.c']
if GetDepend('RT_USING_RTGUI'):
src_drv += ['touch.c', 'calibration.c']
if GetDepend('RT_USING_RTGUI'):
if rtconfig.RT_USING_LCD_TYPE == 'FMT0371':
src_drv += ['lcd_a70.c']
elif rtconfig.RT_USING_LCD_TYPE == 'ILI932X':
src_drv += ['ili_lcd_general.c']
elif rtconfig.RT_USING_LCD_TYPE == 'SSD1289':
src_drv += ['ssd1289.c']
src = src_bsp + src_drv
CPPPATH = [ GetCurrentDir() ]
CPPDEFINES = []
group = DefineGroup('Startup', src, depend = [''], CPPPATH = CPPPATH, CPPDEFINES = CPPDEFINES)
Return('group')
Return('objs')

107
bsp/simulator/application.c
View File

@ -1,107 +0,0 @@
/*
* File : application.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, 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
* 2009-01-05 Bernard the first version
*/
#include <rtthread.h>
#include <stdio.h>
#include <board.h>
#include <components.h>
void rt_init_thread_entry(void* parameter)
{
/* initialization RT-Thread Components */
rt_components_init();
rt_platform_init();
/* Filesystem Initialization */
#ifdef RT_USING_DFS
{
#ifdef RT_USING_DFS_ELMFAT
/* mount sd card fat partition 1 as root directory */
if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
{
rt_kprintf("fatfs initialized!\n");
}
else
rt_kprintf("fatfs initialzation failed!\n");
#endif
#ifdef RT_USING_DFS_ELMFAT
/* mount sd card fat partition 1 as root directory */
if (dfs_mount("nand0", "/nand", "uffs", 0, 0) == 0)
{
rt_kprintf("uffs initialized!\n");
}
else
rt_kprintf("uffs initialzation failed!\n");
#endif
#ifdef RT_USING_DFS_JFFS2
/* mount sd card fat partition 1 as root directory */
if (dfs_mount("nor", "/nor", "jffs2", 0, 0) == 0)
{
rt_kprintf("jffs2 initialized!\n");
}
else
rt_kprintf("jffs2 initialzation failed!\n");
#endif
}
#endif
}
void rt_test_thread_entry(void* parameter)
{
int i;
for(i=0; i<10; i++)
{
rt_kprintf("hello, world\n");
rt_thread_delay(100);
}
}
int rt_application_init()
{
rt_thread_t tid;
tid = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX/3, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
tid = rt_thread_create("test",
rt_test_thread_entry, RT_NULL,
2048, RT_THREAD_PRIORITY_MAX * 3 /4, 20);
if (tid != RT_NULL)
rt_thread_startup(tid);
return 0;
}
#ifndef _CRT_TERMINATE_DEFINED
#define _CRT_TERMINATE_DEFINED
_CRTIMP __declspec(noreturn) void __cdecl exit(__in int _Code);
_CRTIMP __declspec(noreturn) void __cdecl _exit(__in int _Code);
_CRTIMP void __cdecl abort(void);
#endif
void rt_hw_exit(void)
{
rt_kprintf("RT-Thread, bye\n");
exit(0);
}
FINSH_FUNCTION_EXPORT_ALIAS(rt_hw_exit, exit, exit rt-thread);
/*@}*/

45
bsp/simulator/board.c
View File

@ -1,45 +0,0 @@
/*
* File : board.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009 RT-Thread Develop 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
* 2009-01-05 Bernard first implementation
*/
#include <rthw.h>
#include <rtthread.h>
#include "board.h"
/**
* @addtogroup STM32
*/
/**
* This function will initial STM32 board.
*/
void rt_hw_board_init()
{
#if 0
/* NVIC Configuration */
NVIC_Configuration();
/* Configure the SysTick */
SysTick_Config( SystemCoreClock / RT_TICK_PER_SECOND );
#endif
#if defined(RT_USING_CONSOLE)
rt_hw_usart_init();
rt_hw_serial_init();
rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
#endif
}
/*@}*/

32
bsp/simulator/board.h
View File

@ -1,32 +0,0 @@
/*
* File : board.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009, 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
* 2009-09-22 Bernard add board.h to this bsp
*/
#ifndef __BOARD_H__
#define __BOARD_H__
void rt_hw_board_led_on(int n);
void rt_hw_board_led_off(int n);
void rt_hw_board_init(void);
void rt_hw_serial_init(void);
/* SD Card init function */
void rt_hw_sdcard_init(void);
int rt_hw_mtd_nand_init(void);
int sst25vfxx_mtd_init(const char * nor_name, unsigned int block_start, unsigned int block_end);
void rt_platform_init(void);
#endif

234
bsp/simulator/nand_sim.c
View File

@ -1,234 +0,0 @@
#include <rtdevice.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dfs_def.h>
// #define NAND_TRACE rt_kprintf
#define NAND_TRACE(...)
#define NAND_SIM "nand.bin"
struct nand_device
{
struct rt_mtd_nand_device parent;
FILE * file;
};
static struct nand_device _nand;
#define NAND_DEVICE(device) (( struct nand_device*)(device))
#define PAGE_DATA_SIZE 2048 /* page data size in bytes */
#define PAGE_SPARE_SIZE 64 /* oob size in bytes */
#define BLOCK_PAGES 64 /* the number of pages in a block */
#define BLOCK_SIZE ((PAGE_DATA_SIZE + PAGE_SPARE_SIZE) * BLOCK_PAGES)
#define BLOCK_COUNT 128 /* 128 blocks == 16M */
#define BLOCK_MARK_SPARE_OFFSET 4
static rt_mutex_t lock;
/* RT-Thread device interface */
static rt_err_t k9f1g08_mtd_check_block(
struct rt_mtd_nand_device* device,
rt_uint32_t block)
{
rt_uint8_t block_status;
int result;
struct nand_device * nand;
nand = NAND_DEVICE(device);
fseek(nand->file, block * device->pages_per_block *
(device->page_size + device->oob_size) +
device->page_size + BLOCK_MARK_SPARE_OFFSET,
SEEK_SET);
result = fread(&block_status, 1, 1, nand->file);
if (result < 0)
{
NAND_TRACE("nand fread error\n");
return -RT_ERROR;
}
return block_status == 0xFF ? RT_EOK : -RT_ERROR;
}
static rt_err_t k9f1g08_mtd_mark_bad_block(
struct rt_mtd_nand_device* device,
rt_uint32_t block)
{
rt_uint8_t block_status;
int result;
struct nand_device * nand;
nand = NAND_DEVICE(device);
fseek(nand->file, block * device->pages_per_block *
(device->page_size + device->oob_size) +
device->page_size + BLOCK_MARK_SPARE_OFFSET,
SEEK_SET);
block_status = 0x00;
result = fwrite(&block_status, 1, 1, nand->file);
if (result < 0)
{
NAND_TRACE("nand fwrite error\n");
return -RT_ERROR;
}
return RT_EOK;
}
static char block_buffer[BLOCK_SIZE];
static rt_err_t k9f1g08_mtd_erase_block(
struct rt_mtd_nand_device* device,
rt_uint32_t block)
{
int result;
struct nand_device * nand;
nand = NAND_DEVICE(device);
fseek(nand->file, block * device->pages_per_block *
(device->page_size + device->oob_size),
SEEK_SET);
memset(block_buffer, 0xFF, sizeof(BLOCK_SIZE));
result = fwrite(block_buffer, BLOCK_SIZE, 1, nand->file);
if (result < 0)
{
NAND_TRACE("nand fwrite error\n");
return -RT_ERROR;
}
return RT_EOK;
}
/* return 0, ecc ok, 1, can be fixed , -1 can not be fixed */
static rt_err_t k9f1g08_mtd_read(
struct rt_mtd_nand_device * device,
rt_off_t page,
rt_uint8_t * data, rt_uint32_t data_len, //may not always be 2048
rt_uint8_t * spare, rt_uint32_t spare_len)
{
int result;
int ecc_status = 0;
struct nand_device * nand;
nand = NAND_DEVICE(device);
if (data != RT_NULL && data_len != 0)
{
fseek(nand->file, page * (device->page_size + device->oob_size),
SEEK_SET);
result = fread(data, data_len, 1, nand->file);
if (result < 0)
ecc_status = -1;
}
if (spare != RT_NULL && spare_len != 0)
{
fseek(nand->file, page * (device->page_size + device->oob_size)
+device->page_size,
SEEK_SET);
result = fread(spare, spare_len, 1, nand->file);
if (result < 0)
ecc_status = -1;
}
return ecc_status;
}
static rt_err_t k9f1g08_mtd_write (
struct rt_mtd_nand_device * device,
rt_off_t page,
const rt_uint8_t * data, rt_uint32_t data_len,//will be 2048 always!
const rt_uint8_t * spare, rt_uint32_t spare_len)
{
int result;
int ecc_status = 0;
struct nand_device * nand;
nand = NAND_DEVICE(device);
if (data != RT_NULL && data_len != 0)
{
fseek(nand->file, page * (device->page_size + device->oob_size),
SEEK_SET);
result = fwrite(data, data_len, 1, nand->file);
if (result < 0)
ecc_status = -1;
}
if (spare != RT_NULL && spare_len != 0)
{
fseek(nand->file, page * (device->page_size + device->oob_size)
+device->page_size,
SEEK_SET);
result = fwrite(spare, spare_len, 1, nand->file);
if (result < 0)
ecc_status = -1;
}
return ecc_status;
}
const static struct rt_mtd_nand_driver_ops k9f1g08_mtd_ops =
{
RT_NULL,
k9f1g08_mtd_read,
k9f1g08_mtd_write,
k9f1g08_mtd_erase_block,
k9f1g08_mtd_check_block,
k9f1g08_mtd_mark_bad_block,
};
/* interface of nand and rt-thread device */
static struct rt_mtd_nand_device nand_part[2];
int rt_hw_mtd_nand_init(void)
{
int size;
rt_uint32_t id, total_block;
struct nand_device * nand;
struct rt_mtd_nand_device * nand_part;
nand = &_nand;
nand_part = &(nand->parent);
lock = rt_mutex_create("nand", RT_IPC_FLAG_FIFO);
/* open sd card file, if not exist, then create it */
nand->file = fopen(NAND_SIM, "rb+");
if (nand->file == NULL)
{
int i;
/* create a file to simulate sd card */
nand->file = fopen(NAND_SIM, "wb+");
memset(block_buffer, 0xFF, sizeof(block_buffer));
for(i=0; i<BLOCK_COUNT; i++)
{
fseek(nand->file, i * BLOCK_SIZE, SEEK_SET);
fwrite(block_buffer, BLOCK_SIZE, 1, nand->file);
}
}
fseek(nand->file, 0, SEEK_SET);
/* the first partition of nand */
nand_part->page_size = PAGE_DATA_SIZE;
nand_part->pages_per_block = BLOCK_PAGES;//don't caculate oob size
nand_part->block_start = 0;
nand_part->block_end = BLOCK_COUNT -1;
nand_part->oob_size = PAGE_SPARE_SIZE;
nand_part->ops = &k9f1g08_mtd_ops;
rt_mtd_nand_register_device("nand0", nand_part);
return RT_EOK;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
#endif

36
bsp/simulator/platform.c
View File

@ -1,36 +0,0 @@
#include <rtthread.h>
#include "board.h"
void rt_platform_init(void)
{
#ifdef RT_USING_DFS
/* initilize sd card */
#ifdef RT_USING_DFS_ELMFAT
rt_hw_sdcard_init();
#endif
#ifdef RT_USING_MTD_NAND
rt_hw_mtd_nand_init();
#endif
#ifdef RT_USING_MTD_NOR
sst25vfxx_mtd_init("nor", 0, RT_UINT32_MAX);
#endif
#endif /* RT_USING_DFS */
#ifdef RT_USING_RTGUI
/* initilize touch panel */
rtgui_touch_hw_init("spi21");
/* initilize ra8875 lcd controller */
ra8875_init();
/* initilize key module */
rt_hw_key_init();
#endif /* RT_USING_RTGUI */
rt_thread_delay(50);
rt_device_init_all();
}

2
bsp/simulator/rtconfig.h
View File

@ -74,7 +74,7 @@
/* SECTION: Device System */
/* Using Device System */
#define RT_USING_DEVICE
#define RT_USING_SERIAL
//#define RT_USING_SERIAL
//#define RT_USING_UART1
/* SECTION: Console options */

193
bsp/simulator/sd_sim.c
View File

@ -1,193 +0,0 @@
#include <rtthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <dfs_def.h>
// #define SD_TRACE rt_kprintf
#define SD_TRACE(...)
//#define SDCARD_SIM "F:\\Project\\tools\\SDCARD"
#define SDCARD_SIM "sd.bin"
#define SDCARD_SIZE (16*1024*1024) //16M
struct sdcard_device
{
struct rt_device parent;
FILE* file;
};
static struct sdcard_device _sdcard;
#define SDCARD_DEVICE(device) (( struct sdcard_device*)(device))
static rt_mutex_t lock;
/* RT-Thread device interface */
static rt_err_t rt_sdcard_init(rt_device_t dev)
{
return RT_EOK;
}
static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t rt_sdcard_close(rt_device_t dev)
{
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)
{
struct sdcard_device * sd;
int result = 0;
SD_TRACE("sd read: pos %d, size %d\n", position, size);
rt_mutex_take(lock, RT_WAITING_FOREVER);
sd = SDCARD_DEVICE(device);
fseek(sd->file, position * SECTOR_SIZE, SEEK_SET);
result = fread(buffer, size * SECTOR_SIZE, 1, sd->file);
if (result < 0)
goto _err;
rt_mutex_release(lock);
return size;
_err:
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)
{
struct sdcard_device * sd;
int result = 0;
SD_TRACE("sst write: pos %d, size %d\n", position, size);
rt_mutex_take(lock, RT_WAITING_FOREVER);
sd = SDCARD_DEVICE(device);
fseek(sd->file, position * SECTOR_SIZE, SEEK_SET);
result = fwrite(buffer, size * SECTOR_SIZE, 1, sd->file);
if (result < 0)
goto _err;
rt_mutex_release(lock);
return size;
_err:
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;
RT_ASSERT(dev != RT_NULL);
sd = SDCARD_DEVICE(dev);
if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
{
struct rt_device_blk_geometry *geometry;
geometry = (struct rt_device_blk_geometry *)args;
if (geometry == RT_NULL) return -RT_ERROR;
geometry->bytes_per_sector = SECTOR_SIZE;
geometry->block_size = SECTOR_SIZE;
fseek(sd->file, 0, SEEK_END);
size = ftell(sd->file);
geometry->sector_count = size/SECTOR_SIZE;
}
return RT_EOK;
}
rt_err_t rt_hw_sdcard_init(const char * spi_device_name)
{
int size;
rt_uint32_t id, total_block;
struct sdcard_device * sd;
struct rt_device * device;
sd = &_sdcard;
device = &(sd->parent);
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+");
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;
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);
for(i=0; i<(SDCARD_SIZE / (1024*1024)); i++)
fwrite(ptr, 1024 * 1024, 1, sd->file);
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;
rt_device_register(device, "sd0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
return RT_EOK;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
void eraseall(void)
{
printf("had not implemented yet!\n");
}
FINSH_FUNCTION_EXPORT(eraseall, erase all block in SPI flash);
#endif

161
bsp/simulator/serial.c
View File

@ -1,161 +0,0 @@
/*
******************************************************************************
* By : parai
* email:parai@foxmail.com
* 这并不是一个真的串口设备，只是为了能够让内核打印信息而创建
******************************************************************************
*/
#include "rtthread.h"
#define _DEBUG_SERIAL 0
#include "serial.h"
#include <stdio.h>
struct rt_device serial_device;
extern struct serial_int_rx serial_rx;
/*@{*/
/* RT-Thread Device Interface */
/**
* This function initializes serial
*/
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;
}
dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
}
return RT_EOK;
}
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");
#endif
return RT_EOK;
}
static rt_err_t rt_serial_close(rt_device_t dev)
{
#if _DEBUG_SERIAL==1
printf("in rt_serial_close()\n");
#endif
return RT_EOK;
}
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;
ptr = buffer;
err_code = RT_EOK;
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{
/* interrupt mode Rx */
while (size)
{
rt_base_t level;
/* 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--;
/* 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);
}
}
/* 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)
{
#if _DEBUG_SERIAL==1
printf("in rt_serial_write()\n");
#endif
printf("%s",(char*)buffer);
return size;
}
static rt_err_t rt_serial_control (rt_device_t dev, rt_uint8_t cmd, void *args)
{
RT_ASSERT(dev != RT_NULL);
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;
}
return RT_EOK;
}
/*
* serial register
*/
static rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_uint32_t flag)
{
RT_ASSERT(device != RT_NULL);
#if _DEBUG_SERIAL==1
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;
/* 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,"sci0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM);
}

22
bsp/simulator/serial.h
View File

@ -1,22 +0,0 @@
/*
*********************************************************************************************************
* MC9S12DP256/DG128 Specific code
* BANKED MEMORY MODEL
*
* File : rthw.c
* By : parai
* email:parai@foxmail.com
*******************************************************************************************************/
#ifndef __RT_HW_SERIAL_H__
#define __RT_HW_SERIAL_H__
#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_err_t rt_hw_serial_init(void);
#endif

24
bsp/simulator/sst25vfxx_mtd.h
View File

@ -1,24 +0,0 @@
/*
* 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
#include <rtthread.h>
#include <drivers/spi.h>
rt_err_t sst25vfxx_mtd_init(const char *spi_device_name, rt_uint32_t block_start, rt_uint32_t block_end);
#endif

228
bsp/simulator/sst25vfxx_mtd_sim.c
View File

@ -1,228 +0,0 @@
/*
* File : rtdef.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, 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
* 2012-10-21 prife the first version
*/
#include <rtdevice.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "sst25vfxx_mtd.h"
#ifdef RT_USING_MTD_NOR
#define NOR_SIM "nor.bin"
/* JEDEC Manufacturer¡¯s ID */
#define MF_ID (0xBF)
/* JEDEC Device ID : Memory Type */
#define MT_ID (0x25)
/* JEDEC Device ID: Memory Capacity */
#define MC_ID_SST25VF016 (0x41)
#define MC_ID_SST25VF032 (0x4A)
#define MC_ID_SST25VF064 (0x4B)
#define BLOCK_SIZE (64*1024)
#define SST25_MTD(device) ((struct sst25_mtd*)(device))
struct sst25_mtd
{
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)
{
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];
}
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;
sst25 = SST25_MTD(device);
RT_ASSERT(sst25 != RT_NULL);
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");
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)
{
struct sst25_mtd *sst25;
int result;
sst25 = SST25_MTD(device);
RT_ASSERT(sst25 != RT_NULL);
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");
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)
{
struct sst25_mtd *sst25;
int result;
sst25 = SST25_MTD(device);
RT_ASSERT(sst25 != RT_NULL);
rt_mutex_take(&flash_lock, RT_WAITING_FOREVER);
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");
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,
};
static rt_err_t sst25vfxx_hw_init(struct sst25_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_uint32_t id, total_block;
struct sst25_mtd * sst25;
struct rt_mtd_nor_device *mtd;
sst25 = &_sst25_mtd;
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");
}
/* initialize flash */
id = sst25vfxx_read_id(mtd);
switch (id & 0xff)
{
case MC_ID_SST25VF016:
total_block = (16 * 1024 * 1024 / 8) / mtd->block_size;
break;
case MC_ID_SST25VF032:
total_block = (32 * 1024 * 1024 / 8) / mtd->block_size;
break;
case MC_ID_SST25VF064:
total_block = (64 * 1024 * 1024 / 8) / mtd->block_size;
break;
default:
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;
}
else if (block_end > total_block)
{
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+");
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);
/* initialize hardware */
sst25vfxx_hw_init(&_sst25_mtd);
/* register MTD device */
rt_mtd_nor_register_device("nor", mtd);
return RT_EOK;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
void nor_erase(void)
{
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);
}
}
FINSH_FUNCTION_EXPORT(nor_erase, erase all block in SPI flash);
#endif
#endif

102
bsp/simulator/startup.c
View File

@ -1,102 +0,0 @@
/*
* File : startup.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Develop Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://openlab.rt-thread.com/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2012-09-03 prife first implementation
*/
#include <rthw.h>
#include <rtthread.h>
#include "board.h"
/**
* @addtogroup win32
*/
#define HEAP_SIZE (1024*1024*10)
static rt_uint8_t * heap;
void vs_heap_init(void)
{
heap = malloc(HEAP_SIZE);
if (heap == RT_NULL)
rt_kprintf("there is no memory in pc.");
}
/*@{*/
extern int rt_application_init(void);
#ifdef RT_USING_FINSH
extern void finsh_system_init(void);
extern void finsh_set_device(const char* device);
#endif
/**
* This function will startup RT-Thread RTOS.
*/
void rtthread_startup(void)
{
/* init board */
rt_hw_board_init();
/* show version */
rt_show_version();
/* init tick */
rt_system_tick_init();
/* init kernel object */
rt_system_object_init();
/* init timer system */
rt_system_timer_init();
#ifdef RT_USING_HEAP
/* init memory system */
#if (MSVC)
vs_heap_init();
#endif
rt_system_heap_init((void*)heap, (void*)&heap[HEAP_SIZE-1]);
#endif
/* init scheduler system */
rt_system_scheduler_init();
/* init all device */
#ifdef RT_USING_DEVICE
rt_device_init_all();
#endif
/* init application */
rt_application_init();
/* init timer thread */
rt_system_timer_thread_init();
/* init idle thread */
rt_thread_idle_init();
/* start scheduler */
rt_system_scheduler_start();
/* never reach here */
return ;
}
int main(void)
{
/* disable interrupt first */
rt_hw_interrupt_disable();
/* startup RT-Thread RTOS */
rtthread_startup();
return 0;
}
/*@}*/

131
bsp/simulator/usart_sim.c
View File

@ -1,131 +0,0 @@
#include <rtthread.h>
#include <windows.h>
#include <mmsystem.h>
#include <stdio.h>
#include "serial.h"
struct serial_int_rx serial_rx;
extern struct rt_device serial_device;
/*
* Handler for OSKey Thread
*/
static HANDLE OSKey_Thread;
static DWORD OSKey_ThreadID;
static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam);
void rt_hw_usart_init(void)
{
/*
* 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)
{
//Display Error Message
return;
}
SetThreadPriority(OSKey_Thread,
THREAD_PRIORITY_NORMAL);
SetThreadPriorityBoost(OSKey_Thread,
TRUE);
SetThreadAffinityMask(OSKey_Thread,
0x01);
/*
* Start OS get key Thread
*/
ResumeThread(OSKey_Thread);
}
/*
* 方向键(←)： 0xe04b
* 方向键(↑)： 0xe048
* 方向键(→)： 0xe04d
* 方向键(↓)： 0xe050
*/
static int savekey(unsigned char key)
{
/* save on rx buffer */
{
rt_base_t level;
/* disable interrupt */
//暂时关闭中断，因为要操作uart数据结构
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_index追上了read_index，则增大read_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;
}
/* enable interrupt */
//uart数据结构已经操作完成，重新使能中断
rt_hw_interrupt_enable(level);
}
/* 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;
serial_device.rx_indicate(&serial_device, rx_length);
}
return 0;
}
static DWORD WINAPI ThreadforKeyGet(LPVOID lpParam)
{
unsigned char key;
(void)lpParam; //prevent compiler warnings
for(;;)
{
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);
}
continue;
}
savekey(key);
}
} /*** ThreadforKeyGet ***/

74
bsp/simulator/vs2005.vcproj
View File

@ -40,7 +40,7 @@
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".\;..\..\include;..\..\bsp\vs2008;..\..\components\finsh;..\..\components\dfs\include;..\..\components\dfs\filesystems\uffs\src\inc\;..\..\components\dfs\filesystems\uffs;..\..\components\drivers\include;..\..\components\dfs\filesystems\jffs2\src;..\..\components\dfs\filesystems\jffs2\kernel;..\..\components\dfs\filesystems\jffs2\include;..\..\components\dfs\filesystems\jffs2\;..\..\components\dfs\filesystems\jffs2\cyg\compress;..\..\components\init"
AdditionalIncludeDirectories=".\;..\..\include;..\..\bsp\vs2008;..\..\components\finsh;..\..\components\dfs\include;..\..\components\dfs\filesystems\uffs\src\inc\;..\..\components\dfs\filesystems\uffs;..\..\components\drivers\include;..\..\components\dfs\filesystems\jffs2\src;..\..\components\dfs\filesystems\jffs2\kernel;..\..\components\dfs\filesystems\jffs2\include;..\..\components\dfs\filesystems\jffs2\;..\..\components\dfs\filesystems\jffs2\cyg\compress;..\..\components\init;.\drivers"
PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;MSVC;_TIME_T_DEFINED"
MinimalRebuild="true"
BasicRuntimeChecks="3"
@ -245,42 +245,18 @@
</File>
</Filter>
<Filter
Name="board"
Name="app"
>
<File
RelativePath=".\application.c"
RelativePath=".\applications\application.c"
>
</File>
<File
RelativePath=".\board.c"
RelativePath=".\applications\platform.c"
>
</File>
<File
RelativePath=".\nand_sim.c"
>
</File>
<File
RelativePath=".\platform.c"
>
</File>
<File
RelativePath=".\sd_sim.c"
>
</File>
<File
RelativePath=".\serial.c"
>
</File>
<File
RelativePath=".\sst25vfxx_mtd_sim.c"
>
</File>
<File
RelativePath=".\startup.c"
>
</File>
<File
RelativePath=".\usart_sim.c"
RelativePath=".\applications\startup.c"
>
</File>
</Filter>
@ -716,6 +692,46 @@
</File>
</Filter>
</Filter>
<Filter
Name="driver"
>
<File
RelativePath=".\drivers\board.c"
>
</File>
<File
RelativePath=".\drivers\board.h"
>
</File>
<File
RelativePath=".\drivers\nand_sim.c"
>
</File>
<File
RelativePath=".\drivers\sd_sim.c"
>
</File>
<File
RelativePath=".\drivers\serial.c"
>
</File>
<File
RelativePath=".\drivers\serial.h"
>
</File>
<File
RelativePath=".\drivers\sst25vfxx_mtd.h"
>
</File>
<File
RelativePath=".\drivers\sst25vfxx_mtd_sim.c"
>
</File>
<File
RelativePath=".\drivers\usart_sim.c"
>
</File>
</Filter>
</Filter>
<Filter
Name="Header Files"