mch/Mote.h

   1 #ifndef REMOTE_MCH_MOTE_H
   2 #define REMOTE_MCH_MOTE_H
   3
   4 #include "remote.h"
   5 #include "mch/SerialControl.h"
   6
   7 namespace remote { namespace mch {
   8
   9 /** MCH Mote
  10  *
  11  * This class is used for keeping track of information from the mote
  12  * device directory and whether a mote is valid. A mote object is
  13  * created for each mote attached to a mote host.
  14  *
  15  * All the lowlevel control of the serial connection to the mote is
  16  * done via the subclassed #SerialControl class.
  17  */
  18 class Mote : public SerialControl
  19 {
  20 public:
  21         static const std::string NONE;
  22         static const std::string START;
  23         static const std::string STOP;
  24         static const std::string RESET;
  25         static const std::string PROGRAM;
  26
  27         /** Create a new mote.
  28          *
  29          * A newly created will automatically be validated using
  30          * #validate().
  31          *
  32          * @param mac           The mote's MAC address.
  33          * @param directory     The mote device directory.
  34          */
  35         Mote(std::string& mac, std::string& directory);
  36
  37         /** Is the mote started or stopped?
  38          *
  39          * @return      True if the mote is running.
  40          */
  41         bool isRunning();
  42
  43         /** Is the mote valid?
  44          *
  45          * @return      True if the mote is valid.
  46          */
  47         bool isValid();
  48
  49         /** Mark the mote invalid. */
  50         void invalidate();
  51
  52         /** Validate mote.
  53          *
  54          * When validating a mote, information from files in the mote
  55          * device directory are reread in order to check if the mote is
  56          * still operational.
  57          */
  58         void validate();
  59
  60         /** Start mote.
  61          *
  62          * @return      True if mote was started.
  63          */
  64         bool start();
  65
  66         /** Stop mote.
  67          *
  68          * @return      True if mote was stopped.
  69          */
  70         bool stop();
  71
  72         /** Reset mote.
  73          *
  74          * @return      True if mote was reset.
  75          */
  76         bool reset();
  77
  78         /** Start programming a mote.
  79          *
  80          * This will fork a child process to do the actual programming.
  81          *
  82          * @param netaddress    The net address of the mote.
  83          * @param image         The flash image which to use.
  84          * @param imagelen      The length of the flash image data.
  85          * @return              True if the programming was started.
  86          */
  87         bool program(std::string netaddress, const uint8_t *image, uint32_t imagelen);
  88
  89         /** Cancel mote programming.
  90          *
  91          * @return              True if mote was being programmed.
  92          */
  93         bool cancelProgramming();
  94
  95         /** Get result of exiting child.
  96          *
  97          * @param force         Whether to force the child to exit.
  98          * @return              True if the child exited with code 0.
  99          */
 100         bool getChildResult(bool force = false);
 101
 102         /** Get MAC address.
 103          *
 104          * @return      The MAC address.
 105          */
 106         const std::string& getMac();
 107
 108         /** Get the physical device path.
 109          *
 110          * The physical device path contains information about where on
 111          * the mote host the mote is attached. This includes information
 112          * such as which PCI bus it uses, which USB interface etc, for
 113          * example: "/devices/pci0000:00/0000:00:1d.0/usb1/1-1".
 114          *
 115          * This information is read from the "path" file in the mote
 116          * device directory.
 117          *
 118          * @return      The physical device path.
 119          */
 120         const std::string& getDevicePath();
 121
 122         /** Get platform name.
 123          *
 124          * Contains the name of the mote platform, for example "MicaZ"
 125          * or "dig528-2".
 126          *
 127          * This information is read from the "platform" file in the mote
 128          * device directory.
 129          *
 130          * @return      The name of the mote's platform.
 131          */
 132         const std::string& getPlatform();
 133
 134         /** Get control command.
 135          *
 136          * Get name of the command currently being executed.
 137          *
 138          * @return      Command name.
 139          */
 140         const std::string& getControlCommand();
 141
 142 private:
 143         /** Setup TTY port.
 144          *
 145          * This will setup the TTY by opening it. The command parameter
 146          * can be used to indicate in what power mode the mote should start.
 147          *
 148          * @param cmd   Command to execute, if non-empty string.
 149          * @return      True if setup succeeded.
 150          */
 151         bool setupTty(const std::string cmd);
 152
 153         /** Execute power command.
 154          *
 155          * @param cmd   Command to execute, may be: START, STOP, or RESET.
 156          * @return      True if power command was executed.
 157          */
 158         bool power(const std::string cmd);
 159
 160         std::string mac;        /**< MAC address. */
 161         std::string directory;  /**< Device directory path. */
 162         std::string imagefile;  /**< Path to temporary flash image file. */
 163         std::string controller; /**< Path to mote control binary. */
 164         std::string programmer; /**< Path to mote programmer binary. */
 165         std::string ttyControl; /**< Path to control TTY. */
 166         std::string ttyData;    /**< Path to console data TTY. */
 167         std::string path;       /**< Physical device path. */
 168         std::string platform;   /**< Platform name. */
 169         bool isvalid;           /**< Valid flag. */
 170         bool running;           /**< Mote is started or stopped? */
 171         std::string controlCmd; /**< The command being executed. */
 172 };
 173
 174 }}
 175
 176 #endif