+++ /dev/null
-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)
- //requires PWM control
- //TBA, currently in a separate file
- //pwm_convert_duty(value); - convert input to required duty cycle
- //pwm_set_frequency(PWM_id, freq); - can be done during PWM setup, frequency won't change (50Hz?)
- //pwm_set_duty_cycle(PWM_id, duty_cycle); - this is the low/high percentage, will vary with input
- //may also need to set polarity?
- //if pwm is not setup, run setup functions first
- {
- 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:
- //requires digital control
- {
- int value = strtol(set_value, &ptr, 10);
- if (*ptr == '\0') {
- //code to set pin to value
- //move this to separate function, will need to be repeated
- int fd;
- char buffer[10];
- if ((fd = open("/sys/class/gpio/gpio50/value", O_WRONLY)) < 0) //randomly chose pin 50 (each pin can be mapped to a certain switch case as required)
- perror("Failed to open pin");
- if (value) {
- strncpy(buffer, "1", ARRAY_SIZE(buffer) - 1); //copy value to buffer
- } else {
- strncpy(buffer, "0", ARRAY_SIZE(buffer) - 1);
- }
- int write = write(fd, buffer, strlen(buffer)); //write buffer to pin
- if (write < 0) perror("Failed to write to pin");
- close(fd);
- //code for server
- 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.");
- }
-}
\ No newline at end of file
--- /dev/null
+#include "pwm.h"
+
+char pin_dir = "/sys/class/gpio/gpio"; //move these
+int pwm_active = 0;
+
+/** Sets a GPIO pin to the desired value
+* @param value - the value (1 or 0) to write to the pin
+* @param pin_num - the number of the pin (refer to electronics team)
+*/
+
+void SetPin(int value, int pin_num) {
+ int pin;
+ char buffer[10];
+ char pin_path[40];
+ snprintf(pin_path, sizeof(pin_path), "%s%d%s", pin_dir, pin_num, "/value"); //create pin path
+ pin = open(pin_path, O_WRONLY);
+ if (pin < 0) perror("Failed to open pin");
+ if (value) {
+ strncpy(buffer, "1", ARRAY_SIZE(buffer) - 1);
+ }
+ else {
+ strncpy(buffer, "0", ARRAY_SIZE(buffer) - 1);
+ }
+ int write = write(pin, buffer, strlen(buffer));
+ if (write < 0) perror ("Failed to write to pin");
+ close(pin);
+}
+
+//TODO: Be able to write to multiple PWM modules - easy to change
+// but current unsure about how many PWM signals we need
+
+/**
+ * Set an Actuator value
+ * @param a - The Actuator
+ * @param value - The value to set
+ */
+void Actuator_SetValue(Actuator * a, double value)
+{
+ // Set time stamp
+ struct timeval t;
+ gettimeofday(&t, NULL);
+
+ DataPoint d = {TIMEVAL_DIFF(t, g_options.start_time), value};
+ switch (a->id)
+ {
+ case ACTUATOR_TEST0: //Pressure regulator example - requires PWM, 0-1000kPa input
+ {
+ if (pwm_active == 0) { //if inactive, start the pwm module
+ pwm_init();
+ pwm_start();
+ pwm_set_period(FREQ); //50Hz defined in pwm header file
+ }
+ if(value >= 0 && value <= 700) {
+ double duty = value/1000 * 100; //convert pressure to duty percentage
+ pwm_set_duty((int)duty); //set duty percentage for actuator
+ }
+ } break;
+ case ACTUATOR_TEST1:
+ {
+ SetPin(value, 1); //Digital switch example - "1" is the pin number, to be specified by electronics team
+ } break;
+ }
+
+ Log(LOGDEBUG, "Actuator %s set to %f", g_actuator_names[a->id], value);
+
+ // Record the value
+ Data_Save(&(a->data_file), &d, 1);
+}
\ No newline at end of file
-DataPoint * GetData(int sensor_id, DataPoint * d)
-{
- //TODO: We should ensure the time is *never* allowed to change on the server if we use gettimeofday
- // Another way people might think of getting the time is to count CPU cycles with clock()
- // But this will not work because a) CPU clock speed may change on some devices (RPi?) and b) It counts cycles used by all threads
- gettimeofday(&(d->time_stamp), NULL);
+char adc_dir = "/sys/devices/platform/tsc/ain";
+char pin_dir = "/sys/class/gpio/gpio";
+
+/** Open an ADC and return the voltage value from it
+* @param adc_num - ADC number, ranges from 0 to 7 on the Beaglebone
+ @return the converted voltage value if successful
+*/
+
+//TODO: create a function to lookup the ADC or pin number instead of manually
+// specifying it here (so we can keep all the numbers in one place)
+
+int OpenAnalog(int adc_num)
+{
+ char adc_path[40];
+ snprintf(adc_path, sizeof(adc_path), "%s%d", adc_dir, adc_num); //construct ADC path
+ int sensor = open(adc_path, O_RDONLY);
+ char buffer[128]; //I think ADCs are only 12 bits (0-4096)
+ int read = read(sensor, buffer, sizeof(buffer); //buffer can probably be smaller
+ if (read != -1) {
+ buffer[read] = NULL;
+ int value = atoi(buffer);
+ double convert = (value/4096) * 1000; //random conversion factor, will be different for each sensor
+ //lseek(sensor, 0, 0);
+ close(sensor);
+ return convert;
+ }
+ else {
+ perror("Failed to get value from sensor");
+ close(sensor);
+ return -1;
+ }
+}
+
+/** Open a digital pin and return the value from it
+* @param pin_num - pin number, specified by electronics team
+ @return 1 or 0 if reading was successful
+*/
+
+int OpenDigital(int pin_num)
+{
+ char pin_path[40];
+ snprintf(pin_path, sizeof(pin_path), "%s%d%s", pin_dir, pin_num, "/value"); //construct pin path
+ int pin = open(pin_path, O_RDONLY);
+ char ch;
+ lseek(fd, 0, SEEK_SET);
+ int read = read(pin, &ch, sizeof(ch);
+ if (read != -1) {
+ if (ch != '0') {
+ close(pin);
+ return 1;
+ }
+ else {
+ close(pin);
+ return 0;
+ }
+ else {
+ perror("Failed to get value from pin");
+ close(pin);
+ return -1;
+ }
+}
+
+/**
+ * Read a DataPoint from a Sensor; block until value is read
+ * @param id - The ID of the sensor
+ * @param d - DataPoint to set
+ * @returns True if the DataPoint was different from the most recently recorded.
+ */
+bool Sensor_Read(Sensor * s, DataPoint * d)
+{
- switch (sensor_id)
+ // Set time stamp
+ struct timeval t;
+ gettimeofday(&t, NULL);
+ d->time_stamp = TIMEVAL_DIFF(t, g_options.start_time);
+
+ // Read value based on Sensor Id
+ switch (s->id)
{
- //TODO: test buffer size on actual hardware
- // maybe map the sensor path to an array/structure that can be looked up via sensor_id?
- // not sure about the best place to do unit conversions, especially for nonlinear sensors
- case SENSOR_TEST0:
+ case ANALOG_TEST0:
+ d->value = OpenAnalog(0); //ADC #0 on the Beaglebone
+ break;
+ case ANALOG_TEST1:
{
- int sensor = open("/sys/devices/platform/tsc/ain0", O_RDONLY); //need unique path for each sensor ADC, check path in documentation
- char buffer[128]; //ADCs on Beaglebone are 12 bits?
- int read = read(sensor, buffer, sizeof(buffer);
- if (read != -1) {
- buffer[read] = NULL; //string returned by read is not null terminated
- int value = atoi(buffer);
- double convert = (value/4096) * 1800; //sample conversion from ADC input to 'true value'
- d->value = convert;
- lseek(sensor, 0, 0); //after read string must be rewound to start of file using lseek
- }
- else {
- perror("Failed to get value from sensor");
- }
- close(sensor);
+ d->value = OpenAnalog(1);
break;
}
- case SENSOR_TEST1:
- int sensor = open("/sys/devices/platform/tsc/ain1", O_RDONLY);
- char buffer[128];
- int read = read(sensor, buffer, sizeof(buffer);
- if (read != -1) {
- buffer[read] = NULL;
- int value = atoi(buffer);
- double convert = (value/4096) * 1800;
- d->value = convert;
- lseek(sensor, 0, 0);
- }
- else {
- perror("Failed to get value from sensor");
- }
- close(sensor);
+ case ANALOG_FAIL0:
+ d->value = (double)(rand() % 6) * -( rand() % 2) / ( rand() % 100 + 1);
+ //Gives a value between -5 and 5
break;
- break;
- }
- //TODO: think about a better way to address individual pins
- // i.e. pass an int to a separate function that builds the correct filename
- // doesn't really matter if the pins we're using are fixed though
case DIGITAL_TEST0:
- int fd = open("/sys/class/gpio/gpio17/value", O_RDONLY) //again need the right addresses for each pin
- char ch; //just one character for binary info
- lseek(fd, 0, SEEK_SET);
- int read = read(fd, &ch, sizeof(ch);
- if (read != -1) {
- if (ch != '0') {
- d->value = 1;
- }
- else {
- d->value = 0;
- }
- }
- else {
- perror("Failed to get value from pin");
- }
+ d->value = openDigital(0); //replace 0 with correct pin number
break;
case DIGITAL_TEST1:
- int fd = open("/sys/class/gpio/gpio23/value", O_RDONLY)
- char ch;
- lseek(fd, 0, SEEK_SET);
- int read = read(fd, &ch, sizeof(ch);
- if (read != -1) {
- if (ch != '0') {
- d->value = 1;
- }
- else {
- d->value = 0;
- }
- }
- else {
- perror("Failed to get value from pin");
- }
+ d->value = openDigital(1); //replace 1 with correct pin number
+ break;
+ case DIGITAL_FAIL0:
+ if( rand() % 100 > 98)
+ d->value = 2;
+ d->value = rand() % 2;
+ //Gives 0 or 1 or a 2 every 1/100 times
break;
default:
- Fatal("Unknown sensor id: %d", sensor_id);
+ Fatal("Unknown sensor id: %d", s->id);
break;
}
usleep(100000); // simulate delay in sensor polling
- return d;
+ // Perform sanity check based on Sensor's ID and the DataPoint
+ Sensor_CheckData(s->id, d->value);
+
+ // Update latest DataPoint if necessary
+ bool result = (d->value != s->newest_data.value);
+ if (result)
+ {
+ s->newest_data.time_stamp = d->time_stamp;
+ s->newest_data.value = d->value;
+ }
+ return result;
}
\ No newline at end of file
+++ /dev/null
-#include "pwm.h"
-
-/* Initialize PWM :
-1/ mmap /dev/mem to have write access to system clock
-2/ enable system clock (0x0 = disabled, 0x02 = enabled)
-3/ set correct pin MUX
-
-can modify pwm variables through virtual filesystem:
-"/sys/class/pwm/ehrpwm.1:0/..."
-
-pwm drivers reference:
-http://processors.wiki.ti.com/index.php/AM335x_PWM_Driver%27s_Guide */
-
-void pwm_init(void)
-{
- FILE *pwm_mux;
- int i;
- volatile uint32_t *epwmss1;
-
- int fd = open("/dev/mem", O_RDWR);
-
- if(fd < 0)
- {
- printf("Can't open /dev/mem\n");
- exit(1);
- }
-
- epwmss1 = (volatile uint32_t *) mmap(NULL, LENGTH, PROT_READ|PROT_WRITE, MAP_SHARED, fd, START);
- if(epwmss1 == NULL)
- {
- printf("Can't mmap\n");
- exit(1);
- }
- else
- {
- epwmss1[OFFSET_1 / sizeof(uint32_t)] = 0x2;
- }
- close(fd);
-
- pwm_mux = fopen("/sys/kernel/debug/omap_mux/gpmc_a2", "w");
- fprintf(pwm_mux, "6"); // pwm is mux mode 6
- fclose(pwm_mux);
-}
-
-//can change filepath of pwm module "/ehrpwm.%d:0/" by passing %d as argument
-//depends how many pwm modules we have to run
-//TODO:
-
-void pwm_start(void)
-{
- FILE *pwm_run;
- pwm_run = fopen("/sys/class/pwm/ehrpwm.1:0/run", "w");
- fprintf(pwm_run, "1");
- fclose(pwm_run);
-}
-
-void pwm_stop(void)
-{
- FILE *pwm_run;
-
- pwm_run = fopen("/sys/class/pwm/ehrpwm.1:0/run", "w");
- fprintf(pwm_run, "0");
- fclose(pwm_run);
-}
-
-//duty_percent is just a regular percentage (i.e. 50 = 50%)
-
-void pwm_set_duty(int duty_percent)
-{
- FILE *pwm_duty;
-
- pwm_duty = fopen("/sys/class/pwm/ehrpwm.1:0/duty_percent", "w");
- fprintf(pwm_duty, "%d", duty_percent);
- fclose(pwm_duty);
-}
-
-//freq is just normal frequency (i.e. 100 = 100Hz)
-
-void pwm_set_period(int freq)
-{
- FILE *pwm_period;
-
- pwm_period = fopen("/sys/class/pwm/ehrpwm.1:0/period_freq", "w");
- fprintf(pwm_period, "%d", freq);
- fclose(pwm_period);
-}
\ No newline at end of file
+++ /dev/null
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <sys/wait.h>
-#include <sched.h>
-#include <stdint.h>
-
-#define START 0x44e00000 // see datasheet of AM335x
-#define LENGTH 1024
-#define OFFSET_1 0xcc // offset of PWM1 clock (see datasheet of AM335x p.1018)
-
-void pwm_init(void);
-void pwm_start(void);
-void pwm_stop(void);
-void pwm_set_duty(int duty_percent);
-void pwm_set_period(int freq);
\ No newline at end of file
--- /dev/null
+#include "pwm.h"
+
+char pin_dir = "/sys/class/gpio/gpio";
+int pwm_active = 0;
+
+/** Sets a GPIO pin to the desired value
+* @param value - the value (1 or 0) to write to the pin
+* @param pin_num - the number of the pin (refer to electronics team)
+*/
+
+void SetPin(int value, int pin_num) {
+ int pin;
+ char buffer[10];
+ char pin_path[40];
+ snprintf(pin_path, sizeof(pin_path), "%s%d%s", pin_dir, pin_num, "/value"); //create pin path
+ pin = open(pin_path, O_WRONLY);
+ if (pin < 0) perror("Failed to open pin");
+ if (value) {
+ strncpy(buffer, "1", ARRAY_SIZE(buffer) - 1);
+ }
+ else {
+ strncpy(buffer, "0", ARRAY_SIZE(buffer) - 1);
+ }
+ int write = write(pin, buffer, strlen(buffer));
+ if (write < 0) perror ("Failed to write to pin");
+ close(pin);
+}
+
+//TODO: Be able to write to multiple PWM modules - easy to change
+// but current unsure about how many PWM signals we need
+
+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)
+ {
+ if (pwm_active == 0) { //if inactive, start the pwm module
+ pwm_init();
+ pwm_start();
+ pwm_set_period(FREQ); //50Hz defined in pwm header file
+ }
+ int value = strtol(set_value, &ptr, 10);
+ //Beaglebone code
+ if(value >= 0 && value <= 700) {
+ double duty = value/700 * 100; //convert pressure to duty percentage
+ pwm_set_duty((int)duty); //set duty percentage for actuator
+ }
+ //server code
+ 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') {
+ //code to set pin to value
+ SetPin(value, 1); //"1" will need to be changed to pin numbers decided by electronics team
+ //code for server
+ 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.");
+ }
+}
\ No newline at end of file
--- /dev/null
+#include "pwm.h"
+
+/* Initialize PWM :
+1/ mmap /dev/mem to have write access to system clock
+2/ enable system clock (0x0 = disabled, 0x02 = enabled)
+3/ set correct pin MUX
+
+can modify pwm variables through virtual filesystem:
+"/sys/class/pwm/ehrpwm.1:0/..."
+
+pwm drivers reference:
+http://processors.wiki.ti.com/index.php/AM335x_PWM_Driver%27s_Guide */
+
+void pwm_init(void)
+{
+ FILE *pwm_mux;
+ int i;
+ volatile uint32_t *epwmss1;
+
+ int fd = open("/dev/mem", O_RDWR);
+
+ if(fd < 0)
+ {
+ printf("Can't open /dev/mem\n");
+ exit(1);
+ }
+
+ epwmss1 = (volatile uint32_t *) mmap(NULL, LENGTH, PROT_READ|PROT_WRITE, MAP_SHARED, fd, START);
+ if(epwmss1 == NULL)
+ {
+ printf("Can't mmap\n");
+ exit(1);
+ }
+ else
+ {
+ epwmss1[OFFSET_1 / sizeof(uint32_t)] = 0x2;
+ }
+ close(fd);
+
+ pwm_mux = fopen("/sys/kernel/debug/omap_mux/gpmc_a2", "w");
+ fprintf(pwm_mux, "6"); // pwm is mux mode 6
+ fclose(pwm_mux);
+}
+
+//can change filepath of pwm module "/ehrpwm.%d:0/" by passing %d as argument
+//depends how many pwm modules we have to run
+//TODO:
+
+void pwm_start(void)
+{
+ FILE *pwm_run;
+ pwm_run = fopen("/sys/class/pwm/ehrpwm.1:0/run", "w");
+ fprintf(pwm_run, "1");
+ fclose(pwm_run);
+}
+
+void pwm_stop(void)
+{
+ FILE *pwm_run;
+
+ pwm_run = fopen("/sys/class/pwm/ehrpwm.1:0/run", "w");
+ fprintf(pwm_run, "0");
+ fclose(pwm_run);
+}
+
+//duty_percent is just a regular percentage (i.e. 50 = 50%)
+
+void pwm_set_duty(int duty_percent)
+{
+ FILE *pwm_duty;
+
+ pwm_duty = fopen("/sys/class/pwm/ehrpwm.1:0/duty_percent", "w");
+ fprintf(pwm_duty, "%d", duty_percent);
+ fclose(pwm_duty);
+}
+
+//freq is just normal frequency (i.e. 100 = 100Hz)
+
+void pwm_set_period(int freq)
+{
+ FILE *pwm_period;
+
+ pwm_period = fopen("/sys/class/pwm/ehrpwm.1:0/period_freq", "w");
+ fprintf(pwm_period, "%d", freq);
+ fclose(pwm_period);
+}
\ No newline at end of file
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+#include <sched.h>
+#include <stdint.h>
+
+#define START 0x44e00000 // see datasheet of AM335x
+#define LENGTH 1024
+#define OFFSET_1 0xcc // offset of PWM1 clock (see datasheet of AM335x p.1018)
+#define FREQ 50 //50Hz pwm frequency for pressure regulator
+
+void pwm_init(void);
+void pwm_start(void);
+void pwm_stop(void);
+void pwm_set_duty(int duty_percent);
+void pwm_set_period(int freq);
\ No newline at end of file
19:56 < jtanx> then at least you're guaranteed that user input won't stuff up anything
19:56 < jtanx> (as in making it generate invalid JSON)
20:53 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Sat Sep 14 2013
+11:32 < sam_moore> blergh, too many different versions of OpenCV
+11:32 < sam_moore> Also too many different data types
+11:33 < sam_moore> "Getting a digital image into numbers can be very handy for your image processing. In this post i will brief just that."
+11:34 < sam_moore> Thank god, finally a tutorial that makes sense
+11:34 -!- Irssi: #mctxuwa_softdev: Total of 2 nicks [0 ops, 0 halfops, 0 voices, 2 normal]
+11:34 < sam_moore> ... no one else is in the channel
+11:34 < sam_moore> :S
+12:36 < jtanx> on start/stop/pausing an experiment
+12:36 < jtanx> currently everything is relative to g_options.start_time
+12:42 < sam_moore> Yeah
+12:43 < sam_moore> Perhaps make an ExperimentTime function and that leaves us free to change what the time stamps are relative to?
+12:43 < sam_moore> Looking into this interferometer stuff...
+12:43 < jtanx> ok, maybe as part of the Control_ module then
+12:43 < sam_moore> Interesting problem, I think I've worked out an algorithm that isn't too terrible
+12:44 < jtanx> yeah?
+12:44 < jtanx> how does it work
+12:45 < sam_moore> If you have a sinusoidal wave, find the x intercepts, and that lets you calculate the phase and frequency
+12:45 < sam_moore> That's the simple version
+12:46 < jtanx> haha alright
+12:46 < sam_moore> I have 3 pages of notes that I can show Adrian/Adam if I can't get it working
+12:46 < jtanx> wow
+12:46 < jtanx> nice work
+12:47 < sam_moore> Fortran would be good for the array operations
+12:47 < sam_moore> If fortran were able to do anything *other* than array operations it would be a nice language...
+12:47 < jtanx> have you ever used Fortan before?
+12:48 < sam_moore> Yes
+12:48 < sam_moore> I'm going to keep it in C though
+12:48 < sam_moore> It took long enough to get OpenCV working
+12:48 < sam_moore> I'm sure there's some kind of convoluted Fortran library
+12:49 < sam_moore> But a seperate fortran program won't talk to our server
+12:49 < jtanx> can you compile the code as a library with C interop
+12:49 < sam_moore> Erm..
+12:49 < sam_moore> Probably more effort than just doing it in C
+12:49 < jtanx> probably
+12:51 < jtanx> I think a separate mutex is needed around the *_Stop() functions
+12:51 < jtanx> because if a client sends in a request
+12:51 < sam_moore> Oh, good point
+12:52 < jtanx> although that's only going to be a problem if our own software calls the stop function because of the sanity checks
+12:52 < sam_moore> If there are 2 requests?
+12:52 < sam_moore> No wait, the FCGI stuff is serial
+12:52 < jtanx> the request loop is single threaded
+12:52 < sam_moore> It has to finish processing one request to respond to the next
+12:52 < sam_moore> That's fine
+12:56 < sam_moore> Put a mutex in the Sensor struct, use the same one that's already in the Actuator struct, put critical sections around setting the "s->record_data" or "a->activated" variables (or whatever you choose to use as a "is thing running" flag)
+12:56 < sam_moore> And check the flag hasn't already been set before doing anything
+12:57 < sam_moore> Similar to how the Thread_Running() and Thread_QuitProgram() functions used to work
+12:57 < sam_moore> .... Before I deleted them
+12:57 < sam_moore> Any thread could call Thread_QuitProgram, and repeated calls would have no effect
+13:01 < jtanx> ok I'll try that
+13:51 < jtanx> actually, what about this:
+13:51 < jtanx> in control.c, it maintains its own mutex
+13:51 < jtanx> so
+13:52 < jtanx> and it's the only place where Sensor_Start/Stop Actuator_Start/Stop is called
+13:53 < jtanx> You then have Control_Lock/Unlock that's placed around the responses in the handler functions
+13:53 < jtanx> those functions internally lock/unlock the mutex held in control.c
+13:53 < jtanx> ah stuff it
+13:53 < jtanx> I'll commit it to my git repo
+13:54 < jtanx> I still don't know how the pause functionality should be done though
+13:54 < jtanx> especially with the time discontinuities
+14:01 < jtanx> oh yeah, just a reminder that you have to be careful using FCGI_LONG_T vs FCGI_INT_T
+14:02 < jtanx> if your variable is of type int but you give FCGI_LONG_T, and where sizeof(int) != sizeof(long) then there could be a buffer overflow
+14:13 < sam_moore> Right
+14:14 < sam_moore> If you want to commit to the main repo you can use a new branch
+14:14 < sam_moore> Having a single mutex in control.c instead of one per sensor/actuator is probably better
+14:15 < sam_moore> With the pause functionality... I think if you just don't call Data_Close() (and don't call Data_Open on resuming) but otherwise stop the threads running Sensor_Loop in the same way
+14:15 < sam_moore> That should do most of it
+14:16 < sam_moore> Don't reset the experiment start time
+14:17 < sam_moore> Perhaps the experiment start time needs to be stored somewhere though
+14:18 < sam_moore> Anyway, I'll let you solve the problem :P
+14:48 < jtanx> ._.
+15:45 < jtanx> well I think I got something semi-working
+15:45 < jtanx> it involved adding on Sensor_PauseAll/ResumeAll + Acuator_PauseAll/ResmueAll (plus the individual Pause/Resume) functions
+15:46 < sam_moore> Cool
+15:46 < sam_moore> I think I'm starting to get my head around OpenCV
+15:46 < sam_moore> The documentation for it is a bit crap
+15:46 < jtanx> oh don't get me started on opencv documentation
+15:47 < jtanx> yesterday it took me and callum around 30 mins to figure out that CvMat structure
+15:47 < sam_moore> Haha
+15:47 < sam_moore> It probably took me a bit longer :S
+15:47 < jtanx> the problem is that most of it's geared towards c++ usage
+15:49 < jtanx> back on that control stuff, basically those Sensor/Actuator_[Start|Stop|Pause|Resume] functions can only be called via the Control_[Start|Stop|Pause|Resume] functions
+15:50 < jtanx> partly because of threading issues but also because it's the only place where the current state is currently kept track of
+15:51 < jtanx> (e.g if you call Sensor_Start twice then...
+15:53 < sam_moore> Seems sensible
+15:53 < jtanx> anyway, I'm taking a break from this stuff for a while
+15:53 < sam_moore> Yeah, fair enough
+15:54 < jtanx> If you want to see what I've done so far, it's on my git repo (haven't added comments yet)
+15:54 < sam_moore> Cool
+16:50 < sam_moore> The IplImage vs CvMat conversion is dumb
+16:50 < sam_moore> In fact I don't think you even need to do it?
+16:51 < sam_moore> Well at least to display an image you can just pass a CvMat
+16:51 < sam_moore> Maybe you still need the IplImage to capture from a camera
+16:51 < sam_moore> I worked out how to convert from IplImage to CvMat anyway
+16:53 < sam_moore> Other than that, OpenCV doesn't actually seem horrible to use
+16:53 < sam_moore> Just... contradictory documentation
+16:55 < sam_moore> Anyway... I've created a moving sinusoidal image!
+16:56 < sam_moore> Now to work out why the algorithm keeps returning -nan :S
+16:56 < sam_moore> Also for some reason the image is blue instead of red
+16:56 < sam_moore> But whatever
+16:57 < jtanx> :S
+16:57 < jtanx> BGR vs RGB?
+17:02 < sam_moore> Looks like it
+17:03 < sam_moore> Doing this with an actual camera is going to suck
+17:04 < sam_moore> See, I've worked out an algorithm to cope with changing background light conditions
+17:04 < sam_moore> Because differentiating a sinusoid gives you another sinusoid with the same phase (offset by pi/2)
+17:05 < sam_moore> Buut... differentiating with finite differences adds more noise
+17:05 < sam_moore> Or rather it makes the noise more pronounced
+17:07 < sam_moore> Hopefully sensors is considering this
+17:07 < sam_moore> If they want to shoot a laser into a camera, they should really do it in a way that keeps out background light
+17:07 < sam_moore> Buuut
+17:07 < sam_moore> I think they mentioned using one camera to do both the interferometer and look at the can
+17:07 < sam_moore> :S
+17:08 < sam_moore> Oh well, the optics is their problem
+17:09 < sam_moore> I suppose I will prepare a report or something about the algorithm and what conditions the image needs to satisfy
+17:12 < jtanx> um
+17:12 < jtanx> there's going to be two cameras
+17:12 < jtanx> because it was too much hassle moving it
+17:12 < sam_moore> Yes... but one was meant to be looking at each can?
+17:13 < jtanx> oh
+17:13 < jtanx> hmm
+17:13 < sam_moore> We should ask them
+17:13 < jtanx> I just thought that one would be for the interferometer (no need to look at can) and the other would be for the can to be blown up
+17:13 < sam_moore> Probably
+17:15 < jtanx> but I was thinking for the one to be blown up
+17:16 < jtanx> you could possibly just stream it using something like ffserver
+17:16 < jtanx> instead of passing it through opencv
+17:16 < sam_moore> Yeah, that seems like it's probably easier
+17:23 -!- jtanx [
[email protected]] has quit ["my antivirus is pestering me to restart"]
+18:19 < sam_moore> So... when you take an image with a camera the pixels are stored as rgb with 0->255 values
+18:20 < sam_moore> You can convert the IplImage to a CvMat and it keeps the values ordered as rgb with 0->255 values
+18:20 < sam_moore> And then...
+18:20 < sam_moore> If you try and display it...
+18:20 < sam_moore> The display function treats it as having values in bgr order with 0->1 values
+18:20 < sam_moore> -_-
+18:21 < sam_moore> (So unless you manually adjust all the values you'll just get a white picture in the display)
+18:54 < jtanx> hahaha
+18:54 < jtanx> what
+18:56 < jtanx> for cvShowImage:
+18:56 < jtanx> If the image is 8-bit unsigned, it is displayed as is.
+18:56 < jtanx> If the image is 16-bit unsigned or 32-bit integer, the pixels are divided by 256. That is, the value range [0,255*256] is mapped to [0,255].
+18:56 < jtanx> If the image is 32-bit floating-point, the pixel values are multiplied by 255. That is, the value range [0,1] is mapped to [0,255].
+18:57 < jtanx> so it's treating it as 32-bit floating point?
+20:41 < sam_moore> I think it's because of how I converted the IplImage to a CvMat
+20:42 < sam_moore> My algorithm is almost working
+20:43 < sam_moore> The fact that angles wrap around every 2*pi is giving me a headache though
+20:43 < sam_moore> This is pretty fun
+20:45 < sam_moore> Hopefully I can do Computer Vision as an optional, I think its in the list
+20:45 < sam_moore> Maybe I shouldn't make all my optionals CS units, but meh
+21:20 < jtanx> :P
+21:20 < jtanx> the computer vision unit sounds interesting, but a lot of maths/theory involved
+22:02 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Sun Sep 15 2013
+11:02 < sam_moore> I'm really glad I put the IRC logs under git
+11:02 < sam_moore> It's very helpful for keeping my diary up to date
+11:40 < jtanx> hehe
+11:40 < jtanx> I'm gladful for git
+11:48 < jtanx> about the bbb
+11:48 < jtanx> it's probably best to just install debian to the internal memory
+11:54 < jtanx> on the controls
+11:54 < jtanx> maybe we can have the following states: start/pause/resume/stop/close
+11:56 < jtanx> actually, maybe just start/pause/resume/close
+11:56 < jtanx> when an 'emergency stop' due to the sanity checks occurs
+11:57 < jtanx> actually, start/pause/resume/close/emergency
+11:57 < jtanx> start/pause/resume/close can only be initiated by the client
+11:58 < jtanx> emergency can be initiated by client/server
+11:58 < jtanx> in emergency, actuators are set as necessary then deactivated
+11:58 < jtanx> but importantly, the data files remain open, which hopefully removes the need for mutexes
+12:26 < sam_moore> That seems sensible
+13:20 < sam_moore> Hey
+13:20 < sam_moore> It's actually quite simple to stream an image through FastCGI
+13:21 < jtanx> yeah
+13:21 < jtanx> you just fwrite the image buffer
+13:21 < sam_moore> Yep
+13:21 < jtanx> I had some test code for that but could never test it
+13:22 < jtanx> no webcam
+13:22 < sam_moore> Ah, damn
+13:22 < sam_moore> I've written some code, it works pretty brilliantly
+13:22 < jtanx> nice
+13:22 < jtanx> this control code is really annoying me
+13:23 < jtanx> just all the considerations of if you need a mutex here or not and 'what happens if...'
+13:23 < sam_moore> Ah, sorry to hear that
+13:23 < jtanx> yeah nah its ok
+13:24 < jtanx> but that interferometer stuff you did looks really cool
+13:26 < sam_moore> Yeah, it worked surprisingly well
+13:26 < sam_moore> It can cope with a fair bit of background light, even without all the improvements I was thinking about
+13:27 < sam_moore> If I add 2 or 3 more columns to scan, and use the fact that we actually know the spatial frequency to eliminate nodes that are too close together
+13:27 < sam_moore> It should be pretty good
+13:27 < sam_moore> I'm not sure what the laser intensity will be, but the generated image looks similar to ones you can find on the internet
+13:28 < sam_moore> One possible problem is if the mirrors aren't flat enough
+13:28 < sam_moore> But hopefully it won't be a big issue (since they've pretty much just specified an expensive pre-built kit which presumably has flat mirrors)
+13:29 < jtanx> yeah
+13:30 < jtanx> here's to hoping 'it just works'
+13:30 < sam_moore> Yep :P
+13:31 < sam_moore> Got to go, bye
+13:32 < jtanx> ok cya
+15:56 -!- jtanx_ is now known as jtanx
+21:48 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Mon Sep 16 2013
+16:05 -!- jtanx_ [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+19:44 < jtanx> no mctxbot while I work on my f# project
+22:58 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
--- /dev/null
+Electronics
+ - What inputs will be provided
+ - 2x ADC channels, USB Hub (2 webcams?)
+ - What outputs are required
+ - 2x digital out for controlling multiplexers on ADCs
+ - Switch time for multiplexer? Affects sample rate
+ - 1x PWM to control DAC -> Analogue pressure regulator (?)
+ - 3x digital out for controlling solenoids
+ - Need to meet this week to work out sampling rate / antialiasing stuff
+ - Friday 12:00pm -> 2:00pm
+ - Wednesday 10:00am -> 11:00am
+ - Antialiasing: Need to sample at 2x rate we are interested in
+ - Accuracy of timestamps in software uncertain; should do some physical tests
+ - Estimates of BBB sampling rates vary, but from Jeremy's searches, the worst case:
+ - 34KHz for GPIO
+ - 100KHz for ADC
+
+Pneumatics
+ - What is being controlled -> Electronics
+ - Analogue controlled pressure regulator 0-5V
+ - 3 solenoids (on/off)
+ - Master valve (safety)
+ - 1 valve for each can (mutually exclusive, never allow both to be on at the same time) - need 12V for on, 20ms switch time, max freq 10Hz
+ - Electronics will probably use a multiplexer
+ - Will dump air when no power
+ - Diode protection needed
+ - When can fails, major drop in pressure will happen
+ - Should stop air supply when this is detected
+ - What is sensed?
+ - 3 x pressure sensors; 1 on main supply, 1 before each can
+ - Pressure limit of 100KPa on non-exploding can
+ - Safety threshold if sensor after this records > 100KPa
+ - No limit on exploding can
+ - Forgot to ask about *minimum* pressure values; use atmosphere (because if things fall below atmosphere they are probably broken)?
+
+Sensors
+ - Sensors -> Electronics -> Us
+ - Currently having argument with Adrian about use of interferometer or dilatometer
+ - Adrian will probably win the argument
+ - Image processing will be low priority for software until there is more certainty
+ - From a software point of view, interferometer and dilatometer are about the same difficulty
+ - Interferometer: Look for nodes (maximum change in intensity at laser wavelength)
+ - Dilatometer: Look for edge of can (maximum change in intensity of can colour)
+ - Laser light might be easier to process (larger intensity and larger intensity changes against dark background)
+ - But laser interferometer kit will definitely be harder to set up and align and position
+ - Sampling rate of images (stream only) - 20FPS (using Logicrap(TM) camera)
+
+
+Case
+ - The software will fit
+ - There will be a hole for an ethernet cable
# Makefile for server software
CXX = gcc
-FLAGS = -std=c99 -Wall -Werror -pedantic -g
-LIB = -lfcgi -lssl -lcrypto -lpthread -lm
-OBJ = log.o control.o data.o fastcgi.o main.o sensor.o actuator.o
+FLAGS = -std=c99 -Wall -pedantic -g -I/usr/include/opencv -I/usr/include/opencv2/highgui -L/usr/lib
+LIB = -lfcgi -lssl -lcrypto -lpthread -lm -lopencv_highgui -lopencv_core -lopencv_ml -lopencv_imgproc
+OBJ = log.o control.o data.o fastcgi.o main.o sensor.o actuator.o image.o
RM = rm -f
BIN = server
all : $(BIN) $(BIN2)
-#stream : stream.c
-# $(CXX) -o stream stream.c -I/usr/include/opencv -I/usr/include/opencv2/highgui -L/usr/lib -lopencv_highgui -lopencv_core -lopencv_ml -lopencv_imgproc -lm
+stream : stream.c
+ $(CXX) $(FLAGS) -o stream stream.c $(LIB)
+
+intertest : interferometer.c
+ $(CXX) $(FLAGS) -o intertest interferometer.c $(LIB)
$(BIN) : $(OBJ)
#include "actuator.h"
#include "control.h"
#include "options.h"
+#include "image.h"
/**The time period (in seconds) before the control key expires */
#define CONTROL_TIMEOUT 180
va_end(list);
}
+
+/**
+ * Write binary data
+ * See fwrite
+ */
+void FCGI_WriteBinary(void * data, size_t size, size_t num_elem)
+{
+ Log(LOGDEBUG,"Writing!");
+ fwrite(data, size, num_elem, stdout);
+}
+
/**
* Escapes a string so it can be used safely.
* Currently escapes to ensure the validity for use as a JSON string
module_handler = Sensor_Handler;
} else if (!strcmp("actuators", module)) {
module_handler = Actuator_Handler;
+ } else if (!strcmp("image", module)) {
+ module_handler = Image_Handler;
}
context.current_module = module;
extern char *FCGI_EscapeText(char *buf);
extern void *FCGI_RequestLoop (void *data);
+extern void FCGI_WriteBinary(void * data, size_t size, size_t num_elem);
+
/**
* Shortcut to calling FCGI_RejectJSONEx. Sets the error code
* to STATUS_ERROR.
--- /dev/null
+#include "cv.h"
+#include "highgui_c.h"
+#include "image.h"
+#include <string.h>
+#include <stdio.h>
+
+void Image_Handler(FCGIContext * context, const char * params)
+{
+ static CvCapture * capture = NULL;
+ if (capture == NULL)
+ capture = cvCreateCameraCapture(0);
+
+ static int p[] = {CV_IMWRITE_JPEG_QUALITY, 100, 0};
+
+ IplImage * frame = cvQueryFrame(capture);
+ assert(frame != NULL);
+ CvMat * jpg = cvEncodeImage(".jpg", frame, p);
+
+ // Will this work?
+ Log(LOGNOTE, "Sending image!");
+ FCGI_PrintRaw("Content-type: image/jpg\r\n\r\n");
+ //FCGI_PrintRaw("Content-Length: %d", jpg->rows*jpg->cols);
+ FCGI_WriteBinary(jpg->data.ptr,1,jpg->rows*jpg->cols);
+
+}
--- /dev/null
+/**
+ * @file image.h
+ * @purpose Helper functions for image processing
+ */
+
+#ifndef _IMAGE_H
+#define _IMAGE_H
+
+#include "common.h"
+
+extern void Image_Handler(FCGIContext * context, const char * params);
+
+#endif //_IMAGE_H
+
+//EOF
--- /dev/null
+/**
+ * @file interferometer.c
+ * @purpose Implementation of interferometer related functions
+ */
+
+#include "cv.h"
+#include "highgui_c.h"
+#include "interferometer.h"
+#include <math.h>
+
+/** Buffer for storing image data. Stored as a single intensity value for the laser light **/
+static CvMat * g_data = NULL;
+
+
+/** Camera capture pointer **/
+static CvCapture * g_capture = NULL;
+
+
+struct timeval start;
+
+#define PI 3.141592
+
+// For testing purposes
+double test_omega = 0.05;
+double test_angle = PI/2;
+double test_noise[] = {0,0,0.02};
+double test_phase = 0;
+double test_intensity = 1.0;
+
+
+static void Interferometer_TestSinusoid()
+{
+ if (g_capture == NULL)
+ {
+ g_capture = cvCreateCameraCapture(0);
+ }
+
+ // Get image from camera
+ IplImage * img = cvQueryFrame(g_capture);
+
+ // Convert to CvMat
+ CvMat stub;
+ CvMat * background = cvGetMat(img, &stub, 0, 0);
+ // ... Honestly, I have no idea what the "stub" is for
+
+ if (g_data == NULL)
+ {
+ g_data = cvCreateMat(background->rows, background->cols, CV_32FC3);
+ }
+
+ //cvShowImage("background", background);
+
+ for (int x = 0; x < g_data->cols-1; ++x)
+ {
+ for (int y = 0; y < g_data->rows-1; ++y)
+ {
+ // Calculate pure sine in test direction
+ double r = x*cos(test_angle) + y*sin(test_angle);
+ double value = 0.5*test_intensity*(1+sin(test_omega*r + test_phase));
+
+ CvScalar s;
+ s.val[0] = 0; s.val[1] = 0; s.val[2] = value;
+ CvScalar b = cvGet2D(background, y, x);
+
+
+ // Add noise & background image
+
+ // Get the order the right way round
+ double t = b.val[0];
+ b.val[0] = b.val[2];
+ b.val[2] = t;
+ for (int i = 0; i < 3; ++i)
+ {
+
+ s.val[i] += (rand() % 1000) * 1e-3 * test_noise[i];
+ s.val[i] += b.val[i] / 255; // Camera image is 0-255
+ }
+
+ //printf("set %d,%d\n", x, y);
+
+
+
+ cvSet2D(g_data,y, x, s);
+ }
+ }
+
+
+}
+
+
+/**
+ * Get an image from the Interferometer
+ */
+static void Interferometer_GetImage()
+{
+
+
+ Interferometer_TestSinusoid();
+ //TODO: Implement camera
+
+}
+
+/**
+ * Initialise the Interferometer
+ */
+void Interferometer_Init()
+{
+
+ // Make an initial reading (will allocate memory the first time only).
+ Interferometer_Read(1);
+}
+
+/**
+ * Cleanup Interferometer stuff
+ */
+void Interferometer_Cleanup()
+{
+ if (g_data != NULL)
+ cvReleaseMat(&g_data);
+
+ if (g_capture != NULL)
+ cvReleaseCapture(&g_capture);
+
+}
+
+/**
+ * Read the interferometer; gets the latest image, processes it, spits out a single number
+ * @param samples - Number of columns to scan (increasing will slow down performance!)
+ * @returns Value proportional to the change in interferometer path length since the last call to this function
+ */
+double Interferometer_Read(int samples)
+{
+
+
+
+
+ // Get the latest image
+ Interferometer_GetImage();
+ // Frequency of the sinusoid
+ static double omega = 0;
+ // Stores locations of nodes
+ static int nodes[MAXNODES];
+ // Current phase
+ static double phase = 0;
+
+ // Phase
+ double cur_phase = 0;
+
+ int xstep = g_data->cols / (samples+1);
+
+ // Used for testing to see where the nodes are identified
+ // (Can't modify g_data)
+ static CvMat * test_overlay = NULL;
+ if (test_overlay == NULL)
+ {
+ // Creates a memory leak; don't do this in the final version!
+ test_overlay = cvCreateMat(g_data->rows, g_data->cols, CV_32FC3);
+ }
+ cvZero(test_overlay);
+ //cvCopy(g_data, test_overlay, NULL);
+
+ // For each column to sample
+ for (int x = xstep; x < g_data->cols; x += xstep)
+ {
+
+ double avg = 0.5; //TODO: Calculate from image
+ double threshold_dif = 0; //TODO: Pick this value
+
+ int num_nodes = 0;
+
+ // Find nodes
+ for (int y = 1; y < g_data->rows-2 && num_nodes < MAXNODES; ++y)
+ {
+ if (num_nodes == 0 || abs(nodes[num_nodes-1] - y) > 1)
+ {
+ // A "node" is defined where the ajacent points are on opposite sides of the avg
+ double ldif = INTENSITY(cvGet2D(g_data, y-1,x)) - avg;
+ double rdif = INTENSITY(cvGet2D(g_data, y+1,x)) - avg;
+
+ // If that is the case, the product of the differences will be negative
+ if (ldif * rdif < -threshold_dif)
+ {
+
+ nodes[num_nodes++] = y;
+
+ // Put a white line on the overlay to indicate the node was found
+ for (int xx = 0; xx < g_data->cols; ++xx)
+ {
+ CvScalar s; // = cvGet2D(g_data, y, xx);
+ s.val[0] = 1; s.val[1] = 1; s.val[2] = 1;
+ cvSet2D(test_overlay, y, xx, s);
+ }
+ }
+ }
+ }
+
+ // Insufficient nodes found to continue
+ if (num_nodes < 2)
+ {
+ --samples;
+ continue;
+ }
+
+ // Estimate angular frequency from two nodes TODO: Average between nodes
+ double slice_omega = (PI*(num_nodes-1)) / (nodes[num_nodes-1] - nodes[0]);
+ //printf("SLICE: %f vs %f\n", slice_omega, test_omega);
+
+ double slice_phase = 0;
+ for (int i = 0; i < num_nodes; ++i)
+ {
+ double this_phase = ((double)(i)*PI - slice_omega * nodes[i]);
+ //printf("Node %d gives phase %f\n", i, this_phase);
+ slice_phase += this_phase;
+ }
+ slice_phase /= num_nodes;
+ cur_phase += slice_phase;
+ }
+
+ // Average over samples
+ if (samples == 0)
+ return 0;
+
+ cur_phase /= samples;
+
+
+
+ // Get phase change since last call, save current phase
+ double result = (cur_phase - phase);
+
+ // HACK
+ if (abs(result) > 0.5*PI)
+ {
+ if (result > 0)
+ result -= PI;
+ else
+ result += PI;
+ }
+ phase = cur_phase;
+
+ // Display the image with lines to indicate results of data processing
+ //cvShowImage("nodes", test_overlay);
+ //cvWaitKey(1);
+ cvAdd(test_overlay, g_data, test_overlay, NULL);
+ cvShowImage("overlay", test_overlay);
+ cvWaitKey(1);
+ return result;
+
+}
+
+/**
+ * For testing purposes
+ */
+int main(int argc, char ** argv)
+{
+ //cvNamedWindow( "display", CV_WINDOW_AUTOSIZE );// Create a window for display.
+ gettimeofday(&start, NULL);
+
+ //Interferometer_Read(1);
+ //exit(EXIT_SUCCESS);
+
+ Interferometer_Init();
+
+ double sum = 0;
+ double last_phase = test_phase;
+
+ struct timeval now;
+ double time = 0;
+
+ while (time < 20)
+ {
+ gettimeofday(&now, NULL);
+ time = TIMEVAL_DIFF(now, start);
+
+ test_phase = 0.5*PI*sin(time);
+
+
+ double delta = Interferometer_Read(1);
+ sum += delta;
+
+ printf("%f\t%f\t%f\t%f\t%f\n", time, test_phase - last_phase, test_phase, delta, sum);
+
+ last_phase = test_phase;
+ //break;
+ }
+
+}
+
+
--- /dev/null
+/**
+ * @file interferometer.h
+ * @purpose Declarations for functions to deal with interferometer
+ */
+
+#include "common.h"
+
+//#define INTENSITY(rgb) ((rgb).val[0]*(rgb).val[0] + (rgb).val[1]*(rgb).val[1] + (rgb).val[2]*(rgb).val[2])
+#define INTENSITY(rgb) ((rgb).val[2])
+
+#define MAXNODES 100 //TODO: Choose value based on real data
+
+extern void Interferometer_Init(); // Initialise the interferometer
+extern void Interferometer_Cleanup(); // Cleanup
+extern double Interferometer_Read(); // Read the interferometer
+
+
+
--- /dev/null
+rm intertest
+make intertest
+./intertest > test.dat
+
+cmd="set title \"Interferometer Test\""
+cmd="$cmd; set xlabel \"Time (s)\""
+cmd="$cmd; set ylabel \"Phase (rad)\""
+cmd="$cmd; plot \"test.dat\" u 1:3 t \"Specified\" w l, \"test.dat\" u 1:5 t \"Calculated\" w p"
+gnuplot --persist -e "$cmd"
+
+cmd="set title \"Interferometer Test\""
+cmd="$cmd; set xlabel \"Time (s)\""
+cmd="$cmd; set ylabel \"Delta Phase (rad)\""
+cmd="$cmd; plot \"test.dat\" u 1:2 t \"Specified\" w l, \"test.dat\" u 1:4 t \"Measured\" w p"
+gnuplot --persist -e "$cmd"
#!/bin/bash
# Use this to quickly test run the server in valgrind
-spawn-fcgi -p9005 -n ./valgrind.sh
+#spawn-fcgi -p9005 -n ./valgrind.sh
# Use this to run the server normally
#./stream &
-#spawn-fcgi -p9005 -n ./server
+spawn-fcgi -p9005 -n ./server
<meta http-equiv="refresh" content="0">
</head>
-<IMG SRC="/images/test.JPG">
+<IMG SRC="/api/image">
git.ucc.asn.au / matches / MCTX3420.git / commitdiff
UCC git Repository :: git.ucc.asn.au