LOOK+红杏头文件学习第四帖：中断抽象类UART0收发练习

只看该作者 · 2011-6-12 10:02

本帖最后由 hotpower 于 2011-6-19 01:24 编辑

------------------------------2011-06-09------------------------------
LOOK实现四个小任务:
① task_led_t: 助学板上四个LED小灯轮流点亮,有两种显示模式，方式1为LED1--->LED2--->LED3--->LED4--->LED1循环，方式2为LED4--->LED3--->LED2--->LED1--->LED4循环，初始化为方式2；
② task_key_t: 助学板上KEY2通过查询的方式判断按下调整LED的循环方式；
③ 继承于interrupt_t的中断抽象类Key_t: 助学板上KEY1设置为下降沿中断，中断滞后服务函数内置位蜂鸣器鸣叫事件标志；
④ task_beep_t: 助学板上蜂鸣器响3声，该任务由KEY1同步。
初始化设置：时钟配置为 XTL12M_EN: 外部 4~24MHz 晶振使能
                        GPA2~5 GPB10 配置为输出模式
                        GPB14~15    配置为输入模式
               CPU时钟频率为12MHz

关于flag_t:
ANY是wait()事件标志的集合中，任何一个事件到达都可以唤醒任务，相当于“或”运算；
ALL是wait()事件标志的集合中，所有事件全部到达时才能唤醒任务，相当于“与”运算；
当期待的事件标志只有一位时，无所谓ANY,ALL。
KEEP表示到达的事件标志，在唤醒了等待的任务后，该事件不消失（可以继续唤醒其它任务）；
COSUME表示到达的事件标志，在唤醒了等待的任务后，该事件消失。
------------------------------2011-06-12------------------------------
在原基础上作如下调整:
① 取消中断抽象类任务Key_t，该任务实现的功能整合至一般任务类task_key_t中的key_read中；
② 增加中断抽象类任务uart0_t，该任务主要实现UART输出和接收功能，接收到字符'1'为同步蜂鸣器响3次任务，接收到字符'2'实现与KEY2按下相同功能；(参考Lee老师DS18B20的例程)
③ task_beep_t中增加蜂鸣器响之前发送字符串"Buzzer rang three times!\n"。
初始化设置: PB.0选择多功能输入RXD0 PB.1选择多功能输入TXD0
         UART时钟选择外部12MHZ,并使能UART0时钟

源程序：
led.h

复制

#include "look_config.h"

#include <look.h>

#include <instantiate>



#define KEY_NO_DOWN ((1<<14)|(1<<15)) //无按键按下时管脚PIN值



// 任务类 task_led_t 的定义

class task_led_t : public task_t {

public:

task_led_t() __OPT_ATTR__; // 构造函数

protected:

void routine(); // 任务例程

};

// 任务类 task_led_t 的构造函数

__OPT_INLINE__ task_led_t::task_led_t()

{

// TODO: 在此初始化 task_led_t 的类成员

}

// 任务类 task_key_t 的定义

class task_key_t : public task_t {

public:

task_key_t() __OPT_ATTR__; // 构造函数

int32_t key_read() __OPT_ATTR__;

protected:

void routine(); // 任务例程

};



// 任务类 task_key_t 的构造函数

__OPT_INLINE__ task_key_t::task_key_t()

{

// TODO: 在此初始化 task_led_t 的类成员

}

// 任务类 task_beep_t 的定义

class task_beep_t : public task_t {

public:

task_beep_t() __OPT_ATTR__; // 构造函数

protected:

void routine(); // 任务例程

};



// 任务类 task_key_t 的构造函数

__OPT_INLINE__ task_beep_t::task_beep_t()

{

// TODO: 在此初始化 task_led_t 的类成员

}



extern instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led;

extern instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key;

extern instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep;

led.cpp

复制

#include "NUC1xx.h" 

#include "NUC1xxM051Seriescfg.h" 

#include "led.h"



flag_t Flag(0); //位0为LED闪烁模式 位1为KEY1控制蜂鸣器任务同步标志 位2为UART通信控制蜂鸣器任务同步标志



// uart0_t 类为应用层提供了简单的 uart 同步输出功能及接收功能。

class uart0_t : public interrupt_t {

public:

uart0_t() __OPT_ATTR__; //构造函数

void puts(const char* str); //串口输出函数

protected:

bool isr(int vector); //中断服务例程

void dsr(int vector, uintptr_t count); //中断滞后服务例程

private:

void fillfifo(const char* str); //填充FIFO

private:

const char* buffer; // 输出缓冲区

task_t* task; // 正在输出的任务

};



// uart0 构造函数

__OPT_INLINE__ uart0_t::uart0_t()

{

attach(UART0_IRQn);

vector_t::enable(UART0_IRQn);

SYSs.IPRSTC2.Bits.UART0_RST = 1; //UART0 模块复位 

SYSs.IPRSTC2.Bits.UART0_RST = 0; //UART0 模块正常工作

UART0s.FCR.Bits.TFR = 1; //TX 软件复位

UART0s.FCR.Bits.RFR = 1; //RX 软件复位

UART0s.FCR.Bits.RFITL = 0x00; //Rx FIFO中断 (INT_RDA) 触发级别 1位



UART0s.LCR.Bits.SPE = 0; //无校验 奇偶使能位

UART0s.LCR.Bits.EPE = 0; // 0----奇校验 1----偶校验

UART0s.LCR.Bits.PBE = 0; 

UART0s.LCR.Bits.WLS = 0b011; //字长度选择 8bits

UART0s.LCR.Bits.NSB = 0; //1位停止位



UART0s.BAUD.Bits.BRD = 0x66; //外部12MHz 115200bps 对波特率分频寄存器的设置波特率分频设置即该句必须放在第一位

UART0s.BAUD.Bits.DIV_X_EN = 1; //使能分频X

UART0s.BAUD.Bits.DIV_X_ONE = 1; //Divider X equal 1 



UART0s.IER.Bits.RDA_IEN = 1; //使能接收中断

/*

DIV_X_EN DIV_X_ONE Divider X BRD 波特率公式 

Disable 0 B A UART_CLK / [16 * (A+2)] 

Enable 0 B A UART_CLK / [(B+1) * (A+2)] , B must >= 8 

Enable 1 B A UART_CLK / (A+2), A must >=3 

*/

}



// uart0 输出

void uart0_t::puts(const char* str)

{

fillfifo(str); // 填充 fifo

UART0s.IER.Bits.THRE_IEN = 1; // 允许发送中断

task = &scheduler.get_current_task();

delay(); // 阻塞任务

}



// uart0 中断服务例程

bool uart0_t::isr(int vector)

{

if (UART0s.ISR.Bits.THRE_INT==1)

{

//UART0发送中断

const char* str = buffer;

if (str == 0) { // 无数据

UART0s.IER.Bits.THRE_IEN = 0; // 禁止发送中断

return true;

}

fillfifo(str); // 填充 fifo

return false;

}

if (UART0s.ISR.Bits.RDA_INT==1)

{

//UART0接收中断

/* Get all the input characters */

while(UART0s.ISR.Bits.RDA_IF)

{

/* Get the character from UART Buffer */

uint8_t Received_Data = UART0s.DATA.Regs;

if (Received_Data=='1')

{

//执行蜂鸣器响3次的任务

Flag.do_set_bits(0b0100);

}

else if (Received_Data=='2')

{

//执行与KEY2相同的动作

int ** = Flag.peek();

if (**&0b01)

Flag.do_mask_bits(~0b01); //清除事件标志 位0

else

Flag.do_set_bits(0b01); //置位事件标志 位0

}

return false;

}

}

return false;

}



// uart0 中断滞后服务例程

// 所有数据发送完成后，dsr() 被调用

void uart0_t::dsr(int vector, uintptr_t count)

{

task->do_wakeup(); // 唤醒任务

}



// uart0 填充 fifo

void uart0_t::fillfifo(const char* str)

{

do {

char ch;

ch = *str++;

if (ch == 0) {

str = 0;

break;

}

UART0s.DATA.Regs = ch;

} while (!UART0s.FSR.Bits.TX_FULL);

buffer = str;

}



uart0_t uart0; // 创建 uart0 对象



// 任务类 task_led_t 的例程

void task_led_t::routine()

{

// TODO: 在此编写 task_led_t 例程的内容

GPIOAs.DMASK.Regs = ~0b111100; 

GPIOAs.DOUT.Regs = ~0b100; 

while (true) 

{

// TODO: 在此编写 task_led_t 例程的内容

uint32_t data = GPIOAs.DOUT.Regs & 0b111100; 

int flag = Flag.peek();

if (flag)

{

data <<= 1; 

data += data >> 4; 

}

else

{

data >>= 1;

data += data << 4;

}

GPIOAs.DOUT.Regs = data; 

delay(LOOK_TICKS_PER_SEC); 

}

}



// 任务类 task_key_t 的例程

void task_key_t::routine()

{

// TODO: 在此编写 task_led_t 例程的内容

while (true) 

{

// TODO: 在此编写 task_led_t 例程的内容

uint32_t Key_Val = key_read();

if ((Key_Val&(1<<14))==0)

{

//KEY2 按下

int ** = Flag.peek();

if (**&0b01)

Flag.mask_bits(~0b01); //清除事件标志 位0

else

Flag.set_bits(0b01); //置位事件标志 位0

}

if ((Key_Val&(1<<15))==0)

{

//KEY1 按下

Flag.do_set_bits(0b010);

}

delay(LOOK_TICKS_PER_SEC/10);

}

}



// 任务类 task_key_t 的成员函数

__OPT_INLINE__ int32_t task_key_t::key_read()

{

uint32_t Key_Tmp = TRUE; 

static uint32_t Key_Record = KEY_NO_DOWN; //按键记录 

Key_Tmp = GPIOBs.PIN.Regs&KEY_NO_DOWN; 

if(Key_Tmp==KEY_NO_DOWN) //无有效按键按下 

{ 

Key_Record = KEY_NO_DOWN; //清除按键记录 

return KEY_NO_DOWN; //程序退出 

} 

if(Key_Record!=Key_Tmp) //为新按键 

{ 

Key_Record = Key_Tmp; //保存本次结果 

delay(LOOK_TICKS_PER_SEC/100); //延时去抖动 

Key_Tmp = GPIOBs.PIN.Regs&KEY_NO_DOWN; 

if(Key_Tmp==Key_Record) 

return Key_Tmp; 

} 

return KEY_NO_DOWN; 

}



// 任务类 task_beep_t 的例程

void task_beep_t::routine()

{

// TODO: 在此编写 task_led_t 例程的内容

GPIOBs.DOUT.Bits.Pin10 = 0; //蜂鸣器不响

while (true) 

{

// TODO: 在此编写 task_led_t 例程的内容

int flag = Flag.wait(0b110, flag_t::ANY_CONSUME); 

if (flag)

{

uart0.puts("Buzzer rang three times!\n");

for (uint32_t i = 0; i < 6; i ++)

{ 

//蜂鸣器响三次

GPIOBs.DOUT.Bits.Pin10 ^= 1; //蜂鸣器响PB10=1，不响PB10=0

delay(LOOK_TICKS_PER_SEC); //断续间隔

}

}

}

} 



#ifdef LOOK_SCHEDULING_PRIORITY

instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key(0);

instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep(1);

instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led(2);

#else

instantiate::task<task_key_t, LOOK_STACK_SIZE> task_key;

instantiate::task<task_beep_t, LOOK_STACK_SIZE> task_beep;

instantiate::task<task_led_t, LOOK_STACK_SIZE> task_led;

#endif

只看该作者 · 2011-6-12 10:36

本帖最后由 Swallow_0322 于 2011-6-12 10:37 编辑

呵呵！现在M0的学习气氛好淡，自己占沙发并在此预报下一贴目标，作为对自己的监督和鞭策！
uart收到某命令后以启动AD转换任务（此时使用信号灯同步任务），然后uart发送AD转换结果（此时会涉及到互斥信号灯），调度算法使用固定优先级。

2万 · 2011-6-12 20:03

好！俺在路上回家看。
刚与吴旭光教授和牛博士谈了look和ucos。

只看该作者 · 2011-6-12 20:19

什么结果？等大叔好消息！

LOOK+红杏头文件 学习第四帖：中断抽象类UART0收发练习

相关下载

相关帖子

无冕之王奖章

沉静之湖泊

技术奇才奖章

缘定三生

LOOK+红杏头文件学习第四帖：中断抽象类UART0收发练习