diku_mch/Mote.h

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