Tekkotsu Homepage
Demos
Overview
Downloads
Dev. Resources
Reference
Credits

Tekkotsu Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Aibo3DControllerBehaviorListens to aibo3d control commands coming in from the command port
AngPiCircular arithmetic on angles between 0 and pi (180 degrees)
AngSignPiCircular arithmetic on angles between -pi and pi (360 degrees)
AngTwoPiCircular arithmetic on angles between 0 and two pi (360 degrees)
argb
argbf
plist::ArrayBaseMaintains an array of value, see ArrayOf, and the Array typedef
plist::ArrayBase::ConversionTo< PO >This conversion policy accepts entries of the specified template type, and will try to create new instances of that type constructed from any values which are passed
plist::ArrayBase::DeniedValueConversionsIndicates that no value conversions are allowed
plist::ArrayBase::EntryConstraint< PO >
plist::ArrayBase::IntegerConversionAbstract base class to test whether the collection will accept integers (possibly converting to another value type, or storing directly as a [unsigned] long depending on concrete type)
plist::ArrayBase::RealConversionAbstract base class to test whether the collection will accept floating point numbers (possibly converting to another value type, or storing directly as a double depending on concrete type)
plist::ArrayBase::StringConversionAbstract base class to test whether the collection will accept strings (possibly converting to a value type, or storing directly as string depending on concrete type)
plist::ArrayBase::WrapValueConversion< PO >This conversion policy accepts any entries of the specified template type, values will be directly wrapped as Primitives so no conversion at all is actually performed
plist::ArrayOf< PO, Alloc >A collection of plist objects, similar to a Dictionary, but no keys -- order matters!, see plist::Array
AutoGetupBehaviorLittle background behavior to keep the robot on its feet
BallDetectionGeneratorUses segmented color region information to detect round objects
BallDetectionGenerator::VObjectHigh level vision ouput structure for detected objects
basic_inetstream< charT, traits >
basic_ionetstream< charT, traits >
basic_netbuf< charT, traits >
basic_netbuf_interface< charT, traits >
basic_onetstream< charT, traits >
basic_streambuf
BatteryCheckControlWhen activated, this will print a battery report to stdout and light up LEDs to specify power level
BatteryMonitorBehaviorA background behavior which will monitor the power level and flip the ears when appropriate on a 210, or blink the headlight if a 220
BehaviorActivatorControlUpon activation, will start, stop, or toggle a behavior
BehaviorBaseThe basis from which all other Behaviors should inherit
BehaviorReportControlReads the set of currently instantiated behaviors and sends a report to sout
BehaviorSwitchActivatorControlUpon activation, will tell the specified BehaviorSwitchControl to start or stop the behavior
BehaviorSwitchControl< B, Al >Allows proper switching between major behaviors, calling DoStart and DoStop
BehaviorSwitchControlBaseHolds some utility classes and functions for BehaviorSwitchControl which shouldn't be stored in a templated class
BehaviorSwitchControlBase::BehaviorGroupA simple utility class to allow the BehaviorSwitchControl's to be able to deactivate the current behavior when a new one becomes active
BufferBuffer
BufferedImageGeneratorReceives camera frames as they are loaded by the simulator -- or eventually other sources
BufferedImageGenerator::ImageSourceStores information about the current frame, (not the image itself, but meta data a pointer to it)
CameraStreamBehaviorBase class for camera streaming communication classes, handles upstream communication
RobotInfo::CapabilitiesAllows behaviors to lookup output/button/sensor names from other models to support basic cross-model portability
CDTGeneratorGenerates SegmentedColorFilterBankEvents with images provided from the system
CloneableAn interface for cloning objects -- needed for making copies with polymorphism (operator= doesn't work as virtual)
plist::CollectionProvides a common base class for the collection-oriented primitives, Dictionary and Array
plist::Collection::conversion_policy< U, V >Specifies that a collection of collections cannot contain any primitive values
plist::CollectionListenerIf you wish to be notified any time an entry is added, removed, or replaced from a Dictionary, Array, or Vector, inherit from this and implement one or both of the functions, then register it with the collection's addCollectionListener()
CMVision::color_class_state
CompareTrans< T >Causes a transition if a value (through a pointer) goes above a given value
CompletionTransCauses a transition when at least n sources have signalled completion; n = 0 means "all" (default)
ThreadNS::ConditionProvides an inter-thread signaling and synchronization mechanism
ConfigRoot configuration object, provides some global functionality like porting pathnames (portPath())
Config::behaviors_configPlace for users to put their own configuration
Config::controller_configController information
Config::main_configGeneral configuration options
Config::motion_configMotion information
Config::sound_configSound information
Config::sound_config::streaming_configAudio streaming configuration
Config::vision_configVision configuration options (this is a *big* section, with sub-sections)
Config::vision_config::CameraCalibrationThese values represent a "Plumb Bob" model introduced by Brown in 1966
Config::vision_config::RawCamConfigSettings specific to the "RawCam" (original camera images) for streaming video over the network
Config::vision_config::RegionCamConfigSettings specific to the "RegionCam" (only display a box for each blob of color) for streaming over the network
Config::vision_config::SegCamConfigSettings specific to the "SegCam" (segmented color images) for streaming video over the network
Config::vision_config::StreamingConfigSettings related to streaming video over the network
Config::wireless_configWireless configuration options
ConfigDictionarySubclass of plist::Dictionary which adds support for filtering settings by robot model, each configuration section is based on this
ConfigurationEditorProvides interactive editing and loading/saving of a plist::Collection
ConfigurationEditor::AddCollectionEntryDisplays a list of template objects (see ConfigurationEditor::getObjectTemplates()) which can be added to a target collection
ConfigurationEditor::LoadSettingsFile browser to load a plist from the file system
ConfigurationEditor::NamedEnumerationEditorBased on a string input control for easier mixing with other primitives (which just use a basic string input control as an editor)
ConfigurationEditor::NewCollectionEntryInterface to set up a new collection entry before inserting it
ConfigurationEditor::SaveSettingsFile browser to save a plist from the file system
ConnectionMadeTransTransition that occurs as soon as a connection is made
ControlBaseBase class for all items in the Controller hierarchy
ControllerHandles the menu/command system... when it detects the EmergencyStopMC is activated, it'll kick into high priority
DataEvent< T, TID >For passing around data (or pointers to data)
DeadReckoningBehavior< ParticleT >Subscribes to LocomotionEvents and attempts to track robot movement over time using a fairly generic HolonomicMotionModel
plist::DictionaryBaseMaintains a set of (key,value) pairs, see DictionaryOf, and the Dictionary typedef
plist::DictionaryBase::ConversionTo< PO >This conversion policy accepts entries of the specified template type, and will try to create new instances of that type constructed from any values which are passed
plist::DictionaryBase::DeniedValueConversionsIndicates that no value conversions are allowed
plist::DictionaryBase::EntryConstraint< PO >This base conversion policy doesn't actually specify any conversions at all -- this serves as a base class to provide the ability to directly add entries of the specified type; the subclasses will add value conversions
plist::DictionaryBase::IntegerConversionAbstract base class to test whether the collection will accept integers (possibly converting to another value type, or storing directly as a [unsigned] long depending on concrete type)
plist::DictionaryBase::RealConversionAbstract base class to test whether the collection will accept floating point numbers (possibly converting to another value type, or storing directly as a double depending on concrete type)
plist::DictionaryBase::StringConversionAbstract base class to test whether the collection will accept strings (possibly converting to a value type, or storing directly as string depending on concrete type)
plist::DictionaryBase::WrapValueConversion< PO >This conversion policy accepts any entries of the specified template type, values will be directly wrapped as Primitives so no conversion at all is actually performed
plist::DictionaryOf< PO, Alloc >A dictionary which requires all elements to be subtypes of the PO template argument
CMVision::DummyI3< x, y, z >
DummySocketTekkotsu wireless DummySocket class
CMVision::DummyT1< T >
CMVision::DummyT1I3< T, x, y, z >
DumpFileControlUpon activation, loads a position from a file name read from cin (stored in ms/data/motion...)
DynamicMotionSequenceUses STL's vector for dynamic memory allocation - don't use this as a motion command, pointers in shared memory regions can be invalid in other processes
EchoBehaviorWaits for a connection, echos any data received back to the sender
EmergencyStopMCOverrides all joints with high priority freeze, blinks tail pink/red/blue cycle
EmptyResourceNo-op resource, since we don't want Resource itself to be directly instantiatable
ERS210Info::ERS210CapabilitiesPolymorphic robot capability detection/mapping
ERS220Info::ERS220CapabilitiesPolymorphic robot capability detection/mapping
ERS2xxInfo::ERS2xxCapabilitiesPolymorphic robot capability detection/mapping
ERS7Info::ERS7CapabilitiesPolymorphic robot capability detection/mapping
EStopControllerBehaviorListens to control commands coming in from the command port for remotely controlling the head
EventBaseForms the basis of communication between modules/behaviors in the framework
EventGeneratorBaseA simple convenience class for event generators
EventListenerAn interface to allow a standard method of passing events
EventLoggerAllows logging of events to the console or a file, also provides some remote logging facilities over logSocket, required by Storyboard tool
EventLogger::StateMachineListenerSeparate processEvent to distinguish between events requested for logging and events requested by a remote monitor
EventProxy
EventRouterThis class will handle distribution of events as well as management of timers
EventRouter::EventMapperDoes the actual storage of the mapping between EventBase's and the EventListeners/EventTrappers who should receive them
EventRouter::PostingStatusInformation regarding the progress of posting an event
EventRouter::TimerEntryContains all the information needed to maintain a timer by the EventRouter
EventRouter::TimerEntryPtrCmpUsed by STL to sort the timer list in order of activation time
EventTransCauses a transition when the specified event is received
EventTranslatorEventTranslator receives events from EventRouters in non-Main processes and adds them into a SharedQueue for Main to pick up
EventTrapperAn interface to allow a standard method of trapping events
Factory0_1Arg< Base, A1 >Base class for factories which can create products more than one way, in this case via default constructor (0 arguments) or 1-argument constructor
Factory0_1Arg< Base, A1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory0Arg< Base >Typed base class for factories which don't require any arguments to construct their product, see Factories.h file notes
Factory0Arg1Member< Base, M1 >This class produces objects based on a constant specified as a factory member
Factory0Arg1Member< Base, M1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory0Arg1Static< Base, S1, s1 >This class produces objects based on a constant specified as a template parameter
Factory0Arg1Static< Base, S1, s1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory0Arg2Static< Base, S1, s1, S2, s2 >This class produces objects based on constant values specified as a template parameters
Factory0Arg2Static< Base, S1, s1, S2, s2 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory0Arg< Base >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory0ArgBaseUntyped base class for factories which don't require any arguments to construct their product, see Factories.h file notes (see Factory0Arg)
Factory1Arg< Base, A1 >Typed base class for factories which require a single argument to construct their product, which is passed to the concrete Factory's functor
Factory1Arg1Static< Base, A1, S1, s1 >This class produces objects based on a functor argument and a constant specified as a template parameter
Factory1Arg1Static< Base, A1, S1, s1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory1Arg< Base, A1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory1ArgBase< A1 >Untyped base class for factories which require a single argument to construct their product, which is passed to the concrete Factory's functor (see Factory1Arg)
Factory1Static1Arg< Base, S1, s1, A1 >This class produces objects based on a constant specified as a template parameter and a constructor argument
Factory1Static1Arg< Base, S1, s1, A1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
Factory1Static_1Arg< Base, S1, s1, A1 >Variant of Factory0_1Arg, this uses a constant non-type template parameter to specify a default value to use when the 0-argument functor is called..
Factory1Static_1Arg< Base, S1, s1, A1 >::Factory< T >Concrete class for constructing products of a specified subtype of Base
FactoryInvalidT<>A factory interface which doesn't actually allow anything to be produced (for completeness, like 'NULL')
FactoryInvalidT<>::Factory< U >Concrete class for not doing anything
FactoryT
FamilyFactory< FamilyT, NameT, FactoryBaseT, FactoryT >A class which can track a set of subclass types (with shared base class FamilyT), generating new instances on demand based on some form of identifier (the NameT template parameter)
FamilyFactory< FamilyT, NameT, FactoryBaseT, FactoryT >::FactoryType< T >Allows indirect access to create factory classes
FileBrowserControlDisplays the contents of a directory in a control menu, probably useful as a baseclass for other controls
FileInputControlUpon activation, allows user to browse files and select one; stores path in a string
FilterBankEventThis event gives access to a set of image channels at different resolutions, see FilterBankGenerator
FilterBankGeneratorAbstract base class for generators of FilterBankEvent's
FlashIPAddrBehaviorDisplays IP address by speaking the digits and flashing a series of numbers on the LED face panel
FreeMemReportControlGives reports on free memory size at variable rates, can also warn if free memory drops too low
GraphicsProvides basic graphics capabilities for drawing into any bitmap, particularly FilterBankGenerators
GroupNodeAllows a group of StateNodes to be activated together
hashcmp_eqstr
HeadPointControllerBehaviorListens to control commands coming in from the command port for remotely controlling the head
HeadPointerMCThis class gives some quick and easy functions to point the head at things
HeadPointerNodeA simple StateNode that executes a HeadPointerMC motion command
HelpControlRecurses through the menu system and outputs the name and description of each item
HolonomicMotionModel< ParticleT >This class can model the path of a holonomic robot in two dimensions (x and y)
CMVision::image< pixel >
CMVision::image_idx< pixel >
CMVision::image_yuv< element >
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >Attempts to provide references to all currently instantiated objects of a class (and its subclasses)
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::FactoryType< T >Allows indirect access to create factory classes
InstanceTracker< FamilyT, ClassNameT, FactoryBaseT, FactoryT >::InstanceEntryProvides a wrapper for non-plistDictionary entries
InterleavedYUVGeneratorGenerates FilterBankEvents containing raw camera images with interleaved pixels (YUVYUVYUV... instead of YYY...UUU...VVV...)
IPaddr
IPCEventTranslatorAn implementation of EventTranslator which will forward events using the inter-process mechanisms of the current platform
JPEGGeneratorGenerates FilterBankEvents containing JPEG compressed images
KinematicsProvides access to the mathematical functionality of the ROBOOP package using Tekkotsu data structures
Kinematics::hashstringAllows us to use the STL hash_map with strings
Kinematics::InterestPointHolds the position and attached link of a given interest point
Kinematics::JointMapAllows mapping from tekkotsu output index to chain and link indicies
LedEngineProvides basic LED effects via subclassing (e.g. LedMC) or embedding (e.g. EmergencyStopMC)
LedEngine::LEDInfoHolds all the information needed by each of the LEDs
LedMCThis is just a simple wrapper - you probably want to be looking at LedEngine
LedNodeA simple StateNode that executes a LedMC motion command and throws a status event upon completion
LGmixinMix-in for the BehaviorBase or StateNode class to give access to Looking Glass variables
plist::ListenerBase class for the plist listener callbacks
ListMemBuf< T_t, MAX, idx_t >Provides some degree of dynamic allocation of a templated type from a buffer of set size
ListMemBuf< T_t, MAX, idx_t >::entry_tHolds data about an entry in the free/used lists
LoadCalibrationWill load calibration parameters from a text file into a forward and backward matrix
LoadPostureControlUpon activation, loads a position from a file name read from cin (stored in ms/data/motion...)
LoadSaveIntended as an interface to allow easy and portable serialization operations
LoadWalkControlWhen activated, loads a set of walk parameters from a file specified by user
LocalizationParticleEach Particle represents a hypothesis about the match of the local map to the world map
LocalizationParticleDistributionPolicy< ParticleT >Provides parameters and methods for randomizing and tweaking LocalizationParticles
ThreadNS::LockInter-thread lock -- doesn't work across processes, only threads within a process. (see MutexLock for inter-process locks)
LocomotionEventGives updates regarding the current movement of the robot through the world
LookoutEventAbstract base class for all Lookout Events
LookoutIREvent
LookoutPointAtEvent
LookoutScanEvent
LookoutSketchEvent
LostTargetTransCauses a transition if the target has not been seen minframe times within delay milliseconds
MarkScopeProvides a way to mark a resource as used for the duration of the instance's scope
MCNode< T, mcName, mcDesc, completes >A generic wrapper for any MotionCommand, note that some functions are provided by the MCNodeBase common base class, namely MCNodeBase::setMC() and MCNodeBase::getMC_ID()
MCNodeBaseCommon parent class for all the templated MCNode, which is what you want to instantiate
MCValueEditControl< T >Allows you to modify a value in memory, much like ValueEditControl, but will check out a MotionCommand first to maintain proper mutual exclusion
MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS >An implementation of MessageQueueBase, which provides mechanisms for sending shared memory regions between processes
MessageQueue< MAX_UNREAD, MAX_RECEIVERS, MAX_SENDERS >::entryData storage needed for each message
MessageQueueBaseDefines the interface for sending new shared memory regions between processes
MessageQueueBase::MessageFilterInterface for filtering (or otherwise monitoring) messages being sent through a MessageQueue, see MessageQueueBase::addMessageFilter()
MessageQueueStatusThreadDescription of MessageQueueStatusThread
MessageQueueStatusThread::StatusListenerAn interface to allow you to receive callbacks when a message has been read from a MessageQueue, subscribed via an external class which is monitoring the queue's MessageQueueBase::pollStatus() (e.g. LoadFileThread)
MessageReceiverSpawns a thread for monitoring a MessageQueue, calls a specified function when new messages are available
MicrophoneServerStreams audio from the microphone over the network
MMAccessor< MC_t >This class allows convenient ways of accessing a motion command
MotionCommandThe abstract base class for motions, provides common interface. All motions should inherit from this
MotionManagerThe purpose of this class is to repeatedly compute the final set of joint angles for the robot, managing a set of (possibly conflicting) MotionCommands
MotionManager::CommandEntryAll the information we need to maintain about a MotionCommand
MotionManager::OutputStateHolds the full requested value of an output
MotionManager::PIDUpdateUsed to request pids for a given joint
MotionManagerMsgA small header that precedes data sent by MotionManager between processes
MotionSequenceEngineA handy class for storing a sequence of keyframed movements
MotionSequenceEngine::MoveThis struct holds all the information needed about a frame for a particular output
MotionSequenceMC< MAXMOVE >Instantiates MotionSequenceEngines - when you want to run a motion sequence, make one of these
MotionSequenceNode< SIZE >A StateNode for playing a MotionSequence (and looping it if desired)
MutexLock< num_doors >Implements a mutual exclusion lock using semaphores (SYSV style through SemaphoreManager)
MutexLockBaseThe main purpose of this base class is actually to allow setting of usleep_granularity across all locks
MutexLockBase::no_more_semaphoresException if a lock is created but there aren't any more semaphores available
plist::NamedEnumeration< T >Provides an interface for the use of enumerations in a plist -- you can specify values by either the string name or the corresponding integer value
plist::NamedEnumeration< T >::conversion_policy< U, V >
plist::NamedEnumerationBaseSome accessors common across NamedEnumeration types
NetworkBuffer
NetworkStatusControlWill display current network status such as wireless signal strength
NoOpEventTranslatorFor completeness, if you want to have events be piped directly to the local erouter instead having to be encoded and decoded
NullControlWhen activated, this will return immediately (handy for fake items in a menu)
NullTransTransition that occurs (via a 0 msec Timer event) as soon as the source node finishes starting up
plist::ObjectBaseThis base class provides the root functionality for all plist entities -- Dictionary and the various templated subclasses of PrimitiveBase
plist::ObjectBase::conversion_policy< U, V >That collections (e.g. plist::Array or plist::Dictionary) of these abstract base classes (ObjectBase, PrimitiveBase) can convert any primitive type to a plist::Primitive wrapper
OCdtInfo
OCdtVectorData
ODataVectorInfoCompatability with the OPEN-R type of the same name
OFbkImage
OFbkImageInfoCompatability with the OPEN-R type of the same name
OFbkImageVectorDataCompatability with the OPEN-R type of the same name
OSoundInfoCompatability with the OPEN-R type of the same name
OSoundVectorDataCompatability with the OPEN-R type of the same name
OutputCmdThis object holds all the information needed to control a single output
OutputConfig< T >Stores an item for each joint, can be accessed via joint name or array offset
OutputNodeA very simple StateNode that outputs its name to a given ostream upon activation, handy for debugging
OutputPIDThis object holds all the information needed to control a single output
ParticleBaseProvides a common base class for particles used by the ParticleFilter
ParticleFilter< ParticleT >Implements a particle filter with support for a variety of applications through the usage of arbitrary combination of a variety of models and policies
ParticleFilter< ParticleT >::DistributionPolicyA distribution policy provides the ability to randomize ("redistribute") or tweak the values of a group of particles
ParticleFilter< ParticleT >::LowVarianceResamplingPolicyThis class provides a generic, default ResamplingPolicy. It is based on the low variance resampling policy algorithm found in "Probabilistic Robotics" by Sebastian Thrun, Wolfram Burgard, Dieter Fox
ParticleFilter< ParticleT >::MotionModelA motion model is retained by the particle filter to query before evaluating sensor measurements so all known influences are accounted for before testing the particles
ParticleFilter< ParticleT >::ResamplingPolicyThe resampling policy focuses the particle filter on those particles which are performing well, and dropping those which are poorly rated
ParticleFilter< ParticleT >::SensorModelA sensor model is used to update particle weights to account based on each particle's ability to explain observations taken from the system
PIDMCA nice little MotionCommand for manually manipulating the PID values
PitchDetectorGenerates a PitchEvent whenever a notable frequency is detected using FFT
PitchDetector::PitchInfoStores info about the pitch currently being detected
PitchEventProvides information about a tone detected from the microphone(s)
PlaySoundControlUpon activation, loads a position from a file name read from cin (stored in ms/data/motion...)
PNGGeneratorGenerates FilterBankEvents containing PNG compressed images
PollThreadDescription of PollThread
plist::PolymorphicLoaderAllows us to use the LoadSave suite for loading and parsing general XML functions, but forwards loadXML to plist::loadXML() and stores the result as a member
PostureEditorAllows logging of events to the console or a file
PostureEngineA class for storing a set of positions and weights for all the outputs
PostureMCMotionCommand shell for PostureEngine
PostureNodeA simple StateNode that executes a PostureMC motion command
plist::Primitive< T >
plist::Primitive< T >::conversion_policy< U, V >
plist::Primitive< char >
plist::Primitive< char >::conversion_policy< U, V >
plist::Primitive< std::string >Provides a std::string specialization of Primitive<T>
plist::Primitive< std::string >::conversion_policy< U, V >
plist::Primitive< unsigned char >unsigned char specialization of plist::Primitive<T>, adds a unique numeric property to the usual template implementation
plist::Primitive< unsigned char >::conversion_policy< U, V >
plist::PrimitiveBaseProvides common functionality to all primitive value classes (implemented in a templated subclass Primitive)
plist::PrimitiveListenerIf you wish to be notified any time a particular plist primitive's value has been changed, inherit from this and implement the callback, then register it with the plist object through Primitive::addPrimitiveListener()
ProfilerManages a hierarchy of timers for profiling time spent in code, gives microsecond resolution
Profiler::AutoInitAutomatically causes initialization of the histogram buckets when the first Profiler is instantiated
Profiler::SectionInfoHolds all the information needed for book keeping for each timer
Profiler::TimerMeasures the time that this class exists, reports result to a profiler
ProfilerCheckControlCauses the WorldState::mainProfile and WorldState::motionProfile to display reports to sout
ProfilerOfSize< MaxSections >Templated subclass allows compile-time flexibility of how much memory to use
QBotPlusInfo::QBotPlusCapabilitiesPolymorphic robot capability detection/mapping
RandomTransA transition that fires immediately, randomly choosing one destination node to activate
RawCamBehaviorForwards images from camera over wireless
RawCameraGeneratorGenerates FilterBankEvents containing raw camera images directly from the system (doesn't make a copy)
RCRegionCompatability with the OPEN-R type of the same name
RCRegion::IdentifierAll information needed to attach this region from a different process
RebootControlWhen activated, this will cause the aibo to reboot
ReferenceCounterPerforms simple reference counting, will delete the object when removing the last reference
CMVision::region
CMVision::region_small
CMVision::region_tiny
RegionCamBehaviorForwards segmented images from camera over wireless
RegionGeneratorConnects regions of CMVision format runs in RLEGenerator
RegionRegistry< MAX_REGIONS, NAME_LEN >Keeps track of currently available shared memory regions
RegionRegistry< MAX_REGIONS, NAME_LEN >::entryHolds information regarding a shared memory region available for listening
Regis1Info::Regis1CapabilitiesPolymorphic robot capability detection/mapping
RemoteControllerMCThis class is used for setting all outputs to a certain set of values (not the gains, just the joint positions)
RemoteEvents
RemoteRequest
RemoteRouter
RemoteState
ResourceProvides a generic interface for resources which need to keep track of when they are in use, such as mutex locks
Resource::DataBase class for holding data required for requesting to use/release the resource
ResourceAccessor< R >A variation of MarkScope which allows you to forward access to the resource via the '->' operator, smart-pointer style
rgb
rgba
rgbaf
rgbf
RLEGeneratorGenerates RLE compressed FilterBankEvents (generally from indexed color images from, say, SegmentedColorGenerator)
RoverControllerBehaviorDESCRIPTION
CMVision::run< cclass >
CMVision::run_mini< cclass >
RunSequenceControl< SequenceSize >Upon activation, loads a position from a file name read from cin (stored in ms/data/motion...)
SavePostureControlUpon activation, saves the current position to a file name read from user (default is /ms/data/motion...)
SaveWalkControlWhen activated, saves walk parameters to a file specified from cin
SegCamBehaviorForwards segmented images from camera over wireless
SegmentedColorFilterBankEventThis event provides some additional color information over its superclass for image banks made up of indexed colors
SegmentedColorGeneratorGenerates FilterBankEvents indexed color images based on a color threshold file
SegmentedColorGenerator::NoThresholdExceptionThrown if no threshold maps are available
SemaphoreManagerInitializes, manages, and releases a set of System V style semaphores
SensorObserverControlAllows logging of sensor information to the console or file
SensorObserverControl::RTViewControlThe real time view for SensorObserverControl is split into a separate class for more straightfoward handling of refreshes
SharedObject< MC >This templated class allows convenient creation of any type of class wrapped in a shared memory region
SharedObjectBaseIt's nice to have a parent class of SharedObject (which is what you probably want to be reading) so that you can pass around the data structure without worrying about what type is inside the shared memory region
ShutdownControlWhen activated, this will cause the aibo to shut down
SignalTrans< T >Causes a transition if a DataEvent from stateSignalEGID occurs with a specific value
SimulatorAdvanceFrameControlRequests the next camera frame and sensor data, for use when running in simulation
SmoothCompareTrans< T >A subclass of CompareTrans, which provides monitoring of exponentially weighted averages to a threshold
SocketTekkotsu wireless Socket class
SocketListenerInterface for notifications from Wireless
SoundManagerProvides sound effects and caching services, as well as mixing buffers for the SoundPlay process
SoundManager::PlayStateHolds data about sounds currently being played
SoundManager::SoundDataHolds data about the loaded sounds
SoundManagerMsgA small header that preceeds data sent by SoundManager between processes
SoundNodeA simple StateNode that plays a sound upon startup and throws a status event on completion
SpeakerServerPlays streamed audio via the speaker
SpeakerServer::PacketStores information about current sound buffer
stacktrace::StackFrameStores information about a single stack frame
StateNodeRecursive data structure - both a state machine controller as well as a node within a state machine itself
StewartPlatformBehaviorMoves the legs in synchrony to emulate the capabilities of a stewart platform
StringInputControlUpon activation, prompts the user for a string and stores it
TailWagMCA simple motion command for wagging the tail - you can specify period, magnitude, and tilt
TailWagNodeA simple StateNode that executes a TailWagMC motion command
TextMsgEventExtends EventBase to also include actual message text
TextMsgTransFires when a matching string is received
ThreadProvides a nice wrapping of pthreads library
TimeETNice class for handling time values with high precision
TimeOutTransCauses a transition after a specified amount of time has passed
TimerEventAdds a target field to EventBase so listeners can resolve source ID conflict between different behaviors
ToggleControlSimple control for turning things on and off
ToggleControl::RadioGroupLittle class for managing the currently active ToggleControl to allow radio buttons
TorqueCalibrateProvides an interface for making measurements to correlate PID duty cycle and actual force output for each of the motors
TorqueCalibrate::TakeMeasurementControl
TransitionRepresents a transition between StateNodes
value_conversion
value_conversion
tz
UPennWalkControllerBehaviorListens to control commands coming in from the command port for remotely controlling the walk
UPennWalkMCUses the UPennalizers' 2004 RoboCup code to compute walking gaits
uyvy
ValueEditControl< T >Allows real-time modification of a value through a pointer
ValueSetControl< T >Upon activation, this control will set the target pointer to the specified value
ViewWMVarsBehaviorSimply launches the Watchable Memory GUI, which should connect to the already-running WMMonitorBehavior
VisionObjectEventExtends EventBase to also include location in the visual field and distance (though distance is not implimented yet)
VisualTargetCloseTransCauses a transition when a visual object is "close"
VisualTargetTransCauses a transition when a visual object has been seen for at least 6 camera frames
WalkCalibrationAllows interactive calibration of a walk engine
WalkControllerBehaviorListens to control commands coming in from the command port for remotely controlling the walk
WalkEngineNode< W, mcName, mcDesc >A StateNode for walking in a direction, use the template parameter to specify a custom walk MC, or use the WalkNode typedef to accept the "default" walk
WalkMCA nice walking class from Carnegie Mellon University's 2001 Robosoccer team, modified to fit this framework, see their license
WalkMC::CalibrationParamHolds information to correct for slippage, non-idealities
WalkMC::LegParamHolds parameters about how to move each leg
WalkMC::LegWalkStateHolds state about each leg's path
WalkMC::WalkParamHolds more general parameters about the walk
WalkToTargetNodeState node for walking towards a visual target
WAV
WaypointEngine< MAX_WAY >Provides computation and management of a desired path through a series of waypoints
WaypointEngine< MAX_WAY >::WaypointHolds information about each waypoint, see WaypointEngine for overview
WaypointEngineNode< W, mcName, mcDesc >A StateNode for doing a waypoint walk, use the template parameter to specify a custom walk MC, or use the WaypointWalkNode typedef to accept the "default" walk
WaypointWalk< MAX_WAY >Combines a WaypointEngine with a WalkMC so you can walk between a set of waypoints
WaypointWalkControlAllows interactive control and execution of a set of waypoints
WaypointWalkControl::WaypointEditControlHandles editing of individual waypoints
WirelessTekkotsu wireless class
WMentryA WMentry is an entry in a WMregistry
WMitem< T >WMitem<T> is a reference to the variable of type T described by the associated WMentry
WMitem_baseWMitem_base is the base class from which all WMitem<T> subclasses are derived
WMMonitorBehaviorListens to wmmonitor control commands coming in from the command port
WMregistryA WMregistry is a namespace; it holds a collection of WMEntry instances describing the variables that live in this registry
WorldStateThe state of the robot and its environment
WorldStateLookupThis class masquerades as a simple WorldState pointer, but actually checks the process ID of the referencing thread to allow each thread group to have a separate WorldState*
WorldStatePoolHolds multiple instances of WorldState, allows one process to be updating while another is reading
WorldStatePool::ReadRequestRetrieves the current WorldState entry, and through it's destructor, marks the entry available again when it goes out of scope
WorldStatePool::RequestCommon base class for ReadRequest or WriteRequest
WorldStatePool::UpdateInfoReturned by isUnread containing information parsed from the incoming message
WorldStatePool::WriteRequestRetrieves the current WorldState entry, and through it's destructor, marks the entry available again when it goes out of scope
WorldStateSerializerBehaviorCopies WorldState into a buffer for transmission over the network
WorldStateVelDaemonListens for LocomotionEvents and updates the velocity fields of WorldState
XMLLoadSaveXMLLoadSave adds functions for XML format serialization, although if you write binary LoadSave functions as well, you can do either
XMLLoadSave::AutoInitAllows automatic (de)initialization of libxml when the first or last XMLLoadSave class is created or destroyed
XMLLoadSave::bad_formatException to be thrown when a bad XML file is parsed, allows file position information to be passed to the user
yuv
yuvf
yuvi
yuyv

Tekkotsu v4.0
Generated Thu Nov 22 00:58:08 2007 by Doxygen 1.5.4