""" Autogenerated python message buffer code. Source: clad/robotInterface/messageRobotToEngine.clad Full command line: victor-clad/tools/message-buffers/emitters/Python_emitter.py -C src -I clad/src lib/util/source/anki/clad robot/clad/src coretech/vision/clad_src coretech/common/clad_src -o generated/cladPython clad/robotInterface/messageRobotToEngine.clad """ from __future__ import absolute_import from __future__ import print_function def _modify_path(): import inspect, os, sys search_paths = [ '../..', '../../../../victor-clad/tools/message-buffers/support/python', ] currentpath = os.path.abspath(os.path.dirname(inspect.getfile(inspect.currentframe()))) for search_path in search_paths: search_path = os.path.normpath(os.path.abspath(os.path.realpath(os.path.join(currentpath, search_path)))) if search_path not in sys.path: sys.path.insert(0, search_path) _modify_path() import msgbuffers Anki = msgbuffers.Namespace() Anki.AudioEngine = msgbuffers.Namespace() Anki.AudioEngine.Multiplexer = msgbuffers.Namespace() Anki.AudioMetaData = msgbuffers.Namespace() Anki.AudioMetaData.GameEvent = msgbuffers.Namespace() Anki.Vector = msgbuffers.Namespace() Anki.Vector.RobotInterface = msgbuffers.Namespace() Anki.Vector.SwitchboardInterface = msgbuffers.Namespace() from clad.audio.audioCallbackMessage import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.robotInterface.factoryMessages import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.robotInterface.messageFromAnimProcess import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.alexaTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.beatDetectorTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.dockingSignals import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.motorTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.pathEventTypes import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.robotStatusAndActions import Anki as _Anki Anki.update(_Anki.deep_clone()) from clad.types.robotToSwitchboard import Anki as _Anki Anki.update(_Anki.deep_clone()) class SyncRobotAck(object): "Generated message-passing message." __slots__ = ( '_sysconVersion', # uint_8[16] ) @property def sysconVersion(self): "uint_8[16] sysconVersion struct property." return self._sysconVersion @sysconVersion.setter def sysconVersion(self, value): self._sysconVersion = msgbuffers.validate_farray( 'SyncRobotAck.sysconVersion', value, 16, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, 0, 255)) def __init__(self, sysconVersion=(0,) * 16): self.sysconVersion = sysconVersion @classmethod def unpack(cls, buffer): "Reads a new SyncRobotAck from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SyncRobotAck.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SyncRobotAck from the given BinaryReader." _sysconVersion = reader.read_farray('B', 16) return cls(_sysconVersion) def pack(self): "Writes the current SyncRobotAck, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SyncRobotAck to the given BinaryWriter." writer.write_farray(self._sysconVersion, 'B', 16) def __eq__(self, other): if type(self) is type(other): return self._sysconVersion == other._sysconVersion else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_farray(self._sysconVersion, 'B', 16)) def __str__(self): return '{type}(sysconVersion={sysconVersion})'.format( type=type(self).__name__, sysconVersion=msgbuffers.shorten_sequence(self._sysconVersion)) def __repr__(self): return '{type}(sysconVersion={sysconVersion})'.format( type=type(self).__name__, sysconVersion=repr(self._sysconVersion)) Anki.Vector.RobotInterface.SyncRobotAck = SyncRobotAck del SyncRobotAck class RobotServerDisconnect(object): "Generated message-passing message." __slots__ = () def __init__(self): pass @classmethod def unpack(cls, buffer): "Reads a new RobotServerDisconnect from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('RobotServerDisconnect.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new RobotServerDisconnect from the given BinaryReader." return cls() def pack(self): "Writes the current RobotServerDisconnect, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current RobotServerDisconnect to the given BinaryWriter." def __eq__(self, other): if type(self) is type(other): return True else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return 0 def __str__(self): return '{type}()'.format(type=type(self).__name__) def __repr__(self): return '{type}()'.format(type=type(self).__name__) Anki.Vector.RobotInterface.RobotServerDisconnect = RobotServerDisconnect del RobotServerDisconnect class StillAlive(object): "Generated message-passing message." __slots__ = () def __init__(self): pass @classmethod def unpack(cls, buffer): "Reads a new StillAlive from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('StillAlive.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new StillAlive from the given BinaryReader." return cls() def pack(self): "Writes the current StillAlive, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current StillAlive to the given BinaryWriter." def __eq__(self, other): if type(self) is type(other): return True else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return 0 def __str__(self): return '{type}()'.format(type=type(self).__name__) def __repr__(self): return '{type}()'.format(type=type(self).__name__) Anki.Vector.RobotInterface.StillAlive = StillAlive del StillAlive class PrepForShutdown(object): "Generated message-passing message." __slots__ = ( '_reason', # Anki.Vector.ShutdownReason ) @property def reason(self): "Anki.Vector.ShutdownReason reason struct property." return self._reason @reason.setter def reason(self, value): self._reason = msgbuffers.validate_integer( 'PrepForShutdown.reason', value, 0, 255) def __init__(self, reason=Anki.Vector.ShutdownReason.SHUTDOWN_UNKNOWN): self.reason = reason @classmethod def unpack(cls, buffer): "Reads a new PrepForShutdown from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('PrepForShutdown.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new PrepForShutdown from the given BinaryReader." _reason = reader.read('B') return cls(_reason) def pack(self): "Writes the current PrepForShutdown, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current PrepForShutdown to the given BinaryWriter." writer.write(self._reason, 'B') def __eq__(self, other): if type(self) is type(other): return self._reason == other._reason else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._reason, 'B')) def __str__(self): return '{type}(reason={reason})'.format( type=type(self).__name__, reason=self._reason) def __repr__(self): return '{type}(reason={reason})'.format( type=type(self).__name__, reason=repr(self._reason)) Anki.Vector.RobotInterface.PrepForShutdown = PrepForShutdown del PrepForShutdown class RobotPoked(object): "Generated message-passing message." __slots__ = () def __init__(self): pass @classmethod def unpack(cls, buffer): "Reads a new RobotPoked from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('RobotPoked.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new RobotPoked from the given BinaryReader." return cls() def pack(self): "Writes the current RobotPoked, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current RobotPoked to the given BinaryWriter." def __eq__(self, other): if type(self) is type(other): return True else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return 0 def __str__(self): return '{type}()'.format(type=type(self).__name__) def __repr__(self): return '{type}()'.format(type=type(self).__name__) Anki.Vector.RobotInterface.RobotPoked = RobotPoked del RobotPoked class AlexaAuthChanged(object): "Generated message-passing message." __slots__ = ( '_state', # Anki.Vector.AlexaAuthState '_extra', # string[uint_8] ) @property def state(self): "Anki.Vector.AlexaAuthState state struct property." return self._state @state.setter def state(self, value): self._state = msgbuffers.validate_integer( 'AlexaAuthChanged.state', value, 0, 255) @property def extra(self): "string[uint_8] extra struct property." return self._extra @extra.setter def extra(self, value): self._extra = msgbuffers.validate_string( 'AlexaAuthChanged.extra', value, 255) def __init__(self, state=Anki.Vector.AlexaAuthState.Invalid, extra=''): self.state = state self.extra = extra @classmethod def unpack(cls, buffer): "Reads a new AlexaAuthChanged from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AlexaAuthChanged.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AlexaAuthChanged from the given BinaryReader." _state = reader.read('B') _extra = reader.read_string('B') return cls(_state, _extra) def pack(self): "Writes the current AlexaAuthChanged, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AlexaAuthChanged to the given BinaryWriter." writer.write(self._state, 'B') writer.write_string(self._extra, 'B') def __eq__(self, other): if type(self) is type(other): return (self._state == other._state and self._extra == other._extra) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._state, 'B') + msgbuffers.size_string(self._extra, 'B')) def __str__(self): return '{type}(state={state}, extra={extra})'.format( type=type(self).__name__, state=self._state, extra=msgbuffers.shorten_string(self._extra)) def __repr__(self): return '{type}(state={state}, extra={extra})'.format( type=type(self).__name__, state=repr(self._state), extra=repr(self._extra)) Anki.Vector.RobotInterface.AlexaAuthChanged = AlexaAuthChanged del AlexaAuthChanged class AlexaUXChanged(object): "Generated message-passing message." __slots__ = ( '_state', # Anki.Vector.AlexaUXState ) @property def state(self): "Anki.Vector.AlexaUXState state struct property." return self._state @state.setter def state(self, value): self._state = msgbuffers.validate_integer( 'AlexaUXChanged.state', value, 0, 255) def __init__(self, state=Anki.Vector.AlexaUXState.Listening): self.state = state @classmethod def unpack(cls, buffer): "Reads a new AlexaUXChanged from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AlexaUXChanged.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AlexaUXChanged from the given BinaryReader." _state = reader.read('B') return cls(_state) def pack(self): "Writes the current AlexaUXChanged, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AlexaUXChanged to the given BinaryWriter." writer.write(self._state, 'B') def __eq__(self, other): if type(self) is type(other): return self._state == other._state else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._state, 'B')) def __str__(self): return '{type}(state={state})'.format( type=type(self).__name__, state=self._state) def __repr__(self): return '{type}(state={state})'.format( type=type(self).__name__, state=repr(self._state)) Anki.Vector.RobotInterface.AlexaUXChanged = AlexaUXChanged del AlexaUXChanged class TriggerWordDetected(object): "Generated message-passing message." __slots__ = ( '_triggerScore', # uint_32 '_direction', # uint_16 '_isButtonPress', # bool '_fromMute', # bool '_willOpenStream', # bool ) @property def triggerScore(self): "uint_32 triggerScore struct property." return self._triggerScore @triggerScore.setter def triggerScore(self, value): self._triggerScore = msgbuffers.validate_integer( 'TriggerWordDetected.triggerScore', value, 0, 4294967295) @property def direction(self): "uint_16 direction struct property." return self._direction @direction.setter def direction(self, value): self._direction = msgbuffers.validate_integer( 'TriggerWordDetected.direction', value, 0, 65535) @property def isButtonPress(self): "bool isButtonPress struct property." return self._isButtonPress @isButtonPress.setter def isButtonPress(self, value): self._isButtonPress = msgbuffers.validate_bool( 'TriggerWordDetected.isButtonPress', value) @property def fromMute(self): "bool fromMute struct property." return self._fromMute @fromMute.setter def fromMute(self, value): self._fromMute = msgbuffers.validate_bool( 'TriggerWordDetected.fromMute', value) @property def willOpenStream(self): "bool willOpenStream struct property." return self._willOpenStream @willOpenStream.setter def willOpenStream(self, value): self._willOpenStream = msgbuffers.validate_bool( 'TriggerWordDetected.willOpenStream', value) def __init__(self, triggerScore=0, direction=0, isButtonPress=False, fromMute=False, willOpenStream=False): self.triggerScore = triggerScore self.direction = direction self.isButtonPress = isButtonPress self.fromMute = fromMute self.willOpenStream = willOpenStream @classmethod def unpack(cls, buffer): "Reads a new TriggerWordDetected from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('TriggerWordDetected.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new TriggerWordDetected from the given BinaryReader." _triggerScore = reader.read('I') _direction = reader.read('H') _isButtonPress = bool(reader.read('b')) _fromMute = bool(reader.read('b')) _willOpenStream = bool(reader.read('b')) return cls(_triggerScore, _direction, _isButtonPress, _fromMute, _willOpenStream) def pack(self): "Writes the current TriggerWordDetected, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current TriggerWordDetected to the given BinaryWriter." writer.write(self._triggerScore, 'I') writer.write(self._direction, 'H') writer.write(int(self._isButtonPress), 'b') writer.write(int(self._fromMute), 'b') writer.write(int(self._willOpenStream), 'b') def __eq__(self, other): if type(self) is type(other): return (self._triggerScore == other._triggerScore and self._direction == other._direction and self._isButtonPress == other._isButtonPress and self._fromMute == other._fromMute and self._willOpenStream == other._willOpenStream) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._triggerScore, 'I') + msgbuffers.size(self._direction, 'H') + msgbuffers.size(self._isButtonPress, 'b') + msgbuffers.size(self._fromMute, 'b') + msgbuffers.size(self._willOpenStream, 'b')) def __str__(self): return '{type}(triggerScore={triggerScore}, direction={direction}, isButtonPress={isButtonPress}, fromMute={fromMute}, willOpenStream={willOpenStream})'.format( type=type(self).__name__, triggerScore=self._triggerScore, direction=self._direction, isButtonPress=self._isButtonPress, fromMute=self._fromMute, willOpenStream=self._willOpenStream) def __repr__(self): return '{type}(triggerScore={triggerScore}, direction={direction}, isButtonPress={isButtonPress}, fromMute={fromMute}, willOpenStream={willOpenStream})'.format( type=type(self).__name__, triggerScore=repr(self._triggerScore), direction=repr(self._direction), isButtonPress=repr(self._isButtonPress), fromMute=repr(self._fromMute), willOpenStream=repr(self._willOpenStream)) Anki.Vector.RobotInterface.TriggerWordDetected = TriggerWordDetected del TriggerWordDetected class MicDirection(object): "Generated message-passing message." __slots__ = ( '_timestamp', # uint_32 '_direction', # uint_16 '_confidence', # int_16 '_selectedDirection', # uint_16 '_selectedConfidence', # int_16 '_confidenceList', # float_32[13] '_activeState', # int_32 '_latestPowerValue', # float_32 '_latestNoiseFloor', # float_32 ) @property def timestamp(self): "uint_32 timestamp struct property." return self._timestamp @timestamp.setter def timestamp(self, value): self._timestamp = msgbuffers.validate_integer( 'MicDirection.timestamp', value, 0, 4294967295) @property def direction(self): "uint_16 direction struct property." return self._direction @direction.setter def direction(self, value): self._direction = msgbuffers.validate_integer( 'MicDirection.direction', value, 0, 65535) @property def confidence(self): "int_16 confidence struct property." return self._confidence @confidence.setter def confidence(self, value): self._confidence = msgbuffers.validate_integer( 'MicDirection.confidence', value, -32768, 32767) @property def selectedDirection(self): "uint_16 selectedDirection struct property." return self._selectedDirection @selectedDirection.setter def selectedDirection(self, value): self._selectedDirection = msgbuffers.validate_integer( 'MicDirection.selectedDirection', value, 0, 65535) @property def selectedConfidence(self): "int_16 selectedConfidence struct property." return self._selectedConfidence @selectedConfidence.setter def selectedConfidence(self, value): self._selectedConfidence = msgbuffers.validate_integer( 'MicDirection.selectedConfidence', value, -32768, 32767) @property def confidenceList(self): "float_32[13] confidenceList struct property." return self._confidenceList @confidenceList.setter def confidenceList(self, value): self._confidenceList = msgbuffers.validate_farray( 'MicDirection.confidenceList', value, 13, lambda name, value_inner: msgbuffers.validate_float( name, value_inner, 'f')) @property def activeState(self): "int_32 activeState struct property." return self._activeState @activeState.setter def activeState(self, value): self._activeState = msgbuffers.validate_integer( 'MicDirection.activeState', value, -2147483648, 2147483647) @property def latestPowerValue(self): "float_32 latestPowerValue struct property." return self._latestPowerValue @latestPowerValue.setter def latestPowerValue(self, value): self._latestPowerValue = msgbuffers.validate_float( 'MicDirection.latestPowerValue', value, 'f') @property def latestNoiseFloor(self): "float_32 latestNoiseFloor struct property." return self._latestNoiseFloor @latestNoiseFloor.setter def latestNoiseFloor(self, value): self._latestNoiseFloor = msgbuffers.validate_float( 'MicDirection.latestNoiseFloor', value, 'f') def __init__(self, timestamp=0, direction=0, confidence=0, selectedDirection=0, selectedConfidence=0, confidenceList=(0.0,) * 13, activeState=0, latestPowerValue=0.0, latestNoiseFloor=0.0): self.timestamp = timestamp self.direction = direction self.confidence = confidence self.selectedDirection = selectedDirection self.selectedConfidence = selectedConfidence self.confidenceList = confidenceList self.activeState = activeState self.latestPowerValue = latestPowerValue self.latestNoiseFloor = latestNoiseFloor @classmethod def unpack(cls, buffer): "Reads a new MicDirection from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MicDirection.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MicDirection from the given BinaryReader." _timestamp = reader.read('I') _direction = reader.read('H') _confidence = reader.read('h') _selectedDirection = reader.read('H') _selectedConfidence = reader.read('h') _confidenceList = reader.read_farray('f', 13) _activeState = reader.read('i') _latestPowerValue = reader.read('f') _latestNoiseFloor = reader.read('f') return cls(_timestamp, _direction, _confidence, _selectedDirection, _selectedConfidence, _confidenceList, _activeState, _latestPowerValue, _latestNoiseFloor) def pack(self): "Writes the current MicDirection, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MicDirection to the given BinaryWriter." writer.write(self._timestamp, 'I') writer.write(self._direction, 'H') writer.write(self._confidence, 'h') writer.write(self._selectedDirection, 'H') writer.write(self._selectedConfidence, 'h') writer.write_farray(self._confidenceList, 'f', 13) writer.write(self._activeState, 'i') writer.write(self._latestPowerValue, 'f') writer.write(self._latestNoiseFloor, 'f') def __eq__(self, other): if type(self) is type(other): return (self._timestamp == other._timestamp and self._direction == other._direction and self._confidence == other._confidence and self._selectedDirection == other._selectedDirection and self._selectedConfidence == other._selectedConfidence and self._confidenceList == other._confidenceList and self._activeState == other._activeState and self._latestPowerValue == other._latestPowerValue and self._latestNoiseFloor == other._latestNoiseFloor) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._timestamp, 'I') + msgbuffers.size(self._direction, 'H') + msgbuffers.size(self._confidence, 'h') + msgbuffers.size(self._selectedDirection, 'H') + msgbuffers.size(self._selectedConfidence, 'h') + msgbuffers.size_farray(self._confidenceList, 'f', 13) + msgbuffers.size(self._activeState, 'i') + msgbuffers.size(self._latestPowerValue, 'f') + msgbuffers.size(self._latestNoiseFloor, 'f')) def __str__(self): return '{type}(timestamp={timestamp}, direction={direction}, confidence={confidence}, selectedDirection={selectedDirection}, selectedConfidence={selectedConfidence}, confidenceList={confidenceList}, activeState={activeState}, latestPowerValue={latestPowerValue}, latestNoiseFloor={latestNoiseFloor})'.format( type=type(self).__name__, timestamp=self._timestamp, direction=self._direction, confidence=self._confidence, selectedDirection=self._selectedDirection, selectedConfidence=self._selectedConfidence, confidenceList=msgbuffers.shorten_sequence(self._confidenceList), activeState=self._activeState, latestPowerValue=self._latestPowerValue, latestNoiseFloor=self._latestNoiseFloor) def __repr__(self): return '{type}(timestamp={timestamp}, direction={direction}, confidence={confidence}, selectedDirection={selectedDirection}, selectedConfidence={selectedConfidence}, confidenceList={confidenceList}, activeState={activeState}, latestPowerValue={latestPowerValue}, latestNoiseFloor={latestNoiseFloor})'.format( type=type(self).__name__, timestamp=repr(self._timestamp), direction=repr(self._direction), confidence=repr(self._confidence), selectedDirection=repr(self._selectedDirection), selectedConfidence=repr(self._selectedConfidence), confidenceList=repr(self._confidenceList), activeState=repr(self._activeState), latestPowerValue=repr(self._latestPowerValue), latestNoiseFloor=repr(self._latestNoiseFloor)) Anki.Vector.RobotInterface.MicDirection = MicDirection del MicDirection class MicDataState(object): "Generated message-passing message." __slots__ = ( '_rawBufferFullness', # float_32 ) @property def rawBufferFullness(self): "float_32 rawBufferFullness struct property." return self._rawBufferFullness @rawBufferFullness.setter def rawBufferFullness(self, value): self._rawBufferFullness = msgbuffers.validate_float( 'MicDataState.rawBufferFullness', value, 'f') def __init__(self, rawBufferFullness=0.0): self.rawBufferFullness = rawBufferFullness @classmethod def unpack(cls, buffer): "Reads a new MicDataState from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MicDataState.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MicDataState from the given BinaryReader." _rawBufferFullness = reader.read('f') return cls(_rawBufferFullness) def pack(self): "Writes the current MicDataState, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MicDataState to the given BinaryWriter." writer.write(self._rawBufferFullness, 'f') def __eq__(self, other): if type(self) is type(other): return self._rawBufferFullness == other._rawBufferFullness else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._rawBufferFullness, 'f')) def __str__(self): return '{type}(rawBufferFullness={rawBufferFullness})'.format( type=type(self).__name__, rawBufferFullness=self._rawBufferFullness) def __repr__(self): return '{type}(rawBufferFullness={rawBufferFullness})'.format( type=type(self).__name__, rawBufferFullness=repr(self._rawBufferFullness)) Anki.Vector.RobotInterface.MicDataState = MicDataState del MicDataState class FallingEvent(object): "Generated message-passing message." __slots__ = ( '_timestamp', # uint_32 '_duration_ms', # uint_32 ) @property def timestamp(self): "uint_32 timestamp struct property." return self._timestamp @timestamp.setter def timestamp(self, value): self._timestamp = msgbuffers.validate_integer( 'FallingEvent.timestamp', value, 0, 4294967295) @property def duration_ms(self): "uint_32 duration_ms struct property." return self._duration_ms @duration_ms.setter def duration_ms(self, value): self._duration_ms = msgbuffers.validate_integer( 'FallingEvent.duration_ms', value, 0, 4294967295) def __init__(self, timestamp=0, duration_ms=0): self.timestamp = timestamp self.duration_ms = duration_ms @classmethod def unpack(cls, buffer): "Reads a new FallingEvent from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('FallingEvent.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new FallingEvent from the given BinaryReader." _timestamp = reader.read('I') _duration_ms = reader.read('I') return cls(_timestamp, _duration_ms) def pack(self): "Writes the current FallingEvent, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current FallingEvent to the given BinaryWriter." writer.write(self._timestamp, 'I') writer.write(self._duration_ms, 'I') def __eq__(self, other): if type(self) is type(other): return (self._timestamp == other._timestamp and self._duration_ms == other._duration_ms) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._timestamp, 'I') + msgbuffers.size(self._duration_ms, 'I')) def __str__(self): return '{type}(timestamp={timestamp}, duration_ms={duration_ms})'.format( type=type(self).__name__, timestamp=self._timestamp, duration_ms=self._duration_ms) def __repr__(self): return '{type}(timestamp={timestamp}, duration_ms={duration_ms})'.format( type=type(self).__name__, timestamp=repr(self._timestamp), duration_ms=repr(self._duration_ms)) Anki.Vector.RobotInterface.FallingEvent = FallingEvent del FallingEvent class FallImpactEvent(object): "Generated message-passing message." __slots__ = () def __init__(self): pass @classmethod def unpack(cls, buffer): "Reads a new FallImpactEvent from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('FallImpactEvent.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new FallImpactEvent from the given BinaryReader." return cls() def pack(self): "Writes the current FallImpactEvent, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current FallImpactEvent to the given BinaryWriter." def __eq__(self, other): if type(self) is type(other): return True else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return 0 def __str__(self): return '{type}()'.format(type=type(self).__name__) def __repr__(self): return '{type}()'.format(type=type(self).__name__) Anki.Vector.RobotInterface.FallImpactEvent = FallImpactEvent del FallImpactEvent class RobotStopped(object): "Generated message-passing message." __slots__ = ( '_reason', # Anki.Vector.StopReason '_cliffDetectedFlags', # uint_8 '_whiteDetectedFlags', # uint_8 ) @property def reason(self): "Anki.Vector.StopReason reason struct property." return self._reason @reason.setter def reason(self, value): self._reason = msgbuffers.validate_integer( 'RobotStopped.reason', value, 0, 255) @property def cliffDetectedFlags(self): "uint_8 cliffDetectedFlags struct property." return self._cliffDetectedFlags @cliffDetectedFlags.setter def cliffDetectedFlags(self, value): self._cliffDetectedFlags = msgbuffers.validate_integer( 'RobotStopped.cliffDetectedFlags', value, 0, 255) @property def whiteDetectedFlags(self): "uint_8 whiteDetectedFlags struct property." return self._whiteDetectedFlags @whiteDetectedFlags.setter def whiteDetectedFlags(self, value): self._whiteDetectedFlags = msgbuffers.validate_integer( 'RobotStopped.whiteDetectedFlags', value, 0, 255) def __init__(self, reason=Anki.Vector.StopReason.CLIFF, cliffDetectedFlags=0, whiteDetectedFlags=0): self.reason = reason self.cliffDetectedFlags = cliffDetectedFlags self.whiteDetectedFlags = whiteDetectedFlags @classmethod def unpack(cls, buffer): "Reads a new RobotStopped from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('RobotStopped.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new RobotStopped from the given BinaryReader." _reason = reader.read('B') _cliffDetectedFlags = reader.read('B') _whiteDetectedFlags = reader.read('B') return cls(_reason, _cliffDetectedFlags, _whiteDetectedFlags) def pack(self): "Writes the current RobotStopped, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current RobotStopped to the given BinaryWriter." writer.write(self._reason, 'B') writer.write(self._cliffDetectedFlags, 'B') writer.write(self._whiteDetectedFlags, 'B') def __eq__(self, other): if type(self) is type(other): return (self._reason == other._reason and self._cliffDetectedFlags == other._cliffDetectedFlags and self._whiteDetectedFlags == other._whiteDetectedFlags) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._reason, 'B') + msgbuffers.size(self._cliffDetectedFlags, 'B') + msgbuffers.size(self._whiteDetectedFlags, 'B')) def __str__(self): return '{type}(reason={reason}, cliffDetectedFlags={cliffDetectedFlags}, whiteDetectedFlags={whiteDetectedFlags})'.format( type=type(self).__name__, reason=self._reason, cliffDetectedFlags=self._cliffDetectedFlags, whiteDetectedFlags=self._whiteDetectedFlags) def __repr__(self): return '{type}(reason={reason}, cliffDetectedFlags={cliffDetectedFlags}, whiteDetectedFlags={whiteDetectedFlags})'.format( type=type(self).__name__, reason=repr(self._reason), cliffDetectedFlags=repr(self._cliffDetectedFlags), whiteDetectedFlags=repr(self._whiteDetectedFlags)) Anki.Vector.RobotInterface.RobotStopped = RobotStopped del RobotStopped class PathFollowingEvent(object): "Generated message-passing message." __slots__ = ( '_pathID', # uint_16 '_eventType', # Anki.Vector.PathEventType ) @property def pathID(self): "uint_16 pathID struct property." return self._pathID @pathID.setter def pathID(self, value): self._pathID = msgbuffers.validate_integer( 'PathFollowingEvent.pathID', value, 0, 65535) @property def eventType(self): "Anki.Vector.PathEventType eventType struct property." return self._eventType @eventType.setter def eventType(self, value): self._eventType = msgbuffers.validate_integer( 'PathFollowingEvent.eventType', value, 0, 255) def __init__(self, pathID=0, eventType=Anki.Vector.PathEventType.PATH_STARTED): self.pathID = pathID self.eventType = eventType @classmethod def unpack(cls, buffer): "Reads a new PathFollowingEvent from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('PathFollowingEvent.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new PathFollowingEvent from the given BinaryReader." _pathID = reader.read('H') _eventType = reader.read('B') return cls(_pathID, _eventType) def pack(self): "Writes the current PathFollowingEvent, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current PathFollowingEvent to the given BinaryWriter." writer.write(self._pathID, 'H') writer.write(self._eventType, 'B') def __eq__(self, other): if type(self) is type(other): return (self._pathID == other._pathID and self._eventType == other._eventType) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._pathID, 'H') + msgbuffers.size(self._eventType, 'B')) def __str__(self): return '{type}(pathID={pathID}, eventType={eventType})'.format( type=type(self).__name__, pathID=self._pathID, eventType=self._eventType) def __repr__(self): return '{type}(pathID={pathID}, eventType={eventType})'.format( type=type(self).__name__, pathID=repr(self._pathID), eventType=repr(self._eventType)) Anki.Vector.RobotInterface.PathFollowingEvent = PathFollowingEvent del PathFollowingEvent class LiftLoad(object): "Generated message-passing message." __slots__ = ( '_hasLoad', # bool ) @property def hasLoad(self): "bool hasLoad struct property." return self._hasLoad @hasLoad.setter def hasLoad(self, value): self._hasLoad = msgbuffers.validate_bool( 'LiftLoad.hasLoad', value) def __init__(self, hasLoad=False): self.hasLoad = hasLoad @classmethod def unpack(cls, buffer): "Reads a new LiftLoad from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('LiftLoad.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new LiftLoad from the given BinaryReader." _hasLoad = bool(reader.read('b')) return cls(_hasLoad) def pack(self): "Writes the current LiftLoad, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current LiftLoad to the given BinaryWriter." writer.write(int(self._hasLoad), 'b') def __eq__(self, other): if type(self) is type(other): return self._hasLoad == other._hasLoad else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._hasLoad, 'b')) def __str__(self): return '{type}(hasLoad={hasLoad})'.format( type=type(self).__name__, hasLoad=self._hasLoad) def __repr__(self): return '{type}(hasLoad={hasLoad})'.format( type=type(self).__name__, hasLoad=repr(self._hasLoad)) Anki.Vector.RobotInterface.LiftLoad = LiftLoad del LiftLoad class MotorActionAck(object): "Generated message-passing message." __slots__ = ( '_actionID', # uint_8 ) @property def actionID(self): "uint_8 actionID struct property." return self._actionID @actionID.setter def actionID(self, value): self._actionID = msgbuffers.validate_integer( 'MotorActionAck.actionID', value, 0, 255) def __init__(self, actionID=0): self.actionID = actionID @classmethod def unpack(cls, buffer): "Reads a new MotorActionAck from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MotorActionAck.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MotorActionAck from the given BinaryReader." _actionID = reader.read('B') return cls(_actionID) def pack(self): "Writes the current MotorActionAck, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MotorActionAck to the given BinaryWriter." writer.write(self._actionID, 'B') def __eq__(self, other): if type(self) is type(other): return self._actionID == other._actionID else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._actionID, 'B')) def __str__(self): return '{type}(actionID={actionID})'.format( type=type(self).__name__, actionID=self._actionID) def __repr__(self): return '{type}(actionID={actionID})'.format( type=type(self).__name__, actionID=repr(self._actionID)) Anki.Vector.RobotInterface.MotorActionAck = MotorActionAck del MotorActionAck class MicData(object): "Generated message-passing message." __slots__ = ( '_data', # int_16[640] '_timestamp', # uint_32 '_robotStatusFlags', # uint_32 '_robotRotationAngle', # float_32 ) @property def data(self): "int_16[640] data struct property." return self._data @data.setter def data(self, value): self._data = msgbuffers.validate_farray( 'MicData.data', value, 640, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, -32768, 32767)) @property def timestamp(self): "uint_32 timestamp struct property." return self._timestamp @timestamp.setter def timestamp(self, value): self._timestamp = msgbuffers.validate_integer( 'MicData.timestamp', value, 0, 4294967295) @property def robotStatusFlags(self): "uint_32 robotStatusFlags struct property." return self._robotStatusFlags @robotStatusFlags.setter def robotStatusFlags(self, value): self._robotStatusFlags = msgbuffers.validate_integer( 'MicData.robotStatusFlags', value, 0, 4294967295) @property def robotRotationAngle(self): "float_32 robotRotationAngle struct property." return self._robotRotationAngle @robotRotationAngle.setter def robotRotationAngle(self, value): self._robotRotationAngle = msgbuffers.validate_float( 'MicData.robotRotationAngle', value, 'f') def __init__(self, data=(0,) * 640, timestamp=0, robotStatusFlags=0, robotRotationAngle=0.0): self.data = data self.timestamp = timestamp self.robotStatusFlags = robotStatusFlags self.robotRotationAngle = robotRotationAngle @classmethod def unpack(cls, buffer): "Reads a new MicData from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MicData.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MicData from the given BinaryReader." _data = reader.read_farray('h', 640) _timestamp = reader.read('I') _robotStatusFlags = reader.read('I') _robotRotationAngle = reader.read('f') return cls(_data, _timestamp, _robotStatusFlags, _robotRotationAngle) def pack(self): "Writes the current MicData, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MicData to the given BinaryWriter." writer.write_farray(self._data, 'h', 640) writer.write(self._timestamp, 'I') writer.write(self._robotStatusFlags, 'I') writer.write(self._robotRotationAngle, 'f') def __eq__(self, other): if type(self) is type(other): return (self._data == other._data and self._timestamp == other._timestamp and self._robotStatusFlags == other._robotStatusFlags and self._robotRotationAngle == other._robotRotationAngle) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_farray(self._data, 'h', 640) + msgbuffers.size(self._timestamp, 'I') + msgbuffers.size(self._robotStatusFlags, 'I') + msgbuffers.size(self._robotRotationAngle, 'f')) def __str__(self): return '{type}(data={data}, timestamp={timestamp}, robotStatusFlags={robotStatusFlags}, robotRotationAngle={robotRotationAngle})'.format( type=type(self).__name__, data=msgbuffers.shorten_sequence(self._data), timestamp=self._timestamp, robotStatusFlags=self._robotStatusFlags, robotRotationAngle=self._robotRotationAngle) def __repr__(self): return '{type}(data={data}, timestamp={timestamp}, robotStatusFlags={robotStatusFlags}, robotRotationAngle={robotRotationAngle})'.format( type=type(self).__name__, data=repr(self._data), timestamp=repr(self._timestamp), robotStatusFlags=repr(self._robotStatusFlags), robotRotationAngle=repr(self._robotRotationAngle)) Anki.Vector.RobotInterface.MicData = MicData del MicData class AudioPlaybackBegin(object): "Generated message-passing message." __slots__ = ( '_path', # string[uint_8] ) @property def path(self): "string[uint_8] path struct property." return self._path @path.setter def path(self, value): self._path = msgbuffers.validate_string( 'AudioPlaybackBegin.path', value, 255) def __init__(self, path=''): self.path = path @classmethod def unpack(cls, buffer): "Reads a new AudioPlaybackBegin from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AudioPlaybackBegin.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AudioPlaybackBegin from the given BinaryReader." _path = reader.read_string('B') return cls(_path) def pack(self): "Writes the current AudioPlaybackBegin, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AudioPlaybackBegin to the given BinaryWriter." writer.write_string(self._path, 'B') def __eq__(self, other): if type(self) is type(other): return self._path == other._path else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string(self._path, 'B')) def __str__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=msgbuffers.shorten_string(self._path)) def __repr__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=repr(self._path)) Anki.Vector.RobotInterface.AudioPlaybackBegin = AudioPlaybackBegin del AudioPlaybackBegin class AudioPlaybackEnd(object): "Generated message-passing message." __slots__ = ( '_path', # string[uint_8] ) @property def path(self): "string[uint_8] path struct property." return self._path @path.setter def path(self, value): self._path = msgbuffers.validate_string( 'AudioPlaybackEnd.path', value, 255) def __init__(self, path=''): self.path = path @classmethod def unpack(cls, buffer): "Reads a new AudioPlaybackEnd from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AudioPlaybackEnd.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AudioPlaybackEnd from the given BinaryReader." _path = reader.read_string('B') return cls(_path) def pack(self): "Writes the current AudioPlaybackEnd, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AudioPlaybackEnd to the given BinaryWriter." writer.write_string(self._path, 'B') def __eq__(self, other): if type(self) is type(other): return self._path == other._path else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string(self._path, 'B')) def __str__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=msgbuffers.shorten_string(self._path)) def __repr__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=repr(self._path)) Anki.Vector.RobotInterface.AudioPlaybackEnd = AudioPlaybackEnd del AudioPlaybackEnd class MicRecordingComplete(object): "Generated message-passing message." __slots__ = ( '_path', # string[uint_8] ) @property def path(self): "string[uint_8] path struct property." return self._path @path.setter def path(self, value): self._path = msgbuffers.validate_string( 'MicRecordingComplete.path', value, 255) def __init__(self, path=''): self.path = path @classmethod def unpack(cls, buffer): "Reads a new MicRecordingComplete from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('MicRecordingComplete.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new MicRecordingComplete from the given BinaryReader." _path = reader.read_string('B') return cls(_path) def pack(self): "Writes the current MicRecordingComplete, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current MicRecordingComplete to the given BinaryWriter." writer.write_string(self._path, 'B') def __eq__(self, other): if type(self) is type(other): return self._path == other._path else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_string(self._path, 'B')) def __str__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=msgbuffers.shorten_string(self._path)) def __repr__(self): return '{type}(path={path})'.format( type=type(self).__name__, path=repr(self._path)) Anki.Vector.RobotInterface.MicRecordingComplete = MicRecordingComplete del MicRecordingComplete class AudioFFTResult(object): "Generated message-passing message." __slots__ = ( '_result', # uint_32[4] ) @property def result(self): "uint_32[4] result struct property." return self._result @result.setter def result(self, value): self._result = msgbuffers.validate_farray( 'AudioFFTResult.result', value, 4, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, 0, 4294967295)) def __init__(self, result=(0,) * 4): self.result = result @classmethod def unpack(cls, buffer): "Reads a new AudioFFTResult from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('AudioFFTResult.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new AudioFFTResult from the given BinaryReader." _result = reader.read_farray('I', 4) return cls(_result) def pack(self): "Writes the current AudioFFTResult, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current AudioFFTResult to the given BinaryWriter." writer.write_farray(self._result, 'I', 4) def __eq__(self, other): if type(self) is type(other): return self._result == other._result else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_farray(self._result, 'I', 4)) def __str__(self): return '{type}(result={result})'.format( type=type(self).__name__, result=msgbuffers.shorten_sequence(self._result)) def __repr__(self): return '{type}(result={result})'.format( type=type(self).__name__, result=repr(self._result)) Anki.Vector.RobotInterface.AudioFFTResult = AudioFFTResult del AudioFFTResult class DisplayedFaceImageRGBChunk(object): "Generated message-passing message." __slots__ = ( '_faceData', # uint_16[600] '_numPixels', # uint_16 '_imageId', # uint_8 '_chunkIndex', # uint_8 ) @property def faceData(self): "uint_16[600] faceData struct property." return self._faceData @faceData.setter def faceData(self, value): self._faceData = msgbuffers.validate_farray( 'DisplayedFaceImageRGBChunk.faceData', value, 600, lambda name, value_inner: msgbuffers.validate_integer( name, value_inner, 0, 65535)) @property def numPixels(self): "uint_16 numPixels struct property." return self._numPixels @numPixels.setter def numPixels(self, value): self._numPixels = msgbuffers.validate_integer( 'DisplayedFaceImageRGBChunk.numPixels', value, 0, 65535) @property def imageId(self): "uint_8 imageId struct property." return self._imageId @imageId.setter def imageId(self, value): self._imageId = msgbuffers.validate_integer( 'DisplayedFaceImageRGBChunk.imageId', value, 0, 255) @property def chunkIndex(self): "uint_8 chunkIndex struct property." return self._chunkIndex @chunkIndex.setter def chunkIndex(self, value): self._chunkIndex = msgbuffers.validate_integer( 'DisplayedFaceImageRGBChunk.chunkIndex', value, 0, 255) def __init__(self, faceData=(0,) * 600, numPixels=0, imageId=0, chunkIndex=0): self.faceData = faceData self.numPixels = numPixels self.imageId = imageId self.chunkIndex = chunkIndex @classmethod def unpack(cls, buffer): "Reads a new DisplayedFaceImageRGBChunk from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('DisplayedFaceImageRGBChunk.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new DisplayedFaceImageRGBChunk from the given BinaryReader." _faceData = reader.read_farray('H', 600) _numPixels = reader.read('H') _imageId = reader.read('B') _chunkIndex = reader.read('B') return cls(_faceData, _numPixels, _imageId, _chunkIndex) def pack(self): "Writes the current DisplayedFaceImageRGBChunk, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current DisplayedFaceImageRGBChunk to the given BinaryWriter." writer.write_farray(self._faceData, 'H', 600) writer.write(self._numPixels, 'H') writer.write(self._imageId, 'B') writer.write(self._chunkIndex, 'B') def __eq__(self, other): if type(self) is type(other): return (self._faceData == other._faceData and self._numPixels == other._numPixels and self._imageId == other._imageId and self._chunkIndex == other._chunkIndex) else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_farray(self._faceData, 'H', 600) + msgbuffers.size(self._numPixels, 'H') + msgbuffers.size(self._imageId, 'B') + msgbuffers.size(self._chunkIndex, 'B')) def __str__(self): return '{type}(faceData={faceData}, numPixels={numPixels}, imageId={imageId}, chunkIndex={chunkIndex})'.format( type=type(self).__name__, faceData=msgbuffers.shorten_sequence(self._faceData), numPixels=self._numPixels, imageId=self._imageId, chunkIndex=self._chunkIndex) def __repr__(self): return '{type}(faceData={faceData}, numPixels={numPixels}, imageId={imageId}, chunkIndex={chunkIndex})'.format( type=type(self).__name__, faceData=repr(self._faceData), numPixels=repr(self._numPixels), imageId=repr(self._imageId), chunkIndex=repr(self._chunkIndex)) Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk = DisplayedFaceImageRGBChunk del DisplayedFaceImageRGBChunk class BeatDetectorState(object): "Generated message-passing message." __slots__ = ( '_latestBeat', # Anki.Vector.BeatInfo ) @property def latestBeat(self): "Anki.Vector.BeatInfo latestBeat struct property." return self._latestBeat @latestBeat.setter def latestBeat(self, value): self._latestBeat = msgbuffers.validate_object( 'BeatDetectorState.latestBeat', value, Anki.Vector.BeatInfo) def __init__(self, latestBeat=Anki.Vector.BeatInfo()): self.latestBeat = latestBeat @classmethod def unpack(cls, buffer): "Reads a new BeatDetectorState from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('BeatDetectorState.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new BeatDetectorState from the given BinaryReader." _latestBeat = reader.read_object(Anki.Vector.BeatInfo.unpack_from) return cls(_latestBeat) def pack(self): "Writes the current BeatDetectorState, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current BeatDetectorState to the given BinaryWriter." writer.write_object(self._latestBeat) def __eq__(self, other): if type(self) is type(other): return self._latestBeat == other._latestBeat else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size_object(self._latestBeat)) def __str__(self): return '{type}(latestBeat={latestBeat})'.format( type=type(self).__name__, latestBeat=self._latestBeat) def __repr__(self): return '{type}(latestBeat={latestBeat})'.format( type=type(self).__name__, latestBeat=repr(self._latestBeat)) Anki.Vector.RobotInterface.BeatDetectorState = BeatDetectorState del BeatDetectorState class StartSelfTest(object): "Generated message-passing message." __slots__ = () def __init__(self): pass @classmethod def unpack(cls, buffer): "Reads a new StartSelfTest from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('StartSelfTest.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new StartSelfTest from the given BinaryReader." return cls() def pack(self): "Writes the current StartSelfTest, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current StartSelfTest to the given BinaryWriter." def __eq__(self, other): if type(self) is type(other): return True else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return 0 def __str__(self): return '{type}()'.format(type=type(self).__name__) def __repr__(self): return '{type}()'.format(type=type(self).__name__) Anki.Vector.RobotInterface.StartSelfTest = StartSelfTest del StartSelfTest class SendRangeData(object): "Generated message-passing message." __slots__ = ( '_enable', # bool ) @property def enable(self): "bool enable struct property." return self._enable @enable.setter def enable(self, value): self._enable = msgbuffers.validate_bool( 'SendRangeData.enable', value) def __init__(self, enable=False): self.enable = enable @classmethod def unpack(cls, buffer): "Reads a new SendRangeData from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('SendRangeData.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new SendRangeData from the given BinaryReader." _enable = bool(reader.read('b')) return cls(_enable) def pack(self): "Writes the current SendRangeData, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SendRangeData to the given BinaryWriter." writer.write(int(self._enable), 'b') def __eq__(self, other): if type(self) is type(other): return self._enable == other._enable else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): return (msgbuffers.size(self._enable, 'b')) def __str__(self): return '{type}(enable={enable})'.format( type=type(self).__name__, enable=self._enable) def __repr__(self): return '{type}(enable={enable})'.format( type=type(self).__name__, enable=repr(self._enable)) Anki.Vector.RobotInterface.SendRangeData = SendRangeData del SendRangeData class RobotToEngine(object): "Generated message-passing union." __slots__ = ('_tag', '_data') class Tag(object): "The type indicator for this union." syncRobotAck = 0xb0 # Anki.Vector.RobotInterface.SyncRobotAck prepForShutdown = 0xb1 # Anki.Vector.RobotInterface.PrepForShutdown motorActionAck = 0xb2 # Anki.Vector.RobotInterface.MotorActionAck motorCalibration = 0xb3 # Anki.Vector.MotorCalibration robotStopped = 0xb4 # Anki.Vector.RobotInterface.RobotStopped motorAutoEnabled = 0xb5 # Anki.Vector.MotorAutoEnabled pathFollowingEvent = 0xb6 # Anki.Vector.RobotInterface.PathFollowingEvent goalPose = 0xb7 # Anki.Vector.GoalPose dockingStatus = 0xb8 # Anki.Vector.DockingStatus movingLiftPostDock = 0xb9 # Anki.Vector.MovingLiftPostDock liftLoad = 0xba # Anki.Vector.RobotInterface.LiftLoad pickAndPlaceResult = 0xbb # Anki.Vector.PickAndPlaceResult chargerMountCompleted = 0xbc # Anki.Vector.ChargerMountComplete cliffAlignComplete = 0xbd # Anki.Vector.CliffAlignComplete fallImpactEvent = 0xc1 # Anki.Vector.RobotInterface.FallImpactEvent imuDataChunk = 0xc2 # Anki.Vector.RobotInterface.IMUDataChunk imuRawDataChunk = 0xc3 # Anki.Vector.RobotInterface.IMURawDataChunk imuTemperature = 0xc4 # Anki.Vector.RobotInterface.IMUTemperature cliffEvent = 0xc5 # Anki.Vector.CliffEvent potentialCliff = 0xc6 # Anki.Vector.PotentialCliff fallingEvent = 0xc7 # Anki.Vector.RobotInterface.FallingEvent robotPoked = 0xc8 # Anki.Vector.RobotInterface.RobotPoked runFactoryTest = 0xca # Anki.Vector.RobotInterface.RunFactoryTest startSelfTest = 0xcb # Anki.Vector.RobotInterface.StartSelfTest robotServerDisconnect = 0xcd # Anki.Vector.RobotInterface.RobotServerDisconnect stillAlive = 0xce # Anki.Vector.RobotInterface.StillAlive startShutdownAnim = 0xd0 # Anki.Vector.StartShutdownAnim reportCloudConnectivity = 0xd1 # Anki.Vector.ReportCloudConnectivity animAdded = 0xd3 # Anki.Vector.AnimationAdded robotAvailable = 0xd4 # Anki.Vector.RobotAvailable animEvent = 0xd5 # Anki.Vector.AnimationEvent animStarted = 0xd6 # Anki.Vector.AnimationStarted animEnded = 0xd7 # Anki.Vector.AnimationEnded audioFFTResult = 0xd8 # Anki.Vector.RobotInterface.AudioFFTResult triggerWordDetected = 0xd9 # Anki.Vector.RobotInterface.TriggerWordDetected micDirection = 0xda # Anki.Vector.RobotInterface.MicDirection textToSpeechEvent = 0xdb # Anki.Vector.TextToSpeechEvent enterPairing = 0xdc # Anki.Vector.SwitchboardInterface.EnterPairing exitPairing = 0xdd # Anki.Vector.SwitchboardInterface.ExitPairing streamCameraImages = 0xde # Anki.Vector.StreamCameraImages debugScreenMode = 0xdf # Anki.Vector.DebugScreenMode audioCallbackDuration = 0xe0 # Anki.AudioEngine.Multiplexer.AudioCallbackDuration audioCallbackMarker = 0xe1 # Anki.AudioEngine.Multiplexer.AudioCallbackMarker audioCallbackComplete = 0xe2 # Anki.AudioEngine.Multiplexer.AudioCallbackComplete audioCallbackError = 0xe3 # Anki.AudioEngine.Multiplexer.AudioCallbackError displayedFaceImageRGBChunk = 0xe4 # Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk beatDetectorState = 0xe5 # Anki.Vector.RobotInterface.BeatDetectorState audioPlaybackBegin = 0xe6 # Anki.Vector.RobotInterface.AudioPlaybackBegin audioPlaybackEnd = 0xe7 # Anki.Vector.RobotInterface.AudioPlaybackEnd micRecordingComplete = 0xe8 # Anki.Vector.RobotInterface.MicRecordingComplete micDataState = 0xe9 # Anki.Vector.RobotInterface.MicDataState sendRangeData = 0xea # Anki.Vector.RobotInterface.SendRangeData audioStreamStatusEvent = 0xeb # Anki.Vector.AudioStreamStatusEvent alexaAuthChanged = 0xec # Anki.Vector.RobotInterface.AlexaAuthChanged alexaUXChanged = 0xed # Anki.Vector.RobotInterface.AlexaUXChanged state = 0xf0 # Anki.Vector.RobotState micData = 0xf2 # Anki.Vector.RobotInterface.MicData animState = 0xf3 # Anki.Vector.AnimationState @property def tag(self): "The current tag for this union." return self._tag @property def tag_name(self): "The name of the current tag for this union." if self._tag in self._tags_by_value: return self._tags_by_value[self._tag] else: return None @property def data(self): "The data held by this union. None if no data is set." return self._data @property def syncRobotAck(self): "Anki.Vector.RobotInterface.SyncRobotAck syncRobotAck union property." msgbuffers.safety_check_tag('syncRobotAck', self._tag, self.Tag.syncRobotAck, self._tags_by_value) return self._data @syncRobotAck.setter def syncRobotAck(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.syncRobotAck', value, Anki.Vector.RobotInterface.SyncRobotAck) self._tag = self.Tag.syncRobotAck @property def prepForShutdown(self): "Anki.Vector.RobotInterface.PrepForShutdown prepForShutdown union property." msgbuffers.safety_check_tag('prepForShutdown', self._tag, self.Tag.prepForShutdown, self._tags_by_value) return self._data @prepForShutdown.setter def prepForShutdown(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.prepForShutdown', value, Anki.Vector.RobotInterface.PrepForShutdown) self._tag = self.Tag.prepForShutdown @property def motorActionAck(self): "Anki.Vector.RobotInterface.MotorActionAck motorActionAck union property." msgbuffers.safety_check_tag('motorActionAck', self._tag, self.Tag.motorActionAck, self._tags_by_value) return self._data @motorActionAck.setter def motorActionAck(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.motorActionAck', value, Anki.Vector.RobotInterface.MotorActionAck) self._tag = self.Tag.motorActionAck @property def motorCalibration(self): "Anki.Vector.MotorCalibration motorCalibration union property." msgbuffers.safety_check_tag('motorCalibration', self._tag, self.Tag.motorCalibration, self._tags_by_value) return self._data @motorCalibration.setter def motorCalibration(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.motorCalibration', value, Anki.Vector.MotorCalibration) self._tag = self.Tag.motorCalibration @property def robotStopped(self): "Anki.Vector.RobotInterface.RobotStopped robotStopped union property." msgbuffers.safety_check_tag('robotStopped', self._tag, self.Tag.robotStopped, self._tags_by_value) return self._data @robotStopped.setter def robotStopped(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.robotStopped', value, Anki.Vector.RobotInterface.RobotStopped) self._tag = self.Tag.robotStopped @property def motorAutoEnabled(self): "Anki.Vector.MotorAutoEnabled motorAutoEnabled union property." msgbuffers.safety_check_tag('motorAutoEnabled', self._tag, self.Tag.motorAutoEnabled, self._tags_by_value) return self._data @motorAutoEnabled.setter def motorAutoEnabled(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.motorAutoEnabled', value, Anki.Vector.MotorAutoEnabled) self._tag = self.Tag.motorAutoEnabled @property def pathFollowingEvent(self): "Anki.Vector.RobotInterface.PathFollowingEvent pathFollowingEvent union property." msgbuffers.safety_check_tag('pathFollowingEvent', self._tag, self.Tag.pathFollowingEvent, self._tags_by_value) return self._data @pathFollowingEvent.setter def pathFollowingEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.pathFollowingEvent', value, Anki.Vector.RobotInterface.PathFollowingEvent) self._tag = self.Tag.pathFollowingEvent @property def goalPose(self): "Anki.Vector.GoalPose goalPose union property." msgbuffers.safety_check_tag('goalPose', self._tag, self.Tag.goalPose, self._tags_by_value) return self._data @goalPose.setter def goalPose(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.goalPose', value, Anki.Vector.GoalPose) self._tag = self.Tag.goalPose @property def dockingStatus(self): "Anki.Vector.DockingStatus dockingStatus union property." msgbuffers.safety_check_tag('dockingStatus', self._tag, self.Tag.dockingStatus, self._tags_by_value) return self._data @dockingStatus.setter def dockingStatus(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.dockingStatus', value, Anki.Vector.DockingStatus) self._tag = self.Tag.dockingStatus @property def movingLiftPostDock(self): "Anki.Vector.MovingLiftPostDock movingLiftPostDock union property." msgbuffers.safety_check_tag('movingLiftPostDock', self._tag, self.Tag.movingLiftPostDock, self._tags_by_value) return self._data @movingLiftPostDock.setter def movingLiftPostDock(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.movingLiftPostDock', value, Anki.Vector.MovingLiftPostDock) self._tag = self.Tag.movingLiftPostDock @property def liftLoad(self): "Anki.Vector.RobotInterface.LiftLoad liftLoad union property." msgbuffers.safety_check_tag('liftLoad', self._tag, self.Tag.liftLoad, self._tags_by_value) return self._data @liftLoad.setter def liftLoad(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.liftLoad', value, Anki.Vector.RobotInterface.LiftLoad) self._tag = self.Tag.liftLoad @property def pickAndPlaceResult(self): "Anki.Vector.PickAndPlaceResult pickAndPlaceResult union property." msgbuffers.safety_check_tag('pickAndPlaceResult', self._tag, self.Tag.pickAndPlaceResult, self._tags_by_value) return self._data @pickAndPlaceResult.setter def pickAndPlaceResult(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.pickAndPlaceResult', value, Anki.Vector.PickAndPlaceResult) self._tag = self.Tag.pickAndPlaceResult @property def chargerMountCompleted(self): "Anki.Vector.ChargerMountComplete chargerMountCompleted union property." msgbuffers.safety_check_tag('chargerMountCompleted', self._tag, self.Tag.chargerMountCompleted, self._tags_by_value) return self._data @chargerMountCompleted.setter def chargerMountCompleted(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.chargerMountCompleted', value, Anki.Vector.ChargerMountComplete) self._tag = self.Tag.chargerMountCompleted @property def cliffAlignComplete(self): "Anki.Vector.CliffAlignComplete cliffAlignComplete union property." msgbuffers.safety_check_tag('cliffAlignComplete', self._tag, self.Tag.cliffAlignComplete, self._tags_by_value) return self._data @cliffAlignComplete.setter def cliffAlignComplete(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.cliffAlignComplete', value, Anki.Vector.CliffAlignComplete) self._tag = self.Tag.cliffAlignComplete @property def fallImpactEvent(self): "Anki.Vector.RobotInterface.FallImpactEvent fallImpactEvent union property." msgbuffers.safety_check_tag('fallImpactEvent', self._tag, self.Tag.fallImpactEvent, self._tags_by_value) return self._data @fallImpactEvent.setter def fallImpactEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.fallImpactEvent', value, Anki.Vector.RobotInterface.FallImpactEvent) self._tag = self.Tag.fallImpactEvent @property def imuDataChunk(self): "Anki.Vector.RobotInterface.IMUDataChunk imuDataChunk union property." msgbuffers.safety_check_tag('imuDataChunk', self._tag, self.Tag.imuDataChunk, self._tags_by_value) return self._data @imuDataChunk.setter def imuDataChunk(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.imuDataChunk', value, Anki.Vector.RobotInterface.IMUDataChunk) self._tag = self.Tag.imuDataChunk @property def imuRawDataChunk(self): "Anki.Vector.RobotInterface.IMURawDataChunk imuRawDataChunk union property." msgbuffers.safety_check_tag('imuRawDataChunk', self._tag, self.Tag.imuRawDataChunk, self._tags_by_value) return self._data @imuRawDataChunk.setter def imuRawDataChunk(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.imuRawDataChunk', value, Anki.Vector.RobotInterface.IMURawDataChunk) self._tag = self.Tag.imuRawDataChunk @property def imuTemperature(self): "Anki.Vector.RobotInterface.IMUTemperature imuTemperature union property." msgbuffers.safety_check_tag('imuTemperature', self._tag, self.Tag.imuTemperature, self._tags_by_value) return self._data @imuTemperature.setter def imuTemperature(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.imuTemperature', value, Anki.Vector.RobotInterface.IMUTemperature) self._tag = self.Tag.imuTemperature @property def cliffEvent(self): "Anki.Vector.CliffEvent cliffEvent union property." msgbuffers.safety_check_tag('cliffEvent', self._tag, self.Tag.cliffEvent, self._tags_by_value) return self._data @cliffEvent.setter def cliffEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.cliffEvent', value, Anki.Vector.CliffEvent) self._tag = self.Tag.cliffEvent @property def potentialCliff(self): "Anki.Vector.PotentialCliff potentialCliff union property." msgbuffers.safety_check_tag('potentialCliff', self._tag, self.Tag.potentialCliff, self._tags_by_value) return self._data @potentialCliff.setter def potentialCliff(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.potentialCliff', value, Anki.Vector.PotentialCliff) self._tag = self.Tag.potentialCliff @property def fallingEvent(self): "Anki.Vector.RobotInterface.FallingEvent fallingEvent union property." msgbuffers.safety_check_tag('fallingEvent', self._tag, self.Tag.fallingEvent, self._tags_by_value) return self._data @fallingEvent.setter def fallingEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.fallingEvent', value, Anki.Vector.RobotInterface.FallingEvent) self._tag = self.Tag.fallingEvent @property def robotPoked(self): "Anki.Vector.RobotInterface.RobotPoked robotPoked union property." msgbuffers.safety_check_tag('robotPoked', self._tag, self.Tag.robotPoked, self._tags_by_value) return self._data @robotPoked.setter def robotPoked(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.robotPoked', value, Anki.Vector.RobotInterface.RobotPoked) self._tag = self.Tag.robotPoked @property def runFactoryTest(self): "Anki.Vector.RobotInterface.RunFactoryTest runFactoryTest union property." msgbuffers.safety_check_tag('runFactoryTest', self._tag, self.Tag.runFactoryTest, self._tags_by_value) return self._data @runFactoryTest.setter def runFactoryTest(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.runFactoryTest', value, Anki.Vector.RobotInterface.RunFactoryTest) self._tag = self.Tag.runFactoryTest @property def startSelfTest(self): "Anki.Vector.RobotInterface.StartSelfTest startSelfTest union property." msgbuffers.safety_check_tag('startSelfTest', self._tag, self.Tag.startSelfTest, self._tags_by_value) return self._data @startSelfTest.setter def startSelfTest(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.startSelfTest', value, Anki.Vector.RobotInterface.StartSelfTest) self._tag = self.Tag.startSelfTest @property def robotServerDisconnect(self): "Anki.Vector.RobotInterface.RobotServerDisconnect robotServerDisconnect union property." msgbuffers.safety_check_tag('robotServerDisconnect', self._tag, self.Tag.robotServerDisconnect, self._tags_by_value) return self._data @robotServerDisconnect.setter def robotServerDisconnect(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.robotServerDisconnect', value, Anki.Vector.RobotInterface.RobotServerDisconnect) self._tag = self.Tag.robotServerDisconnect @property def stillAlive(self): "Anki.Vector.RobotInterface.StillAlive stillAlive union property." msgbuffers.safety_check_tag('stillAlive', self._tag, self.Tag.stillAlive, self._tags_by_value) return self._data @stillAlive.setter def stillAlive(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.stillAlive', value, Anki.Vector.RobotInterface.StillAlive) self._tag = self.Tag.stillAlive @property def startShutdownAnim(self): "Anki.Vector.StartShutdownAnim startShutdownAnim union property." msgbuffers.safety_check_tag('startShutdownAnim', self._tag, self.Tag.startShutdownAnim, self._tags_by_value) return self._data @startShutdownAnim.setter def startShutdownAnim(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.startShutdownAnim', value, Anki.Vector.StartShutdownAnim) self._tag = self.Tag.startShutdownAnim @property def reportCloudConnectivity(self): "Anki.Vector.ReportCloudConnectivity reportCloudConnectivity union property." msgbuffers.safety_check_tag('reportCloudConnectivity', self._tag, self.Tag.reportCloudConnectivity, self._tags_by_value) return self._data @reportCloudConnectivity.setter def reportCloudConnectivity(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.reportCloudConnectivity', value, Anki.Vector.ReportCloudConnectivity) self._tag = self.Tag.reportCloudConnectivity @property def animAdded(self): "Anki.Vector.AnimationAdded animAdded union property." msgbuffers.safety_check_tag('animAdded', self._tag, self.Tag.animAdded, self._tags_by_value) return self._data @animAdded.setter def animAdded(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.animAdded', value, Anki.Vector.AnimationAdded) self._tag = self.Tag.animAdded @property def robotAvailable(self): "Anki.Vector.RobotAvailable robotAvailable union property." msgbuffers.safety_check_tag('robotAvailable', self._tag, self.Tag.robotAvailable, self._tags_by_value) return self._data @robotAvailable.setter def robotAvailable(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.robotAvailable', value, Anki.Vector.RobotAvailable) self._tag = self.Tag.robotAvailable @property def animEvent(self): "Anki.Vector.AnimationEvent animEvent union property." msgbuffers.safety_check_tag('animEvent', self._tag, self.Tag.animEvent, self._tags_by_value) return self._data @animEvent.setter def animEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.animEvent', value, Anki.Vector.AnimationEvent) self._tag = self.Tag.animEvent @property def animStarted(self): "Anki.Vector.AnimationStarted animStarted union property." msgbuffers.safety_check_tag('animStarted', self._tag, self.Tag.animStarted, self._tags_by_value) return self._data @animStarted.setter def animStarted(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.animStarted', value, Anki.Vector.AnimationStarted) self._tag = self.Tag.animStarted @property def animEnded(self): "Anki.Vector.AnimationEnded animEnded union property." msgbuffers.safety_check_tag('animEnded', self._tag, self.Tag.animEnded, self._tags_by_value) return self._data @animEnded.setter def animEnded(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.animEnded', value, Anki.Vector.AnimationEnded) self._tag = self.Tag.animEnded @property def audioFFTResult(self): "Anki.Vector.RobotInterface.AudioFFTResult audioFFTResult union property." msgbuffers.safety_check_tag('audioFFTResult', self._tag, self.Tag.audioFFTResult, self._tags_by_value) return self._data @audioFFTResult.setter def audioFFTResult(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioFFTResult', value, Anki.Vector.RobotInterface.AudioFFTResult) self._tag = self.Tag.audioFFTResult @property def triggerWordDetected(self): "Anki.Vector.RobotInterface.TriggerWordDetected triggerWordDetected union property." msgbuffers.safety_check_tag('triggerWordDetected', self._tag, self.Tag.triggerWordDetected, self._tags_by_value) return self._data @triggerWordDetected.setter def triggerWordDetected(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.triggerWordDetected', value, Anki.Vector.RobotInterface.TriggerWordDetected) self._tag = self.Tag.triggerWordDetected @property def micDirection(self): "Anki.Vector.RobotInterface.MicDirection micDirection union property." msgbuffers.safety_check_tag('micDirection', self._tag, self.Tag.micDirection, self._tags_by_value) return self._data @micDirection.setter def micDirection(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.micDirection', value, Anki.Vector.RobotInterface.MicDirection) self._tag = self.Tag.micDirection @property def textToSpeechEvent(self): "Anki.Vector.TextToSpeechEvent textToSpeechEvent union property." msgbuffers.safety_check_tag('textToSpeechEvent', self._tag, self.Tag.textToSpeechEvent, self._tags_by_value) return self._data @textToSpeechEvent.setter def textToSpeechEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.textToSpeechEvent', value, Anki.Vector.TextToSpeechEvent) self._tag = self.Tag.textToSpeechEvent @property def enterPairing(self): "Anki.Vector.SwitchboardInterface.EnterPairing enterPairing union property." msgbuffers.safety_check_tag('enterPairing', self._tag, self.Tag.enterPairing, self._tags_by_value) return self._data @enterPairing.setter def enterPairing(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.enterPairing', value, Anki.Vector.SwitchboardInterface.EnterPairing) self._tag = self.Tag.enterPairing @property def exitPairing(self): "Anki.Vector.SwitchboardInterface.ExitPairing exitPairing union property." msgbuffers.safety_check_tag('exitPairing', self._tag, self.Tag.exitPairing, self._tags_by_value) return self._data @exitPairing.setter def exitPairing(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.exitPairing', value, Anki.Vector.SwitchboardInterface.ExitPairing) self._tag = self.Tag.exitPairing @property def streamCameraImages(self): "Anki.Vector.StreamCameraImages streamCameraImages union property." msgbuffers.safety_check_tag('streamCameraImages', self._tag, self.Tag.streamCameraImages, self._tags_by_value) return self._data @streamCameraImages.setter def streamCameraImages(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.streamCameraImages', value, Anki.Vector.StreamCameraImages) self._tag = self.Tag.streamCameraImages @property def debugScreenMode(self): "Anki.Vector.DebugScreenMode debugScreenMode union property." msgbuffers.safety_check_tag('debugScreenMode', self._tag, self.Tag.debugScreenMode, self._tags_by_value) return self._data @debugScreenMode.setter def debugScreenMode(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.debugScreenMode', value, Anki.Vector.DebugScreenMode) self._tag = self.Tag.debugScreenMode @property def audioCallbackDuration(self): "Anki.AudioEngine.Multiplexer.AudioCallbackDuration audioCallbackDuration union property." msgbuffers.safety_check_tag('audioCallbackDuration', self._tag, self.Tag.audioCallbackDuration, self._tags_by_value) return self._data @audioCallbackDuration.setter def audioCallbackDuration(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioCallbackDuration', value, Anki.AudioEngine.Multiplexer.AudioCallbackDuration) self._tag = self.Tag.audioCallbackDuration @property def audioCallbackMarker(self): "Anki.AudioEngine.Multiplexer.AudioCallbackMarker audioCallbackMarker union property." msgbuffers.safety_check_tag('audioCallbackMarker', self._tag, self.Tag.audioCallbackMarker, self._tags_by_value) return self._data @audioCallbackMarker.setter def audioCallbackMarker(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioCallbackMarker', value, Anki.AudioEngine.Multiplexer.AudioCallbackMarker) self._tag = self.Tag.audioCallbackMarker @property def audioCallbackComplete(self): "Anki.AudioEngine.Multiplexer.AudioCallbackComplete audioCallbackComplete union property." msgbuffers.safety_check_tag('audioCallbackComplete', self._tag, self.Tag.audioCallbackComplete, self._tags_by_value) return self._data @audioCallbackComplete.setter def audioCallbackComplete(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioCallbackComplete', value, Anki.AudioEngine.Multiplexer.AudioCallbackComplete) self._tag = self.Tag.audioCallbackComplete @property def audioCallbackError(self): "Anki.AudioEngine.Multiplexer.AudioCallbackError audioCallbackError union property." msgbuffers.safety_check_tag('audioCallbackError', self._tag, self.Tag.audioCallbackError, self._tags_by_value) return self._data @audioCallbackError.setter def audioCallbackError(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioCallbackError', value, Anki.AudioEngine.Multiplexer.AudioCallbackError) self._tag = self.Tag.audioCallbackError @property def displayedFaceImageRGBChunk(self): "Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk displayedFaceImageRGBChunk union property." msgbuffers.safety_check_tag('displayedFaceImageRGBChunk', self._tag, self.Tag.displayedFaceImageRGBChunk, self._tags_by_value) return self._data @displayedFaceImageRGBChunk.setter def displayedFaceImageRGBChunk(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.displayedFaceImageRGBChunk', value, Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk) self._tag = self.Tag.displayedFaceImageRGBChunk @property def beatDetectorState(self): "Anki.Vector.RobotInterface.BeatDetectorState beatDetectorState union property." msgbuffers.safety_check_tag('beatDetectorState', self._tag, self.Tag.beatDetectorState, self._tags_by_value) return self._data @beatDetectorState.setter def beatDetectorState(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.beatDetectorState', value, Anki.Vector.RobotInterface.BeatDetectorState) self._tag = self.Tag.beatDetectorState @property def audioPlaybackBegin(self): "Anki.Vector.RobotInterface.AudioPlaybackBegin audioPlaybackBegin union property." msgbuffers.safety_check_tag('audioPlaybackBegin', self._tag, self.Tag.audioPlaybackBegin, self._tags_by_value) return self._data @audioPlaybackBegin.setter def audioPlaybackBegin(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioPlaybackBegin', value, Anki.Vector.RobotInterface.AudioPlaybackBegin) self._tag = self.Tag.audioPlaybackBegin @property def audioPlaybackEnd(self): "Anki.Vector.RobotInterface.AudioPlaybackEnd audioPlaybackEnd union property." msgbuffers.safety_check_tag('audioPlaybackEnd', self._tag, self.Tag.audioPlaybackEnd, self._tags_by_value) return self._data @audioPlaybackEnd.setter def audioPlaybackEnd(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioPlaybackEnd', value, Anki.Vector.RobotInterface.AudioPlaybackEnd) self._tag = self.Tag.audioPlaybackEnd @property def micRecordingComplete(self): "Anki.Vector.RobotInterface.MicRecordingComplete micRecordingComplete union property." msgbuffers.safety_check_tag('micRecordingComplete', self._tag, self.Tag.micRecordingComplete, self._tags_by_value) return self._data @micRecordingComplete.setter def micRecordingComplete(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.micRecordingComplete', value, Anki.Vector.RobotInterface.MicRecordingComplete) self._tag = self.Tag.micRecordingComplete @property def micDataState(self): "Anki.Vector.RobotInterface.MicDataState micDataState union property." msgbuffers.safety_check_tag('micDataState', self._tag, self.Tag.micDataState, self._tags_by_value) return self._data @micDataState.setter def micDataState(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.micDataState', value, Anki.Vector.RobotInterface.MicDataState) self._tag = self.Tag.micDataState @property def sendRangeData(self): "Anki.Vector.RobotInterface.SendRangeData sendRangeData union property." msgbuffers.safety_check_tag('sendRangeData', self._tag, self.Tag.sendRangeData, self._tags_by_value) return self._data @sendRangeData.setter def sendRangeData(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.sendRangeData', value, Anki.Vector.RobotInterface.SendRangeData) self._tag = self.Tag.sendRangeData @property def audioStreamStatusEvent(self): "Anki.Vector.AudioStreamStatusEvent audioStreamStatusEvent union property." msgbuffers.safety_check_tag('audioStreamStatusEvent', self._tag, self.Tag.audioStreamStatusEvent, self._tags_by_value) return self._data @audioStreamStatusEvent.setter def audioStreamStatusEvent(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.audioStreamStatusEvent', value, Anki.Vector.AudioStreamStatusEvent) self._tag = self.Tag.audioStreamStatusEvent @property def alexaAuthChanged(self): "Anki.Vector.RobotInterface.AlexaAuthChanged alexaAuthChanged union property." msgbuffers.safety_check_tag('alexaAuthChanged', self._tag, self.Tag.alexaAuthChanged, self._tags_by_value) return self._data @alexaAuthChanged.setter def alexaAuthChanged(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.alexaAuthChanged', value, Anki.Vector.RobotInterface.AlexaAuthChanged) self._tag = self.Tag.alexaAuthChanged @property def alexaUXChanged(self): "Anki.Vector.RobotInterface.AlexaUXChanged alexaUXChanged union property." msgbuffers.safety_check_tag('alexaUXChanged', self._tag, self.Tag.alexaUXChanged, self._tags_by_value) return self._data @alexaUXChanged.setter def alexaUXChanged(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.alexaUXChanged', value, Anki.Vector.RobotInterface.AlexaUXChanged) self._tag = self.Tag.alexaUXChanged @property def state(self): "Anki.Vector.RobotState state union property." msgbuffers.safety_check_tag('state', self._tag, self.Tag.state, self._tags_by_value) return self._data @state.setter def state(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.state', value, Anki.Vector.RobotState) self._tag = self.Tag.state @property def micData(self): "Anki.Vector.RobotInterface.MicData micData union property." msgbuffers.safety_check_tag('micData', self._tag, self.Tag.micData, self._tags_by_value) return self._data @micData.setter def micData(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.micData', value, Anki.Vector.RobotInterface.MicData) self._tag = self.Tag.micData @property def animState(self): "Anki.Vector.AnimationState animState union property." msgbuffers.safety_check_tag('animState', self._tag, self.Tag.animState, self._tags_by_value) return self._data @animState.setter def animState(self, value): self._data = msgbuffers.validate_object( 'RobotToEngine.animState', value, Anki.Vector.AnimationState) self._tag = self.Tag.animState def __init__(self, **kwargs): if not kwargs: self._tag = None self._data = None elif len(kwargs) == 1: key, value = next(iter(kwargs.items())) if key not in self._tags_by_name: raise TypeError("'{argument}' is an invalid keyword argument for this method.".format(argument=key)) # calls the correct property setattr(self, key, value) else: raise TypeError('This method only accepts up to one keyword argument.') @classmethod def unpack(cls, buffer): "Reads a new RobotToEngine from the given buffer." reader = msgbuffers.BinaryReader(buffer) value = cls.unpack_from(reader) if reader.tell() != len(reader): raise msgbuffers.ReadError( ('RobotToEngine.unpack received a buffer of length {length}, ' + 'but only {position} bytes were read.').format( length=len(reader), position=reader.tell())) return value @classmethod def unpack_from(cls, reader): "Reads a new RobotToEngine from the given BinaryReader." tag = reader.read('B') if tag in cls._tags_by_value: value = cls() setattr(value, cls._tags_by_value[tag], cls._tag_unpack_methods[tag](reader)) return value else: raise ValueError('RobotToEngine attempted to unpack unknown tag {tag}.'.format(tag=tag)) def pack(self): "Writes the current RobotToEngine, returning bytes." writer = msgbuffers.BinaryWriter() self.pack_to(writer) return writer.dumps() def pack_to(self, writer): "Writes the current SampleUnion to the given BinaryWriter." if self._tag in self._tags_by_value: writer.write(self._tag, 'B') self._tag_pack_methods[self._tag](writer, self._data) else: raise ValueError('Cannot pack an empty RobotToEngine.') def clear(self): self._tag = None self._data = None @classmethod def typeByTag(cls, tag): return cls._type_by_tag_value[tag]() def __eq__(self, other): if type(self) is type(other): return self._tag == other._tag and self._data == other._data else: return NotImplemented def __ne__(self, other): if type(self) is type(other): return not self.__eq__(other) else: return NotImplemented def __len__(self): if 0 <= self._tag < 58: return self._tag_size_methods[self._tag](self._data) else: return 1 def __str__(self): if 0 <= self._tag < 58: return '{type}({name}={value})'.format( type=type(self).__name__, name=self.tag_name, value=self._data) else: return '{type}()'.format( type=type(self).__name__) def __repr__(self): if 0 <= self._tag < 58: return '{type}({name}={value})'.format( type=type(self).__name__, name=self.tag_name, value=repr(self._data)) else: return '{type}()'.format( type=type(self).__name__) _tags_by_name = dict( syncRobotAck=176, prepForShutdown=177, motorActionAck=178, motorCalibration=179, robotStopped=180, motorAutoEnabled=181, pathFollowingEvent=182, goalPose=183, dockingStatus=184, movingLiftPostDock=185, liftLoad=186, pickAndPlaceResult=187, chargerMountCompleted=188, cliffAlignComplete=189, fallImpactEvent=193, imuDataChunk=194, imuRawDataChunk=195, imuTemperature=196, cliffEvent=197, potentialCliff=198, fallingEvent=199, robotPoked=200, runFactoryTest=202, startSelfTest=203, robotServerDisconnect=205, stillAlive=206, startShutdownAnim=208, reportCloudConnectivity=209, animAdded=211, robotAvailable=212, animEvent=213, animStarted=214, animEnded=215, audioFFTResult=216, triggerWordDetected=217, micDirection=218, textToSpeechEvent=219, enterPairing=220, exitPairing=221, streamCameraImages=222, debugScreenMode=223, audioCallbackDuration=224, audioCallbackMarker=225, audioCallbackComplete=226, audioCallbackError=227, displayedFaceImageRGBChunk=228, beatDetectorState=229, audioPlaybackBegin=230, audioPlaybackEnd=231, micRecordingComplete=232, micDataState=233, sendRangeData=234, audioStreamStatusEvent=235, alexaAuthChanged=236, alexaUXChanged=237, state=240, micData=242, animState=243, ) _tags_by_value = dict() _tags_by_value[176] = 'syncRobotAck' _tags_by_value[177] = 'prepForShutdown' _tags_by_value[178] = 'motorActionAck' _tags_by_value[179] = 'motorCalibration' _tags_by_value[180] = 'robotStopped' _tags_by_value[181] = 'motorAutoEnabled' _tags_by_value[182] = 'pathFollowingEvent' _tags_by_value[183] = 'goalPose' _tags_by_value[184] = 'dockingStatus' _tags_by_value[185] = 'movingLiftPostDock' _tags_by_value[186] = 'liftLoad' _tags_by_value[187] = 'pickAndPlaceResult' _tags_by_value[188] = 'chargerMountCompleted' _tags_by_value[189] = 'cliffAlignComplete' _tags_by_value[193] = 'fallImpactEvent' _tags_by_value[194] = 'imuDataChunk' _tags_by_value[195] = 'imuRawDataChunk' _tags_by_value[196] = 'imuTemperature' _tags_by_value[197] = 'cliffEvent' _tags_by_value[198] = 'potentialCliff' _tags_by_value[199] = 'fallingEvent' _tags_by_value[200] = 'robotPoked' _tags_by_value[202] = 'runFactoryTest' _tags_by_value[203] = 'startSelfTest' _tags_by_value[205] = 'robotServerDisconnect' _tags_by_value[206] = 'stillAlive' _tags_by_value[208] = 'startShutdownAnim' _tags_by_value[209] = 'reportCloudConnectivity' _tags_by_value[211] = 'animAdded' _tags_by_value[212] = 'robotAvailable' _tags_by_value[213] = 'animEvent' _tags_by_value[214] = 'animStarted' _tags_by_value[215] = 'animEnded' _tags_by_value[216] = 'audioFFTResult' _tags_by_value[217] = 'triggerWordDetected' _tags_by_value[218] = 'micDirection' _tags_by_value[219] = 'textToSpeechEvent' _tags_by_value[220] = 'enterPairing' _tags_by_value[221] = 'exitPairing' _tags_by_value[222] = 'streamCameraImages' _tags_by_value[223] = 'debugScreenMode' _tags_by_value[224] = 'audioCallbackDuration' _tags_by_value[225] = 'audioCallbackMarker' _tags_by_value[226] = 'audioCallbackComplete' _tags_by_value[227] = 'audioCallbackError' _tags_by_value[228] = 'displayedFaceImageRGBChunk' _tags_by_value[229] = 'beatDetectorState' _tags_by_value[230] = 'audioPlaybackBegin' _tags_by_value[231] = 'audioPlaybackEnd' _tags_by_value[232] = 'micRecordingComplete' _tags_by_value[233] = 'micDataState' _tags_by_value[234] = 'sendRangeData' _tags_by_value[235] = 'audioStreamStatusEvent' _tags_by_value[236] = 'alexaAuthChanged' _tags_by_value[237] = 'alexaUXChanged' _tags_by_value[240] = 'state' _tags_by_value[242] = 'micData' _tags_by_value[243] = 'animState' _tag_unpack_methods = dict() _tag_unpack_methods[176] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.SyncRobotAck.unpack_from) _tag_unpack_methods[177] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.PrepForShutdown.unpack_from) _tag_unpack_methods[178] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.MotorActionAck.unpack_from) _tag_unpack_methods[179] = lambda reader: reader.read_object(Anki.Vector.MotorCalibration.unpack_from) _tag_unpack_methods[180] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.RobotStopped.unpack_from) _tag_unpack_methods[181] = lambda reader: reader.read_object(Anki.Vector.MotorAutoEnabled.unpack_from) _tag_unpack_methods[182] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.PathFollowingEvent.unpack_from) _tag_unpack_methods[183] = lambda reader: reader.read_object(Anki.Vector.GoalPose.unpack_from) _tag_unpack_methods[184] = lambda reader: reader.read_object(Anki.Vector.DockingStatus.unpack_from) _tag_unpack_methods[185] = lambda reader: reader.read_object(Anki.Vector.MovingLiftPostDock.unpack_from) _tag_unpack_methods[186] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.LiftLoad.unpack_from) _tag_unpack_methods[187] = lambda reader: reader.read_object(Anki.Vector.PickAndPlaceResult.unpack_from) _tag_unpack_methods[188] = lambda reader: reader.read_object(Anki.Vector.ChargerMountComplete.unpack_from) _tag_unpack_methods[189] = lambda reader: reader.read_object(Anki.Vector.CliffAlignComplete.unpack_from) _tag_unpack_methods[193] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.FallImpactEvent.unpack_from) _tag_unpack_methods[194] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.IMUDataChunk.unpack_from) _tag_unpack_methods[195] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.IMURawDataChunk.unpack_from) _tag_unpack_methods[196] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.IMUTemperature.unpack_from) _tag_unpack_methods[197] = lambda reader: reader.read_object(Anki.Vector.CliffEvent.unpack_from) _tag_unpack_methods[198] = lambda reader: reader.read_object(Anki.Vector.PotentialCliff.unpack_from) _tag_unpack_methods[199] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.FallingEvent.unpack_from) _tag_unpack_methods[200] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.RobotPoked.unpack_from) _tag_unpack_methods[202] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.RunFactoryTest.unpack_from) _tag_unpack_methods[203] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.StartSelfTest.unpack_from) _tag_unpack_methods[205] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.RobotServerDisconnect.unpack_from) _tag_unpack_methods[206] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.StillAlive.unpack_from) _tag_unpack_methods[208] = lambda reader: reader.read_object(Anki.Vector.StartShutdownAnim.unpack_from) _tag_unpack_methods[209] = lambda reader: reader.read_object(Anki.Vector.ReportCloudConnectivity.unpack_from) _tag_unpack_methods[211] = lambda reader: reader.read_object(Anki.Vector.AnimationAdded.unpack_from) _tag_unpack_methods[212] = lambda reader: reader.read_object(Anki.Vector.RobotAvailable.unpack_from) _tag_unpack_methods[213] = lambda reader: reader.read_object(Anki.Vector.AnimationEvent.unpack_from) _tag_unpack_methods[214] = lambda reader: reader.read_object(Anki.Vector.AnimationStarted.unpack_from) _tag_unpack_methods[215] = lambda reader: reader.read_object(Anki.Vector.AnimationEnded.unpack_from) _tag_unpack_methods[216] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.AudioFFTResult.unpack_from) _tag_unpack_methods[217] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.TriggerWordDetected.unpack_from) _tag_unpack_methods[218] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.MicDirection.unpack_from) _tag_unpack_methods[219] = lambda reader: reader.read_object(Anki.Vector.TextToSpeechEvent.unpack_from) _tag_unpack_methods[220] = lambda reader: reader.read_object(Anki.Vector.SwitchboardInterface.EnterPairing.unpack_from) _tag_unpack_methods[221] = lambda reader: reader.read_object(Anki.Vector.SwitchboardInterface.ExitPairing.unpack_from) _tag_unpack_methods[222] = lambda reader: reader.read_object(Anki.Vector.StreamCameraImages.unpack_from) _tag_unpack_methods[223] = lambda reader: reader.read_object(Anki.Vector.DebugScreenMode.unpack_from) _tag_unpack_methods[224] = lambda reader: reader.read_object(Anki.AudioEngine.Multiplexer.AudioCallbackDuration.unpack_from) _tag_unpack_methods[225] = lambda reader: reader.read_object(Anki.AudioEngine.Multiplexer.AudioCallbackMarker.unpack_from) _tag_unpack_methods[226] = lambda reader: reader.read_object(Anki.AudioEngine.Multiplexer.AudioCallbackComplete.unpack_from) _tag_unpack_methods[227] = lambda reader: reader.read_object(Anki.AudioEngine.Multiplexer.AudioCallbackError.unpack_from) _tag_unpack_methods[228] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk.unpack_from) _tag_unpack_methods[229] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.BeatDetectorState.unpack_from) _tag_unpack_methods[230] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.AudioPlaybackBegin.unpack_from) _tag_unpack_methods[231] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.AudioPlaybackEnd.unpack_from) _tag_unpack_methods[232] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.MicRecordingComplete.unpack_from) _tag_unpack_methods[233] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.MicDataState.unpack_from) _tag_unpack_methods[234] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.SendRangeData.unpack_from) _tag_unpack_methods[235] = lambda reader: reader.read_object(Anki.Vector.AudioStreamStatusEvent.unpack_from) _tag_unpack_methods[236] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.AlexaAuthChanged.unpack_from) _tag_unpack_methods[237] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.AlexaUXChanged.unpack_from) _tag_unpack_methods[240] = lambda reader: reader.read_object(Anki.Vector.RobotState.unpack_from) _tag_unpack_methods[242] = lambda reader: reader.read_object(Anki.Vector.RobotInterface.MicData.unpack_from) _tag_unpack_methods[243] = lambda reader: reader.read_object(Anki.Vector.AnimationState.unpack_from) _tag_pack_methods = dict() _tag_pack_methods[176] = lambda writer, value: writer.write_object(value) _tag_pack_methods[177] = lambda writer, value: writer.write_object(value) _tag_pack_methods[178] = lambda writer, value: writer.write_object(value) _tag_pack_methods[179] = lambda writer, value: writer.write_object(value) _tag_pack_methods[180] = lambda writer, value: writer.write_object(value) _tag_pack_methods[181] = lambda writer, value: writer.write_object(value) _tag_pack_methods[182] = lambda writer, value: writer.write_object(value) _tag_pack_methods[183] = lambda writer, value: writer.write_object(value) _tag_pack_methods[184] = lambda writer, value: writer.write_object(value) _tag_pack_methods[185] = lambda writer, value: writer.write_object(value) _tag_pack_methods[186] = lambda writer, value: writer.write_object(value) _tag_pack_methods[187] = lambda writer, value: writer.write_object(value) _tag_pack_methods[188] = lambda writer, value: writer.write_object(value) _tag_pack_methods[189] = lambda writer, value: writer.write_object(value) _tag_pack_methods[193] = lambda writer, value: writer.write_object(value) _tag_pack_methods[194] = lambda writer, value: writer.write_object(value) _tag_pack_methods[195] = lambda writer, value: writer.write_object(value) _tag_pack_methods[196] = lambda writer, value: writer.write_object(value) _tag_pack_methods[197] = lambda writer, value: writer.write_object(value) _tag_pack_methods[198] = lambda writer, value: writer.write_object(value) _tag_pack_methods[199] = lambda writer, value: writer.write_object(value) _tag_pack_methods[200] = lambda writer, value: writer.write_object(value) _tag_pack_methods[202] = lambda writer, value: writer.write_object(value) _tag_pack_methods[203] = lambda writer, value: writer.write_object(value) _tag_pack_methods[205] = lambda writer, value: writer.write_object(value) _tag_pack_methods[206] = lambda writer, value: writer.write_object(value) _tag_pack_methods[208] = lambda writer, value: writer.write_object(value) _tag_pack_methods[209] = lambda writer, value: writer.write_object(value) _tag_pack_methods[211] = lambda writer, value: writer.write_object(value) _tag_pack_methods[212] = lambda writer, value: writer.write_object(value) _tag_pack_methods[213] = lambda writer, value: writer.write_object(value) _tag_pack_methods[214] = lambda writer, value: writer.write_object(value) _tag_pack_methods[215] = lambda writer, value: writer.write_object(value) _tag_pack_methods[216] = lambda writer, value: writer.write_object(value) _tag_pack_methods[217] = lambda writer, value: writer.write_object(value) _tag_pack_methods[218] = lambda writer, value: writer.write_object(value) _tag_pack_methods[219] = lambda writer, value: writer.write_object(value) _tag_pack_methods[220] = lambda writer, value: writer.write_object(value) _tag_pack_methods[221] = lambda writer, value: writer.write_object(value) _tag_pack_methods[222] = lambda writer, value: writer.write_object(value) _tag_pack_methods[223] = lambda writer, value: writer.write_object(value) _tag_pack_methods[224] = lambda writer, value: writer.write_object(value) _tag_pack_methods[225] = lambda writer, value: writer.write_object(value) _tag_pack_methods[226] = lambda writer, value: writer.write_object(value) _tag_pack_methods[227] = lambda writer, value: writer.write_object(value) _tag_pack_methods[228] = lambda writer, value: writer.write_object(value) _tag_pack_methods[229] = lambda writer, value: writer.write_object(value) _tag_pack_methods[230] = lambda writer, value: writer.write_object(value) _tag_pack_methods[231] = lambda writer, value: writer.write_object(value) _tag_pack_methods[232] = lambda writer, value: writer.write_object(value) _tag_pack_methods[233] = lambda writer, value: writer.write_object(value) _tag_pack_methods[234] = lambda writer, value: writer.write_object(value) _tag_pack_methods[235] = lambda writer, value: writer.write_object(value) _tag_pack_methods[236] = lambda writer, value: writer.write_object(value) _tag_pack_methods[237] = lambda writer, value: writer.write_object(value) _tag_pack_methods[240] = lambda writer, value: writer.write_object(value) _tag_pack_methods[242] = lambda writer, value: writer.write_object(value) _tag_pack_methods[243] = lambda writer, value: writer.write_object(value) _tag_size_methods = dict() _tag_size_methods[176] = lambda value: msgbuffers.size_object(value) _tag_size_methods[177] = lambda value: msgbuffers.size_object(value) _tag_size_methods[178] = lambda value: msgbuffers.size_object(value) _tag_size_methods[179] = lambda value: msgbuffers.size_object(value) _tag_size_methods[180] = lambda value: msgbuffers.size_object(value) _tag_size_methods[181] = lambda value: msgbuffers.size_object(value) _tag_size_methods[182] = lambda value: msgbuffers.size_object(value) _tag_size_methods[183] = lambda value: msgbuffers.size_object(value) _tag_size_methods[184] = lambda value: msgbuffers.size_object(value) _tag_size_methods[185] = lambda value: msgbuffers.size_object(value) _tag_size_methods[186] = lambda value: msgbuffers.size_object(value) _tag_size_methods[187] = lambda value: msgbuffers.size_object(value) _tag_size_methods[188] = lambda value: msgbuffers.size_object(value) _tag_size_methods[189] = lambda value: msgbuffers.size_object(value) _tag_size_methods[193] = lambda value: msgbuffers.size_object(value) _tag_size_methods[194] = lambda value: msgbuffers.size_object(value) _tag_size_methods[195] = lambda value: msgbuffers.size_object(value) _tag_size_methods[196] = lambda value: msgbuffers.size_object(value) _tag_size_methods[197] = lambda value: msgbuffers.size_object(value) _tag_size_methods[198] = lambda value: msgbuffers.size_object(value) _tag_size_methods[199] = lambda value: msgbuffers.size_object(value) _tag_size_methods[200] = lambda value: msgbuffers.size_object(value) _tag_size_methods[202] = lambda value: msgbuffers.size_object(value) _tag_size_methods[203] = lambda value: msgbuffers.size_object(value) _tag_size_methods[205] = lambda value: msgbuffers.size_object(value) _tag_size_methods[206] = lambda value: msgbuffers.size_object(value) _tag_size_methods[208] = lambda value: msgbuffers.size_object(value) _tag_size_methods[209] = lambda value: msgbuffers.size_object(value) _tag_size_methods[211] = lambda value: msgbuffers.size_object(value) _tag_size_methods[212] = lambda value: msgbuffers.size_object(value) _tag_size_methods[213] = lambda value: msgbuffers.size_object(value) _tag_size_methods[214] = lambda value: msgbuffers.size_object(value) _tag_size_methods[215] = lambda value: msgbuffers.size_object(value) _tag_size_methods[216] = lambda value: msgbuffers.size_object(value) _tag_size_methods[217] = lambda value: msgbuffers.size_object(value) _tag_size_methods[218] = lambda value: msgbuffers.size_object(value) _tag_size_methods[219] = lambda value: msgbuffers.size_object(value) _tag_size_methods[220] = lambda value: msgbuffers.size_object(value) _tag_size_methods[221] = lambda value: msgbuffers.size_object(value) _tag_size_methods[222] = lambda value: msgbuffers.size_object(value) _tag_size_methods[223] = lambda value: msgbuffers.size_object(value) _tag_size_methods[224] = lambda value: msgbuffers.size_object(value) _tag_size_methods[225] = lambda value: msgbuffers.size_object(value) _tag_size_methods[226] = lambda value: msgbuffers.size_object(value) _tag_size_methods[227] = lambda value: msgbuffers.size_object(value) _tag_size_methods[228] = lambda value: msgbuffers.size_object(value) _tag_size_methods[229] = lambda value: msgbuffers.size_object(value) _tag_size_methods[230] = lambda value: msgbuffers.size_object(value) _tag_size_methods[231] = lambda value: msgbuffers.size_object(value) _tag_size_methods[232] = lambda value: msgbuffers.size_object(value) _tag_size_methods[233] = lambda value: msgbuffers.size_object(value) _tag_size_methods[234] = lambda value: msgbuffers.size_object(value) _tag_size_methods[235] = lambda value: msgbuffers.size_object(value) _tag_size_methods[236] = lambda value: msgbuffers.size_object(value) _tag_size_methods[237] = lambda value: msgbuffers.size_object(value) _tag_size_methods[240] = lambda value: msgbuffers.size_object(value) _tag_size_methods[242] = lambda value: msgbuffers.size_object(value) _tag_size_methods[243] = lambda value: msgbuffers.size_object(value) _type_by_tag_value = dict() _type_by_tag_value[176] = lambda : Anki.Vector.RobotInterface.SyncRobotAck _type_by_tag_value[177] = lambda : Anki.Vector.RobotInterface.PrepForShutdown _type_by_tag_value[178] = lambda : Anki.Vector.RobotInterface.MotorActionAck _type_by_tag_value[179] = lambda : Anki.Vector.MotorCalibration _type_by_tag_value[180] = lambda : Anki.Vector.RobotInterface.RobotStopped _type_by_tag_value[181] = lambda : Anki.Vector.MotorAutoEnabled _type_by_tag_value[182] = lambda : Anki.Vector.RobotInterface.PathFollowingEvent _type_by_tag_value[183] = lambda : Anki.Vector.GoalPose _type_by_tag_value[184] = lambda : Anki.Vector.DockingStatus _type_by_tag_value[185] = lambda : Anki.Vector.MovingLiftPostDock _type_by_tag_value[186] = lambda : Anki.Vector.RobotInterface.LiftLoad _type_by_tag_value[187] = lambda : Anki.Vector.PickAndPlaceResult _type_by_tag_value[188] = lambda : Anki.Vector.ChargerMountComplete _type_by_tag_value[189] = lambda : Anki.Vector.CliffAlignComplete _type_by_tag_value[193] = lambda : Anki.Vector.RobotInterface.FallImpactEvent _type_by_tag_value[194] = lambda : Anki.Vector.RobotInterface.IMUDataChunk _type_by_tag_value[195] = lambda : Anki.Vector.RobotInterface.IMURawDataChunk _type_by_tag_value[196] = lambda : Anki.Vector.RobotInterface.IMUTemperature _type_by_tag_value[197] = lambda : Anki.Vector.CliffEvent _type_by_tag_value[198] = lambda : Anki.Vector.PotentialCliff _type_by_tag_value[199] = lambda : Anki.Vector.RobotInterface.FallingEvent _type_by_tag_value[200] = lambda : Anki.Vector.RobotInterface.RobotPoked _type_by_tag_value[202] = lambda : Anki.Vector.RobotInterface.RunFactoryTest _type_by_tag_value[203] = lambda : Anki.Vector.RobotInterface.StartSelfTest _type_by_tag_value[205] = lambda : Anki.Vector.RobotInterface.RobotServerDisconnect _type_by_tag_value[206] = lambda : Anki.Vector.RobotInterface.StillAlive _type_by_tag_value[208] = lambda : Anki.Vector.StartShutdownAnim _type_by_tag_value[209] = lambda : Anki.Vector.ReportCloudConnectivity _type_by_tag_value[211] = lambda : Anki.Vector.AnimationAdded _type_by_tag_value[212] = lambda : Anki.Vector.RobotAvailable _type_by_tag_value[213] = lambda : Anki.Vector.AnimationEvent _type_by_tag_value[214] = lambda : Anki.Vector.AnimationStarted _type_by_tag_value[215] = lambda : Anki.Vector.AnimationEnded _type_by_tag_value[216] = lambda : Anki.Vector.RobotInterface.AudioFFTResult _type_by_tag_value[217] = lambda : Anki.Vector.RobotInterface.TriggerWordDetected _type_by_tag_value[218] = lambda : Anki.Vector.RobotInterface.MicDirection _type_by_tag_value[219] = lambda : Anki.Vector.TextToSpeechEvent _type_by_tag_value[220] = lambda : Anki.Vector.SwitchboardInterface.EnterPairing _type_by_tag_value[221] = lambda : Anki.Vector.SwitchboardInterface.ExitPairing _type_by_tag_value[222] = lambda : Anki.Vector.StreamCameraImages _type_by_tag_value[223] = lambda : Anki.Vector.DebugScreenMode _type_by_tag_value[224] = lambda : Anki.AudioEngine.Multiplexer.AudioCallbackDuration _type_by_tag_value[225] = lambda : Anki.AudioEngine.Multiplexer.AudioCallbackMarker _type_by_tag_value[226] = lambda : Anki.AudioEngine.Multiplexer.AudioCallbackComplete _type_by_tag_value[227] = lambda : Anki.AudioEngine.Multiplexer.AudioCallbackError _type_by_tag_value[228] = lambda : Anki.Vector.RobotInterface.DisplayedFaceImageRGBChunk _type_by_tag_value[229] = lambda : Anki.Vector.RobotInterface.BeatDetectorState _type_by_tag_value[230] = lambda : Anki.Vector.RobotInterface.AudioPlaybackBegin _type_by_tag_value[231] = lambda : Anki.Vector.RobotInterface.AudioPlaybackEnd _type_by_tag_value[232] = lambda : Anki.Vector.RobotInterface.MicRecordingComplete _type_by_tag_value[233] = lambda : Anki.Vector.RobotInterface.MicDataState _type_by_tag_value[234] = lambda : Anki.Vector.RobotInterface.SendRangeData _type_by_tag_value[235] = lambda : Anki.Vector.AudioStreamStatusEvent _type_by_tag_value[236] = lambda : Anki.Vector.RobotInterface.AlexaAuthChanged _type_by_tag_value[237] = lambda : Anki.Vector.RobotInterface.AlexaUXChanged _type_by_tag_value[240] = lambda : Anki.Vector.RobotState _type_by_tag_value[242] = lambda : Anki.Vector.RobotInterface.MicData _type_by_tag_value[243] = lambda : Anki.Vector.AnimationState Anki.Vector.RobotInterface.RobotToEngine = RobotToEngine del RobotToEngine