diku_mch/Mote.cc

   1 #include "Mote.h"
   2
   3 namespace remote { namespace diku_mch {
   4
   5 using namespace remote::util;
   6
   7 const std::string Mote::NONE = "none";
   8 const std::string Mote::START = "start";
   9 const std::string Mote::STOP = "stop";
  10 const std::string Mote::RESET = "reset";
  11 const std::string Mote::PROGRAM = "program";
  12
  13 Mote::Mote(std::string& p_mac, std::string& p_directory)
  14         : SerialControl(), mac(p_mac), directory(p_directory), isRunning(false),
  15           controlCmd(NONE)
  16 {
  17         validate();
  18         if (isvalid && !setupTty(STOP))
  19                 isvalid = false;
  20
  21         Log::info("Mote %s (%s) @ %s", mac.c_str(), platform.c_str(), path.c_str());
  22 }
  23
  24 bool Mote::setupTty(const std::string cmd)
  25 {
  26         if (!openTty(ttyData))
  27                 return false;
  28
  29         if (cmd == START || cmd == STOP || cmd == RESET)
  30                 return power(cmd) == SUCCESS;
  31
  32         return true;
  33 }
  34
  35
  36 bool Mote::isValid()
  37 {
  38         return isvalid;
  39 }
  40
  41 void Mote::invalidate()
  42 {
  43         isvalid = false;
  44 }
  45
  46 void Mote::validate()
  47 {
  48         isvalid = true;
  49         imagefile = directory + "image";
  50
  51         programmer = directory + "programmer";
  52         if (programmer == "" || !File::exists(programmer))
  53                 isvalid = false;
  54
  55         path = File::readFile(directory + "path");
  56         if (path == "")
  57                 isvalid = false;
  58
  59         platform = File::readFile(directory + "platform");
  60         if (platform == "")
  61                 isvalid = false;
  62
  63         ttyData = File::readLink(directory + "tty/data");
  64         if (ttyData == "")
  65                 isvalid = false;
  66
  67         ttyControl = File::readLink(directory + "tty/control");
  68         if (ttyControl == "")
  69                 isvalid = false;
  70
  71         if (!isvalid)
  72                 Log::warn("Mote %s is invalid", mac.c_str());
  73 }
  74
  75
  76 result_t Mote::start()
  77 {
  78         return power(START);
  79 }
  80
  81 result_t Mote::stop()
  82 {
  83         return power(STOP);
  84 }
  85
  86 result_t Mote::reset()
  87 {
  88         return power(RESET);
  89 }
  90
  91 result_t Mote::power(const std::string cmd)
  92 {
  93         bool resetting = cmd == RESET;
  94
  95         if (!isOpen())
  96                 return FAILURE;
  97
  98         if (!resetting || controlDTR(isRunning)) {
  99                 bool enable = resetting ? !isRunning : cmd == STOP;
 100
 101                 if (controlDTR(enable)) {
 102                         isRunning = !enable;
 103                         return SUCCESS;
 104                 }
 105
 106                 /* Mirror that the first reset DTR change succeeded. */
 107                 if (resetting)
 108                         isRunning = !isRunning;
 109         }
 110
 111         Log::error("Failed to %s mote %s: %s",
 112                    cmd.c_str(), mac.c_str(), strerror(errno));
 113         closeTty();
 114         return FAILURE;
 115 }
 116
 117
 118 result_t Mote::program(std::string tos, const uint8_t *image, uint32_t imagelen)
 119 {
 120         if (hasChild())
 121                 return FAILURE;
 122
 123         if (File::writeFile(imagefile, image, imagelen)) {
 124                 std::string mac_env = "macaddress=" + mac;
 125                 std::string tos_env = "tosaddress=" + tos;
 126                 std::string platform_env = "platform=" + platform;
 127                 char * const args[] = {
 128                         (char *) programmer.c_str(),
 129                         (char *) ttyControl.c_str(),
 130                         (char *) imagefile.c_str(),
 131                         NULL
 132                 };
 133                 char * const envp[] = {
 134                         (char *) mac_env.c_str(),
 135                         (char *) tos_env.c_str(),
 136                         (char *) platform_env.c_str(),
 137                         NULL
 138                 };
 139
 140                 Log::info("Programming mote %s", mac.c_str());
 141
 142                 if (runChild(args, envp)) {
 143                         controlCmd = PROGRAM;
 144                         return SUCCESS;
 145                 }
 146
 147                 remove(imagefile.c_str());
 148         }
 149
 150         return FAILURE;
 151 }
 152
 153 result_t Mote::cancelProgramming()
 154 {
 155         if (getControlCommand() != PROGRAM)
 156                 return FAILURE;
 157
 158         return getChildResult(true);
 159 }
 160
 161 result_t Mote::getChildResult(bool force)
 162 {
 163         bool success = endChild(force);
 164         bool afterProgramming = controlCmd == PROGRAM;
 165         const std::string cmd = afterProgramming ? STOP : NONE;
 166
 167         if (afterProgramming)
 168                 remove(imagefile.c_str());
 169         if (!setupTty(cmd))
 170                 success = false;
 171
 172         controlCmd = NONE;
 173         return success ? SUCCESS : FAILURE;
 174 }
 175
 176
 177 status_t Mote::getStatus()
 178 {
 179         if (hasChild() && controlCmd == PROGRAM)
 180                 return MOTE_PROGRAMMING;
 181         if (!isOpen()) return MOTE_UNAVAILABLE;
 182         if (isRunning) return MOTE_RUNNING;
 183         return MOTE_STOPPED;
 184 }
 185
 186 const std::string& Mote::getControlCommand()
 187 {
 188         return hasChild() ? controlCmd : NONE;
 189 }
 190
 191
 192 const std::string& Mote::getMac()
 193 {
 194         return mac;
 195 }
 196
 197 const std::string& Mote::getDevicePath()
 198 {
 199         return path;
 200 }
 201
 202 const std::string& Mote::getPlatform()
 203 {
 204         return platform;
 205 }
 206
 207 }}