3 | 
4 |
5 |
7 |
8 |
4 | Noooope
12 |
14 |
15 |
18 |
54 |
58 |
96 |
100 |
112 | 16 | build SETTINGS
17 |
19 |
20 |
21 |
27 |
28 |
31 | Enable focusing
32 |
33 |
36 | Remember position on boot
37 |
38 |
41 | Flip back/forward
42 |
43 |
44 |
45 |
46 |
47 |
53 |
48 | Reset Settings
51 |
52 | 55 | compare_arrowsmanual control 56 |
57 |
59 |
95 |
60 |
61 |
79 |
80 |
85 |
86 |
87 |
91 | Set as new 0 position
92 |
93 |
94 |
62 |
68 | Move forward
69 |
70 |
74 | Move Backward
75 |
76 |
77 |
78 | 97 | settingsRaspberry 98 |
99 |
101 |
110 | PiLapseRails © Koivistik.com
111 |
102 |
106 | Shut off Raspberry
107 |
108 |
109 |
114 |
115 |
130 |
116 |
117 |
119 | {{railStatus.count}} / {{railStatus.shotsLeft}}
118 |
120 |
121 |
122 |
124 | {{railStatus.timeLeft}}
123 |
125 |
126 |
127 |
129 | {{railStatus.interval}}
128 |
131 |
241 |
242 |
132 |
134 |
232 | Please configure the length of your rails in the settings menu
133 |
233 |
240 |
234 |
236 |
237 | Stop
238 |
239 |
243 |
245 |
246 | Safe to power off your raspberry in a few moments...
244 |
247 |
249 |
250 |
251 |
252 |
253 |
--------------------------------------------------------------------------------
/public/app/components/main/main-controller.js:
--------------------------------------------------------------------------------
1 | //***********************************************************
2 | // PiLapseRails
3 | // raspberry Pi powered timelapse controller
4 | // author: Joosep Kõivistik // koivistik.com
5 | // repository: https://github.com/equilerex/PiLapseRails
6 | //***********************************************************
7 |
8 |
9 | angular.module("ngapp").controller("MainController", function(shared, $state, $scope, $mdSidenav, $mdComponentRegistry, $timeout,$mdToast, $location){
10 | //***********************************************************
11 | // dev mode... set true in www.js and main-controller.js & uncomment http://localhost:8080/public/app/vendor/socket.js in index.html and comment out src="http://192.168.43.80:8080/public/app/vendor/socket.js
12 | //***********************************************************
13 | var windowsDevEnvironment = true; //set true in()
14 |
15 | //***********************************************************
16 | // settings slide out bar
17 | //***********************************************************
18 | var ctrl = this;
19 | this.auth = shared.info.auth;
20 | this.toggle = angular.noop;
21 | this.title = $state.current.title;
22 | this.isOpen = function() { return false };
23 | $mdComponentRegistry
24 | .when("left")
25 | .then( function(sideNav){
26 | ctrl.isOpen = angular.bind( sideNav, sideNav.isOpen );
27 | ctrl.toggle = angular.bind( sideNav, sideNav.toggle );
28 | });
29 | this.toggleRight = function() {
30 | $mdSidenav("left").toggle()
31 | .then(function(){
32 | });
33 | };
34 | this.close = function() {
35 | $mdSidenav("right").close()
36 | .then(function(){
37 | });
38 | };
39 | //close menu when moving back
40 | $scope.openMenu = function () {
41 | $location.search("menuOpen", true)
42 | };
43 | $scope.$on('$locationChangeStart', function(event, next, current) {
44 | if(current.split("#")[1]==="/main?menuOpen" && next.split("#")[1]==="/main") {
45 | if($scope.main.isOpen()) {
46 | $scope.main.toggle()
47 | }
48 | }
49 | });
50 |
51 |
52 | //***********************************************************
53 | // Available settings / default values
54 | //***********************************************************
55 | $scope.defaultLapseConf = {
56 | "bulbMode":false,
57 | "shutterSpeed":1000,
58 | "focusLength":0,
59 | "motorPulse":2000,
60 | "waitLength":1000,
61 | "direction":true, //backward
62 | "loopEnabled":false,
63 | "loopCount":0
64 | };
65 | $scope.defaultRailConf = {
66 | "focusEnabled":false,
67 | "rememberPosition":false
68 | };
69 | $scope.railStatus = {
70 | "shotsLeft":0,
71 | "timeLeft":0,
72 | "interval":0
73 | };
74 | $scope.lapseConf = {};
75 | $scope.railConf = {};
76 | var timeFormats = {
77 | minute:{
78 | "human":"min | sec | ms",
79 | "machine":"mm:ss:SS"
80 | },
81 | hour: {
82 | "human":"hour | min | sec",
83 | "machine":"HH:mm:ss"
84 | },
85 | day: {
86 | "human":"Days",
87 | "machine":"day"
88 | }
89 | };
90 | $scope.timeLeftFormat = timeFormats.underHour;
91 | $scope.intervalFormat = timeFormats.underHour;
92 |
93 |
94 | //***********************************************************
95 | // progress / calculation feedback
96 | //***********************************************************
97 | var loopAddon = function() {
98 | var loopAddon = 0;
99 | var count = 0;
100 | if( $scope.railStatus.loopCount) {
101 | count = $scope.railStatus.loopCount
102 | } else {
103 | count = $scope.lapseConf.loopCount
104 | }
105 | if($scope.lapseConf.loopEnabled && count>0) {
106 | return loopAddon = $scope.railConf.railLength*count;
107 | } else {
108 | return 0
109 | }
110 | };
111 | //progress bar
112 | $scope.loadBar = function() {
113 | var calculate = ($scope.railStatus.shotsLeft-$scope.railStatus.count)/($scope.railStatus.shotsLeft/100)
114 | if ($scope.lapseConf.direction) {
115 | return parseInt(100 - calculate)
116 | } else {
117 | return parseInt(calculate)
118 | }
119 | };
120 | //choose the best format for estimates
121 | var chooseFormat = function(timeType, duration) {
122 |
123 | //select format
124 | var type = "minute";
125 | if(duration > 86400000) {
126 | type ="day"
127 | } else if(duration > 3600000) {
128 | type ="hour"
129 | }
130 | //save human readable value
131 | $scope[timeType] = timeFormats[type].human;
132 | //return value into the source function
133 | return timeFormats[type].machine;
134 | };
135 | //shots calculation
136 | $scope.shotsLeft = function() {
137 | //shots depend on the rail length divided by motor pulse
138 | var value = 0;
139 | if($scope.lapseConf.direction) {
140 | value = parseInt((($scope.railConf.railLength-$scope.railStatus.currentPosition)+loopAddon())/$scope.lapseConf.motorPulse)
141 | } else {
142 | value = parseInt(($scope.railStatus.currentPosition+loopAddon())/$scope.lapseConf.motorPulse)
143 | }
144 | //last shot behaves a bit fishy
145 | if (value > 0) {
146 | return value + 1
147 | } else {
148 | return 0
149 | }
150 | };
151 | //remaining time calculation
152 | $scope.timeLeft = function() {
153 | var timeLeft = $scope.intervalNumber()*$scope.shotsLeft();
154 | var momentFormat = chooseFormat("timeLeftFormat",timeLeft)
155 | if(momentFormat === "day") {
156 | $scope.railStatus.timeLeft = parseInt(moment.duration(timeLeft).asDays());
157 | } else {
158 | $scope.railStatus.timeLeft = moment(moment.duration(timeLeft)._data).format(momentFormat)
159 | }
160 | };
161 | //interval calculation
162 | $scope.intervalNumber = function() {
163 | var interval = 0;
164 | if($scope.railConf.focusEnabled) {
165 | interval += parseInt($scope.lapseConf.focusLength)
166 | }
167 | if($scope.lapseConf.bulbMode) {
168 | interval += parseInt($scope.lapseConf.shutterSpeed)
169 | }
170 | interval += parseInt($scope.lapseConf.motorPulse);
171 | interval += parseInt($scope.lapseConf.waitLength);
172 | return interval
173 |
174 | };
175 | //update all calculations
176 | $scope.updateEstimate = function(){
177 | var multiply = 0;
178 | if($scope.railConf.loopEnabled) {
179 | multiply = $scope.railConf.loopCount
180 | }
181 | if(!$scope.railStatus.lapseInProgress) {
182 | $scope.railStatus.count = 0;
183 | $scope.railStatus.shotsLeft = $scope.shotsLeft();
184 | }
185 | $scope.timeLeft();
186 | var intervalNumber = $scope.intervalNumber();
187 | var momentFormat = chooseFormat("intervalFormat",intervalNumber)
188 | if(momentFormat === "day") {
189 | $scope.railStatus.interval = parseInt(moment.duration(intervalNumber).asDays())
190 | } else {
191 | $scope.railStatus.interval = moment(moment.duration(intervalNumber)._data).format(momentFormat);
192 | }
193 | };
194 |
195 | //***********************************************************
196 | //Communicate with Raspberry runtime
197 | //***********************************************************
198 | //connect to raspberry data feed
199 | var socket = "";
200 | //socket is on current environment (used to switch between dev environment and raspberry)
201 | var url = window.location.href ;
202 | var arr = url.split("/");
203 | var absoluteUrl = arr[0] + "//" + arr[2];
204 | socket = io.connect(absoluteUrl);
205 | socket.on("connect_error", function () {
206 | $scope.$apply(function() {
207 | $scope.disconnected = true;
208 | });
209 | });
210 | //device has been connected event
211 | socket.on('connect', function(data){
212 | socket.emit('pageLoaded');
213 | $scope.$apply(function() {
214 | $scope.disconnected = false;
215 | });
216 | });
217 | socket.on("disconnect", function () {
218 | $scope.$apply(function() {
219 | $scope.disconnected = true;
220 | });
221 | });
222 | //fetch saved data upon loading
223 | socket.on('connectionEstablished', function(data){
224 | console.log(data)
225 | //use saved data
226 | $scope.$apply(function() {
227 | if (data.railConf) {
228 | console.log(1)
229 | $scope.railConf = data.railConf;
230 | //use default
231 | } else {
232 | console.log(2)
233 | $scope.railConf = $scope.defaultRailConf;
234 | }
235 | if (data.lapseConf) {
236 | console.log(3)
237 | $scope.lapseConf = data.lapseConf;
238 | //use default
239 | } else {
240 | console.log(4)
241 | $scope.lapseConf = $scope.defaultLapseConf;
242 | }
243 | $timeout(function(){$scope.updateEstimate()},300)
244 | $scope.connectionEstablished = true;
245 | });
246 | $scope.$apply(function() {
247 | $scope.disconnected = false;
248 | });
249 | });
250 | //active timelapse feedback info
251 | socket.on('timelapseStatus', function (data) {
252 | $scope.$apply(function() {
253 | $scope.railStatus = data;
254 | $scope.updateEstimate()
255 | });
256 | });
257 | //run the timelapse
258 | $scope.runTimelapse = function() {
259 | socket.emit('runTimelapse', {"lapseConf":$scope.lapseConf,"railConf":$scope.railConf, "railStatus":$scope.railStatus});
260 | };
261 | //cancel timelapse
262 | $scope.cancelTimelapse = function(source) {
263 | socket.emit('cancelTimelapse', {"lapseConf":$scope.lapseConf,"railConf":$scope.railConf});
264 | };
265 | //manual move
266 | $scope.manualSlide = function(direction, state) {
267 | socket.emit('manualSlide',{direction:direction, state:!state});
268 | };
269 | //reset RailConf
270 | $scope.resetConf = function(file, data) {
271 | $scope.railConf = angular.copy($scope.defaultRailConf)
272 | socket.emit('saveSettings',{"file":"railconf","data":$scope.defaultRailConf});
273 | $scope.lapseConf = angular.copy($scope.defaultLapseConf);
274 | socket.emit('saveSettings',{"file":"lapseconf","data":$scope.defaultLapseConf});
275 | };
276 | //set current position as new "0"
277 | $scope.resetCurrentPosition = function() {
278 | $scope.railStatus.currentPosition = 0;
279 | socket.emit('resetPosition', $scope.railStatus);
280 | $scope.showSimpleToast("Position set to 0");
281 | };
282 | //save settings
283 | $scope.saveSettings = function(file, data) {
284 | socket.emit('saveSettings',{"file":file,"data":data});
285 | };
286 | //active timelapse feedback info
287 | socket.on('errorOnSave', function (data) {
288 | $scope.showSimpleToast('Something went wrong while saving settings, better hit "Reset settings" button to ensure nothing is screwed :)');
289 | });
290 | //confirmation messages
291 | $scope.showSimpleToast = function(message) {
292 | $mdToast.show(
293 | $mdToast.simple()
294 | .textContent(message)
295 | .position("top")
296 | .hideDelay(4000)
297 | );
298 | };
299 | //shut off
300 | $scope.shutOffPi = function() {
301 | $scope.main.toggle();
302 | $scope.poweredOff = true;
303 | socket.emit('shutOffPi',"shut it!");
304 | };
305 | //save settings
306 | $scope.testShot = function() {
307 | socket.emit('testShot',{"lapseConf":$scope.lapseConf,"railConf":$scope.railConf, "railStatus":$scope.railStatus});
308 | };
309 | })
310 | .directive("loseFocus", function() {
311 | return {
312 | restrict: 'A',
313 | link: function($scope,elem,attrs) {
314 | elem.bind('keydown', function(e) {
315 | var code = e.keyCode || e.which;
316 | if (code === 13) {
317 | e.preventDefault();
318 | elem.blur();
319 | }
320 | });
321 | }
322 | }
323 | });
--------------------------------------------------------------------------------
/bin/www.js:
--------------------------------------------------------------------------------
1 | //***********************************************************
2 | // PiLapseRails
3 | // raspberry Pi powered timelapse controller
4 | // author: Joosep Kõivistik // koivistik.com
5 | // repository: https://github.com/equilerex/PiLapseRails
6 | //***********************************************************
7 |
8 |
9 |
10 | //***********************************************************
11 | // dev mode... set true if windows
12 | var os = require('os')
13 | var windowsDevEnvironment = os.platform() === "win32";
14 |
15 | //***********************************************************
16 | // Dummy / demo function to test on windows, uncomment to test
17 | //***********************************************************
18 | var gpio = {
19 | "read": function (nr, state) {
20 | console.log("read pin " + gpio.definitions[nr])
21 | },
22 | "open": function (nr, state, func) {
23 | console.log("opened pin " + gpio.definitions[nr])
24 | func()
25 | },
26 | "close": function (nr, state, func) {
27 | console.log("stop " + gpio.definitions[nr])
28 | },
29 | "write": function (nr, state, func) {
30 | console.log(gpio.definitions.state[state]+" "+gpio.definitions[nr])
31 | func()
32 | },
33 | "definitions": {
34 | 11: "focus",
35 | 12: "shutter",
36 | 15: "motor forward",
37 | 16: "motor back",
38 | "state":{
39 | 1:"start",
40 | 0:"stop"
41 | }
42 | }
43 | };
44 | //normal pin plugin (override dummy)
45 | if(!windowsDevEnvironment) {
46 | gpio = require("pi-gpio")
47 | }
48 |
49 | //***********************************************************
50 | // node setup
51 | //***********************************************************
52 | var express = require('express')
53 | , app = express()
54 | , server = require('http').createServer(app)
55 | , path = require('path')
56 | //websocket connection
57 | , io = require('socket.io').listen(server)
58 | , spawn = require('child_process').spawn
59 | ,exec = require('child_process').exec
60 | //pin accesss
61 | //saving settings locally
62 | , fs = require('fs');
63 | app.engine('html', require('ejs').renderFile);
64 | app.set('view engine', 'ejs');
65 | app.set('port', process.env.TEST_PORT || 8080);
66 | //set default route
67 | /* GET home page. */
68 | app.get('/', function(req, res, next) {
69 | res.render(path.join(__dirname, '../public/app/views/index'), { root: path.join(__dirname, '../public/'), "absoluteUrl":req.headers.host});
70 | });
71 |
72 | //make files accessible in public folder
73 | app.use("/public", express.static(path.join(__dirname, '../public')));
74 |
75 |
76 | //***********************************************************
77 | // pin configuration (feel free to change) using values from here: https://github.com/rakeshpai/pi-gpio
78 | //***********************************************************
79 | var pinConf = {
80 | "focus": 11,
81 | "shutter": 12,
82 | "forward": 15,
83 | "back": 16
84 | };
85 |
86 | //***********************************************************
87 | // Status feedback
88 | //***********************************************************
89 | var railStatus = {
90 | "currentPosition":0,
91 | "lapseInProgress":false,
92 | "forward":false,
93 | "back":false,
94 | "count":0
95 | };
96 |
97 | var serverRailConf = false;
98 | var serverLapseConf = false;
99 |
100 | //***********************************************************
101 | // switch back and forward pins (in case you set up your rail the other way around)
102 | //***********************************************************
103 | var flipDirection = function() {
104 | var newForward = pinConf.back;
105 | var newBack = pinConf.forward;
106 | pinConf.forward = newForward;
107 | pinConf.back = newBack;
108 | };
109 |
110 | //***********************************************************
111 | // get saved settings
112 | //***********************************************************
113 | fs.readFile(path.join(__dirname, '../public/app/railconf.json'), 'utf8', function (err, savedRailconf) {
114 | fs.readFile(path.join(__dirname, '../public/app/lapseconf.json'), 'utf8', function (err2, savedLapseconf) {
115 | if (savedLapseconf && savedLapseconf.length > 0) {
116 | //store for socket connections
117 | serverLapseConf = JSON.parse(savedLapseconf);
118 | }
119 | if (savedRailconf && savedRailconf.length > 0) {
120 | //store for socket connections
121 | serverRailConf = JSON.parse(savedRailconf);
122 | //if position should be remembered on boot, restore it.
123 | if(serverRailConf.rememberPosition && serverRailConf.savedPosition) {
124 | railStatus.currentPosition = serverRailConf.savedPosition
125 | }
126 | //if position should be remembered on boot, restore it.
127 | if(serverRailConf.flipDirection ) {
128 | flipDirection()
129 | }
130 | };
131 | });
132 |
133 | });
134 |
135 | //***********************************************************
136 | //open pins for business
137 | //***********************************************************
138 | var openErr = false;
139 | var openCount = 0;
140 | var openPins = function() {
141 | //failsafe
142 | openCount+=1
143 | var markError = function(err) {
144 | if(err) {
145 | openErr = true
146 | }
147 | };
148 | gpio.open(pinConf.focus, "output", function (err) {markError()});
149 | gpio.open(pinConf.shutter, "output", function (err) {markError()});
150 | gpio.open(pinConf.forward, "output", function (err) {markError()});
151 | gpio.open(pinConf.back, "output", function (err) {markError()});
152 | //if outdated session then opening nodes that are open already produces error
153 | setTimeout(function () {
154 | if (openErr && openCount < 5) {
155 | console.log("try to close and open pins")
156 | gpio.close(pinConf.focus);
157 | gpio.close(pinConf.shutter);
158 | gpio.close(pinConf.forward);
159 | gpio.close(pinConf.back);
160 | openErr = false;
161 |
162 | setTimeout(function () {
163 | openPins()
164 | },2000);
165 | }
166 | },2000)
167 | };
168 | openPins();
169 |
170 | //***********************************************************
171 | // if you want to save position on boot
172 | //***********************************************************
173 | var railMoved = function() {
174 | if(serverRailConf.rememberPosition) {
175 | serverRailConf.savedPosition = railStatus.currentPosition;
176 | fs.writeFile(path.join(__dirname, '../public/app/railconf.json'), JSON.stringify(serverRailConf), "utf8", function (err) {
177 | if(err) {
178 | plr.emit("errorOnSave");
179 | }
180 | });
181 | }
182 | };
183 |
184 | //***********************************************************
185 | // cancel active timelapse
186 | //***********************************************************
187 | var stopTimelapse = function(lapseConf) {
188 | lastMotorStop = new Date().getTime();
189 | clearTimeout(focusEvent);
190 | clearTimeout(shutterEvent);
191 | clearTimeout(engineEvent);
192 | clearTimeout(intetvalEvent);
193 | clearTimeout(intetvalEvent2);
194 |
195 |
196 | gpio.write(pinConf.shutter, 0, function () {});
197 | gpio.write(pinConf.focus, 0, function () {});
198 | gpio.write(pinConf.forward, 0, function () {});
199 | gpio.write(pinConf.back, 0, function () {});
200 |
201 |
202 | // if stop was in the middle of a motor run, add that in the status
203 | if(lastMotorStart) {
204 | var motorRun = lastMotorStop - lastMotorStart;
205 | if (lapseConf.direction === true) {
206 | railStatus.currentPosition += parseInt(motorRun)
207 | } else if (lapseConf.direction === false) {
208 | railStatus.currentPosition -= parseInt(motorRun)
209 | }
210 | }
211 | //update status
212 | railStatus.lapseInProgress = false;
213 | delete railStatus.loopCount;
214 | //save state
215 | railMoved();
216 | plr.emit("timelapseStatus", railStatus);
217 | };
218 |
219 | //***********************************************************
220 | // Running timelapse logic
221 | //***********************************************************
222 | //set timeout values
223 | var focusEvent
224 | ,shutterEvent
225 | ,engineEvent
226 | ,intetvalEvent
227 | ,intetvalEvent2;
228 |
229 | //in case motor is stopped, we need the new locaton
230 | var lastMotorStart;
231 | var lastMotorStop;
232 | var runTimeLapse = function(data) {
233 | //shots left is static per session
234 | railStatus.shotsLeft = data.railStatus.shotsLeft;
235 | //make a local copy
236 | railStatus.loopCount = data.lapseConf.loopCount;
237 | //select right gpio pin for motor direction
238 | var motorGpio = pinConf.forward;
239 | var selectMotorPin = function(){
240 | if (!data.lapseConf.direction) {
241 | motorGpio = pinConf.back;
242 | } else {
243 | motorGpio = pinConf.forward
244 | }
245 | };
246 | selectMotorPin();
247 |
248 | //store new settings locally in case of restart
249 | fs.writeFile(path.join(__dirname, '../public/app/lapseconf.json'), JSON.stringify(data.lapseConf), "utf8", function (err) {
250 | //save new settings server side
251 | serverLapseConf = data.lapseConf;
252 | if(err) {
253 | plr.emit("errorOnSave");
254 | }
255 | });
256 |
257 |
258 | //set shutter speed default length if bulb disabled
259 | if (!data.lapseConf.bulbMode) {
260 | data.lapseConf.shutterSpeed = 0
261 | }
262 | //single shot cycle
263 | var shutterCycle = function () {
264 | //trigger focus & wait for focus length
265 | gpio.write(pinConf.focus, 1, function () {
266 | focusEvent = setTimeout(function () {
267 | //trigger shutter & wait for shutter speed if any
268 | gpio.write(pinConf.shutter, 1, function () {
269 | shutterEvent = setTimeout(function () {
270 | //release shutter / focus
271 | gpio.write(pinConf.shutter, 0, function () {});
272 | gpio.write(pinConf.focus, 0, function () {});
273 | //update status
274 | railStatus.count = railStatus.count+1;
275 | plr.emit("timelapseStatus", railStatus);
276 | //half of "wait" before engine, half after in order to stabilize the rails
277 | intetvalEvent = setTimeout(function () {
278 | //if loop enabled and end of rails, switch direction
279 | if(data.lapseConf.loopEnabled && railStatus.loopCount>0) {
280 |
281 | if (data.lapseConf.direction && railStatus.currentPosition <= data.railConf.railLength - data.lapseConf.motorPulse || !data.lapseConf.direction && railStatus.currentPosition >= data.lapseConf.motorPulse) {
282 | //ignore
283 | } else {
284 | //count loop
285 | railStatus.loopCount -=1;
286 | //switch direction
287 | data.lapseConf.direction = !data.lapseConf.direction;
288 | //switch pins
289 | selectMotorPin();
290 | }
291 | }
292 | //trigger motor if theres still room for it
293 | if (data.lapseConf.direction && railStatus.currentPosition <= data.railConf.railLength - data.lapseConf.motorPulse || !data.lapseConf.direction && railStatus.currentPosition >= data.lapseConf.motorPulse) {
294 | gpio.write(motorGpio, 1, function () {
295 | //log start time
296 | lastMotorStart = new Date().getTime();
297 | //stop motor
298 | engineEvent = setTimeout(function () {
299 | lastMotorStart = false;
300 | gpio.write(motorGpio, 0, function () {});
301 | //calculate new position
302 | if (data.lapseConf.direction === true) {
303 | railStatus.currentPosition += parseInt(data.lapseConf.motorPulse)
304 | } else if (data.lapseConf.direction === false) {
305 | railStatus.currentPosition -= parseInt(data.lapseConf.motorPulse)
306 | }
307 | plr.emit("timelapseStatus", railStatus);
308 | //wait til interval finishes before shooting again
309 | intetvalEvent2 = setTimeout(function () {
310 | //restart cycle
311 | shutterCycle()
312 | }, data.lapseConf.waitLength / 2);
313 | }, data.lapseConf.motorPulse);
314 | });
315 | } else {
316 | stopTimelapse(data.lapseConf);
317 | }
318 | }, data.lapseConf.waitLength / 2);
319 | }, data.lapseConf.shutterSpeed)
320 | })
321 | }, data.lapseConf.focusLength)
322 | });
323 | };
324 |
325 | //trigger the cycle for the first time
326 | shutterCycle();
327 | //update status
328 | railStatus.lapseInProgress = true;
329 | railStatus.count = 0;
330 | plr.emit("timelapseStatus", railStatus);
331 | };
332 |
333 | //***********************************************************
334 | // manual rail slide
335 | //***********************************************************
336 | var timer;
337 | var manualDirection = false;
338 | var updateStopWatch = function() {
339 | if(manualDirection==="forward") {
340 | railStatus.currentPosition += 100;
341 | } else {
342 | railStatus.currentPosition -= 100;
343 | }
344 | plr.emit("timelapseStatus", railStatus);
345 | timer = setTimeout(function() {
346 | updateStopWatch()
347 | }, 100);
348 | };
349 | var runManualSlide = function(data) {
350 | //clear states
351 | gpio.write(pinConf.forward, 0, function () {});
352 | gpio.write(pinConf.back, 0, function () {});
353 | //start or stop motor
354 | railStatus[data.direction] = data.state;
355 | if (data.state) {
356 | railStatus.lapseInProgress = true;
357 | gpio.write(pinConf[data.direction], 1, function () {});
358 | manualDirection = data.direction;
359 | updateStopWatch();
360 | } else {
361 | railStatus.lapseInProgress = false;
362 | manualDirection = false;
363 | clearTimeout(timer);
364 | //save state
365 | railMoved();
366 | plr.emit("timelapseStatus", railStatus);
367 | }
368 | };
369 |
370 | //***********************************************************
371 | // Socket.io Congfig
372 | //***********************************************************
373 | server.listen(app.get('port'), function () {
374 | console.log('Express server listening on port ' + app.get('port'));
375 | });
376 | //Save the Screen Socket in this variable
377 | var plr;
378 | //***********************************************************
379 | // Socket listener events
380 | //***********************************************************
381 | io.sockets.on('connection', function (socket) {
382 | //device connected
383 | socket.on("pageLoaded", function () {
384 | plr = socket;
385 | //If there are saved values from last session, send them to frontend
386 | var data = {
387 | "lapseConf":false,
388 | "railConf":false
389 | };
390 | if (serverLapseConf) {
391 | //pass saved config to frontend
392 | data.lapseConf = serverLapseConf;
393 | }
394 | if (serverRailConf) {
395 | //pass saved config to frontend
396 | data.railConf = serverRailConf
397 | }
398 | //send current status
399 | plr.emit("connectionEstablished", data);
400 | plr.emit("timelapseStatus", railStatus);
401 |
402 | });
403 |
404 | socket.on("saveSettings", function (data) {
405 | if(data.file === "railconf") {
406 | //in remember enabled, save status right away
407 | if(data.data.rememberPosition && serverRailConf.rememberPosition === false) {
408 | railMoved()
409 | }
410 | //flip motor pins
411 | if(serverRailConf.flipDirection !== data.data.flipDirection) {
412 | flipDirection()
413 | }
414 | //set new data
415 | serverRailConf = data.data;
416 | }
417 | //store settings locally for the next restart
418 | fs.writeFile(path.join(__dirname, '../public/app/'+data.file+'.json'), JSON.stringify(data.data), "utf8", function (err) {
419 | //save new settings on the server
420 | if(data.file === "railconf") {
421 | serverRailConf = data.data;
422 | } else if(data.file === "lapseconf") {
423 | serverLapseConf = data.data;
424 | }
425 | if(err) {
426 | plr.emit("errorOnSave");
427 | }
428 | });
429 | });
430 | //running timelapse call
431 | socket.on("runTimelapse", function (conf) {
432 | runTimeLapse(conf)
433 | });
434 | // cancel active timelapse call
435 | socket.on("cancelTimelapse", function (data) {
436 | stopTimelapse(data)
437 | });
438 | //manual slide call
439 | socket.on("manualSlide", function (data) {
440 | runManualSlide(data)
441 | });
442 | //update position
443 | socket.on("resetPosition", function (data) {
444 | railStatus.currentPosition = 0;
445 | });
446 | //shut down
447 | socket.on("shutOffPi", function (data) {
448 | exec("sudo shutdown -h now", function (error, stdout, stderr) {
449 | return;
450 | });
451 | });
452 | //test shot
453 | socket.on("testShot", function (data) {
454 | if (!data.lapseConf.bulbMode) {
455 | data.lapseConf.shutterSpeed = 0
456 | }
457 | gpio.write(pinConf.focus, 1, function () {
458 | focusEvent = setTimeout(function () {
459 | //trigger shutter & wait for shutter speed if any
460 | gpio.write(pinConf.shutter, 1, function () {
461 | shutterEvent = setTimeout(function () {
462 | //release shutter / focus
463 | gpio.write(pinConf.shutter, 0, function () {});
464 | gpio.write(pinConf.focus, 0, function () {});
465 | }, data.lapseConf.shutterSpeed)
466 | })
467 | }, data.lapseConf.focusLength)
468 | });
469 | });
470 |
471 | });
--------------------------------------------------------------------------------
/public/app/assets/lib/angular-animate.min.js:
--------------------------------------------------------------------------------
1 | /*
2 | AngularJS v1.4.8
3 | (c) 2010-2015 Google, Inc. http://angularjs.org
4 | License: MIT
5 | */
6 | (function(H,u,Sa){'use strict';function wa(a,b,c){if(!a)throw ngMinErr("areq",b||"?",c||"required");return a}function xa(a,b){if(!a&&!b)return"";if(!a)return b;if(!b)return a;X(a)&&(a=a.join(" "));X(b)&&(b=b.join(" "));return a+" "+b}function Ia(a){var b={};a&&(a.to||a.from)&&(b.to=a.to,b.from=a.from);return b}function T(a,b,c){var d="";a=X(a)?a:a&&I(a)&&a.length?a.split(/\s+/):[];q(a,function(a,s){a&&0