文章目录
【 1. 同步计数器 】
① 同步二进制计数器
同步二进制加法计数器
74161 十六进制四位二进制加法计数器
74163
同步二进制减法计数器
同步二进制加/减计数器
单时钟方式 74191
双时钟方式 74193
② 同步十进制计数器
同步十进制加法计数器
74160
74162
同步十进制减法计数器
同步十进制加减计数器
【 2. 异步计数器 】
① 异步二进制计数器
异步二进制加法计数器
异步二进制减法计数器
② 异步十进制计数器
异步十进制加法计数器
【 3. N进制计数器→M进制计数器 】
① N>M
异步置零
同步置零
同步置数
② N

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

【 1. 同步计数器 】
① 同步二进制计数器
同步二进制加法计数器

原理










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




方程




状态转换表

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




状态转换图

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




时序图

从时序图中可以看出，若计数输入脉冲的频率为f0，则Q0、Q1、Q2、Q3输出端脉冲的频率将依次为$\frac{1}{2}f~0~$、$\frac{1}{4}f~0~$、$\frac{1}{8}f~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数据选择器

一、实验目的
掌握8254的基本工作原理和编程方法，用示波器观察不同方式下的波形。（说明：没有示波器，所以用LED灯的闪烁来观察）
二、实验原理和内容

三、编程提示

四、电路接线图
实验1：



实验2：


五、程序设计流程图
实验1：



实验2：


六、一些说明

实验1中，每次读取后简单判断一下是不是跟上次一样，因为可能本次读取时计数器还没有减1。
实验2中，由于要输出两个不同的频率方波，并且要使LED灯来得及闪烁，所以需要用到三个计数器。

七、程序源代码
实验1：
stack segment stack
    db 200 dup(0)
stack ends

data segment
      ZERO equ 280h
      ONE equ 281h
      CTRL equ 283h
data ends

code segment
      assume cs:code,ds:data,ss:stack

      newline MACRO   ;回车换行
        push ax
        push dx
        mov ah,02h
        mov dl,0ah
        int 21h
        mov ah,02h
        mov dl,0dh
        int 21h
        pop dx
        pop ax
      ENDM

      dispchar MACRO x    ;输出单个字符并换行
        push dx
        push ax
        newline
        mov ah,02h
        mov dl,x
        int 21h
        pop ax
        pop dx
      ENDM

      put_data MACRO x, y  ;x为端口,y为数据
        push ax
        push dx
        mov al, y
        mov dx, x
        out dx, al
        pop dx
        pop ax
      ENDM

   main:mov ax,data
        mov ds,ax
        mov ax, stack
        mov ss, ax
        put_data CTRL, 00010000b  ;计数器0工作在方式0下，只读写低8位，二进制计数码
        put_data ZERO, 0fh   ;写入计数器初值15,开始计数
  again:mov dx, ZERO
        in al, dx   ;读取通道0数据
        and al, 0fh;  读取低四位
        mov dl, al
        cmp bl, dl
        jz again   ;本次读出的数值与上次一样，说明还没有手动输入脉冲，继续读取，直到本次读取 的数据与上次不一样
        mov bl, dl  ;本次与上次不一样
        cmp dl, 9  ;判断是否小于9
        ja disp_
        add dl, 30h
        dispchar dl   ;显示0-9的一个数
        jmp again
  disp_:add dl, 37h
        dispchar dl    ;显示A-F中的一个数
        jmp again
        mov ah,4ch
        int 21h
code ends
     end main

实验2：
stack segment stack
    db 200 dup(0)
stack ends

data segment
      ZERO equ 280h
      ONE equ 281h
      TWO equ 282h
      CTRL equ 283h
      
data ends

code segment
      assume cs:code,ds:data,ss:stack
      
      put_data MACRO x, y  ;x为端口 y为数据
        push ax
        push dx
        mov al, y
        mov dx, x
        out dx, al
        pop dx
        pop ax
      ENDM

;分析：连接时钟频率为1MHz,周期为1us,要求输出的1Hz的信号周期为1秒,分频系数为1e6,but8254最大计数为65536
;又因为1e6 = 1000 * 1000,所以通道0和通道1分别把信号1000分频即可

   main:mov ax,data
        mov ds,ax
        mov ax, stack
        mov ss, ax
        put_data CTRL, 00110111b  ;计数器0工作在方式3下,读写16位,BCD计数码
        put_data ZERO, 00   ;写入计数器初值1000
        put_data ZERO, 10h  ;先写低8位再写高8位0001 0000 0000 0000
        put_data CTRL, 01110110b  ;计数器1工作在方式3下,读写16位,二进制数码
        put_data ONE, 0e8h
        put_data ONE, 03h   ;写入计数器初值1000,开始计数,out0端为高电平,接LED灯,LED灯亮
        put_data CTRL 10110111b    ;计数器2工作在方式3下，读写16位，BCD计数码
        put_data TWO 02      ；写入计数初值2，输出两个端口，out1端口输出频率是out2端口2倍
        put_data TWO 00h
        mov ah, 4ch
        int 21h
code ends
     end main

一、为什么要做计数器：

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

二、难点：

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;
    }
}


 

二进制计数器

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