The integral constant for the speed regulation PID.
328398
def speed_i(self):
        
        self._speed_i, value = self.get_attr_int(self._speed_i, 'speed_pid/Ki')
        return value
899493
def register_phase_model(self, pid):
        
        if self.assignments['forward_model'] is None:
            self.assignments['forward_model'] = [None, None]

        self.assignments['forward_model'][1] = pid
326036
def _integrate_variable_trajectory(self, h, g, tol, step, relax):
        """"""
        # initialize the solution using initial condition
        solution = np.hstack((self.t, self.y))

        while self.successful():

            self.integrate(self.t + h, step, relax)
            current_step = np.hstack((self.t, self.y))
            solution = np.vstack((solution, current_step))

            if g(self.t, self.y, *self.f_params) < tol:
                break
            else:
                continue

        return solution
13631
def get_motor_offsets(SERVO_OUTPUT_RAW, ofs, motor_ofs):
    ''''''
    import mavutil
    self = mavutil.mavfile_global

    m = SERVO_OUTPUT_RAW
    motor_pwm = m.servo1_raw + m.servo2_raw + m.servo3_raw + m.servo4_raw
    motor_pwm *= 0.25
    rc3_min = self.param('RC3_MIN', 1100)
    rc3_max = self.param('RC3_MAX', 1900)
    motor = (motor_pwm - rc3_min) / (rc3_max - rc3_min)
    if motor > 1.0:
        motor = 1.0
    if motor < 0.0:
        motor = 0.0

    motor_offsets0 = motor_ofs[0] * motor
    motor_offsets1 = motor_ofs[1] * motor
    motor_offsets2 = motor_ofs[2] * motor
    ofs = (ofs[0] + motor_offsets0, ofs[1] + motor_offsets1, ofs[2] + motor_offsets2)

    return ofs
1031315
function pidFind(pid) {
  if (!_.isFinite(pid)) return false;
  try {
    if (runningAsRoot()) {
      return process.kill(pid, 0);
    } else {
      return !!ps(pid);
    }
  } catch (e) {
    return false;
  }
}
1293424
def __writepid(self, pid):
        
        import tempfile
        d = tempfile.gettempdir()
        name = os.path.join(d, "hoverpy.%i.%i"%(self._proxyPort, self._adminPort))
        with open(name, 'w') as f:
            f.write(str(pid))
            logging.debug("writing to %s"%name)
598770
public static void setProcessInfo(String pid, String label, String superPid) {
		svPid = pid ;
		svLabel = label ;
		svSuperPid = superPid ;
	}
441776
def write_pid(self, pid=None):
    """"""
    pid = pid or os.getpid()
    self.write_metadata_by_name(self._name, 'pid', str(pid))
1351676
def set_id(self,pid):
        
        if self.type == 'KAF':
            return self.node.set('pid',pid)
        elif self.type == 'NAF':
            return self.node.set('id',pid)
837860
def mod2pi(ts):
    
    return np.pi - np.mod(np.pi - ts, 2*np.pi)
1011458
def pid_from_context(_, context):
    """"""
    pid = (context or {}).get('pid')
    return pid.pid_value if pid else missing
128560
def PartialDynamicSystem(self, ieq, variable):
        
        if ieq == 0:
            # U1=0
            if variable == self.variables[0]:
                b1 = FunctionBlock(
                    self.physical_nodes[0].variable, self.max_torque, self.Tmax)
                b2 = Saturation(self.commands[0], self.throttle, 0, 1)
                b3 = Product(self.max_torque, self.throttle, variable)
                return[b1, b2, b3]
890330
function(res, pid) {
  var lines = res.split('\n')
    , data = s(lines[1]).collapseWhitespace().s
    , dataParts = data.split(' ');

  return {
    pid: pid
  , cpu: dataParts[0] || '0.0'
  , mem: dataParts[1] || '0'
  };
}
208113
def setSpeedDeviation(self, typeID, deviation):
        
        self._connection._sendDoubleCmd(
            tc.CMD_SET_VEHICLETYPE_VARIABLE, tc.VAR_SPEED_DEVIATION, typeID, deviation)
28593
def pid(self):
        
        return hashlib.md5(':'.join([self.__class__.__name__,
                                     self._uri]).encode('utf-8')).hexdigest()
281049
def send_pid(cls, sock, pid):
    """"""
    assert(isinstance(pid, IntegerForPid) and pid > 0)
    encoded_int = cls.encode_int(pid)
    cls.write_chunk(sock, ChunkType.PID, encoded_int)
88151
def PartialDynamicSystem(self, ieq, variable):
        
        if ieq == 0:
            # U2-U1=signal
            if variable == self.physical_nodes[0].variable:
                # U1 is output
                # U1=U2-signal
                return [WeightedSum([self.physical_nodes[1].variable, self.voltage_signal], variable, [1, -1])]
            elif variable == self.physical_nodes[1].variable:
                # U2 is output
                # U2=U1+signal
                return [WeightedSum([self.physical_nodes[0].variable, self.voltage_signal], variable, [1, 1])]