20:27 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
23:03 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Sat Aug 31 2013
+15:30 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+20:48 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Sun Sep 01 2013
+14:17 < jtanx> it'd have been cool to have written then server in python
+14:19 < Callum> gah havent done much for this project this week. not sure what i should do either
+14:19 < jtanx> hmm
+14:19 < Callum> so far behind in one of my units too. haha joys of uni
+14:19 < jtanx> lol
+14:20 < jtanx> werent we meant to get the camera stuff working or something
+14:21 < Callum> well yea but thats more rosher getting stuff working on his end. still not really sure what's going on. need to find an efficient way to transfer data (which would be directly streaming but it seemed adrian wanted some sort of processing)
+14:21 < Callum> guess i could start working on edge detection
+14:21 < jtanx> james hasn't got much done afaik
+14:21 < Callum> nah dont think he ahs
+14:22 < jtanx> but man I was looking at the javascript stuff
+14:22 < jtanx> and it's really annoying
+14:22 < jtanx> everything in javascript is asynchronous
+14:22 < jtanx> so you have a callback for an AJAX query, and it gets executed some time in the future
+14:23 < jtanx> it's really hard to pass variables to the callback and then also retrieve them
+14:23 < Callum> hmm
+14:23 < jtanx> i'm probably not doing it in the right fashion or something
+14:28 < Callum> not sure. don't really understand this stuff myself. havent done much/any
+14:45 < jtanx> flask is so cool
+15:01 < jtanx> oh
+15:02 < jtanx> maybe we can use cookies to store authorization
+15:02 < jtanx> instead of in javascript
+15:02 < jtanx> hmm
+15:02 < jtanx> http://stackoverflow.com/questions/15722795/how-to-create-a-cookie-with-fastcgi-nginx-in-c
+15:57 < sam_moore> Maybe a cookie is better, but couldn't you have a global variable that the JavaScript code sets in the callback?
+15:57 -!- Irssi: #mctxuwa_softdev: Total of 4 nicks [0 ops, 0 halfops, 0 voices, 4 normal]
+15:59 < sam_moore> Ok, I'll do the simulated "digital" sensor and actuator
+15:59 < sam_moore> We should make some kind of minimal gui in JavaScript
+16:00 < sam_moore> I'm not sure what James has done, but there's nothing under git
+16:02 < sam_moore> http://www.flotcharts.org/flot/examples/ajax/index.html is a good starting point for updating sensor graphs
+16:03 < sam_moore> jtanx: I wouldn't worry about the login/authentication too much for this week
+16:04 < jtanx> james said he got the buttons working but that's about it
+16:04 < jtanx> he's more concerned about issues with styling them than getting a fully fledged gui
+16:04 < sam_moore> I think actually having a gui is more important than having a pretty gui
+16:04 < sam_moore> At the moment anyway
+16:05 < jtanx> yeah
+16:05 < jtanx> it would be great to have *something*
+16:05 < jtanx> the problem with js
+16:05 < jtanx> is from what i've seen, the callback occurs in the jQuery file
+16:06 < jtanx> so you can't set global variables in say sensors.js
+16:06 < jtanx> and expect to be able to read/set them in the callback
+16:06 < sam_moore> Hmm, that's wierd
+16:06 < jtanx> what really shits me about javascript is variable handling
+16:06 < sam_moore> Hang on, let me have another look at the only project I ever used jQuery for... :P
+16:07 < jtanx> you can pass one/none/more than specified parameters
+16:07 < sam_moore> It was a chess game, so it should definietly be possible to modify variables in the callback function
+16:07 < jtanx> yeah there's probably a way, I just don't know it
+16:08 < jtanx> about the actuators
+16:08 < jtanx> I've already got something working in my repository
+16:08 < jtanx> but I don't really like how I've done it
+16:30 < sam_moore> I'm making a minimal gui (it will be able to plot something, and have a button); we can either ditch it or improve on it later
+16:31 < jtanx> sounds good
+16:35 < sam_moore> Callum: If you want to make a (really awful but possibly looking good enough at this stage for Adrian) "streaming" images thing
+16:35 < sam_moore> You can have your program continuously save to a file
+16:35 < sam_moore> And a html page that just has "<meta http-equiv="refresh" content="0">" in the header
+16:35 < sam_moore> With a link to the image
+16:36 < Callum> alright il look into it
+16:36 < sam_moore> It's absolutely aweful, but it will give the effect of a really laggy video
+16:36 < jtanx> nice :P
+16:36 < sam_moore> You can improve it (if you get time) by having 2 images instead of one, with a symbolic link to swap between them
+16:38 < sam_moore> I'll bring the raspberry pi with the webcam tomorrow and we'll put everything on it to show Adrian
+16:38 < jtanx> hehehe
+16:38 < jtanx> can you install ffserver on the raspi?
+16:39 < sam_moore> Probably
+16:40 < jtanx> actually
+16:41 < jtanx> does our code run on the raspi?
+16:50 < sam_moore> Yes, at the moment
+16:54 < Callum> how are we integrating my code into it?
+17:01 < sam_moore> Keep it as a seperate process for now
+17:01 < Callum> alright
+17:01 < sam_moore> I'll modify the "run.sh" script to start both of them
+17:01 < sam_moore> Sigh javascript
+17:01 < sam_moore> So useful and yet so horrible
+17:02 < sam_moore> Still, I think if we can get our heads around it it is actually a nice way to do this
+17:09 < jtanx> the camera thing or the api or both?
+17:24 < sam_moore> The API
+17:24 < Callum> ok so how do i link to the image? (
+17:24 < sam_moore> Just put a html file in the /server directory for now
+17:25 < sam_moore> With <img src="path_to_image"> in the body somewhere
+17:29 < Callum> where are we going to put the images?
+17:31 < sam_moore> /server/images (?)
+17:31 < sam_moore> Wherever it seems logical I guess
+17:33 < sam_moore> If either of you are available earlier on Monday, I'm free for pretty much the whole day
+17:33 < sam_moore> Do you want to meet earlier and actually do coding as a group?
+17:37 < sam_moore> Dammit why does javascript remove the [] brackets when printing string representations of arrays
+17:37 < sam_moore> How are you supposed to tell what dimensions the array has...
+17:37 < jtanx> if you want sample code of how I printed the array of sensor values
+17:37 < jtanx> see the unit tests
+17:37 < sam_moore> Ok, thanks
+17:37 < jtanx> for (var i = 0; i < data.data.length; i++) {
+17:37 < jtanx> result += data.data[i][0] + ":" + data.data[i][1] + ", ";
+17:37 < jtanx> }
+17:56 < Callum> ok well iv done trhat, i think. you should probably check it to make sure its right
+17:58 < Callum> sent pull request. and i'v got food so brb
+17:58 < sam_moore> Ok, thanks
+17:59 < sam_moore> jtanx: You're right, altering variables on a successful ajax call is a pain in the ass
+17:59 < jtanx> hehe
+17:59 < sam_moore> ... You can modify html attributes really easily though
+17:59 < jtanx> true
+17:59 < jtanx> that's what I was thinking
+17:59 < sam_moore> Must resist urge to store data in a comment
+17:59 < jtanx> have a hidden input field?
+18:01 < jtanx> I must say that the firebug debugger and inbuilt web console were both quite useful
+18:02 < sam_moore> Yes, I've got firebug running
+18:04 < jtanx> I was looking at flask and it was ridiculously easy to set up a similar API in python
+18:05 < sam_moore> Do you want to change to python then?
+18:06 < sam_moore> Don't we still have to do the javascript though?
+18:07 < sam_moore> The API we have at the moment isn't that terrible
+18:07 < jtanx> nah
+18:07 < jtanx> it's probably best to stick with what we have
+18:07 < jtanx> the javascript stuff would remain the same yeah
+18:09 < sam_moore> Ok
+18:26 < sam_moore> Right... you can update global variables on a successful AJAX request
+18:27 < sam_moore> If you put "var" in front of the variable in the global scope then the AJAX callback will just make a new local variable and modify that -_-
+18:27 < sam_moore> But if you Don't put the "var" there, it will work
+18:40 < jtanx> lol
+18:41 < jtanx> but using global variables in javascript can get.... messy
+18:41 < sam_moore> Mmm
+18:42 < sam_moore> But doing pretty much *anything* in javascript is messy
+18:42 < jtanx> yeah
+18:42 < jtanx> true that
+18:43 < sam_moore> I wonder...
+18:43 < sam_moore> Should we just have one html page for each sensor/actuator
+18:43 < sam_moore> And then the user can open multiple tabs?
+18:45 < sam_moore> That's probably not very nice though
+18:46 < sam_moore> I think we should return data about multiple sensors at a time
+18:51 < jtanx> you'd probably want it all on one page
+18:51 < sam_moore> Yeah
+18:51 < jtanx> how many sensors are we talking about again
+18:51 < sam_moore> 6 or 7 I think, + a camera
+18:51 < jtanx> oh yeah
+18:51 < sam_moore> Oh well, we can redesign it later
+18:51 < jtanx> I guess we can design for max 7
+18:52 < sam_moore> But it might be a good idea to query multiple sensors in one ajax request
+18:53 < jtanx> yep
+18:53 < jtanx> supply more than one id in a go?
+18:53 < jtanx> could have an array (max size 7) that holds all the sensors you want to get data for
+18:53 < jtanx> i guess
+18:55 < sam_moore> It's probably more flexible to just add a "getall" key to the sensor module
+18:57 < jtanx> oh yeah
+18:57 < jtanx> I'm free until 12 tomorrow
+18:57 < jtanx> do you want to work together before that?
+18:58 < sam_moore> Sure
+18:59 < sam_moore> Try G19 again, but if that doesn't work we can go to the physics lab, or the computer science labs
+19:01 < jtanx> yeah ok
+19:02 < jtanx> what time do you want to start?
+19:04 < sam_moore> I'll probably get in around 9 or 10, depending on how much sleep I get
+19:04 < sam_moore> Let's say 10:00
+19:05 < sam_moore> Got to go, I'll be back later
+19:05 < jtanx> ok
+21:35 < sam_moore> I'm just going to use the same Sensor stuff for digital sensors
+21:36 < sam_moore> Adding a second type of sensor seems needlessly complicated
+21:36 < sam_moore> 1 = on and 0 = off
+21:37 < sam_moore> Probably do the same for actuators (just have some sanity checks on the values you can set, both at the client and the server)
+21:38 < jtanx> usually I'd just say 0 is off and not 0 is on
+21:38 < sam_moore> Haha, fair enough
+21:39 < jtanx> I kinda hate over-checking stuff :P
+21:39 < sam_moore> The actual GetData function has to return something reasonably sane though
+21:39 < sam_moore> It's easy to just make it only return 0 or 1
+21:39 < jtanx> oh I was more talking about setting the value of the actuator
+21:39 < sam_moore> Right
+21:40 < sam_moore> We should probably check for 0 or 1 anyway
+21:40 < sam_moore> In case the user does something dumb
+21:40 < jtanx> well
+21:40 < sam_moore> Like think they are setting an analog sensor and put in like "200"
+21:40 < jtanx> it should be the js code that's setting it
+21:41 < jtanx> so if you write the code properly it shoul be ok
+21:41 < sam_moore> "should be OK"...
+21:41 < jtanx> you shouldn't access the api directly
+21:41 < sam_moore> Alright, we'll see, but it's like, 1/2 a line of code to check :P
+21:41 < sam_moore> Redundancy and all that
+21:41 < jtanx> but even if they entered 200
+21:41 < jtanx> well so what
+21:41 < sam_moore> Yeah, but people *can* access the API directly
+21:41 < jtanx> it'd just represet 1
+21:42 < jtanx> represent
+21:42 < jtanx> *
+21:42 < sam_moore> How does the server know the difference between someone typing the URL and an AJAX request to the URL?
+21:42 < jtanx> yeah
+21:42 < sam_moore> Someone could go view source, "How can I break this... ah, what happens if I pass stupid values directly to the API"
+21:42 < jtanx> well if you define that 0 is off and not zero is on
+21:43 < jtanx> then it meets specs :P
+21:43 < sam_moore> Ok, I suppose it doesn't really matter
+21:44 < sam_moore> I respectfully disagree with the idea of having too many checks :P
+21:44 < sam_moore> Unless we went "while (true) DoCheck();" or something like that
+21:44 < sam_moore> That would be dumb
+21:44 < jtanx> hahaha
+21:45 < jtanx> but sometimes it gets really messy to maintain when you have that many checks
+21:45 < jtanx> and then when you want to modify something it's a real pain
+21:45 < jtanx> and really easy to break
+21:45 < sam_moore> True, but a bounds check isn't that bad
+21:46 < jtanx> yrue
+21:46 < sam_moore> I mean, you have to convert the value that isn't zero to an "on" anyway, which requires a check
+21:46 < jtanx> not really
+21:46 < sam_moore> Depends on the actuator
+21:46 < jtanx> you check if !value
+21:47 < sam_moore> Alright
+21:58 < jtanx> do you think there should be a stop/start method?
+21:58 < jtanx> eg start the experiment
+21:58 < jtanx> stop the experiment
+22:28 < sam_moore> Yes, probably
+22:28 < sam_moore> The stuff I wrote for Thread Exit conditions may actually help there...
+22:29 < sam_moore> Remove the bit where the FCGI loop exits though
+22:29 < jtanx> yeah
+23:09 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Mon Sep 02 2013
+08:33 < sam_moore> Hi
+08:33 < sam_moore> I managed to get a reasonable sensor plotting GUI done
+08:35 < sam_moore> So, adrian wanted: 1) A digital sensor simulation (done) 2) Sensors plotted in GUI (done) 3) A test actuator in the GUI 4) Camera images in the GUI (sort of done, kind of)
+08:35 < sam_moore> Was there anything else?
+08:38 < sam_moore> I have to go to Uni, I'll be in G19 otherwise I'll send an email
+08:38 < sam_moore> See you
+08:42 < jtanx> ok then
+09:02 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+09:55 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+13:15 < jtanx> hey
+13:18 < james__> hey
+13:18 < james__> I have the AJAX call working i am pretty sure
+13:19 < jtanx> ok
+13:19 < james__> Do you know if we have the beaglebones in yet?
+13:19 < jtanx> I don't know
+13:19 < jtanx> it should be ready soon though
+13:19 < jtanx> anyway, sam got a gui with graphs semi working
+13:20 < jtanx> could you update your git repository with what you've done?
+13:28 -!- james__ [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+13:31 < jtanx> :(
+13:31 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+21:04 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Tue Sep 03 2013
+21:35 -!- jtanx_ is now known as jtanx
+22:10 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Wed Sep 04 2013
+09:02 -!- jtanx_ is now known as jtanx
+09:03 -!- MctxBot_ is now known as MctxBot
+11:54 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+16:00 -!- jtanx_ is now known as jtanx
+20:49 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Thu Sep 05 2013
+09:34 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+18:51 < jtanx> hm, so to get clock_gettime to work, you need to use std=gnu99 instead of std=c99
+18:52 < jtanx> do you think we should just stick with gettimeofday?
+--- Day changed Fri Sep 06 2013
+12:05 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+16:05 < jtanx> I was just thinking, what sort of identification information is needed from the server?
+16:05 < jtanx> The gui should have some understanding of what sort of sensors/actuators it needs to display
+16:10 < jtanx> it might be enough to say this is API version x
+16:10 < jtanx> and at version x, it's agreed that these id values correspond to these sensors/actuators etc?
+16:19 < jtanx> anyway, what I've done for now is if asked, the api will list the sensor/actuator ids and the corresponding human readable string
+16:19 < jtanx> api/?sensors&actuators
+18:06 < jtanx> also, what do you think of keeping track of the number of points stored
+18:07 < jtanx> then you can allow the user to request from where they want to retrieve data from and how many to retrieve
+18:08 < jtanx> the only problem is that it wouldn't be time based, but based on the number of data points recorded
+18:08 < jtanx> this method is simpler because you now the offset to use with fseek
+18:08 < jtanx> if it's time based you have to search the data for the correct point
+19:51 < sam_moore> All the above makes good sense
+19:52 < sam_moore> If we can make a working "request X number of points" first instead of "request from time T onwards", we might be able to convert the latter to the former if necessary
+20:04 < jtanx> ok I just submitted a pull request for some stuff
+20:04 < jtanx> mostly the identification stuff and some reordering
+20:04 < jtanx> FCGI_RejectJSON now requires that you give a description explaining why
+20:05 < jtanx> when RejectJSOn is called, it's always logged along with the description, so some of the current log messages within the handler functions may be redundant
+21:11 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Sat Sep 07 2013
+18:29 < jtanx> hmm
+18:29 < jtanx> what if you had two file pointers to the same file
+18:29 < jtanx> one read only, one write only
+18:29 < jtanx> then if you also kept track of how many points were written to the file
+18:29 < jtanx> you don't need to have mutexes anymore
+18:30 < jtanx> as long as you write the read/write calls carefully
+18:44 < jtanx> ahp, may have spoken too soon
+18:44 < jtanx> you'd still need a mutex around the read/write from/to the counter
+18:45 < jtanx> I think...
+19:07 < jtanx> but it might still be a good idea
+21:38 < jtanx> I went the simple route
+21:53 < jtanx> what I've got: /api/sensors?id=x&from=y&count=z
+21:54 < jtanx> In dump mode:
+21:54 < jtanx> If from < 0, then return from start, else from the given index (0-indexed)
+21:54 < jtanx> if count < 0, then return all points, else return /at most/ that many points
+21:55 < jtanx> in normal mode:
+21:55 < jtanx> if from < 0, then return from the end (return the most recent points)
+21:55 < jtanx> if count < 0, then return at most the default amount (SENSOR_QUERYBUFSIZ)
+21:56 < jtanx> otherwise return /at most/ that many points
+21:56 < jtanx> oh ya, if from >= 0 then return from that indicated index
+21:57 < jtanx> it's only in my git repository for now because I haven't tested it enough and I'm still not sure how I should go about integrating it with the current code
+21:58 < jtanx> (I basically rewrote Sensor_Handler and it has less error checks on the input; not sure if they're necessary or not)
+21:59 < jtanx> Since requesting a huge range could impact on sensor readings due to the mutex, it may be better to at least restrict dumps to when the experiment is not 'running'
+--- Day changed Sun Sep 08 2013
+18:06 < Callum_> what was the server stuff you said to install? also what packages do i need?
+18:09 -!- Callum_ is now known as Callum
+18:21 < jtanx> if you want to install the server, you need at least the 'nginx' and 'spawn-fcgi' packages
+18:21 < jtanx> one nginx is installed you need to copy the config files from the git repository in
+21:14 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+22:36 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+22:38 -!- Callum [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Mon Sep 09 2013
+10:54 -!- jtanx_ [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+11:30 -!- Irssi: #mctxuwa_softdev: Total of 2 nicks [0 ops, 0 halfops, 0 voices, 2 normal]
+15:55 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+21:01 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Tue Sep 10 2013
+17:25 < jtanx> it looks like we do need an sd card, at least to install the os onto it
+17:26 < jtanx> http://beagleboard.org/Getting%20Started#update
+17:41 < jtanx> http://avedo.net/653/flashing-ubuntu-13-04-or-debian-wheezy-to-the-beaglebone-black-emmc/
+17:42 < sam_moore> Ok, we should write a BOM for next week then
+17:42 < sam_moore> 1x SD Card
+17:44 < jtanx> from what I understand
+17:45 < jtanx> you write an image to the sd card
+17:45 < jtanx> boot off the sd card
+17:45 < jtanx> then you can write another image directly too the internal storage
+17:45 < jtanx> after that you don't need the sd card any more
+17:46 < sam_moore> Alright
+17:46 < jtanx> http://www.armhf.com/index.php/boards/beaglebone-black/
+17:47 < jtanx> any preference for ubuntu or debian?
+17:48 < sam_moore> As a debian user, I'd have to say debian :P
+17:49 < jtanx> hehe
+17:49 < sam_moore> If it works on debian stable, we know it will work for at least the next 6 years
+17:49 < jtanx> yup
+17:49 < jtanx> debian should be fine
+17:53 < jtanx> *correction; we need a microsd card
+17:56 < jtanx> that's at least 2GB in size
+17:57 < sam_moore> Ok
+18:04 < jtanx> haha it's cheaper to buy a 4gb one than a 2gb one
+18:35 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+20:15 < jtanx> Well I can confirm that angstrom doesn't have nginx precompiled - http://www.angstrom-distribution.org/repo/
+20:57 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Wed Sep 11 2013
+15:58 < jtanx> urgh
+15:58 < jtanx> it took so long just getting internet access to the bbb
+16:01 < jtanx> dhcp/dns issues
+16:01 < jtanx> the debian image on the microsd is set to static ip 192.168.0.7
+16:02 < jtanx> /etc/resolv.conf should have the uwa nameservers in it, but it may have been rewritten by resolvconf
+16:02 < jtanx> I've left it in g19
+16:51 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+19:32 < jtanx> I've moved the 'current_time', 'start_time' and 'running_time' to the identify module instead of sticking it on every json response, because it's probably not information that will be required most of the time
+19:37 < jtanx> actually, we may have to rethink those, especially if we introduce start/stop control
+20:38 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Thu Sep 12 2013
+09:36 < sam_moore> I think I have some time after the tutorial today to work on stuff
+09:36 < sam_moore> I take it we have the bbb now?
+09:37 < sam_moore> I'll bring that crappy webcam
+09:37 < sam_moore> Maybe look into sending images as part of the API, see if it's feasable to do it that way
+09:38 < sam_moore> I think we can introduce start/stop control fairly easily
+09:40 < sam_moore> "Mush Mush"
+09:40 < sam_moore> Heh
+09:41 < sam_moore> To reduce the load on the client, we might be able to send averaged data points instead of every data point
+09:41 < sam_moore> You specify "averages per point"
+09:42 < sam_moore> So each [time, value] pair is actually an average of X recordings
+09:42 < sam_moore> In fact it's better to send [mean_time, mean_value, std_dev]
+09:42 < sam_moore> The std_dev gives you an idea of noise and/or if the value is changing a lot
+09:43 < sam_moore> And of course you can always specify a single average and it becomes equivelant to what we currently do
+09:50 < jtanx> yeah
+09:50 < jtanx> I'm free after the tute
+09:50 < jtanx> I'm bringing in a router to make it easier
+09:50 < jtanx> to work on the bbb together
+09:51 < jtanx> yesterday it was so painful trying to get shit working
+09:51 < jtanx> dhcp issues, dns issues, internet connection sharing issues...
+09:51 < jtanx> (mostly the fault of my own computer though)
+09:51 < jtanx> btw I'm working on adding an extra function to FCGI to makeit easier to parse parameters
+09:51 < jtanx> (hoepfully)
+09:55 < jtanx> gtg see you at the tute
+09:55 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+18:26 < Callum> would be easier to talk here...if everyone was on
+18:41 < jtanx> did you bring the bbb home?
+18:43 < sam_moore> Yep
+18:44 < sam_moore> I'll put it back tomorrow morning
+18:49 < jtanx> ok
+19:47 < jtanx> I'm so tempted to use bitflags for that request function
+19:52 < jtanx> one thing that I need to do is to sanitise json string fields
+20:18 < sam_moore> Sanitise? As in "make sane" or "make clean"?
+20:18 < sam_moore> Um... if you think bitflags are necessary, I fully support you :P
+20:19 < jtanx> as in
+20:19 < jtanx> If I allow FCGI_JSONPair to also be passed a format string
+20:19 < jtanx> then having stuff like \ or " or newline characters for eg in the string
+20:20 < jtanx> is not a good idea
+20:20 < sam_moore> Hmm
+20:20 < jtanx> it's sorta like this:
+20:20 < sam_moore> Well, writing the function to print out data (either as TSV or JSON)
+20:20 < sam_moore> I've only been using FCGI_PrintRaw
+20:20 < jtanx> yeah
+20:20 < jtanx> but right now, you're logging messages in Server_handler
+20:20 < jtanx> about invalid values
+20:21 < sam_moore> Yes, I'm not sure how to deal with that
+20:21 < jtanx> Sensor_handler*
+20:21 < jtanx> so
+20:21 < jtanx> eg Log(LOGERR, "Require \"all\" or an integer value: %s = %s", key, value);
+20:21 < sam_moore> Yes
+20:21 < jtanx> if I wanted to send that back to the client in FCGI_RejectJSON
+20:21 < jtanx> there's the potential (...) that the user could hvae included a " in the value
+20:22 < jtanx> so if you return it as part of your json response, then suddenly it's broken
+20:22 < sam_moore> Oh, that sucks
+20:23 < sam_moore> Perhaps treat Log messages seperately from JSON responses?
+20:23 < jtanx> eg: "description":" required an id, got 'blah-stray"'"
+20:23 < jtanx> yeah
+20:24 < jtanx> What I could do is just replace any special characters with space
+20:24 < jtanx> and return that in description
+20:24 < jtanx> but keep the actual value in log
+20:24 < sam_moore> Maybe
+20:24 < sam_moore> You could also call FCGI_RejectJSON as soon as you get a special character
+20:25 < sam_moore> Since we shouldn't have any key/values that use them
+20:25 < sam_moore> (I think :P)
+20:25 < jtanx> lol
+20:25 < sam_moore> Whatever seems best
+20:25 < jtanx> let me think about it some more
+20:25 < sam_moore> Yeah, fair enough
+20:25 < sam_moore> Um, another thing (sorry) is error messages that you might get independent of any request
+20:26 < sam_moore> Like you suddenly have an I/O error on a file
+20:26 < sam_moore> Currently we handle that with Fatal
+20:26 < sam_moore> Which it would be convenient to keep; but instead of terminating the whole program, we need to notify the client somehow
+20:26 < jtanx> that won't happen until the next request
+20:27 < jtanx> what you could do is keep it exiting
+20:27 < jtanx> when that happens, nginx sends 502 bad gateway
+20:27 < jtanx> then if that's detected, send a link to the log file
+20:27 < sam_moore> Yeah, that seems good
+20:27 < jtanx> and a method to restart the software
+20:28 < sam_moore> Do we want to notify the client of non-fatal errors or warnings though?
+20:28 < sam_moore> Hmm
+20:29 < jtanx> hmm
+20:29 < jtanx> probably a good idea
+20:29 < jtanx> but how
+20:29 < sam_moore> The client could periodically request the log file and deal with messages?
+20:30 < jtanx> It could just display it I guess
+20:30 < jtanx> onus on the user to take action if required
+20:30 < sam_moore> Sure, an alert might be nice though
+20:30 < sam_moore> Perhaps have an extra log file that just has the most recent message in it (with a timestamp)
+20:31 < jtanx> you could perform a regex on the text and highlight lines with warning or something
+20:31 < sam_moore> The client just periodically looks at that and if it's a new message can alert
+20:31 < sam_moore> Yeah that would work, as long as the file doesn't get too big
+20:31 < sam_moore> It probably won't
+20:31 < jtanx> well you could autoscroll it anyway
+20:32 < jtanx> but ok maybe that's getting a bit ahead of ourselves
+20:32 < sam_moore> Yeah, sure
+20:32 < sam_moore> I'll get back to rewriting 90% of the sensor code :P
+20:32 < jtanx> haha
+20:32 < jtanx> currently, I've got
+20:32 < jtanx> bool FCGI_ParseRequest(FCGIContext *context, char *params, FCGIValue values[], size_t count);
+20:32 < jtanx> (any better suggestion for FCGIValue?)
+20:32 < jtanx> (the name that is)
+20:33 < jtanx> with
+20:33 < sam_moore> That's probably fine
+20:33 < jtanx> typedef struct FCGIValue {
+20:33 < jtanx> const char *key;
+20:33 < jtanx> void *value;
+20:33 < jtanx> unsigned flags;
+20:33 < jtanx> } FCGIValue;
+20:33 < jtanx> you then do
+20:33 < jtanx> something like:
+20:33 < jtanx> FCGIValue values[2] = {{"sensors", &ident_sensors, FCGI_REQUIRED(FCGI_BOOL_T)},
+20:33 < jtanx> {"actuators", &ident_actuators, FCGI_BOOL_T}};
+20:33 < sam_moore> Looks good
+20:33 < jtanx> although I'm open to suggestions on those type names too
+20:34 < jtanx> if you really have to
+20:34 < jtanx> you can do something like FCGI_RECEIVED(values[0].flags)
+20:34 < jtanx> to check if you received the argument or not
+20:34 < sam_moore> If it's not too hard to implement, then OK
+20:35 < jtanx> ?
+20:35 < sam_moore> That looks reasonably nice
+20:35 < jtanx> the #defines look less so:
+20:35 < jtanx> #define FCGI_PARAM_REQUIRED (1 << 0)
+20:35 < jtanx> #define FCGI_PARAM_RECEIVED (1 << 1)
+20:35 < jtanx> #define FCGI_BOOL_T (1 << 2)
+20:35 < jtanx> #define FCGI_LONG_T (1 << 3)
+20:35 < jtanx> #define FCGI_DOUBLE_T (1 << 4)
+20:35 < jtanx> #define FCGI_STRING_T (1 << 5)
+20:35 < jtanx> #define FCGI_REQUIRED(x) ((x) | FCGI_PARAM_REQUIRED)
+20:35 < jtanx> #define FCGI_IS_REQUIRED(x) ((x) & FCGI_PARAM_REQUIRED)
+20:35 < jtanx> #define FCGI_RECEIVED(x) ((x) & FCGI_PARAM_RECEIVED)
+20:35 < jtanx> #define FCGI_TYPE(x) ((x) & ~(FCGI_PARAM_REQUIRED | FCGI_PARAM_RECEIVED))
+20:35 < sam_moore> In fact it's similar to how you use select(2)
+20:35 < sam_moore> Wow, macros
+20:35 < jtanx> :P
+20:35 < jtanx> makes life easier
+20:36 < sam_moore> Alright, this is C
+20:36 < sam_moore> Yeah, FCGI_RECEIVED(values[i].flags) looks nice (from the point of view of actually using it anyway)
+20:37 < jtanx> yeah it's ok
+20:37 < jtanx> the only stickler is that hardcoded index
+20:37 < jtanx> can't really do much about that though
+20:37 < sam_moore> I can put an enum in the function
+20:38 < jtanx> if you want; it might be more work to maintain the enum than anything though
+20:39 < jtanx> but yeah, essentially if you require a parameter, you surround the type in FCGI_REQUIRED()
+20:39 < jtanx> hopefully that part was clear
+20:39 < sam_moore> Yep, I'm happy with that
+20:39 < jtanx> cool
+20:43 < jtanx> for the bool value, what behaviour do you think is better
+20:43 < jtanx> always set the value to true, or invert the current value
+20:44 < jtanx> right now it's set to always be true
+21:06 < sam_moore> Um... always set to true?
+21:09 < jtanx> yeah
+21:29 < jtanx> oh
+21:30 < jtanx> well I didn't need to escape after all
+21:30 < jtanx> If you do something like this: http://mctx.us.to:8080/api?afa%22%22%22%22
+21:30 < jtanx> it gets url encoded
+21:30 < jtanx> http://mctx.us.to:8080/api?afa""""
+21:30 < jtanx> I wonder if that's guaranteed
+21:32 < jtanx> well, apparently it's not because IE doesn't escape it for you
+21:32 < jtanx> so I did need to escape
+21:33 < sam_moore> There's no escape
+21:46 < jtanx> wait wat
+21:59 < sam_moore> (It's a pun)
+22:00 < sam_moore> So I've made a DataFile structure to isolate it a bit more from the higher level Sensor related stuff
+22:00 < sam_moore> Hopefully things make more sense
+22:00 < sam_moore> I put in 2 seperate FILE* as well
+22:00 < sam_moore> And got rid of the confusing "fill a buffer then dump the buffer to a file" loop
+22:01 < sam_moore> Now it just writes each point to a file
+22:01 < sam_moore> Hopefully it's thread safe enough
+22:01 < sam_moore> Now... I just need to simplify the Sensor_Handler function...
+22:02 < jtanx> > (It's a pun)
+22:02 * jtanx facepalm
+22:03 < jtanx> hoho
+22:03 < jtanx> ok
+22:03 < jtanx> I'll submit what I've done so far to git
+22:08 < jtanx> callum
+22:08 < jtanx> that code you submitted
+22:08 < jtanx> I don't think it's right
+22:08 -!- Irssi: #mctxuwa_softdev: Total of 3 nicks [0 ops, 0 halfops, 0 voices, 3 normal]
+22:09 < jtanx> the stuff with g_sensor_names, that's the human readable name of each sensor
+22:10 < sam_moore> I've changed the name and how the sanity check gets called, but I've left the body unimplemented for now
+22:12 < jtanx> it's with the pull request he submitted ~30mins ago
+22:12 < sam_moore> Oh, ok
+22:13 < sam_moore> Good thing I made a new branch for my changes
+22:14 < jtanx> the pull request isn't merged yet
+22:15 < sam_moore> Yeah, I don't think we should merge that, sorry Callum
+22:17 < jtanx> ok just submitted the pull request
+22:17 < sam_moore> I never put documentation on g_sensor_names I guess, sorry
+22:17 < jtanx> I think I did though
+22:17 < jtanx> but in the header file
+22:18 < jtanx> which is annoying :/
+22:18 < jtanx> (as in there's more than one spot to put documentation)
+22:19 < sam_moore> Yeah... does one overwrite another?
+22:19 < sam_moore> I'll just copy paste the same thing into the .c file
+22:19 < jtanx> No idea how doxygen handles that
+22:20 < sam_moore> I wonder how much fun I'll have merging these branches...
+22:20 < jtanx> hehe
+22:20 < jtanx> I'm not really sure if FCGI_ParseRequest will be that helpful or not
+22:20 < jtanx> if you find it doesn't really help then we can scrap it
+22:21 < sam_moore> Well it makes sense to seperate the code for getting key,value pairs from the code that does stuff with them
+22:23 < jtanx> I guess
+22:23 < sam_moore> I've basically moved a lot of functionality from sensor.c into a new file data.c under functions with the prefix "Data_"
+22:24 < jtanx> ok
+22:24 < sam_moore> data.c doesn't care anything about what the data is or where it came from, it just wraps around saving/reading/selecting ranges of DataPoints
+22:25 < jtanx> sounds like a good idea
+22:25 < jtanx> it might be of use in actuator code I guess
+22:25 < sam_moore> Yeah, there's a DataFile structure that basically wraps around the binary file
+22:25 < sam_moore> Yes, I was thinking that too
+22:25 < sam_moore> Because we'll probably want to store DataPoints when an actuator gets changed
+22:26 < jtanx> yeah true
+22:27 < sam_moore> If the idea about using 2 FILE* is right... I don't think we really need any mutexes?
+22:28 < sam_moore> There is an index that gets incremented, but since only one thread can write to it, the worst that can happen is you return one (maybe two at the extreme) less point than actually exists
+22:29 < sam_moore> If you had 2 threads incrementing the index you'd need a mutex though
+22:29 < jtanx> the problem is that setting a value is not guaranteed to be atomic
+22:29 < jtanx> i think
+22:29 < sam_moore> Yes, sure
+22:29 < jtanx> so while setting and you read it it could be indeterminate
+22:29 < sam_moore> Mmm
+22:30 < jtanx> I think you need mutexes around reading/writing the points_written(?)
+22:30 < jtanx> index
+22:30 < jtanx> but that's it
+22:31 < jtanx> http://stackoverflow.com/questions/54188/are-c-reads-and-writes-of-an-int-atomic
+22:31 < sam_moore> I'm not sure you do if you are writing in one thread and reading in another
+22:31 < sam_moore> Ah, stackoverflow, OK
+22:32 < jtanx> it's actually very architecture specific
+22:32 < sam_moore> Yeah "Yes, no, hmmm, well it depends" is probably right
+22:32 < jtanx> haha
+22:32 < sam_moore> Well... there are no mutexes at the moment, but maybe I should get around to putting them in
+22:32 < sam_moore> I think I had one thread writing and another reading in my parallel programming assignment and got full marks :S
+22:33 < sam_moore> Threads are strange and magical
+22:33 < jtanx> hey well it probably works 99% of the time
+22:34 < sam_moore> Ah, it probably works if the size of the integer is smaller than the bus
+22:34 < sam_moore> smaller or equal
+22:34 < jtanx> too bad linux doesn't have something like InterlockedExchange
+22:35 < sam_moore> I'll add mutexes in later then
+22:35 < jtanx> One thing I liked about C++ was auto locks
+22:36 < jtanx> (you could call some lock function and once that scope ended the lock ended too)
+22:36 < sam_moore> That's nice
+22:40 < jtanx> Ok, that's all I'm probably going to get done today
+22:41 < sam_moore> Yeah, thanks
+22:42 < jtanx> what's with the meeting tomorrow though
+22:43 < sam_moore> I'm busy from 2:00pm until at least 4:00pm (maybe later)
+22:43 < sam_moore> But I think I should be preparing for something before 2:00pm
+22:44 < jtanx> ok, I'll probably come in around 1.30pm so I can work with Callum, and I'll stay on until whatever time
+22:44 < sam_moore> Alright
+22:45 < sam_moore> Check github in the morning, I'll push all my changes
+22:45 < jtanx> ok I'll do that
+22:45 < sam_moore> Hopefully they make sense, otherwise you can change everything back :P
+22:45 < sam_moore> The wonders of git
+22:45 < jtanx> haha I'm sure it'll make sense
+22:46 < jtanx> after staring for a while
+22:46 < sam_moore> Yeah it should be a bit simpler
+22:46 < jtanx> thanks
+22:47 < jtanx> see you tomorrow (probably)
+22:48 -!- jtanx [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+23:28 -!- Callum_ [
[email protected]] has quit ["ChatZilla 0.9.90.1 [Firefox 23.0.1/20130814063812]"]
+--- Day changed Fri Sep 13 2013
+08:31 < jtanx> oh yeah, I forgot to restart the bot :P
+08:53 < sam_moore> So, using 2 FILE* causes some problems, I recommend we just use 1
+08:54 < sam_moore> In theory the operating system is supposed to use locks when multiple processes have access to the same file
+08:54 < sam_moore> But...
+08:54 < sam_moore> It probably doesn't work with threads
+08:55 < sam_moore> I'm not sure exactly what goes wrong, but using 1 works and isn't really going to be slower (if the OS uses locks then that probably has a similar overhead to using a mutex)
+08:59 < jtanx> yeah, let's stick to one then
+09:00 < jtanx> there's still a few bugs around I think
+09:00 < sam_moore> Probably
+09:01 < sam_moore> I put valgrind back in, I got rid of a lot last night
+09:01 < jtanx> nice
+09:01 < sam_moore> Although I probably introduced them in the first place
+09:01 < jtanx> what was with that mem leak in fastcgi code?
+09:03 < sam_moore> Oh, that wasn't a memory leak, it was an uninitialised value
+09:04 < sam_moore> I thought I'd be clever and use sizeof() on the FCGIValue array
+09:04 < sam_moore> But I forgot that the actual number of elements is not just sizeof()
+09:04 < sam_moore> It's sizeof(array) / sizeof(element)
+09:04 < jtanx> oh right haha
+09:05 < sam_moore> So the refactored code basically does the same thing
+09:05 < sam_moore> But hopefully it's a bit cleaner
+09:05 < jtanx> yep
+09:05 < jtanx> it's pretty good
+09:06 < jtanx> when you get an invalid id or format, do you want to reject that?
+09:07 < sam_moore> Yeah, I wasn't sure what I should do there, but I think Sensor_Handler is the only place you can really deal with that
+09:07 < jtanx> yeah
+09:07 < sam_moore> I did have it calling FCGI_RejectJSON if the sensor id was invalid
+09:08 < jtanx> the current code on git just calls Log
+09:08 < sam_moore> But I must have done something wrong, because the normal JSON was getting printed just after that
+09:08 < sam_moore> So I removed it
+09:08 < jtanx> oh yeah
+09:08 < jtanx> you have to return after FCGI_RejectJSON
+09:08 < sam_moore> Ah
+09:08 < sam_moore> Durr
+09:08 < jtanx> :P
+09:09 < jtanx> anyways I'll look through and see if I can fix stuff up
+09:09 < jtanx> then I'll try and do that start/stop stuf
+09:10 < sam_moore> Ok
+09:10 < sam_moore> I put in Sensor_Start and Sensor_Stop which might help
+09:10 < sam_moore> I thought you might want to pause data collection without actually "stopping" the experiment?
+09:11 < jtanx> ok
+09:11 < jtanx> that might be a good idea
+09:11 < sam_moore> And also it should be fairly easy to implement a Sensor_Load if we want to be able to load previous experiments
+09:11 < jtanx> yeah
+09:38 < jtanx> those issues with fread
+09:38 < jtanx> it could be because you didn't specify the 'b' flag in fopen
+09:38 < jtanx> ?
+09:39 < jtanx> // Clear the FILE*s
+09:39 < jtanx> df->read_file = NULL;
+09:39 < jtanx> df->write_file = NULL;
+09:39 < jtanx> fclose(df->write_file);
+09:52 < sam_moore> Oh... hurdur
+09:52 < sam_moore> Wait how is it working at all
+09:52 < sam_moore> The write file is mode "w+" which should make it plain text
+09:53 < jtanx> so it's no longer a binary file?
+09:53 < jtanx> I think i may not be experiencing the same issues as you just because I'm running everything on single core processors
+09:53 < sam_moore> Well... it certainly looks like a binary file when you try and cat it
+09:53 < jtanx> ok
+09:53 < jtanx> it's probably a good idea to stick to one file pointer and use mutexes
+09:53 < sam_moore> Yeah
+09:53 < sam_moore> But also make sure that file is binary
+09:53 < jtanx> yeah
+09:54 < sam_moore> It's probably compiler specific what happens when you use fwrite and fread on a plain text file
+09:54 < jtanx> probably
+09:54 < sam_moore> But it looks like a binary file to me, so I'm not sure that's related to the problems with fread
+09:54 < sam_moore> I can investigate this by changing like 4 characters...
+09:55 < jtanx> one thing I did notice on linux
+09:55 < jtanx> if it wasn't a binary file you'd have to use fflush to explicitly write out text and have it appear when you used cat
+09:56 < jtanx> but overall I think it's not due to it being a binary file or not
+09:56 < sam_moore> Yep
+09:56 < sam_moore> I just put the second FILE* for read_file back in
+09:56 < sam_moore> Made them both binary
+09:56 < sam_moore> Still get the "Transport endpoint is not connected" errors
+09:57 < sam_moore> So there should be a "b" in the file mode, but that's unrelated to having multiple FILE*
+09:57 < jtanx> yep then I think that's due to you running it on a multicore processor
+09:57 < jtanx> maybe
+09:57 < sam_moore> I think the OS locks around file access are based on PID
+09:58 < jtanx> on linux all file locks are advisory only
+09:58 < sam_moore> Can
+09:58 < sam_moore> Anyway, it's clearly safest to just have one FILE*
+09:58 < jtanx> yeah
+09:58 < jtanx> I'm changing it now
+10:09 < jtanx> oh ffs that's the second time it's crashed simply because I didn't do make clean before make
+10:16 < sam_moore> haha
+10:17 < sam_moore> Modify the make file to always run make clean?
+10:28 < jtanx> haha that's one option
+10:28 < jtanx> it's because make doesn't consider changes to the header files
+10:28 < jtanx> there's a way to make it detect those, but *effort*
+10:40 < sam_moore> Regarding Actuators, I think if we design for a thread to control (one or more) actuators that will make it easy to add more advanced control later
+10:42 < sam_moore> eg: The Actuator_Handler just sets some kind of formula or says "Every time sensor 0 is stable for Xs (within a range) change actuator by Y" and the thread watches the sensor data and changes the actuator when necessary
+10:43 < sam_moore> You could also add feedback that way too
+10:44 < sam_moore> "Set this actuator so that sensor 0 has value X"
+10:46 < jtanx> hmm
+10:47 < jtanx> about the sensor stuff
+10:47 < jtanx> there were a few things I noticed
+10:48 < jtanx> the time wrapping
+10:48 < jtanx> could still give a negative start_time or end_time
+10:48 < jtanx> if the user specified a very negative start_time/end_time
+10:49 < jtanx> (eg specifies a negative time greater than the total running time)
+10:49 < sam_moore> Oh yeah
+10:49 < jtanx> so in data_printbytimes
+10:49 < jtanx> I just clamped it to zero
+10:49 < jtanx> instead of asserting
+10:49 < sam_moore> Fair enough
+10:49 < jtanx> strangely this code seems to work pretty good:
+10:49 < jtanx> void Data_PrintByTimes(DataFile * df, double start_time, double end_time, DataFormat format)
+10:49 < jtanx> {
+10:49 < jtanx> assert(df != NULL);
+10:49 < jtanx> //Clamp boundaries
+10:49 < jtanx> if (start_time < 0)
+10:49 < jtanx> start_time = 0;
+10:50 < jtanx> if (end_time < 0)
+10:50 < jtanx> end_time = 0;
+10:50 < jtanx> int start_index = 0, end_index = 0;
+10:50 < jtanx> if (start_time < end_time)
+10:50 < jtanx> {
+10:50 < jtanx> start_index = Data_FindByTime(df, start_time, NULL);
+10:50 < jtanx> end_index = Data_FindByTime(df, end_time, NULL);
+10:50 < jtanx> }
+10:50 < jtanx> Data_PrintByIndexes(df, start_index, end_index, format);
+10:50 < jtanx> }
+10:50 < jtanx> oh but that was the other ting
+10:50 < jtanx> it works better if you have exclusive end index/time
+10:50 < sam_moore> Ok
+10:50 < sam_moore> I have to go now
+10:50 < jtanx> ok
+10:50 < sam_moore> See you this afternoon if you're still there
+10:50 < jtanx> yep see you then
+10:51 < jtanx> probably
+13:44 < callum> should i just add the sensor threshold values to the sensor struct?
+13:47 < jtanx> probably not
+13:47 < jtanx> I think you have to create a new struct
+13:48 < jtanx> are you at uni?
+13:49 < callum> yea. why is a new struct necessary?
+13:49 < jtanx> come to g19
+13:49 < jtanx> the bbb is setup too
+16:17 < sam_moore> Are you guys still in G19?
+16:17 < sam_moore> On my way now
+18:42 < jtanx> lol you need to use a transistor to turn on an led from the gpio pins
+19:56 < jtanx> ok I think I'll just escape all input parameters from within the request loop
+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]"]