计数器 订阅
计数是一种最简单基本的运算。计数器就是实现这种运算的逻辑电路,计数器在数字系统中主要是对脉冲的个数进行计数,以实现测量、计数和控制的功能,同时兼有分频功能,计数器是由基本的计数单元和一些控制门所组成,计数单元则由一系列具有存储信息功能的各类触发器构成,这些触发器有RS触发器、T触发器、D触发器及JK触发器等。计数器在数字系统中应用广泛,如在电子计算机的控制器中对指令地址进行计数,以便顺序取出下一条指令,在运算器中作乘法、除法运算时记下加法、减法次数,又如在数字仪器中对脉冲的计数等等。计数器可以用来显示产品的工作状态,一般来说主要是用来表示产品已经完成了多少份的折页配页工作。它主要的指标在于计数器的位数,常见的有3位和4位的。很显然,3位数的计数器最大可以显示到999,4位数的最大可以显示到9999。 展开全文
计数是一种最简单基本的运算。计数器就是实现这种运算的逻辑电路,计数器在数字系统中主要是对脉冲的个数进行计数,以实现测量、计数和控制的功能,同时兼有分频功能,计数器是由基本的计数单元和一些控制门所组成,计数单元则由一系列具有存储信息功能的各类触发器构成,这些触发器有RS触发器、T触发器、D触发器及JK触发器等。计数器在数字系统中应用广泛,如在电子计算机的控制器中对指令地址进行计数,以便顺序取出下一条指令,在运算器中作乘法、除法运算时记下加法、减法次数,又如在数字仪器中对脉冲的计数等等。计数器可以用来显示产品的工作状态,一般来说主要是用来表示产品已经完成了多少份的折页配页工作。它主要的指标在于计数器的位数,常见的有3位和4位的。很显然,3位数的计数器最大可以显示到999,4位数的最大可以显示到9999。
信息
指    标
计数器的位数
组    成
基本的计数单元和一些控制门
分    类
同步计数器和异步计数器
释    义
运算的逻辑电路
中文名
计数器
功    能
测量、计数和控制
计数器基本信息
狭义的计数器是指一些常用计时器,例如体育比赛中测试时间的计时器等,但本词条所要介绍的并不是这种计时器,要介绍的是应用更为广泛的时序逻辑电路中的计数器。
收起全文
精华内容
参与话题
问答
  • 计数器

    2020-05-05 18:10:56
    同步计数器 】 同步二进制计数器 同步二进制加法计数器 原理 4位二进制同步加法计数器 方程 状态转换表 ( 利用第16个计数脉冲到达时C端电位的下降沿可作为向高位计数器电路进位的输出信号 ) ...

    • 计数器的容量(计数器的模):时序中实际的状态个数。=2n
    • n位二进制计数器中能计到的最大数=2n-1

    【 1. 同步计数器 】

    ① 同步二进制计数器

    同步二进制加法计数器

    原理
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    4位二进制同步加法计数器
    在这里插入图片描述

    方程
    在这里插入图片描述

    状态转换表
    ( 利用第16个计数脉冲到达时C端电位的下降沿可作为向高位计数器电路进位的输出信号 )
    在这里插入图片描述在这里插入图片描述

    状态转换图
    每输入16个脉冲,触发器状态循环一次,并且输出端C产生一个进位信号,故为16进制计数器
    在这里插入图片描述

    时序图
    从时序图中可以看出,若计数输入脉冲的频率为f0,则Q0、Q1、Q2、Q3输出端脉冲的频率将依次为12f 0 \frac{1}{2}f~0~14f 0 \frac{1}{4}f~0~18f 0 \frac{1}{8}f~0~116f 0 \frac{1}{16}f~0~
    分频功能。
    在这里插入图片描述

    74161 十六进制四位二进制加法计数器

    具有加法计数、同步预置数、异步置0、保持功能。

    在这里插入图片描述

    LD’ 预置数控制端
    D0 ~ D3 数据输入端
    C 进位输出端
    RD’ 异步置零(复位)端
    EP、ET 工作状态控制端

    在这里插入图片描述
    在这里插入图片描述

    74163

    具有同步清零、同步并行预置数、计数、保持功能。

    在这里插入图片描述
    在这里插入图片描述

    同步二进制减法计数器

    原理
    在这里插入图片描述

    逻辑图
    在这里插入图片描述

    同步二进制加/减计数器

    单时钟方式 74191

    74LS191功能:异步置数、保持、加/减计数
    在这里插入图片描述

    单时钟定义
    由加/减控制电平的高低来决定加计数还是减计数
    在这里插入图片描述

    逻辑图
    采用T触发器
    在这里插入图片描述

    方程
    在这里插入图片描述

    功能表
    在这里插入图片描述

    时序图
    在这里插入图片描述

    双时钟方式 74193

    74LS193功能:异步置零、异步置数、保持、加/减计数
    在这里插入图片描述

    逻辑图
    采用 T’ 触发器( 即T触发器的T=1)
    在这里插入图片描述

    方程
    在这里插入图片描述

    功能表
    在这里插入图片描述

    ② 同步十进制计数器

    同步十进制加法计数器

    原理
    在这里插入图片描述在这里插入图片描述

    逻辑图
    在这里插入图片描述

    驱动方程
    在这里插入图片描述
    状态方程
    在这里插入图片描述

    状态转换表
    在这里插入图片描述

    状态转换图(可自启动)
    在这里插入图片描述

    74160

    在这里插入图片描述

    74162

    在这里插入图片描述

    同步十进制减法计数器

    原理
    在这里插入图片描述

    逻辑图
    在这里插入图片描述

    驱动方程
    在这里插入图片描述
    状态方程
    在这里插入图片描述

    状态转换表
    在这里插入图片描述

    状态转换图
    在这里插入图片描述

    同步十进制加减计数器

    单时钟类型:74LS190、74LS168、CC4510
    双时钟类型:74LS192、CC40192

    【 2. 异步计数器 】

    ① 异步二进制计数器

    异步二进制加法计数器

    在这里插入图片描述

    异步二进制减法计数器

    在这里插入图片描述

    ② 异步十进制计数器

    异步十进制加法计数器

    在这里插入图片描述在这里插入图片描述

    【 3. N进制计数器→M进制计数器 】

    在这里插入图片描述

    ① N>M

    在这里插入图片描述
    在这里插入图片描述

    异步置零
    如图6.3.30(a)虚线
    从S0计数到SM时立即又异步 (时间极短) 被置成S0,故SM状态不稳定(稳定状态循环中不包括这个状态)。在这里插入图片描述在这里插入图片描述
    同步置零
    如图6.3.30(a)实线
    从S0计数到SM-1时同步(等到下个时钟) 被置成S0(稳定状态循环中包括这个状态)。在这里插入图片描述

    异步置数
    如图6.3.30(b)虚线
    从S0计数到Si+1时异步(时间极短) 被置成Sj(其中快进了N-M个状态),再计数到S0。故Si+1状态不稳定(稳定状态循环中不包括这个状态)。
    .
    同步置数
    如图6.3.30(b)实线
    从S0计数到Si时同步(等到下个时钟) 被置成Sj(其中快进了N-M个状态),再计数到S0。Si状态不稳定(稳定状态循环中包括这个状态)
    在这里插入图片描述在这里插入图片描述

    异步置零

    在这里插入图片描述

    同步置零

    在这里插入图片描述

    同步置数

    在这里插入图片描述
    在这里插入图片描述

    ② N<M

    在这里插入图片描述

    M=N1xN2

    在这里插入图片描述在这里插入图片描述

    在这里插入图片描述

    M<NxN

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    【 4. 移位寄存器型计数器 】

    ① 环形计数器

    在这里插入图片描述

    ② 扭环形计数器

    在这里插入图片描述

    【 5. 计数器应用 】

    ① 顺序节拍脉冲发生器

    74LS138译码器的 S1、S2、S3可视为总开关,当三者同时有效时,方可正常工作,否则其8个输出端均为1。
    在这里插入图片描述

    ② 序列脉冲发生器

    74LS152为8选1数据选择器在这里插入图片描述在这里插入图片描述

    展开全文
  • counter计数器

    万次阅读 2019-12-02 18:16:46
    一、为什么要做计数器: 在唯品会的工作的时候,为了更好的推动系统向智慧供应链发展,理性分析供应商和商助对产品的使用频率,于是,开发了一款轻量级计数器,供各团队使用。 二、难点: 1、数据量大 2、各团队...

    一、为什么要做计数器:

    在唯品会的工作的时候,为了更好的推动系统向智慧供应链发展,理性分析供应商和商助对产品的使用频率,追溯服务历史调用情况,于是,开发了一款轻量级计数器,供各团队使用。

    二、难点:

    1、调用量大

    2、各团队需要保证极端情况下,计数器服务不可用时,不影响各团队业务正常运行

    3、需要使用简单

    4、个别需要统一业务日志

    5、不能有额外的定时器一直轮询

    三、优势:

    1、简单   @LogCounter  对应的类或者方法上 即可开启计数器功能

    2、可配置    日志记录可选择开启和关闭、可选择记录到本地、可选择记录到远程服务器

    3、统一日志  开启日志功能后,即可对方法的入参和出参进行记录

    4、采用了线程池隔离

    5、设计了漏斗策略

    四、代码:

          https://gitee.com/sunrisexq/counter

          

    package com.javaxiaobang.counter.aspect.log;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 功    能:日志注解标签
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @Documented
    public @interface LogCounter {
    
        String counterName() default "";//计数器名称
    
        boolean useLogFile() default true;//true时记录log日志
    
        boolean useRemote() default true;//true时记录counter
    
        boolean useLocal() default false;//true时开启本地counter
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.alibaba.fastjson.JSON;
    import com.javaxiaobang.counter.exception.CounterException;
    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * 功    能:日志AOP
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Order
    @Aspect
    @Component("commonLogCounterAop")
    public class LogCounterAop {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    
        @Autowired
        private LogCounterLocalBusiness logCounterLocalBusiness;
        @Autowired
        private LogCounterRemoteBusiness logCounterRemoteBusiness;
    
        //切入点
        @Pointcut("@annotation(com.javaxiaobang.counter.aspect.log.LogCounter)")
        public void anyMethod() {
        }
    
        //方法执行之前
        @Before("anyMethod()")
        public void before(final JoinPoint joinPoint) {
            try {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null && method.isAnnotationPresent(LogCounter.class)) {
                    String methodName = method.getName();
                    final LogCounter aspect = method.getAnnotation(LogCounter.class);
                    if (aspect.useLogFile()) {
                        logger.info("{}{}方法的参数值:{}", aspect.counterName(), methodName, JSON.toJSONString(joinPoint.getArgs()));
                    }
                    final String counterName = StringUtils.isBlank(aspect.counterName()) ? methodName : aspect.counterName();
                    if (aspect.useLocal()) {
                        pool.submit(new Runnable() {
                            @Override
                            public void run() {
                                logCounterLocalBusiness.execute(counterName);
                            }
                        });
                    }
                    if (aspect.useRemote()) {
                        pool.submit(new Runnable() {
                            @Override
                            public void run() {
                                logCounterRemoteBusiness.execute(counterName);
                            }
                        });
                    }
                }
            } catch (Exception e) {
                logger.debug("before切面异常:", e);
            }
        }
    
        //方法执行之后
        @AfterReturning(pointcut = "anyMethod()", returning = "retVal")
        public void after(JoinPoint joinPoint, Object retVal) {
            try {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null) {
                    String methodName = method.getName();
                    LogCounter aspect = method.getAnnotation(LogCounter.class);
                    if (aspect != null && aspect.useLogFile()) {
                        logger.info("{}{}方法的返回值:{}", aspect.counterName(), methodName, JSON.toJSONString(retVal));
                    }
                }
            } catch (Exception e) {
                logger.debug("after切面异常:", e);
            }
        }
    
        //方法执行之后异常日志
        @AfterThrowing(pointcut = "anyMethod()", throwing = "e")
        public void afterThrowing(JoinPoint joinPoint, Throwable e) throws CounterException {
            //不需要再记录ServiceException,因为在service异常切面中已经记录过
            if (e instanceof CounterException) {
                throw (CounterException) e;
            } else {
                Signature signature = joinPoint.getSignature();
                MethodSignature methodSignature = (MethodSignature) signature;
                Method method = methodSignature.getMethod();
                if (method != null) {
                    String methodName = method.getName();
                    LogCounter aspect = method.getAnnotation(LogCounter.class);
                    logger.warn("{}{}方法异常:", aspect.counterName(), methodName, e);
                    throw new CounterException();
                }
            }
        }
    
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.javaxiaobang.counter.util.LogCounterUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 功    能:远程计数器-调用远程服务保存数据
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Component("logCounterRemoteBusiness")
    public class LogCounterRemoteBusiness {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ReentrantLock lock = new ReentrantLock();
    
        private static String domain = LogCounterUtil.getDomain();
    
        private static long tryLockTime = 2;//尝试2秒获取锁的时间
    
        private static long refreshTime = 30000L;//30秒刷新一次
    
        private static ConcurrentHashMap<String, AtomicLong> countMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> timeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        private static long detailRefreshTime = 10 * 60 * 1000L;//默认10分钟刷新数据
    
        private static ConcurrentHashMap<String, AtomicLong> detailCountMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> detailTimeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
    //    private CounterServiceHelper.CounterServiceClient client = new CounterServiceHelper.CounterServiceClient();//唯品会counter服务-对应两张表
    
        /**
         * 计数器逻辑处理
         */
        public void execute(String counterName) {
            commonMethod("total", counterName, refreshTime, countMap, timeMap);//计数器头表
            commonMethod("detail", counterName, detailRefreshTime, detailCountMap, detailTimeMap);//计数器明细表
        }
    
        private void commonMethod(String type, String counterName, long refreshTime, ConcurrentHashMap<String, AtomicLong> countMap, ConcurrentHashMap<String, Long> timeMap) {
            try {
                String key = counterName + domain;//唯一key
                AtomicLong atomicLong = countMap.get(key);
                if (null == atomicLong) {//原子计数器
                    synchronized (lock) {//并发控制
                        atomicLong = countMap.get(key);
                        if (null == atomicLong) {
                            countMap.put(key, new AtomicLong(1));
                            timeMap.put(key, System.currentTimeMillis());
                            return;
                        }
                    }
                }
                atomicLong.incrementAndGet();//原子计数器加1
    
                boolean flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//超过N秒 并且 次数大于0
                if (flag) {//满足条件的漏斗
                    if (lock.tryLock(tryLockTime, TimeUnit.SECONDS)) {
                        try {
                            flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//避免错误更新
                            if (flag) {
                                long counter = countMap.get(key).get();
                                timeMap.put(key, System.currentTimeMillis());//重新计时
                                atomicLong.set(0);
                                countMap.put(key, atomicLong);//重新计数
                                if ("detail".equals(type)) {
                                    incrementDetailCounter(counterName, domain, counter, refreshTime);
                                } else {
                                    incrementCounter(counterName, domain, counter);
                                }
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        logger.warn("2秒内没有获取到锁则放弃,下次再调用远程保存数据的服务:{}", key);
                    }
                }
            } catch (Exception e) {
                logger.debug("remote计数器异常:", e);
            }
        }
    
        /**
         * 保存到counter_info头表
         */
        public void incrementCounter(String counterName, String domain, long counter) {
            //调用远程方法
    //        try {
    //            CounterInfo counterInfo = new CounterInfo();
    //            counterInfo.setCounterName(counterName);
    //            counterInfo.setDomain(domain);
    //            counterInfo.setCounter(counter);
    //            client.incrementCounter(counterInfo);
    //        } catch (Exception e) {
    //            logger.debug("incrementCounter:", e);
    //        }
        }
    
        /**
         * 保存到counter_detail明细表
         */
        public void incrementDetailCounter(String counterName, String domain, long counter, long interval) {
            //调用远程方法
    //        try {
    //            CounterInfo counterInfo = new CounterInfo();
    //            counterInfo.setCounterName(counterName);
    //            counterInfo.setDomain(domain);
    //            counterInfo.setCounter(counter);
    //            counterInfo.setInterval(interval);
    //            client.incrementDetailCounter(counterInfo);
    //        } catch (Exception e) {
    //            logger.debug("incrementDetailCounter:", e);
    //        }
        }
    
        public static long getRefreshTime() {
            return refreshTime;
        }
    
        public static void setRefreshTime(long refreshTime) {
            LogCounterRemoteBusiness.refreshTime = refreshTime;
        }
    
        public static long getDetailRefreshTime() {
            return detailRefreshTime;
        }
    
        public static void setDetailRefreshTime(long detailRefreshTime) {
            LogCounterRemoteBusiness.detailRefreshTime = detailRefreshTime;
        }
    
        public static void setDomain(String domain) {
            LogCounterRemoteBusiness.domain = domain;
        }
    
        public static String getDomain() {
            return domain;
        }
    
    
    }
    
    package com.javaxiaobang.counter.aspect.log;
    
    import com.javaxiaobang.counter.aspect.delay.LogCounterDelayInterface;
    import com.javaxiaobang.counter.util.LogCounterUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicLong;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * 功    能:本地计数器-实现LogCounterDelayInterface接口-保存到本地数据库
     * 作    者:java潇邦
     * 时    间:2018-05-19
     */
    @Component("logCounterLocalBusiness")
    public class LogCounterLocalBusiness {
    
        private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
        private static ReentrantLock lock = new ReentrantLock();
    
        private static String domain = LogCounterUtil.getDomain();
    
        private static long tryLockTime = 2;//尝试2秒获取锁的时间
    
        private static long refreshTime = 30000L;//30秒刷新一次
    
        private static ConcurrentHashMap<String, AtomicLong> countMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> timeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        private static long detailRefreshTime = 10 * 60 * 1000L;//默认10分钟刷新数据
    
        private static ConcurrentHashMap<String, AtomicLong> detailCountMap = new ConcurrentHashMap<String, AtomicLong>(32);//并发计数
    
        private static ConcurrentHashMap<String, Long> detailTimeMap = new ConcurrentHashMap<String, Long>(32);//并发计时
    
        //懒加载
        @Autowired(required = false)
        private LogCounterDelayInterface logCounterDelayInterface;
    
        /**
         * 计数器逻辑处理
         */
        public void execute(String counterName) {
            commonMethod("total", counterName, refreshTime, countMap, timeMap);
            commonMethod("detail", counterName, detailRefreshTime, detailCountMap, detailTimeMap);
        }
    
        private void commonMethod(String type, String counterName, long refreshTime, ConcurrentHashMap<String, AtomicLong> countMap, ConcurrentHashMap<String, Long> timeMap) {
            try {
                String key = counterName + domain;//唯一key
                AtomicLong atomicLong = countMap.get(key);
                if (null == atomicLong) {//原子计数器
                    synchronized (lock) {//并发控制
                        atomicLong = countMap.get(key);
                        if (null == atomicLong) {
                            countMap.put(key, new AtomicLong(1));
                            timeMap.put(key, System.currentTimeMillis());
                            return;
                        }
                    }
                }
                atomicLong.incrementAndGet();//原子计数器加1
    
                boolean flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//超过N秒 并且 次数大于0
                if (flag) {//满足条件的漏斗
                    if (lock.tryLock(tryLockTime, TimeUnit.SECONDS)) {
                        try {
                            flag = (System.currentTimeMillis() - timeMap.get(key) > refreshTime) && (atomicLong.get() > 0);//避免错误更新
                            if (flag) {
                                long counter = countMap.get(key).get();
                                timeMap.put(key, System.currentTimeMillis());//重新计时
                                atomicLong.set(0);
                                countMap.put(key, atomicLong);//重新计数
                                if ("detail".equals(type)) {
                                    logCounterDelayInterface.incrementDetailCounter(counterName, domain, counter, refreshTime);
                                } else {
                                    logCounterDelayInterface.incrementCounter(counterName, domain, counter);
                                }
                            }
                        } finally {
                            lock.unlock();
                        }
                    } else {
                        logger.warn("2秒内没有获取到锁则放弃,下次再调用保存数据的服务:{}", key);
                    }
                }
            } catch (Exception e) {
                logger.info("local计数器异常:", e);
            }
        }
    
        public static void setDomain(String domain) {
            LogCounterLocalBusiness.domain = domain;
        }
    
        public static String getDomain() {
            return domain;
        }
    
        public static long getRefreshTime() {
            return refreshTime;
        }
    
        public static void setRefreshTime(long refreshTime) {
            LogCounterLocalBusiness.refreshTime = refreshTime;
        }
    
        public static long getDetailRefreshTime() {
            return detailRefreshTime;
        }
    
        public static void setDetailRefreshTime(long detailRefreshTime) {
            LogCounterLocalBusiness.detailRefreshTime = detailRefreshTime;
        }
    }
    

     

    展开全文
  • CSS 计数器

    2020-12-13 20:51:06
    CSS 计数器 CSS 计数器通过一个变量来设置,根据规则递增变量。 使用计数器自动编号 CSS 计数器根据规则来递增变量。 CSS 计数器使用到以下几个属性: counter-reset – 创建或者重置计数器 counter-increment – ...
  • 约翰逊计数器

    2018-04-09 16:27:23
    约翰逊计数器 FPGA 约翰逊计数器 FPGA 约翰逊计数器 FPGA
  • verilog计数器

    2020-04-15 22:05:31
    256位计数器,题目:设计一个 8位计数器,包含清零信号 clear,复位信号 rst,预加载值 preload。 解答: 本次设置的 preload=32。理论上最大计数值为 256。模块名称为 counter。
  • 二进制计数器 n位的2进制计数器,可以表示2^n个状态 相邻的两组数据会出现两位或两位以上不一样 环形计数器(右移) n位的环形计数器,可以表示n个状态 举例:4位的独热码环形计数器的数据表示(0001 >>...

    二进制计数器

    n位的2进制计数器,可以表示2^n个状态

    相邻的两组数据会出现两位或两位以上不一样

     

    环形计数器(右移)

    n位的环形计数器,可以表示n个状态

    举例:4位的独热码环形计数器的数据表示(0001 >> 0010 >> 0100 >> 1000 >> 0001  ……)

    相邻的两组数据会有两位不一样

     

    Johnson计数器(右移)

    n位的Johnson计数器,可以表示2n个状态

    举例:4位的Johnson计数器的数据表示(1000 >> 1100 >> 1110 >> 1111 >> 0111 >> 0011 >> 0001 >> 0000 >> 1000 ……)

    相邻的两组数据只有一位不一样(我想这正是Johnson计数器存在的意义吧,有点像格雷码),是可靠计数器

    最右位是0,则左移入1;最右位是1,则左移入0

     

     

     

     

    展开全文
  • 实用的web计数器插件

    2017-05-04 17:04:31
    计数器
  • 库伯勒 HC77系列计数器-脉冲计数器rar,库伯勒 HC77系列计数器-脉冲计数器
  • 一、实验目的1、学习用集成触发器构成计数器的方法2、掌握中规模集成计数器的使用及功能测试方法3、运用集成计数计构成1/N分频器二、实验原理计数器是一个用以实现计数功能的时序部件,它不仅可用来计脉冲数,还常用...
    一、实验目的1、学习用集成触发器构成计数器的方法2、掌握中规模集成计数器的使用及功能测试方法3、运用集成计数计构成1/N分频器二、实验原理

    计数器是一个用以实现计数功能的时序部件,它不仅可用来计脉冲数,还常用作数字系统的定时、分频和执行数字运算以及其它特定的逻辑功能。

    计数器种类很多。按构成计数器中的各触发器是否使用一个时钟脉冲源来分,有同步计数器和异步计数器。根据计数制的不同,分为二进制计数器,十进制计数器和任意进制计数器。根据计数的增减趋势,又分为加法、减法和可逆计数器。还有可预置数和可编程序功能计数器等等。目前,无论是TTL还是CMOS集成电路,都有品种较齐全的中规模集成计数器。使用者只要借助于器件手册提供的功能表和工作波形图以及引出端的排列,就能正确地运用这些器件。

    1、用D触发器构成异步二进制加/减计数器

    下图是用四只D触发器构成的四位二进制异步加法计数器,它的连接特点是将每只D触发器接成T'触发器,再由低位触发器的5c1b34e301b3e137dbc2dcde1302d502.png端和高一位的CP端相连接。

    a60a533905b5af35bb3f244c1fc320c7.png

    若将上图稍加改动,即将低位触发器的Q端与高一位的CP端相连接,即构成了一个4位二进制减法计数器。

    2、中规模十进制计数器

    CC40192或74LS192是同步十进制可逆计数器,具有双时钟输入,并具有清除和置数等功能,其引脚排列及逻辑符号如下图所示。

    8657e44226c0d0fe810b7502e8b64136.png

    3b5d08fcefe6ffbb8bd8468522cfefbd.png

    36bd57b57b9c4c96c130cf80d5d2ffa0.png

    ef88d1a8038aeb09d70ffee80113a389.png

    4c8cc9548bc2247b242a0912a89e9782.png

    74LS192同步十进制可逆计数器逻辑功能总结:

    f85e0748636b0385a41d33b8d0cad412.png

    3、计数器的级联使用

    一个十进制计数器只能表示09十个数,为了扩大计数器范围,常用多个十进制计数器级联使用。

    同步计数器往往设有进位(或借位)输出端,故可选用其进位(或借位)输出信号驱动下一级计数器。下图是由CC40192利用进位输出控制高一位的CPU端构成的加数级联图。用两个CC40192计数器可以构成100进制计数器。

    1c1d60d8cc46f30bf9be10fc6b8e3148.png

    4、实现任意进制计数

    (1)用复位法获得任意进制计数器

    假定已有N进制计数器,而需要得到一个M进制计数器时,只要MN,用复位法使计数器计数到M时置“0”,即获得M进制计数器。

    (2)利用预置功能获M进制计数器

    用三个CC40192可组成421进制计数器。

    外加的由与非门构成的锁存器可以克服器件计数速度的离散性,保证在反馈置“0”信号作用下计数器可靠置“0”

    三、实验设备与器件1 5V直流电源 2 双踪示波器3 连续脉冲源 4 单次脉冲源5 逻辑电平开关6 逻辑电平显示器7 译码显示器8 CC4013×2(74LS74)      CC40192×3(74LS192)      CC4011(74LS00)

          CC4012(74LS20)

    04567340c0ea6ef67d4f3d600621e39f.png

    四、实验内容

    1、用74LS74 D触发器构成4位二进制异步加法计数器。

    a7af650f7c398f630d796a8f8c5f7352.png

    4cfd0c65b056c7d9a3ae83b8792bc949.png

    实验步骤-连接电路后,按单次脉冲源,观察输出端状态变化。

    b617831c8dc678f66970908d3c258825.png

    4位二进制异步加法计数器状态表:

    ff191ebc2a3b53f30c176c8549d4f493.png

    将图电路中的低位触发器的Q端与高一位的CP端相连接,构成减法计数器,按实验内容2)3)进行实验,观察并列表记录Q3Q0的状态。(选做)2. CC40192或74LS192构成十进制加法计数电路图(选做)

    4345639cc99f46d9c846bc8811c4ce9b.png

    (减计数时CPU接高CPD接脉冲)

    3、用两片CC40192或74LS192组成两位十进制加法计数器

       按图连接电路,输入计数脉冲,进行由00—99累加计数,记录之。

    9beaa371bc24ef498c41b0aa8ec24708.png

    实验步骤-连接电路后,按单次脉冲源,观察输出端状态变化。

    030f1074baafc8992f8f3da4e4e72027.png

    e6960c6a06d405f79680b9ccfd625da7.png

    4、将两位十进制加法计数器改为两位十进制减法计数器,实现由99—00递减计数,记录之。(选做)

    5、设计一个数字钟移位60进制计数器并进行实验。(选做)

    五、实验报告及总结要求

    1、画出实验线路图,记录、整理实验现象及实验所得的有关波形。对实验结果进行分析。

    2、总结使用集成计数器的体会。

    展开全文
  • 计数器主要是应用于电子科技领域,计数器是一种运用得比较多的时序逻辑电路。计数器可以对数字进行运算,它是一种没有办法显示计算结果的显示器。随着电子科技的不断发展,现在的计数器也实现了智能功能。智能计数器...
  • 计数器
  • 绍了计数器CD40192在这里被接成加计数器的使用方法
  • 计数器 自定义Java计数器 1)MapReduce框架允许用户自定义计数器 2)计数器是一个全局变量 3)计数器有组的概念,可以用Java的枚举类型或者用字符串来定义 public Counter getCounter(Enum<?> counterName...
  • 程序计数器

    2020-12-30 22:31:24
    文章目录PC Registers程序计数器案例 PC Registers 程序计数器案例
  • 人数计数器

    2014-11-22 22:03:06
    人数计数器,LCD电子计数器计数器,最大计数100亿,这个资料很难得,带源程序和仿真软件仿真图,只要稍懂点电子知识的就能看懂和制作
  • 尘埃粒子计数器根据不同的分类标准具有不同的分类方式,其根据流量大小的不同可分为小流量计数器和大流量计数器;根据体积及其形状的不同可分为手持式计数器和台式计数器;根据测试原理的不同可分为光散乱法测试计数器...
  • 如果需要引用的数据量较大,且要求不能重复或者需要自增,那么可以使用计数器来实现。计数器(counter):允许用户创建一个在线程组之内都可以被引用的计数器计数器允许用户配置一个起点,一个最大值,增量数,循环到...
  • 计数器应用

    2020-12-01 19:35:40
    计数器应用(多线程情况下,无法使用debug调试代码,只能通过计数器的方式来调节) 打log和debug是解决问题的重要手段 Hadoop为每个作业维护若干内置计数器,以描述多项指标。例如,某些计数器记录已处理的字节数...
  • css计数器

    2019-12-18 11:37:11
    css 计数器 一、初始化计数器 counter-reset: 计数器名称[, 默认值number]; /* 重置计数器成0 */ 在使用计数器的时候需要先初始化这个计数器,并且设置一个计数器的名字(变量)。conter-reset 就是用来初始化的,这...
  • 张继军 董卫 《java web 应用开发技术与实案列教程》课后习题之第三章第7题网页访问计数器count1.jsp会话计数器count2.jsp访问网站访问计数器count3.jsp 题目内容:7.分别设计网页访问计数器,会话计数器,访问网站...
  • Hadoop 计数器

    2016-05-17 11:11:06
    计数器 1)计数器主要用来收集系统信息,以及相关作业的运行时候的统计数据,用于知道作业成功、失败等情况。 2)相比而言,计数器方式比日志更易于分析内置计数器 1)Hadoop内置的计数器,主要用来记录作业的...
  • 红外光电计数器

    2018-06-21 18:34:24
    红外光电计数器:使用51单片机开发板开发的红外计数器
  • CSS计数器

    2019-10-11 19:23:40
    CSS计数器 我们在编辑网页时常常需要一些序号,css计数器就可以帮助我们实现根据一定规则来递增变量。 css计数器有以下几个属性: counter-reset 创建或者重置计数器 counter-increment 递增变量 content 插入生成的...

空空如也

1 2 3 4 5 ... 20
收藏数 58,031
精华内容 23,212
关键字:

计数器