计数器

2020-05-05 18:10:56

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

计数器的容量（计数器的模）：时序中实际的状态个数。=2ⁿ
n位二进制计数器中能计到的最大数=2ⁿ-1

【 1. 同步计数器】

① 同步二进制计数器

同步二进制加法计数器

原理

4位二进制同步加法计数器

方程

状态转换表
（利用第16个计数脉冲到达时C端电位的下降沿可作为向高位计数器电路进位的输出信号）

状态转换图
每输入16个脉冲，触发器状态循环一次，并且输出端C产生一个进位信号，故为16进制计数器

时序图
从时序图中可以看出，若计数输入脉冲的频率为f₀，则Q₀、Q₁、Q₂、Q₃输出端脉冲的频率将依次为 $\frac{1}{2}f~0~$ 、 $\frac{1}{4}f~0~$ 、 $\frac{1}{8}f~0~$ 、 $\frac{1}{16}f~0~$ 。
即分频功能。

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

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

在这里插入图片描述

LD’ 预置数控制端
D₀ ~ D₃ 数据输入端
C 进位输出端
R_D’ 异步置零(复位)端
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)虚线
从S₀计数到S_M时立即又异步 (时间极短) 被置成S₀，故S_M状态不稳定（稳定状态循环中不包括这个状态）。
同步置零
如图6.3.30(a)实线
从S₀计数到S_M-1时同步(等到下个时钟) 被置成S₀(稳定状态循环中包括这个状态）。

异步置数
如图6.3.30(b)虚线
从S₀计数到S_i+1时异步(时间极短) 被置成S_j(其中快进了N-M个状态)，再计数到S₀。故S_i+1状态不稳定（稳定状态循环中不包括这个状态）。
.
同步置数：
如图6.3.30(b)实线
从S₀计数到S_i时同步(等到下个时钟) 被置成S_j(其中快进了N-M个状态)，再计数到S₀。S_i状态不稳定（稳定状态循环中包括这个状态）

异步置零

在这里插入图片描述

同步置零

在这里插入图片描述

同步置数

在这里插入图片描述

② N<M

在这里插入图片描述

M=N₁xN₂

M＜NxN

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

① 环形计数器

在这里插入图片描述

② 扭环形计数器

在这里插入图片描述

【 5. 计数器应用】

① 顺序节拍脉冲发生器

74LS138译码器的 S₁、S₂、S₃可视为总开关，当三者同时有效时，方可正常工作，否则其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
收起
FPGA
verilog计数器
2020-04-15 22:05:31
256位计数器，题目：设计一个 8位计数器，包含清零信号 clear，复位信号 rst，预加载值 preload。解答：本次设置的 preload=32。理论上最大计数值为 256。模块名称为 counter。
收起
verilog

二进制计数器，环形计数器，Johnson计数器

2020-08-15 17:11:18

二进制计数器 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
2019-09-23 09:59:59
库伯勒 HC77系列计数器-脉冲计数器rar,库伯勒 HC77系列计数器-脉冲计数器
收起

计数器_计数器及其应用

2021-01-14 14:37:29

一、实验目的1、学习用集成触发器构成计数器的方法2、掌握中规模集成计数器的使用及功能测试方法3、运用集成计数计构成1/N分频器二、实验原理计数器是一个用以实现计数功能的时序部件，它不仅可用来计脉冲数，还常用...


	
一、实验目的1、学习用集成触发器构成计数器的方法2、掌握中规模集成计数器的使用及功能测试方法3、运用集成计数计构成1/N分频器二、实验原理计数器是一个用以实现计数功能的时序部件，它不仅可用来计脉冲数，还常用作数字系统的定时、分频和执行数字运算以及其它特定的逻辑功能。
计数器种类很多。按构成计数器中的各触发器是否使用一个时钟脉冲源来分，有同步计数器和异步计数器。根据计数制的不同，分为二进制计数器，十进制计数器和任意进制计数器。根据计数的增减趋势，又分为加法、减法和可逆计数器。还有可预置数和可编程序功能计数器等等。目前，无论是TTL还是CMOS集成电路，都有品种较齐全的中规模集成计数器。使用者只要借助于器件手册提供的功能表和工作波形图以及引出端的排列，就能正确地运用这些器件。1、用D触发器构成异步二进制加／减计数器
下图是用四只D触发器构成的四位二进制异步加法计数器，它的连接特点是将每只D触发器接成T'触发器，再由低位触发器的端和高一位的CP端相连接。
若将上图稍加改动，即将低位触发器的Q端与高一位的CP端相连接，即构成了一个4位二进制减法计数器。2、中规模十进制计数器
CC40192或74LS192是同步十进制可逆计数器，具有双时钟输入，并具有清除和置数等功能，其引脚排列及逻辑符号如下图所示。
74LS192同步十进制可逆计数器逻辑功能总结：
3、计数器的级联使用
一个十进制计数器只能表示0～9十个数，为了扩大计数器范围，常用多个十进制计数器级联使用。
同步计数器往往设有进位(或借位)输出端，故可选用其进位(或借位)输出信号驱动下一级计数器。下图是由CC40192利用进位输出控制高一位的CP_U端构成的加数级联图。用两个CC40192计数器可以构成100进制计数器。
4、实现任意进制计数
(1)用复位法获得任意进制计数器
假定已有N进制计数器，而需要得到一个M进制计数器时，只要M＜N，用复位法使计数器计数到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)
四、实验内容1、用74LS74 D触发器构成4位二进制异步加法计数器。
实验步骤-连接电路后，按单次脉冲源，观察输出端状态变化。
4位二进制异步加法计数器状态表：
将图电路中的低位触发器的Q端与高一位的CP端相连接，构成减法计数器，按实验内容2)、3)进行实验，观察并列表记录Q₃～Q₀的状态。(选做)2. CC40192或74LS192构成十进制加法计数电路图(选做)
(减计数时CPU接高CPD接脉冲)
3、用两片CC40192或74LS192组成两位十进制加法计数器
   按图连接电路，输入计数脉冲，进行由00—99累加计数，记录之。
实验步骤-连接电路后，按单次脉冲源，观察输出端状态变化。
4、将两位十进制加法计数器改为两位十进制减法计数器，实现由99—00递减计数，记录之。(选做)
5、设计一个数字钟移位60进制计数器并进行实验。(选做)
五、实验报告及总结要求
1、画出实验线路图，记录、整理实验现象及实验所得的有关波形。对实验结果进行分析。2、总结使用集成计数器的体会。

收起

展开全文

计数器_智能计数器简介
2020-12-27 16:00:51
计数器主要是应用于电子科技领域，计数器是一种运用得比较多的时序逻辑电路。计数器可以对数字进行运算，它是一种没有办法显示计算结果的显示器。随着电子科技的不断发展，现在的计数器也实现了智能功能。智能计数器...
收起
数字逻辑模6计数器D触发器实现电路
2020-12-26 10:13:09
计数器
收起
计数器CD40192在这里被接成加计数器
2020-08-08 11:03:32
绍了计数器CD40192在这里被接成加计数器的使用方法
收起
hadoop 计数器与自定义计数器
2019-07-05 22:24:50
计数器 自定义Java计数器 1）MapReduce框架允许用户自定义计数器 2）计数器是一个全局变量 3）计数器有组的概念，可以用Java的枚举类型或者用字符串来定义 public Counter getCounter(Enum<?> counterName...
收起
程序计数器
2020-12-30 22:31:24
文章目录PC Registers程序计数器案例 PC Registers 程序计数器案例
收起
jvm
人数计数器
2014-11-22 22:03:06
人数计数器，LCD电子计数器，计数器，最大计数100亿，这个资料很难得，带源程序和仿真软件仿真图，只要稍懂点电子知识的就能看懂和制作
收起
计数器_尘埃粒子计数器检测范围,手持式尘埃离子计数器
2020-12-26 17:11:00
尘埃粒子计数器根据不同的分类标准具有不同的分类方式，其根据流量大小的不同可分为小流量计数器和大流量计数器;根据体积及其形状的不同可分为手持式计数器和台式计数器;根据测试原理的不同可分为光散乱法测试计数器...
收起
jmeter 计数器_Jmeter之计数器
2020-12-24 18:27:48
如果需要引用的数据量较大，且要求不能重复或者需要自增，那么可以使用计数器来实现。计数器(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 就是用来初始化的，这...
收起
css html list-style
分别设计网页访问计数器，会话计数器，访问网站计数器。
2020-05-17 19:15:32
张继军董卫《java web 应用开发技术与实案列教程》课后习题之第三章第7题网页访问计数器count1.jsp会话计数器count2.jsp访问网站访问计数器count3.jsp 题目内容：7.分别设计网页访问计数器，会话计数器，访问网站...
收起
java web jsp session
Hadoop 计数器
2016-05-17 11:11:06
计数器 1）计数器主要用来收集系统信息，以及相关作业的运行时候的统计数据，用于知道作业成功、失败等情况。 2）相比而言，计数器方式比日志更易于分析内置计数器 1）Hadoop内置的计数器，主要用来记录作业的...
收起
hadoop
红外光电计数器
2018-06-21 18:34:24
红外光电计数器：使用51单片机开发板开发的红外计数器；
收起
CSS计数器
2019-10-11 19:23:40
CSS计数器我们在编辑网页时常常需要一些序号，css计数器就可以帮助我们实现根据一定规则来递增变量。 css计数器有以下几个属性： counter-reset 创建或者重置计数器 counter-increment 递增变量 content 插入生成的...
收起
css

计数器

文章目录

【 1. 同步计数器 】

① 同步二进制计数器

同步二进制加法计数器

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

74163

同步二进制减法计数器

同步二进制加/减计数器

单时钟方式 74191

双时钟方式 74193

② 同步十进制计数器

同步十进制加法计数器

74160

74162

同步十进制减法计数器

同步十进制加减计数器

【 2. 异步计数器 】

① 异步二进制计数器

异步二进制加法计数器

异步二进制减法计数器

② 异步十进制计数器

异步十进制加法计数器

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

① N>M

异步置零

同步置零

同步置数

② N<M

M=N1xN2

M＜NxN

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

① 环形计数器

② 扭环形计数器

【 5. 计数器应用 】

① 顺序节拍脉冲发生器

② 序列脉冲发生器

counter计数器

CSS 计数器

约翰逊计数器

verilog计数器

二进制计数器，环形计数器，Johnson计数器

实用的web计数器插件

库伯勒 HC77系列计数器-脉冲计数器.rar

计数器_计数器及其应用

计数器_智能计数器简介

数字逻辑模6计数器D触发器实现电路

计数器CD40192在这里被接成加计数器

hadoop 计数器与自定义计数器

程序计数器

人数计数器

计数器_尘埃粒子计数器检测范围,手持式尘埃离子计数器

jmeter 计数器_Jmeter之计数器

计数器应用

css计数器

分别设计网页访问计数器，会话计数器，访问网站计数器。

Hadoop 计数器

红外光电计数器

CSS计数器

计数器

新一代数据仓库：Snowflake 弹性数仓介绍(全文翻译)

微服务系列第七十一季-Introducing Spring Boot

【已解决】ImportError: No module named arbotix_msgs.msg

2021-01-19

mysql查询语句记录

layui-v2.5.6

【数据分析-随到随学】机器学习模型及应用

Python 一行代码能做什么

bootstrap-select下拉复选框.rar

前端架构师-速成

UniPatcher2019(macOS)

备战2021软考网络规划设计师历年真题套餐

redis学习

数控加工基础（第三版）习题册参考资料（答案）-A02-9077.pdf

使用element UI导航菜单默认展开选中子菜单

openfire_4_6_0_bundledJRE_x64.exe

剑指 Offer 22. 链表中倒数第k个节点

【数据分析-随到随学】量化交易策略模型

项目笔记四：使用python的pyserial操作串口

matlab程序画图像的直方图

【 1. 同步计数器】

【 2. 异步计数器】

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

M=N₁xN₂

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

【 5. 计数器应用】