我的账户
中国电子DIY

科技成就未来

亲爱的游客,欢迎!

已有账号,请

如尚未注册?

  • 客服电话

    在线时间:8:00-16:00

    客服电话

    000-000-0000

    电子邮件

    ndiyadmin@163.com
  • 手机版

    电子DIY手机版

    随时随地掌握网站动态

  • 官方微信

    扫描二维码

    免费获取邀请码

51188bet金博宝注册初级-数码管 用CH595的原因

[复制链接]
3124 5
打野食 发表于 2018-6-1 14:33:13 | 只看该作者 |只看大图 |阅读模式 打印 上一主题 下一主题
本帖最后由 打野食 于 2018-6-1 14:37 编辑

数码管的一种是半导体发光器件,数码管可分为七段数码管和八段数码管,区别在于八段数码管比七段数码管多一个用于显示小数点的发光二极管单元DP(decimal point),其基本单元是发光二极管。数码管是一类价格便宜使用简单,通过对其不同的管脚输入相对的电流,使其发亮,从而显示出数字能够显示 时间、日期、温度等所有可用数字表示的参数的器件。
在电器特别是家电领域应用极为广泛,如显示屏、空调、热水器、冰箱等等。绝大多数热水器用的都是数码管,其他家电也用液晶屏与荧光屏。

直流驱动是指每个数码管的每一个段码都由一个188bet金博宝注册的I/O端口进行驱动,或者使用如BCD码二-十进制译码器译码进行驱动。优点是编程简单,显示亮度高,缺点是占用I/O端口多。显示驱动是将所有数码管通过分时轮流控制各个数码管的的COM端,就使各个数码管轮流受控显示。将所有数码管的8个显示笔划"a,b,c,d,e,f,g,dp"的同名端连在一起,另外为每个数码管的公共极COM增加位选通控制电路,位选通由各自独立的I/O线控制,当188bet金博宝注册输出字形码时,所有数码管都接收到相同的字形码,但究竟是那个数码管会显示出字形,取决于188bet金博宝注册对位选通COM端电路的控制,所以我们只要将需要显示的数码管的选通控制打开,该位就显示出字形,没有选通的数码管就不会亮。

我们经常要用多只数码管,如果每个数码管都要单独直接连到188bet金博宝注册,188bet金博宝注册管教数量会不够用,实际工程中常把公共端单独连接,其余管教并联。尽管如此还是会占用不少管脚,所以工程上用串并变换芯片扩展188bet金博宝注册IO,如下图所示

4HC595D芯片引脚图与功能


74HC595的数据端:
QA--QH: 八位并行输出端,可以直接控制数码管的8个段。
QH': 级联输出端。我将它接下一个595的SI端。
SI: 串行数据输入端。74hc595的控制端说明: /SCLR(10脚): 低电平时将移位寄存器的数据清零。通常我将它接Vcc。 SCK(11脚):上升沿时数据寄存器的数据移位。QA-->QB-->QC-->...-->QH;下降沿移位寄存器数据不变。(脉冲宽度:5V时,大于几十纳秒就行了。我通常都选微秒级)
   控制移位寄存器        SCK 上升沿 数据  移位       SCK 下降沿 数据  保持  RCK(12脚):上升沿时移位寄存器的数据进入存储寄存器,下降沿时存储寄存器数据不变。通常我将RCK置为低电平,当移位结束后,在RCK端产生一个正脉冲(5V时,大于几十纳秒就行了。我通常都选微秒级),更新显示数据。
   控制存储寄存器       RCK 上升沿 移位寄存器 的数据进入 存储寄存器       RCK  下降沿 存储寄存器数据不变   /G(13脚): 高电平时禁止输出(高阻态)。如果188bet金博宝注册的引脚不紧张,用一个引脚控制它,可以方便地产生闪烁和熄灭效果。比通过数据端移位控制要省时省力。 注:74164和74595功能相仿,都是8位串行输入转并行输出移位寄存器。74164的驱动电流(25mA)比74595(35mA)的要小,14脚封装,体积也小一些。 74595的主要优点是具有数据存储寄存器,在移位的过程中,输出端的数据可以保持不变。这在串行速度慢的场合很有用处,数码管没有闪烁感。
  1. #include<reg52.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. sbit Input_Clock=P2^2;//上升沿有效-将SER上的数据移入74HC595D的移位寄存器中
  5. sbit Output_Clock=P2^1;//上升沿有效-将移位寄存器中的数据送入到输出锁存器中
  6. sbit Input_Data=P2^0;//串行数据输入
  7. sbit P35=P3^5;
  8. void delay_ns(uint ns)
  9. {
  10.         uint a,b;
  11.         for(a=0;a<ns;a++)
  12.                 for(b=0;b<3000;b++);
  13. }

  14. void main()
  15. {
  16.         //1
  17.         uint Reference_Level=0x6666;        
  18.         uint i,aa,bb;
  19.         Output_Clock=0;
  20.                
  21.         while(1)
  22.                 {
  23.                 for(aa=0;aa<5;aa++)
  24.                         {        
  25.                         Reference_Level=0x9F80;
  26.                 for(i=0;i<16;i++)
  27.                         {
  28.                                 if(Reference_Level&0x0001==0x0001)
  29.                                         {
  30.                                                 Input_Clock=0;
  31.                                                 delay_ns(1);
  32.                                                 Input_Data=1;
  33.                                                 Input_Clock=1;
  34.                                                 P35=0;
  35.                                                 delay_ns(1);
  36.                                                 
  37.                                                 
  38.                                         }else{
  39.                                                 Input_Clock=0;
  40.                                                 delay_ns(1);
  41.                                                 Input_Data=0;
  42.                                                 Input_Clock=1;
  43.                                                 delay_ns(1);
  44.                                                 P35=1;
  45.                                                 
  46.                                         }
  47.                                 Reference_Level=Reference_Level>>1;                        
  48.                         }
  49.                 Output_Clock=1;
  50.                 delay_ns(1);
  51.                 Output_Clock=0;
  52.                         
  53.                 //2
  54.                  Reference_Level=0x2540;
  55.                 for(i=0;i<16;i++)
  56.                         {
  57.                                 if(Reference_Level&0x0001==0x0001)
  58.                                         {
  59.                                                 Input_Clock=0;
  60.                                                 delay_ns(1);
  61.                                                 Input_Data=1;
  62.                                                 Input_Clock=1;
  63.                                                 P35=0;
  64.                                                 delay_ns(1);
  65.                                         }else{
  66.                                                 Input_Clock=0;
  67.                                                 delay_ns(1);
  68.                                                 Input_Data=0;
  69.                                                 Input_Clock=1;
  70.                                                 P35=1;
  71.                                                 delay_ns(1);                        
  72.                                         }
  73.                                 Reference_Level=Reference_Level>>1;                        
  74.                         }
  75.                         Output_Clock=1;
  76.                         delay_ns(1);
  77.                         Output_Clock=0;
  78.                
  79.                 //3
  80.                  Reference_Level=0x0D20;
  81.                 for(i=0;i<16;i++)
  82.                         {
  83.                                 if(Reference_Level&0x0001==0x0001)
  84.                                         {
  85.                                                 Input_Clock=0;
  86.                                                 delay_ns(1);
  87.                                                 Input_Data=1;
  88.                                                 Input_Clock=1;
  89.                                                 P35=0;
  90.                                                 delay_ns(1);
  91.                                         }else{
  92.                                                 Input_Clock=0;
  93.                                                 delay_ns(1);
  94.                                                 Input_Data=0;
  95.                                                 Input_Clock=1;
  96.                                                 P35=1;
  97.                                                 delay_ns(1);                        
  98.                                         }
  99.                                 Reference_Level=Reference_Level>>1;                        
  100.                         }
  101.                         Output_Clock=1;
  102.                         delay_ns(1);
  103.                         Output_Clock=0;
  104.                         
  105.                         //4
  106.                  Reference_Level=0x9910;
  107.                 for(i=0;i<16;i++)
  108.                         {
  109.                                 if(Reference_Level&0x0001==0x0001)
  110.                                         {
  111.                                                 Input_Clock=0;
  112.                                                 delay_ns(1);
  113.                                                 Input_Data=1;
  114.                                                 Input_Clock=1;
  115.                                                 P35=0;
  116.                                                 delay_ns(1);
  117.                                         }else{
  118.                                                 Input_Clock=0;
  119.                                                 delay_ns(0);
  120.                                                 Input_Data=0;
  121.                                                 Input_Clock=1;
  122.                                                 P35=1;
  123.                                                 delay_ns(1);                        
  124.                                         }
  125.                                 Reference_Level=Reference_Level>>1;                        
  126.                         }
  127.                         Output_Clock=1;
  128.                         delay_ns(1);
  129.                         Output_Clock=0;
  130.                         
  131.                 //5
  132.                  Reference_Level=0x4908;
  133.                 for(i=0;i<16;i++)
  134.                         {
  135.                                 if(Reference_Level&0x0001==0x0001)
  136.                                         {
  137.                                                 Input_Clock=0;
  138.                                                 delay_ns(1);
  139.                                                 Input_Data=1;
  140.                                                 Input_Clock=1;
  141.                                                 P35=0;
  142.                                                 delay_ns(1);
  143.                                         }else{
  144.                                                 Input_Clock=0;
  145.                                                 delay_ns(1);
  146.                                                 Input_Data=0;
  147.                                                 Input_Clock=1;
  148.                                                 P35=1;
  149.                                                 delay_ns(1);                        
  150.                                         }
  151.                                 Reference_Level=Reference_Level>>1;                        
  152.                         }
  153.                         Output_Clock=1;
  154.                         delay_ns(1);
  155.                         Output_Clock=0;        
  156.                         
  157.                 //6
  158.                 Reference_Level=0x4104;
  159.                 for(i=0;i<16;i++)
  160.                         {
  161.                                 if(Reference_Level&0x0001==0x0001)
  162.                                         {
  163.                                                 Input_Clock=0;
  164.                                                 delay_ns(1);
  165.                                                 Input_Data=1;
  166.                                                 Input_Clock=1;
  167.                                                 P35=0;
  168.                                                 delay_ns(1);
  169.                                         }else{
  170.                                                 Input_Clock=0;
  171.                                                 delay_ns(1);
  172.                                                 Input_Data=0;
  173.                                                 Input_Clock=1;
  174.                                                 P35=1;
  175.                                                 delay_ns(1);                        
  176.                                         }
  177.                                 Reference_Level=Reference_Level>>1;                        
  178.                         }
  179.                         Output_Clock=1;
  180.                         delay_ns(1);
  181.                         Output_Clock=0;        
  182.                         
  183.                 //7
  184.                 Reference_Level=0x1F02;
  185.                 for(i=0;i<16;i++)
  186.                         {
  187.                                 if(Reference_Level&0x0001==0x0001)
  188.                                         {
  189.                                                 Input_Clock=0;
  190.                                                 delay_ns(1);
  191.                                                 Input_Data=1;
  192.                                                 Input_Clock=1;
  193.                                                 P35=0;
  194.                                                 delay_ns(1);
  195.                                         }else{
  196.                                                 Input_Clock=0;
  197.                                                 delay_ns(1);
  198.                                                 Input_Data=0;
  199.                                                 Input_Clock=1;
  200.                                                 P35=1;
  201.                                                 delay_ns(1);                        
  202.                                         }
  203.                                 Reference_Level=Reference_Level>>1;                        
  204.                         }
  205.                         Output_Clock=1;
  206.                         delay_ns(1);
  207.                         Output_Clock=0;        
  208.                         
  209.                 //8
  210.                  Reference_Level=0x0101;
  211.                 for(i=0;i<16;i++)
  212.                         {
  213.                                 if(Reference_Level&0x0001==0x0001)
  214.                                         {
  215.                                                 Input_Clock=0;
  216.                                                 delay_ns(1);
  217.                                                 Input_Data=1;
  218.                                                 Input_Clock=1;
  219.                                                 P35=0;
  220.                                                 delay_ns(1);
  221.                                         }else{
  222.                                                 Input_Clock=0;
  223.                                                 delay_ns(1);
  224.                                                 Input_Data=0;
  225.                                                 Input_Clock=1;
  226.                                                 P35=1;
  227.                                                 delay_ns(1);                        
  228.                                         }
  229.                                 Reference_Level=Reference_Level>>1;                        
  230.                         }
  231.                         Output_Clock=1;
  232.                         delay_ns(1);
  233.                         Output_Clock=0;        
  234.                         }
  235.                         
  236.                                 Reference_Level=0x0000;
  237.                 for(i=0;i<16;i++)
  238.                         {
  239.                                 if(Reference_Level&0x0001==0x0001)
  240.                                         {
  241.                                                 Input_Clock=0;
  242.                                                 delay_ns(1);
  243.                                                 Input_Data=1;
  244.                                                 Input_Clock=1;
  245.                                                 P35=0;
  246.                                                 delay_ns(1);
  247.                                         }else{
  248.                                                 Input_Clock=0;
  249.                                                 delay_ns(1);
  250.                                                 Input_Data=0;
  251.                                                 Input_Clock=1;
  252.                                                 P35=1;
  253.                                                 delay_ns(1);                        
  254.                                         }
  255.                                 Reference_Level=Reference_Level>>1;                        
  256.                         }
  257.                         Output_Clock=1;
  258.                         delay_ns(1);
  259.                         Output_Clock=0;        
  260.                         
  261.                         
  262.                         for(aa=0;aa<10;aa++)
  263.                                         {
  264.                                                 P35=0;
  265.                                                 P0=0xfe;
  266.                                                 for(bb=0;bb<=7;bb++)
  267.                                                         {
  268.                                                                 P35=1;
  269.                                                                 if(bb==8)
  270.                                                                 {
  271.                                                                         P0=0xfe;
  272.                                                                 }
  273.                                                                 delay_ns(10);
  274.                                                                 P0=P0<<1;
  275.                                                                
  276.                                                         }
  277.                                         }
  278.                                         P0=0xff;
  279.                 }
  280. }
复制代码
烧录程序 显示如下

程序在这 程序.rar (748 Bytes, 下载次数: 3)
收藏
收藏0
分享
分享
支持
支持0
反对
反对0

精彩评论5

跳转到指定楼层
2#
王栋春 发表于 2018-6-1 21:45:03 | 只看该作者
不错的经验分享                             
3#
bhzjr 发表于 2018-6-2 20:58:40 | 只看该作者
确实不错的资料。
4#
 楼主| 打野食 发表于 2018-6-10 15:27:00 | 只看该作者
    最近发现很多人对595不是很清楚,看不懂数据手册说的是什么意思。确实,有些东西无法用文字描述清楚,能看懂的都是有些基础的。比如用文字描述圆形,看似简单,让所有人都明白也是很难的,不信你自己就试试吧,记住是让所以人明白,智商正常的人。    看不懂没关系,也许找张纸画一下就明白了,一张图说明很多问题,也许是理科出身的原因吧。言归正传,看不懂595的说明没关系,上图吧!

输入有5各脚,其中10脚复位可以不理他,给他固定电平就好。13脚是输出使能,我们使能,给他固定电平。剩下三个脚有用了,14脚是数据输入,11脚是上升沿数据移位,12脚是锁存输出。第9脚可以做级联,给下一个芯片的数据输入。

5#
bhzjr 发表于 2018-6-15 21:09:14 | 只看该作者
  感谢你的分享 。不错!
6#
电子学徒工 发表于 2019-3-25 11:59:24 | 只看该作者
多谢分享非常好的芯片内部资料
您需要登录后才可以回帖 登录 | 注册

本版积分规则

关注我们
中国电子DIY官方微信

客服电话:000-000-0000

客服邮箱:776513803@qq.com

周一至周五 9:00-18:00

公司地址:深圳市南山区美丽湾大厦B座

Powered by X3.4@ 2001-2013