Python 如何记录系统输出1的时间？

此代码注册来自串行USB端口距离跟踪器的传入数据，并将数据流转换为

1

或

0

（如果它们超过某个阈值），并添加Unix时间戳

代码：

import serial
import datetime
import time

distance = 5

# Open serial usb port
ser = serial.Serial('/dev/tty.usbserial', 115200, timeout=0.05)

# converts data to 1/0 
def convertData(data):
    data = data.decode("utf-8")
    data = data.replace('$BM,','') 

    try:
        data = float(data)
        if data <= distance:
        data = 1
        else:
            data = 0
    except ValueError:
        pass
    return data


while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print ('Distance:', specData,'Timestamp(Unix):', measureunix)   

问题：

import serial
import datetime
import time

distance = 5

# Open serial usb port
ser = serial.Serial('/dev/tty.usbserial', 115200, timeout=0.05)

# converts data to 1/0 
def convertData(data):
    data = data.decode("utf-8")
    data = data.replace('$BM,','') 

    try:
        data = float(data)
        if data <= distance:
        data = 1
        else:
            data = 0
    except ValueError:
        pass
    return data


while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print ('Distance:', specData,'Timestamp(Unix):', measureunix)   

至于下一步-我不知道如何做，但我想设置一个计数器，当输出为（1）时开始计数，继续计数直到有两个连续的（0），然后停止计数并打印出花费在计数上的时间

（上次的时间（1）-第一次的时间（1））

除以

（1）的数量

，等待下一个

（1）

，然后再次启动

背景：

我正在尝试建立一个系统，使用距离跟踪激光来测量旋转圆盘的速度（圆盘上有固定直径的孔）。因此，激光将记录旋转，从而有可能了解旋转圆盘的角速度和角度

---

也许有更好的方法可以做到这一点，我不确定。

类似的方法可以跟踪您试图跟踪的状态和价值：

start_one_time = None
last_one_time = None
zeros_seen = 0
ones_seen = 0
while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print ('Distance:', specData, 'Timestamp(Unix):', measureunix)

    if specData == 1:
        zeros_seen = 0
        ones_seen += 1
        if start_one_time is None:
            start_one_time = measureunix
        last_one_time = measureunix
    else:
        zeros_seen += 1
        if start_one_time is not None and zeros_seen == 2:
            duration = last_one_time - start_one_time
            print (duration / ones_seen)
            start_one_time = None
            ones_seen = 0

---

注意：我无法测试它，因此它可能包含一些错误。

类似的内容可以跟踪您试图跟踪的状态和值：

start_one_time = None
last_one_time = None
zeros_seen = 0
ones_seen = 0
while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print ('Distance:', specData, 'Timestamp(Unix):', measureunix)

    if specData == 1:
        zeros_seen = 0
        ones_seen += 1
        if start_one_time is None:
            start_one_time = measureunix
        last_one_time = measureunix
    else:
        zeros_seen += 1
        if start_one_time is not None and zeros_seen == 2:
            duration = last_one_time - start_one_time
            print (duration / ones_seen)
            start_one_time = None
            ones_seen = 0

---

注意：我无法测试它，因此它可能包含一些错误。

当然，我无法用真实数据测试它，但以下方法似乎适用于模拟输入。基本上，您所做的是解析0和1的数据流，而a似乎是一种很好的方法。一个类的逻辑可以完全封装在一个类中：

class FSM(object):
    def __init__(self):
        self.state = self.state0

    def transition(self, value):
        self.state(value)

    def state0(self, value):
        if value == 1:
            self.start = time.time()
            self.count = 1
            self.state = self.state1

    def state1(self, value):
        if value == 0:  # first 0?
            self.state = self.state2
        if value == 1:
            self.count += 1

    def state2(self, value):
        if value == 0:  # second 0 in a row?
            elapsed = time.time() - self.start
            try:
                rate = self.count / elapsed
            except ZeroDivisionError:
                rate = float('NaN')
            print('rate {}'.format(rate))
            self.state = self.state0
        if value == 1:
            self.count += 1
            self.state = self.state1

使用它很简单，只需使用每个数据值调用其

transition（）

方法即可：

fsm = FSM()
while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print('Distance:', specData, 'Timestamp(Unix):', measureunix)
    fsm.transition(specData)

---

当然，我不能用真实数据来测试这一点，但下面的方法似乎适用于模拟输入。基本上，您所做的是解析0和1的数据流，而a似乎是一种很好的方法。一个类的逻辑可以完全封装在一个类中：

class FSM(object):
    def __init__(self):
        self.state = self.state0

    def transition(self, value):
        self.state(value)

    def state0(self, value):
        if value == 1:
            self.start = time.time()
            self.count = 1
            self.state = self.state1

    def state1(self, value):
        if value == 0:  # first 0?
            self.state = self.state2
        if value == 1:
            self.count += 1

    def state2(self, value):
        if value == 0:  # second 0 in a row?
            elapsed = time.time() - self.start
            try:
                rate = self.count / elapsed
            except ZeroDivisionError:
                rate = float('NaN')
            print('rate {}'.format(rate))
            self.state = self.state0
        if value == 1:
            self.count += 1
            self.state = self.state1

使用它很简单，只需使用每个数据值调用其

transition（）

方法即可：

fsm = FSM()
while True:
    data = ser.read(9999999)
    measureunix = float(time.time())
    specData = convertData(data)
    print('Distance:', specData, 'Timestamp(Unix):', measureunix)
    fsm.transition(specData)

---

注意你真的不需要做

float（time.time（））

，因为

time.time（）

返回浮点值。布兰登：不客气。实际上，经过一些额外的测试后，我认为它不太正确，在

state2（）

方法的末尾添加了

self.state=self.state1

。还添加了一个异常处理程序，以防计算的

已用时间

始终为零并导致除法错误。请注意，您确实不需要执行

浮点（time.time（））

，因为

time.time（）

返回浮点值。布兰登：不客气。实际上，经过一些额外的测试后，我认为它不太正确，在

state2（）

方法的末尾添加了

self.state=self.state1

。还添加了一个异常处理程序，以防计算的

经过的
时间始终为零并导致除法错误。