Skip to content

R
rt-thread

u010088926 / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 17857917 编写于 作者: B bernard.xiong@gmail.com
浏览文件
操作

Change source code to UNIX end of line 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1743 bbd45198-f89e-11dd-88c7-29a3b14d5316
上级 73a11703
展开全部 隐藏空白更改
内联 并排
Showing with 1991 addition and 1991 deletion
bsp/fm3/mb9bf506r/SConscript
浏览文件 @ 17857917
import rtconfig import rtconfig
Import('RTT_ROOT') Import('RTT_ROOT')
from building import * from building import *
src_bsp = ['application.c', 'startup.c', 'board.c', 'led.c', 'console.c'] src_bsp = ['application.c', 'startup.c', 'board.c', 'led.c', 'console.c']
src_drv = ['serial.c', 'nand.c'] src_drv = ['serial.c', 'nand.c']
if GetDepend('RT_USING_RTGUI'): if GetDepend('RT_USING_RTGUI'):
src_drv += ['info.c'] src_drv += ['info.c']
src = src_bsp + src_drv src = src_bsp + src_drv
CPPPATH = [GetCurrentDir()] CPPPATH = [GetCurrentDir()]
CPPDEFINES = [] CPPDEFINES = []
group = DefineGroup('Startup', src, depend = [''], CPPPATH = CPPPATH, CPPDEFINES = CPPDEFINES) group = DefineGroup('Startup', src, depend = [''], CPPPATH = CPPPATH, CPPDEFINES = CPPDEFINES)
Return('group') Return('group')
bsp/fm3/mb9bf506r/SConstruct
浏览文件 @ 17857917
import os import os
import sys import sys
import rtconfig import rtconfig
if os.getenv('RTT_ROOT'): if os.getenv('RTT_ROOT'):
RTT_ROOT = os.getenv('RTT_ROOT') RTT_ROOT = os.getenv('RTT_ROOT')
else: else:
RTT_ROOT = os.path.normpath(os.getcwd() + '/../../..') RTT_ROOT = os.path.normpath(os.getcwd() + '/../../..')
sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')] sys.path = sys.path + [os.path.join(RTT_ROOT, 'tools')]
from building import * from building import *
TARGET = 'rtthread.' + rtconfig.TARGET_EXT TARGET = 'rtthread.' + rtconfig.TARGET_EXT
env = Environment(tools = ['mingw'], env = Environment(tools = ['mingw'],
AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS, AS = rtconfig.AS, ASFLAGS = rtconfig.AFLAGS,
CC = rtconfig.CC, CCFLAGS = rtconfig.CFLAGS, CC = rtconfig.CC, CCFLAGS = rtconfig.CFLAGS,
AR = rtconfig.AR, ARFLAGS = '-rc', AR = rtconfig.AR, ARFLAGS = '-rc',
LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS) LINK = rtconfig.LINK, LINKFLAGS = rtconfig.LFLAGS)
env.PrependENVPath('PATH', rtconfig.EXEC_PATH) env.PrependENVPath('PATH', rtconfig.EXEC_PATH)
if rtconfig.PLATFORM == 'iar': if rtconfig.PLATFORM == 'iar':
env.Replace(CCCOM = ['$CC $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -o $TARGET $SOURCES']) env.Replace(CCCOM = ['$CC $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -o $TARGET $SOURCES'])
env.Replace(LINKCOM = ['$LINK $SOURCES $LINKFLAGS -o $TARGET --map project.map']) env.Replace(LINKCOM = ['$LINK $SOURCES $LINKFLAGS -o $TARGET --map project.map'])
env.Replace(ARFLAGS = '') env.Replace(ARFLAGS = '')
Export('RTT_ROOT') Export('RTT_ROOT')
Export('rtconfig') Export('rtconfig')
# prepare building environment # prepare building environment
objs = PrepareBuilding(env, RTT_ROOT) objs = PrepareBuilding(env, RTT_ROOT)
objs = objs + SConscript('../CMSIS/SConscript', variant_dir='build/bsp/Libraries', duplicate=0) objs = objs + SConscript('../CMSIS/SConscript', variant_dir='build/bsp/Libraries', duplicate=0)
# build program # build program
env.Program(TARGET, objs) env.Program(TARGET, objs)
# end building # end building
EndBuilding(TARGET) EndBuilding(TARGET)
bsp/fm3/mb9bf506r/application.c
浏览文件 @ 17857917
/* /*
* File : application.c * File : application.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009 - 2011, RT-Thread Development Team * COPYRIGHT (C) 2009 - 2011, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-05-24 Bernard the first version * 2011-05-24 Bernard the first version
*/ */
/** /**
* @addtogroup FM3 * @addtogroup FM3
*/ */
/*@{*/ /*@{*/
#include <rtthread.h> #include <rtthread.h>
#include "board.h" #include "board.h"
#include "led.h" #include "led.h"
#ifdef RT_USING_DFS #ifdef RT_USING_DFS
/* dfs init */ /* dfs init */
#include <dfs_init.h> #include <dfs_init.h>
/* dfs filesystem:ELM filesystem init */ /* dfs filesystem:ELM filesystem init */
#include <dfs_elm.h> #include <dfs_elm.h>
/* dfs Filesystem APIs */ /* dfs Filesystem APIs */
#include <dfs_fs.h> #include <dfs_fs.h>
#endif #endif
void rt_init_thread_entry(void *parameter) void rt_init_thread_entry(void *parameter)
{ {
/* Filesystem Initialization */ /* Filesystem Initialization */
#ifdef RT_USING_DFS #ifdef RT_USING_DFS
{ {
/* init the device filesystem */ /* init the device filesystem */
dfs_init(); dfs_init();
#ifdef RT_USING_DFS_ELMFAT #ifdef RT_USING_DFS_ELMFAT
/* init the elm chan FatFs filesystam*/ /* init the elm chan FatFs filesystam*/
elm_init(); elm_init();
/* mount ELM FatFs on NAND flash as root directory */ /* mount ELM FatFs on NAND flash as root directory */
if (dfs_mount("nand", "/", "elm", 0, 0) == 0) if (dfs_mount("nand", "/", "elm", 0, 0) == 0)
{ {
rt_kprintf("File System initialized!\n"); rt_kprintf("File System initialized!\n");
} }
else else
rt_kprintf("File System initialzation failed!\n"); rt_kprintf("File System initialzation failed!\n");
#endif #endif
} }
#endif #endif
/* LED Initialization */ /* LED Initialization */
rt_hw_led_init(); rt_hw_led_init();
} }
int rt_application_init() int rt_application_init()
{ {
rt_thread_t tid; rt_thread_t tid;
tid = rt_thread_create("init", tid = rt_thread_create("init",
rt_init_thread_entry, RT_NULL, rt_init_thread_entry, RT_NULL,
2048, 8, 20); 2048, 8, 20);
if (tid != RT_NULL) rt_thread_startup(tid); if (tid != RT_NULL) rt_thread_startup(tid);
return 0; return 0;
} }
/*@}*/ /*@}*/
bsp/fm3/mb9bf506r/board.c
浏览文件 @ 17857917
/* /*
* File : board.c * File : board.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009 - 2011 RT-Thread Develop Team * COPYRIGHT (C) 2009 - 2011 RT-Thread Develop Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-02-24 Bernard first implementation * 2011-02-24 Bernard first implementation
*/ */
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#include "board.h" #include "board.h"
#include "mb9bf506r.h" #include "mb9bf506r.h"
#include "serial.h" #include "serial.h"
#include "nand.h" #include "nand.h"
extern const uint32_t SystemFrequency; extern const uint32_t SystemFrequency;
/** /**
* @addtogroup FM3 * @addtogroup FM3
*/ */
/*@{*/ /*@{*/
/** /**
* This is the timer interrupt service routine. * This is the timer interrupt service routine.
* *
*/ */
void rt_hw_timer_handler(void) void rt_hw_timer_handler(void)
{ {
/* enter interrupt */ /* enter interrupt */
rt_interrupt_enter(); rt_interrupt_enter();
rt_tick_increase(); rt_tick_increase();
/* leave interrupt */ /* leave interrupt */
rt_interrupt_leave(); rt_interrupt_leave();
} }
/** /**
* This function will initial FM3 Easy Kit board. * This function will initial FM3 Easy Kit board.
*/ */
void rt_hw_board_init() void rt_hw_board_init()
{ {
/* init systick */ /* init systick */
SysTick_Config(SystemFrequency/RT_TICK_PER_SECOND); SysTick_Config(SystemFrequency/RT_TICK_PER_SECOND);
/* initialize UART device */ /* initialize UART device */
rt_hw_serial_init(); rt_hw_serial_init();
/* set console as UART device */ /* set console as UART device */
rt_console_set_device("uart2"); rt_console_set_device("uart2");
/* initialize nand flash device */ /* initialize nand flash device */
rt_hw_nand_init(); rt_hw_nand_init();
} }
/*@}*/ /*@}*/
bsp/fm3/mb9bf506r/board.h
浏览文件 @ 17857917
/* /*
* File : board.h * File : board.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009, RT-Thread Development Team * COPYRIGHT (C) 2009, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2009-09-22 Bernard add board.h to this bsp * 2009-09-22 Bernard add board.h to this bsp
* 2011-03-04 lgnq add board.h to FM3 bsp * 2011-03-04 lgnq add board.h to FM3 bsp
*/ */
#ifndef __BOARD_H__ #ifndef __BOARD_H__
#define __BOARD_H__ #define __BOARD_H__
#include "serial.h" #include "serial.h"
//Internal SRAM memory size[Kbytes] <8-64> //Internal SRAM memory size[Kbytes] <8-64>
//MB9BF500 : 32 //MB9BF500 : 32
//MB9BF504 : 32 //MB9BF504 : 32
//MB9BF505 : 48 //MB9BF505 : 48
//MB9BF506 : 64 //MB9BF506 : 64
#define FM3_SRAM_SIZE 64 #define FM3_SRAM_SIZE 64
#define FM3_SRAM_END (0x1FFF8000 + FM3_SRAM_SIZE * 1024) #define FM3_SRAM_END (0x1FFF8000 + FM3_SRAM_SIZE * 1024)
void rt_hw_board_init(void); void rt_hw_board_init(void);
#endif #endif
bsp/fm3/mb9bf506r/console.c
浏览文件 @ 17857917
#include <rtthread.h> #include <rtthread.h>
#include <serial.h> #include <serial.h>
#define RT_CONSOLE_WIDTH 240 #define RT_CONSOLE_WIDTH 240
#define RT_CONSOLE_HEIGHT 320 #define RT_CONSOLE_HEIGHT 320
#define RT_CONSOLE_FONT_WIDTH 8 #define RT_CONSOLE_FONT_WIDTH 8
#define RT_CONSOLE_FONT_HEIGHT 16 #define RT_CONSOLE_FONT_HEIGHT 16
#define RT_CONSOLE_COL (RT_CONSOLE_WIDTH/RT_CONSOLE_FONT_WIDTH) #define RT_CONSOLE_COL (RT_CONSOLE_WIDTH/RT_CONSOLE_FONT_WIDTH)
#define RT_CONSOLE_ROW (RT_CONSOLE_HEIGHT/RT_CONSOLE_FONT_HEIGHT) #define RT_CONSOLE_ROW (RT_CONSOLE_HEIGHT/RT_CONSOLE_FONT_HEIGHT)
#define RT_CONSOLE_TAB 4 #define RT_CONSOLE_TAB 4
#define RT_CONSOLE_FOREPIXEL (0x001f) #define RT_CONSOLE_FOREPIXEL (0x001f)
extern struct serial_device uart2; extern struct serial_device uart2;
struct rt_console struct rt_console
{ {
rt_uint8_t* video_ptr; rt_uint8_t* video_ptr;
rt_uint8_t* font_ptr; rt_uint8_t* font_ptr;
/* bpp and pixel of width */ /* bpp and pixel of width */
rt_uint8_t bpp; rt_uint8_t bpp;
rt_uint32_t pitch; rt_uint32_t pitch;
/* current cursor */ /* current cursor */
rt_uint8_t current_col; rt_uint8_t current_col;
rt_uint8_t current_row; rt_uint8_t current_row;
}; };
struct rt_console console; struct rt_console console;
void rt_hw_console_init(rt_uint8_t* video_ptr, rt_uint8_t* font_ptr, rt_uint8_t bpp); void rt_hw_console_init(rt_uint8_t* video_ptr, rt_uint8_t* font_ptr, rt_uint8_t bpp);
void rt_hw_console_newline(void); void rt_hw_console_newline(void);
void rt_hw_console_putc(char c); void rt_hw_console_putc(char c);
void rt_hw_console_clear(void); void rt_hw_console_clear(void);
void rt_hw_console_init(rt_uint8_t* video_ptr, rt_uint8_t* font_ptr, rt_uint8_t bpp) void rt_hw_console_init(rt_uint8_t* video_ptr, rt_uint8_t* font_ptr, rt_uint8_t bpp)
{ {
rt_memset(&console, 0, sizeof(struct rt_console)); rt_memset(&console, 0, sizeof(struct rt_console));
console.video_ptr = video_ptr; console.video_ptr = video_ptr;
console.font_ptr = font_ptr; console.font_ptr = font_ptr;
console.bpp = bpp; console.bpp = bpp;
console.pitch = console.bpp * RT_CONSOLE_WIDTH; console.pitch = console.bpp * RT_CONSOLE_WIDTH;
rt_hw_console_clear(); rt_hw_console_clear();
} }
void rt_hw_console_putc(char c) void rt_hw_console_putc(char c)
{ {
switch (c) switch (c)
{ {
case 10: case 10:
case 11: case 11:
case 12: case 12:
case 13: case 13:
/* to next line */ /* to next line */
rt_hw_console_newline(); rt_hw_console_newline();
console.current_col = 0; console.current_col = 0;
break; break;
case 9: case 9:
console.current_col += RT_CONSOLE_TAB; console.current_col += RT_CONSOLE_TAB;
break; break;
default: default:
{ {
rt_uint8_t* font_ptr; rt_uint8_t* font_ptr;
register rt_uint32_t cursor; register rt_uint32_t cursor;
register rt_uint32_t i, j; register rt_uint32_t i, j;
if (console.current_col == RT_CONSOLE_COL) if (console.current_col == RT_CONSOLE_COL)
{ {
rt_hw_console_newline(); rt_hw_console_newline();
console.current_col = 0; console.current_col = 0;
rt_hw_console_putc(c); rt_hw_console_putc(c);
return; return;
} }
font_ptr = console.font_ptr + c * RT_CONSOLE_FONT_HEIGHT; font_ptr = console.font_ptr + c * RT_CONSOLE_FONT_HEIGHT;
cursor = (console.current_row * RT_CONSOLE_FONT_HEIGHT) * console.pitch cursor = (console.current_row * RT_CONSOLE_FONT_HEIGHT) * console.pitch
+ console.current_col * RT_CONSOLE_FONT_WIDTH * console.bpp; + console.current_col * RT_CONSOLE_FONT_WIDTH * console.bpp;
for (i = 0; i < RT_CONSOLE_FONT_HEIGHT; i ++ ) for (i = 0; i < RT_CONSOLE_FONT_HEIGHT; i ++ )
{ {
for (j = 0; j < RT_CONSOLE_FONT_WIDTH; j ++) for (j = 0; j < RT_CONSOLE_FONT_WIDTH; j ++)
{ {
if ( ((font_ptr[i] >> (7-j)) & 0x01) != 0 ) if ( ((font_ptr[i] >> (7-j)) & 0x01) != 0 )
{ {
/* draw a pixel */ /* draw a pixel */
rt_uint8_t *ptr = &(console.video_ptr[cursor + i * console.pitch + j * console.bpp]); rt_uint8_t *ptr = &(console.video_ptr[cursor + i * console.pitch + j * console.bpp]);
switch(console.bpp) switch(console.bpp)
{ {
case 1: case 1:
*ptr = RT_CONSOLE_FOREPIXEL; *ptr = RT_CONSOLE_FOREPIXEL;
break; break;
case 2: case 2:
*(rt_uint16_t*)ptr = RT_CONSOLE_FOREPIXEL; *(rt_uint16_t*)ptr = RT_CONSOLE_FOREPIXEL;
break; break;
case 3: case 3:
ptr[0] = RT_CONSOLE_FOREPIXEL & 0xff; ptr[0] = RT_CONSOLE_FOREPIXEL & 0xff;
ptr[1] = (RT_CONSOLE_FOREPIXEL >> 8) & 0xff; ptr[1] = (RT_CONSOLE_FOREPIXEL >> 8) & 0xff;
ptr[2] = (RT_CONSOLE_FOREPIXEL >> 16) & 0xff; ptr[2] = (RT_CONSOLE_FOREPIXEL >> 16) & 0xff;
break; break;
case 4: case 4:
*(rt_uint32_t*)ptr = RT_CONSOLE_FOREPIXEL; *(rt_uint32_t*)ptr = RT_CONSOLE_FOREPIXEL;
break; break;
} }
} }
} }
} }
console.current_col ++; console.current_col ++;
} }
break; break;
} }
} }
void rt_hw_console_newline() void rt_hw_console_newline()
{ {
console.current_row ++; console.current_row ++;
if (console.current_row >= RT_CONSOLE_ROW) if (console.current_row >= RT_CONSOLE_ROW)
{ {
rt_uint32_t i; rt_uint32_t i;
/* scroll to next line */ /* scroll to next line */
for (i = 0; i < RT_CONSOLE_ROW - 1; i ++) for (i = 0; i < RT_CONSOLE_ROW - 1; i ++)
{ {
rt_memcpy(console.video_ptr + i * RT_CONSOLE_FONT_HEIGHT * console.pitch, rt_memcpy(console.video_ptr + i * RT_CONSOLE_FONT_HEIGHT * console.pitch,
console.video_ptr + (i + 1) * RT_CONSOLE_FONT_HEIGHT * console.pitch, console.video_ptr + (i + 1) * RT_CONSOLE_FONT_HEIGHT * console.pitch,
RT_CONSOLE_FONT_HEIGHT * console.pitch); RT_CONSOLE_FONT_HEIGHT * console.pitch);
} }
/* clear last line */ /* clear last line */
rt_memset(console.video_ptr + (RT_CONSOLE_ROW - 1) * RT_CONSOLE_FONT_HEIGHT * console.pitch, rt_memset(console.video_ptr + (RT_CONSOLE_ROW - 1) * RT_CONSOLE_FONT_HEIGHT * console.pitch,
0, 0,
RT_CONSOLE_FONT_HEIGHT * console.pitch); RT_CONSOLE_FONT_HEIGHT * console.pitch);
console.current_row = RT_CONSOLE_ROW - 1; console.current_row = RT_CONSOLE_ROW - 1;
} }
} }
void rt_hw_console_clear() void rt_hw_console_clear()
{ {
console.current_col = 0; console.current_col = 0;
console.current_row = 0; console.current_row = 0;
rt_memset(console.video_ptr, 0, RT_CONSOLE_HEIGHT * console.pitch); rt_memset(console.video_ptr, 0, RT_CONSOLE_HEIGHT * console.pitch);
} }
/* write one character to serial, must not trigger interrupt */ /* write one character to serial, must not trigger interrupt */
void rt_hw_serial_putc(const char c) void rt_hw_serial_putc(const char c)
{ {
/* /*
to be polite with serial console add a line feed to be polite with serial console add a line feed
to the carriage return character to the carriage return character
*/ */
if (c=='\n')rt_hw_serial_putc('\r'); if (c=='\n')rt_hw_serial_putc('\r');
while (!(uart2.uart_device->SSR & SSR_TDRE)); while (!(uart2.uart_device->SSR & SSR_TDRE));
uart2.uart_device->TDR = (c & 0x1FF); uart2.uart_device->TDR = (c & 0x1FF);
} }
/** /**
* This function is used by rt_kprintf to display a string on console. * This function is used by rt_kprintf to display a string on console.
* *
* @param str the displayed string * @param str the displayed string
*/ */
void rt_hw_console_output(const char* str) void rt_hw_console_output(const char* str)
{ {
while (*str) while (*str)
{ {
rt_hw_serial_putc(*str++); rt_hw_serial_putc(*str++);
} }
} }
bsp/fm3/mb9bf506r/led.c
浏览文件 @ 17857917
/* /*
* File : led.c * File : led.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Develop Team * COPYRIGHT (C) 2011, RT-Thread Develop Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-03-03 lgnq * 2011-03-03 lgnq
*/ */
#include <rtthread.h> #include <rtthread.h>
#include <rthw.h> #include <rthw.h>
#include "mb9bf506r.h" #include "mb9bf506r.h"
#include "led.h" #include "led.h"
void rt_hw_led_on(rt_uint8_t num) void rt_hw_led_on(rt_uint8_t num)
{ {
RT_ASSERT(num < LEDS_MAX_NUMBER); RT_ASSERT(num < LEDS_MAX_NUMBER);
switch (num) switch (num)
{ {
case 1: case 1:
USER_LED_PDOR &= ~USER_LED1; USER_LED_PDOR &= ~USER_LED1;
break; break;
case 2: case 2:
USER_LED_PDOR &= ~USER_LED2; USER_LED_PDOR &= ~USER_LED2;
break; break;
case 3: case 3:
USER_LED_PDOR &= ~USER_LED3; USER_LED_PDOR &= ~USER_LED3;
break; break;
default: default:
break; break;
} }
} }
void rt_hw_led_off(rt_uint8_t num) void rt_hw_led_off(rt_uint8_t num)
{ {
RT_ASSERT(num < LEDS_MAX_NUMBER); RT_ASSERT(num < LEDS_MAX_NUMBER);
switch (num) switch (num)
{ {
case 1: case 1:
USER_LED_PDOR |= USER_LED1; USER_LED_PDOR |= USER_LED1;
break; break;
case 2: case 2:
USER_LED_PDOR |= USER_LED2; USER_LED_PDOR |= USER_LED2;
break; break;
case 3: case 3:
USER_LED_PDOR |= USER_LED3; USER_LED_PDOR |= USER_LED3;
break; break;
default: default:
break; break;
} }
} }
void rt_hw_led_toggle(rt_uint8_t num) void rt_hw_led_toggle(rt_uint8_t num)
{ {
RT_ASSERT(num < LEDS_MAX_NUMBER); RT_ASSERT(num < LEDS_MAX_NUMBER);
switch (num) switch (num)
{ {
case 1: case 1:
if (USER_LED_PDOR&USER_LED1) if (USER_LED_PDOR&USER_LED1)
USER_LED_PDOR &= ~USER_LED1; USER_LED_PDOR &= ~USER_LED1;
else else
USER_LED_PDOR |= USER_LED1; USER_LED_PDOR |= USER_LED1;
break; break;
case 2: case 2:
if (USER_LED_PDOR&USER_LED2) if (USER_LED_PDOR&USER_LED2)
USER_LED_PDOR &= ~USER_LED2; USER_LED_PDOR &= ~USER_LED2;
else else
USER_LED_PDOR |= USER_LED2; USER_LED_PDOR |= USER_LED2;
break; break;
case 3: case 3:
if (USER_LED_PDOR&USER_LED3) if (USER_LED_PDOR&USER_LED3)
USER_LED_PDOR &= ~USER_LED3; USER_LED_PDOR &= ~USER_LED3;
else else
USER_LED_PDOR |= USER_LED3; USER_LED_PDOR |= USER_LED3;
break; break;
default: default:
break; break;
} }
} }
void led_init(void) void led_init(void)
{ {
/*Select CPIO function*/ /*Select CPIO function*/
USER_LED_PFR &= ~USER_LED_MASK; USER_LED_PFR &= ~USER_LED_MASK;
/* disable analog input */ /* disable analog input */
FM3_GPIO->ADE &= ~USER_LED_MASK; FM3_GPIO->ADE &= ~USER_LED_MASK;
/*Set CPIO Pull-Up function*/ /*Set CPIO Pull-Up function*/
USER_LED_PCR |= USER_LED_MASK; USER_LED_PCR |= USER_LED_MASK;
/*Make led pins outputs*/ /*Make led pins outputs*/
USER_LED_DDR |= USER_LED_MASK; USER_LED_DDR |= USER_LED_MASK;
USER_LED_PDOR |= USER_LED_MASK; USER_LED_PDOR |= USER_LED_MASK;
} }
void pwm_update(rt_uint16_t value) void pwm_update(rt_uint16_t value)
{ {
FM3_BT2_PWM->PDUT = value; FM3_BT2_PWM->PDUT = value;
} }
static void led1_thread_entry(void *parameter) static void led1_thread_entry(void *parameter)
{ {
while (1) while (1)
{ {
rt_hw_led_toggle(1); rt_hw_led_toggle(1);
rt_thread_delay(RT_TICK_PER_SECOND); rt_thread_delay(RT_TICK_PER_SECOND);
} }
} }
static void led2_thread_entry(void *parameter) static void led2_thread_entry(void *parameter)
{ {
while (1) while (1)
{ {
rt_hw_led_toggle(2); rt_hw_led_toggle(2);
rt_thread_delay(RT_TICK_PER_SECOND/2); rt_thread_delay(RT_TICK_PER_SECOND/2);
} }
} }
static rt_thread_t led1_thread; static rt_thread_t led1_thread;
static rt_thread_t led2_thread; static rt_thread_t led2_thread;
void rt_hw_led_init(void) void rt_hw_led_init(void)
{ {
led_init(); led_init();
led1_thread = rt_thread_create("led1", led1_thread_entry, RT_NULL, 384, 29, 5); led1_thread = rt_thread_create("led1", led1_thread_entry, RT_NULL, 384, 29, 5);
if (led1_thread != RT_NULL) if (led1_thread != RT_NULL)
rt_thread_startup(led1_thread); rt_thread_startup(led1_thread);
led2_thread = rt_thread_create("led2", led2_thread_entry, RT_NULL, 384, 30, 5); led2_thread = rt_thread_create("led2", led2_thread_entry, RT_NULL, 384, 30, 5);
if (led2_thread != RT_NULL) if (led2_thread != RT_NULL)
rt_thread_startup(led2_thread); rt_thread_startup(led2_thread);
} }
bsp/fm3/mb9bf506r/led.h
浏览文件 @ 17857917
/* /*
* File : led.h * File : led.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2011, RT-Thread Develop Team * COPYRIGHT (C) 2011, RT-Thread Develop Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-03-03 lgnq * 2011-03-03 lgnq
*/ */
#ifndef __LED_H__ #ifndef __LED_H__
#define __LED_H__ #define __LED_H__
#include "mb9bf506r.h" #include "mb9bf506r.h"
#define LEDS_MAX_NUMBER 4 #define LEDS_MAX_NUMBER 4
/* LED */ /* LED */
#define USER_LED1 (1UL<<0x9) #define USER_LED1 (1UL<<0x9)
#define USER_LED2 (1UL<<0xa) #define USER_LED2 (1UL<<0xa)
#define USER_LED3 (1UL<<0xb) #define USER_LED3 (1UL<<0xb)
#define USER_LED_MASK (USER_LED1 | USER_LED2 | USER_LED3) #define USER_LED_MASK (USER_LED1 | USER_LED2 | USER_LED3)
#define USER_LED_PFR FM3_GPIO->PFR1 #define USER_LED_PFR FM3_GPIO->PFR1
#define USER_LED_PCR FM3_GPIO->PCR1 #define USER_LED_PCR FM3_GPIO->PCR1
#define USER_LED_PDOR FM3_GPIO->PDOR1 #define USER_LED_PDOR FM3_GPIO->PDOR1
#define USER_LED_DDR FM3_GPIO->DDR1 #define USER_LED_DDR FM3_GPIO->DDR1
#define RT_DEVICE_CTRL_LED_ON 0 #define RT_DEVICE_CTRL_LED_ON 0
#define RT_DEVICE_CTRL_LED_OFF 1 #define RT_DEVICE_CTRL_LED_OFF 1
#define RT_DEVICE_CTRL_LED_TOGGLE 2 #define RT_DEVICE_CTRL_LED_TOGGLE 2
void rt_hw_led_init(void); void rt_hw_led_init(void);
void rt_hw_led_on(rt_uint8_t num); void rt_hw_led_on(rt_uint8_t num);
void rt_hw_led_off(rt_uint8_t num); void rt_hw_led_off(rt_uint8_t num);
void rt_hw_led_toggle(rt_uint8_t num); void rt_hw_led_toggle(rt_uint8_t num);
void pwm_update(rt_uint16_t value); void pwm_update(rt_uint16_t value);
#endif #endif
bsp/fm3/mb9bf506r/nand.c
浏览文件 @ 17857917
此差异已折叠。
bsp/fm3/mb9bf506r/nand.h
浏览文件 @ 17857917
/* /*
* File : nand.h * File : nand.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-05-25 Bernard first version * 2011-05-25 Bernard first version
*/ */
#ifndef __NAND_H__ #ifndef __NAND_H__
#define __NAND_H__ #define __NAND_H__
#include <rtthread.h> #include <rtthread.h>
#define IO_NF_PFR FM3_GPIO->PFR3 #define IO_NF_PFR FM3_GPIO->PFR3
#define IO_NF_DDR FM3_GPIO->DDR3 #define IO_NF_DDR FM3_GPIO->DDR3
#define IO_NF_PDOR FM3_GPIO->PDOR3 #define IO_NF_PDOR FM3_GPIO->PDOR3
#define NF_EN 0x0008 #define NF_EN 0x0008
#define NF_DATA_DIR 0x0004 #define NF_DATA_DIR 0x0004
#define EXT_BUS_BASE_ADDR 0x60000000 #define EXT_BUS_BASE_ADDR 0x60000000
#define EXT_CS7_OFFSET 0x0E000000 #define EXT_CS7_OFFSET 0x0E000000
#define EXT_CS7_SIZE 0x02000000 #define EXT_CS7_SIZE 0x02000000
#define NF_FLASH_BASE_ADDR (EXT_BUS_BASE_ADDR+EXT_CS7_OFFSET) #define NF_FLASH_BASE_ADDR (EXT_BUS_BASE_ADDR+EXT_CS7_OFFSET)
#define NF_ALE_OFFSET 0x00003000 #define NF_ALE_OFFSET 0x00003000
#define NF_ADDR_OFFSET 0x00002000 #define NF_ADDR_OFFSET 0x00002000
#define NF_CMD_OFFSET 0x00001000 #define NF_CMD_OFFSET 0x00001000
#define NF_DATA_OFFSET 0x00000000 #define NF_DATA_OFFSET 0x00000000
/* NAND command */ /* NAND command */
#define NAND_CMD_READ0 0x00 #define NAND_CMD_READ0 0x00
#define NAND_CMD_READ1 0x01 #define NAND_CMD_READ1 0x01
#define NAND_CMD_PAGEPROG 0x10 #define NAND_CMD_PAGEPROG 0x10
#define NAND_CMD_READOOB 0x50 #define NAND_CMD_READOOB 0x50
#define NAND_CMD_ERASE1 0x60 #define NAND_CMD_ERASE1 0x60
#define NAND_CMD_STATUS 0x70 #define NAND_CMD_STATUS 0x70
#define NAND_CMD_SEQIN 0x80 #define NAND_CMD_SEQIN 0x80
#define NAND_CMD_READID 0x90 #define NAND_CMD_READID 0x90
#define NAND_CMD_READID1 0x91 #define NAND_CMD_READID1 0x91
#define NAND_CMD_ERASE2 0xd0 #define NAND_CMD_ERASE2 0xd0
#define NAND_CMD_RESET 0xff #define NAND_CMD_RESET 0xff
#define FLASH_OK 0 #define FLASH_OK 0
#define FLASH_NG 1 #define FLASH_NG 1
/* nand flash device initialization */ /* nand flash device initialization */
void rt_hw_nand_init(void); void rt_hw_nand_init(void);
#endif #endif
bsp/fm3/mb9bf506r/rtconfig.py
浏览文件 @ 17857917
# toolchains options # toolchains options
ARCH='arm' ARCH='arm'
CPU='fm3' CPU='fm3'
CROSS_TOOL='gcc' CROSS_TOOL='gcc'
# cross_tool provides the cross compiler # cross_tool provides the cross compiler
# EXEC_PATH is the compiler execute path, for example, CodeSourcery, Keil MDK, IAR # EXEC_PATH is the compiler execute path, for example, CodeSourcery, Keil MDK, IAR
if CROSS_TOOL == 'gcc': if CROSS_TOOL == 'gcc':
PLATFORM = 'gcc' PLATFORM = 'gcc'
EXEC_PATH = 'C:/Program Files/CodeSourcery/Sourcery G++ Lite/bin' EXEC_PATH = '/media/workspace/arm-2011.03/bin'
elif CROSS_TOOL == 'keil': elif CROSS_TOOL == 'keil':
PLATFORM = 'armcc' PLATFORM = 'armcc'
EXEC_PATH = 'C:/Keil' EXEC_PATH = 'C:/Keil'
elif CROSS_TOOL == 'iar': elif CROSS_TOOL == 'iar':
PLATFORM = 'iar' PLATFORM = 'iar'
IAR_PATH = 'C:\Program Files\IAR Systems\Embedded Workbench 6.0 Evaluation' IAR_PATH = 'C:\Program Files\IAR Systems\Embedded Workbench 6.0 Evaluation'
BUILD = 'debug' BUILD = 'debug'
if PLATFORM == 'gcc': if PLATFORM == 'gcc':
# toolchains # toolchains
PREFIX = 'arm-none-eabi-' PREFIX = 'arm-none-eabi-'
CC = PREFIX + 'gcc' CC = PREFIX + 'gcc'
AS = PREFIX + 'gcc' AS = PREFIX + 'gcc'
AR = PREFIX + 'ar' AR = PREFIX + 'ar'
LINK = PREFIX + 'gcc' LINK = PREFIX + 'gcc'
TARGET_EXT = 'axf' TARGET_EXT = 'axf'
SIZE = PREFIX + 'size' SIZE = PREFIX + 'size'
OBJDUMP = PREFIX + 'objdump' OBJDUMP = PREFIX + 'objdump'
OBJCPY = PREFIX + 'objcopy' OBJCPY = PREFIX + 'objcopy'
DEVICE = ' -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections' DEVICE = ' -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections'
CFLAGS = DEVICE CFLAGS = DEVICE
AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp' AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp'
LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-fm3.map,-cref,-u,Reset_Handler -T fm3_rom.ld' LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-fm3.map,-cref,-u,Reset_Handler -T fm3_rom.ld'
CPATH = '' CPATH = ''
LPATH = '' LPATH = ''
if BUILD == 'debug': if BUILD == 'debug':
CFLAGS += ' -O0 -gdwarf-2' CFLAGS += ' -O0 -gdwarf-2'
AFLAGS += ' -gdwarf-2' AFLAGS += ' -gdwarf-2'
else: else:
CFLAGS += ' -O2' CFLAGS += ' -O2'
POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n' POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n'
elif PLATFORM == 'armcc': elif PLATFORM == 'armcc':
# toolchains # toolchains
CC = 'armcc' CC = 'armcc'
AS = 'armasm' AS = 'armasm'
AR = 'armar' AR = 'armar'
LINK = 'armlink' LINK = 'armlink'
TARGET_EXT = 'axf' TARGET_EXT = 'axf'
DEVICE = ' --device DARMSTM' DEVICE = ' --device DARMSTM'
CFLAGS = DEVICE + ' --apcs=interwork' CFLAGS = DEVICE + ' --apcs=interwork'
AFLAGS = DEVICE AFLAGS = DEVICE
LFLAGS = DEVICE + ' --info sizes --info totals --info unused --info veneers --list rtthread-stm32.map --scatter stm32_rom.sct' LFLAGS = DEVICE + ' --info sizes --info totals --info unused --info veneers --list rtthread-stm32.map --scatter stm32_rom.sct'
CFLAGS += ' -I' + EXEC_PATH + '/ARM/RV31/INC' CFLAGS += ' -I' + EXEC_PATH + '/ARM/RV31/INC'
LFLAGS += ' --libpath ' + EXEC_PATH + '/ARM/RV31/LIB' LFLAGS += ' --libpath ' + EXEC_PATH + '/ARM/RV31/LIB'
EXEC_PATH += '/arm/bin40/' EXEC_PATH += '/arm/bin40/'
if BUILD == 'debug': if BUILD == 'debug':
CFLAGS += ' -g -O0' CFLAGS += ' -g -O0'
AFLAGS += ' -g' AFLAGS += ' -g'
else: else:
CFLAGS += ' -O2' CFLAGS += ' -O2'
POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET' POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET'
elif PLATFORM == 'iar': elif PLATFORM == 'iar':
# toolchains # toolchains
CC = 'iccarm' CC = 'iccarm'
AS = 'iasmarm' AS = 'iasmarm'
AR = 'iarchive' AR = 'iarchive'
LINK = 'ilinkarm' LINK = 'ilinkarm'
TARGET_EXT = 'out' TARGET_EXT = 'out'
CFLAGS = '' CFLAGS = ''
CFLAGS += ' --diag_suppress Pa050' CFLAGS += ' --diag_suppress Pa050'
CFLAGS += ' --no_cse' CFLAGS += ' --no_cse'
CFLAGS += ' --no_unroll' CFLAGS += ' --no_unroll'
CFLAGS += ' --no_inline' CFLAGS += ' --no_inline'
CFLAGS += ' --no_code_motion' CFLAGS += ' --no_code_motion'
CFLAGS += ' --no_tbaa' CFLAGS += ' --no_tbaa'
CFLAGS += ' --no_clustering' CFLAGS += ' --no_clustering'
CFLAGS += ' --no_scheduling' CFLAGS += ' --no_scheduling'
CFLAGS += ' --debug' CFLAGS += ' --debug'
CFLAGS += ' --endian=little' CFLAGS += ' --endian=little'
CFLAGS += ' --cpu=Cortex-M3' CFLAGS += ' --cpu=Cortex-M3'
CFLAGS += ' -e' CFLAGS += ' -e'
CFLAGS += ' --fpu=None' CFLAGS += ' --fpu=None'
CFLAGS += ' --dlib_config "' + IAR_PATH + '/arm/INC/c/DLib_Config_Normal.h"' CFLAGS += ' --dlib_config "' + IAR_PATH + '/arm/INC/c/DLib_Config_Normal.h"'
CFLAGS += ' -Ol' CFLAGS += ' -Ol'
CFLAGS += ' --use_c++_inline' CFLAGS += ' --use_c++_inline'
AFLAGS = '' AFLAGS = ''
AFLAGS += ' -s+' AFLAGS += ' -s+'
AFLAGS += ' -w+' AFLAGS += ' -w+'
AFLAGS += ' -r' AFLAGS += ' -r'
AFLAGS += ' --cpu Cortex-M3' AFLAGS += ' --cpu Cortex-M3'
AFLAGS += ' --fpu None' AFLAGS += ' --fpu None'
AFLAGS += ' -I"' + IAR_PATH + '/arm/INC"' AFLAGS += ' -I"' + IAR_PATH + '/arm/INC"'
LFLAGS = ' --config mb9bf506.icf' LFLAGS = ' --config mb9bf506.icf'
LFLAGS += ' --semihosting' LFLAGS += ' --semihosting'
LFLAGS += ' --entry __iar_program_start' LFLAGS += ' --entry __iar_program_start'
EXEC_PATH = IAR_PATH + '/arm/bin/' EXEC_PATH = IAR_PATH + '/arm/bin/'
POST_ACTION = 'ielftool.exe --srec --verbose $TARGET rtthread.srec' POST_ACTION = 'ielftool.exe --srec --verbose $TARGET rtthread.srec'
bsp/fm3/mb9bf506r/serial.c
浏览文件 @ 17857917
/* /*
* File : serial.c * File : serial.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2006-03-13 Bernard first version * 2006-03-13 Bernard first version
* 2011-05-15 lgnq modified according bernard's implementaion. * 2011-05-15 lgnq modified according bernard's implementaion.
*/ */
#include <rtthread.h> #include <rtthread.h>
#include "serial.h" #include "serial.h"
/** /**
* @addtogroup FM3 MB9B500 * @addtogroup FM3 MB9B500
*/ */
/*@{*/ /*@{*/
/* RT-Thread Device Interface */ /* RT-Thread Device Interface */
/** /**
* This function initializes serial * 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)
{ {
struct serial_device* uart = (struct serial_device*) dev->user_data; struct serial_device* uart = (struct serial_device*) dev->user_data;
if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED)) if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
{ {
if (dev->flag & RT_DEVICE_FLAG_INT_RX) if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{ {
rt_memset(uart->int_rx->rx_buffer, 0, rt_memset(uart->int_rx->rx_buffer, 0,
sizeof(uart->int_rx->rx_buffer)); sizeof(uart->int_rx->rx_buffer));
uart->int_rx->read_index = uart->int_rx->save_index = 0; uart->int_rx->read_index = uart->int_rx->save_index = 0;
} }
if (dev->flag & RT_DEVICE_FLAG_INT_TX) if (dev->flag & RT_DEVICE_FLAG_INT_TX)
{ {
rt_memset(uart->int_tx->tx_buffer, 0, rt_memset(uart->int_tx->tx_buffer, 0,
sizeof(uart->int_tx->tx_buffer)); sizeof(uart->int_tx->tx_buffer));
uart->int_tx->write_index = uart->int_tx->save_index = 0; uart->int_tx->write_index = uart->int_tx->save_index = 0;
} }
dev->flag |= RT_DEVICE_FLAG_ACTIVATED; dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
} }
return RT_EOK; return RT_EOK;
} }
/* save a char to serial buffer */ /* save a char to serial buffer */
static void rt_serial_savechar(struct serial_device* uart, char ch) static void rt_serial_savechar(struct serial_device* uart, char ch)
{ {
rt_base_t level; rt_base_t level;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
uart->int_rx->rx_buffer[uart->int_rx->save_index] = ch; uart->int_rx->rx_buffer[uart->int_rx->save_index] = ch;
uart->int_rx->save_index ++; uart->int_rx->save_index ++;
if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE) if (uart->int_rx->save_index >= UART_RX_BUFFER_SIZE)
uart->int_rx->save_index = 0; uart->int_rx->save_index = 0;
/* if the next position is read index, discard this 'read char' */ /* if the next position is read index, discard this 'read char' */
if (uart->int_rx->save_index == uart->int_rx->read_index) if (uart->int_rx->save_index == uart->int_rx->read_index)
{ {
uart->int_rx->read_index ++; uart->int_rx->read_index ++;
if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE) if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
uart->int_rx->read_index = 0; uart->int_rx->read_index = 0;
} }
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
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)
{ {
struct serial_device* uart; struct serial_device* uart;
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
uart = (struct serial_device*) dev->user_data; uart = (struct serial_device*) dev->user_data;
if (dev->flag & RT_DEVICE_FLAG_INT_RX) if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{ {
/* enable interrupt */ /* enable interrupt */
UART_ENABLE_IRQ(uart->rx_irq); UART_ENABLE_IRQ(uart->rx_irq);
} }
return RT_EOK; return RT_EOK;
} }
static rt_err_t rt_serial_close(rt_device_t dev) static rt_err_t rt_serial_close(rt_device_t dev)
{ {
struct serial_device* uart; struct serial_device* uart;
RT_ASSERT(dev != RT_NULL); RT_ASSERT(dev != RT_NULL);
uart = (struct serial_device*) dev->user_data; uart = (struct serial_device*) dev->user_data;
if (dev->flag & RT_DEVICE_FLAG_INT_RX) if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{ {
/* disable interrupt */ /* disable interrupt */
UART_DISABLE_IRQ(uart->rx_irq); UART_DISABLE_IRQ(uart->rx_irq);
} }
return RT_EOK; return RT_EOK;
} }
static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer, static rt_size_t rt_serial_read (rt_device_t dev, rt_off_t pos, void* buffer,
rt_size_t size) rt_size_t size)
{ {
rt_uint8_t* ptr; rt_uint8_t* ptr;
rt_err_t err_code; rt_err_t err_code;
struct serial_device* uart; struct serial_device* uart;
ptr = buffer; ptr = buffer;
err_code = RT_EOK; err_code = RT_EOK;
uart = (struct serial_device*)dev->user_data; uart = (struct serial_device*)dev->user_data;
if (dev->flag & RT_DEVICE_FLAG_INT_RX) if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{ {
rt_base_t level; rt_base_t level;
/* interrupt mode Rx */ /* interrupt mode Rx */
while (size) while (size)
{ {
if (uart->int_rx->read_index != uart->int_rx->save_index) if (uart->int_rx->read_index != uart->int_rx->save_index)
{ {
*ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index]; *ptr++ = uart->int_rx->rx_buffer[uart->int_rx->read_index];
size --; size --;
/* disable interrupt */ /* disable interrupt */
level = rt_hw_interrupt_disable(); level = rt_hw_interrupt_disable();
uart->int_rx->read_index ++; uart->int_rx->read_index ++;
if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE) if (uart->int_rx->read_index >= UART_RX_BUFFER_SIZE)
uart->int_rx->read_index = 0; uart->int_rx->read_index = 0;
/* enable interrupt */ /* enable interrupt */
rt_hw_interrupt_enable(level); rt_hw_interrupt_enable(level);
} }
else else
{ {
/* set error code */ /* set error code */
err_code = -RT_EEMPTY; err_code = -RT_EEMPTY;
break; break;
} }
} }
} }
else else
{ {
/* polling mode */ /* polling mode */
while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size) while ((rt_uint32_t)ptr - (rt_uint32_t)buffer < size)
{ {
while (uart->uart_device->SSR & SSR_RDRF) while (uart->uart_device->SSR & SSR_RDRF)
{ {
*ptr = uart->uart_device->RDR & 0xff; *ptr = uart->uart_device->RDR & 0xff;
ptr ++; ptr ++;
} }
} }
} }
/* set error code */ /* set error code */
rt_set_errno(err_code); rt_set_errno(err_code);
return (rt_uint32_t)ptr - (rt_uint32_t)buffer; return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
} }
static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos, static rt_size_t rt_serial_write (rt_device_t dev, rt_off_t pos,
const void* buffer, rt_size_t size) const void* buffer, rt_size_t size)
{ {
rt_uint8_t* ptr; rt_uint8_t* ptr;
rt_err_t err_code; rt_err_t err_code;
struct serial_device* uart; struct serial_device* uart;
err_code = RT_EOK; err_code = RT_EOK;
ptr = (rt_uint8_t*)buffer; ptr = (rt_uint8_t*)buffer;
uart = (struct serial_device*)dev->user_data; uart = (struct serial_device*)dev->user_data;
if (dev->flag & RT_DEVICE_FLAG_INT_TX) if (dev->flag & RT_DEVICE_FLAG_INT_TX)
{ {
/* interrupt mode Tx */ /* interrupt mode Tx */
while (uart->int_tx->save_index != uart->int_tx->write_index) while (uart->int_tx->save_index != uart->int_tx->write_index)
{ {
/* save on tx buffer */ /* save on tx buffer */
uart->int_tx->tx_buffer[uart->int_tx->save_index] = *ptr++; uart->int_tx->tx_buffer[uart->int_tx->save_index] = *ptr++;
-- size; -- size;
/* move to next position */ /* move to next position */
uart->int_tx->save_index ++; uart->int_tx->save_index ++;
/* wrap save index */ /* wrap save index */
if (uart->int_tx->save_index >= UART_TX_BUFFER_SIZE) if (uart->int_tx->save_index >= UART_TX_BUFFER_SIZE)
uart->int_tx->save_index = 0; uart->int_tx->save_index = 0;
} }
/* set error code */ /* set error code */
if (size > 0) if (size > 0)
err_code = -RT_EFULL; err_code = -RT_EFULL;
} }
else else
{ {
/* polling mode */ /* polling mode */
while (size) while (size)
{ {
/* /*
* to be polite with serial console add a line feed * to be polite with serial console add a line feed
* to the carriage return character * to the carriage return character
*/ */
if (*ptr == '\n' && (dev->flag & RT_DEVICE_FLAG_STREAM)) if (*ptr == '\n' && (dev->flag & RT_DEVICE_FLAG_STREAM))
{ {
while (!(uart->uart_device->SSR & SSR_TDRE)); while (!(uart->uart_device->SSR & SSR_TDRE));
uart->uart_device->TDR = '\r'; uart->uart_device->TDR = '\r';
} }
while (!(uart->uart_device->SSR & SSR_TDRE)); while (!(uart->uart_device->SSR & SSR_TDRE));
uart->uart_device->TDR = (*ptr & 0x1FF); uart->uart_device->TDR = (*ptr & 0x1FF);
++ptr; --size; ++ptr; --size;
} }
} }
/* set error code */ /* set error code */
rt_set_errno(err_code); rt_set_errno(err_code);
return (rt_uint32_t)ptr - (rt_uint32_t)buffer; return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
} }
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) switch (cmd)
{ {
case RT_DEVICE_CTRL_SUSPEND: case RT_DEVICE_CTRL_SUSPEND:
/* suspend device */ /* suspend device */
dev->flag |= RT_DEVICE_FLAG_SUSPENDED; dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
break; break;
case RT_DEVICE_CTRL_RESUME: case RT_DEVICE_CTRL_RESUME:
/* resume device */ /* resume device */
dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED; dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
break; break;
} }
return RT_EOK; return RT_EOK;
} }
/* /*
* serial register * serial register
*/ */
rt_err_t rt_hw_serial_register(rt_device_t device, const char* name, rt_err_t rt_hw_serial_register(rt_device_t device, const char* name,
rt_uint32_t flag, struct serial_device *serial) rt_uint32_t flag, struct serial_device *serial)
{ {
RT_ASSERT(device != RT_NULL); RT_ASSERT(device != RT_NULL);
device->type = RT_Device_Class_Char; device->type = RT_Device_Class_Char;
device->rx_indicate = RT_NULL; device->rx_indicate = RT_NULL;
device->tx_complete = RT_NULL; device->tx_complete = RT_NULL;
device->init = rt_serial_init; device->init = rt_serial_init;
device->open = rt_serial_open; device->open = rt_serial_open;
device->close = rt_serial_close; device->close = rt_serial_close;
device->read = rt_serial_read; device->read = rt_serial_read;
device->write = rt_serial_write; device->write = rt_serial_write;
device->control = rt_serial_control; device->control = rt_serial_control;
device->user_data = serial; device->user_data = serial;
/* register a character device */ /* register a character device */
return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag); return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | flag);
} }
/* ISR for serial interrupt */ /* ISR for serial interrupt */
void rt_hw_serial_isr(rt_device_t device) void rt_hw_serial_isr(rt_device_t device)
{ {
struct serial_device* uart = (struct serial_device*) device->user_data; struct serial_device* uart = (struct serial_device*) device->user_data;
/* interrupt mode receive */ /* interrupt mode receive */
RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX); RT_ASSERT(device->flag & RT_DEVICE_FLAG_INT_RX);
/* save on rx buffer */ /* save on rx buffer */
while (uart->uart_device->SSR & SSR_RDRF) while (uart->uart_device->SSR & SSR_RDRF)
{ {
rt_serial_savechar(uart, uart->uart_device->RDR & 0xff); rt_serial_savechar(uart, uart->uart_device->RDR & 0xff);
} }
/* invoke callback */ /* invoke callback */
if (device->rx_indicate != RT_NULL) if (device->rx_indicate != RT_NULL)
{ {
rt_size_t rx_length; rt_size_t rx_length;
/* get rx length */ /* get rx length */
rx_length = uart->int_rx->read_index > uart->int_rx->save_index ? rx_length = uart->int_rx->read_index > uart->int_rx->save_index ?
UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index : UART_RX_BUFFER_SIZE - uart->int_rx->read_index + uart->int_rx->save_index :
uart->int_rx->save_index - uart->int_rx->read_index; uart->int_rx->save_index - uart->int_rx->read_index;
device->rx_indicate(device, rx_length); device->rx_indicate(device, rx_length);
} }
} }
#ifdef RT_USING_UART2 #ifdef RT_USING_UART2
/* UART2 device driver structure */ /* UART2 device driver structure */
#define UART2 FM3_MFS2_UART #define UART2 FM3_MFS2_UART
struct serial_int_rx uart2_int_rx; struct serial_int_rx uart2_int_rx;
struct serial_device uart2 = struct serial_device uart2 =
{ {
UART2, UART2,
MFS2RX_IRQn, MFS2RX_IRQn,
MFS2TX_IRQn, MFS2TX_IRQn,
&uart2_int_rx, &uart2_int_rx,
RT_NULL RT_NULL
}; };
struct rt_device uart2_device; struct rt_device uart2_device;
void MFS2RX_IRQHandler(void) void MFS2RX_IRQHandler(void)
{ {
/* enter interrupt */ /* enter interrupt */
rt_interrupt_enter(); rt_interrupt_enter();
rt_hw_serial_isr(&uart2_device); rt_hw_serial_isr(&uart2_device);
/* leave interrupt */ /* leave interrupt */
rt_interrupt_leave(); rt_interrupt_leave();
} }
#endif #endif
void rt_hw_serial_init(void) void rt_hw_serial_init(void)
{ {
#ifdef RT_USING_UART2 #ifdef RT_USING_UART2
/* initialize UART2 */ /* initialize UART2 */
/* Set Uart Ch2 Port, SIN2_1, SOT2_1 */ /* Set Uart Ch2 Port, SIN2_1, SOT2_1 */
FM3_GPIO->PFR2 = FM3_GPIO->PFR2 | 0x0030; FM3_GPIO->PFR2 = FM3_GPIO->PFR2 | 0x0030;
FM3_GPIO->EPFR07 = FM3_GPIO->EPFR07 | 0x000a0000; FM3_GPIO->EPFR07 = FM3_GPIO->EPFR07 | 0x000a0000;
uart2.uart_device->SMR = SMR_MD_UART | SMR_SOE;; uart2.uart_device->SMR = SMR_MD_UART | SMR_SOE;;
uart2.uart_device->BGR = (40000000UL + (BPS/2))/BPS - 1; uart2.uart_device->BGR = (40000000UL + (BPS/2))/BPS - 1;
uart2.uart_device->ESCR = ESCR_DATABITS_8; uart2.uart_device->ESCR = ESCR_DATABITS_8;
uart2.uart_device->SCR = SCR_RXE | SCR_TXE | SCR_RIE; uart2.uart_device->SCR = SCR_RXE | SCR_TXE | SCR_RIE;
/* register UART2 device */ /* register UART2 device */
rt_hw_serial_register(&uart2_device, rt_hw_serial_register(&uart2_device,
"uart2", "uart2",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart2); &uart2);
#endif #endif
} }
/*@}*/ /*@}*/
bsp/fm3/mb9bf506r/serial.h
浏览文件 @ 17857917
/* /*
* File : serial.h * File : serial.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team * COPYRIGHT (C) 2006, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2006-03-13 Bernard first version * 2006-03-13 Bernard first version
* 2011-05-15 lgnq modified according bernard's implementaion. * 2011-05-15 lgnq modified according bernard's implementaion.
*/ */
#ifndef __RT_HW_SERIAL_H__ #ifndef __RT_HW_SERIAL_H__
#define __RT_HW_SERIAL_H__ #define __RT_HW_SERIAL_H__
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#include "mb9bf506r.h" #include "mb9bf506r.h"
#define SMR_SOE 0x01U #define SMR_SOE 0x01U
#define SMR_BDS 0x04U #define SMR_BDS 0x04U
#define SMR_SBL 0x08U #define SMR_SBL 0x08U
#define SMR_WUCR 0x10U #define SMR_WUCR 0x10U
#define SMR_MD_UART 0x00U #define SMR_MD_UART 0x00U
#define SMR_MD_UART_MP 0x20U #define SMR_MD_UART_MP 0x20U
#define SMR_MD_SIO 0x40U #define SMR_MD_SIO 0x40U
#define SMR_MD_LIN 0x60U #define SMR_MD_LIN 0x60U
#define SMR_MD_I2C 0x80U #define SMR_MD_I2C 0x80U
#define SCR_TXE 0x01U #define SCR_TXE 0x01U
#define SCR_RXE 0x02U #define SCR_RXE 0x02U
#define SCR_TBIE 0x04U #define SCR_TBIE 0x04U
#define SCR_TIE 0x08U #define SCR_TIE 0x08U
#define SCR_RIE 0x10U #define SCR_RIE 0x10U
#define SCR_UPGL 0x80U #define SCR_UPGL 0x80U
#define SSR_TBI 0x01U #define SSR_TBI 0x01U
#define SSR_TDRE 0x02U #define SSR_TDRE 0x02U
#define SSR_RDRF 0x04U #define SSR_RDRF 0x04U
#define SSR_ORE 0x08U #define SSR_ORE 0x08U
#define SSR_FRE 0x10U #define SSR_FRE 0x10U
#define SSR_PE 0x20U #define SSR_PE 0x20U
#define SSR_REC 0x80U #define SSR_REC 0x80U
#define ESCR_P 0x08U #define ESCR_P 0x08U
#define ESCR_PEN 0x10U #define ESCR_PEN 0x10U
#define ESCR_INV 0x20U #define ESCR_INV 0x20U
#define ESCR_ESBL 0x40U #define ESCR_ESBL 0x40U
#define ESCR_FLWEN 0x80U #define ESCR_FLWEN 0x80U
#define ESCR_DATABITS_8 0x00U #define ESCR_DATABITS_8 0x00U
#define ESCR_DATABITS_5 0x01U #define ESCR_DATABITS_5 0x01U
#define ESCR_DATABITS_6 0x02U #define ESCR_DATABITS_6 0x02U
#define ESCR_DATABITS_7 0x03U #define ESCR_DATABITS_7 0x03U
#define ESCR_DATABITS_9 0x04U #define ESCR_DATABITS_9 0x04U
#define BPS 115200 /* serial baudrate */ #define BPS 115200 /* serial baudrate */
#define UART_RX_BUFFER_SIZE 64 #define UART_RX_BUFFER_SIZE 64
#define UART_TX_BUFFER_SIZE 64 #define UART_TX_BUFFER_SIZE 64
struct serial_int_rx struct serial_int_rx
{ {
rt_uint8_t rx_buffer[UART_RX_BUFFER_SIZE]; rt_uint8_t rx_buffer[UART_RX_BUFFER_SIZE];
rt_uint32_t read_index, save_index; rt_uint32_t read_index, save_index;
}; };
struct serial_int_tx struct serial_int_tx
{ {
rt_uint8_t tx_buffer[UART_TX_BUFFER_SIZE]; rt_uint8_t tx_buffer[UART_TX_BUFFER_SIZE];
rt_uint32_t write_index, save_index; rt_uint32_t write_index, save_index;
}; };
/* /*
* Enable/DISABLE Interrupt Controller * Enable/DISABLE Interrupt Controller
*/ */
/* deviation from MISRA-C:2004 Rule 19.7 */ /* deviation from MISRA-C:2004 Rule 19.7 */
#define UART_ENABLE_IRQ(n) NVIC_EnableIRQ((n)) #define UART_ENABLE_IRQ(n) NVIC_EnableIRQ((n))
#define UART_DISABLE_IRQ(n) NVIC_DisableIRQ((n)) #define UART_DISABLE_IRQ(n) NVIC_DisableIRQ((n))
struct serial_device struct serial_device
{ {
FM3_MFS03_UART_TypeDef* uart_device; FM3_MFS03_UART_TypeDef* uart_device;
/* irq number */ /* irq number */
IRQn_Type rx_irq, tx_irq; IRQn_Type rx_irq, tx_irq;
/* rx structure */ /* rx structure */
struct serial_int_rx* int_rx; struct serial_int_rx* int_rx;
/* tx structure */ /* tx structure */
struct serial_int_tx* int_tx; struct serial_int_tx* int_tx;
}; };
void rt_hw_serial_isr(rt_device_t device); void rt_hw_serial_isr(rt_device_t device);
void rt_hw_serial_init(void); void rt_hw_serial_init(void);
#endif #endif
bsp/fm3/mb9bf506r/startup.c
浏览文件 @ 17857917
/* /*
* File : startup.c * File : startup.c
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2009 - 2011, RT-Thread Development Team * COPYRIGHT (C) 2009 - 2011, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2011-02-24 Bernard first implementation * 2011-02-24 Bernard first implementation
*/ */
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#include "board.h" #include "board.h"
#include "mb9bf506r.h" #include "mb9bf506r.h"
#ifdef RT_USING_FINSH #ifdef RT_USING_FINSH
#include <finsh.h> #include <finsh.h>
#endif #endif
/** /**
* @addtogroup FM3 * @addtogroup FM3
*/ */
extern struct serial_device uart0; extern struct serial_device uart0;
extern struct rt_device uart0_device; extern struct rt_device uart0_device;
extern struct serial_device uart2; extern struct serial_device uart2;
extern struct rt_device uart2_device; extern struct rt_device uart2_device;
/*@{*/ /*@{*/
extern int rt_application_init(void); extern int rt_application_init(void);
#ifdef RT_USING_FINSH #ifdef RT_USING_FINSH
extern void finsh_system_init(void); extern void finsh_system_init(void);
#endif #endif
#ifdef __CC_ARM #ifdef __CC_ARM
extern int Image$$RW_IRAM1$$ZI$$Limit; extern int Image$$RW_IRAM1$$ZI$$Limit;
#elif __ICCARM__ #elif __ICCARM__
#pragma section="HEAP" #pragma section="HEAP"
#else #else
extern int __bss_end; extern int __bss_end;
#endif #endif
/** /**
* This function will startup RT-Thread RTOS. * This function will startup RT-Thread RTOS.
*/ */
void rtthread_startup(void) void rtthread_startup(void)
{ {
/* init board */ /* init board */
rt_hw_board_init(); rt_hw_board_init();
/* show version */ /* show version */
rt_show_version(); rt_show_version();
/* init tick */ /* init tick */
rt_system_tick_init(); rt_system_tick_init();
/* init timer system */ /* init timer system */
rt_system_timer_init(); rt_system_timer_init();
#ifdef RT_USING_HEAP #ifdef RT_USING_HEAP
#ifdef __CC_ARM #ifdef __CC_ARM
rt_system_heap_init((void*)&Image$$RW_IRAM1$$ZI$$Limit, (void*)FM3_SRAM_END); rt_system_heap_init((void*)&Image$$RW_IRAM1$$ZI$$Limit, (void*)FM3_SRAM_END);
#elif __ICCARM__ #elif __ICCARM__
rt_system_heap_init(__segment_end("HEAP"), (void*)FM3_SRAM_END); rt_system_heap_init(__segment_end("HEAP"), (void*)FM3_SRAM_END);
#else #else
/* init memory system */ /* init memory system */
rt_system_heap_init((void*)&__bss_end, (void*)FM3_SRAM_END); rt_system_heap_init((void*)&__bss_end, (void*)FM3_SRAM_END);
#endif #endif
#endif #endif
/* init scheduler system */ /* init scheduler system */
rt_system_scheduler_init(); rt_system_scheduler_init();
#ifdef RT_USING_DFS #ifdef RT_USING_DFS
#ifdef RT_USING_DFS_UFFS #ifdef RT_USING_DFS_UFFS
rt_hw_nand_init(); rt_hw_nand_init();
#endif #endif
#endif #endif
/* init application */ /* init application */
rt_application_init(); rt_application_init();
#ifdef RT_USING_FINSH #ifdef RT_USING_FINSH
/* init finsh */ /* init finsh */
finsh_system_init(); finsh_system_init();
#ifdef RT_USING_DEVICE #ifdef RT_USING_DEVICE
finsh_set_device("uart2"); finsh_set_device("uart2");
#endif #endif
#endif #endif
/* init timer thread */ /* init timer thread */
rt_system_timer_thread_init(); rt_system_timer_thread_init();
/* init idle thread */ /* init idle thread */
rt_thread_idle_init(); rt_thread_idle_init();
/* start scheduler */ /* start scheduler */
rt_system_scheduler_start(); rt_system_scheduler_start();
/* never reach here */ /* never reach here */
return ; return ;
} }
int main(void) int main(void)
{ {
/* disable interrupt first */ /* disable interrupt first */
rt_hw_interrupt_disable(); rt_hw_interrupt_disable();
/* init system setting */ /* init system setting */
SystemInit(); SystemInit();
/* startup RT-Thread RTOS */ /* startup RT-Thread RTOS */
rtthread_startup(); rtthread_startup();
return 0; return 0;
} }
/*@}*/ /*@}*/
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或