0

我有 2 个带有值的 txt 文件，一个带有点 1 的 x 坐标，一个带有点 2 的 x 坐标，点 2 需要跟随点 1，在通过调节器运行点之间的差异后，我需要获得点 2 的速度由于系统是离散的，因此我们假设每 8ms 调节一次调节器

简而言之：从point1和point2的txt读取行通过调节器对point2的写入速度，每8ms或更慢，没关系

点的坐标逐行列在 txt 文件中，我已经有调节器的代码（如下），但不知道如何使用 txt 文件来执行此操作，因为我刚开始使用 python

class PID:
    """
    Discrete PID control
    """

    def __init__(self, P=1.3, I=0.3, D=0.0, Derivator=0, Integrator=0, Integrator_max=500, Integrator_min=-500):

        self.Kp=P
        self.Ki=I
        self.Kd=D
        self.Derivator=Derivator
        self.Integrator=Integrator
        self.Integrator_max=Integrator_max
        self.Integrator_min=Integrator_min

        self.set_point=0.0
        self.error=0.0

    def update(self,current_value):
        """
        Calculate PID output value for given reference input and feedback
        """

        self.error = self.set_point - current_value

        self.P_value = self.Kp * self.error
        self.D_value = self.Kd * ( self.error - self.Derivator)
        self.Derivator = self.error

        self.Integrator = self.Integrator + self.error

        if self.Integrator > self.Integrator_max:
            self.Integrator = self.Integrator_max
        elif self.Integrator < self.Integrator_min:
            self.Integrator = self.Integrator_min

        self.I_value = self.Integrator * self.Ki

        PID = self.P_value + self.I_value + self.D_value

        return PID

    def setPoint(self,set_point):
        """
        Initilize the setpoint of PID
        """
        self.set_point = set_point
        self.Integrator=0
        self.Derivator=0

    def setIntegrator(self, Integrator):
        self.Integrator = Integrator

    def setDerivator(self, Derivator):
        self.Derivator = Derivator

    def setKp(self,P):
        self.Kp=P

    def setKi(self,I):
        self.Ki=I

    def setKd(self,D):
        self.Kd=D

    def getPoint(self):
        return self.set_point

    def getError(self):
        return self.error

    def getIntegrator(self):
        return self.Integrator

    def getDerivator(self):
        return self.Derivator
4

1 回答 1

2

假设您有两个文件，其中包含int- 每行一个。
这里是in_1.txt：

12
15
117
1

这是in_2.txt：

22
25
217
2

以下是如何根据您的需要逐步处理这些文件。

第 1 步：读取两个输入文件

以下代码将能够读取其自己的Python 列表中的每个文件内容：

# Read first file
with open("in_1.txt", "rt") as f:
    # in the following line, replace `int` by `float` to read ... floats
    data1 = [int(line) for line in f.readlines()]

# Read second file
with open("in_2.txt", "rt") as f:
    # in the following line, replace `int` by `float` to read ... floats
    data2 = [int(line) for line in f.readlines()]

print "data1 =", data1
print "data2 =", data2

生产：

data1 = [12, 15, 117, 1]
data2 = [22, 25, 217, 2]

在这里，为了简单起见，我在其自己的列表中读取了每个文件，以便随后将它们合并。但是，根据您的数据文件的大小，它们可能是对内存更友好的读取方式。无论如何，让我们进一步处理“合并”......

步骤 2a：连接两个列表

您可以使用以下方式将列表的所有项目附加到另一个列表中extends：

data1.extend(data2)
print "data1 =", data1

生产：

data1 = [12, 15, 117, 1, 22, 25, 217, 2]

步骤 3a：将数据写入输出文件

最后，您必须将列表中的内容写入每行out.txt一个值：

with open("out.txt", "wt") as f:
    for i in data1:
        f.write("{0}\n".format(i))

你现在有它out.txt：

12
15
117
1
22
25
217
2

步骤 2b：生成数据对

假设您还有在Step 1末尾找到的data1列表。但是现在，您希望成对配对。因为/如果您的两个列表具有相同的长度，您可以使用（或更好的内存效率）data2zipitertools.izip

pairs = zip(data1, data2)
print data1
print data2
print pairs

产生输出：

[12, 15, 117, 1]
[22, 25, 217, 2]
[(12, 22), (15, 25), (117, 217), (1, 2)]

步骤 3b：写入输出文件，每行一对，用空格分隔

最后，假设您必须将这些对写入“空格分隔”文件：

with open("out.txt", "wt") as f:
    for x, y in pairs:
        f.write("{0} {1}\n".format(x,y))

生成输出文件out.txt：

12 22
15 25
117 217
1 2

遗言

最后一句话。有很多空间可以“优化”或“定制”所有这些示例。但我认为他们会向您展示一些从文件读取/写入整数的基本用法。最后，我在integers上完成了所有这些。但是，如果您使用floats，则必须将单词int的每个实例替换为float... 并且它应该可以工作。

于 2013-06-17T18:19:48.180 回答