开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
IrDA.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：8k
源码类别：

uCOS

开发平台：

C/C++

IrDA.c：源码内容
  1. #include <string.h>
  2. #include <stdlib.h>
  3. #include "2440addr.h"
  4. #include "2440lib.h"
  5. #include "def.h"
  6. #include "irda.h"
  8. #define IrDA_BUFLEN 0x100
  10. void IrDA_Port_Set(void);
  11. void IrDA_Port_Return(void);
  13. void __irq IrDA_TxInt(void);
  14. void __irq IrDA_RxOrErr(void);
  15. void __sub_IrDA_RxInt(void);
  16. void __sub_IrDA_RxErrInt(void);
  18. volatile U8 *IrDAdataPt;
  19. volatile U8 *IrDAdataFl;
  20. volatile U32 IrDA_cnt,IrDA_end,IrDA_err,IrDA_BAUD;
  21. volatile U32 sirda_rGPBCON,sirda_rGPBDAT,sirda_rGPBUP;
  22. volatile U32 sirda_rGPHCON,sirda_rGPHDAT,sirda_rGPHUP;
  23. volatile U32 sirda_ULCON2,sirda_UCON2,sirda_UFCON2,sirda_UMCON2,sirda_UBRDIV2;
  26. void * func_irda_test[][2]=
  27. {
  28. //     "0123456789012345" max 15磊 肺茄沥窍咯 comment窍技夸.
  29. //IrDA
  30. (void *)Test_IrDA_Rx,  "UART2 IrDA Rx  ",
  31. (void *)Test_IrDA_Tx,  "UART2 IrDA Tx  ",
  32. 0,0
  33. };
  35. void IrDA_Test(void)
  36. {
  37. int i;
  39. Uart_Printf("n======  IrDA Test program start ======n");
  41. while(1)
  42. {
  43. i=0;
  44. Uart_Printf("nn");
  45. while(1)
  46. {   //display menu
  47. Uart_Printf("%2d:%s",i,func_irda_test[i][1]);
  48. i++;
  49. if((int)(func_irda_test[i][0])==0)
  50. {
  51. Uart_Printf("n");
  52. break;
  53. }
  54. if((i%4)==0)
  55. Uart_Printf("n");
  56. }
  58. Uart_Printf("nPress Enter key to exit : ");
  59. i = Uart_GetIntNum();
  60. if(i==-1) break; // return.
  61. if(i>=0 && (i<((sizeof(func_irda_test)-1)/8)) ) // select and execute...
  62. ( (void (*)(void)) (func_irda_test[i][0]) )();
  63. }
  65. Uart_Printf("n====== IrDA Test program end ======n");
  66. }
  71. void IrDA_Port_Set(void)
  72. {
  73.     //Push UART GPIO port configuration
  74.     sirda_rGPBCON=rGPBCON; 
  75.     sirda_rGPBDAT=rGPBDAT;
  76.     sirda_rGPBUP=rGPBUP;
  77.     sirda_rGPHCON=rGPHCON; 
  78.     sirda_rGPHDAT=rGPHDAT;
  79.     sirda_rGPHUP=rGPHUP;
  80.     //Configure IrDA port
  81.     rGPBDAT|=(1<<1);
  82.     rGPBCON&=0x3ffff3;
  83.     rGPBCON|=(1<<2); // Output(nIrDATXDEN)
  84.     rGPBUP|=(1<<1); //Uart port pull-up disable
  85.     rGPHCON&=0x3c0fff;
  86.     rGPHCON|=0x2a000; // TXD2,RXD2
  87.     rGPHUP|=0x1c0; //Uart port pull-up disable
  88.     //Push Uart control registers 
  89.     sirda_ULCON2=rULCON2;
  90.     sirda_UCON2 =rUCON2;
  91.     sirda_UFCON2=rUFCON2;
  92.     sirda_UMCON2=rUMCON2;
  93.     sirda_UBRDIV2=rUBRDIV2;
  94. }       
  95.         
  96. void IrDA_Port_Return(void)
  97. {       
  98.     //Pop UART GPIO port configuration
  99.     rGPBCON=sirda_rGPBCON;
  100.     rGPBDAT=sirda_rGPBDAT;
  101.     rGPBUP =sirda_rGPBUP;
  102.     rGPHCON=sirda_rGPHCON;
  103.     rGPHDAT=sirda_rGPHDAT;
  104.     rGPHUP =sirda_rGPHUP;
  105.     //Pop Uart control registers 
  106.     rULCON2=sirda_ULCON2;
  107.     rUCON2 =sirda_UCON2;
  108.     rUFCON2=sirda_UFCON2;
  109.     rUMCON2=sirda_UMCON2;
  110.     rUBRDIV2=sirda_UBRDIV2;
  111. }
  113. void __irq IrDA_TxInt(void)
  114. {
  115.     rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
  116.     if(IrDA_cnt < (IrDA_BUFLEN))
  117.     {
  118. Uart_Printf("%d,",*IrDAdataPt);
  119. WrUTXH2(*IrDAdataPt++);
  120. IrDA_cnt++;
  121. ClearPending(BIT_UART2);
  122.         rSUBSRCPND=(BIT_SUB_TXD2);
  123.         rINTSUBMSK&=~(BIT_SUB_TXD2);
  124.     }
  125.     else
  126.     {
  127. IrDA_end=1;
  128. while(rUFSTAT2 & 0x2f0); //Until FIFO is empty
  129. while(!(rUTRSTAT2 & 0x4)); //Until Tx shifter is empty
  130.         ClearPending(BIT_UART2);
  131. rINTMSK|=BIT_UART2;
  132.     }
  133. }
  135. void __irq IrDA_RxOrErr(void)
  136. {
  137.     rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2); // Just for the safety
  138.     if(rSUBSRCPND&BIT_SUB_RXD2) __sub_IrDA_RxInt();
  139.     else __sub_IrDA_RxErrInt();
  140.     rSUBSRCPND=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
  141.     rINTSUBMSK&=~(BIT_SUB_RXD2|BIT_SUB_ERR2);
  142.     ClearPending(BIT_UART2);
  143. }
  145. void __sub_IrDA_RxInt(void)
  146. {
  147.     while( (rUFSTAT2 & 0x100) || (rUFSTAT2 & 0xf)  )
  148.     {
  149. *IrDAdataPt=rURXH2;
  150. *IrDAdataPt++;
  151. IrDA_cnt++;
  152.     }
  153.     if(IrDA_cnt >= IrDA_BUFLEN)
  154.     {
  155.      IrDA_end=1;
  156.      rINTMSK|=BIT_UART2;
  157.     }
  158. }
  160. void __sub_IrDA_RxErrInt(void)
  161. {
  162.     switch(rUERSTAT2)//to clear and check the status of register bits
  163.     {
  164. case '1':
  165.     Uart_Printf("Overrun errorn");
  166.     break;
  167. case '2':
  168.     Uart_Printf("Parity errorn");
  169.     break;
  170. case '4':
  171.     Uart_Printf("Frame errorn");
  172.     break;
  173. case '8':
  174.     Uart_Printf("Breake detectn");
  175.     break;
  176. default :
  177.     break;
  178.     }
  179. }
  181. void Test_IrDA_Tx(void)
  182. {
  183.     int i;
  184.     IrDA_cnt=0;
  185.     IrDA_end=0;
  186.     IrDAdataFl=(volatile U8 *)IrDABUFFER;
  187.     IrDAdataPt=(volatile U8 *)IrDABUFFER;
  188.     IrDA_Port_Set();
  189.     Uart_Select(1);
  190.     for(i=0;i<IrDA_BUFLEN;i++) *IrDAdataFl++=i; // Initialize IrDA Tx data
  191.     pISR_UART2=(U32)IrDA_TxInt;
  192.     Uart_Printf("nSelect the baud raten"); // Select IrDA baud rate
  193.     Uart_Printf("1)9600    2)19200    3)38400    4)57600    5)115200n"); 
  194.     i=Uart_Getch ();
  195.     switch(i)
  196.     {
  197. case '1':
  198. IrDA_BAUD=9600;
  199.         break;
  201. case '2':
  202.         IrDA_BAUD=19200;
  203.         break;
  205. case '3':
  206.         IrDA_BAUD=38400;
  207.         break;
  209. case '4':
  210.         IrDA_BAUD=57600;
  211.         break;
  213. case '5':
  214.         IrDA_BAUD=115200;
  215.         break;
  217. default:
  218.         break;
  219.     }
  220.     rUBRDIV2=( (int)(PCLK/16./IrDA_BAUD) -1 );
  221.     Uart_Printf("rUBRDIV2=%dn", rUBRDIV2);
  222.     Uart_Printf("[UART IrDA Tx Test]n");
  223.     Uart_Printf("This test should be configured two boards.n");
  224.     Uart_Printf("Start Rx first and press any key and...n");
  225.     Uart_TxEmpty(1);
  226.     rGPBDAT &= ~(1<<1); // Enable nIrDATXDEN - GPB1
  227.     rUFCON2=(1<<6)|(0<<4)|(1<<2)|(1<<1)|(1);
  228.     //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on
  229.     rUCON2=(0<<10)|(1<<9)|(1<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(0<<2)|(0); // From H/W    
  230.     rULCON2=(1<<6)|(0<<3)|(0<<2)|(3); // IrDA,No parity,One stop bit, 8bit
  231.     Uart_Getch();
  232.     rUCON2 |= (1<<2); // Tx enable
  233.     Uart_Printf("Now... Tx with IrDAn");
  234.     rINTMSK=~(BIT_UART2);
  235.     rINTSUBMSK=~(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
  237.     while(!IrDA_end);
  239.     rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
  240.     rUFCON2=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  241.     rGPBDAT|=(1<<1); // Disable nIrDATXDEN        
  242.     Uart_Printf("nEnd Tx, transfer data count=%dn",IrDA_cnt);
  243.     IrDA_Port_Return();
  244. }
  246. void Test_IrDA_Rx(void)
  247. {
  248.     unsigned int i;
  249.     IrDA_cnt=0;
  250.     IrDA_end=0;
  251.     IrDA_err=0;
  253.     IrDAdataPt =(volatile U8 *)IrDABUFFER; // 0 initialize
  254.     for(i=0;i<IrDA_BUFLEN;i++) *IrDAdataPt++=0; // Initialize IrDA Tx data
  255.     IrDAdataPt =(volatile U8 *)IrDABUFFER;
  257.     IrDA_Port_Set();    
  258.     Uart_Select(1);
  259.     pISR_UART2=(unsigned)IrDA_RxOrErr;
  260.     Uart_Printf("nSelect the baud raten"); // Select IrDA baud rate
  261.     Uart_Printf("1)9600    2)19200    3)38400    4)57600    5)115200n"); 
  262.     i=Uart_Getch();
  263.     switch(i)
  264.     {
  265. case '1':
  266.             IrDA_BAUD=9600;
  267.         break;
  269. case '2':
  270.             IrDA_BAUD=19200;
  271.         break;
  273. case '3':
  274.             IrDA_BAUD=38400;
  275.         break;
  277. case '4':
  278.             IrDA_BAUD=57600;
  279.         break;
  281. case '5':
  282.             IrDA_BAUD=115200;
  283.         break;
  285. default:
  286. break;
  287.     }
  288.     rUBRDIV2=( (int)(PCLK/16./IrDA_BAUD) -1 );
  289.     Uart_Printf("rUBRDIV2=%dn", rUBRDIV2);
  290.     Uart_Printf("[UART IrDA Rx Test]n");
  291.     Uart_Printf("This test should be configured two boards.n");
  292.     Uart_Printf("Press any key to start Rx and then Start Tx....n");
  293.     rUFCON2=(1<<6)|(0<<4)|(1<<2)|(1<<1)|(1);
  294.     //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx Reset,FIFO En
  295.     rUCON2=(0<<10)|(1<<9)|(1<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(0<<2)|(0); // From H/W
  296.     rULCON2=(1<<6)|(0<<3)|(0<<2)|(3); // IrDA,No parity,One stop bit, 8bit
  297.     Uart_Getch();
  298.     Uart_Printf("Now... Rx with IrDAn");
  299.     rUCON2 |= 1; // Rx enable
  300.     rINTMSK=~(BIT_UART2);
  301.     rINTSUBMSK=~(BIT_SUB_RXD2|BIT_SUB_ERR2);
  303.     while(!IrDA_end) if(Uart_GetKey()=='r') break;
  304.     
  305.     rINTSUBMSK|=(BIT_SUB_RXD2|BIT_SUB_TXD2|BIT_SUB_ERR2);
  306.     rUFCON2=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  307.     Uart_Printf("nEnd Rx, receive data count=%dn",IrDA_cnt);
  309.     IrDAdataPt =(volatile U8 *)IrDABUFFER;
  310.     for(i=0;i<IrDA_BUFLEN;i++)
  311.     {
  312. if(i-(*IrDAdataPt))
  313. {
  314.     Uart_Printf("i=%d,",i);
  315.     IrDA_err++;
  316. }
  317. else
  318. Uart_Printf("%d,",*IrDAdataPt++);
  319.     }
  320.     if(IrDA_err)
  321.      Uart_Printf("IrDA test fail!! Error count=%dn",IrDA_err);
  322.     else
  323.      Uart_Printf("nIrDA test is good!!n");
  324.     IrDA_Port_Return();
  325. }