def run(self, value, variable, current, error=0, modulo_error=False): """ :param value: A Number that represents the value to be targeted. :param variable: A SHM variable (object with a set method) that will be called with a single argument to target. :param current: A function that when called with no arguments returns the current value as a Number. :param error: A Number representing the allowed error before a wrapper is finished. :param modulo_error: a Boolean that is true only if the error calculated should be with respect to modulo 360. """ value, current = evaluate_or_call(value), evaluate_or_call(current) variable.set(value) if within_deadband(value, current, error, use_mod_error=modulo_error): self._finish()
def run(self, point, deadband=(15, 15), px=.0005, ix=0, dx=0, py=.001, iy=0, dy=0, target=(512, 384), min_out=None): point = evaluate_or_call(point) self.pid_loop_x(input_value=point[0], p=px, i=ix, d=dx, target=target[0], deadband=deadband[0], min_out=min_out) self.pid_loop_y(input_value=point[1], p=py, i=iy, d=dy, target=target[1], deadband=deadband[1], min_out=min_out) if finished(self.pid_loop_x, self.pid_loop_y): self._finish()
def run(self, point, deadband=(15, 15), px=.001, ix=0, dx=0, py=.001, iy=0, dy=0, target=(510, 510), modulo_error=False): point = evaluate_or_call(point) self.log('Running ForwardTarget on ({0}, {1}).'.format( point[0], point[1])) self.pid_loop_x(input_value=point[0], p=px, i=ix, d=dx, target=target[0], deadband=deadband[0], negate=True) self.pid_loop_y(input_value=point[1], p=py, i=iy, d=dy, target=target[1], deadband=deadband[1], negate=True) if finished(self.pid_loop_x, self.pid_loop_y): self._finish()
def firstrun(self, value, variable, current, error=0, delta=False, modulo_error=False): self.initial_value = evaluate_or_call(current)
def run(self, input_value, output_function, p=0.2, d=0, i=0, target=0, deadband=0, modulo_error=False, negate=False, debug=False, min_out=None): input_value = evaluate_or_call(input_value) # Don't do anything if the current value (input_value) is within the deadband of the target. if within_deadband(input_value, target, deadband, use_mod_error=modulo_error): # TODO: Should we set the output to the target as we don't know what the current target is? self._finish() return err = (-1 if negate else 1) * (target - input_value) self.error = err # P, I and D loops output_value = p * err self.total_error += err * (self.this_run - self.last_run) output_value += i * self.total_error output_value += d * (self.last_value - input_value) / (self.this_run - self.last_run) if debug: print(output_value) print() if min_out is not None and output_value < min_out: output_function(min_out * (-1 if output_value < 0 else 1)) else: output_function(output_value) self.log({ 'p': p, 'i': i, 'd': d, 'in': input_value, 'out': output_value, 'negate': negate })
def run(self, angle, deadband=3, p=.001, i=0, d=0, target=0, modulo_error=True): angle = evaluate_or_call(angle) self.pid_loop_heading(input_value=angle, p=p, i=i, d=d, target=target, deadband=deadband, negate=True) if finished(self.pid_loop_heading): self._finish()
def run(self, distance, deadband=.1, p=1, i=0, d=0): """ :param distance: The distance to move. Positive values will move the sub right. :param deadband: The accepted error for when the task should finish. If the sub has moved forward in the range [distance - deadband, distance + deadband], then the task will finish. """ self.total_distance += kalman.vely.get() * (self.this_run - self.last_run) distance = evaluate_or_call(distance) self.pid_loop_y(input_value=self.total_distance, p=p, i=i, d=d, deadband=deadband, target=distance) if finished(self.pid_loop_y): self._finish()
def firstrun(self, input_value, output_function, *args, **kwargs): self.total_error = 0 self.last_value = evaluate_or_call(input_value) self.out = output_function self.error = 0
def run(self, condition, task1, task2): task1() if evaluate_or_call(condition) else task2()