Use experiment folders instead of chdir
[matches/MCTX3420.git] / server / sensor.c
1 /**
2  * @file sensor.c
3  * @brief Implementation of sensor thread
4  * TODO: Finalise implementation
5  */
6
7 #include "common.h"
8 #include "sensor.h"
9 #include "options.h"
10 #include "bbb_pin.h"
11 #include <math.h>
12
13 /** Array of sensors, initialised by Sensor_Init **/
14 static Sensor g_sensors[SENSORS_MAX];
15 /** The number of sensors **/
16 int g_num_sensors = 0;
17
18
19
20 /** 
21  * Add and initialise a Sensor
22  * @param name - Human readable name of the sensor
23  * @param user_id - User identifier
24  * @param read - Function to call whenever the sensor should be read
25  * @param init - Function to call to initialise the sensor (may be NULL)
26  * @param max_error - Maximum error threshold; program will exit if this is exceeded for the sensor reading
27  * @param min_error - Minimum error threshold; program will exit if the sensor reading falls below this value
28  * @param max_warn - Maximum warning threshold; program will log warnings if the value exceeds this threshold
29  * @param min_warn - Minimum warning threshold; program will log warnings if the value falls below this threshold
30  * @returns Number of actuators added so far
31  */
32 int Sensor_Add(const char * name, int user_id, ReadFn read, InitFn init, CleanFn cleanup, SanityFn sanity)
33 {
34         if (++g_num_sensors > SENSORS_MAX)
35         {
36                 Fatal("Too many sensors; Increase SENSORS_MAX from %d in sensor.h and recompile", SENSORS_MAX);
37                 // We could design the program to use realloc(3)
38                 // But since someone who adds a new sensor has to recompile the program anyway...
39         }
40         Sensor * s = &(g_sensors[g_num_sensors-1]);
41
42         s->id = g_num_sensors-1;
43         s->user_id = user_id;
44         Data_Init(&(s->data_file));
45         s->name = name;
46         s->read = read; // Set read function
47         s->init = init; // Set init function
48
49         // Start by averaging values taken over a second
50         s->sample_us = 1e6;
51         s->averages = 1;
52
53         // Set sanity function
54         s->sanity = sanity;
55
56         if (init != NULL)
57         {
58                 if (!init(name, user_id))
59                         Fatal("Couldn't init sensor %s", name);
60         }
61
62
63         return g_num_sensors;
64 }
65
66 /**
67  * Initialise all sensors used by the program
68  * TODO: Edit this to add any extra sensors you need
69  * TODO: Edit the includes as well
70  */
71 #include "sensors/resource.h"
72 #include "sensors/strain.h"
73 #include "sensors/pressure.h"
74 void Sensor_Init()
75 {
76         Sensor_Add("cpu_stime", RESOURCE_CPU_SYS, Resource_Read, NULL, NULL, NULL);     
77         Sensor_Add("cpu_utime", RESOURCE_CPU_USER, Resource_Read, NULL, NULL, NULL);    
78         Sensor_Add("pressure_high0", PRES_HIGH0, Pressure_Read, Pressure_Init, Pressure_Cleanup, NULL);
79         Sensor_Add("pressure_high1", PRES_HIGH1, Pressure_Read, Pressure_Init, Pressure_Cleanup, NULL);
80         Sensor_Add("pressure_low0", PRES_LOW0, Pressure_Read, Pressure_Init, Pressure_Cleanup, NULL);
81         //Sensor_Add("../testing/count.py", 0, Piped_Read, Piped_Init, Piped_Cleanup, 1e50,-1e50,1e50,-1e50);
82         //Sensor_Add("strain0", STRAIN0, Strain_Read, Strain_Init, 5000,0,5000,0);
83         //Sensor_Add("strain1", STRAIN1, Strain_Read, Strain_Init, 5000,0,5000,0);
84         //Sensor_Add("strain2", STRAIN2, Strain_Read, Strain_Init, 5000,0,5000,0);
85         //Sensor_Add("strain3", STRAIN3, Strain_Read, Strain_Init, 5000,0,5000,0);
86         //Sensor_Add("pressure0", PRESSURE0, Pressure_Read, Pressure_Init, 5000,0,5000,0);
87         //Sensor_Add("pressure1", PRESSURE1, Pressure_Read, Pressure_Init, 5000,0,5000,0);
88         //Sensor_Add("pressure_feedback", PRESSURE_FEEDBACK, Pressure_Read, Pressure_Init, 5000,0,5000,0);
89         //Sensor_Add("enclosure", ENCLOSURE, Enclosure_Read, Enclosure_Init, 1,1,1,1);
90         //Sensor_Add("dilatometer", DILATOMETER, Dilatometer_Read, Dilatometer_Init, -1,-1,-1,-1);
91 }
92
93 /**
94  * Cleanup all sensors
95  */
96 void Sensor_Cleanup()
97 {
98         for (int i = 0; i < g_num_sensors; ++i)
99         {
100                 Sensor * s = g_sensors+i;
101                 if (s->cleanup != NULL)
102                         s->cleanup(s->user_id);
103         }
104 }
105
106 /**
107  * Sets the sensor to the desired control mode. No checks are
108  * done to see if setting to the desired mode will conflict with
109  * the current mode - the caller must guarantee this itself.
110  * @param s The sensor whose mode is to be changed
111  * @param mode The mode to be changed to
112  * @param arg An argument specific to the mode to be set. 
113  *            e.g for CONTROL_START it represents the experiment name.
114  */
115 void Sensor_SetMode(Sensor * s, ControlModes mode, void * arg)
116 {
117         switch(mode)
118         {
119                 case CONTROL_START:
120                         {
121                                 // Set filename
122                                 char filename[BUFSIZ];
123                                 const char *experiment_path = (const char*) arg;
124                                 int ret;
125
126                                 ret = snprintf(filename, BUFSIZ, "%s/sensor_%d", experiment_path, s->id);
127
128                                 if (ret >= BUFSIZ) 
129                                 {
130                                         Fatal("Experiment path \"%s\" too long (%d, limit %d)",
131                                                         experiment_path, ret, BUFSIZ);
132                                 }
133
134                                 Log(LOGDEBUG, "Sensor %d with DataFile \"%s\"", s->id, filename);
135                                 // Open DataFile
136                                 Data_Open(&(s->data_file), filename);
137                         }
138                 case CONTROL_RESUME: //Case fallthrough, no break before
139                         {
140                                 int ret;
141                                 s->activated = true; // Don't forget this!
142
143                                 // Create the thread
144                                 ret = pthread_create(&(s->thread), NULL, Sensor_Loop, (void*)(s));
145                                 if (ret != 0)
146                                 {
147                                         Fatal("Failed to create Sensor_Loop for Sensor %d", s->id);
148                                 }
149
150                                 Log(LOGDEBUG, "Resuming sensor %d", s->id);
151                         }
152                 break;
153
154                 case CONTROL_EMERGENCY:
155                 case CONTROL_PAUSE:
156                         s->activated = false;
157                         pthread_join(s->thread, NULL);
158                         Log(LOGDEBUG, "Paused sensor %d", s->id);
159                 break;
160                 
161                 case CONTROL_STOP:
162                         if (s->activated) //May have been paused before
163                         {
164                                 s->activated = false;
165                                 pthread_join(s->thread, NULL);
166                         }
167
168                         Data_Close(&(s->data_file)); // Close DataFile
169                         Log(LOGDEBUG, "Stopped sensor %d", s->id);
170                 break;
171                 default:
172                         Fatal("Unknown control mode: %d", mode);
173         }
174 }
175
176 /**
177  * Sets all sensors to the desired mode. 
178  * @see Sensor_SetMode for more information.
179  * @param mode The mode to be changed to
180  * @param arg An argument specific to the mode to be set.
181  */
182 void Sensor_SetModeAll(ControlModes mode, void * arg)
183 {
184         for (int i = 0; i < g_num_sensors; i++)
185                 Sensor_SetMode(&g_sensors[i], mode, arg);
186 }
187
188
189 /**
190  * Record data from a single Sensor; to be run in a seperate thread
191  * @param arg - Cast to Sensor* - Sensor that the thread will handle
192  * @returns NULL (void* required to use the function with pthreads)
193  */
194 void * Sensor_Loop(void * arg)
195 {
196         Sensor * s = (Sensor*)(arg);
197         Log(LOGDEBUG, "Sensor %d starts", s->id);
198
199         // Until the sensor is stopped, record data points
200         while (s->activated)
201         {
202                 DataPoint d;
203                 d.value = 0;
204                 bool success = s->read(s->user_id, &(d.value));
205
206                 struct timeval t;
207                 gettimeofday(&t, NULL);
208                 d.time_stamp = TIMEVAL_DIFF(t, *Control_GetStartTime());        
209                 
210                 if (success)
211                 {
212                         if (s->sanity != NULL)
213                         {
214                                 if (!s->sanity(s->user_id, d.value))
215                                 {
216                                         Fatal("Sensor %s (%d,%d) reads unsafe value", s->name, s->id, s->user_id);
217                                 }
218                         }
219                         Data_Save(&(s->data_file), &d, 1); // Record it
220                 }
221                 else
222                         Log(LOGWARN, "Failed to read sensor %s (%d,%d)", s->name, s->id,s->user_id);
223
224                 usleep(s->sample_us);
225         }
226         
227         // Needed to keep pthreads happy
228         Log(LOGDEBUG, "Sensor %s (%d,%d) finished", s->name,s->id,s->user_id);
229         return NULL;
230 }
231
232 /**
233  * Get a Sensor given its name
234  * @returns Sensor with the given name, NULL if there isn't one
235  */
236 Sensor * Sensor_Identify(const char * name)
237 {       
238         for (int i = 0; i < g_num_sensors; ++i)
239         {
240                 if (strcmp(g_sensors[i].name, name) == 0)
241                         return &(g_sensors[i]);
242         }
243         return NULL;
244 }
245
246 /**
247  * Helper: Begin sensor response in a given format
248  * @param context - the FCGIContext
249  * @param id - ID of sensor
250  * @param format - Format
251  */
252 void Sensor_BeginResponse(FCGIContext * context, Sensor * s, DataFormat format)
253 {
254         // Begin response
255         switch (format)
256         {
257                 case JSON:
258                         FCGI_BeginJSON(context, STATUS_OK);
259                         FCGI_JSONLong("id", s->id);
260                         FCGI_JSONLong("user_id", s->user_id); //NOTE: Might not want to expose this?
261                         FCGI_JSONPair("name", s->name);
262                         break;
263                 default:
264                         FCGI_PrintRaw("Content-type: text/plain\r\n\r\n");
265                         break;
266         }
267 }
268
269 /**
270  * Helper: End sensor response in a given format
271  * @param context - the FCGIContext
272  * @param id - ID of the sensor
273  * @param format - Format
274  */
275 void Sensor_EndResponse(FCGIContext * context, Sensor * s, DataFormat format)
276 {
277         // End response
278         switch (format)
279         {
280                 case JSON:
281                         FCGI_EndJSON();
282                         break;
283                 default:
284                         break;
285         }
286 }
287
288 /**
289  * Handle a request to the sensor module
290  * @param context - The context to work in
291  * @param params - Parameters passed
292  */
293 void Sensor_Handler(FCGIContext *context, char * params)
294 {
295         struct timeval now;
296         gettimeofday(&now, NULL);
297         double current_time = TIMEVAL_DIFF(now, *Control_GetStartTime());
298         int id = 0;
299         const char * name = "";
300         double start_time = 0;
301         double end_time = current_time;
302         const char * fmt_str;
303         double sample_s = 0;
304
305         // key/value pairs
306         FCGIValue values[] = {
307                 {"id", &id, FCGI_INT_T}, 
308                 {"name", &name, FCGI_STRING_T},
309                 {"format", &fmt_str, FCGI_STRING_T}, 
310                 {"start_time", &start_time, FCGI_DOUBLE_T}, 
311                 {"end_time", &end_time, FCGI_DOUBLE_T},
312                 {"sample_s", &sample_s, FCGI_DOUBLE_T}
313         };
314
315         // enum to avoid the use of magic numbers
316         typedef enum {
317                 ID,
318                 NAME,
319                 FORMAT,
320                 START_TIME,
321                 END_TIME,
322                 SAMPLE_S
323         } SensorParams;
324         
325         // Fill values appropriately
326         if (!FCGI_ParseRequest(context, params, values, sizeof(values)/sizeof(FCGIValue)))
327         {
328                 // Error occured; FCGI_RejectJSON already called
329                 return;
330         }
331
332         Sensor * s = NULL;
333         if (FCGI_RECEIVED(values[NAME].flags))
334         {
335                 if (FCGI_RECEIVED(values[ID].flags))
336                 {
337                         FCGI_RejectJSON(context, "Can't supply both sensor id and name");
338                         return;
339                 }
340                 s = Sensor_Identify(name);
341                 if (s == NULL)
342                 {
343                         FCGI_RejectJSON(context, "Unknown sensor name");
344                         return;
345                 }
346         }
347         else if (!FCGI_RECEIVED(values[ID].flags))
348         {
349                 FCGI_RejectJSON(context, "No sensor id or name supplied");
350                 return;
351         }
352         else if (id < 0 || id >= g_num_sensors)
353         {
354                 FCGI_RejectJSON(context, "Invalid sensor id");
355                 return;
356         }
357         else
358         {
359                 s = &(g_sensors[id]);
360         }
361
362         // Adjust sample rate if necessary
363         if (FCGI_RECEIVED(values[SAMPLE_S].flags))
364         {
365                 if (sample_s < 0)
366                 {
367                         FCGI_RejectJSON(context, "Negative sampling speed!");
368                         return;
369                 }               
370                 s->sample_us = 1e6*sample_s;
371         }
372         
373         
374         DataFormat format = Data_GetFormat(&(values[FORMAT]));
375
376         // Begin response
377         Sensor_BeginResponse(context, s, format);
378
379         // Print Data
380         Data_Handler(&(s->data_file), &(values[START_TIME]), &(values[END_TIME]), format, current_time);
381         
382         // Finish response
383         Sensor_EndResponse(context, s, format);
384
385 }
386
387 /**
388  * Get the Name of a Sensor
389  * @param id - ID number
390  */
391 const char * Sensor_GetName(int id)
392 {
393         return g_sensors[id].name;
394 }
395
396
397

UCC git Repository :: git.ucc.asn.au