_PowerBoardState.py

Go to the documentation of this file.

"""autogenerated by genpy from pr2_msgs/PowerBoardState.msg. Do not edit."""
import sys
python3 = True if sys.hexversion > 0x03000000 else False
import genpy
import struct

import std_msgs.msg

class PowerBoardState(genpy.Message):
  _md5sum = "08899b671e6a1a449e7ce0000da8ae7b"
  _type = "pr2_msgs/PowerBoardState"
  _has_header = True #flag to mark the presence of a Header object
  _full_text = """# This message communicates the state of the PR2's power board.
int8 STATE_NOPOWER=0
int8 STATE_STANDBY=1
int8 STATE_PUMPING=2
int8 STATE_ON=3
int8 STATE_ENABLED=3  # Preferred over STATE_ON, keeping STATE_ON for backcompat
int8 STATE_DISABLED=4

int8 MASTER_NOPOWER=0
int8 MASTER_STANDBY=1
int8 MASTER_ON=2
int8 MASTER_OFF=3
int8 MASTER_SHUTDOWN=4

Header header
string name # Name with serial number
uint32 serial_num # Serial number for this board's message
float64 input_voltage # Input voltage to power board

# Master States:
#  MASTER_NOPOWER, MASTER_STANDBY, MASTER_ON, MASTER_OFF, MASTER_SHUTDOWN 
int8 master_state  # The master state machine's state in the powerboard

# Circuit States:
#  STATE_NOPOWER, STATE_STANDBY, STATE_PUMPING, STATE_ON, STATE_DISABLED
int8[3] circuit_state # One of the above states
float64[3] circuit_voltage  # Output voltage of each circuit

# True if robot should be enabled
bool run_stop           #Note - if the wireless run-stop is hit, this will be unobservable
bool wireless_stop 

================================================================================
MSG: std_msgs/Header
# Standard metadata for higher-level stamped data types.
# This is generally used to communicate timestamped data 
# in a particular coordinate frame.
# 
# sequence ID: consecutively increasing ID 
uint32 seq
#Two-integer timestamp that is expressed as:
# * stamp.secs: seconds (stamp_secs) since epoch
# * stamp.nsecs: nanoseconds since stamp_secs
# time-handling sugar is provided by the client library
time stamp
#Frame this data is associated with
# 0: no frame
# 1: global frame
string frame_id

"""
  # Pseudo-constants
  STATE_NOPOWER = 0
  STATE_STANDBY = 1
  STATE_PUMPING = 2
  STATE_ON = 3
  STATE_ENABLED = 3
  STATE_DISABLED = 4
  MASTER_NOPOWER = 0
  MASTER_STANDBY = 1
  MASTER_ON = 2
  MASTER_OFF = 3
  MASTER_SHUTDOWN = 4

  __slots__ = ['header','name','serial_num','input_voltage','master_state','circuit_state','circuit_voltage','run_stop','wireless_stop']
  _slot_types = ['std_msgs/Header','string','uint32','float64','int8','int8[3]','float64[3]','bool','bool']

  def __init__(self, *args, **kwds):
    """
    Constructor. Any message fields that are implicitly/explicitly
    set to None will be assigned a default value. The recommend
    use is keyword arguments as this is more robust to future message
    changes.  You cannot mix in-order arguments and keyword arguments.

    The available fields are:
       header,name,serial_num,input_voltage,master_state,circuit_state,circuit_voltage,run_stop,wireless_stop

    :param args: complete set of field values, in .msg order
    :param kwds: use keyword arguments corresponding to message field names
    to set specific fields.
    """
    if args or kwds:
      super(PowerBoardState, self).__init__(*args, **kwds)
      #message fields cannot be None, assign default values for those that are
      if self.header is None:
        self.header = std_msgs.msg.Header()
      if self.name is None:
        self.name = ''
      if self.serial_num is None:
        self.serial_num = 0
      if self.input_voltage is None:
        self.input_voltage = 0.
      if self.master_state is None:
        self.master_state = 0
      if self.circuit_state is None:
        self.circuit_state = [0,0,0]
      if self.circuit_voltage is None:
        self.circuit_voltage = [0.,0.,0.]
      if self.run_stop is None:
        self.run_stop = False
      if self.wireless_stop is None:
        self.wireless_stop = False
    else:
      self.header = std_msgs.msg.Header()
      self.name = ''
      self.serial_num = 0
      self.input_voltage = 0.
      self.master_state = 0
      self.circuit_state = [0,0,0]
      self.circuit_voltage = [0.,0.,0.]
      self.run_stop = False
      self.wireless_stop = False

  def _get_types(self):
    """
    internal API method
    """
    return self._slot_types

  def serialize(self, buff):
    """
    serialize message into buffer
    :param buff: buffer, ``StringIO``
    """
    try:
      _x = self
      buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
      _x = self.header.frame_id
      length = len(_x)
      if python3 or type(_x) == unicode:
        _x = _x.encode('utf-8')
        length = len(_x)
      buff.write(struct.pack('<I%ss'%length, length, _x))
      _x = self.name
      length = len(_x)
      if python3 or type(_x) == unicode:
        _x = _x.encode('utf-8')
        length = len(_x)
      buff.write(struct.pack('<I%ss'%length, length, _x))
      _x = self
      buff.write(_struct_Idb.pack(_x.serial_num, _x.input_voltage, _x.master_state))
      buff.write(_struct_3b.pack(*self.circuit_state))
      buff.write(_struct_3d.pack(*self.circuit_voltage))
      _x = self
      buff.write(_struct_2B.pack(_x.run_stop, _x.wireless_stop))
    except struct.error as se: self._check_types(se)
    except TypeError as te: self._check_types(te)

  def deserialize(self, str):
    """
    unpack serialized message in str into this message instance
    :param str: byte array of serialized message, ``str``
    """
    try:
      if self.header is None:
        self.header = std_msgs.msg.Header()
      end = 0
      _x = self
      start = end
      end += 12
      (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
      start = end
      end += 4
      (length,) = _struct_I.unpack(str[start:end])
      start = end
      end += length
      if python3:
        self.header.frame_id = str[start:end].decode('utf-8')
      else:
        self.header.frame_id = str[start:end]
      start = end
      end += 4
      (length,) = _struct_I.unpack(str[start:end])
      start = end
      end += length
      if python3:
        self.name = str[start:end].decode('utf-8')
      else:
        self.name = str[start:end]
      _x = self
      start = end
      end += 13
      (_x.serial_num, _x.input_voltage, _x.master_state,) = _struct_Idb.unpack(str[start:end])
      start = end
      end += 3
      self.circuit_state = _struct_3b.unpack(str[start:end])
      start = end
      end += 24
      self.circuit_voltage = _struct_3d.unpack(str[start:end])
      _x = self
      start = end
      end += 2
      (_x.run_stop, _x.wireless_stop,) = _struct_2B.unpack(str[start:end])
      self.run_stop = bool(self.run_stop)
      self.wireless_stop = bool(self.wireless_stop)
      return self
    except struct.error as e:
      raise genpy.DeserializationError(e) #most likely buffer underfill


  def serialize_numpy(self, buff, numpy):
    """
    serialize message with numpy array types into buffer
    :param buff: buffer, ``StringIO``
    :param numpy: numpy python module
    """
    try:
      _x = self
      buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
      _x = self.header.frame_id
      length = len(_x)
      if python3 or type(_x) == unicode:
        _x = _x.encode('utf-8')
        length = len(_x)
      buff.write(struct.pack('<I%ss'%length, length, _x))
      _x = self.name
      length = len(_x)
      if python3 or type(_x) == unicode:
        _x = _x.encode('utf-8')
        length = len(_x)
      buff.write(struct.pack('<I%ss'%length, length, _x))
      _x = self
      buff.write(_struct_Idb.pack(_x.serial_num, _x.input_voltage, _x.master_state))
      buff.write(self.circuit_state.tostring())
      buff.write(self.circuit_voltage.tostring())
      _x = self
      buff.write(_struct_2B.pack(_x.run_stop, _x.wireless_stop))
    except struct.error as se: self._check_types(se)
    except TypeError as te: self._check_types(te)

  def deserialize_numpy(self, str, numpy):
    """
    unpack serialized message in str into this message instance using numpy for array types
    :param str: byte array of serialized message, ``str``
    :param numpy: numpy python module
    """
    try:
      if self.header is None:
        self.header = std_msgs.msg.Header()
      end = 0
      _x = self
      start = end
      end += 12
      (_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
      start = end
      end += 4
      (length,) = _struct_I.unpack(str[start:end])
      start = end
      end += length
      if python3:
        self.header.frame_id = str[start:end].decode('utf-8')
      else:
        self.header.frame_id = str[start:end]
      start = end
      end += 4
      (length,) = _struct_I.unpack(str[start:end])
      start = end
      end += length
      if python3:
        self.name = str[start:end].decode('utf-8')
      else:
        self.name = str[start:end]
      _x = self
      start = end
      end += 13
      (_x.serial_num, _x.input_voltage, _x.master_state,) = _struct_Idb.unpack(str[start:end])
      start = end
      end += 3
      self.circuit_state = numpy.frombuffer(str[start:end], dtype=numpy.int8, count=3)
      start = end
      end += 24
      self.circuit_voltage = numpy.frombuffer(str[start:end], dtype=numpy.float64, count=3)
      _x = self
      start = end
      end += 2
      (_x.run_stop, _x.wireless_stop,) = _struct_2B.unpack(str[start:end])
      self.run_stop = bool(self.run_stop)
      self.wireless_stop = bool(self.wireless_stop)
      return self
    except struct.error as e:
      raise genpy.DeserializationError(e) #most likely buffer underfill

_struct_I = genpy.struct_I
_struct_3b = struct.Struct("<3b")
_struct_3I = struct.Struct("<3I")
_struct_Idb = struct.Struct("<Idb")
_struct_2B = struct.Struct("<2B")
_struct_3d = struct.Struct("<3d")