• 山东大学单片机原理与应用实验 3.7LCD 1602显示实验

    目录

    一、实验题目

    二、实验要求

    三、实验过程及结果分析

    四、实验流程图

    五、实验源代码

    一、实验题目

    3.7 LCD 1602显示实验

    二、实验要求

    1、画出实验的流程图

    2、编写源程序并进行注释

    3、记录实验过程

    4、记录程序运行结果截图

    三、实验过程及结果分析

    要求利用LCD1602和16个按键实现简单的十进制数的加减乘除四则运算。其中按键KEY0-KEY9代表数字0-9，按键KEY10-KEY13分别代表运算符+、-、*、/，按键KEY15代表=，按键KEY14代表清除命令。不管什么时候按下清除按键，计算过程均将停止，两个输入变量清零，屏幕将清屏。

    LCD1602第一行用于显示所输入的两个计算数以及计算符，第二行用于显示计算结果，结果允许为附属，但输入的两个输入数都必须是双字节正整数范围内的数，即0-32767.除数必须保证不为0，否则将报错。在有余数除法中，必须能同时显示商与余数。

    1. 在Proteus 环境下建立图1所示原理图，并将其保存为LCD1602_self.DSN 文件：

    图1：实验原理图

    2. 编写源程序，将其保存为LCD1602_self.c。运行Keil开发环境，建立工程LCD1602_self.uV2，CPU 为AT89C51，包含启动文件STARTUP.A51。将C 语言源程序LCD1602_self.c 加入工程LCD1602_self.uV2，并设置工程LCD1602_self.uV2 属性，将其晶振频率设置为12MHz，选择输出可执行文件，仿真方式为选择硬仿真，并选择其中的“PROTEUS VSM

    MONITOR 51 DRIVER”仿真器。

    3. 构造（Build）工程LCD1602_self.uV2。如果输入有误进行修改，直至构造正确，生成可执行程序LCD1602_self.hex 为止，为AT89C51 设置可执行程序LCD1602_self.hex。

    4. 运行程序，点击按键输入数据与运算符，计算，观察计算结果，并验证其是否正确，输入过程中，按“清除按键”观察结果，重新输入数据计算并验证。

       1）加法：1+2=3，如图2：

    图2：加法测试

    2）减法：5-3=2，如图3：

    图3：减法测试

    3）特殊情况：6-9=-3，如图4：

    图4：负数减法测试

    4）乘法：4*5=20，如图5：

    图5：乘法测试

      5) 除法：20/5=4，如图6：

    图6：除法测试

    6) 带余数的除法，如图7：

    图7：带余数的除法测试

    7) 除法为0报错，如图8：

    图8：除法为0报错

    8) 清零，如图9：

    图9：清零

    四、实验流程图

    图10：实验流程图

    编程时要有一个状态变量，该变量用于记录当前是输入的哪个变量。输入第一个变量，遇到输入运算符时结束第一个变量的输入。输入第二个变量，遇到“=”号时结束第二个变量的输入，并且开始计算结果。

    计算结果由于是16 进制的，要将其转换成十进制，并将该十进制的数转换成字符串后逐位显示出来。减法时要注意结果是否为负，除法时要注意除数是否为0，结果是否带有余数。另外，按键要注意去抖动处理。

    采用的是逐行扫描，扫描的时候将要扫描的行置0，其余的行置1；扫描过程中，所有的列全部置1，当某一行的其中一个按键被按下，且正好扫描到这一样，那么所在的列将会被置0. 这时只需要；将行与1111相与即可判断那一列为0，即按下了哪一列。也是实验3.6中键盘扫描的基本思路。

    五、实验源代码

    1. #include<reg51.h>     //预处理伪指令
    2. #define uint unsigned int 
    3. #define uchar unsigned char
    4. sbit lcden=P1^5;       //定义引脚E使能端，高到低液晶模块执行任务
    5. sbit rs=P1^7;
    6. sbit rw=P1^6;         // 控制读写
    7. sbit busy=P0^7;
    8. char i,j,temp,num;
    9. long a=0,b=0,c=0,d=0;  //初始化a参与运算的第一个数，b参与运算的第二个数，c得数，d余数 
    10. float a_c,b_c;
    11. uchar flag,signal;  //flag表示运算符是否按下
    12.                 //signal表示按下运算符的名称
    13.  
    14. uchar code table[]={
    15. 0,1,2,3,
    16. 4,5,6,7,
    17. 8,9,0x2b-0x30,0x2d-0x30,
    18. 0x2a-0x30,0x2f-0x30,0x01-0x30,0x3d-0x30};	 //定义table数组
    19. uchar code error[]="Error!";	//定义error数组，用于显示除数为0的情况
    20.  
    21. void delay(uchar z)     // 设置延迟函数                       
    22. {
    23. 	uchar y;
    24. 	for(z;z>0;z--)
    25.     	for(y=0;y<110;y++);
    26. }
    27. void check()      // 判断系统状态                 
    28. {
    29. 	do
    30. 	{
    31. 	    P2=0xFF;
    32. 	    rs=0;        
    33. 	    rw=1;        
    34. 	    lcden=0;     
    35. 	    delay(1);    
    36. 	    lcden=1;     
    37. 	}
    38. 	while(busy==1);  //判断是否为空闲,1为忙,0为空闲
    39. }
    40. void lcd_wcmd(uchar com) // 写指令             
    41. {
    42. 	P2=com;          
    43. 	rs=0;			  
    44. 	rw=0;			  
    45. 	lcden=0;		 
    46. 	check();
    47. 	lcden=1;		 
    48. }
    49. void lcd_wdat(uchar date)       // 写数据          
    50. {
    51.     P2=date;		
    52. 	rs=1;	        
    53. 	rw=0;			
    54. 	lcden=0;
    55. 	check();
    56. 	lcden=1;
    57. }
    58. void init() //初始化
    59. {
    60.     num=-1;
    61. 	lcden=1;             // 使能信号为高电平
    62. 	lcd_wcmd(0x38);       // 8位,2行，5X7点阵
    63. 	lcd_wcmd(0x0c);      //显示开,光标关,不闪烁
    64. 	lcd_wcmd(0x06);     //增量方式不移位，地址自动增加 
    65. 	lcd_wcmd(0x80);     //检测忙信号
    66. 	lcd_wcmd(0x01);       //清屏
    67. 	i=0;
    68. 	j=0;
    69. 	flag=0;   
    70. 	signal=0;    
    71. }
    72. void keyscan() 	 // 键盘扫描
    73. {
    74.  
    75. 	P3=0xfe; 	  //扫描第一行，后四位是行							
    76. 	if(P3!=0xfe)
    77. 	{
    78.    		delay(20);	//延时去抖动
    79.    		if(P3!=0xfe)		//第一行有键按下  
    80.    		{
    81.     		temp=P3&0xf0;	// 将列与1111进行与操作取列号
    82.     		switch(temp)   // 根据与出来的列号进行选择
    83.     		{
    84.     			 case 0xe0:num=0;
    85.        			 break;
    86.      			 case 0xd0:num=1;
    87.        			 break; 
    88.      			 case 0xb0:num=2;
    89.       			 break;
    90.       			 case 0x70:num=3;
    91.       			 break;
    92.     		}
    93.    		}
    94.    		while(P3!=0xfe);				
    95.    		if(flag==0)    // 没有按过符号键时输入继续赋给第一个数
    96.    		{
    97.    			a=a*10+table[num]; 
    98. 		}
    99. 		else           // 如果按过符号键，则赋给第二个数
    100. 		{
    101. 			b=b*10+table[num]; 
    102. 		}
    103. 			i=table[num];
    104. 			lcd_wdat(0x30+i);	//  显示屏写入数字
    105. 	}
    106. 	P3=0xfd; //扫描第二行
    107. 	if(P3!=0xfd)
    108. 	{
    109. 	   delay(5);
    110. 	   if(P3!=0xfd)  // 不等于初值，即代表该行有按键按下
    111. 	   {			// 第二行有数被按下
    112. 	    temp=P3&0xf0;	// 列与1111相与，判断按下的列
    113. 	    switch(temp)
    114. 	    {
    115. 	     case 0xe0:num=4;
    116. 	         break;
    117. 	      
    118. 	     case 0xd0:num=5;
    119. 	         break;
    120. 	      
    121. 	     case 0xb0:num=6;
    122. 	         break;
    123. 	      
    124. 	     case 0x70:num=7;
    125. 	         break;
    126. 	    }
    127. 	   }
    128. 	   while(P3!=0xfd);
    129. 	   if(flag==0)   //没有按过符号键
    130. 	    {
    131. 	     a=a*10+table[num]; 
    132. 	    }
    133. 	    else  //按过符号键
    134. 	    {
    135. 	     b=b*10+table[num]; 
    136. 	    }
    137. 	   i=table[num];
    138. 	   lcd_wdat(0x30+i); //写入显示屏
    139. 	}
    140. 	P3=0xfb; //扫描第三行	
    141. 	if(P3!=0xfb)
    142. 	{
    143. 	   delay(5);
    144. 	   if(P3!=0xfb)
    145. 	   {
    146. 	    temp=P3&0xf0;
    147. 	    switch(temp)
    148. 	    {
    149. 	     case 0xe0:num=8;
    150. 	         break;
    151. 	      
    152. 	     case 0xd0:num=9;
    153. 	         break;
    154. 	      
    155. 	     case 0xb0:num=10;
    156. 	         break;
    157. 	      
    158. 	     case 0x70:num=11;
    159. 	         break;
    160. 	    }
    161. 	   }
    162. 	   while(P3!=0xfb);     // 第三行的话不全是数字 
    163. 	   if(num==8||num==9)   //按下的是'8','9'
    164. 	   { 
    165. 	      if(flag==0) //没有按过符号键
    166. 	    {
    167. 	     a=a*10+table[num]; 
    168. 	    }
    169. 	    else     //按过符号键
    170. 	    {
    171. 	     b=b*10+table[num]; 
    172. 	    }
    173. 	   }//0-9用table
    174. 	   else if(num==10)   // 如果按下的是'+'
    175. 	   {
    176. 	    flag=1;
    177. 	    signal=1;   // signal为1表示按下的是加号
    178. 	   }
    179. 	   else if(num==11) //如果按下的是'-'
    180. 	   {
    181. 	    flag=1;
    182. 	    signal=2;  //2表示按下的是减号
    183. 	   }
    184. 	   i=table[num];
    185. 	   lcd_wdat(0x30+i);
    186. 	}
    187. 	P3=0xf7;    // 第四行都是符号
    188. 	if(P3!=0xf7)
    189. 	{
    190. 	   delay(5);
    191. 	   if(P3!=0xf7)
    192. 	   {
    193. 	    temp=P3&0xf0;     // 列和1111相与取列号
    194. 	    switch(temp)
    195. 	    {
    196. 	     case 0xe0:num=12;
    197. 	         break;
    198. 	      
    199. 	     case 0xd0:num=13;
    200. 	         break;
    201. 	      
    202. 	     case 0xb0:num=14;
    203. 	         break;
    204. 	      
    205. 	     case 0x70:num=15;
    206. 	         break;
    207. 	    }
    208. 	   }
    209. 	   while(P3!=0xf7);
    210. 	   switch(num)
    211. 	   {
    212. 	    case 12:{lcd_wdat(0x30+table[num]); flag=1;signal=3;}
    213. 	     break;
    214. 	    case 13:{lcd_wdat(0x30+table[num]); flag=1;signal=4;}                //运算符号用table   
    215. 	     break;
    216. 	    case 14:{lcd_wcmd(0x01);i=0;j=0;a=0;b=0;c=0;d=0;flag=0;signal=0;}    //按下的是"清零" ，0x01指令
    217. 	     break;
    218. 	    case 15:{j=1;
    219. 	       if(signal==1)	//+号
    220. 		   {
    221. 			   lcd_wcmd(0x80+0x40); //第二行	           
    222. 	           c=a+b;
    223. 			   lcd_wdat(0x3d);
    224. 	           while(c!=0)
    225. 		       {
    226. 			    if(c/10000!=0)
    227. 			    {
    228. 				lcd_wdat(0x30+c/10000);
    229. 				c=c%10000;
    230. 			   	lcd_wdat(0x30+c/1000);
    231. 				c=c%1000;
    232. 			   	lcd_wdat(0x30+c/100);
    233. 				c=c%100;
    234. 				lcd_wdat(0x30+c/10);
    235. 				c=c%10;
    236. 				lcd_wdat(0x30+c);
    237. 			    }  
    238. 				else if(c/1000!=0)
    239. 				{
    240. 				lcd_wdat(0x30+c/1000);
    241. 				c=c%1000;
    242. 			   	lcd_wdat(0x30+c/100);
    243. 				c=c%100;
    244. 				lcd_wdat(0x30+c/10);
    245. 				c=c%10;
    246. 				lcd_wdat(0x30+c);
    247. 				}
    248. 			    else if(c/100!=0)
    249. 			    {
    250. 			   	lcd_wdat(0x30+c/100);
    251. 				c=c%100;
    252. 				lcd_wdat(0x30+c/10);
    253. 				c=c%10;
    254. 				lcd_wdat(0x30+c);
    255. 			    }
    256. 	            else if(c/10!=0)
    257. 			    {
    258. 				lcd_wdat(0x30+c/10);
    259. 				c=c%10;
    260. 				lcd_wdat(0x30+c);	
    261. 			    }
    262. 				else if(c/10==0)
    263. 			    {
    264. 				lcd_wdat(0x30+c);
    265. 		        }
    266. 			   a=0;b=0;c=0;flag=0;signal=0;
    267. 	          }
    268. 		  }
    269. 	      else if(signal==2)	
    270. 		  {
    271. 		  	   lcd_wcmd(0x80+0x40); //第二行
    272. 	           if(a-b>0)
    273. 	           c=a-b;
    274. 	           else 
    275. 	           c=b-a;				 //c为绝对值
    276. 			   lcd_wdat(0x3d);     //写"="           	           
    277. 			   if(a-b<0)
    278. 	           lcd_wdat(0x2d);	    //小于0时为负号
    279. 			   while(c!=0)			//若c不为0
    280. 			   {
    281. 			    if(c/10000!=0)			 //则先从最高位写起
    282. 			    {
    283. 				lcd_wdat(0x30+c/10000);
    284. 				c=c%10000;
    285. 			   	lcd_wdat(0x30+c/1000);
    286. 				c=c%1000;
    287. 			   	lcd_wdat(0x30+c/100);
    288. 				c=c%100;
    289. 				lcd_wdat(0x30+c/10);
    290. 				c=c%10;
    291. 				lcd_wdat(0x30+c);
    292. 			    }  
    293. 	            else if(c/1000!=0)
    294. 			    {
    295. 			   	lcd_wdat(0x30+c/1000);	
    296. 				c=c%1000; 
    297. 			   	lcd_wdat(0x30+c/100);
    298. 				c=c%100;
    299. 				lcd_wdat(0x30+c/10);
    300. 				c=c%10;
    301. 				lcd_wdat(0x30+c);
    302. 			    }
    303. 			    else if(c/100!=0)
    304. 			    {
    305. 			   	lcd_wdat(0x30+c/100);
    306. 				c=c%100;
    307. 				lcd_wdat(0x30+c/10);
    308. 				c=c%10;
    309. 				lcd_wdat(0x30+c);
    310. 			    }
    311. 	            else if(c/10!=0)
    312. 				{
    313. 				lcd_wdat(0x30+c/10);
    314. 				c=c%10;
    315. 				lcd_wdat(0x30+c);	
    316. 				}
    317. 				else if(c/10==0)
    318. 				{
    319. 				lcd_wdat(0x30+c);
    320. 				}
    321. 			    a=0;b=0;c=0;flag=0;signal=0;            	          
    322. 	           }
    323. 	   	  }
    324. 	      else if(signal==3)  //乘号的情况
    325. 		  {
    326. 			   lcd_wcmd(0x80+0x40);
    327. 	           c=a*b;
    328. 			   lcd_wdat(0x3d); 
    329. 			   while(c!=0)
    330. 			   {    
    331. 			   if(c/10000!=0)
    332. 			    {
    333. 				lcd_wdat(0x30+c/10000);
    334. 				c=c%10000;
    335. 			   	lcd_wdat(0x30+c/1000);
    336. 				c=c%1000;
    337. 			   	lcd_wdat(0x30+c/100);
    338. 				c=c%100;
    339. 				lcd_wdat(0x30+c/10);
    340. 				c=c%10;
    341. 				lcd_wdat(0x30+c);
    342. 			    }  	          	
    343. 	            else if(c/1000!=0)
    344. 			    {
    345. 			   	lcd_wdat(0x30+c/1000);
    346. 				c=c%1000;
    347. 			   	lcd_wdat(0x30+c/100);
    348. 				c=c%100;
    349. 				lcd_wdat(0x30+c/10);
    350. 				c=c%10;
    351. 				lcd_wdat(0x30+c);
    352. 			    }
    353. 			    else if(c/100!=0)
    354. 			    {
    355. 			   	lcd_wdat(0x30+c/100);
    356. 				c=c%100;
    357. 				lcd_wdat(0x30+c/10);
    358. 				c=c%10;
    359. 				lcd_wdat(0x30+c);
    360. 			    }
    361. 	            else if(c/10!=0)
    362. 				{
    363. 				lcd_wdat(0x30+c/10);
    364. 				c=c%10;
    365. 				lcd_wdat(0x30+c);	
    366. 				}
    367. 				else if(c/10==0)
    368. 				{
    369. 				lcd_wdat(0x30+c);
    370. 				}
    371. 			    a=0;b=0;c=0;flag=0;signal=0;
    372. 	           }
    373. 	      }
    374. 	      else if(signal==4)	//除号的情况
    375. 		  {
    376. 			   lcd_wcmd(0x80+0x40);
    377. 	           lcd_wcmd(0x06);
    378. 			   if(b==0)
    379. 			   {
    380. 				 	i=0;
    381. 					while(error[i]!='\0')
    382. 					{
    383. 						lcd_wdat(error[i]); 
    384. 						i++;
    385. 					}
    386. 					a=0;b=0;c=0;flag=0;signal=0;
    387. 				}							//被除数为0显示error
    388. 				else if((a%b==0)&&(b!=0))	// 整除时输出c
    389. 				{
    390. 			    	lcd_wdat(0x3d);                              
    391. 	            	c=a/b;
    392. 					if(a/b<=0)
    393. 					{
    394. 	             	lcd_wdat(0x30); 
    395. 	            	}
    396. 				 while(c!=0)
    397. 			     {
    398. 				 if(c/10000!=0)
    399. 			    {
    400. 				lcd_wdat(0x30+c/10000);
    401. 				c=c%10000;
    402. 			   	lcd_wdat(0x30+c/1000);
    403. 				c=c%1000;
    404. 			   	lcd_wdat(0x30+c/100);
    405. 				c=c%100;
    406. 				lcd_wdat(0x30+c/10);
    407. 				c=c%10;
    408. 				lcd_wdat(0x30+c);
    409. 			    }  
    410. 				  else if(c/1000!=0)
    411. 			    {
    412. 			   	lcd_wdat(0x30+c/1000);
    413. 				c=c%1000;
    414. 			   	lcd_wdat(0x30+c/100);
    415. 				c=c%100;
    416. 				lcd_wdat(0x30+c/10);
    417. 				c=c%10;
    418. 				lcd_wdat(0x30+c);
    419. 			    }
    420. 			     else if(c/100!=0)
    421. 			     {
    422. 			   	 lcd_wdat(0x30+c/100);
    423. 				 c=c%100;
    424. 				 lcd_wdat(0x30+c/10);
    425. 				 c=c%10;
    426. 				 lcd_wdat(0x30+c);
    427. 			     }
    428. 	             else if(c/10!=0)
    429. 				 {
    430. 				 lcd_wdat(0x30+c/10);
    431. 				 c=c%10;
    432. 				 lcd_wdat(0x30+c);	
    433. 				 }
    434. 				 else if(c/10==0)
    435. 				 {
    436. 				 lcd_wdat(0x30+c);
    437. 				 }
    438. 			     a=0;b=0;c=0;flag=0;signal=0;
    439. 	            }
    440. 			   }
    441. 			   else if((a%b!=0)&&(b!=0))	//若不整除输出c```d
    442. 			   {
    443. 					c=a/b;
    444. 					d=a%b;
    445. 					lcd_wdat(0x3d);  
    446. 					if(a/b<=0)
    447. 					{
    448. 	             	lcd_wdat(0x30); 
    449. 	            	}
    450. 				while(c!=0)
    451. 			    { 
    452. 				 if(c/10000!=0)
    453. 			    {
    454. 				lcd_wdat(0x30+c/10000);
    455. 				c=c%10000;
    456. 			   	lcd_wdat(0x30+c/1000);
    457. 				c=c%1000;
    458. 			   	lcd_wdat(0x30+c/100);
    459. 				c=c%100;
    460. 				lcd_wdat(0x30+c/10);
    461. 				c=c%10;
    462. 				lcd_wdat(0x30+c);
    463. 			    }  
    464. 				else if(c/1000!=0)
    465. 			    {
    466. 			   	lcd_wdat(0x30+c/1000);
    467. 				c=c%1000;
    468. 			   	lcd_wdat(0x30+c/100);
    469. 				c=c%100;
    470. 				lcd_wdat(0x30+c/10);
    471. 				c=c%10;
    472. 				lcd_wdat(0x30+c);
    473. 			    }                           
    474. 			   	else if(c/100!=0)
    475. 			    {
    476. 			   	lcd_wdat(0x30+c/100);
    477. 				c=c%100;
    478. 				lcd_wdat(0x30+c/10);
    479. 				c=c%10;
    480. 				lcd_wdat(0x30+c);
    481. 			    }
    482. 	            else if(c/10!=0)
    483. 			    {
    484. 				lcd_wdat(0x30+c/10);
    485. 				c=c%10;
    486. 				lcd_wdat(0x30+c);	
    487. 			    }
    488. 				else if(c/10==0)
    489. 			    {
    490. 				lcd_wdat(0x30+c);
    491. 			    }
    492. 			    a=0;b=0;c=0;flag=0;signal=0;
    493. 	           }
    494. 					lcd_wdat(0x2e);
    495. 					lcd_wdat(0x2e);
    496. 					lcd_wdat(0x2e);
    497. 				if(d/10000!=0)
    498. 			    {
    499. 				lcd_wdat(0x30+d/10000);
    500. 				d=d%10000;
    501. 				lcd_wdat(0x30+d/1000);
    502. 				d=d%1000;
    503. 			   	lcd_wdat(0x30+d/100);
    504. 				d=d%100;
    505. 				lcd_wdat(0x30+d/10);
    506. 				d=d%10;
    507. 				lcd_wdat(0x30+d);
    508. 			    }
    509. 				else if(d/1000!=0)
    510. 			    {
    511. 				lcd_wdat(0x30+d/1000);
    512. 				d=d%1000;
    513. 			   	lcd_wdat(0x30+d/100);
    514. 				d=d%100;
    515. 				lcd_wdat(0x30+d/10);
    516. 				d=d%10;
    517. 				lcd_wdat(0x30+d);
    518. 			    }
    519. 				else if(d/100!=0)
    520. 			    {
    521. 			   	lcd_wdat(0x30+d/100);
    522. 				d=d%100;
    523. 				lcd_wdat(0x30+d/10);
    524. 				d=d%10;
    525. 				lcd_wdat(0x30+d);
    526. 			    }
    527. 	            else if(d/10!=0)
    528. 			    {
    529. 				lcd_wdat(0x30+d/10);
    530. 				d=d%10;
    531. 				lcd_wdat(0x30+d);	
    532. 				}
    533. 				else if(d/10==0)
    534. 				{
    535. 				lcd_wdat(0x30+d);	
    536. 	            }
    537. 	           }
    538. 	      }
    539. 	     break;
    540. 	   }
    541. 	}
    542.  }
    543.  }
    544.  
    545. main()	// 定义主程序
    546. {
    547. 	init();	//初始化子程序
    548. 	while(1)	  //一直循环
    549. 	{
    550.    		keyscan();  // 键盘扫描函数扫描输入
    551. 	}
    552. }

    初学单片机，可能存在错误之处，还请各位不吝赐教。

    受于文本原因，本文相关实验工程无法展示出来，现已将资源上传，可自行下载。

     山东大学单片机原理与应用实验工程文件3.7LCD1602显示实验-单片机文档类资源-CSDN下载山东大学单片机原理与应用实验工程文件3.7LCD1602显示实验详解博客地址：https:/更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/m0_52316372/85924094

  • 相关阅读:
    js-函数式编程-monad-chain-mcompose-自动解嵌套
    【100个 Unity实用技能】| 关于触发器互相检测的必要前提条件配置
    vue实现调用手机拍照、录像功能
    基于Cortex-M的RTOS上下文切换详解及FreeRTOS实例
    2023-2024 年最佳 6 款数据恢复软件免费在线下载
    微信小程序使用Animate.css动画库
    地图轨迹跟踪系统设计与实现（Android+Eclipse+APP）
    4800坐标反算
    一体式水利视频监控站 遥测终端视频图像水位水质水量流速监测
    NFNet：NF-ResNet的延伸，不用BN的4096超大batch size训练 | 21年论文
  • 原文地址：https://blog.csdn.net/m0_52316372/article/details/125631876