@@ -1,52 +1,52 | |||||
1 | import os |
|
1 | import os | |
2 | import json |
|
2 | import json | |
3 |
|
3 | |||
4 | from datetime import datetime |
|
4 | from datetime import datetime | |
5 |
|
5 | |||
6 | from pymongo import MongoClient |
|
6 | from pymongo import MongoClient | |
7 |
|
7 | |||
8 | from channels.handler import AsgiHandler |
|
8 | from channels.handler import AsgiHandler | |
9 | from channels.auth import channel_session_user |
|
9 | from channels.auth import channel_session_user | |
10 | from channels import Group |
|
10 | from channels import Group | |
11 |
|
11 | |||
12 | host = os.environ.get('HOST_MONGO', 'localhost') |
|
12 | host = os.environ.get('HOST_MONGO', 'localhost') | |
13 | CLIENT = MongoClient('{}:27017'.format(host)) |
|
13 | CLIENT = MongoClient('{}:27017'.format(host)) | |
14 | DB = CLIENT['dbplots'] |
|
14 | DB = CLIENT['dbplots'] | |
15 |
|
15 | |||
16 | # Connected to websocket.connect |
|
16 | # Connected to websocket.connect | |
17 | def ws_connect(message, code, plot): |
|
17 | def ws_connect(message, code, plot): | |
18 | message.reply_channel.send({'accept': True}) |
|
18 | message.reply_channel.send({'accept': True}) | |
19 | pk = message.content['query_string'].split('=')[1] |
|
19 | pk = message.content['query_string'].split('=')[1] | |
20 | Group('{}_{}'.format(pk, plot)).add(message.reply_channel) |
|
20 | Group('{}_{}'.format(pk, plot)).add(message.reply_channel) | |
21 |
print('New connection from: {}, |
|
21 | print('New connection from: {}, Group: {}_{}'.format(message.content['client'][0], pk, plot)) | |
22 |
|
22 | |||
23 | def ws_message(message, code, plot): |
|
23 | def ws_message(message, code, plot): | |
24 | # Accept the incoming connection |
|
24 | # Accept the incoming connection | |
25 | print 'incoming message' |
|
25 | print 'incoming message' | |
26 | dt = datetime.strptime(str(json.loads(message.content['text'])['date']), '%d/%m/%Y') |
|
26 | dt = datetime.strptime(str(json.loads(message.content['text'])['date']), '%d/%m/%Y') | |
27 | exp = DB.exp_meta.find_one({'code': int(code), 'date': dt}) |
|
27 | exp = DB.exp_meta.find_one({'code': int(code), 'date': dt}) | |
28 | print exp |
|
28 | ||
29 | if exp: |
|
29 | if exp and plot in exp['plots']: | |
30 | if plot == 'spc': |
|
30 | if plot == 'spc': | |
31 | datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', -1).limit(1)[0] |
|
31 | datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', -1).limit(1)[0] | |
32 | exp['time'] = [datas['time']] |
|
32 | exp['time'] = [datas['time']] | |
33 | exp['spc'] = datas['data']['spc'] |
|
33 | exp['spc'] = datas['data']['spc'] | |
34 | exp['rti'] = datas['data']['rti'] |
|
34 | exp['rti'] = datas['data']['rti'] | |
35 | exp['noise'] = datas['data']['noise'] |
|
35 | exp['noise'] = datas['data']['noise'] | |
36 | else: |
|
36 | else: | |
37 | datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', 1) |
|
37 | datas = DB.exp_data.find({'expmeta': exp['_id']}, ['time', 'data']).sort('time', 1) | |
38 | print 'Counting...' |
|
38 | print 'Counting...' | |
39 | print datas.count() |
|
39 | print datas.count() | |
40 | dum = [(d['time'], d['data'][plot]) for d in datas] |
|
40 | dum = [(d['time'], d['data'][plot]) for d in datas] | |
41 | exp['time'] = [d[0] for d in dum] |
|
41 | exp['time'] = [d[0] for d in dum] | |
42 | dum = [d[1] for d in dum] |
|
42 | dum = [d[1] for d in dum] | |
43 | exp[plot] = map(list, zip(*dum)) |
|
43 | exp[plot] = map(list, zip(*dum)) | |
44 | exp.pop('date', None) |
|
44 | exp.pop('date', None) | |
45 | exp.pop('_id', None) |
|
45 | exp.pop('_id', None) | |
46 | message.reply_channel.send({'text': json.dumps(exp)}) |
|
46 | message.reply_channel.send({'text': json.dumps(exp)}) | |
47 | else: |
|
47 | else: | |
48 | message.reply_channel.send({'text': json.dumps({'interval': 0})}) |
|
48 | message.reply_channel.send({'text': json.dumps({'interval': 0})}) | |
49 |
|
49 | |||
50 | # Connected to websocket.disconnect |
|
50 | # Connected to websocket.disconnect | |
51 | def ws_disconnect(message, code, plot): |
|
51 | def ws_disconnect(message, code, plot): | |
52 | Group('{}_{}'.format(code, plot)).discard(message.reply_channel) |
|
52 | Group('{}_{}'.format(code, plot)).discard(message.reply_channel) |
@@ -1,454 +1,455 | |||||
1 |
|
1 | |||
2 |
|
2 | |||
3 | class PcolorBuffer{ |
|
3 | class PcolorBuffer{ | |
4 | constructor({div, data, key, props}){ |
|
4 | constructor({div, data, key, props}){ | |
5 | this.div = document.getElementById(div); |
|
5 | this.div = document.getElementById(div); | |
6 | this.n = 0 |
|
6 | this.n = 0 | |
7 | this.divs = []; |
|
7 | this.divs = []; | |
8 | this.wait = false; |
|
8 | this.wait = false; | |
9 | this.key = key; |
|
9 | this.key = key; | |
10 | this.timer = (props.throttle || 30)*1000; |
|
10 | this.timer = (props.throttle || 30)*1000; | |
11 | this.lastRan = Date.now(); |
|
11 | this.lastRan = Date.now(); | |
12 | this.lastFunc = null; |
|
12 | this.lastFunc = null; | |
13 | this.zbuffer = []; |
|
13 | this.zbuffer = []; | |
14 | this.xbuffer = []; |
|
14 | this.xbuffer = []; | |
15 | this.empty = Array(data.yrange.length).fill(null); |
|
15 | this.empty = Array(data.yrange.length).fill(null); | |
16 | this.props = props; |
|
16 | this.props = props; | |
17 | this.setup(data); |
|
17 | this.setup(data); | |
18 | } |
|
18 | } | |
19 |
|
19 | |||
20 | setup(data){ |
|
20 | setup(data){ | |
21 | this.last = data.time.slice(-1); |
|
21 | this.last = data.time.slice(-1); | |
22 | if (data.time.length == 1){ |
|
22 | if (data.time.length == 1){ | |
23 | var values = { 'time': data.time, 'data': data[this.key].map(function(x) {return [x]})}; |
|
23 | var values = { 'time': data.time, 'data': data[this.key].map(function(x) {return [x]})}; | |
24 | }else{ |
|
24 | }else{ | |
25 | var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length); |
|
25 | var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length); | |
26 | } |
|
26 | } | |
27 |
|
27 | |||
28 | var t = values.time.map(function(x) { return new Date(x*1000); }); |
|
28 | var t = values.time.map(function(x) { return new Date(x*1000); }); | |
29 |
|
29 | |||
30 | for (var i = 0; i < data[this.key].length; i++){ |
|
30 | for (var i = 0; i < data[this.key].length; i++){ | |
31 | var layout = { |
|
31 | var layout = { | |
32 | xaxis: { |
|
32 | xaxis: { | |
33 | title: 'Time', |
|
33 | title: 'Time', | |
34 | showgrid: false, |
|
34 | showgrid: false, | |
35 | }, |
|
35 | }, | |
36 | yaxis: { |
|
36 | yaxis: { | |
37 | title: 'km', |
|
37 | title: 'km', | |
38 | showgrid: false, |
|
38 | showgrid: false, | |
39 | }, |
|
39 | }, | |
40 | titlefont: { |
|
40 | titlefont: { | |
41 | size: 14, |
|
41 | size: 14, | |
42 | } |
|
42 | } | |
43 | }; |
|
43 | }; | |
44 | var iDiv = document.createElement('div'); |
|
44 | var iDiv = document.createElement('div'); | |
45 | iDiv.id = 'plot-' + i; |
|
45 | iDiv.id = 'plot-' + i; | |
46 | this.zbuffer.push([]); |
|
46 | this.zbuffer.push([]); | |
47 | this.n = this.n + 1; |
|
47 | this.n = this.n + 1; | |
48 | this.div.appendChild(iDiv); |
|
48 | this.div.appendChild(iDiv); | |
49 | this.divs.push(iDiv.id); |
|
49 | this.divs.push(iDiv.id); | |
50 | var trace = { |
|
50 | var trace = { | |
51 | z: values.data[i], |
|
51 | z: values.data[i], | |
52 | x: t, |
|
52 | x: t, | |
53 | y: data.yrange, |
|
53 | y: data.yrange, | |
54 | colorscale: this.props.colormap || 'Viridis', |
|
54 | colorscale: this.props.colormap || 'Viridis', | |
55 | transpose: true, |
|
55 | transpose: true, | |
56 | type: 'heatmap' |
|
56 | type: 'heatmap' | |
57 | }; |
|
57 | }; | |
58 |
|
58 | |||
59 | if (this.props.zmin) {trace.zmin = this.props.zmin} |
|
59 | if (this.props.zmin) {trace.zmin = this.props.zmin} | |
60 | if (this.props.zmax) {trace.zmax = this.props.zmax} |
|
60 | if (this.props.zmax) {trace.zmax = this.props.zmax} | |
61 |
|
61 | |||
62 | layout.title = 'Channel ' + i + ' - ' + t.slice(-1).toLocaleString(); |
|
62 | layout.title = 'Channel ' + i + ' - ' + t.slice(-1).toLocaleString(); | |
63 | var conf = { |
|
63 | var conf = { | |
64 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], |
|
64 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], | |
65 | displaylogo: false, |
|
65 | displaylogo: false, | |
66 | showTips: true |
|
66 | showTips: true | |
67 | }; |
|
67 | }; | |
68 | Plotly.newPlot('plot-'+i, [trace], layout, conf); |
|
68 | Plotly.newPlot('plot-'+i, [trace], layout, conf); | |
69 | } |
|
69 | } | |
70 | } |
|
70 | } | |
71 |
|
71 | |||
72 | getSize(){ |
|
72 | getSize(){ | |
73 | var div = document.getElementById(this.divs[0]); |
|
73 | var div = document.getElementById(this.divs[0]); | |
74 | var t = this.xbuffer.slice(-1)[0]; |
|
74 | var t = this.xbuffer.slice(-1)[0]; | |
75 | var n = 0; |
|
75 | var n = 0; | |
76 | var timespan = (this.props.timespan || 8)*1000*60*60; |
|
76 | var timespan = (this.props.timespan || 8)*1000*60*60; | |
77 |
|
77 | |||
78 | while ((t-div.data[0].x[n]) > timespan){ |
|
78 | while ((t-div.data[0].x[n]) > timespan){ | |
79 | n += 1; |
|
79 | n += 1; | |
80 | } |
|
80 | } | |
81 | return n; |
|
81 | return n; | |
82 | } |
|
82 | } | |
83 |
|
83 | |||
84 | fill_gaps(xBuffer, zBuffer, interval, N){ |
|
84 | fill_gaps(xBuffer, zBuffer, interval, N){ | |
85 |
|
85 | |||
86 | var x = [xBuffer[0]]; |
|
86 | var x = [xBuffer[0]]; | |
87 | var z = []; |
|
87 | var z = []; | |
88 | var last; |
|
88 | var last; | |
89 |
|
89 | |||
90 | for (var j = 0; j < N; j++){ |
|
90 | for (var j = 0; j < N; j++){ | |
91 | z.push([zBuffer[j][0]]); |
|
91 | z.push([zBuffer[j][0]]); | |
92 | } |
|
92 | } | |
93 |
|
93 | |||
94 | for (var i = 1; i < xBuffer.length; i++){ |
|
94 | for (var i = 1; i < xBuffer.length; i++){ | |
95 | var cnt = 0; |
|
95 | var cnt = 0; | |
96 | last = x.slice(-1)[0]; |
|
96 | last = x.slice(-1)[0]; | |
97 | while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){ |
|
97 | while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){ | |
98 | cnt += 1; |
|
98 | cnt += 1; | |
99 | last = last+interval; |
|
99 | last = last+interval; | |
100 | x.push(last); |
|
100 | x.push(last); | |
101 | for (var j = 0; j < N; j++){ |
|
101 | for (var j = 0; j < N; j++){ | |
102 | z[j].push(this.empty); |
|
102 | z[j].push(this.empty); | |
103 | } |
|
103 | } | |
104 | // Avoid infinite loop |
|
104 | // Avoid infinite loop | |
105 | if (cnt==100){break;} |
|
105 | if (cnt==100){break;} | |
106 | } |
|
106 | } | |
107 | x.push(xBuffer[i]); |
|
107 | x.push(xBuffer[i]); | |
108 | for (var j = 0; j < N; j++){ |
|
108 | for (var j = 0; j < N; j++){ | |
109 | z[j].push(zBuffer[j][i]); |
|
109 | z[j].push(zBuffer[j][i]); | |
110 | } |
|
110 | } | |
111 | } |
|
111 | } | |
112 |
|
112 | |||
113 | return {'time':x, 'data':z}; |
|
113 | return {'time':x, 'data':z}; | |
114 | } |
|
114 | } | |
115 |
|
115 | |||
116 | plot(){ |
|
116 | plot(){ | |
117 | // add new data to plots and empty buffers |
|
117 | // add new data to plots and empty buffers | |
118 | var N = this.getSize(); |
|
118 | var N = this.getSize(); | |
119 | console.log('Plotting...'); |
|
119 | console.log('Plotting...'); | |
120 | for (var i = 0; i < this.n; i++){ |
|
120 | for (var i = 0; i < this.n; i++){ | |
121 | var div = document.getElementById(this.divs[i]); |
|
121 | var div = document.getElementById(this.divs[i]); | |
122 | if (N > 0){ |
|
122 | if (N > 0){ | |
123 | div.data[0].z = div.data[0].z.slice(N,) |
|
123 | div.data[0].z = div.data[0].z.slice(N,) | |
124 | div.data[0].x = div.data[0].x.slice(N,) |
|
124 | div.data[0].x = div.data[0].x.slice(N,) | |
125 | } |
|
125 | } | |
126 | Plotly.extendTraces(div, { |
|
126 | Plotly.extendTraces(div, { | |
127 | z: [this.zbuffer[i]], |
|
127 | z: [this.zbuffer[i]], | |
128 | x: [this.xbuffer] |
|
128 | x: [this.xbuffer] | |
129 | }, [0]); |
|
129 | }, [0]); | |
130 | this.zbuffer[i] = []; |
|
130 | this.zbuffer[i] = []; | |
131 | } |
|
131 | } | |
132 | this.xbuffer = []; |
|
132 | this.xbuffer = []; | |
133 | } |
|
133 | } | |
134 |
|
134 | |||
135 | update(obj){ |
|
135 | update(obj){ | |
136 |
|
136 | |||
137 | // fill data gaps |
|
137 | // fill data gaps | |
138 | var cnt = 0; |
|
138 | var cnt = 0; | |
139 | while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){ |
|
139 | while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){ | |
140 | cnt += 1; |
|
140 | cnt += 1; | |
141 | this.last += obj.interval; |
|
141 | this.last += obj.interval; | |
142 | var newt = new Date((this.last)*1000); |
|
142 | var newt = new Date((this.last)*1000); | |
143 | this.xbuffer.push(newt); |
|
143 | this.xbuffer.push(newt); | |
144 | for (var i = 0; i < obj[this.key].length; i++){ |
|
144 | for (var i = 0; i < obj[this.key].length; i++){ | |
145 | this.zbuffer[i].push(this.empty); |
|
145 | this.zbuffer[i].push(this.empty); | |
146 | } |
|
146 | } | |
147 | // Avoid infinite loop |
|
147 | // Avoid infinite loop | |
148 | if (cnt==100){break;} |
|
148 | if (cnt==100){break;} | |
149 | } |
|
149 | } | |
150 |
|
150 | |||
151 | // update buffers |
|
151 | // update buffers | |
152 | this.last = parseFloat(obj.time[0]); |
|
152 | this.last = parseFloat(obj.time[0]); | |
153 | var t = new Date(obj.time[0]*1000); |
|
153 | var t = new Date(obj.time[0]*1000); | |
154 | this.xbuffer.push(t); |
|
154 | this.xbuffer.push(t); | |
155 | for (var i = 0; i < obj[this.key].length; i++){ |
|
155 | for (var i = 0; i < obj[this.key].length; i++){ | |
156 | this.zbuffer[i].push(obj[this.key][i]); |
|
156 | this.zbuffer[i].push(obj[this.key][i]); | |
157 | // update title |
|
157 | // update title | |
|
158 | var title = this.props.title || '' | |||
158 |
|
|
159 | var div = document.getElementById(this.divs[i]); | |
159 | Plotly.relayout(div, { |
|
160 | Plotly.relayout(div, { | |
160 | title: 'Channel ' + i + ' - ' + t.toLocaleString(), |
|
161 | title: title + ': Channel ' + i + ' - ' + t.toLocaleString(), | |
161 | }); |
|
162 | }); | |
162 | } |
|
163 | } | |
163 |
|
164 | |||
164 | // plot when ready (every 10 secs) |
|
165 | // plot when ready (every 10 secs) | |
165 | if (!this.wait){ |
|
166 | if (!this.wait){ | |
166 | this.plot(); |
|
167 | this.plot(); | |
167 | this.wait = true; |
|
168 | this.wait = true; | |
168 | } else { |
|
169 | } else { | |
169 | clearTimeout(this.lastFunc) |
|
170 | clearTimeout(this.lastFunc) | |
170 | this.lastFunc = setTimeout(function(scope) { |
|
171 | this.lastFunc = setTimeout(function(scope) { | |
171 | if ((Date.now() - scope.lastRan) >= scope.timer) { |
|
172 | if ((Date.now() - scope.lastRan) >= scope.timer) { | |
172 | scope.plot() |
|
173 | scope.plot() | |
173 | scope.lastRan = Date.now() |
|
174 | scope.lastRan = Date.now() | |
174 | } |
|
175 | } | |
175 | }, this.timer - (Date.now() - this.lastRan), this) |
|
176 | }, this.timer - (Date.now() - this.lastRan), this) | |
176 | } |
|
177 | } | |
177 | } |
|
178 | } | |
178 | } |
|
179 | } | |
179 |
|
180 | |||
180 | class Pcolor{ |
|
181 | class Pcolor{ | |
181 | constructor({div, data, props}){ |
|
182 | constructor({div, data, props}){ | |
182 | this.div = document.getElementById(div); |
|
183 | this.div = document.getElementById(div); | |
183 | this.n = 0 |
|
184 | this.n = 0 | |
184 | this.divs = []; |
|
185 | this.divs = []; | |
185 | this.props = props; |
|
186 | this.props = props; | |
186 | this.setup(data); |
|
187 | this.setup(data); | |
187 | } |
|
188 | } | |
188 |
|
189 | |||
189 | setup(data){ |
|
190 | setup(data){ | |
190 | console.log(data); |
|
191 | console.log(data); | |
191 | for (var i = 0; i < data.spc.length; i++){ |
|
192 | for (var i = 0; i < data.spc.length; i++){ | |
192 | var layout = { |
|
193 | var layout = { | |
193 | height: 400, |
|
194 | height: 400, | |
194 | xaxis: { |
|
195 | xaxis: { | |
195 | title: 'Velocity', |
|
196 | title: 'Velocity', | |
196 | showgrid: false, |
|
197 | showgrid: false, | |
197 | zeroline: false, |
|
198 | zeroline: false, | |
198 | domain: [0, 0.7], |
|
199 | domain: [0, 0.7], | |
199 | }, |
|
200 | }, | |
200 | yaxis: { |
|
201 | yaxis: { | |
201 | title: 'km', |
|
202 | title: 'km', | |
202 | showgrid: false, |
|
203 | showgrid: false, | |
203 | }, |
|
204 | }, | |
204 | xaxis2: { |
|
205 | xaxis2: { | |
205 | title: 'dB', |
|
206 | title: 'dB', | |
206 | domain: [0.75, 1], |
|
207 | domain: [0.75, 1], | |
207 | ticks: 'outside', |
|
208 | ticks: 'outside', | |
208 | }, |
|
209 | }, | |
209 | titlefont: { |
|
210 | titlefont: { | |
210 | size: 14, |
|
211 | size: 14, | |
211 | } |
|
212 | } | |
212 | }; |
|
213 | }; | |
213 | var iDiv = document.createElement('div'); |
|
214 | var iDiv = document.createElement('div'); | |
214 | iDiv.id = 'plot-' + i; |
|
215 | iDiv.id = 'plot-' + i; | |
215 | iDiv.className += iDiv.className ? ' col-md-6' : 'col-md-6'; |
|
216 | iDiv.className += iDiv.className ? ' col-md-6' : 'col-md-6'; | |
216 | this.n = this.n + 1; |
|
217 | this.n = this.n + 1; | |
217 | this.div.appendChild(iDiv); |
|
218 | this.div.appendChild(iDiv); | |
218 | this.divs.push(iDiv.id); |
|
219 | this.divs.push(iDiv.id); | |
219 |
|
220 | |||
220 | var trace1 = { |
|
221 | var trace1 = { | |
221 | z: data.spc[i], |
|
222 | z: data.spc[i], | |
222 | x: data.xrange, |
|
223 | x: data.xrange, | |
223 | y: data.yrange, |
|
224 | y: data.yrange, | |
224 | colorscale: this.props.colormap || 'Viridis', |
|
225 | colorscale: this.props.colormap || 'Viridis', | |
225 | transpose: true, |
|
226 | transpose: true, | |
226 | type: 'heatmap' |
|
227 | type: 'heatmap' | |
227 | }; |
|
228 | }; | |
228 |
|
229 | |||
229 | var trace2 = { |
|
230 | var trace2 = { | |
230 | x: data.rti[i], |
|
231 | x: data.rti[i], | |
231 | y: data.yrange, |
|
232 | y: data.yrange, | |
232 | xaxis: 'x2', |
|
233 | xaxis: 'x2', | |
233 | yaxis: 'y', |
|
234 | yaxis: 'y', | |
234 | type: 'scatter', |
|
235 | type: 'scatter', | |
235 | }; |
|
236 | }; | |
236 |
|
237 | |||
237 | if (this.props.zmin) { |
|
238 | if (this.props.zmin) { | |
238 | trace1.zmin = this.props.zmin |
|
239 | trace1.zmin = this.props.zmin | |
239 | } |
|
240 | } | |
240 | if (this.props.zmax) { |
|
241 | if (this.props.zmax) { | |
241 | trace1.zmax = this.props.zmax; |
|
242 | trace1.zmax = this.props.zmax; | |
242 | layout.xaxis2.range = [this.props.zmin, this.props.zmax] |
|
243 | layout.xaxis2.range = [this.props.zmin, this.props.zmax] | |
243 | } |
|
244 | } | |
244 |
|
245 | |||
245 | var t = new Date(data.time*1000); |
|
246 | var t = new Date(data.time*1000); | |
246 | layout.title = 'Channel ' + i + ': ' + data.noise[i]+'dB - ' + t.toLocaleString(); |
|
247 | layout.title = 'Channel ' + i + ': ' + data.noise[i]+'dB - ' + t.toLocaleString(); | |
247 | var conf = { |
|
248 | var conf = { | |
248 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], |
|
249 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], | |
249 | displaylogo: false, |
|
250 | displaylogo: false, | |
250 | showTips: true |
|
251 | showTips: true | |
251 | }; |
|
252 | }; | |
252 | Plotly.newPlot('plot-'+i, [trace1, trace2], layout, conf); |
|
253 | Plotly.newPlot('plot-'+i, [trace1, trace2], layout, conf); | |
253 | } |
|
254 | } | |
254 | } |
|
255 | } | |
255 |
|
256 | |||
256 | plot(obj){ |
|
257 | plot(obj){ | |
257 |
|
258 | |||
258 | // add new data to plots and empty buffers |
|
259 | // add new data to plots and empty buffers | |
259 | console.log('Plotting...'); |
|
260 | console.log('Plotting...'); | |
260 | var t = new Date(obj.time[0]*1000); |
|
261 | var t = new Date(obj.time[0]*1000); | |
261 | for (var i = 0; i < this.n; i++){ |
|
262 | for (var i = 0; i < this.n; i++){ | |
262 | var div = document.getElementById(this.divs[i]); |
|
263 | var div = document.getElementById(this.divs[i]); | |
263 | Plotly.relayout(div, { |
|
264 | Plotly.relayout(div, { | |
264 | title: 'Channel ' + i + ': ' + obj.noise[i]+'dB - ' + t.toLocaleString(), |
|
265 | title: 'Channel ' + i + ': ' + obj.noise[i]+'dB - ' + t.toLocaleString(), | |
265 | }); |
|
266 | }); | |
266 | Plotly.restyle(div, { |
|
267 | Plotly.restyle(div, { | |
267 | z: [obj.spc[i], null], |
|
268 | z: [obj.spc[i], null], | |
268 | x: [obj.xrange, obj.rti[i]] |
|
269 | x: [obj.xrange, obj.rti[i]] | |
269 | }, [0, 1]); |
|
270 | }, [0, 1]); | |
270 | } |
|
271 | } | |
271 | } |
|
272 | } | |
272 | } |
|
273 | } | |
273 |
|
274 | |||
274 | class Scatter{ |
|
275 | class Scatter{ | |
275 | constructor({div, data, key, props}){ |
|
276 | constructor({div, data, key, props}){ | |
276 | this.div = document.getElementById(div); |
|
277 | this.div = document.getElementById(div); | |
277 | this.n = 0 |
|
278 | this.n = 0 | |
278 | this.key = key; |
|
279 | this.key = key; | |
279 | this.wait = false; |
|
280 | this.wait = false; | |
280 | this.timer = (props.throttle || 30)*1000; |
|
281 | this.timer = (props.throttle || 30)*1000; | |
281 | this.lastRan = Date.now(); |
|
282 | this.lastRan = Date.now(); | |
282 | this.lastFunc = null; |
|
283 | this.lastFunc = null; | |
283 | this.ybuffer = []; |
|
284 | this.ybuffer = []; | |
284 | this.xbuffer = []; |
|
285 | this.xbuffer = []; | |
285 | this.props = props; |
|
286 | this.props = props; | |
286 | this.setup(data); |
|
287 | this.setup(data); | |
287 | } |
|
288 | } | |
288 |
|
289 | |||
289 | setup(data){ |
|
290 | setup(data){ | |
290 |
|
291 | |||
291 | var traces = []; |
|
292 | var traces = []; | |
292 | this.last = data.time.slice(-1); |
|
293 | this.last = data.time.slice(-1); | |
293 | if (data.time.length == 1){ |
|
294 | if (data.time.length == 1){ | |
294 | var values = { 'time': data.time, 'data': data[this.key] }; |
|
295 | var values = { 'time': data.time, 'data': data[this.key] }; | |
295 | }else{ |
|
296 | }else{ | |
296 | var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length); |
|
297 | var values = this.fill_gaps(data.time, data[this.key], data.interval, data[this.key].length); | |
297 | } |
|
298 | } | |
298 |
|
299 | |||
299 | var t = values.time.map(function(x) { return new Date(x*1000); }); |
|
300 | var t = values.time.map(function(x) { return new Date(x*1000); }); | |
300 |
|
301 | |||
301 | for (var i = 0; i < data[this.key].length; i++){ |
|
302 | for (var i = 0; i < data[this.key].length; i++){ | |
302 |
|
303 | |||
303 | this.n = this.n + 1; |
|
304 | this.n = this.n + 1; | |
304 | this.ybuffer.push([]); |
|
305 | this.ybuffer.push([]); | |
305 | var trace = { |
|
306 | var trace = { | |
306 | x: t, |
|
307 | x: t, | |
307 | y: data[this.key][i], |
|
308 | y: data[this.key][i], | |
308 | mode: 'lines', |
|
309 | mode: 'lines', | |
309 | type: 'scatter', |
|
310 | type: 'scatter', | |
310 | name: 'Channel ' + i |
|
311 | name: 'Channel ' + i | |
311 | }; |
|
312 | }; | |
312 |
|
313 | |||
313 | traces.push(trace); |
|
314 | traces.push(trace); | |
314 | } |
|
315 | } | |
315 | var title = this.props.title || '' |
|
316 | var title = this.props.title || '' | |
316 | var layout = { |
|
317 | var layout = { | |
317 | // autosize: false, |
|
318 | // autosize: false, | |
318 | // width: 800, |
|
319 | // width: 800, | |
319 | // height: 400, |
|
320 | // height: 400, | |
320 | title: title + ' - ' + t.slice(-1).toLocaleString(), |
|
321 | title: title + ' - ' + t.slice(-1).toLocaleString(), | |
321 | xaxis: { |
|
322 | xaxis: { | |
322 | title: 'Time', |
|
323 | title: 'Time', | |
323 | linecolor: 'black', |
|
324 | linecolor: 'black', | |
324 | }, |
|
325 | }, | |
325 | yaxis: { |
|
326 | yaxis: { | |
326 | title: this.props.ylabel || 'dB', |
|
327 | title: this.props.ylabel || 'dB', | |
327 | linecolor: 'black', |
|
328 | linecolor: 'black', | |
328 | }, |
|
329 | }, | |
329 | titlefont: { |
|
330 | titlefont: { | |
330 | size: 14, |
|
331 | size: 14, | |
331 | } |
|
332 | } | |
332 | }; |
|
333 | }; | |
333 |
|
334 | |||
334 | if (this.props.ymin) {layout.yaxis.range = [this.props.ymin, this.props.ymax] } |
|
335 | if (this.props.ymin) {layout.yaxis.range = [this.props.ymin, this.props.ymax] } | |
335 |
|
336 | |||
336 | var conf = { |
|
337 | var conf = { | |
337 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], |
|
338 | modeBarButtonsToRemove: ['sendDataToCloud', 'autoScale2d', 'hoverClosestCartesian', 'hoverCompareCartesian', 'lasso2d', 'select2d', 'zoomIn2d', 'zoomOut2d', 'toggleSpikelines'], | |
338 | displaylogo: false, |
|
339 | displaylogo: false, | |
339 | showTips: true |
|
340 | showTips: true | |
340 | }; |
|
341 | }; | |
341 | Plotly.newPlot('plot', traces, layout, conf); |
|
342 | Plotly.newPlot('plot', traces, layout, conf); | |
342 | } |
|
343 | } | |
343 |
|
344 | |||
344 | getSize(){ |
|
345 | getSize(){ | |
345 | var t = this.xbuffer.slice(-1)[0]; |
|
346 | var t = this.xbuffer.slice(-1)[0]; | |
346 | var n = 0; |
|
347 | var n = 0; | |
347 | var timespan = (this.props.timespan || 12)*1000*60*60; |
|
348 | var timespan = (this.props.timespan || 12)*1000*60*60; | |
348 |
|
349 | |||
349 | while ((t-this.div.data[0].x[n]) > timespan){ |
|
350 | while ((t-this.div.data[0].x[n]) > timespan){ | |
350 | n += 1; |
|
351 | n += 1; | |
351 | } |
|
352 | } | |
352 | return n; |
|
353 | return n; | |
353 | } |
|
354 | } | |
354 |
|
355 | |||
355 | fill_gaps(xBuffer, yBuffer, interval, N){ |
|
356 | fill_gaps(xBuffer, yBuffer, interval, N){ | |
356 |
|
357 | |||
357 | var x = [xBuffer[0]]; |
|
358 | var x = [xBuffer[0]]; | |
358 | var y = []; |
|
359 | var y = []; | |
359 |
|
360 | |||
360 | for (var j = 0; j < N; j++){ |
|
361 | for (var j = 0; j < N; j++){ | |
361 | y.push([yBuffer[j][0]]); |
|
362 | y.push([yBuffer[j][0]]); | |
362 | } |
|
363 | } | |
363 |
|
364 | |||
364 | var last; |
|
365 | var last; | |
365 |
|
366 | |||
366 | for (var i = 1; i < xBuffer.length; i++){ |
|
367 | for (var i = 1; i < xBuffer.length; i++){ | |
367 | var cnt = 0; |
|
368 | var cnt = 0; | |
368 | last = x.slice(-1)[0]; |
|
369 | last = x.slice(-1)[0]; | |
369 | while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){ |
|
370 | while (Math.abs(parseFloat(xBuffer[i])-last-parseFloat(interval))>0.5){ | |
370 | cnt += 1; |
|
371 | cnt += 1; | |
371 | last = last+interval; |
|
372 | last = last+interval; | |
372 | x.push(last); |
|
373 | x.push(last); | |
373 | for (var j = 0; j < N; j++){ |
|
374 | for (var j = 0; j < N; j++){ | |
374 | y[j].push(null); |
|
375 | y[j].push(null); | |
375 | } |
|
376 | } | |
376 | // Avoid infinite loop |
|
377 | // Avoid infinite loop | |
377 | if (cnt==100){break;} |
|
378 | if (cnt==100){break;} | |
378 | } |
|
379 | } | |
379 | x.push(xBuffer[i]); |
|
380 | x.push(xBuffer[i]); | |
380 |
|
381 | |||
381 | for (var j = 0; j < N; j++){ |
|
382 | for (var j = 0; j < N; j++){ | |
382 | y[j].push(yBuffer[j][i]); |
|
383 | y[j].push(yBuffer[j][i]); | |
383 | } |
|
384 | } | |
384 | } |
|
385 | } | |
385 | return {'time':x, 'data':y}; |
|
386 | return {'time':x, 'data':y}; | |
386 | } |
|
387 | } | |
387 |
|
388 | |||
388 | plot(){ |
|
389 | plot(){ | |
389 | // add new data to plots and empty buffers |
|
390 | // add new data to plots and empty buffers | |
390 | var xvalues = []; |
|
391 | var xvalues = []; | |
391 | var yvalues = []; |
|
392 | var yvalues = []; | |
392 | var traces = []; |
|
393 | var traces = []; | |
393 | var N = this.getSize(); |
|
394 | var N = this.getSize(); | |
394 | console.log('Plotting...'); |
|
395 | console.log('Plotting...'); | |
395 | for (var i = 0; i < this.n; i++){ |
|
396 | for (var i = 0; i < this.n; i++){ | |
396 | if (N > 0){ |
|
397 | if (N > 0){ | |
397 | this.div.data[i].y = this.div.data[i].y.slice(N,) |
|
398 | this.div.data[i].y = this.div.data[i].y.slice(N,) | |
398 | this.div.data[i].x = this.div.data[i].x.slice(N,) |
|
399 | this.div.data[i].x = this.div.data[i].x.slice(N,) | |
399 | } |
|
400 | } | |
400 | yvalues.push(this.ybuffer[i]); |
|
401 | yvalues.push(this.ybuffer[i]); | |
401 | xvalues.push(this.xbuffer); |
|
402 | xvalues.push(this.xbuffer); | |
402 | traces.push(i); |
|
403 | traces.push(i); | |
403 | this.ybuffer[i] = []; |
|
404 | this.ybuffer[i] = []; | |
404 | } |
|
405 | } | |
405 | Plotly.extendTraces(this.div, { |
|
406 | Plotly.extendTraces(this.div, { | |
406 | y: yvalues, |
|
407 | y: yvalues, | |
407 | x: xvalues |
|
408 | x: xvalues | |
408 | }, traces); |
|
409 | }, traces); | |
409 | this.xbuffer = []; |
|
410 | this.xbuffer = []; | |
410 | } |
|
411 | } | |
411 |
|
412 | |||
412 | update(obj){ |
|
413 | update(obj){ | |
413 |
|
414 | |||
414 | // fill data gaps |
|
415 | // fill data gaps | |
415 | var cnt = 0; |
|
416 | var cnt = 0; | |
416 | while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){ |
|
417 | while (Math.abs(parseFloat(obj.time[0])-this.last-parseFloat(obj.interval))>0.5){ | |
417 | cnt += 1; |
|
418 | cnt += 1; | |
418 | this.last += obj.interval; |
|
419 | this.last += obj.interval; | |
419 | var newt = new Date((this.last)*1000); |
|
420 | var newt = new Date((this.last)*1000); | |
420 | this.xbuffer.push(newt); |
|
421 | this.xbuffer.push(newt); | |
421 | for (var i = 0; i < this.n; i++){ |
|
422 | for (var i = 0; i < this.n; i++){ | |
422 | this.ybuffer[i].push(null); |
|
423 | this.ybuffer[i].push(null); | |
423 | } |
|
424 | } | |
424 | // Avoid infinite loop |
|
425 | // Avoid infinite loop | |
425 | if (cnt==100){break;} |
|
426 | if (cnt==100){break;} | |
426 | } |
|
427 | } | |
427 |
|
428 | |||
428 | // update buffers |
|
429 | // update buffers | |
429 | this.last = parseFloat(obj.time[0]); |
|
430 | this.last = parseFloat(obj.time[0]); | |
430 | var t = new Date(obj.time[0]*1000); |
|
431 | var t = new Date(obj.time[0]*1000); | |
431 | this.xbuffer.push(t); |
|
432 | this.xbuffer.push(t); | |
432 | for (var i = 0; i < this.n; i++){ |
|
433 | for (var i = 0; i < this.n; i++){ | |
433 | this.ybuffer[i].push(obj[this.key][i][0]); |
|
434 | this.ybuffer[i].push(obj[this.key][i][0]); | |
434 | } |
|
435 | } | |
435 | var title = this.props.title || '' |
|
436 | var title = this.props.title || '' | |
436 | Plotly.relayout(this.div, { |
|
437 | Plotly.relayout(this.div, { | |
437 | title: title + ' - ' + t.toLocaleString(), |
|
438 | title: title + ' - ' + t.toLocaleString(), | |
438 | }); |
|
439 | }); | |
439 |
|
440 | |||
440 | // plot when ready (every 10 secs) |
|
441 | // plot when ready (every 10 secs) | |
441 | if (!this.wait){ |
|
442 | if (!this.wait){ | |
442 | this.plot(); |
|
443 | this.plot(); | |
443 | this.wait = true; |
|
444 | this.wait = true; | |
444 | } else { |
|
445 | } else { | |
445 | clearTimeout(this.lastFunc) |
|
446 | clearTimeout(this.lastFunc) | |
446 | this.lastFunc = setTimeout(function(scope) { |
|
447 | this.lastFunc = setTimeout(function(scope) { | |
447 | if ((Date.now() - scope.lastRan) >= scope.timer) { |
|
448 | if ((Date.now() - scope.lastRan) >= scope.timer) { | |
448 | scope.plot() |
|
449 | scope.plot() | |
449 | scope.lastRan = Date.now() |
|
450 | scope.lastRan = Date.now() | |
450 | } |
|
451 | } | |
451 | }, this.timer - (Date.now() - this.lastRan), this) |
|
452 | }, this.timer - (Date.now() - this.lastRan), this) | |
452 | } |
|
453 | } | |
453 | } |
|
454 | } | |
454 | } |
|
455 | } |
@@ -1,118 +1,118 | |||||
1 | {% load static %} {% load bootstrap3 %} |
|
1 | {% load static %} {% load bootstrap3 %} | |
2 | <!doctype html> |
|
2 | <!doctype html> | |
3 | <html lang="en"> |
|
3 | <html lang="en"> | |
4 |
|
4 | |||
5 | <head> |
|
5 | <head> | |
6 | <meta charset="utf-8"> |
|
6 | <meta charset="utf-8"> | |
7 | <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> |
|
7 | <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> | |
8 | <meta http-equiv="X-UA-Compatible" content="ie=edge"> |
|
8 | <meta http-equiv="X-UA-Compatible" content="ie=edge"> | |
9 | <link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet"> |
|
9 | <link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet"> | |
10 | <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet"> |
|
10 | <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet"> | |
11 | <script src="{% static 'js/jquery.min.js' %}"></script> |
|
11 | <script src="{% static 'js/jquery.min.js' %}"></script> | |
12 | <style> |
|
12 | <style> | |
13 | /* Paste this css to your style sheet file or under head tag */ |
|
13 | /* Paste this css to your style sheet file or under head tag */ | |
14 |
|
14 | |||
15 | /* This only works with JavaScript, |
|
15 | /* This only works with JavaScript, | |
16 | if it's not present, don't show loader */ |
|
16 | if it's not present, don't show loader */ | |
17 |
|
17 | |||
18 | .loader { |
|
18 | .loader { | |
19 | width: 100%; |
|
19 | width: 100%; | |
20 | height: 10px; |
|
20 | height: 10px; | |
21 | position: relative; |
|
21 | position: relative; | |
22 | z-index: 9999; |
|
22 | z-index: 9999; | |
23 | background: url("{% static 'images/loader.gif' %}") center no-repeat #fff; |
|
23 | background: url("{% static 'images/loader.gif' %}") center no-repeat #fff; | |
24 | } |
|
24 | } | |
25 |
|
25 | |||
26 | .no-data { |
|
26 | .no-data { | |
27 | text-align: center; |
|
27 | text-align: center; | |
28 | background-color: #d58512; |
|
28 | background-color: #d58512; | |
29 | padding: 8px 16px; |
|
29 | padding: 8px 16px; | |
30 | border-radius: 5px; |
|
30 | border-radius: 5px; | |
31 | color: #FEFEFE; |
|
31 | color: #FEFEFE; | |
32 | font: 20px 'Helvetica'; |
|
32 | font: 20px 'Helvetica'; | |
33 | text-transform: uppercase; |
|
33 | text-transform: uppercase; | |
34 | } |
|
34 | } | |
35 | </style> |
|
35 | </style> | |
36 | <title>Realtime plots at JRO</title> |
|
36 | <title>Realtime plots at JRO</title> | |
37 | </head> |
|
37 | </head> | |
38 |
|
38 | |||
39 | <body> |
|
39 | <body> | |
40 | <div class="container"> |
|
40 | <div class="container"> | |
41 | <div id="page" class="row" style="min-height:600px"> |
|
41 | <div id="page" class="row" style="min-height:600px"> | |
42 | {% bootstrap_messages %} |
|
42 | {% bootstrap_messages %} | |
43 | <div class="page-header"> |
|
43 | <div class="page-header"> | |
44 | <h1>{% block content-title %}Realtime{% endblock %} |
|
44 | <h1>{% block content-title %}Realtime{% endblock %} | |
45 | <small>{% block content-suptitle %}Plots{% endblock %}</small> |
|
45 | <small>{% block content-suptitle %}Plots{% endblock %}</small> | |
46 | </h1> |
|
46 | </h1> | |
47 | </div> |
|
47 | </div> | |
48 | <div class="col-md-3 hidden-xs hidden-sm" role="complementary"> |
|
48 | <div class="col-md-3 hidden-xs hidden-sm" role="complementary"> | |
49 | <div id="sidebar"> |
|
49 | <div id="sidebar"> | |
50 | {% if form.is_multipart %} |
|
50 | {% if form.is_multipart %} | |
51 | <form class="form" enctype="multipart/form-data" method="post" action="{{action}}"> |
|
51 | <form class="form" enctype="multipart/form-data" method="post" action="{{action}}"> | |
52 | {% else %} |
|
52 | {% else %} | |
53 | <form class="form" method="post" action="{{action}}"> |
|
53 | <form class="form" method="post" action="{{action}}"> | |
54 | {% endif %} {% csrf_token %} {% bootstrap_form form layout='inline' size='medium' %} |
|
54 | {% endif %} {% csrf_token %} {% bootstrap_form form layout='inline' size='medium' %} | |
55 | <div style="clear: both;"></div> |
|
55 | <div style="clear: both;"></div> | |
56 | <br> |
|
56 | <br> | |
57 | <div class="pull-left"> |
|
57 | <div class="pull-left"> | |
58 | <button type="button" id="bt_show" class="btn btn-primary">Show</button> |
|
58 | <button type="button" id="bt_show" class="btn btn-primary">Show</button> | |
59 | </div> |
|
59 | </div> | |
60 | </form> |
|
60 | </form> | |
61 | </div> |
|
61 | </div> | |
62 | </div> |
|
62 | </div> | |
63 | <div class="col-md-9 col-xs-12" role="main"> |
|
63 | <div class="col-md-9 col-xs-12" role="main"> | |
64 | <div id="loader" class="loader"></div> |
|
64 | <div id="loader" class="loader"></div> | |
65 | {% block content %} {% endblock %} |
|
65 | {% block content %} {% endblock %} | |
66 | </div> |
|
66 | </div> | |
67 | </div> |
|
67 | </div> | |
68 | <!--/row--> |
|
68 | <!--/row--> | |
69 | </div> |
|
69 | </div> | |
70 | <script src="{% static 'js/plotly-latest.min.js' %}"></script> |
|
70 | <script src="{% static 'js/plotly-latest.min.js' %}"></script> | |
71 | <script src="{% static 'js/moment.min.js' %}"></script> |
|
71 | <script src="{% static 'js/moment.min.js' %}"></script> | |
72 | <script src="{% static 'js/bootstrap-datetimepicker.min.js' %}"></script> |
|
72 | <script src="{% static 'js/bootstrap-datetimepicker.min.js' %}"></script> | |
73 | <script src="{% static 'js/jroplots.js' %}"></script> |
|
73 | <script src="{% static 'js/jroplots.js' %}"></script> | |
74 | <script type="text/javascript"> |
|
74 | <script type="text/javascript"> | |
75 | $('#id_date').datetimepicker({ |
|
75 | $('#id_date').datetimepicker({ | |
76 | pickTime: false, |
|
76 | pickTime: false, | |
77 | format: 'DD/MM/YYYY', |
|
77 | format: 'DD/MM/YYYY', | |
78 | }); |
|
78 | }); | |
79 | $("#bt_show").click(function () { |
|
79 | $("#bt_show").click(function () { | |
80 | document.location = '/' + $("#id_experiment").val() + '/' + $("#id_plot").val() + '/?date=' + $("#id_date").val(); |
|
80 | document.location = '/' + $("#id_experiment").val() + '/' + $("#id_plot").val() + '/?date=' + $("#id_date").val(); | |
81 | }); |
|
81 | }); | |
82 |
|
82 | |||
83 | {% if date %} |
|
83 | {% if date %} | |
84 | $("#loader").css("display", "block"); |
|
84 | $("#loader").css("display", "block"); | |
85 | var socket = new WebSocket('ws://' + window.location.host + '/{{code}}/{{plot}}/?' + 'pk={{id}}'); |
|
85 | var socket = new WebSocket('ws://' + window.location.host + '/{{code}}/{{plot}}/?' + 'pk={{id}}'); | |
86 | socket.onopen = function open() { |
|
86 | socket.onopen = function open() { | |
87 | console.log('WebSockets connection created.'); |
|
87 | console.log('WebSockets connection created.'); | |
88 | {% if date %} |
|
88 | {% if date %} | |
89 | socket.send('{"date": "{{date}}" }'); |
|
89 | socket.send('{"date": "{{date}}" }'); | |
90 | {% else %} |
|
90 | {% else %} | |
91 | socket.send('{"date": "{% now "d/m/Y" %}" }'); |
|
91 | socket.send('{"date": "{% now "d/m/Y" %}" }'); | |
92 | {% endif %} |
|
92 | {% endif %} | |
93 | }; |
|
93 | }; | |
94 |
|
94 | |||
95 | socket.onmessage = function message(event) { |
|
95 | socket.onmessage = function message(event) { | |
96 | var data = JSON.parse(event.data); |
|
96 | var data = JSON.parse(event.data); | |
97 | console.log(data); |
|
97 | console.log(data.time); | |
98 | if (data.interval == 0) { |
|
98 | if (data.interval == 0) { | |
99 | $("#loader").removeClass("loader").addClass("no-data"); |
|
99 | $("#loader").removeClass("loader").addClass("no-data"); | |
100 | $("#loader").html("No data found"); |
|
100 | $("#loader").html("No data found"); | |
101 | } else { |
|
101 | } else { | |
102 | var first = plot(data); |
|
102 | var first = plot(data); | |
103 | if (first == true) { |
|
103 | if (first == true) { | |
104 | $("#loader").css("display", "none"); |
|
104 | $("#loader").css("display", "none"); | |
105 | } |
|
105 | } | |
106 | } |
|
106 | } | |
107 | } |
|
107 | } | |
108 |
|
108 | |||
109 | if (socket.readyState == WebSocket.OPEN) { |
|
109 | if (socket.readyState == WebSocket.OPEN) { | |
110 | socket.onopen(); |
|
110 | socket.onopen(); | |
111 | } |
|
111 | } | |
112 | {% else %} |
|
112 | {% else %} | |
113 | $("#loader").css("display", "none"); |
|
113 | $("#loader").css("display", "none"); | |
114 | {% endif %} |
|
114 | {% endif %} | |
115 | </script> {% block script %}{% endblock script %} |
|
115 | </script> {% block script %}{% endblock script %} | |
116 | </body> |
|
116 | </body> | |
117 |
|
117 | |||
118 | </html> No newline at end of file |
|
118 | </html> |
@@ -1,22 +1,22 | |||||
1 | {% extends 'base.html' %} {% block content %} |
|
1 | {% extends 'base.html' %} {% block content %} | |
2 | <div id="plot"></div> |
|
2 | <div id="plot"></div> | |
3 | {% endblock content %} {% block script %} |
|
3 | {% endblock content %} {% block script %} | |
4 | <script> |
|
4 | <script> | |
5 | let flag = true; |
|
5 | let flag = true; | |
6 | function plot(data) { |
|
6 | function plot(data) { | |
7 | if (flag === true) { |
|
7 | if (flag === true) { | |
8 | flag = false; |
|
8 | flag = false; | |
9 | rti = new PcolorBuffer({ |
|
9 | rti = new PcolorBuffer({ | |
10 | div: 'plot', |
|
10 | div: 'plot', | |
11 | data: data, |
|
11 | data: data, | |
12 | key: 'rti', |
|
12 | key: 'rti', | |
13 |
props: { title: '{{title}}', zmin: 15, zmax: 3 |
|
13 | props: { title: '{{title}}', zmin: 15, zmax: 35, throttle: 10, timespan: 12, colormap: 'Jet' }, | |
14 | }); |
|
14 | }); | |
15 | return true; |
|
15 | return true; | |
16 | } else { |
|
16 | } else { | |
17 | rti.update(data); |
|
17 | rti.update(data); | |
18 | return false; |
|
18 | return false; | |
19 | } |
|
19 | } | |
20 | } |
|
20 | } | |
21 |
|
21 | |||
22 | </script> {% endblock script %} No newline at end of file |
|
22 | </script> {% endblock script %} |
@@ -1,28 +1,28 | |||||
1 | {% extends 'base.html' %} |
|
1 | {% extends 'base.html' %} | |
2 |
|
2 | |||
3 | {% block content %} |
|
3 | {% block content %} | |
4 | <div id="plot"></div> |
|
4 | <div id="plot"></div> | |
5 | {% endblock content %} |
|
5 | {% endblock content %} | |
6 |
|
6 | |||
7 | {% block script %} |
|
7 | {% block script %} | |
8 | <script> |
|
8 | <script> | |
9 | let flag = true; |
|
9 | let flag = true; | |
10 |
|
10 | |||
11 | function plot(data){ |
|
11 | function plot(data){ | |
12 | // console.log(data['time']); |
|
12 | // console.log(data['time']); | |
13 | if (flag === true){ |
|
13 | if (flag === true){ | |
14 | flag = false; |
|
14 | flag = false; | |
15 | plt = new Scatter({ |
|
15 | plt = new Scatter({ | |
16 | div: 'plot', |
|
16 | div: 'plot', | |
17 | data: data, |
|
17 | data: data, | |
18 | key: '{{plot}}', |
|
18 | key: '{{plot}}', | |
19 |
props: {title: '{{title}}', ylabel:'Noise [dB]', ymin:1 |
|
19 | props: {title: '{{title}}', ylabel:'Noise [dB]', ymin:18, ymax:22 }, | |
20 | }); |
|
20 | }); | |
21 | return true; |
|
21 | return true; | |
22 | } else { |
|
22 | } else { | |
23 | plt.update(data); |
|
23 | plt.update(data); | |
24 | return false; |
|
24 | return false; | |
25 | } |
|
25 | } | |
26 | } |
|
26 | } | |
27 | </script> |
|
27 | </script> | |
28 | {% endblock script %} No newline at end of file |
|
28 | {% endblock script %} |
@@ -1,84 +1,84 | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 | from __future__ import unicode_literals |
|
2 | from __future__ import unicode_literals | |
3 |
|
3 | |||
4 | import os |
|
4 | import os | |
5 | from datetime import datetime |
|
5 | from datetime import datetime | |
6 |
|
6 | |||
7 | from django import forms |
|
7 | from django import forms | |
8 | from django.contrib import messages |
|
8 | from django.contrib import messages | |
9 | from django.utils.safestring import mark_safe |
|
9 | from django.utils.safestring import mark_safe | |
10 | from django.shortcuts import render |
|
10 | from django.shortcuts import render | |
11 |
|
11 | |||
12 | from bootstrap3_datetime.widgets import DateTimePicker |
|
12 | from bootstrap3_datetime.widgets import DateTimePicker | |
13 |
|
13 | |||
14 | import mongoengine |
|
14 | import mongoengine | |
15 |
|
15 | |||
16 | from plotter.models import Experiment, ExpMeta |
|
16 | from plotter.models import Experiment, ExpMeta | |
17 |
|
17 | |||
18 | host = os.environ.get('HOST_MONGO', 'localhost') |
|
18 | host = os.environ.get('HOST_MONGO', 'localhost') | |
19 | mongoengine.connect('dbplots', host=host, port=27017) |
|
19 | mongoengine.connect('dbplots', host=host, port=27017) | |
20 |
|
20 | |||
21 | # Forms |
|
21 | # Forms | |
22 | class SearchForm(forms.Form): |
|
22 | class SearchForm(forms.Form): | |
23 |
|
23 | |||
24 | experiment = forms.ChoiceField() |
|
24 | experiment = forms.ChoiceField() | |
25 | plot = forms.ChoiceField( |
|
25 | plot = forms.ChoiceField( | |
26 | choices = [(0, 'Select Plot'), ('rti', 'RTI'),('spc', 'Spectra'),('noise', 'Noise')] |
|
26 | choices = [(0, 'Select Plot'), ('rti', 'RTI'),('spc', 'Spectra'),('noise', 'Noise')] | |
27 | ) |
|
27 | ) | |
28 | date = forms.DateField( |
|
28 | date = forms.DateField( | |
29 | widget=DateTimePicker(options={"format": "DD/MM/YYYY"}) |
|
29 | widget=DateTimePicker(options={"format": "DD/MM/YYYY"}) | |
30 | ) |
|
30 | ) | |
31 |
|
31 | |||
32 | def __init__(self, *args, **kwargs): |
|
32 | def __init__(self, *args, **kwargs): | |
33 |
|
33 | |||
34 | exp_choices = kwargs.pop('exp_choices', []) |
|
34 | exp_choices = kwargs.pop('exp_choices', []) | |
35 | super(SearchForm, self).__init__(*args, **kwargs) |
|
35 | super(SearchForm, self).__init__(*args, **kwargs) | |
36 | self.fields['experiment'].choices = [(0, 'Select Experiment')] + exp_choices |
|
36 | self.fields['experiment'].choices = [(0, 'Select Experiment')] + exp_choices | |
37 |
|
37 | |||
38 | # Create your views here. |
|
38 | # Create your views here. | |
39 | def main(request, code=None, plot=None): |
|
39 | def main(request, code=None, plot=None): | |
40 |
|
40 | |||
41 | initial = {} |
|
41 | initial = {} | |
42 | date = request.GET.get('date', datetime.now().strftime('%d/%m/%Y')) |
|
42 | date = request.GET.get('date', datetime.now().strftime('%d/%m/%Y')) | |
43 | initial['date'] = date |
|
43 | initial['date'] = date | |
44 |
|
44 | |||
45 | if code is not None: |
|
45 | if code is not None: | |
46 | initial['experiment'] = code |
|
46 | initial['experiment'] = code | |
47 | if plot is not None: |
|
47 | if plot is not None: | |
48 | initial['plot'] = plot |
|
48 | initial['plot'] = plot | |
49 |
|
49 | |||
50 | exps = [(q['code'], q['name']) for q in Experiment.objects.all()] |
|
50 | exps = [(q['code'], q['name']) for q in Experiment.objects.all()] | |
51 |
|
51 | |||
52 | form = SearchForm( |
|
52 | form = SearchForm( | |
53 | initial = initial, |
|
53 | initial = initial, | |
54 | exp_choices = [(e[0], e[1]) for e in exps] |
|
54 | exp_choices = [(e[0], e[1]) for e in exps] | |
55 | ) |
|
55 | ) | |
56 |
|
56 | |||
57 | try: |
|
57 | try: | |
58 | exp = ExpMeta.objects.get(code=int(code), date=datetime.strptime(date, '%d/%m/%Y')) |
|
58 | exp = ExpMeta.objects.get(code=int(code), date=datetime.strptime(date, '%d/%m/%Y')) | |
59 | exp_id = exp.id |
|
59 | exp_id = exp.id | |
60 | except: |
|
60 | except: | |
61 | exp_id = 0 |
|
61 | exp_id = 0 | |
62 |
|
62 | |||
63 |
|
63 | |||
64 | kwargs = { |
|
64 | kwargs = { | |
65 | 'code': code, |
|
65 | 'code': code, | |
66 | 'plot': plot, |
|
66 | 'plot': plot, | |
67 | 'date': date, |
|
67 | 'date': date, | |
68 | 'form': form, |
|
68 | 'form': form, | |
69 | 'id': exp_id |
|
69 | 'id': exp_id | |
70 | } |
|
70 | } | |
71 |
|
71 | |||
72 | if code and exps: |
|
72 | if code and exps: | |
73 | kwargs['title'] = [t[1] for t in exps if t[0]==int(code)][0] |
|
73 | kwargs['title'] = [t[1] for t in exps if int(t[0])==int(code)][0] | |
74 | else: |
|
74 | else: | |
75 | kwargs['title'] = 'JRO' |
|
75 | kwargs['title'] = 'JRO' | |
76 |
|
76 | |||
77 | if plot == 'rti': |
|
77 | if plot == 'rti': | |
78 | return render(request, 'rti.html', kwargs) |
|
78 | return render(request, 'rti.html', kwargs) | |
79 | elif plot == 'spc': |
|
79 | elif plot == 'spc': | |
80 | return render(request, 'spectra.html', kwargs) |
|
80 | return render(request, 'spectra.html', kwargs) | |
81 | elif plot == 'noise': |
|
81 | elif plot == 'noise': | |
82 | return render(request, 'scatter.html', kwargs) |
|
82 | return render(request, 'scatter.html', kwargs) | |
83 | else: |
|
83 | else: | |
84 | return render(request, 'base.html', kwargs) No newline at end of file |
|
84 | return render(request, 'base.html', kwargs) |
@@ -1,110 +1,110 | |||||
1 | [ |
|
1 | [ | |
2 | { |
|
2 | { | |
3 | "code" : 100, |
|
3 | "code" : 100, | |
4 | "name" : "HF JRO" |
|
4 | "name" : "HF JRO" | |
5 | }, |
|
5 | }, | |
6 | { |
|
6 | { | |
7 | "code" : 101, |
|
7 | "code" : 101, | |
8 | "name" : "HF Huancayo" |
|
8 | "name" : "HF Huancayo" | |
9 | }, |
|
9 | }, | |
10 | { |
|
10 | { | |
11 | "code" : 102, |
|
11 | "code" : 102, | |
12 | "name" : "HF Ica" |
|
12 | "name" : "HF Ica" | |
13 | }, |
|
13 | }, | |
14 | { |
|
14 | { | |
15 | "code" : 110, |
|
15 | "code" : 110, | |
16 | "name" : "ISR EW Drifts" |
|
16 | "name" : "ISR EW Drifts" | |
17 | }, |
|
17 | }, | |
18 | { |
|
18 | { | |
19 | "code" : 111, |
|
19 | "code" : 111, | |
20 | "name" : "ISR Faraday" |
|
20 | "name" : "ISR Faraday" | |
21 | }, |
|
21 | }, | |
22 | { |
|
22 | { | |
23 | "code" : 112, |
|
23 | "code" : 112, | |
24 | "name" : "ISR Imaging" |
|
24 | "name" : "ISR Imaging" | |
25 | }, |
|
25 | }, | |
26 | { |
|
26 | { | |
27 | "code" : 120, |
|
27 | "code" : 120, | |
28 | "name" : "Faraday" |
|
28 | "name" : "Faraday" | |
29 | }, |
|
29 | }, | |
30 | { |
|
30 | { | |
31 | "code" : 121, |
|
31 | "code" : 121, | |
32 | "name" : "Faraday Long Pulse" |
|
32 | "name" : "Faraday Long Pulse" | |
33 | }, |
|
33 | }, | |
34 | { |
|
34 | { | |
35 | "code" : 122, |
|
35 | "code" : 122, | |
36 | "name" : "Faraday Codded LP" |
|
36 | "name" : "Faraday Codded LP" | |
37 | }, |
|
37 | }, | |
38 | { |
|
38 | { | |
39 | "code" : 123, |
|
39 | "code" : 123, | |
40 | "name" : "Faraday Double Pulse" |
|
40 | "name" : "Faraday Double Pulse" | |
41 | }, |
|
41 | }, | |
42 | { |
|
42 | { | |
43 | "code" : 124, |
|
43 | "code" : 124, | |
44 | "name" : "Faraday AC" |
|
44 | "name" : "Faraday AC" | |
45 | }, |
|
45 | }, | |
46 | { |
|
46 | { | |
47 | "code" : 125, |
|
47 | "code" : 125, | |
48 | "name" : "Faraday Differential Phase" |
|
48 | "name" : "Faraday Differential Phase" | |
49 | }, |
|
49 | }, | |
50 | { |
|
50 | { | |
51 | "code" : 150, |
|
51 | "code" : 150, | |
52 | "name" : "JASMET 50" |
|
52 | "name" : "JASMET 50" | |
53 | }, |
|
53 | }, | |
54 | { |
|
54 | { | |
55 | "code" : 151, |
|
55 | "code" : 151, | |
56 | "name" : "JASMET 30" |
|
56 | "name" : "JASMET 30" | |
57 | }, |
|
57 | }, | |
58 | { |
|
58 | { | |
59 | "code" : 170, |
|
59 | "code" : 170, | |
60 | "name" : "BLTR Huancayo" |
|
60 | "name" : "BLTR Huancayo" | |
61 | }, |
|
61 | }, | |
62 | { |
|
62 | { | |
63 | "code" : 171, |
|
63 | "code" : 171, | |
64 | "name" : "CIRI Huancayo" |
|
64 | "name" : "CIRI Huancayo" | |
65 | }, |
|
65 | }, | |
66 | { |
|
66 | { | |
67 | "code" : 172, |
|
67 | "code" : 172, | |
68 | "name" : "CLAIRE Huancayo" |
|
68 | "name" : "CLAIRE Huancayo" | |
69 | }, |
|
69 | }, | |
70 | { |
|
70 | { | |
71 | "code" : 180, |
|
71 | "code" : 180, | |
72 | "name" : "MST" |
|
72 | "name" : "MST" | |
73 | }, |
|
73 | }, | |
74 | { |
|
74 | { | |
75 | "code" : 181, |
|
75 | "code" : 181, | |
76 | "name" : "ISR" |
|
76 | "name" : "ISR" | |
77 | }, |
|
77 | }, | |
78 | { |
|
78 | { | |
79 | "code" : 182, |
|
79 | "code" : 182, | |
80 | "name" : "EEJ" |
|
80 | "name" : "EEJ" | |
81 | }, |
|
81 | }, | |
82 | { |
|
82 | { | |
83 | "code" : 190, |
|
83 | "code" : 190, | |
84 | "name" : "JULIA 150km (Natalia)" |
|
84 | "name" : "JULIA 150km (Natalia)" | |
85 | }, |
|
85 | }, | |
86 | { |
|
86 | { | |
87 | "code" : 191, |
|
87 | "code" : 191, | |
88 | "name" : "JULIA SpreadF (Natalia)" |
|
88 | "name" : "JULIA SpreadF (Natalia)" | |
89 | }, |
|
89 | }, | |
90 | { |
|
90 | { | |
91 | "code" : 200, |
|
91 | "code" : 200, | |
92 | "name" : "JULIA 150km" |
|
92 | "name" : "JULIA 150km" | |
93 | }, |
|
93 | }, | |
94 | { |
|
94 | { | |
95 | "code" : 201, |
|
95 | "code" : 201, | |
96 | "name" : "JULIA EEJ" |
|
96 | "name" : "JULIA EEJ" | |
97 | }, |
|
97 | }, | |
98 | { |
|
98 | { | |
99 | "code" : 202, |
|
99 | "code" : 202, | |
100 | "name" : "JULIA SpreadF" |
|
100 | "name" : "JULIA SpreadF" | |
101 | }, |
|
101 | }, | |
102 | { |
|
102 | { | |
103 | "code" : 203, |
|
103 | "code" : 203, | |
104 | "name" : "JULIA Imaging" |
|
104 | "name" : "JULIA Imaging" | |
105 | }, |
|
105 | }, | |
106 | { |
|
106 | { | |
107 |
"code" : 20 |
|
107 | "code" : 204, | |
108 | "name" : "JULIA Bistatic" |
|
108 | "name" : "JULIA Bistatic" | |
109 | } |
|
109 | } | |
110 | ] No newline at end of file |
|
110 | ] |
@@ -1,84 +1,87 | |||||
1 | import os |
|
1 | import os | |
2 | import sys |
|
2 | import sys | |
3 | import json |
|
3 | import json | |
4 | import simplejson |
|
4 | import simplejson | |
5 | from datetime import datetime |
|
5 | from datetime import datetime | |
6 | import zmq |
|
6 | import zmq | |
7 | import redis |
|
7 | import redis | |
8 | import asgi_redis |
|
8 | import asgi_redis | |
9 | import mongoengine |
|
9 | import mongoengine | |
10 |
|
10 | |||
11 | sys.path.append('/app') |
|
11 | sys.path.append('/app') | |
12 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "realtime.settings") |
|
12 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "realtime.settings") | |
13 |
|
13 | |||
14 | from plotter.models import Experiment, ExpMeta, ExpData |
|
14 | from plotter.models import Experiment, ExpMeta, ExpData | |
15 |
|
15 | |||
16 | host_mongo = os.environ.get('HOST_MONGO', 'localhost') |
|
16 | host_mongo = os.environ.get('HOST_MONGO', 'localhost') | |
17 | mongoengine.connect('dbplots', host=host_mongo, port=27017) |
|
17 | mongoengine.connect('dbplots', host=host_mongo, port=27017) | |
18 |
|
18 | |||
19 |
|
19 | |||
20 | host_redis = os.environ.get('HOST_REDIS', 'localhost') |
|
20 | host_redis = os.environ.get('HOST_REDIS', 'localhost') | |
21 | channel = asgi_redis.RedisChannelLayer(hosts=[(host_redis, 6379)]) |
|
21 | channel = asgi_redis.RedisChannelLayer(hosts=[(host_redis, 6379)]) | |
22 |
|
22 | |||
23 | context = zmq.Context() |
|
23 | context = zmq.Context() | |
24 | receiver = context.socket(zmq.SUB) |
|
24 | receiver = context.socket(zmq.SUB) | |
25 |
|
25 | |||
26 | receiver.bind("tcp://0.0.0.0:4444") |
|
26 | receiver.bind("tcp://0.0.0.0:4444") | |
27 | receiver.setsockopt(zmq.SUBSCRIBE, '') |
|
27 | receiver.setsockopt(zmq.SUBSCRIBE, '') | |
28 |
|
28 | |||
29 | def loaddata(): |
|
29 | def loaddata(): | |
30 | print('Loading Experiments...') |
|
30 | print('Loading Experiments...') | |
31 | for tup in json.load(open('scripts/experiments.json')): |
|
31 | for tup in json.load(open('scripts/experiments.json')): | |
32 | print(tup['name']) |
|
32 | print(tup['name']) | |
33 | exp = Experiment.objects(code=tup['code']).modify( |
|
33 | exp = Experiment.objects(code=tup['code']).modify( | |
34 | upsert=True, |
|
34 | upsert=True, | |
35 | new=True, |
|
35 | new=True, | |
36 | set__code=tup['code'], |
|
36 | set__code=tup['code'], | |
37 | set__name=tup['name'], |
|
37 | set__name=tup['name'], | |
38 | ) |
|
38 | ) | |
39 | exp.save() |
|
39 | exp.save() | |
40 |
|
40 | |||
41 | def update(buffer): |
|
41 | def update(buffer): | |
42 | dt = datetime.utcfromtimestamp(buffer['time']) |
|
42 | dt = datetime.utcfromtimestamp(buffer['time']) | |
43 | exp = ExpMeta.objects(code=buffer['exp_code'], date=dt.date()).modify( |
|
43 | exp = ExpMeta.objects(code=buffer['exp_code'], date=dt.date()).modify( | |
44 | upsert=True, |
|
44 | upsert=True, | |
45 | new=True, |
|
45 | new=True, | |
46 | set__code=buffer['exp_code'], |
|
46 | set__code=buffer['exp_code'], | |
47 | set__date=dt.date(), |
|
47 | set__date=dt.date(), | |
48 | set__yrange = buffer['yrange'], |
|
48 | set__yrange = buffer['yrange'], | |
49 | set__xrange = buffer['xrange'], |
|
49 | set__xrange = buffer['xrange'], | |
50 | set__interval = buffer['interval'], |
|
50 | set__interval = buffer['interval'], | |
51 | set__localtime = buffer['localtime'], |
|
51 | set__localtime = buffer['localtime'], | |
52 | set__plots = buffer['data'].keys() |
|
52 | set__plots = buffer['data'].keys() | |
53 | ) |
|
53 | ) | |
54 | exp.save() |
|
54 | exp.save() | |
55 |
|
55 | |||
56 | data = ExpData.objects(expmeta=exp, time=buffer['time']).modify( |
|
56 | data = ExpData.objects(expmeta=exp, time=buffer['time']).modify( | |
57 | upsert=True, |
|
57 | upsert=True, | |
58 | new=True, |
|
58 | new=True, | |
59 | set__expmeta = exp, |
|
59 | set__expmeta = exp, | |
60 | set__time = buffer['time'], |
|
60 | set__time = buffer['time'], | |
61 | set__data = buffer['data'] |
|
61 | set__data = buffer['data'] | |
62 | ) |
|
62 | ) | |
63 |
|
63 | |||
64 | data.save() |
|
64 | data.save() | |
65 |
|
65 | |||
66 | return exp.id |
|
66 | return exp.id | |
67 |
|
67 | |||
68 | def main(): |
|
68 | def main(): | |
69 | print('Starting ZMQ server...') |
|
69 | print('Starting ZMQ server...') | |
70 | while True: |
|
70 | while True: | |
71 | buffer = receiver.recv_json() |
|
71 | buffer = receiver.recv_json() | |
72 | code = update(buffer) |
|
72 | code = update(buffer) | |
73 | for plot in buffer['data']: |
|
73 | for plot in buffer['data']: | |
74 | dum = buffer.copy() |
|
74 | dum = buffer.copy() | |
75 | dum['time'] = [buffer['time']] |
|
75 | dum['time'] = [buffer['time']] | |
76 | dum[plot] = buffer['data'][plot] |
|
76 | if plot=='noise': | |
|
77 | dum[plot] = [[x] for x in buffer['data'][plot]] | |||
|
78 | else: | |||
|
79 | dum[plot] = buffer['data'][plot] | |||
77 | dum.pop('data') |
|
80 | dum.pop('data') | |
78 | dum.pop('exp_code') |
|
81 | dum.pop('exp_code') | |
79 | channel.send_group(u'{}_{}'.format(code, plot), {'text': simplejson.dumps(dum, ignore_nan=True)}) |
|
82 | channel.send_group(u'{}_{}'.format(code, plot), {'text': simplejson.dumps(dum, ignore_nan=True)}) | |
80 | print('Sending...{} - {} bytes'.format(plot, len(str(dum)))) |
|
83 | print('Sending...{} - {} bytes'.format(plot, len(str(dum)))) | |
81 |
|
84 | |||
82 | if __name__=='__main__': |
|
85 | if __name__=='__main__': | |
83 | loaddata() |
|
86 | loaddata() | |
84 | main() No newline at end of file |
|
87 | main() |
General Comments 0
You need to be logged in to leave comments.
Login now