发新帖我要提问
返回列表
打印
[LOOK]

【M0第四帖||Look第二帖】LOOK的中断详解，实现个串口类

[复制链接]
2664|7
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
nixianmin|  楼主 | 2011-9-28 21:40 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
串口, UART, UART0, TE, ui
终于在几天的学习下又有进一步的突破了，LOOK系统也有个大概的概念了，且在学习LOOK的过程中也在思考用C++如何写程序，和C语言写程序有比较大的不同了，毕竟它的精华是面向对象的思想，刚开始写一直用LOOK里类的派生类，发现自己被LOOK类绑架了:L，没事就用task_t类，唉，没抓住他们特点就有点胡来的感觉，现在没事就自己建个类，要用到LOOK类的功能才从LOOK派生。    最近学了下interrupt_t和mbox<T>类，实现了几个简单的功能，下面来讲讲这些类:
    interrut_t是当使用中断功能时才用该类派生个中断类，该类最重要也就是
   
复制
interrupt_t *  attach (uintptr_t irq) 

                     挂接本中断对象到指定的中断号上 

   


    该功能实现当前的中断对象和对应的中断向量类进行相关联，无聊找出了其中的一些关系
    这段是中断的attach函数，看到和vector::table[中断号].attach(this),还有vector_t::attach
  
复制
__OPT_INLINE__ look::interrupt_t* look::interrupt_t::attach(uintptr_t irq)

   {

     return vector_t::table[irq - -1/*SysTick_IRQn*/].attach(this);

   }

    _OPT_INLINE__ look::interrupt_t*

look::vector_t::attach(interrupt_t* intr)



  {



     interrupt_t*

old = interrupt;



     interrupt

= intr;



     return

old;



  }   


    在vector_t类中找到table[], 从这几段代码看出在产生中断时就可以通过table[中断号].interrupt.isr/dsr来调用
对应中断的相关中断函数了，应为每个table[]中都用了interrupt *将其联系起来了，好了中断就讲到这
   
复制
#ifndef __DOXYGEN__

    union {

    struct {

        interrupt_t* interrupt;

        uint16_t count;

        uint8_t next;

    };

      uint64_t data;

   };

  #endif        // __DOXYGEN__



  static vector_t table[] __attribute__((aligned(4)));

  

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
下面是我写的代码，一个uart0_int_c:public interrupt_t类实现串口的一些功能，可以设置参数，也可以用默认设置
这些代码有些都是照着MO库来改写的，并在一个任务中实现了mmbox_t<T,SIZE>多信息邮箱，如果串口中断接收到数据，则通过
邮箱将数据送到一个任务函数中并通过串口发送出去，邮箱的get()函数在没有信息时会使当前任务进入阻塞状态，只有有信息时，才能
激活任务，并读取邮箱里的数据。
uart.h
复制
/*****************************************

//

//

******************************************/

#ifndef _Uart_h_

#define _Uart_h_

#include"look.h"



/*---------------------------------------------------------------------------------------------------------*/

/* DATA BIT */

/*---------------------------------------------------------------------------------------------------------*/

typedef enum 

{

DRVUART_DATABITS_5 = 0x0,

DRVUART_DATABITS_6         =         0x1,

DRVUART_DATABITS_7 =         0x2,

DRVUART_DATABITS_8 =         0x3



} DATABITS_SET;



/*---------------------------------------------------------------------------------------------------------*/

/* PARITY Setting */

/*---------------------------------------------------------------------------------------------------------*/



typedef enum 

{

DRVUART_PARITY_NONE = 0x0,

DRVUART_PARITY_ODD         =        0x1,

DRVUART_PARITY_EVEN =        0x3,

DRVUART_PARITY_MARK =        0x5,

DRVUART_PARITY_SPACE =        0x7

} PARITY_SET;



/*---------------------------------------------------------------------------------------------------------*/

/* STOP BIT */

/*---------------------------------------------------------------------------------------------------------*/



typedef enum 

{

DRVUART_STOPBITS_1 = 0x0,

DRVUART_STOPBITS_1_5        = 0x1,

DRVUART_STOPBITS_2 = 0x1

} STOPBITS_SET;





/*---------------------------------------------------------------------------------------------------------*/

/* FIFO Select */

/*---------------------------------------------------------------------------------------------------------*/

typedef enum 

{

DRVUART_FIFO_1BYTES = 0x0, 

DRVUART_FIFO_4BYTES = 0x1,

DRVUART_FIFO_8BYTES = 0x2,

DRVUART_FIFO_14BYTES = 0x3,

DRVUART_FIFO_30BYTES = 0x4,

DRVUART_FIFO_46BYTES = 0x5,

DRVUART_FIFO_62BYTES = 0x6

}FIFO_SET;



/*****************************************

//串口中断类

*****************************************/

class uart0_int_c :public interrupt_t{

public:

uart0_int_c(uint32_t u32Bandrate = 9600 ,PARITY_SET u8cParity=DRVUART_PARITY_NONE,\

STOPBITS_SET u8cStopBits=DRVUART_STOPBITS_1,DATABITS_SET u8cDataBits=DRVUART_DATABITS_8,\

FIFO_SET u8cRxTriggerLevel= DRVUART_FIFO_1BYTES);



void Uart0Close();

void Uart0RxEnableInt();//接收中断使能

void Uart0RxDisableInt();//接受中断失效

uint8_t Wstr(const char *);

uint8_t Write(uint32_t *,uint32_t);//发送数据

uint8_t Read(uint32_t * ,uint32_t);//读接收的数据



protected:

bool isr(int vector);

void dsr(int vector,uintptr_t count);



private:

void BaudRateSet(uint32_t clk, uint32_t baudRate);

};



#endif




uart.cpp串口代码
复制
#include <NUC1xx.h>

#include"NUC1xxM051Seriescfg.h"

#include"LOOK_config.h"

#include"Uart.h"



//构造函数，并可以设置波特率,校验,数据位,停止位，UART_FIFO

uart0_int_c::uart0_int_c(uint32_t u32Bandrate  ,PARITY_SET u8cParity,\

STOPBITS_SET u8cStopBits,DATABITS_SET u8cDataBits,\

FIFO_SET u8cRxTriggerLevel){

  

  //将管脚设置为UART0模式

  SYSs.GPBMFP.Bits.UART0_RX=1;

  SYSs.GPBMFP.Bits.UART0_TX=1;

  SYSs.GPBMFP.Bits.UART0_nRTS_nWRL=1;

  SYSs.GPBMFP.Bits.UART0_nCTS_nWRH=1;  //SYSs.GPBMFP.Regs|=0x0f;

   /* Reset IP */

  SYSs.IPRSTC2.Bits.UART0_RST = 1;

        SYSs.IPRSTC2.Bits.UART0_RST = 0;

                

        /* Enable UART0 clock */

  SYSCLKs.APBCLK.Bits.UART0_EN=1;

  

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

  UART0s.FCR.Bits.RFR =1;



  /* Set Rx Trigger Level */

        UART0s.FCR.Bits.RFITL = u8cRxTriggerLevel;  

        

        /* Set Parity & Data bits & Stop bits */

        UART0s.LCR.Bits.SPE        =(u8cParity&0x4)?1:0;

        UART0s.LCR.Bits.EPE        =(u8cParity&0x2)?1:0;

        UART0s.LCR.Bits.PBE        =(u8cParity&0x1)?1:0;

                

        UART0s.LCR.Bits.WLS        =u8cDataBits;

        UART0s.LCR.Bits.NSB        =DRVUART_STOPBITS_1;

                

        /* Set Time-Out */

        UART0s.TOR.Bits.TOIC        =0x7f;



  //设置UART时钟为外部12M时钟

  SYSCLKs.CLKSEL1.Bits.UART_S = 0;



  BaudRateSet(F_CPU,u32Bandrate);//设置波特率

  }

//关闭UART0串口

void uart0_int_c::Uart0Close()

{

  while(UART0s.FSR.Bits.TE_FLAG);

  SYSCLKs.APBCLK.Bits.UART0_EN = 0;

  vector_t::disable(UART0_IRQn);

}

//使能UART0接收中断

void uart0_int_c::Uart0RxEnableInt()

{

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

        attach(UART0_IRQn);

        vector_t::enable(UART0_IRQn);

}

//失效

void uart0_int_c::Uart0RxDisableInt()

{

        UART0s.IER.Bits.RDA_IEN=0;

    vector_t::disable(UART0_IRQn);

}



uint8_t uart0_int_c::Wstr(const char *wstrbuf)

{

        uint32_t u32delayno=0;



        do{

                u32delayno = 0;

                UART0s.DATA.Regs=*wstrbuf++;

                

                   while (UART0s.FSR.Bits.TE_FLAG !=1)                                                            /* Wait Tx empty and Time-out manner */

               {

                   u32delayno++;

                   if ( u32delayno >= 0x1000)                 

                      return 0;                                       

               }

        }while(*wstrbuf!='\0');        



        return 1;

}

//发送数据

uint8_t uart0_int_c::Write(uint32_t        *pu32TxBuf,         uint32_t u32WriteBytes)

{

  uint32_t  u32Count, u32delayno;



  for (u32Count=0; u32Count<u32WriteBytes; u32Count++)

  {

     u32delayno = 0;

           while (UART0s.FSR.Bits.TE_FLAG !=1)                                                            /* Wait Tx empty and Time-out manner */

       {

                   u32delayno++;

                   if ( u32delayno >= 0x1000)                 

                      return 0;                    

                                   

       }

           UART0s.DATA.Regs = pu32TxBuf[u32Count];                                                /* Send UART Data from buffer */

    }



    return 1;

        

  

}



//读数据



uint8_t uart0_int_c::Read(uint32_t        *pu32RxBuf, uint32_t        u32ReadBytes)

{

    uint32_t  u32Count, u32delayno;



    for (u32Count=0; u32Count < u32ReadBytes; u32Count++)

    {

                 u32delayno = 0;

             while (UART0s.FSR.Bits.RX_EMPTY ==1)                                            /* Check RX empty => failed */           

             {

                     u32delayno++;        

                if ( u32delayno >= 0x1000 )        

                        return 0;               

         }

         pu32RxBuf[u32Count] = UART0s.DATA.Regs;                                            /* Get Data from UART RX  */

    }



    return 1;

        

}







//M0库中的波特率设置函数

void uart0_int_c::BaudRateSet(uint32_t clk, uint32_t baudRate)

{

  int32_t tmp;

        int32_t div;



        if(((clk / baudRate)%16)<3)              /* Source Clock mod 16 <3 => Using Divider X =16 (MODE#0) */ 

        {                                                                  

                UART0s.BAUD.Bits.DIV_X_EN = 0;

          UART0s.BAUD.Bits.DIV_X_ONE   = 0;

                tmp = clk / baudRate/16  -2;

        }

        else                                                          /* Source Clock mod 16 >3 => Up 5% Error BaudRate */

        {

            UART0s.BAUD.Bits.DIV_X_EN = 1;                          /* Try to Set Divider X = 1 (MODE#2)*/

            UART0s.BAUD.Bits.DIV_X_ONE   = 1;

                tmp = clk / baudRate  -2;



                if(tmp > 0xFFFF)                          /* If Divider > Range  */

                {

                        UART0s.BAUD.Bits.DIV_X_EN = 1;                  /* Try to Set Divider X up 10 (MODE#1) */

                        UART0s.BAUD.Bits.DIV_X_ONE   = 0;



                        for(div = 8; div <16;div++)

                        {

                                if(((clk / baudRate)%(div+1))<3)

                                {

                                        UART0s.BAUD.Bits.DIVIDER_X   = div;

                                        tmp = clk / baudRate / (div+1) -2;

                                        break;

                                }

                        }

                }

        }



        UART0s.BAUD.Bits.BRD = tmp; 



}



main.cpp主文件
复制
#include <NUC1xx.h>

#include"NUC1xxM051Seriescfg.h"

#include "main.h"

#include"M0Base.h"

#include"Uart.h"







/******************************************/

//声明对象

///////////////////////////////////////////

//key_int_c key;

led_ctl_c led1;

uart0_int_c uart0;



#ifdef LOOK_SCHEDULING_PRIORITY

instantiate::task<task1_main_t, LOOK_STACK_SIZE> task1_main(0);

instantiate::task<task2_uart0_c,LOOK_STACK_SIZE> task2_uart0(1);

#else

instantiate::task<task1_main_t, LOOK_STACK_SIZE> task1_main;

instantiate::task<task2_uart0_c,LOOK_STACK_SIZE> task2_uart0;

#endif





/*************************************

//task1任务类的任务函数

**************************************/

void task1_main_t::routine()

{

        led_ctl_c led;

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

        while (true) {



                led.Led1to4();

                scheduler.yield();

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

        }

}



/***************************************

//

***************************************/

void task2_uart0_c::routine()

{

        uart0.Uart0RxEnableInt();  //使能接受中断



        while(true){

                #ifdef _DEBUG_

                        uart0.Wstr("before uart_megs");

                #endif

                uint32_t msg=uart_megs.get();

                uart0.Wstr("接收的内容:");

                uart0.Write(&msg,1);          //发送接收的数据

    uart0.Wstr("\n");



        }

}

/***************************************

*按键中断类成员函数

****************************************/

inline key_int_c::key_int_c()

{

  attach(EINT0_IRQn); //将中断号和本对象挂钩

  attach(EINT1_IRQn);

  GPIOBs.IEN.Regs = (1 << Pin15) | (1 << Pin14);   // 开启中断

  vector_t::enable(EINT0_IRQn);//必须在有main.h的头文件中 

  vector_t::enable(EINT1_IRQn);

}

// Keyboard_t 中断服务例程

bool key_int_c::isr(int vector)

{

  GPIOBs.ISRC.Regs = GPIOBs.ISRC.Regs;   // 清中断 flag

  return true;

}

// Keyboard_t 中断滞后服务例程

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

{

  if (vector == EINT0_IRQn) 

  {

  //  led1.Led4to1();   

  }

  else if (vector == EINT1_IRQn) 

  {

   //  led1.Led1to4();  

  }

}



/*********************************

//uart0类的成员函数

***********************************/

bool uart0_int_c::isr(int vector)

{

        #ifdef _DEBUG_

                uart0.Wstr("Into uart0 isr\n");

        #endif        



        return true;

}



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

{

        uint32_t buf=0;

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

        {

                #ifdef _DEBUG_

                        uart0.Wstr("Into uart0 dsr\n");

                #endif

//                do{

      buf=UART0s.DATA.Regs;

                        task2_uart0.uart_megs.do_tryput(buf);        //读取接收的数据

//      task2_uart0.uart_megs.do_tryput('a');        

//                }while(UART0s.ISR.Bits.RDA_IF!=0);        

        }

                

}



其他代码不贴了，要的大家看程序，希望老师、大叔和大家多多提提意见，好让我提高下
有问题也可以一起多多交流下

LOOK实现串口类.rar

958.37 KB

使用特权

评论回复 赏

相关下载

相关帖子

沙发
john_lee| | 2011-9-29 00:14 | 只看该作者
首先肯定一下楼主的进步，对LOOK的中断处理有了比较深刻的认识。

然后谈谈楼主程序中存在的一些问题：
最严重的，是在uart0_int_c::isr()函数，该函数并没有对UART硬件有任何操作，而是直接返回了true，RDA_IF会一直存在，中断发生的条件没有消失，这将导致中断返回后再次进入中断。
其次，程序中有忙等存在，没有使用同步对象。
第三，使用邮箱来传递单字节数据，效率较低。

以上只是指出了主要的错误所在，我先不给出解决的方法，希望楼主自己能想出。
再次鼓励一下。

使用特权

评论回复 赏
板凳
nixianmin|  楼主 | 2011-9-29 07:16 | 只看该作者
2# john_lee 老师，串口的RDA_IF位是只读的，当RxFIFO跌落到极限级别该位清除，所以当我dsr读数据时就会使该位自动清除了，我试了也没遇到重复进入中断的情况。

2、忙等待是指在LED里的吧，差点忘了，是因为以前两个灯的任务一用look::delay函数任务就会进入就绪态，运行另一个灯的任务，这样灯就显示不错我要的效果，这个程序可以用delay函数来延时了

3、邮箱这个倒是可以不同邮箱直接将数据发送，我就是想试试邮箱的阻塞效果，当邮箱没信息get()所在的任务会阻塞，当邮箱就收到消息时，该任务激活，并通过get()获得消息发送

使用特权

评论回复 赏
地板
Swallow_0322| | 2011-9-29 08:04 | 只看该作者
值得学习，加油！:victory:

使用特权

评论回复 赏
5楼
nixianmin|  楼主 | 2011-9-29 08:10 | 只看该作者
Swallow_0322 嘿嘿，我都是参考你的帖子写的，希望能多带小弟玩玩

使用特权

评论回复 赏
6楼
hotpower| | 2011-9-29 08:30 | 只看该作者
不错学习，交流和进步！

使用特权

评论回复 赏
7楼
nixianmin|  楼主 | 2011-9-29 10:13 | 只看该作者
刚才想了好多，很多机制没想通，关于老师第三个问题我想老师是想我用其他机制，像事件标志类，如果有中断发生则标志事件，并在任务中判断标志来进行

使用特权

评论回复 赏
8楼
nixianmin|  楼主 | 2011-9-29 16:29 | 只看该作者
刚才发现mmbox在接收字符串很有优势，尤其是命令，晚上发帖解说下

使用特权

评论回复 赏
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

nixianmin
个人签名：电机控制，TI InstaSpin Foc交流群：335663930

40

主题

431

帖子

6

粉丝