*/
#include "common.h"
#include "control.h"
-
-
-const char * g_actuator_names[NUMACTUATORS] = {
- "Pressure regulator", "Solenoid 1"
-};
-
-/*
-void ActuatorHandler(FCGIContext *context, ActuatorId id, const char *set_value) {
- char *ptr;
-
- switch(id) { //Add new actuators here
- case ACT_PRESSURE: //Suppose is pressure regulator. 0-700 input (kPa)
- {
- int value = strtol(set_value, &ptr, 10);
- if (*ptr == '\0' && value >= 0 && value <= 700) {
- FCGI_BeginJSON(context, STATUS_OK);
- FCGI_JSONKey("description");
- FCGI_JSONValue("\"Set pressure to %d kPa!\"", value);
- FCGI_EndJSON();
- } else {
- FCGI_RejectJSONEx(context,
- STATUS_ERROR, "Invalid pressure specified.");
- }
- } break;
- case ACT_SOLENOID1:
- {
- int value = strtol(set_value, &ptr, 10);
- if (*ptr == '\0') {
- const char *state = "off";
- if (value)
- state = "on";
- FCGI_BeginJSON(context, STATUS_OK);
- FCGI_JSONKey("description");
- FCGI_JSONValue("\"Solenoid 1 turned %s!\"", state);
- FCGI_EndJSON();
- } else {
- FCGI_RejectJSON(context, "Invalid actuator value specified");
- }
- } break;
- default:
- FCGI_RejectJSONEx(context,
- STATUS_ERROR, "Invalid actuator id specified.");
- }
-}*/
-
-typedef enum ControlState {
- STATE_STOPPED,
- STATE_PAUSED,
- STATE_RUNNING
-} ControlState;
+#include "sensor.h"
+#include "actuator.h"
typedef struct ControlData {
- ControlState state;
+ ControlModes current_mode;
pthread_mutex_t mutex;
struct timeval start_time;
} ControlData;
-ControlData g_controls = {STATE_STOPPED, PTHREAD_MUTEX_INITIALIZER, {0}};
+ControlData g_controls = {CONTROL_STOP, PTHREAD_MUTEX_INITIALIZER, {0}};
+
+static bool PathExists(const char *path) {
+ FILE *fp = fopen(path, "r");
+ if (fp) {
+ fclose(fp);
+ return true;
+ }
+ return false;
+}
/**
* System control handler. This covers high-level control, including
void Control_Handler(FCGIContext *context, char *params) {
const char *action, *key = "", *name = "";
bool force = false;
+ ControlModes desired_mode;
FCGIValue values[4] = {
{"action", &action, FCGI_REQUIRED(FCGI_STRING_T)},
if (!strcmp(action, "lock")) {
FCGI_LockControl(context, force);
+ return;
+ } else if (!strcmp(action, "emergency")) {
+ desired_mode = CONTROL_EMERGENCY;
+ } else if (!strcmp(action, "query")) {
+ FCGI_BeginJSON(context, STATUS_OK);
+ FCGI_JSONPair("state", Control_GetModeName(Control_GetMode()));
+ FCGI_EndJSON();
+ return;
} else if (FCGI_HasControl(context, key)) {
if (!strcmp(action, "release")) {
FCGI_ReleaseControl(context);
} else if (!strcmp(action, "start")) {
- FCGI_BeginJSON(context, STATUS_OK);
- FCGI_JSONPair("description", "start");
- FCGI_EndJSON();
+ desired_mode = CONTROL_START;
} else if (!strcmp(action, "pause")) {
- FCGI_BeginJSON(context, STATUS_OK);
- FCGI_JSONPair("description", "stop");
- FCGI_EndJSON();
- } else if (!strcmp(action, "end")) {
- FCGI_BeginJSON(context, STATUS_OK);
- FCGI_JSONPair("description", "stop");
- FCGI_EndJSON();
+ desired_mode = CONTROL_PAUSE;
+ } else if (!strcmp(action, "resume")) {
+ desired_mode = CONTROL_RESUME;
+ } else if (!strcmp(action, "stop")) {
+ desired_mode = CONTROL_STOP;
} else {
FCGI_RejectJSON(context, "Unknown action specified.");
+ return;
}
} else {
FCGI_RejectJSONEx(context, STATUS_UNAUTHORIZED,
"Invalid control key specified.");
+ return;
}
-}
-bool Control_Start(const char *experiment_name) {
- pthread_mutex_lock(&(g_controls.mutex));
- if (g_controls.state == STATE_STOPPED) {
- gettimeofday(&(g_controls.start_time), NULL);
- Sensor_StartAll(experiment_name);
- g_controls.state = STATE_RUNNING;
+ void *arg = NULL;
+ if (desired_mode == CONTROL_START) {
+ int len = strlen(name);
+ if (len <= 0) {
+ FCGI_RejectJSON(context, "An experiment name must be specified.");
+ return;
+ } else if (PathExists(name) && !force) {
+ FCGI_RejectJSON(context, "An experiment with that name already exists.");
+ return;
+ }
- pthread_mutex_unlock(&(g_controls.mutex));
- return true;
+ arg = (void*)name;
+ }
+
+ const char *ret;
+ if ((ret = Control_SetMode(desired_mode, arg)) != NULL) {
+ FCGI_RejectJSON(context, ret);
+ } else {
+ FCGI_BeginJSON(context, STATUS_OK);
+ FCGI_JSONPair("description", "ok");
+ FCGI_EndJSON();
}
- return false;
- pthread_mutex_unlock(&(g_controls.mutex));
}
-void Control_Pause() {
+/**
+ * Sets the mode to the desired mode, if possible.
+ * @param desired_mode The mode to be set to
+ * @param arg An argument specific to the mode to be set.
+ * @return NULL on success, an error message on failure.
+ */
+const char* Control_SetMode(ControlModes desired_mode, void * arg)
+{
+ const char *ret = NULL;
+
pthread_mutex_lock(&(g_controls.mutex));
+ if (g_controls.current_mode == CONTROL_EMERGENCY && desired_mode != CONTROL_STOP) {
+ ret = "In emergency mode. Stop before doing anything else.";
+ } else if (g_controls.current_mode == desired_mode) {
+ ret = "Already in desired mode.";
+ } else if (desired_mode == CONTROL_START) {
+ if (g_controls.current_mode == CONTROL_STOP) {
+ //TODO Sanitise name (ensure it contains no special chars eg \ / .. .
+ FILE *fp = fopen((const char*) arg, "a");
+ if (fp) {
+ fclose(fp);
+ gettimeofday(&(g_controls.start_time), NULL);
+ } else {
+ ret = "Cannot open experiment name marker";
+ }
+ } else {
+ ret = "Cannot start when not in a stopped state.";
+ }
+ } else if (desired_mode == CONTROL_RESUME) {
+ if (g_controls.current_mode != CONTROL_PAUSE)
+ ret = "Cannot resume when not in a paused state.";
+ }
+
+ if (ret == NULL) {
+ Actuator_SetModeAll(desired_mode, arg);
+ Sensor_SetModeAll(desired_mode, arg);
+ if (desired_mode != CONTROL_RESUME)
+ g_controls.current_mode = desired_mode;
+ else
+ g_controls.current_mode = CONTROL_START;
+ }
pthread_mutex_unlock(&(g_controls.mutex));
+ return ret;
}
-bool Control_End() {
- pthread_mutex_lock(&(g_controls.mutex));
- if (g_controls.state != STATE_STOPPED) {
- Sensor_StopAll();
- g_controls.state = STATE_STOPPED;
+/**
+ * Gets the current mode.
+ * @return The current mode
+ */
+ControlModes Control_GetMode() {
+ return g_controls.current_mode;
+}
- pthread_mutex_unlock(&(g_controls.mutex));
- return true;
+/**
+ * Gets a string representation of a mode
+ * @param mode The mode to get a string representation of
+ * @return The string representation of the mode
+ */
+const char * Control_GetModeName(ControlModes mode) {
+ const char * ret = "Unknown";
+
+ switch (mode) {
+ case CONTROL_START: ret = "Running"; break;
+ case CONTROL_PAUSE: ret = "Paused"; break;
+ case CONTROL_RESUME: ret = "Resumed"; break;
+ case CONTROL_STOP: ret = "Stopped"; break;
+ case CONTROL_EMERGENCY: ret = "Emergency mode"; break;
}
- pthread_mutex_unlock(&(g_controls.mutex));
+ return ret;
+}
+
+/*
+bool Control_Lock() {
+ pthread_mutex_lock(&(g_controls.mutex));
+ if (g_controls.state == STATE_RUNNING || g_controls.state == STATE_PAUSED)
+ return true;
+ pthread_mutex_unlock(&(g_controls.mutex));
return false;
}
+
+void Control_Unlock() {
+ pthread_mutex_unlock(&(g_controls.mutex));
+}*/
+
+/**
+ * Gets the start time for the current experiment
+ * @return the start time
+ */
+const struct timeval* Control_GetStartTime() {
+ return &g_controls.start_time;
+}
\ No newline at end of file