You can define a new node class using the $nodeclass shorthand notation by specifying the name of the class and at least one parent class, like so:

$nodeclass MyUselessClass : StateNode {
}

The above definition expands into the following C++ code:

class MyUselessClass : public StateNode {
public:
  MyUselessClass(const std::string &nodename = "MyUselessClass") : StateNode(nodename) {}
};

One way to define a not-so-useless class is to pass some extra arguments to the parent's constructor. In the shorthand notation, instead of writing the name of a parent class you can write a call to its constructor, and the stateparser will do the rest. In any parent constructor call, the special symbol $ will be substituted for the nodename argument. Example:

$nodeclass SayHello : SpeechNode($,"Hello there!") {
}

Now we can use SayHello in a state machine definition, just like any of the built-in state node classes.

$shortnodeclass WriteNodeName : StateNode {
  virtual void doStart() {
    cout << "This is node " << getName() << endl;
  }
}

Here's another trick: to turn on a robot's green LED using a LedNode, you must tell the LedMC motion command inside the LedNode which LED you want to operate on, and what you want to do with it. To simplify things, you can make a new class called GreenLEDOn and include code in its constructor to supply the necessary information to the motion command. To do that, you specify an optional method argument on the $nodeclass line; in this case it's the constructor method that you want to add to:

$nodeclass GreenLEDOn : LEDNode : constructor {
  getMC()->set(RobotInfo::GreenLEDMask, 1.0);
}

Here's an example of a class with both doStart and doEvent methods. This class waits for the user to press the green button on the robot, and then posts a completion event. (Normally we would use an EventTrans to look for a button event, and we might abbreviate it using a =B(...)=> shorthand transition. Here we're handling the button event in an unusual way just for illustrative purposes.)

$nodeclass WaitForPress : StateNode {
  virtual void doStart() {
    erouter->addListener(this, EventBase::buttonEGID, RobotInfo::GreenButOffset, EventBase::activateETID);
  }

  virtual void doEvent() {
    cout << "Green button pressed: "  << event->getDescription() << endl;
    postStateCompletion();
  }

}

$nodeclass WaitFor3Presses : StateNode : count() {
  int count;

  virtual void doStart() {
    count = 0;
    erouter->addListener(this, EventBase::buttonEGID, 
                        RobotInfo::GreenButOffset, EventBase::activateETID);
  }

  virtual void doEvent() {
    if ( ++count == 3 )
      postStateCompletion();
  }

}

You might be wondering why count is explicitly initialized to 0 in the doStart method instead of relying on the constructor's initializer list. The reason is that the constructor is only called to instantiate the class and produce an instance. If that state node instance is part of a loop it will be entered multiple times, and the counter needs to be reset each time. On the other hand, if the variable count did not have an intiailizer expression in the $nodeclass declaration, we would get a compiler warning. So an initializer must be supplied, but in this example the initial value it assigns is not being relied upon.

Here's an example: suppose we want to define a node class GoForward that takes a distance argument in its constructor, makes the robot travel forward by that distance, and also announces the distance in a message on the console. If we're coding for the the Create we would use a WalkNode to do the moving. Here is the class definition:

$nodeclass GoForward(float distance) : WalkNode($, distance, 0, 0, 1) {
  virtual void doStart() {
    cout << "Going forward by " << distance << " mm." << endl;
  }
}

There are several things to note in the above example. First, even though we explicitly specified the form of the GoForward constructor, we did not have to include the nodename argument; that is supplied automatically by the stateparser and cannot be overridden. Second, we did not have to write an initializer expression for distance; this was also handled automatically by the state parser. The declaration above expands into the following C++ code:

class GoForward : public WalkNode {
 public:
  float distance;  // cache the constructor's parameter
  GoForward(const std::string &nodename, float _distance) : WalkNode(nodename,_distance,0,0,1), distance(_distance) {}
  virtual void doStart() {
    cout << "Going forward by " << distance << " mm." << endl;
  }
};

Note that since we did not specify a default value for the distance argument, a value must be supplied in the constructor call, and this in turn means a value must be supplied for the nodename argument that precedes it. Thus, with the above definition for GoForward, this expression is not legal:

  fwd: GoForward =C=> SayHello

  fwd: GoForward($,100) =C=> SayHello

$nodeclass GoForward(float distance=100) : WalkNode($,_distance,0,0,1) {
  virtual void doStart() {
    cout << "Going forward by " << distance << " mm." << endl;
  }
}

• A node class can have multiple parent classes. Just separate them by commas in the $nodeclass declararation.

• If you're uncertain about the effect of a nodeclass declaration, you can run the stateparser directly and look at the generated code. Suppose you've placed a node declaration in the file MyCode.cc.fsm. Then type the following to display the generated code:

  Tekkotsu/tools/sbin/stateparser MyCode.cc.fsm -

  The dash as second argument indicates that the output should be written to the console instead of to a file. If you omit the second argument, the output will be written to the file MyCode-fsm.cc.

• If your class contains pointer members, and you don't want to write explicit definitions for the copy constructor and assignment operator, use $nodeclass*. This variant supplies dummy prototypes for the copy constructor and assignment operator.