设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于单片机的数字集成电路芯片测试仪设计 程序Proteus仿 ...
返回列表 发新帖
查看: 1766|回复: 0
打印 上一主题 下一主题
收起左侧

基于单片机的数字集成电路芯片测试仪设计 程序Proteus仿真

[复制链接]
跳转到指定楼层
楼主
ID:142045 发表于 2021-11-15 14:32 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
  该仿真设计一套数字集成电路测试装置，能够实现对指定几种14脚常见的74系列数字电路测试。芯片有74LS00、74LS04、74LS20、74LS74、74LS86、74LS92。能够对指定的74系列门电路芯片进行功能测试（完好/损坏）。74LS00、74LS04、74LS20、74LS86。对于逻辑芯片的检测，我们主要实现检测芯片逻辑功能好坏亦或是确定芯片的型号，由于主控单元采用STC89c52单片机，其I/O与TTL电平完全兼容，因而直接由单片机对芯片插座的引脚进行扫描，由于是固定的14脚芯片，为了编程方便，使芯片测试引脚1~7分别为P1.0~P1.6，引脚14~8分别为P2.0~P2.6。实现了通过单片机输出端口模拟芯片的各种输入状态，并通过单片机读回芯片的输出结果，通过与芯片真值表的比较即可判断芯片逻辑功能的好坏的目的。在进行芯片扫描时，必须先将芯片的输出引脚I/O置为高电平，然后对芯片的输入引脚进行各种状态的扫描，通过单片机读回芯片的输出，再依据芯片的真值表对其输出进相比较，不一致则说明芯片的逻辑功能发生错误，断定芯片为坏的，若芯片的输出与真值表完全相符，则说明芯片的逻辑功能正确，可以判断为好芯片。 然后再依据所检测的结果，通过单片机对芯片的逻辑功能加以详细测试，并对结果加以显示。在自动识别的时候，为了提高准确度，我们编写了程序，采用对同一端口两次输入再两次读回其状态的比较方法，来对芯片好坏进行准确测试，继而返回正确的芯片型号。

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. /*------数字集成电路芯片测试仪C51程序仅供参考------------------------------*/
  2. //-------------------------------------------------------------------------------------------
  3. #include<reg52.h>
  4. #include <intrins.h>
  5. #include <stdio.h>
  6. //这是头文件必须包含
  7. /*==============================宏定义==============================*/
  8. #define LCD_data P0                //数据口
  9. #define M 4                                //要测试的芯片好坏的个数
  10. #define N 8
  11. #define input1 P1                        //用于检测的引脚
  12. #define input2 P2
  13. /*======================液晶宏定义、初始化引脚=========================*/
  14. void delay(unsigned int z);
  15. void charfill(unsigned char c);        //整屏显示A代表的ASCII字符子程序
  16. void putstrxy(unsigned char cx,unsigned char cy,unsigned char code *s);//在(cx,cy)字符位置写字符串子程序
  17. void putstr(unsigned char code *s);    //定位写字符串子程序
  18. void putchars(unsigned char c);       //在(CXPOS,CYPOS)字符位置写字符子程序
  19. unsigned char getchars(void);         //CXPOS,CYPOS)字符位置读字符子程序
  20. void charlcdpos(void);              //设置(CXPOS,CYPOS)字符位置的DDRAM地址
  21. void charcursornext(void);           //置字符位置为下一个有效位置子程序
  22. void lcdreset(void);                 //SMC1602系列液晶显示控制器初始化子程序
  23. void delay3ms(void);                //延时3MS子程序
  24. void lcdwc(unsigned char c);          //送控制字到液晶显示控制器子程序
  25. void lcdwd(unsigned char d);         //送控制字到液晶显示控制器子程序
  26. unsigned char lcdrd(void);            //读数据子程序
  27. void lcdwaitidle(void);               //忙检测子程序
  28. unsigned char data CXPOS;           //列方向地址指针(用于CHARLCDPOS子程序)
  29. unsigned char data CYPOS;           //行方向地址指针(用于CHARLCDPOS子程序)
  30. sbit RSPIN   = P3^5;               //RS对应单片机引脚
  31. sbit RWPIN   = P3^4;              //RW对应单片机引脚
  32. sbit EPIN    = P3^3;               //E对应单片机引脚
  33. /*==============================宏定义==============================*/
  34. unsigned char detect(); //自动检测引脚
  35. /*=============================定义按键=============================*/
  36. sbit key1=P3^0;  // 选择检测芯片
  37. sbit key2=P3^1;  // 确定选择的芯片
  38. sbit key3=P3^2;  // 自动检测
  39. sbit key4=P3^6;  // 继电器的切换

  41. unsigned char *name[]={"74LS00 Y=/AB","74LS04 Y=/A","74LS20 Y=/ABCD","74LS86 Y=/A⊕B","74LS74","74LS92","ERROR"};
  42. /*==============================按键的标志位=========================*/
  43. unsigned char flag=0;                                //要选择的芯片型号在已定义字符数组中的序号
  44. unsigned char flag1=0;
  45. unsigned char flag2=0;                                //用来标示某芯片各通道检测均完好的标志位
  46. unsigned char k=0;                                 //返回自动检测后芯片序号在已定义的数组中的序号
  47. unsigned char code LS00[4][4]={
  48.                                 0x3f,0x3f,0x1b,0x1b,                //74ls00
  49.                                        0x24,0x24,0x24,0x24,
  50.                                 0x36,0x36,0x36,0x36,
  51.                                                           0x2d,0x2d,0x2d,0x2d,
  52.                                         };

  54. unsigned char code LS04[2][4]={
  55.                                                              0x2a,0x2a,0x2a,0x2a,                //74ls04
  56.                                                               0x3f,0x3f,0x15,0x15,
  57.                                                     };

  59. unsigned char code LS20[16][4]={
  60.                                 0x24,0x24,0x24,0x24,                //74ls20
  61.                                 0x25,0x25,0x25,0x25,
  62.                                                          0x26,0x26,0x26,0x26,
  63.                                                          0x27,0x27,0x27,0x27,
  64.                                                          0x2c,0x2c,0x2c,0x2c,
  65.                                                        0x2d,0x2d,0x2d,0x2d,
  66.                                                               0x2e,0x2e,0x2e,0x2e,
  67.                                                                0x2f,0x2f,0x2f,0x2f,
  68.                                                            0x34,0x34,0x34,0x34,
  69.                                                               0x35,0x35,0x35,0x35,
  70.                                                             0x36,0x36,0x36,0x36,
  71.                                                            0x37,0x37,0x37,0x37,
  72.                                                       0x3c,0x3c,0x3c,0x3c,
  73.                                                               0x3d,0x3d,0x3d,0x3d,
  74.                                                       0x3e,0x3e,0x3e,0x3e,
  75.                                                      0x3f,0x3f,0x1f,0x1f,
  76.                                                     };

  78. unsigned char code LS86[4][4]={
  79.                                 0x24,0x24,0x00,0x00,                //74ls86
  80.                                 0x36,0x36,0x36,0x36,
  81.                                                       0x2d,0x2d,0x2d,0x2d,
  82.                                                          0x3f,0x3f,0x1b,0x1b,
  83.                                           };


  86. unsigned char code IC[M][N]={
  87.                                0x24,0x24,0x24,0x24,0x3f,0x3f,0x1b,0x1b, //7400
  88.                                                            0x3f,0x3f,0x15,0x15,0x3f,0x3f,0x15,0x15, //7404
  89.                                0x3f,0x3f,0x1f,0x1f,0x3f,0x3f,0x1f,0x1f, //7420
  90.                                0x3f,0x3f,0x1b,0x1b,0x3f,0x3f,0x1b,0x1b, //7486
  91.                                        };

  93. void main()
  94. {  
  95. unsigned char i,output1,output2;
  96.     lcdreset();                         //液晶显示控制器初始化
  97.     putstrxy(0,0,"PLEASE CHOOSE 74LS CHIP");  //显示欢迎界面
  98.     while(1)
  99.         {  
  100.                 if(key1==0)
  101.                 {
  102.                  delay(100);
  103.                    if(key1==0)
  104.                    {
  105.                                if(flag==4)
  106.                        {
  107.                            flag=0;
  108.                        }
  109.                         flag++;
  110.                         switch(flag)
  111.                                                 {
  112.                           case 1:charfill(' '); putstrxy(0,0,"NOW '74LS00'");break;
  113.                                                 case 2:charfill(' '); putstrxy(0,0,"NOW '74LS04'");break;
  114.                                                   case 3:charfill(' '); putstrxy(0,0,"NOW '74LS20'");break;
  115.                                                   case 4:charfill(' '); putstrxy(0,0,"NOW '74LS86'");
  116.                                                 }

  118.                    }
  119.                 }

  121.                 if(flag==1&&key2==0)
  122.                 {
  123.                    for(i=0;i<4;i++)
  124.                    {
  125.                          input1=LS00[i][0];
  126.                          input2=LS00[i][1];
  127.                           delay(5);
  128.                           output1=input1&0x3f;
  129.                           output2=input2&0x3f;
  130.                           if(output1!=LS00[i][2]||output2!=LS00[i][3])
  131.                              {
  132.                                   putstrxy(0,1,"SORRY,BAD CHIP!");
  133.                                   flag2=0;
  134.                                   break;
  135.                              }
  136.                           if(output1==LS00[i][2]&&output2==LS00[i][3])
  137.                              {
  138.                                   flag2++;
  139.                    }
  140.                 }
  141.                  if(flag2==4)
  142.                    {
  143.                           putstrxy(0,1,"OK,GOOD CHIP!");
  144.                           flag2=0;
  145.                    }
  146.                 }
  147.                if(flag==2&&key2==0)
  148.                 {
  149.                    for(i=0;i<2;i++)
  150.                    {
  151.                           input1=LS04[i][0];
  152.                           input2=LS04[i][1];
  153.                           delay(5);
  154.                           output1=input1&0x3f;
  155.                           output2=input2&0x3f;
  156.                           if(output1!=LS04[i][2]||output2!=LS04[i][3])
  157.                             {
  158.                                   putstrxy(0,1,"SORRY,BAD CHIP!");
  159.                                   flag2=0;
  160.                                   break;
  161.                             }
  162.                           if(output1==LS04[i][2]&&output2==LS04[i][3])
  163.                             {
  164.                                   flag2++;
  165.                             }
  166.                    }
  167.                      if(flag2==2)
  168.                        {
  169.                           putstrxy(0,1,"OK,GOOD CHIP!");
  170.                           flag2=0;
  171.                       }
  172.                  }
  173.                 if(flag==3&&key2==0)
  174.                 {
  175.                    for(i=0;i<16;i++)
  176.                    {
  177.                           input1=LS20[i][0];
  178.                           input2=LS20[i][1];
  179.                           delay(5);
  180.                           output1=input1&0x3f;
  181.                           output2=input2&0x3f;
  182.                           if(output1!=LS20[i][2]||output2!=LS20[i][3])
  183.                             {
  184.                                   putstrxy(0,1,"SORRY,BAD CHIP!");
  185.                                   flag2=0;
  186.                                   break;
  187.                             }
  188.                           if(output1==LS20[i][2]&&output2==LS20[i][3])
  189.                             {
  190.                                    flag2++;
  191.                             }
  192.                    }
  193.                       if(flag2==16)
  194.                         {
  195.                            putstrxy(0,1,"OK,GOOD CHIP!");
  196.                            flag2=0;
  197.                         }
  198.                  }
  199.                 if(flag==4&&key2==0)
  200.                  {
  201.                     for(i=0;i<4;i++)
  202.                     {
  203.                            input1=LS86[i][0];
  204.                            input2=LS86[i][1];
  205.                            delay(5);
  206.                            output1=input1&0x3f;
  207.                            output2=input2&0x3f;
  208.                            if(output1!=LS86[i][2]||output2!=LS86[i][3])
  209.                              {
  210.                                    putstrxy(0,1,"SORRY,BAD CHIP!");
  211.                                    flag2=0;
  212.                                    break;
  213.                              }
  214.                            if(output1==LS86[i][2]&&output2==LS86[i][3])
  215.                              {
  216.                                     flag2++;
  217.                              }
  218.                     }
  219.                        if(flag2==4)
  220.                          {
  221.                            putstrxy(0,1,"OK,GOOD CHIP!");
  222.                            flag2=0;
  223.                          }
  224.                 }

  226.                 if(key3==0)
  227.                 {
  228.                            k=detect();
  229.                            charfill(' ');
  230.                            putstrxy(0,0,"This is:");
  231.                            putstrxy(0,5,name[k]);
  232.                 }
  233.        }
  234. }

  236. //延时函数
  237. void delay(unsigned int z)
  238. {
  239.         unsigned int x,y;
  240.         for(x=z;x>0;x--)
  241.                 for(y=110;y>0;y--);
  242. }

  244. /*============================14脚芯片识别函数=======================*/
  245. unsigned char detect() //14脚芯片识别函数
  246. {
  247.   unsigned char i,output1,output2;
  248. //7474的检测
  249.   P1=0xff;                          //初始化测试端口
  250.   P2=0xff;
  251.   input1=0x3b;                                                
  252.   input2=0x39;
  253.   delay(5);
  254.   input1=0x3f;                                                   //上升沿
  255.   input2=0x3d;
  256.   delay(5);
  257.   output1=input1&0x3f;
  258.   output2=input2&0x3f;
  259.   if(output1==0x1f&&output2==0x2d)
  260.   {
  261.         return (4);
  262.   }
  263.                                                                         //7400/04/20/86的自动检测
  264.   P1=0xff;                          //初始化测试端口
  265.   P2=0xff;

  267.   for(i=0;i<M;i++)
  268.   {
  269.     input1=IC[i][0];
  270.     input2=IC[i][1];
  271.     delay(5);
  272.     output1=input1&0x3f;                                 //将芯片逻辑结果input1通过&0x3f取出
  273.     output2=input2&0x3f;
  274.     if(output1==IC[i][2]&&output2==IC[i][3])
  275.     {
  276.          input1=IC[i][4];
  277.          input2=IC[i][5];
  278.          delay(5);
  279.          output1=input1&0x3f;         
  280.          output2=input2&0x3f;
  281.          if(output1==IC[i][6]&&output2==IC[i][7])
  282.          {
  283.                 return i;
  284.          }
  285.     }
  286.   }
  287.    
  288.   key4=0;                                                        //检测7492时，先用继电器江电源供电引脚切换
  289.   P1=0xff;                          //初始化测试端口
  290.   P2=0xff;
  291.   input1=0x3f;                                            //7492的检测
  292.   input2=0x3f;
  293.   delay(5);
  294.   output1=input1&0x3f;
  295.   output2=input2&0x3f;
  296.   if(output1==0x3f&&output2==0x01)
  297.   {
  298.       delay(100);key4=1;return (5);
  299.   }
  300.   delay(100);
  301.   key4=1;                                                        //测试结束，将电源供电引脚切换回原状态
  302.   return (6);
  303. }
  304. //-------------------------------------------------------------------------------
  305. void charfill(unsigned char c)          //整屏显示A代表的ASCII字符子程序
  306. {   for(CXPOS=CYPOS=0;1;)
  307.     {   putchars(c);                //定位写字符
  308.         charcursornext();            //置字符位置为下一个有效位置
  309.         if((CXPOS==0) && (CYPOS==0)) break;
  310.     }
  311. }
  312. //子程序名称:void putstrxy(unsigned char cx,unsigned char cy,unsigned char *s).
  313. //功能:在(cx,cy)字符位置写字符串.
  314. //-------------------------------------------------------------------------------
  315. void putstrxy(unsigned char cx,unsigned char cy,unsigned char code *s)
  316. {                                 //在(cx,cy)字符位置写字符串子程序
  317.     CXPOS=cx;                    //置当前X位置为cx
  318.     CYPOS=cy;                    //置当前Y位置为cy
  319.     for(;*s!=0;s++)                 //为零表示字符串结束,退出
  320.     {   putchars(*s);               //写1个字符
  321.         charcursornext();           //字符位置移到下一个
  322.     }
  323. }
  324. //-------------------------------------------------------------------------------
  325. //子程序名称:void putstr(unsigned char *s).
  326. //功能:在(CXPOS,CYPOS)字符位置写字符串.
  327. //-------------------------------------------------------------------------------
  328. void putstr(unsigned char code *s)     //定位写字符串子程序
  329. {   for(;*s!=0;s++)                //为零表示字符串结束,退出
  330.     {   putchars(*s);              //写1个字符
  331.         charcursornext();          //字符位置移到下一个
  332.     }
  333. }
  334. //-------------------------------------------------------------------------------
  335. //子程序名称:void putchar(unsigned char c).
  336. //功能:在(CXPOS,CYPOS)字符位置写字符.
  337. //-------------------------------------------------------------------------------
  338. void putchars(unsigned char c)       //在(CXPOS,CYPOS)字符位置写字符子程序
  339. {
  340.     charlcdpos();                 //设置(CXPOS,CYPOS)字符位置的DDRAM地址
  341.     lcdwd(c);                    //写字符
  342. }
  343. //-------------------------------------------------------------------------------
  344. //子程序名称:unsigned char getchar(void).
  345. //功能:在(CXPOS,CYPOS)字符位置读字符.
  346. //-------------------------------------------------------------------------------
  347. unsigned char getchars(void)          //在(CXPOS,CYPOS)字符位置读字符子程序
  348. {
  349.     charlcdpos();                   //设置(CXPOS,CYPOS)字符位置的DDRAM地址
  350.     return lcdrd();                  //读字符
  351. }
  352. //-------------------------------------------------------------------------------
  353. //以下charlcdpos,charcursornext,lcdreset为HD44780兼容芯片的液晶显示控制器的
  354. //16字符X2行的SMC1602系列标准字符点阵型液晶显示模块的接口程序.
  355. //-------------------------------------------------------------------------------
  356. //子程序名称:void charlcdpos(void).
  357. ……………………

  359. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei附件下载:
数字集成电路芯片测试仪.rar (75.57 KB, 下载次数: 14)

评分

参与人数 1黑币 +80 收起 理由
admin + 80 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表