NRF24L01无线模块收发程序(实测成功 多图)

       本模块是NRF24L01无线传输模块，用于无线传输数据，距离不远，一般只是能够满足小距离的传输，目测是4-5m，价格一般是4元左右，可以方便的买到。

       51最小系统学习板就可以，当时是用了两块学习板，一块用于发送，一块用于接收。

         小车也是比较容易购到的，四个端口控制两个电机，两个控制一个电机，当两个端口高低电平不同时电机就会转动，即为赋值1和0是电机转动，赋值可以用单片机作用，当然这是小车启动部分，前进后退左转右转就是你赋值0和1的顺序问题了。

       整体思路是用发射端的按键控制小车，即为按键按下就前进，再按其他按键实现其他功能，本次程序是在用NRF24L01发射数据在接收端用1602显示的基础上改变。
下面是程序源码（有好几个文件，分别创建）

1. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
2. #include
   
3. #include
   
4. #include'1602.h'
   
5. #include'delay.h'
   
6. #include 'nrf24l01.h'
   
7. #define uint unsigned int
   
8. #define uchar unsigned char
   
9. uint Weight_Shiwu=1234;
   
10. unsigned char KeyScan(void);//键盘扫描
    
11. // unsigned char KeyScan(void);//键盘扫描
    
12. 
    
13. //#define KeyPort P0
    
14. sbit KEY1 = P0^0;
    
15. sbit KEY2 = P0^1;
    
16. sbit KEY3 = P0^2;
    
17. sbit KEY4 = P0^3;
    
18. sbit KEY5 = P0^4;
    
19. void main()
    
20. {
    
21. // char TxDate[4];
    
22. // LCD_Init(); //初始化液晶屏
    
23. // LCD_Clear(); //清屏
    
24. // NRF24L01Int(); //初始化LCD1602
    
25. // LCD_Write_String(4,0,'welcome');
    
26. while(1)
    
27. {
    
28. KeyScan();
    
29. 
    
30. }
    
31. }
    
32. 
    
33. 
    
34. 
    
35. 
    
36. unsigned char KeyScan(void)
    
37. {
    
38. /********************************************************/
    
39. char TxDate[4];
    
40. {
    
41. if(!KEY1) //如果检测到低电平，说明按键按下
    
42. {
    
43. DelayMs(10); //延时去抖，一般10-20ms
    
44. if(!KEY1) //再次确认按键是否按下，没有按下则退出
    
45. {
    
46. while(!KEY1);//如果确认按下按键等待按键释放，没有则退出
    
47. {
    
48. TxDate[0] = 1;//向左转
    
49. TxDate[1] = 0;
    
50. TxDate[2] = 1;
    
51. TxDate[3] = 1;
    
52. NRFSetTxMode(TxDate);//发送数据·
    
53. while(CheckACK()); //检测是否发送完毕
    
54. }
    
55. }
    
56. }
    
57. /********************************************************/
    
58. else if(!KEY2) //如果检测到低电平，说明按键按下
    
59. {
    
60. DelayMs(10); //延时去抖，一般10-20ms
    
61. if(!KEY2) //再次确认按键是否按下，没有按下则退出
    
62. {
    
63. while(!KEY2);//如果确认按下按键等待按键释放，没有则退出
    
64. {
    
65. TxDate[0] = 1;//向右转
    
66. TxDate[1] = 1;
    
67. TxDate[2] = 1;
    
68. TxDate[3] = 0;
    
69. NRFSetTxMode(TxDate);//发送数据
    
70. while(CheckACK()); //检测是否发送完毕
    
71. }
    
72. }
    
73. }
    
74. /********************************************************/
    
75. else if(!KEY3) //如果检测到低电平，说明按键按下
    
76. {
    
77. DelayMs(10); //延时去抖，一般10-20ms
    
78. if(!KEY3) //再次确认按键是否按下，没有按下则退出
    
79. {
    
80. while(!KEY3);//如果确认按下按键等待按键释放，没有则退出
    
81. {
    
82. TxDate[0] = 1;//前进
    
83. TxDate[1] = 0;
    
84. TxDate[2] = 1;
    
85. TxDate[3] = 0;
    
86. NRFSetTxMode(TxDate);//发送数据
    
87. while(CheckACK()); //检测是否发送完毕
    
88. }
    
89. }
    
90. }
    
91. /********************************************************/
    
92. else if(!KEY4) //如果检测到低电平，说明按键按下
    
93. {
    
94. DelayMs(10); //延时去抖，一般10-20ms
    
95. if(!KEY4) //再次确认按键是否按下，没有按下则退出
    
96. {
    
97. while(!KEY4);//如果确认按下按键等待按键释放，没有则退出
    
98. {
    
99. TxDate[0] = 0;//后退
    
100. TxDate[1] = 1;
     
101. TxDate[2] = 0;
     
102. TxDate[3] = 1;
     
103. NRFSetTxMode(TxDate);//发送数据
     
104. while(CheckACK()); //检测是否发送完毕
     
105. }
     
106. }
     
107. }
     
108. else if(!KEY5)
     
109. {
     
110. DelayMs(10);
     
111. if(!KEY5)
     
112. {
     
113. while(!KEY5)
     
114. {
     
115. TxDate[0] = 1;
     
116. TxDate[1] = 1;
     
117. TxDate[2] = 1;
     
118. TxDate[3] = 1;
     
119. NRFSetTxMode(TxDate);
     
120. while(CheckACK());
     
121. }
     
122. }
     
123. }
     
124. }
     
125. }

1. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
2. #include
   
3. #include
   
4. #include'1602.h'
   
5. #include'delay.h'
   
6. #include 'nrf24l01.h'
   
7. #define uint unsigned int
   
8. #define uchar unsigned char
   
9. uint Weight;
   
10. sbit a = P2^0;
    
11. sbit b = P2^1;
    
12. sbit c = P2^2;
    
13. sbit d = P2^3;
    
14. void main()
    
15. {
    
16. LCD_Init(); //初始化液晶屏
    
17. LCD_Clear(); //清屏
    
18. *(RevTempDate+4)=*\0*;
    
19. NRF24L01Int();
    
20. while(1)
    
21. {
    
22. 
    
23. NRFSetRXMode();//设置为接收模式
    
24. GetDate();//开始接受数;
    
25. // Weight=RevTempDate[0]*1000+RevTempDate[1]*100+RevTempDate[2]*10+RevTempDate[3];
    
26. LCD_Write_Char(7,0,RevTempDate[0]+0x30);
    
27. LCD_Write_Char(8,0,RevTempDate[1]+0x30);
    
28. LCD_Write_Char(9,0,RevTempDate[2]+0x30);
    
29. LCD_Write_Char(10,0,RevTempDate[3]+0x30);
    
30. a = RevTempDate[0];//根据接受数据来设置高低电平（目测仅限传输1.0两种数值）
    
31. b = RevTempDate[1];
    
32. c = RevTempDate[2];
    
33. d = RevTempDate[3];
    
34. }
    
35. }
    
36. 
    
37. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1. #include
   
2. #include 'nrf24l01.h'
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. sbit IRQ =P1^2;//输入
   
6. sbit MISO =P1^3; //输入
   
7. sbit MOSI =P1^1;//输出
   
8. sbit SCLK =P1^4;//输出
   
9. sbit CE =P1^5;//输出
   
10. sbit CSN =P1^0;//输出
    
11. uchar code TxAddr[]={0x34,0x43,0x10,0x10,0x01};//发送地址
    
12. /*****************状态标志*****************************************/
    
13. uchar bdata sta; //状态标志
    
14. sbit RX_DR=sta^6;
    
15. sbit TX_DS=sta^5;
    
16. sbit MAX_RT=sta^4;
    
17. /*****************SPI时序函数******************************************/
    
18. uchar NRFSPI(uchar date)
    
19. {
    
20. uchar i;
    
21. for(i=0;i<8;i++)>
    
22. {
    
23. if(date&0x80)
    
24. MOSI=1;
    
25. else
    
26. MOSI=0; // byte最高位输出到MOSI
    
27. date<=1;>
    
28. SCLK=1;
    
29. if(MISO) // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
    
30. date|=0x01; // 读MISO到byte最低位
    
31. SCLK=0; // SCK置低
    
32. }
    
33. return(date); // 返回读出的一字节
    
34. }
    
35. /**********************NRF24L01初始化函数*******************************/
    
36. void NRF24L01Int()
    
37. {
    
38. DDelay(2);//让系统什么都不干
    
39. CE=0; //待机模式1
    
40. CSN=1;
    
41. SCLK=0;
    
42. IRQ=1;
    
43. }
    
44. /*****************SPI读寄存器一字节函数*********************************/
    
45. uchar NRFReadReg(uchar RegAddr)
    
46. {
    
47. uchar BackDate;
    
48. CSN=0;//启动时序
    
49. NRFSPI(RegAddr);//写寄存器地址
    
50. BackDate=NRFSPI(0x00);//写入读寄存器指令
    
51. CSN=1;
    
52. return(BackDate); //返回状态
    
53. }
    
54. /*****************SPI写寄存器一字节函数*********************************/
    
55. uchar NRFWriteReg(uchar RegAddr,uchar date)
    
56. {
    
57. uchar BackDate;
    
58. CSN=0;//启动时序
    
59. BackDate=NRFSPI(RegAddr);//写入地址
    
60. NRFSPI(date);//写入值
    
61. CSN=1;
    
62. return(BackDate);
    
63. }
    
64. /*****************SPI读取RXFIFO寄存器的值********************************/
    
65. uchar NRFReadRxDate(uchar RegAddr,uchar *RxDate,uchar DateLen)
    
66. { //寄存器地址//读取数据存放变量//读取数据长度//用于接收
    
67. uchar BackDate,i;
    
68. CSN=0;//启动时序
    
69. BackDate=NRFSPI(RegAddr);//写入要读取的寄存器地址
    
70. for(i=0;i
    
71. {
    
72. RxDate[i]=NRFSPI(0);
    
73. }
    
74. CSN=1;
    
75. return(BackDate);
    
76. }
    
77. /*****************SPI写入TXFIFO寄存器的值**********************************/
    
78. uchar NRFWriteTxDate(uchar RegAddr,uchar *TxDate,uchar DateLen)
    
79. { //寄存器地址//写入数据存放变量//读取数据长度//用于发送
    
80. uchar BackDate,i;
    
81. CSN=0;
    
82. BackDate=NRFSPI(RegAddr);//写入要写入寄存器的地址
    
83. for(i=0;i
    
84. {
    
85. NRFSPI(*TxDate++);
    
86. }
    
87. CSN=1;
    
88. return(BackDate);
    
89. }
    
90. /*****************NRF设置为发送模式并发送数据******************************/
    
91. void NRFSetTxMode(uchar *TxDate)
    
92. {//发送模式
    
93. CE=0;
    
94. NRFWriteTxDate(W_REGISTER+TX_ADDR,TxAddr,TX_ADDR_WITDH);//写寄存器指令+接收地址使能指令+接收地址+地址宽度
    
95. NRFWriteTxDate(W_REGISTER+RX_ADDR_P0,TxAddr,TX_ADDR_WITDH);//为了应答接收设备，接收通道0地址和发送地址相同
    
96. NRFWriteTxDate(W_TX_PAYLOAD,TxDate,TX_DATA_WITDH);//写入数据
    
97. /******下面有关寄存器配置**************/
    
98. NRFWriteReg(W_REGISTER+EN_AA,0x01); // 使能接收通道0自动应答
    
99. NRFWriteReg(W_REGISTER+EN_RXADDR,0x01); // 使能接收通道0
    
100. NRFWriteReg(W_REGISTER+SETUP_RETR,0x0a); // 自动重发延时等待250us+86us，自动重发10次
     
101. NRFWriteReg(W_REGISTER+RF_CH,0x40); // 选择射频通道0x40
     
102. NRFWriteReg(W_REGISTER+RF_SETUP,0x07); // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
     
103. NRFWriteReg(W_REGISTER+CONFIG,0x0e); // CRC使能，16位CRC校验，上电
     
104. CE=1;
     
105. DDelay(5);//保持10us秒以上
     
106. }
     
107. /*****************NRF设置为接收模式并接收数据******************************/
     
108. //主要接收模式
     
109. void NRFSetRXMode()
     
110. {
     
111. CE=0;
     
112. NRFWriteTxDate(W_REGISTER+RX_ADDR_P0,TxAddr,TX_ADDR_WITDH); // 接收设备接收通道0使用和发送设备相同的发送地址
     
113. NRFWriteReg(W_REGISTER+EN_AA,0x01); // 使能接收通道0自动应答
     
114. NRFWriteReg(W_REGISTER+EN_RXADDR,0x01); // 使能接收通道0
     
115. NRFWriteReg(W_REGISTER+RF_CH,0x40); // 选择射频通道0x40
     
116. NRFWriteReg(W_REGISTER+RX_PW_P0,TX_DATA_WITDH); // 接收通道0选择和发送通道相同有效数据宽度
     
117. NRFWriteReg(W_REGISTER+RF_SETUP,0x07); // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益*/
     
118. NRFWriteReg(W_REGISTER+CONFIG,0x0f); // CRC使能，16位CRC校验，上电，接收模式
     
119. CE = 1;
     
120. DDelay(5);//保持10us秒以上
     
121. }
     
122. /****************************检测应答信号******************************/
     
123. uchar CheckACK()
     
124. { //用于发射
     
125. sta=NRFReadReg(R_REGISTER+STATUS); // 返回状态寄存器
     
126. if(TX_DS||MAX_RT) //发送完毕中断
     
127. {
     
128. NRFWriteReg(W_REGISTER+STATUS,0xff); // 清除TX_DS或MAX_RT中断标志
     
129. CSN=0;
     
130. NRFSPI(FLUSH_TX);//用于清空FIFO ！！关键！！不然会出现意想不到的后果！！！大家记住！！
     
131. CSN=1;
     
132. return(0);
     
133. }
     
134. else
     
135. return(1);
     
136. }
     
137. /******************判断是否接收收到数据，接到就从RX取出*********************/
     
138. //用于接收模式
     
139. uchar NRFRevDate(uchar *RevDate)
     
140. {
     
141. uchar RevFlags=0;
     
142. sta=NRFReadReg(R_REGISTER+STATUS);//发送数据后读取状态寄存器
     
143. if(RX_DR) // 判断是否接收到数据
     
144. {
     
145. CE=0; //SPI使能
     
146. NRFReadRxDate(R_RX_PAYLOAD,RevDate,RX_DATA_WITDH);// 从RXFIFO读取数据
     
147. RevFlags=1; //读取数据完成标志
     
148. }
     
149. NRFWriteReg(W_REGISTER+STATUS,0xff); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标
     
150. return(RevFlags);
     
151. }
     
152. void DDelay(uint t)
     
153. {
     
154. uint x,y;
     
155. for(x=t;x>0;x--)
     
156. for(y=110;y>0;y--);
     
157. }
     
158. ////////////////////////////////////////////////////////////////////////////////////////////////////////

1. #include 'delay.h'
   
2. /*------------------------------------------------
   
3. uS延时函数，含有输入参数 unsigned char t，无返回值
   
4. unsigned char 是定义无符号字符变量，其值的范围是
   
5. 0~255 这里使用晶振12M，精确延时请使用汇编,大致延时
   
6. 长度如下 T=tx2+5 uS
   
7. ------------------------------------------------*/
   
8. void DelayUs2x(unsigned char t)
   
9. {
   
10. while(--t);
    
11. }
    
12. /*------------------------------------------------
    
13. mS延时函数，含有输入参数 unsigned char t，无返回值
    
14. unsigned char 是定义无符号字符变量，其值的范围是
    
15. 0~255 这里使用晶振12M，精确延时请使用汇编
    
16. ------------------------------------------------*/
    
17. void DelayMs(unsigned char t)
    
18. {
    
19. 
    
20. while(t--)
    
21. {
    
22. //大致延时1mS
    
23. DelayUs2x(245);
    
24. DelayUs2x(245);
    
25. 
    
26. }
    
27. }
    
28. ///////////////////////////////////////////////////////////////////////////////////////////

1. 下面是接收的NRF24L01的程序。
   
2. #include
   
3. #include 'nrf24l01.h'
   
4. #include
   
5. #define uchar unsigned char
   
6. #define uint unsigned int
   
7. 
   
8. sbit IRQ =P1^2;//输入
   
9. sbit MISO =P1^3; //输入
   
10. sbit MOSI =P1^1;//输出
    
11. sbit SCLK =P1^4;//输出
    
12. sbit CE =P1^5;//输出
    
13. sbit CSN =P1^0;//输出
    
14. 
    
15. 
    
16. uchar RevTempDate[5];//最后一位用来存放结束标志
    
17. uchar code TxAddr[]={0x34,0x43,0x10,0x10,0x01};//发送地址
    
18. /*****************状态标志*****************************************/
    
19. uchar bdata sta; //状态标志
    
20. sbit RX_DR=sta^6;
    
21. sbit TX_DS=sta^5;
    
22. sbit MAX_RT=sta^4;
    
23. /*****************SPI时序函数******************************************/
    
24. uchar NRFSPI(uchar date)
    
25. {
    
26. uchar i;
    
27. for(i=0;i<8;i++)>
    
28. {
    
29. if(date&0x80)
    
30. MOSI=1;
    
31. else
    
32. MOSI=0; // byte最高位输出到MOSI
    
33. date<=1;>
    
34. SCLK=1;
    
35. if(MISO) // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
    
36. date|=0x01; // 读MISO到byte最低位
    
37. SCLK=0; // SCK置低
    
38. }
    
39. return(date); // 返回读出的一字节
    
40. }
    
41. /**********************NRF24L01初始化函数*******************************/
    
42. void NRF24L01Int()
    
43. {
    
44. NRFDelay(2);//让系统什么都不干
    
45. CE=0;
    
46. CSN=1;
    
47. SCLK=0;
    
48. IRQ=1;
    
49. }
    
50. /*****************SPI读寄存器一字节函数*********************************/
    
51. uchar NRFReadReg(uchar RegAddr)
    
52. {
    
53. uchar BackDate;
    
54. CSN=0;//启动时序
    
55. NRFSPI(RegAddr);//写寄存器地址
    
56. BackDate=NRFSPI(0x00);//写入读寄存器指令
    
57. CSN=1;
    
58. return(BackDate); //返回状态
    
59. }
    
60. /*****************SPI写寄存器一字节函数*********************************/
    
61. uchar NRFWriteReg(uchar RegAddr,uchar date)
    
62. {
    
63. uchar BackDate;
    
64. CSN=0;//启动时序
    
65. BackDate=NRFSPI(RegAddr);//写入地址
    
66. NRFSPI(date);//写入值
    
67. CSN=1;
    
68. return(BackDate);
    
69. }
    
70. /*****************SPI读取RXFIFO寄存器的值********************************/
    
71. uchar NRFReadRxDate(uchar RegAddr,uchar *RxDate,uchar DateLen)
    
72. { //寄存器地址//读取数据存放变量//读取数据长度//用于接收
    
73. uchar BackDate,i;
    
74. CSN=0;//启动时序
    
75. BackDate=NRFSPI(RegAddr);//写入要读取的寄存器地址
    
76. for(i=0;i
    
77. {
    
78. RxDate[i]=NRFSPI(0);
    
79. }
    
80. CSN=1;
    
81. return(BackDate);
    
82. }
    
83. /*****************SPI写入TXFIFO寄存器的值**********************************/
    
84. uchar NRFWriteTxDate(uchar RegAddr,uchar *TxDate,uchar DateLen)
    
85. { //寄存器地址//写入数据存放变量//读取数据长度//用于发送
    
86. uchar BackDate,i;
    
87. CSN=0;
    
88. BackDate=NRFSPI(RegAddr);//写入要写入寄存器的地址
    
89. for(i=0;i
    
90. {
    
91. NRFSPI(*TxDate++);
    
92. }
    
93. CSN=1;
    
94. return(BackDate);
    
95. }
    
96. /*****************NRF设置为发送模式并发送数据******************************/
    
97. void NRFSetTxMode(uchar *TxDate)
    
98. { //发送模式
    
99. CE=0;
    
100. NRFWriteTxDate(W_REGISTER+TX_ADDR,TxAddr,TX_ADDR_WITDH);//写寄存器指令+P0地址使能指令+发送地址+地址宽度
     
101. NRFWriteTxDate(W_REGISTER+RX_ADDR_P0,TxAddr,TX_ADDR_WITDH);//为了应答接收设备，接收通道0地址和发送地址相同
     
102. NRFWriteTxDate(W_TX_PAYLOAD,TxDate,TX_DATA_WITDH);//写入数据
     
103. /******下面有关寄存器配置**************/
     
104. NRFWriteReg(W_REGISTER+EN_AA,0x01); // 使能接收通道0自动应答
     
105. NRFWriteReg(W_REGISTER+EN_RXADDR,0x01); // 使能接收通道0
     
106. NRFWriteReg(W_REGISTER+SETUP_RETR,0x0a); // 自动重发延时等待250us+86us，自动重发10次
     
107. NRFWriteReg(W_REGISTER+RF_CH,0x40); // 选择射频通道0x40
     
108. NRFWriteReg(W_REGISTER+RF_SETUP,0x07); // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
     
109. NRFWriteReg(W_REGISTER+CONFIG,0x0e); // CRC使能，16位CRC校验，上电
     
110. CE=1;
     
111. NRFDelay(5);//保持10us秒以上
     
112. }
     
113. /*****************NRF设置为接收模式并接收数据******************************/
     
114. //接收模式
     
115. void NRFSetRXMode()
     
116. {
     
117. CE=0;
     
118. NRFWriteTxDate(W_REGISTER+RX_ADDR_P0,TxAddr,TX_ADDR_WITDH); // 接收设备接收通道0使用和发送设备相同的发送地址
     
119. NRFWriteReg(W_REGISTER+EN_AA,0x01); // 使能接收通道0自动应答
     
120. NRFWriteReg(W_REGISTER+EN_RXADDR,0x01); // 使能接收通道0
     
121. NRFWriteReg(W_REGISTER+RF_CH,0x40); // 选择射频通道0x40
     
122. NRFWriteReg(W_REGISTER+RX_PW_P0,TX_DATA_WITDH); // 接收通道0选择和发送通道相同有效数据宽度
     
123. NRFWriteReg(W_REGISTER+RF_SETUP,0x07); // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
     
124. NRFWriteReg(W_REGISTER+CONFIG,0x0f); // CRC使能，16位CRC校验，上电，接收模式
     
125. CE = 1;
     
126. NRFDelay(5);
     
127. }
     
128. /****************************检测是否有接收到数据******************************/
     
129. void CheckACK()
     
130. { //用于发射模式接收应答信号
     
131. sta=NRFReadReg(R_REGISTER+STATUS); // 返回状态寄存器
     
132. if(TX_DS)
     
133. NRFWriteReg(W_REGISTER+STATUS,0xff); // 清除TX_DS或MAX_RT中断标志
     
134. }
     
135. /*************************接收数据*********************************************/
     
136. void GetDate()
     
137. {
     
138. sta=NRFReadReg(R_REGISTER+STATUS);//发送数据后读取状态寄存器
     
139. if(RX_DR) // 判断是否接收到数据
     
140. {
     
141. CE=0;//待机
     
142. NRFReadRxDate(R_RX_PAYLOAD,RevTempDate,RX_DATA_WITDH);// 从RXFIFO读取数据 接收4位即可，后一位位结束位
     
143. NRFWriteReg(W_REGISTER+STATUS,0xff); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标
     
144. CSN=0;
     
145. NRFSPI(FLUSH_RX);//用于清空FIFO ！！关键！！不然会出现意想不到的后果！！！大家记住！！
     
146. CSN=1;
     
147. }
     
148. //NRFWriteReg(W_REGISTER+STATUS,0xff); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标
     
149. }
     
150. void NRFDelay(uint t)
     
151. {
     
152. uint x,y;
     
153. for(x=t;x>0;x--)
     
154. for(y=110;y>0;y--);
     
155. }