[LOOK] LOOK+红杏头文件 学习第五帖：信号灯+AD转换(查询法)

 

#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_key_t 的类成员

}



// 任务类 task_beep_t 的定义

class task_beep_t : public task_t {

public:

task_beep_t() __OPT_ATTR__; // 构造函数

protected:

void routine(); // 任务例程

};

// 任务类 task_beep_t 的构造函数

__OPT_INLINE__ task_beep_t::task_beep_t()

{

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

}



// 任务类 task_ad_t 的定义

class task_ad_t : public task_t {

public:

task_ad_t() __OPT_ATTR__;  // 构造函数

sem_t sem;      // 信号灯为AD转换提供同步

protected:

void routine();     // 任务例程

};

// 任务类 task_beep_t 的构造函数

__OPT_INLINE__ task_ad_t::task_ad_t():sem(0)

{

// TODO: 在此初始化 task_ad_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;

extern instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad;



led.cpp

[code]

#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

}

else if (Received_Data=='3')

{

task_ad.sem.do_post(); //释放一个信号量资源 

}

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_key_t 例程的内容

while (true) 

{

// TODO: 在此编写 task_key_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_beep_t 例程的内容

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

while (true) 

{

// TODO: 在此编写 task_beep_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); //断续间隔

}

}

}

} 



// 任务类 task_ad_t 的例程

void task_ad_t::routine()

{

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

SYSs.IPRSTC2.Bits.ADC_RST = 1;

SYSs.IPRSTC2.Bits.ADC_RST = 0; /* Reset ADC */



//ADC时钟、分频及配置为AD引脚在look中配置



ADCs.ADCR.Bits.ADEN = 1; //使能AD模块



ADCs.ADCALR.Bits.CALEN = 1; //自校正使能

while(!ADCs.ADCALR.Bits.CALDONE); //等待自校正结束



ADCs.ADCR.Bits.DIFFEN = 0; //单端输入

ADCs.ADCR.Bits.ADST = 0; //停止AD

ADCs.ADCR.Bits.ADMD = 0; //单一转换

ADCs.ADCHER.Bits.CHEN = 0x02; //模拟输入通道1使能

ADCs.ADSR.Bits.ADF = 1; //清AD中断标志

while (true) 

{

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

if (sem.wait())

{

ADCs.ADCR.Bits.ADST = 1; //启动AD

while(!ADCs.ADSR.Bits.ADF); //等待转换结束

ADCs.ADSR.Bits.ADF = 1; //清AD中断标志

uint32_t AD_Result = ADCs.ADDR1.Regs&0xFFF;

char str[4];

char *p;

str[0] = AD_Result/1000+'0';

str[1] = AD_Result/100%10+'0';

str[2] = AD_Result/10%10+'0';

str[3] = AD_Result%10+'0';

p = &str[0];

uart0.puts("ADC_RESULT_AD1:");

uart0.puts(p);

}



}

} 



#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);

instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad(3);

#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;

instantiate::task<task_ad_t, LOOK_STACK_SIZE> task_ad;

#endif