Compare commits

...

557 Commits
1.5.1 ... main

Author SHA1 Message Date
Matt McWilliams e6ef1ff395 Actually add new commands to cfg and all libs 2024-06-13 13:42:05 -04:00
Matt McWilliams 8e9a57bcd3 Add new command flags for camera open camera closed. Re-organized and separated identifiers and cmd flags 2024-06-13 13:35:25 -04:00
Matt McWilliams 4dc988c5bb Resolves #83; Adds the -hwaccel auto flag to all ffmpeg output commands. May not be used unless the source video is an accelerated format. 2024-05-24 15:43:52 -04:00
Matt McWilliams bc081cfe63 Correct lib jsdocs in modules. Update tests to catch new error in mscript. 2024-05-24 15:23:58 -04:00
Matt McWilliams 6c8d2d712d Remove callback from mscript (never used) and make all non-public methods private. 2024-05-24 00:26:12 -04:00
Matt McWilliams b4a974a33e Updated tests to add cases catching mscript failing on multi-device scripts 2024-05-24 00:09:28 -04:00
Matt McWilliams b21b899303 Re-enabled tests. Re-enabled docs build (jsdocs are very out of date). Removed several any types and created types for Config 2024-05-23 23:36:51 -04:00
Matt McWilliams 5597aea828 Do not display broken layout before devices are ready 2024-05-23 20:56:32 -04:00
Matt McWilliams 5d31bf0020 Ported main.js to TypeScript. Rewrote all imports and replaced with class constructors, not require()(). 2024-05-23 20:51:35 -04:00
Matt McWilliams 91ad944c46 Removed several uses of any and added types to System module. 2024-05-23 19:54:42 -04:00
Matt McWilliams cb63194fc6 All known classes have types exported and imported into dependent modules. This has already caught a class of bugs. Removing references to any will catch another. 2024-05-23 18:49:18 -04:00
Matt McWilliams 7f8a9d4289 Add Settings and Devices classes TypeScript source. 2024-05-22 23:37:21 -04:00
Matt McWilliams 8e8fac92d1 Update Settings class to export properly. Replace use of any in Device. 2024-05-22 23:36:40 -04:00
Matt McWilliams 7e24c70454 Re-write of log module to use export properly (in Typescript) and include the winston types for Logger. Will repeat this step with all of the remaining modules that are declared 'any' type and miss out on the benefits of using Typescript in the first place. 2024-05-19 18:14:33 -04:00
Matt McWilliams a9f20ebf36 Remove extraneous log lines from arduino. Device is printed by send() and also sendAsync is called by send and logs the same information. Removed. 2024-05-19 17:11:31 -04:00
Matt McWilliams 4b8c8ee842 Improve logging in JKMM100 sketches. 2024-05-19 17:10:50 -04:00
Matt McWilliams 5bad15a79a In a two device simultaneous action, the cmd module was attemptint to await both actions in an array. This was not working and caused await to not occur. Instead, all actions have been replaced by a Promise.all, which awaits both actions simultaneously until both are complete. After that, function is correct. 2024-05-19 11:05:16 -04:00
Matt McWilliams 9b7d1a3e5c Add a second projector version of the JKM100 script. In the script, move the 16ms delay to BEFORE the confirmation character and increase it to 100ms to make sure all shake is out of the system before shooting a frame. 2024-05-19 09:38:48 -04:00
Matt McWilliams 5f7fa6287f Add changes from diverged repo 2024-05-15 21:49:45 -04:00
Matt McWilliams 2af8b4b209 Merge remote-tracking branch 'origin/main' 2024-04-28 21:38:32 -04:00
Matt McWilliams 66096fa2ea Add the designs and sketches for the ACME Trebes. 2024-04-19 18:09:44 -06:00
Matt McWilliams 18875a01c6 Correctly reference common.scad and add file for camera mount. 2024-04-15 14:05:38 -06:00
Matt McWilliams 7d2c2b9d09 Use common.scad, change all cylinder entries 2024-04-15 09:42:25 -06:00
Matt McWilliams 67a290a02a Add a bellows adapter for Canon RF cameras and an ACME bellows 2024-04-14 13:34:41 -06:00
Matt McWilliams 63f4278b2b Resolve startup order issues and explanation for all the delays that were meager attempts to solve a race condition. By moving more IPC connectionts to handles, which can be awaited, there are no more attempts to send message to light object that fails because it has not yet been instantiated. 2024-04-06 23:37:30 -04:00
Matt McWilliams 6778f871db Devices, serial and type terms were updated everywhere in code except in the settings object. 2024-04-06 20:29:56 -04:00
Matt McWilliams edc72a5486 Do not overwrite data with an empty object. Overwrite values if there are keys in the object. 2024-04-06 20:15:19 -04:00
Matt McWilliams 2779258111 List of devices looks strange on laptop. Attempt at fix here 2024-04-06 20:10:14 -04:00
Matt McWilliams da735779b4 Add more trycatches add more logs. Not sure where failure is. 2024-04-06 20:00:54 -04:00
Matt McWilliams b7e2e912f4 Figure out why devices.ready() is not reaching end of method on Mono laptop 2024-04-06 19:53:04 -04:00
Matt McWilliams d34172d8e9 Use device.profile() method, seemingly not implemented properly 2024-04-06 19:37:29 -04:00
Matt McWilliams f30ce78f9d Suppress warnings from Intval and execRaw during compilation. Add logging to ready to test on Mono laptop 2024-04-06 19:18:15 -04:00
Matt McWilliams ed767aedb5 Recompile with newer modules. 2024-04-06 19:09:50 -04:00
Matt McWilliams ab35895cb3 update rails 2024-04-06 19:02:39 -04:00
Matt McWilliams 1e2b65644d Update package lock files to work with node16 and electron19 2024-04-06 18:55:46 -04:00
Matt McWilliams 3f58bbc617 Merged changes from work script into JKMM100, works on device in both work script and deployment one 2024-04-06 15:48:02 -04:00
Matt McWilliams c1da7b53a2 Fix for the canonical URL caught by Tom Murphy
Thanks Tom!
2024-01-24 05:19:07 +00:00
Matt McWilliams 4181c22995 Cleanup whitespace/semicolons and add concept for passing an exposure length to the image in millis. 2024-01-19 06:49:03 -05:00
Matt McWilliams d31ac53bd1 Back is ready to print 2024-01-09 13:54:01 -05:00
Matt McWilliams 9b954852aa Add the first draft for the CPC plug back 2024-01-08 15:49:08 -05:00
Matt McWilliams 3758916fb5 Adjust plug insert 2024-01-06 17:56:55 -05:00
Matt McWilliams 25c1395655 make insert thicker for betther overall strength of the plug 2024-01-06 14:30:00 -05:00
Matt McWilliams 440edd7b18 Add 5mm marks to bolex plate 2023-12-27 23:56:10 -05:00
Matt McWilliams a2f045841f Fix bolt countersink in bolex mounting block. Add center line to top 2023-12-27 20:04:43 -05:00
Matt McWilliams c890107e1e Experimental refactor, move commonly-used pattern of cylinder() module with 4 names arguments to cy() with 3 positional arguments, D = diameter, H = height, and FN = $fn. Might improve readability and reduce repetative use of center = true. 2023-12-26 17:37:39 -05:00
Matt McWilliams a5df1650b9 Move nuts to bottom of camera sled and bolts can drop in from the top (easier assembly, bolts can be glued in place or held in more easily). Create camera sled bolex plate and modify the bolex standoff to accomodate it. WIP. 2023-12-23 23:08:59 -05:00
Matt McWilliams 173ce499bc CPC connector work 2023-12-15 19:40:18 -05:00
Matt McWilliams 33412b0588 Merge branch 'main' of ssh://git.sixteenmillimeter.com/16mm/mcopy 2023-12-10 22:51:38 -05:00
Matt McWilliams 3c5e31a961 Work on CPC Connector plug 2023-12-10 22:48:12 -05:00
Matt McWilliams 39676f9a06 fastcsg is non-deterministic 2023-12-02 09:40:54 -05:00
Matt McWilliams 0f893d94c4 Fix the dual projector script and add notes 2023-11-30 22:32:48 -05:00
Matt McWilliams b08f5094d5 Make a solid bearing roller 2023-11-30 22:32:33 -05:00
Matt McWilliams 70e046eeb7 Fix plug diameter 2023-11-30 22:32:18 -05:00
Matt McWilliams 58d0742187 Add takeup signal terminals to the mcopy projector board. 2023-11-28 23:09:09 -05:00
Matt McWilliams f84e8b741a Developed a seemingly working fix with the "correction loop" strategy. Might be putting the motor through hell but it is consistent. 2023-11-25 20:22:44 -05:00
Matt McWilliams fcf24b5539 Add the OFFSET command to the McopySerial library 2023-11-25 20:06:16 -05:00
Matt McWilliams 128a4d2ded Update mcopy_JKMM100_work to have McopySerial library 2023-11-25 20:05:52 -05:00
Matt McWilliams b14d24e650 Prototype for Arduino Mega shield for projector. 2023-11-25 18:08:10 -05:00
Matt McWilliams 7995665c6b Add camera sled 2023-11-24 10:58:20 -05:00
Matt McWilliams a22906d3c2 Add mcopy projector board. 2023-11-22 17:33:23 -05:00
Matt McWilliams 042533dc85 Add plugs for linear bearings in rail ends. 2023-11-19 16:08:37 -05:00
Matt McWilliams 5fbefeecbf Update to the orbital brace 2023-11-13 20:43:13 -05:00
Matt McWilliams a9772ff081 Changes to the brace to allow the projector to fit. Made Y of panel larger. 2023-11-13 20:41:26 -05:00
Matt McWilliams cdf983c7c6 Render STLs for mcopy_projector and mcopy_rails. Make tweaks to orbital mount to fit bolts. 2023-11-12 15:22:23 -05:00
Matt McWilliams 03f886580f Created orbital brace corner and rendered additional stls 2023-11-09 15:54:56 -05:00
Matt McWilliams a06e2869b9 Adjust bolt voids on corner_bracket 2023-11-08 18:15:31 -05:00
Matt McWilliams 6bafb263de Projector rails added and printed 2023-11-04 09:38:20 -04:00
Matt McWilliams 493ff5fbf6 Update raisl and render all files 2023-11-01 00:27:46 -04:00
Matt McWilliams c29e0880ac Work on rails and lens gantry. First prototype is made. Rendering all. 2023-10-30 22:02:30 -04:00
Matt McWilliams 986c7a915b Tweaks to lens sled gantry 2023-10-26 18:11:35 -04:00
Matt McWilliams 68b1b8b819 Double bearings in lens sled 2023-10-24 22:20:47 -04:00
Matt McWilliams 382ba56fa7 Create a prospective "inaccurate" analogReadAverage method. 2023-10-10 22:29:02 -04:00
Matt McWilliams 24d6685047 Use I to trigger projector.home() 2023-10-10 22:12:31 -04:00
Matt McWilliams 565d2ecceb Add second dataset for testing findPeak method 2023-10-10 21:20:51 -04:00
Matt McWilliams c4456e458f Add "home" as command character "I". 2023-10-10 21:16:49 -04:00
Matt McWilliams f707dedc91 New homing behavior. Ready to port back to original. 2023-10-09 22:59:05 -04:00
Matt McWilliams 702fc4680d Had accidentally switched motors, explaining odd homing behavior. New homing behavior whips ass. 2023-10-09 22:58:48 -04:00
Matt McWilliams 99b63150ac Add more smoothing during homing step. Is running consistently but is ending with motor in wrong position each time. Very strange. 2023-10-09 20:52:58 -04:00
Matt McWilliams 6e7c226c57 Make a sample script for analyzing the array during homing step. 2023-10-09 20:52:18 -04:00
Matt McWilliams c8e5f7b742 Caught one bug after separating out code 2023-10-09 19:15:30 -04:00
Matt McWilliams 0cf147d185 Piece off homing code into its own script. 2023-10-09 19:09:50 -04:00
Matt McWilliams cf1514f53e Print lens slded at full width (140mm for now) 2023-10-09 19:07:16 -04:00
Matt McWilliams af3843a8ef Add servo functionality for rack and pinion motion. Need to fix home feature. 2023-10-09 09:59:19 -04:00
Matt McWilliams 91ce2dd450 Add BOM log lines and move rail ends into its own module 2023-10-09 09:58:55 -04:00
Matt McWilliams 71c9efae42 Tweak to the rack and pinion mechanism to allow it to fit. 2023-10-09 09:58:35 -04:00
Matt McWilliams 08ce0d792b Fix for case where this.confirmExec is not a function 2023-10-08 18:15:31 -04:00
Matt McWilliams 754ef17b74 Update servo gear to fit reinforced servo connectors. 2023-10-08 11:41:35 -04:00
Matt McWilliams 5d4fec8c81 Start adding BOM log lines to build. 2023-10-07 15:26:10 -04:00
Matt McWilliams 1e0338a77f Update rack and pinion library to one that produces valid geometry. Make first pass at rack and pinion gear 2023-10-06 13:47:15 -04:00
Matt McWilliams e6b9628746 All projector work from today 2023-10-05 17:28:01 -04:00
Matt McWilliams 6f68081dc5 Restore the home method. Now it compiles. 2023-10-03 13:44:04 -04:00
Matt McWilliams 66b18dd351 Work on LED enclosure 2023-10-03 09:16:34 -04:00
Matt McWilliams b5f5b6461a Work on LED housings 2023-09-28 22:51:55 -04:00
Matt McWilliams 6dd29d9596 Disable home feature for now. Fixed impossibly stupid bug with reverse mode. Used uint16_t rather than int16_t causing an overflow. 2023-09-28 20:46:45 -04:00
Matt McWilliams 29ba125534 Work on LED housing. 2023-09-27 21:31:35 -04:00
Matt McWilliams 144af1414c Merge remote-tracking branch 'origin/main' 2023-09-27 19:10:24 -04:00
Matt McWilliams 06906eca42 Start progress on rack and pinion nub mover 2023-09-27 19:10:13 -04:00
Matt McWilliams 0d47748d6a Saved work in progress 2023-09-27 10:07:50 -04:00
Matt McWilliams b1c8192625 Projector firmware progress: currently the homing function will not compile due to errors with reference and so the sketch method needs to be broken into workable smaller methods 2023-09-25 21:54:31 -04:00
Matt McWilliams d2c7781d79 Servo notch puller progress 2023-09-25 21:53:10 -04:00
Matt McWilliams 37d4f50ef4 Add OpenSCAD/MCAD to the project to prevent double work. Including as a submodule appears to satisfy the requirement of the LGPL and allows mcopy to remain MIT licensed. 2023-09-25 12:25:56 -04:00
Matt McWilliams 082ac85c5c Add deeper notches for 90 degree points 2023-09-25 12:14:59 -04:00
Matt McWilliams cfca56ba48 Migrate stepper block into its own module 2023-09-24 22:58:14 -04:00
Matt McWilliams c7cb4ddbc5 Create the first design of the orbital mount and make slight adjustment to panel (screws were not attaching fully). 2023-09-24 22:46:38 -04:00
Matt McWilliams 7f98d6028b Commit all work in progress 2023-09-21 21:06:31 -04:00
Matt McWilliams 401822a7bb Merge branch 'main' of ssh://git.sixteenmillimeter.com/16mm/mcopy 2023-09-15 19:18:09 -04:00
Matt McWilliams 173ba06590 Work on projector (wrong) 2023-09-14 23:30:29 -04:00
Matt McWilliams 2677118bad fix 2023-09-12 22:36:18 -04:00
Matt McWilliams 8e90456d87 LED gate should be larger 2023-09-12 21:53:38 -04:00
Matt McWilliams 0b880a5e79 Add accurateRead functions and Readme 2023-09-06 15:41:36 -04:00
Matt McWilliams 082dbc0826 Add void for motor, threaded rod (optional) and linear rod. 2023-09-06 00:01:00 -04:00
Matt McWilliams 5eccbbf6df Remove part of the 2020 ends so that it can print without supports 2023-09-05 23:29:48 -04:00
Matt McWilliams 513deb7a0a Render part of the projector. 2023-09-05 23:15:53 -04:00
Matt McWilliams 2b24dc647c Update lens assembly to start using a 2020 frame 2023-09-05 23:15:32 -04:00
Matt McWilliams f8e5968f30 Rename JK lens assembly to reflect it is a new design 2023-09-05 21:31:31 -04:00
Matt McWilliams 18b8c84fff Add additional bearings to lens sled and voids for m5 bolts to hold in side bearings. 2023-09-04 13:10:23 -04:00
Matt McWilliams 1d6ccb7838 Enlarge void for m5 bolt. Add void for m5 nut. 2023-09-04 11:43:01 -04:00
Matt McWilliams a7a63a3be7 Render all projector and rails in current state 2023-09-04 10:49:20 -04:00
Matt McWilliams 153ef9eceb Use fast-csg and parallel with 8 jobs hardcoded 2023-09-04 10:48:54 -04:00
Matt McWilliams eec7765e73 Restore settings logic 2023-08-30 01:18:10 -04:00
Matt McWilliams 03f2b55762 Fucked up the merge 2023-08-29 23:33:42 -04:00
Matt McWilliams 6714374639 restore work from tonight 2023-08-29 23:11:24 -04:00
Matt McWilliams b6b1f5d5ba Parts work 2023-08-29 22:34:55 -04:00
Matt McWilliams d7a10f9737 Enable different modes of stepping by using the settings pins. Previously was causing odd behavior because they were being used for LEDs. 2023-08-29 19:48:49 -04:00
Matt McWilliams d778adc7d0 Add LED holder concept to projector panel design 2023-08-29 17:05:53 -04:00
Matt McWilliams dcbb57f732 Rewrite mcopy_projector_firmware with AccelStepper, replacing the custom Itead firmware (not working) 2023-08-29 15:33:51 -04:00
Matt McWilliams 24452794a9 Merge remote-tracking branch 'origin/main' 2023-08-25 16:44:35 -04:00
Matt McWilliams 24fe1e8773 Work on projector: Still having issues with IteadDualStepperShield (addresses wrong motor, wrong number of steps). 2023-08-25 16:44:28 -04:00
Matt McWilliams b30c637c10 Add structures to insert 2020 Tslot into to make rails fit more snug 2023-08-23 23:35:00 -04:00
Matt McWilliams f16795b11c Render the mcopy rails parts in current form 2023-08-23 22:27:06 -04:00
Matt McWilliams 141d27599f McopyProjector lib for mcopy_projector_firmware rewrite in progress. 2023-08-23 15:21:50 -04:00
Matt McWilliams 86c88c4ac2 Printing a prototype for the lens sled 2023-08-23 00:14:47 -04:00
Matt McWilliams fbab0c043a Give up on SCAD makefile 2023-08-21 22:47:29 -04:00
Matt McWilliams 1a01a4f05e Update sprocketed_roller 2023-08-21 22:47:05 -04:00
Matt McWilliams b0305ae6da Run on all but 1 core. Update JK rails to use actual measurement 2023-08-21 22:46:42 -04:00
Matt McWilliams dd4834de04 Render rails parts (still WIP) 2023-08-21 19:39:08 -04:00
Matt McWilliams 2d90c127a3 Render existing projector panel parts 2023-08-21 19:38:55 -04:00
Matt McWilliams 51d440fccc Render all working CPC connector parts 2023-08-21 19:38:16 -04:00
Matt McWilliams 2e3ed56bb3 Update part names of bellows.scad. Render missing magnetic board. 2023-08-21 19:34:21 -04:00
Matt McWilliams 4be57f3128 Update part names for CPC connectors 2023-08-21 19:31:20 -04:00
Matt McWilliams de6f0d0495 Compile all parts in project, optionally using GNU parallel if available. 2023-08-21 19:04:39 -04:00
Matt McWilliams 98e1e73163 Update to a dynamic bash file that can render all parts in a .scad file 2023-08-21 18:23:41 -04:00
Matt McWilliams 1ae524ff31 Start making a parts list in rails end file 2023-08-21 18:23:16 -04:00
Matt McWilliams 010927c5ca Rename rails_2020 to mcopy_rails 2023-08-20 23:55:27 -04:00
Matt McWilliams 3346bf01af Work on rails having a bearing 2023-08-20 23:54:21 -04:00
Matt McWilliams 788cac7d50 All work towards creating a sled rail for the lens carriage assembly 2023-08-20 18:35:48 -04:00
Matt McWilliams 4c0fa2ba41 rails end prototype 2023-08-20 13:57:00 -04:00
Matt McWilliams 83209f466f Update all submodules 2023-08-20 12:46:36 -04:00
Matt McWilliams 10c452c1b3 Work on rails 2023-08-20 12:37:50 -04:00
Matt McWilliams a8a33a823a Update to 1.8.0 to reflect new breaking changes in app 2023-08-06 15:22:38 -04:00
Matt McWilliams e7e7f86ab3 Manual merge from capper branch: all changes to devices library. 2023-08-06 15:04:33 -04:00
Matt McWilliams 386285d48c Definition file that prevents compiler warnings on some platforms. Still unexplained because tsc is installed local to the project. 2023-08-06 14:58:26 -04:00
Matt McWilliams c4119ab7cc Manual merge from capper branch: all changes to arduino library with some improvements. 2023-08-06 14:56:42 -04:00
Matt McWilliams 176643f148 Manual merge from capper branch: all changes to display library. 2023-08-06 14:36:31 -04:00
Matt McWilliams 8b235bb6b0 mitchell work 2023-08-05 14:42:03 -04:00
Matt McWilliams 8a170f65ca Merge pull request 'canon_ble' (#82) from canon_ble into main
Reviewed-on: #82
2023-08-01 03:38:51 +00:00
Matt McWilliams 2f56dd4b8a Update the timing after delaying for 5000ms (hack) 2023-07-30 23:03:06 -04:00
Matt McWilliams 699c2dbec8 UI cleanup 1: confirm setting the exposure 2023-07-30 22:26:05 -04:00
Matt McWilliams dac720863d Resolves #80 and #81. UI will need a little cleanup. There is some string concatenation happening where it shouldn't. 2023-07-30 22:13:50 -04:00
Matt McWilliams 3b03eb70fb Add placeholder for original stepper motor 2023-07-24 21:20:06 -04:00
Matt McWilliams a173cf0d7c WIP 2023-07-23 20:00:42 -04:00
Matt McWilliams 55b39e7db3 Tweak to USB protector 2023-07-18 23:13:20 -04:00
Matt McWilliams 505a2a71e7 Add magnetic bellows models 2023-07-14 21:40:03 -04:00
Matt McWilliams fb51716e3a All work 2023-07-14 21:13:04 -04:00
Matt McWilliams bdd74fa90a Save css changes 2023-07-14 21:12:48 -04:00
Matt McWilliams 8631250b9e Ignore all apple hidden files 2023-07-13 13:00:10 -04:00
Matt McWilliams c9f35ffe90 Merge branch 'canon_ble' of ssh://git.sixteenmillimeter.com/16mm/mcopy into canon_ble 2023-07-12 22:25:17 -04:00
Matt McWilliams 18d6e2c7cd WIP on state problem 2023-07-12 22:22:46 -04:00
Matt McWilliams f47ea2d382 Work on rails ends 2023-07-10 23:07:32 -04:00
Matt McWilliams 0cc167b3a6 Incredibly close to #80 and #81. Can get state confirmation at startup. Can send exposure string and get confirmation after. Cannot get state outside of initial confirmation. Something is either locked or failing to wait? 2023-07-10 22:33:16 -04:00
Matthew McWilliams 5133295f38 Save JKMM100 work 2023-07-08 19:44:57 -04:00
Matt McWilliams 621948fbac Work on mcopy_rails concepts 2023-07-05 15:17:56 -04:00
Matt McWilliams 4539c6d897 Methods in place for setting exposure 2023-07-05 15:17:45 -04:00
Matt McWilliams a7db072dc6 Accept exposure targets as string arguments to be parsed 2023-07-05 14:46:43 -04:00
Matt McWilliams 58ce079330 Both components are working properly. 2023-07-04 22:46:37 -04:00
Matt McWilliams dd03583a27 Proof of concept works. Nano can proxy requests to ESP32 via soft serial and then receives confirmation after event. Nano has a cleaner serial interface and will not throw junk into mcopy app serial listener. 2023-07-04 18:45:51 -04:00
Matt McWilliams 3feaea74bf Do not need to declare Serial2. 2023-07-04 18:18:51 -04:00
Matt McWilliams 1d6cbe5c53 Update the serial tests 2023-07-04 17:15:26 -04:00
Matt McWilliams 318f931dbf ESP32 HardSerial note 2023-07-03 22:44:43 -04:00
Matt McWilliams 5400518ea6 Merge remote-tracking branch 'origin/canon_ble' into canon_ble 2023-07-03 22:35:37 -04:00
Matt McWilliams f73a1e3931 nano softserial note 2023-07-03 22:35:29 -04:00
Matthew McWilliams 60d7ab4b5e Add missing lines to debug sketch 2023-07-03 20:34:47 -04:00
Matthew McWilliams 95cde2907a Run the debug script 2023-07-03 20:33:32 -04:00
Matthew McWilliams 35b67f1815 Use the correct identifier on projectors 2023-07-03 20:33:18 -04:00
Matt McWilliams f958789b20 Merge remote-tracking branch 'origin/canon_ble' into canon_ble 2023-07-02 13:56:11 -04:00
Matt McWilliams 4beef04a3f Projector debug idea. 2023-07-02 13:56:03 -04:00
Matthew McWilliams 6d379d284b on site work at MONO 2023-07-01 16:34:07 -04:00
Matt McWilliams 2c21110b97 fix reference to cmdChar 2023-06-28 20:01:53 -04:00
Matt McWilliams 777db577d7 Structure of both sketches is complete, need to test on hardware 2023-06-28 15:06:11 -04:00
Matt McWilliams bf320216cf REmove remaining components from ble 2023-06-28 12:43:24 -04:00
Matt McWilliams b48c498574 Remove unneeded components from both ble sketches 2023-06-28 12:41:54 -04:00
Matt McWilliams 0b71da8e7b Canon BLE two-Arduino rewrite WIP 2023-06-27 23:16:16 -04:00
Matt McWilliams c0d6cbccec Can now detect if state is available on a device 2023-06-17 17:57:30 -04:00
Matt McWilliams 95ede98623 State string should start and end with the character 2023-06-17 13:08:00 -04:00
Matt McWilliams 3881dd4891 Update McopySerial to have a sendStr method, which is distinct from print, which should be used for debug logging. 2023-06-17 11:40:56 -04:00
Matt McWilliams 71e4bea384 Preliminary state support in arduino library. Currently confirms the negative state. Might want to push it until after verify, out of enumerate. 2023-06-16 23:04:16 -04:00
Matt McWilliams 83aa3099c4 Update the settings page with time for projector and camera actions 2023-06-16 22:07:53 -04:00
Matt McWilliams 672db32917 Put in place changes needed to receive a string from an arduino 2023-06-12 22:45:25 -04:00
Matt McWilliams 80a9c23f4d Speed down the motors 2023-05-26 07:09:00 -04:00
Matt McWilliams 49ad3c28a8 Only print projector time to state 2023-05-25 10:45:44 -04:00
Matt McWilliams a29c85628c Add bones of the dual stepper motor, JK compatible projector firmware. 2023-05-25 10:43:45 -04:00
Matt McWilliams 3ec93ab3b1 work 2023-05-16 23:05:13 -04:00
Matt McWilliams 10c29d3af1 Add a set screw to the gate_key 2023-05-15 21:48:09 -04:00
Matt McWilliams 41840b90c8 Update gitsub 2023-05-15 12:36:03 -04:00
Matt McWilliams c89e865d3d Bearing needs slight gap to allow the inner bearing wheel to rotate freely 2023-05-14 21:17:20 -04:00
Matt McWilliams c6ec54bd06 Flip projector panel to print 2023-05-14 21:01:46 -04:00
Matt McWilliams af3b1b8cbb Create first draft of projector panel redesign 2023-05-14 21:00:52 -04:00
Matt McWilliams 86273a9f09 Merge remote-tracking branch 'origin/canon_ble' into canon_ble 2023-05-02 23:58:39 -04:00
Matt McWilliams ba0241a811 Update ESP32 case 2023-05-02 23:58:31 -04:00
Matt McWilliams 1bd73876b4 Add sprocketed roller module 2023-04-28 15:35:54 -04:00
Matt McWilliams cc806cbe52 Initialize and connect only after mcopyserial connects. 2023-04-20 22:50:48 -04:00
Matt McWilliams 8f7a40075a Add connected and identified member booleans to determine when fully connected to mcopy. 2023-04-20 22:37:37 -04:00
Matt McWilliams 64faaa9427 Slight change to outer diameter. 2023-04-19 13:32:06 -04:00
Matt McWilliams d44c67ce80 Update the lens board design 2023-04-19 13:31:47 -04:00
Matt McWilliams 144b408092 Print state in the arri-s firmware 2023-04-17 16:44:04 -04:00
Matt McWilliams d2390dca30 Add a bellows board -- to be attached to bellows and then to boards with magnets. Render all STLs 2023-04-16 23:33:11 -04:00
Matt McWilliams 503a8ec92f Add magnets to bellows board design 2023-04-16 22:53:16 -04:00
Matt McWilliams ca22a3ba4b Rewrite arri_s_firmware to use McopySerial 2023-04-16 16:42:00 -04:00
Matt McWilliams ef54e61494 Use McopySerial in mcopy_arri_s_firmware 2023-04-15 22:44:33 -04:00
Matt McWilliams b1745c786b Invert logic for use with solid state relays rather than standard 2023-04-14 19:48:20 -04:00
Matt McWilliams 83efbc18c7 Fix mcopy_cam_canon_ble 2023-04-13 20:39:24 -04:00
Matthew McWilliams f47396e48c Need confirmation after mcopy_cam_relay 2023-04-12 15:25:41 -04:00
Matt McWilliams 03c27a9226 Relay logic was reversed 2023-04-12 15:15:41 -04:00
Matt McWilliams 08655898d4 Merge remote-tracking branch 'origin/canon_ble' into canon_ble 2023-04-12 14:52:40 -04:00
Matt McWilliams 5d347d23e4 Correctly reference backward LED 2023-04-12 14:52:35 -04:00
Matthew McWilliams a25d93ec55 Correctly delay between frames. 2023-04-12 14:52:05 -04:00
Matthew McWilliams bbf0cbd1c6 Add the button to the relay sketch 2023-04-11 23:43:35 -04:00
Matthew McWilliams 4aceeac1c2 Remove libraries required by TickTwo. This sketch will not use blink in this fashion ATM. 2023-04-11 23:26:12 -04:00
Matt McWilliams 1f5bb85304 Correctly reference LEDs 2023-04-11 22:39:44 -04:00
Matthew McWilliams 087fd3f763 Complete the mcopy relay sketch without variable exposure. 2023-04-11 01:13:44 -04:00
Matthew McWilliams daece3b45a Add the new mcopy_cam_relay script. 2023-04-11 00:38:06 -04:00
Matthew McWilliams 9705505285 Refactor ino.sh to loop through array of scripts to copy McopySerial library to. 2023-04-11 00:37:14 -04:00
Matthew McWilliams 9016062f70 Rename mcopy_cam_canon to mcopy_cam_canon_ble to differentiate 2023-04-11 00:28:27 -04:00
Matthew McWilliams a6de66eb66 Blink LED on startup 2023-04-11 00:24:39 -04:00
Matt McWilliams 6ada6b08ed Add LED features to projector firmware. 2023-04-10 23:28:02 -04:00
Matt McWilliams 710e178ba2 Merge branch 'canon_ble' of ssh://git.sixteenmillimeter.com/16mm/mcopy into canon_ble 2023-04-10 21:12:08 -04:00
Matt McWilliams 9e7990851e Case design work 2023-04-10 21:04:01 -04:00
Matt McWilliams ae34558f18 Add project home and mirrors to Readme 2023-04-07 09:44:51 -04:00
Matt McWilliams c1a51f1ce8 Canon EF bellows adapter 2023-04-01 19:24:29 -04:00
Matt McWilliams 13702a3d5b Add a canon_EF_body_cap script 2023-03-30 20:15:43 -04:00
Matt McWilliams 6b66cfe03f Add bolt voids to canon mount 2023-03-29 22:47:49 -04:00
Matt McWilliams cbc876c57c Case ready for production 2023-03-29 21:58:03 -04:00
Matt McWilliams 7813a8c904 First draft of Rebel case 2023-03-28 19:41:35 -04:00
Matt McWilliams 5f941e91b5 Add conecpt for arduino nano case 2023-03-26 20:19:15 -04:00
Matt McWilliams d262ed418d Add base to socket connector. 2023-03-26 20:19:00 -04:00
Matt McWilliams 2e9db4d667 Connector size is working 2023-03-26 18:53:01 -04:00
Matt McWilliams bd9317dd8f Adjust angles. Make $fn configurable (crashing the GUI on my desktop). 2023-03-26 17:53:26 -04:00
Matt McWilliams 461add1cda Start adding LEDs 2023-03-26 16:06:08 -04:00
Matt McWilliams 1528dec668 Rename bellows adapter 2023-03-24 13:51:29 -04:00
Matt McWilliams fff9d5d410 Export mcopy serial to it's own repo 2023-03-24 13:50:38 -04:00
Matt McWilliams 231c354cb1 Update McopySerial usage in both scripts that use it. 2023-03-21 20:38:45 -04:00
Matt McWilliams 4e0149e752 Fixed issue with baud being stored as const overflowed. Silly mistake.
Also storing command chars as public const variables to shorten code and allow for mc.COMMAND rather than McopySerial::COMMAND. Cleans up example code a lot.
2023-03-21 20:35:00 -04:00
Matt McWilliams 5c6b9191e5 Work in progress: Serial does not work from external library 2023-03-20 19:45:32 -04:00
Matt McWilliams 77a0f7d8a0 Use the correct pins for the projector 2023-03-18 17:36:24 -04:00
Matt McWilliams 9faae6fc36 Create the first state sender. 2023-03-18 17:25:58 -04:00
Matt McWilliams 3689eb7528 Rewrite mcopy_light to use McopySerial 2023-03-18 17:13:41 -04:00
Matt McWilliams 210dc85558 Add getString and print methods 2023-03-18 17:04:06 -04:00
Matt McWilliams 174b900cd8 Update commands 2023-03-18 17:00:13 -04:00
Matt McWilliams fbe954280f Socket connector work 2023-03-18 17:00:02 -04:00
Matt McWilliams 142c990a0e Refactored GUI into TypeScript and class-based format 2023-03-18 16:59:26 -04:00
Matt McWilliams 790ea3d551 Add guides for collar flanges 2023-03-15 22:11:48 -04:00
Matt McWilliams c6b8592490 Enlarge case and add bolt 2023-03-15 21:35:35 -04:00
Matt McWilliams f67e011d5e Canon EOS M50 mount design 2023-03-15 21:35:23 -04:00
Matt McWilliams a4bc54482d Work on canon mount 2023-03-15 19:22:18 -04:00
Matt McWilliams be50eb6fcf Work on ESP32 case and CPC socket 2023-03-14 21:45:18 -04:00
Matt McWilliams a7d784583a Case for an ESP32 dev board (Inland, Microcenter) 2023-03-13 17:46:38 -04:00
Matt McWilliams 7af1f739e4 Canon EF M bellows mount 2023-03-13 17:46:21 -04:00
Matt McWilliams 3e247703a8 More CPC connector work 2023-03-13 17:45:50 -04:00
Matt McWilliams c7e338ebff projector electronics improvements, move arduino mount, increase size, adjust resistor mount 2023-03-12 21:28:29 -04:00
Matt McWilliams cc2af435d5 First pass at esp32 case 2023-03-12 17:55:09 -04:00
Matt McWilliams 87695b173d First pass at projector controller design and refactor of sequencer case. 2023-03-12 16:36:16 -04:00
Matt McWilliams 722ff9c05e Remove unneeded comments 2023-03-10 21:19:30 -05:00
Matt McWilliams 51114df576 First draft of the JKMM100 firmware using McopySerial. Boy does this make my life easier.
Need to find a better way than copying it into all of these different projects.
Oh well.
2023-03-09 21:54:54 -05:00
Matt McWilliams 9126bc82c0 Confirm the camera command (this should happen after it expects frame is taken). 2023-03-09 21:51:49 -05:00
Matt McWilliams e09fe7d42f McopySerial now has a confirm() method which marks the end of a command. This is a wrapper around Serial.println() 2023-03-09 21:51:29 -05:00
Matt McWilliams 234e69c7a2 Canon BLE firmware now uses the McopySerial script for it's USB communication. 2023-03-09 21:30:59 -05:00
Matt McWilliams d7017af245 Move connect and identify methods to internal ones. 2023-03-09 21:26:31 -05:00
Matt McWilliams f49c70ead6 Define all command chars as static constants. Provide an identity when initializing and allow for setting with another method. 2023-03-09 21:18:10 -05:00
Matt McWilliams 9a89dbe6a5 Automatically toggle debug state internally 2023-03-09 21:08:36 -05:00
Matt McWilliams 844bb286a5 Build the skeleton of McopySerial. Contains all command chars as flags. Is now re-built with latest command flags automatically when syncing to all projects. Compiles. Will implement more in canon firmware. 2023-03-09 21:01:20 -05:00
Matt McWilliams 4eceecf139 Add ino script 2023-03-08 22:37:40 -05:00
Matt McWilliams 95e2e997e5 Move mcopy serial script. Add work (isn't working). 2023-03-08 21:28:09 -05:00
Matt McWilliams 346c303edb First pass at connector plug 2023-03-08 16:01:02 -05:00
Matt McWilliams 908fe52ad8 Simplify projector_controller.scad 2023-03-05 17:14:01 -05:00
Matt McWilliams 3fd1e47b7b Rename sleeve to collar 2023-03-05 17:13:42 -05:00
Matt McWilliams d41f082839 Update light sketch, add Pixie lib 2023-03-05 17:13:29 -05:00
Matt McWilliams 2047ce4f76 cpc connector work 2023-03-05 00:28:39 -05:00
Matt McWilliams 3ef56cab21 Compile all Arri-S parts 2023-03-04 20:20:16 -05:00
Matt McWilliams 6b77b98aad Add more files to scad.sh 2023-03-04 20:00:01 -05:00
Matt McWilliams 211101cd6b Add common SCAD lib. Add a script that compiles all scad files to stl (make is getting excessive). Canonicalize STL files after they're compiled. 2023-03-04 19:44:20 -05:00
Matt McWilliams e27cae353f Work on McopySerial library. Still having trouble with compiling. 2023-03-04 19:25:50 -05:00
Matt McWilliams b12a08e47a Rename lib to match style of others 2023-03-04 19:04:55 -05:00
Matt McWilliams 9b298ac676 Sync actual files 2023-03-04 19:01:35 -05:00
Matt McWilliams 52acb97e08 Try without symlinks 2023-03-04 18:59:47 -05:00
Matt McWilliams 78450e9e6a Add mcopy_serial library 2023-03-04 18:52:51 -05:00
Matt McWilliams dc746fe6f4 canon work 2023-03-03 10:13:40 -05:00
Matt McWilliams 0e3bc563a7 Update blink functionality. Probably will not work during start? 2023-03-01 13:51:54 -05:00
Matt McWilliams d0ef5d410d Ignore all .svd files 2023-03-01 13:38:48 -05:00
Matt McWilliams d9aa7dc698 Ignore build artifacts 2023-03-01 13:38:27 -05:00
Matt McWilliams 70ab8cb527 Improve timing. Sequence takes into account serialDelay within each command and sequenceDelay has no bearing. Was adding 120ms of error to every step 2023-03-01 13:37:22 -05:00
Matt McWilliams 512f6c86ad Resolves #73. Delay is exported in .ts file so it is non-ambient 2023-03-01 13:35:45 -05:00
Matt McWilliams d23eb290d9 Merge branch 'main' into canon_ble 2023-02-28 15:59:11 -05:00
Matt McWilliams 648bca5b2e Merge pull request 'Merge the estimates branch' (#79) from estimates into main
Reviewed-on: #79
2023-02-28 15:58:26 -05:00
Matt McWilliams 5db5d477e4 Timing is now updated via rolling average on all projector and camera actions. This data is reset when profile is changed. This data is stored in the settings.json and loaded on start so estimates will improve the more it is used. 2023-02-28 15:55:02 -05:00
Matt McWilliams 7741134917 Create the Timing class 2023-02-28 14:30:17 -05:00
Matt McWilliams 3c19cd35cf Resolves #4 (4 years ago!). Adds delay (stops scripts for X seconds), alert (displays an alert that stops script execution) and pause (displays a pre-populated alert). 2023-02-28 12:49:11 -05:00
Matt McWilliams 85832d18f6 Placeholder for notes 2023-02-27 23:16:44 -05:00
Matt McWilliams 5f0da91659 Canon BLE work 2023-02-26 22:19:07 -05:00
Matt McWilliams e1bf69e622 Add work on mcopy_cam_canon. This includes teh CanonBLERemote library, ArduinoNvs (dependency of CanonBLERemote) and TickTwo, potentially to manage a blinking UI component. Not working. Finish the firmware feature in this branch. 2023-02-25 22:24:29 -05:00
Matt McWilliams d9290f7262 Add branch_name.sh to print out only the branch name 2023-02-25 22:22:42 -05:00
Matt McWilliams 81b6846261 Only update patch on main 2023-02-25 22:22:18 -05:00
Matt McWilliams a57519adce Merge pull request 'Merge all work on server with filmout features' (#77) from server into main
Reviewed-on: #77
2023-02-25 21:16:28 -05:00
Matt McWilliams 02639466ee By doing a check for active clients during the sequencer start and stop actions, the local display is no longer used. Resolves first part of #20. 2023-02-25 17:00:11 -05:00
Matt McWilliams 6e2795d380 Remove ACK messages for ping, rely on 2023-02-25 16:33:55 -05:00
Matt McWilliams 8e35596088 Fixed the iOS issue. Also allow for fullscreen on all browsers (with no sleep). Can preview properly but normal mode does not work 2023-02-25 16:32:08 -05:00
Matt McWilliams 0162d012c5 Server can now display images and will completely preempt local display when done 2023-02-25 13:22:20 -05:00
Matt McWilliams 47fb673b78 Combined script and html into single request (problems with iOS safari).
Can get script loaded but still cannot connect to websocket server without SSL.

ALSO: Now can pre-empt opening new display if an active client is connected to server.
Otherwise will open a local link.
2023-02-25 13:11:40 -05:00
Matt McWilliams f296488bc2 Further progress on #20. TODO: Image display logic on the server side. Need to add image to proxy list and give it a properly-extensioned name and cmdAll.
ALSO: Server is not working on iOS.
2023-02-25 12:40:35 -05:00
Matt McWilliams f5392aea9f Resolves #74 2023-02-25 12:33:18 -05:00
Matt McWilliams 24b1301f9f Adding contextIsolation: false to the display module fixes the initial issue in #74, cannot use "require" but the escape button does not work due to "Cannot read properties of undefined (reading 'getCurrentWindow')" 2023-02-25 12:16:47 -05:00
Matt McWilliams 1290a8f324 Major progress on #20. Promised-based websocket command structure is completed. All functionality needs to be placed into individual classes and any new functions get added to the server.
Will create entire thin client using this method.
2023-02-25 11:59:56 -05:00
Matt McWilliams e64277e438 More work on #20. Fix typos in display code. Should re-work script into transpiled ts file. 2023-02-25 02:08:56 -05:00
Matt McWilliams c9bcb74a9f Progress on #20. Can start up a server and serve client.js 2023-02-25 02:08:05 -05:00
Matt McWilliams 42db1f81b8 Server work 2023-02-25 00:24:07 -05:00
Matt McWilliams 7222952eba Update version nubmers 2023-02-19 19:43:12 -05:00
Matt McWilliams 744f10c948 Display version in app 2023-02-19 11:36:06 -05:00
Matt McWilliams b50704a6a8 Fix minor layout issue on sequence page (on mac at least). 2023-02-19 01:28:18 -05:00
Matt McWilliams c152806511 Now it works. 2023-02-19 01:27:19 -05:00
Matt McWilliams 4d9454daf2 Patch script now working 2023-02-19 01:22:44 -05:00
Matt McWilliams e754c65602 Increment patch without npm install 2023-02-19 01:20:51 -05:00
Matt McWilliams b672921c84 Increment patch number on commit 2023-02-19 01:18:03 -05:00
Matt McWilliams 6116ada2fd Getting a new error when compiling delay library. Attempt to stop autogenerating d.ts files.
src/delay/index.ts:11:10 - error TS2384: Overload signatures must all be ambient or non-ambient.
2023-02-19 00:55:17 -05:00
Matt McWilliams d7baa4d17b Merge branch 'capper'
:w
ls
2023-02-19 00:29:40 -05:00
Matt McWilliams ebc5504998 Add commands for takeup 2023-02-19 00:29:07 -05:00
Matt McWilliams c5e66a6f40 Merge pull request 'Merge in 9 months of work on capper branch' (#71) from capper into main
Reviewed-on: #71
2023-02-19 00:28:45 -05:00
Matt McWilliams cff558ef9a Add 15mm to mount void for camera bolt 2023-02-12 14:14:03 -05:00
Matt McWilliams 325837d93e Adjustment to allow space on the right side 2023-02-12 14:10:44 -05:00
Matt McWilliams 135540b261 Remove some material for the rails 2023-02-03 20:08:18 -05:00
Matt McWilliams 49464cd25a Finished the design of the lens assembly base z attachment 2023-02-02 19:48:30 -05:00
Matt McWilliams d0fe54b429 Add m5 nut to the common lib 2023-02-02 19:48:08 -05:00
Matt McWilliams 2dce6f4b08 Merge branch 'capper' of git.sixteenmillimeter.com:16mm/mcopy into capper 2023-01-31 11:52:13 -05:00
Matt McWilliams 99794d04c2 jk assembly and arri-s wip 2023-01-31 11:52:10 -05:00
Matt McWilliams cc06655cd6 Update debug 2023-01-23 00:28:26 -05:00
Matt McWilliams ab6f517d27 Rails work 2023-01-17 12:04:03 -05:00
Matt McWilliams 682167db48 Add new commands for takeup forward and takeup backward 2023-01-15 10:09:55 -05:00
Matt McWilliams f127dc1128 Merge remote-tracking branch 'origin/capper' into capper 2023-01-14 15:26:07 -05:00
Matt McWilliams 0b816ae8e1 Adjust the position of the Z axis, move the linear bearing up and down to prevent binding on motion 2023-01-14 15:25:53 -05:00
Matt McWilliams c600fea4e1 Start rails concept 2023-01-12 19:26:05 -05:00
Matt McWilliams 92067bdbef Add top part to assembly 2023-01-11 19:17:15 -05:00
Matt McWilliams c181e003a3 First draft of base 2023-01-07 18:43:59 -05:00
Matt McWilliams 597137670d Merge base work with knob changes 2023-01-06 10:31:25 -05:00
Matt McWilliams 3036aebbc4 Knob and collar work 2023-01-06 09:18:03 -05:00
Matt McWilliams cbe6477af2 Improvements to bearing and Tnut size 2023-01-05 17:35:25 -05:00
Matthew McWilliams c2546d2bc5 Add m3 nuts and bolts to threaded z movement 2023-01-05 14:40:25 -05:00
Matt McWilliams 46be1bfd3b Assembly work. Adjusted design to simplify placement of 2 linear bearings 2023-01-04 23:11:48 -05:00
Matt McWilliams 1029885047 Update threaded Z, still needs m3 bolts 2023-01-04 18:26:22 -05:00
Matt McWilliams 164bde8cce All arri s mount and jk lens assembly work. need to do some branch cleanup on this project and tackle capper issues for merge of this branch. 2023-01-03 21:16:19 -05:00
Matt McWilliams 41504caac9 Increase the bolt size on the bellows board 2023-01-02 17:11:44 -05:00
Matt McWilliams 9b34b4e026 Adjust the height of the mount (-14.5mm) and make bolt voids larger 2023-01-02 14:33:16 -05:00
Matt McWilliams 95612c1d18 Add m3 nuts 2023-01-02 14:30:54 -05:00
Matt McWilliams 0829ec9081 Use a variable 2023-01-02 13:53:41 -05:00
Matt McWilliams ef0d246901 Increase the inner diameter of the bellows board to allow the threads to pass through cleanly and be held in place by the screw 2023-01-02 13:53:30 -05:00
Matt McWilliams 622a8a7c42 Add first concept bellows board 2023-01-01 11:43:30 -05:00
Matt McWilliams 925659ba4b Create an Arri S mount for the JK rails 2023-01-01 11:43:21 -05:00
Matt McWilliams 20c9287ac2 Work on concept JK lens assembly 2022-12-24 17:36:25 -05:00
Matt McWilliams 8aaa2b8940 Add a concept JK lens assembly 2022-12-24 01:55:11 -05:00
Matt McWilliams 30bd35e21d Add an M4 nut to the common OpenSCAD lib 2022-12-24 01:54:57 -05:00
Matthew McWilliams 0c2e39f0b2 Arri bellows work 2022-12-23 23:01:37 -05:00
Matt McWilliams cbd7001228 Save work on the JK99 shield. 2022-11-13 17:35:18 -05:00
Matt McWilliams dec96ec9be Use variable in stepper declaration 2022-11-11 15:47:58 -05:00
Matt McWilliams 3942cd05be Declare stepsPerRevolution so change is explicit when that happens 2022-11-11 15:47:43 -05:00
Matt McWilliams ee1e9c9feb Stepper firmware is working. Needed extra tape around coupling connector to add friction to connection and now it keeps. 2022-11-04 19:37:11 -04:00
Matt McWilliams fcb77232ec Create the driveCoupling module for the stepper motor design 2022-10-30 12:14:25 -04:00
Matt McWilliams 1fcbec7466 Work on stepper motor design and software. Motor still moves more slowly than it should but will investigate multiple factors leading to this result 2022-10-28 19:46:02 -04:00
Matt McWilliams 98f2c7a24a Pausing work on arri_s_DC firmware because hardware is less than ideal. Too much play in the motor position to trust right now. Steppers better approach. 2022-10-28 11:28:30 -04:00
Matt McWilliams 787e6ed06e Add a concept arri_s camera controller firmware. Using class-based approach as an experiment in Arduino code structure. 2022-10-28 07:50:30 -04:00
Matt McWilliams bb5b7c7897 Add divot to the drive coupling 2022-10-28 07:44:19 -04:00
Matt McWilliams 42b3aa767d Allow for even more space for microswritch 2022-10-28 01:32:58 -04:00
Matt McWilliams b20a6084e6 Allow for more space for the microswitch 2022-10-27 18:10:13 -04:00
Matthew McWilliams d9a8576701 Adjust size of drive coupling for the DC connector 2022-10-21 16:05:56 -04:00
Matthew McWilliams 69273d2a1c Increase scale of motor shaft void by 5% 2022-10-21 15:26:17 -04:00
Matthew McWilliams 755ea757f7 Add set screw for bearing and counter sink bolt caps for other cap m3s 2022-10-21 15:24:21 -04:00
Matt McWilliams 81fc54af8d DC motor design has all components designed, need to print, test and adjust. 2022-10-19 06:38:56 -04:00
Matt McWilliams 4281ca4390 Work on Arri-S DC motor 2022-10-16 19:03:02 -04:00
Matt McWilliams 3419172535 Arri-S work 2022-10-15 00:13:05 -04:00
Matt McWilliams 206c266b08 Added Arri-S motor and cap measurements as taken 10/8/2022 2022-10-09 11:22:12 -04:00
Matthew McWilliams 5026cf869f Arri-S work 2022-10-07 19:47:56 -04:00
Matthew McWilliams d5ecd9e057 Improve capper documentation 2022-09-16 09:45:19 -04:00
Matthew McWilliams 72b5077356 Restructure includes and type definition files so that mscript runs 2022-08-07 22:18:58 -04:00
Matthew McWilliams 6601c030f7 Refactor mscript GUI code into Typescript 2022-08-07 22:10:53 -04:00
Matthew McWilliams 3ec1373f08 Caught a possible ancient bug in the loop logic for calculating state of camera and projector backwards movements. 2022-08-07 17:23:06 -04:00
Matt McWilliams b29478cb58 Increment build patch version 2022-08-04 10:57:36 -04:00
Matt McWilliams fe61e63e76 Add secondary projector and camera commands to the mscript module 2022-08-04 10:52:00 -04:00
Matt McWilliams ee0ab663d7 Complete the alert feature. Have not created pause, but this could be done using the same alert object to prevent code duplication. 2022-08-03 09:02:47 -04:00
Matt McWilliams 1964d6002d Add mono logo as png, but might use svg instead. Render crashed PC. 2022-07-22 21:56:43 -04:00
Matt McWilliams f55b72044c Mcopy firmware with optional capper feature 2022-07-17 11:05:20 -04:00
Matt McWilliams 3f759f5678 Add the ability to detect a single capper device 2022-07-17 09:57:52 -04:00
Matt McWilliams 6582154ec6 Fix debug script and component 2022-07-17 09:56:03 -04:00
Matt McWilliams 9d0545aa4f All capper features in app, can shoot blank frames, can turn on capper independently and can schedule blank frames in the sequencer. Some cleanup may be needed but there are no noticeable regressions in the app. TODO: Finish all arduino scripts. 2022-07-15 18:11:26 -04:00
Matt McWilliams ea055d6e56 Capper case candidate 2022-07-13 23:04:00 -04:00
Matthew McWilliams bc48765b35 Start work on base 2022-07-13 18:16:43 -04:00
Matthew McWilliams 70c2c695f0 All capper work. Need to wrap all actions in the 'b' command and push functionality to a lower level to prevent unneeded complexity. 2022-07-13 15:21:26 -04:00
Matthew McWilliams 8ec5816364 Adjust settings page to support Processing input 2022-07-13 10:15:47 -04:00
Matthew McWilliams c33c6e24f6 Work on motor rod 2022-07-13 09:01:25 -04:00
Matt McWilliams b0ca15bd8d Merge branch 'capper' of git.sixteenmillimeter.com:16mm/mcopy into capper 2022-07-13 08:28:58 -04:00
Matt McWilliams 76799bd66d Capper work 2022-07-13 08:28:18 -04:00
Matthew McWilliams 18dbb72a54 Minor updates to comments 2022-07-06 14:42:53 -04:00
Matthew McWilliams c0ec81c0f9 Add Servo debug script 2022-07-06 14:42:16 -04:00
Matt McWilliams c3661d6ff1 Remove opto endstop logic, ready for hardware testing. 2022-06-28 08:58:31 -04:00
Matt McWilliams c0f056cd8d Re-render all STLs for capper, removing the opto endstop component (for now) 2022-06-28 08:38:11 -04:00
Matt McWilliams 2924efe39f Reduce the size of the void for the screw in the cap. 2022-06-28 08:34:29 -04:00
Matt McWilliams e275539fb0 Remove endstop completely and start rounding surfaces. 2022-06-22 07:45:01 -04:00
Matt McWilliams 4c13c54815 Updates to endstop mount design. Had incorrectly positioned voids for SMD chips on the endstop 2022-06-20 13:00:40 -04:00
Matt McWilliams 62a66f5f6d More mount work and start of endstop logic. Rebuilding the B&H projector unity. 2022-06-17 23:39:19 -04:00
Matt McWilliams 3a435933e3 Work on the opto endstop mount. This needs to be re-oriented before next print. 2022-06-16 00:29:31 -04:00
Matt McWilliams 78f7ac0e68 Mount work 2022-06-13 22:46:23 -04:00
Matt McWilliams 28dc19fc32 Work on endstop functionality 2022-06-13 22:46:13 -04:00
Matt McWilliams 585c47d6c7 Allow capper identifier in list of acceptable responses. 2022-06-13 08:08:42 -04:00
Matt McWilliams 04a0330327 All work on first draft of capper hardware 2022-06-12 22:26:03 -04:00
Matt McWilliams dae4e65aee Merge branch 'capper' of git.sixteenmillimeter.com:16mm/mcopy into capper 2022-06-12 13:37:52 -04:00
Matt McWilliams 129647b863 App work 2022-06-12 13:37:00 -04:00
Matt McWilliams 2f9201716a All capper work. Debug firmware for testing. STL of cap as printed. 2022-06-12 13:14:43 -04:00
Matt McWilliams f9d716552b Merge branch 'capper' of git.sixteenmillimeter.com:16mm/mcopy into capper 2022-06-11 16:06:25 -04:00
Matt McWilliams 818c8453ee Capper OpenSCAD work 2022-06-11 16:03:08 -04:00
Matthew McWilliams f7a3c52260 Silly typo: did not invoke Servo_init() and so servo was not initalizing 2022-06-10 13:19:38 -04:00
Matt McWilliams 9d3bf24627 Hardware ideas for capper mount and flag. Need to model servo and add places for endstops 2022-06-07 07:55:47 -04:00
Matt McWilliams c77201ef4e Add new commands and identifiers for the capper, start moving into capital characters 2022-06-07 07:55:26 -04:00
Matt McWilliams f585aa2a5a Upgrade electron 11 -> 19 (huge jump). Install new remote module to preserve legacy communication protocol. 2022-06-04 11:11:23 -04:00
Matt McWilliams 96e0ce6050 Merge branch 'capper' of git.sixteenmillimeter.com:16mm/mcopy into capper 2022-05-31 17:44:56 -04:00
Matt McWilliams 17d4ff459f Notes about 4pin_connectors 2022-05-31 17:43:03 -04:00
Matt McWilliams c15c376a2f Start work on capper branch 2022-05-30 18:50:18 -04:00
Matt McWilliams 22bed4632b Update the notarization process for installing mcopy 2022-04-30 18:51:33 -04:00
Matt McWilliams 8b5faaa1a4 Update global package.lock 2022-04-30 16:03:33 -04:00
Matt McWilliams 81d94fd727 update package lock 2022-04-30 16:03:03 -04:00
Matt McWilliams bbfe6fc657 Add option to use Processing with a server as a capture method triggered by the camera.
Enter a url into the Settings panel in the Processing URL input box and select the radio button.
2022-04-30 15:58:17 -04:00
Matt McWilliams 467a5c06d6 Update the projector knob design 2022-04-30 15:52:04 -04:00
Matt McWilliams 9dce9fb1f2 Add an alternate script for notarizing builds 2021-05-01 12:20:19 -04:00
Matt McWilliams e1c8ba1320 Build_linux.sh already tags the installer with the correct version number 2021-04-13 18:39:22 -04:00
mmcwilliams 4ef318c55e Rename installer after build process. 2021-04-13 14:45:15 -04:00
mmcwilliams 7f7513809a Established an app signing process for macs using electron-packager. The process takes an enormous amount of time but has so far been running without throwing an exception and the signature is confirmed by codesign. 2021-04-13 14:17:12 -04:00
Matt McWilliams b3bb07454f Add a lamp housing knob 2021-04-05 10:40:50 -04:00
Matt McWilliams faad084b2b Hide "blank" buttons because they do not have a use case in the current app. 2021-04-01 22:21:27 -04:00
Matt McWilliams 3e528c23a5 Give the filmout position input element a fixed width value 2021-04-01 19:45:08 -04:00
Matt McWilliams 6fed941441 Filmout UI was breaking on linux (all of a sudden) 2021-04-01 19:40:29 -04:00
Matt McWilliams 6fee5a803c connector case box 2021-03-19 21:32:53 -04:00
Matt McWilliams 2861bc52fd intval2 connector firmware 2021-03-19 14:09:46 -04:00
Matt McWilliams 8c14a06b96 Removed naked console.log statements that were used to debug a serial issue. If needed they can be re-added to the actual log library. 2021-03-19 12:10:07 -04:00
Matt McWilliams 3e0ac3f0d0 Added return types to Filmout library and added return types to comments where needed. 2021-03-19 12:09:03 -04:00
Matt McWilliams 394fbe2323 Update cfg.json. Not sure why this lags?? 2021-03-18 11:55:18 -04:00
Matt McWilliams 11267796ba Update links to latest release 2021-03-18 11:35:55 -04:00
Matt McWilliams aac5e5d488 Increment patch to 1.6.9 2021-03-18 11:28:46 -04:00
Matt McWilliams 8a6bc0b4f5 Fixed video export, still sequence selection 2021-03-18 11:27:53 -04:00
Matt McWilliams a2af605d37 Filmout needs to receive the whole state, not just the frame. Still broken. 2021-03-18 10:00:49 -04:00
Matt McWilliams 32f70be614 Fixes #50 - Support image sequences in filmout feature 2021-02-24 11:58:19 -05:00
Matt McWilliams 31c701734a Corrected a UI issue with selecting directories of non-supported images. Works on macOS now with videos, images and image sequences. Testing on linux again before resolving. 2021-02-24 11:50:15 -05:00
Matt McWilliams fb7b1e2fb6 Added an edge-case helper for choosing files/directories in linux. This finishes the requirement for issue #50 on linux, but will test changes on macOS before marking the issue resolved. 2021-02-24 10:05:45 -05:00
Matt McWilliams 5061a511ab Corrected an issue with the monitor selection UI where the text is cut off. 2021-02-24 00:38:11 -05:00
Matt McWilliams c0121bcfe7 Have seemingly added the ability to use image sequences with the filmout feature with a few caveats. File selection is working on mac but was not on Linux. Also using this method only jpeg and png sequences can be used. This is not unacceptable, but the UI will have to be made more explicit about this limitation. I would like to support TIFF files but even now with single images they are rendered to PNG using ffmpeg. 2021-02-24 00:22:08 -05:00
Matt McWilliams 66639e951b Allow for the selection of a video file, image or directory containing images to be selected in the filmout UI. 2021-02-23 19:54:03 -05:00
Matt McWilliams 53d147b9bc Add lstat and "directory" property onto the filmout.state object. 2021-02-23 19:53:22 -05:00
Matt McWilliams ad1ac51fc8 Need to enableRemote in the electron browser window that gets created by filmout. 2021-02-23 16:16:17 -05:00
Matt McWilliams 88a6e9f563 Update links to older builds 2021-02-22 13:48:19 -05:00
Matt McWilliams 7dc4d153be Merge remote-tracking branch 'origin/master' 2021-02-22 13:47:05 -05:00
Matt McWilliams dcc91501ee Update readme with links to latest release (1.6.7) 2021-02-22 13:46:58 -05:00
Matt McWilliams 6473f388d8 Update package-lock to latest version 2021-02-22 13:40:44 -05:00
Matt McWilliams a21fff82f1 Update license as work has been ongoing since 2018 2021-02-22 13:26:21 -05:00
Matt McWilliams 2c8eabeffd 3D printable panel for the Oxberry control box. 2021-02-22 13:24:18 -05:00
Matt McWilliams 85bfa57127 Update all modules in app to latest version, including electron. Removed electron updater because of no plans to integrate and to reduce the app size. 2021-02-22 13:23:36 -05:00
Matt McWilliams 112e6b543c Update modules at the project root level. Update to npm lock version 2. 2021-02-22 13:16:49 -05:00
Matt McWilliams 232f39b861 Remove the cli project. It was unmaintained and unnecessarily adds to the project complexity. 2021-02-22 13:15:38 -05:00
Matt McWilliams 338a60f947 Restructure function to match convention. Declare all variables in the beginning of the function rather than declaring them throughout. Small edit while I re-read the UI code and build the file sequence feature. 2021-02-22 13:12:27 -05:00
Matt McWilliams 9ab1436d49 Move dev commands into its own script. 2021-02-22 13:03:41 -05:00
Matt McWilliams 8d3c035e7b Rename "build" to "compile" to match rest of project. 2021-02-22 13:03:08 -05:00
sixteenmillimeter 10b823bca8
Merge pull request #58 from sixteenmillimeter/dependabot/npm_and_yarn/cli/systeminformation-4.27.11
Bump systeminformation from 4.16.0 to 4.27.11 in /cli
2020-11-09 23:49:17 -05:00
sixteenmillimeter 7f9020e698
Merge pull request #57 from sixteenmillimeter/dependabot/npm_and_yarn/app/electron-9.3.1
Bump electron from 9.1.1 to 9.3.1 in /app
2020-11-09 23:49:06 -05:00
sixteenmillimeter 6a563e131b
Merge pull request #56 from sixteenmillimeter/dependabot/npm_and_yarn/electron-10.1.3
Bump electron from 9.1.0 to 10.1.3
2020-11-09 23:48:56 -05:00
dependabot[bot] 1fb5c984ac
Bump systeminformation from 4.16.0 to 4.27.11 in /cli
Bumps [systeminformation](https://github.com/sebhildebrandt/systeminformation) from 4.16.0 to 4.27.11.
- [Release notes](https://github.com/sebhildebrandt/systeminformation/releases)
- [Changelog](https://github.com/sebhildebrandt/systeminformation/blob/master/CHANGELOG.md)
- [Commits](https://github.com/sebhildebrandt/systeminformation/commits)

Signed-off-by: dependabot[bot] <support@github.com>
2020-10-27 20:31:56 +00:00
dependabot[bot] b90a68cb39
Bump electron from 9.1.1 to 9.3.1 in /app
Bumps [electron](https://github.com/electron/electron) from 9.1.1 to 9.3.1.
- [Release notes](https://github.com/electron/electron/releases)
- [Changelog](https://github.com/electron/electron/blob/master/docs/breaking-changes.md)
- [Commits](https://github.com/electron/electron/compare/v9.1.1...v9.3.1)

Signed-off-by: dependabot[bot] <support@github.com>
2020-10-06 17:50:14 +00:00
dependabot[bot] 7ebfe16897
Bump electron from 9.1.0 to 10.1.3
Bumps [electron](https://github.com/electron/electron) from 9.1.0 to 10.1.3.
- [Release notes](https://github.com/electron/electron/releases)
- [Changelog](https://github.com/electron/electron/blob/master/docs/breaking-changes.md)
- [Commits](https://github.com/electron/electron/compare/v9.1.0...v10.1.3)

Signed-off-by: dependabot[bot] <support@github.com>
2020-10-06 14:48:42 +00:00
sixteenmillimeter e84f1ce8ff Add additional logging 2020-10-03 21:33:45 -04:00
sixteenmillimeter eb7e62aac7 Fixed projector function 2020-10-03 21:32:16 -04:00
sixteenmillimeter dab5c67c04
Merge pull request #54 from sixteenmillimeter/dependabot/npm_and_yarn/cli/bl-3.0.1
Bump bl from 3.0.0 to 3.0.1 in /cli
2020-09-29 15:51:26 -04:00
sixteenmillimeter 69ca62f884
Merge pull request #53 from sixteenmillimeter/dependabot/npm_and_yarn/app/bl-4.0.3
Bump bl from 4.0.2 to 4.0.3 in /app
2020-09-29 15:51:13 -04:00
dependabot[bot] 53941835cb
Bump bl from 3.0.0 to 3.0.1 in /cli
Bumps [bl](https://github.com/rvagg/bl) from 3.0.0 to 3.0.1.
- [Release notes](https://github.com/rvagg/bl/releases)
- [Commits](https://github.com/rvagg/bl/compare/v3.0.0...v3.0.1)

Signed-off-by: dependabot[bot] <support@github.com>
2020-09-29 19:50:45 +00:00
dependabot[bot] 7d4e53fe24
Bump bl from 4.0.2 to 4.0.3 in /app
Bumps [bl](https://github.com/rvagg/bl) from 4.0.2 to 4.0.3.
- [Release notes](https://github.com/rvagg/bl/releases)
- [Commits](https://github.com/rvagg/bl/compare/v4.0.2...v4.0.3)

Signed-off-by: dependabot[bot] <support@github.com>
2020-09-29 19:50:29 +00:00
sixteenmillimeter 6f19842da0
Merge pull request #49 from sixteenmillimeter/dependabot/npm_and_yarn/lodash-4.17.19
Bump lodash from 4.17.15 to 4.17.19
2020-09-29 15:49:53 -04:00
sixteenmillimeter 3692195887
Merge pull request #48 from sixteenmillimeter/dependabot/npm_and_yarn/cli/lodash-4.17.19
Bump lodash from 4.17.15 to 4.17.19 in /cli
2020-09-29 15:49:36 -04:00
sixteenmillimeter e672c2dc93
Merge pull request #47 from sixteenmillimeter/dependabot/npm_and_yarn/app/lodash-4.17.19
Bump lodash from 4.17.15 to 4.17.19 in /app
2020-09-29 15:49:24 -04:00
sixteenmillimeter 65292524b1 Edit addresses the issue implied by #52. In simple tests with improvised hardware, frame cannot complete in less than 450ms, which is half a full frame. Will add another check to proj_stop() to evaluate the time elapsed and throw an error if too high or low (+/- 20%) 2020-09-29 15:13:22 -04:00
sixteenmillimeter 5e481e77b0 Addressing the issue with the JKMM99 projector functionality where frames stop prematurely. Conceivably, the proj_microswitch() function is the only place that calls proj_stop() so the issue is with the logic there. It makes little sense that this function allows for 15ms frames because of the test that requires a 450ms elapsed time before it is stopped. 2020-09-29 14:00:54 -04:00
sixteenmillimeter 7c9543239e Rest of last commit. Renderer js 2020-09-29 13:57:59 -04:00
sixteenmillimeter 8672b6584a Work towards issue #52. Adds a statement within the arduino.end() method that watches for an 'E' char byte and will alert the UI while pausing a running sequence. Needs to be in place for firmware to be able to throw errors to UI. 2020-09-29 13:48:06 -04:00
sixteenmillimeter c5d7f9c91f Re-write of the JKMM99 which replaces the relay-based camera controller with an intval-based one. This relies on the Arduino Uno in the control box to handle all of the control logic in place of an on-board Arduino Trinket Pro. 2020-09-28 23:49:57 -04:00
sixteenmillimeter 9502d255c7 Fixed typo in Pins() where PROJECTOR_FWD was set to LOW twice instead of PROJECTOR_BWD. 2020-09-28 23:47:36 -04:00
sixteenmillimeter 08c3c23da0 Firmware for new JKMM99. Deployed for testing. 2020-08-18 14:21:27 -04:00
sixteenmillimeter 6eeeae85c8 Updated patch number, now working on 1.6.5 2020-08-18 14:21:07 -04:00
sixteenmillimeter 7c61af7043 Added logging to the arduino module to list all connected devices. 2020-08-18 14:20:43 -04:00
sixteenmillimeter d501623290 Updated projector knob for printing 2020-08-18 14:20:15 -04:00
sixteenmillimeter 0ccb29dfb0 Shape for the friction knob on the JK 106 projection system. 2020-08-10 23:52:54 -04:00
sixteenmillimeter f02782d4da Increment build to 1.6.4. Re-package and deploy for mac 2020-08-09 23:39:52 -04:00
sixteenmillimeter c2e83ab27b Added a diagram for wiring the Slo-Syn motor 2020-08-09 23:26:21 -04:00
sixteenmillimeter 32356b0037 Log doesn't need to print its own path. 2020-08-09 23:25:55 -04:00
sixteenmillimeter dd1bec8394 Firmware for controlling the JK 106 projector with a 103/104-style camera 2020-08-09 20:04:26 -04:00
sixteenmillimeter 4f2252d113 Merge remote-tracking branch 'origin/master' 2020-08-09 20:03:52 -04:00
sixteenmillimeter 0145bebb4b Turn off notifier if errors out 2020-08-09 20:03:48 -04:00
mmcwilliams 5e6fbbb43c Add armv7l architecture to dpkg for Raspian. 2020-07-30 11:28:11 -04:00
mmcwilliams 7e516a59b6 Wrong arch again 2020-07-30 11:04:02 -04:00
mmcwilliams 948b20fead Install dependencies for rpi. Package as armv71 for raspberry pi 2020-07-30 11:01:57 -04:00
mmcwilliams c61c128044 Merge remote-tracking branch 'origin/master' 2020-07-30 10:54:44 -04:00
mmcwilliams 296ef93ecb Installer for rpi 2020-07-30 10:54:35 -04:00
sixteenmillimeter 74621ef1fb Squashing notifier/notify-send errors on raspian. If the system doesnt work with node-notifier just skip 2020-07-27 11:43:55 -04:00
sixteenmillimeter 0811222d27 Normalize paths being used in filmout feature. Purpose of this is to rely on fs module to correctly handle paths for windows because it was previously broken. Will run tests. 2020-07-26 22:26:34 -04:00
sixteenmillimeter 0c364576c9 Squash errors in case of mkdir trying to create an existing directory (need mkdirp, but this works without an extra module) 2020-07-26 22:01:28 -04:00
dependabot[bot] 7ff49f0aa6
Bump lodash from 4.17.15 to 4.17.19 in /app
Bumps [lodash](https://github.com/lodash/lodash) from 4.17.15 to 4.17.19.
- [Release notes](https://github.com/lodash/lodash/releases)
- [Commits](https://github.com/lodash/lodash/compare/4.17.15...4.17.19)

Signed-off-by: dependabot[bot] <support@github.com>
2020-07-27 01:56:48 +00:00
dependabot[bot] a9b678f748
Bump lodash from 4.17.15 to 4.17.19 in /cli
Bumps [lodash](https://github.com/lodash/lodash) from 4.17.15 to 4.17.19.
- [Release notes](https://github.com/lodash/lodash/releases)
- [Commits](https://github.com/lodash/lodash/compare/4.17.15...4.17.19)

Signed-off-by: dependabot[bot] <support@github.com>
2020-07-27 01:56:36 +00:00
dependabot[bot] f2fd77a858
Bump lodash from 4.17.15 to 4.17.19
Bumps [lodash](https://github.com/lodash/lodash) from 4.17.15 to 4.17.19.
- [Release notes](https://github.com/lodash/lodash/releases)
- [Commits](https://github.com/lodash/lodash/compare/4.17.15...4.17.19)

Signed-off-by: dependabot[bot] <support@github.com>
2020-07-27 01:56:33 +00:00
sixteenmillimeter 8c97258866 Update all modules in core project and desktop app. Needed to update syntax of import in sequencer module because uuid is updated to 8.2.0 2020-07-26 21:55:36 -04:00
sixteenmillimeter 5c691a8e12 Fixed serialization error that was breaking raspberry pi 4 installation. It is apparently a real bug that should be breaking the app. 2020-07-26 21:52:53 -04:00
sixteenmillimeter e5e4c7ded7
Update Readme.md
Add reference to new Windows build of 1.6.1
2020-07-07 12:18:25 -04:00
sixteenmillimeter a748f689bd
Merge pull request #45 from sixteenmillimeter/dependabot/npm_and_yarn/app/electron-7.2.4
Bump electron from 7.1.8 to 7.2.4 in /app
2020-07-07 12:16:04 -04:00
sixteenmillimeter 5309f85638
Merge pull request #46 from sixteenmillimeter/dependabot/npm_and_yarn/electron-9.1.0
Bump electron from 4.1.1 to 9.1.0
2020-07-07 12:15:51 -04:00
sixteenmillimeter efc6d0ef03 Moving further down up the path. See previous commit. 2020-07-07 12:07:00 -04:00
sixteenmillimeter a379e4b086 Windows path differences from linux/darwin are ruining my day https://github.com/felixrieseberg/electron-wix-msi/issues/5 2020-07-07 12:05:28 -04:00
sixteenmillimeter 4a1bf417a4 Running build scripts on windows for the first time in a while. 2020-07-07 11:59:34 -04:00
mmcwilliams b702929e1f cases work 2020-07-07 11:54:20 -04:00
sixteenmillimeter d042381293 Projector work 2020-07-07 11:54:01 -04:00
dependabot[bot] 9805127387
Bump electron from 4.1.1 to 9.1.0
Bumps [electron](https://github.com/electron/electron) from 4.1.1 to 9.1.0.
- [Release notes](https://github.com/electron/electron/releases)
- [Changelog](https://github.com/electron/electron/blob/master/docs/breaking-changes.md)
- [Commits](https://github.com/electron/electron/compare/v4.1.1...v9.1.0)

Signed-off-by: dependabot[bot] <support@github.com>
2020-07-07 09:36:23 +00:00
dependabot[bot] 270862bd5f
Bump electron from 7.1.8 to 7.2.4 in /app
Bumps [electron](https://github.com/electron/electron) from 7.1.8 to 7.2.4.
- [Release notes](https://github.com/electron/electron/releases)
- [Changelog](https://github.com/electron/electron/blob/master/docs/breaking-changes.md)
- [Commits](https://github.com/electron/electron/compare/v7.1.8...v7.2.4)

Signed-off-by: dependabot[bot] <support@github.com>
2020-07-07 00:20:09 +00:00
sixteenmillimeter 53e012018f JK projector WIP 2020-07-01 18:04:17 -04:00
sixteenmillimeter 420a3fbd50 Sequencer case 2020-07-01 18:04:10 -04:00
sixteenmillimeter 5258fcbf30 Rails work 2020-07-01 18:04:03 -04:00
sixteenmillimeter 4db3ce8b88 jk camera controller case 2020-07-01 18:03:40 -04:00
sixteenmillimeter e3d36a1f27 Merge remote-tracking branch 'origin/master' 2020-07-01 18:03:26 -04:00
sixteenmillimeter 67d0e750c2 Mcopy camera firmware 2020-07-01 18:03:20 -04:00
mmcwilliams f4eb066725 camera conjtroller mod work 2020-05-27 16:47:14 -04:00
mmcwilliams fb63bade2f Fix windows build process (avoid asar) 2020-04-29 10:06:51 -04:00
Matt ed0175b733
Update Readme.md 2020-04-25 16:27:02 -04:00
mmcwilliams 8163f7d454 Merge remote-tracking branch 'origin/master' 2020-04-24 22:38:35 -04:00
mmcwilliams 5ec50713ba Remove extraneous build config from package.json. 2020-04-24 22:38:32 -04:00
Matt 37719b9974
Added latest release to Readme.md 2020-04-24 22:38:11 -04:00
sixteenmillimeter 3fd2b04e75 Update build script on mac to not throw an error 2020-04-24 22:26:00 -04:00
mmcwilliams c15cd512ae The trick on linux is to not build as an asar. Go figure. 2020-04-24 22:17:10 -04:00
mmcwilliams cc41b75130 FFMPEG not working yet 2020-04-24 22:12:56 -04:00
mmcwilliams f929ea2cc2 No, use ffmpeg-static and ffprobe-static but explcitly whitelist the node_modules bin folder where the binaries actually sit 2020-04-24 17:22:58 -04:00
mmcwilliams d4987ed3a3 Replace ffmpeg-static and ffprobe-static with ffmpeg-static-electron and ffprobe-static-electron. These will allow for packaging ffmpeg and ffprobe binaries that can be accessed from within the build. The path replace string hacks weren't cutting it. 2020-04-24 16:01:09 -04:00
mmcwilliams da00c62db3 FFMPEG and FFPROBE need to be stored unpacked in asar for build. 2020-04-24 15:09:51 -04:00
sixteenmillimeter 55c460fbb4 Install new frame module in electron app package 2020-04-24 14:46:05 -04:00
sixteenmillimeter 01cac728f5 Remove ImageMagick dependency. Replace sharp with jimp (prevent linux build issues). Jimp will also perform the same composite step as convert was. Light module is still disabled globally. 2020-04-24 14:33:58 -04:00
sixteenmillimeter 8d5663d3a2 Drop unnecessary console.dir statement 2020-03-09 15:58:36 -04:00
sixteenmillimeter 1c940d6df7 Display export progress and time estimate while all frames are being exported 2020-03-09 15:46:06 -04:00
sixteenmillimeter 891c34ad88 Correct the link to build tagged 1.5.2 2020-02-22 23:34:38 -05:00
sixteenmillimeter aec5b79f90 Update README.md to list new builds and new features. TODO: add a how-to and hardware section. 2020-02-22 23:29:20 -05:00
sixteenmillimeter e25a8bbc7c Use the gui.confirm dialog and not the native confirm function. 2020-02-21 16:58:35 -05:00
sixteenmillimeter d70de98256 Pre-export all frames in video (with confirmation dialog). Greatly improves sequence times and reliablity in conjunction with last commit. Resolves #36 and resolves #39. 2020-02-21 13:34:22 -05:00
sixteenmillimeter aec3e29476 Wait until image is loaded in a temp element and then report back to main process using ipc. This uses the "display_load" ipc channel to call back to the Display class and resolve a promise made in the .show() method. Resolves #38. 2020-02-21 02:28:26 -05:00
sixteenmillimeter 32fe873707 Allow for longer videos by using longer padded numbers for sequences 2020-02-21 01:58:56 -05:00
sixteenmillimeter 549cd3cc04 1.5.2 changes. Build includes code not in repo :( 2020-01-21 11:38:50 -05:00
469 changed files with 3266450 additions and 17199 deletions

10
.gitignore vendored
View File

@ -3,4 +3,12 @@
*.Parent
node_modules
dist
dist
*.svd
*debug_custom.json
*debug.cfg
notes/mphd
./lib

9
.gitmodules vendored Normal file
View File

@ -0,0 +1,9 @@
[submodule "scad/common"]
path = scad/common
url = https://git.sixteenmillimeter.com/modules/common.git
[submodule "scad/sprocketed_roller"]
path = scad/sprocketed_roller
url = https://git.sixteenmillimeter.com/modules/sprocketed_roller.git
[submodule "scad/MCAD"]
path = scad/MCAD
url = https://github.com/openscad/MCAD.git

View File

@ -1,4 +1,4 @@
Copyright 2018 M McWilliams
Copyright 2018-2021 M McWilliams
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

172
Readme.md
View File

@ -1,79 +1,93 @@
# mcopy
An open platform for controlling small-gauge film optical printers (16mm, Super8, 8mm).
-------
1. <a href="#intro">Introduction</a>
2. <a href="#downloads">Downloads</a>
1. <a href="#usage">Usage</a>
2. <a href="#software">Software</a>
3. <a href="#firmware">Firmware</a>
3. <a href="#hardware">Hardware</a>
4. <a href="#why">Why?</a>
-------
## Introduction <a name="intro"></a>
The `mcopy` project is comprised of software and hardware for optical printers, built with re-purposed broken projectors.
#### Components
* Sequencer desktop app
* Scripting language, called `mscript`, for orchestrating complex sequences
* Arduino firmware for projectors, cameras, lights and existing printers
* 3D models of parts used for modifying projectors and printers
* Schematics for simple Arduino-based electronics
## Downloads <a name="downloads"></a>
### Latest Installers
* [1.4.9](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.4.9) for macOS and Linux (.deb)
### Older Versions
* [1.2.0](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.2.0) for macOS and Linux (.deb)
* [1.0.3](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.0.3) for macOS and Linux (.deb)
For Windows, you can [install from source](https://github.com/sixteenmillimeter/mcopy/tree/master/app#mcopy-desktop-app) for now.
## Usage <a name="usage"></a>
The software requires your hardware to be in place before the mcopy control app is useful.
![mcopy app](docs/mcopy.png?raw=true "mcopy app")
## Software <a name="software"></a>
The mcopy desktop app is an Electron-based project which can be built for Linux, Windows and macOS.
Pre-built packages will be made available for macOS, initially, with the other two target platforms to follow.
To build the desktop app from source, see the [installation and running instructions](https://github.com/sixteenmillimeter/mcopy/tree/master/app#mcopy-desktop-app).
The desktop software also interoperates with two related projects; the Bluetooth + Wifi capable, Raspberry Pi-based [INTVAL3](https://github.com/sixteenmillimeter/intval3) and the Arduino-based [intval2](https://github.com/sixteenmillimeter/intval2).
## Firmware <a name="firmware"></a>
This project contains Arduino formware for controlling:
* a projector
* a camera (see [intval2](https://github.com/sixteenmillimeter/intval2) for more info)
* a light
* a projector + a camera
* a projector + a light
* a camera + a light
* a camera + a projector + a light
Using a simple serial interface, this modular platform can be used to control DIY components, modified existing optical printers or a mixture of components.
The desktop app can connect to multiple serial devices, so your mcopy optical printer can be built from various designs that suit your hardware tastes/needs/available parts.
## Hardware <a name="hardware"></a>
All non-electronic hardware for this project is available as plaintext OpenSCAD files and 3D print-able .STL files.
The hardware component of this project is aimed at modifying broken Bell & Howell projectors into USB serial-controlled projectors to be used in optical printing.
As a secondary capability, this desktop software and firmware package can be used to replace the sequencers for early-model JK optical printers, with some modification.
## Why? <a name="why"></a>
I'm interested in expanding the viability and access of the 16mm film format and to repurpose thre rising tide of discarded film technology.
# mcopy
An open platform for controlling small-gauge film optical printers (16mm, Super8, 8mm).
## [Project Home - git.sixteenmillimeter.com/16mm/mcopy](https://git.sixteenmillimeter.com/16mm/mcopy)
* Github Mirror - [github.com/sixteenmillimeter/mcopy](https://github.com/sixteenmillimeter/mcopy)
* Gitlab Mirror - [gitlab.com/16mm/mcopy](https://gitlab.com/16mm/mcopy)
-------
1. <a href="#intro">Introduction</a>
2. <a href="#downloads">Downloads</a>
1. <a href="#usage">Usage</a>
2. <a href="#software">Software</a>
3. <a href="#firmware">Firmware</a>
3. <a href="#hardware">Hardware</a>
4. <a href="#why">Why?</a>
-------
## Introduction <a name="intro"></a>
The `mcopy` project is comprised of software and hardware for optical printers, built with re-purposed broken projectors.
#### Components
* Sequencer desktop app
* Scripting language, called `mscript`, for orchestrating complex sequences
* Arduino firmware for projectors, cameras, lights and existing printers
* 3D models of parts used for modifying projectors and printers
* Schematics for simple Arduino-based electronics
* Filmout feature for digitally transferring video and images to analog film
* Interoperability with the [intval3](https://github.com/sixteenmillimeter/intval3) intervalometer
## Downloads <a name="downloads"></a>
### Latest Installers
* [1.6.9](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.6.9) for macOS, Linux (.deb) and Windows (.msi)
### Older Versions
* [1.6.7](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.6.7) for macOS and Linux (.deb)
* [1.6.4](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.6.4) for macOS, Linux (.deb) and Windows (.msi)
* [1.6.2](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.6.2) for macOS
* [1.6.1](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.6.1) for macOS
* [1.5.2](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.5.2) for macOS
* [1.4.9](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.4.9) for macOS and Linux (.deb)
* [1.2.0](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.2.0) for macOS and Linux (.deb)
* [1.0.3](https://github.com/sixteenmillimeter/mcopy/releases/tag/1.0.3) for macOS and Linux (.deb)
For Windows, you can [install from source](https://github.com/sixteenmillimeter/mcopy/tree/master/app#mcopy-desktop-app) for now.
## Usage <a name="usage"></a>
The software requires your hardware to be in place before the mcopy control app is useful.
![mcopy app](docs/mcopy.png?raw=true "mcopy app")
## Software <a name="software"></a>
The mcopy desktop app is an Electron-based project which can be built for Linux, Windows and macOS.
Pre-built packages will be made available for macOS, initially, with the other two target platforms to follow.
To build the desktop app from source, see the [installation and running instructions](https://github.com/sixteenmillimeter/mcopy/tree/master/app#mcopy-desktop-app).
The desktop software also interoperates with two related projects; the Bluetooth + Wifi capable, Raspberry Pi-based [INTVAL3](https://github.com/sixteenmillimeter/intval3) and the Arduino-based [intval2](https://github.com/sixteenmillimeter/intval2).
## Firmware <a name="firmware"></a>
This project contains Arduino formware for controlling:
* a projector
* a camera (see [intval2](https://github.com/sixteenmillimeter/intval2) for more info)
* a light
* a projector + a camera
* a projector + a light
* a camera + a light
* a camera + a projector + a light
Using a simple serial interface, this modular platform can be used to control DIY components, modified existing optical printers or a mixture of components.
The desktop app can connect to multiple serial devices, so your mcopy optical printer can be built from various designs that suit your hardware tastes/needs/available parts.
## Hardware <a name="hardware"></a>
All non-electronic hardware for this project is available as plaintext OpenSCAD files and 3D print-able .STL files.
The hardware component of this project is aimed at modifying broken Bell & Howell projectors into USB serial-controlled projectors to be used in optical printing.
As a secondary capability, this desktop software and firmware package can be used to replace the sequencers for early-model JK optical printers, with some modification.
## Why? <a name="why"></a>
I'm interested in expanding the viability and access of the 16mm film format and to repurpose thre rising tide of discarded film technology.

5
app/.gitignore vendored
View File

@ -1,3 +1,6 @@
node_modules/*
logs/*
data/transfer*.json
data/transfer*.json
.appleId*
.applePwd*
.appleIdentity*

View File

@ -194,8 +194,8 @@ button:focus {
width: 66px;
height: 66px;
position: absolute;
top: 7px;
left: 7px;
top: 14px / 2;
left: 14px / 2;
}
.dial-wrapper input {
margin-top: 94px;
@ -210,10 +210,10 @@ button:focus {
top: 0;
bottom: 0;
overflow: hidden;
width: 40px;
width: 80px / 2;
}
.dial-container.dial-container1 {
left: 40px;
left: 80px / 2;
}
.dial-container.dial-container1 .dial-wedge {
transform: rotateZ(0deg);
@ -227,16 +227,16 @@ button:focus {
.dial-container.dial-container2 .dial-wedge {
transform: rotateZ(0deg);
border-radius: 80px 0 0 80px;
transform-origin: 40px 40px;
transform-origin: 80px/2 80px/2;
}
.dial-wedge {
height: 80px;
width: 40px;
width: 80px / 2;
}
.dial-marker {
border-radius: 50%;
height: 7px;
width: 7px;
height: 14px / 2;
width: 14px / 2;
position: absolute;
top: 0;
left: calc(50% - (14px * 2));
@ -367,6 +367,7 @@ button:focus {
float: right;
width: 90px;
margin-right: 60px;
height: 32px;
}
#seq_stats {
width: 40%;
@ -484,6 +485,9 @@ button:focus {
#sequence #projector_second_backward > div {
color: #bf2e39;
}
#sequence #black input[type=checkbox]:checked {
background: white;
}
#sequence input[type=checkbox] {
-webkit-appearance: none;
-moz-appearance: none;
@ -500,6 +504,10 @@ button:focus {
box-sizing: border-box;
cursor: pointer;
}
#sequence input[type=checkbox].disabled {
cursor: not-allowed;
border-color: #646464;
}
#sequence .L {
display: inline-block;
width: 35px;
@ -627,6 +635,11 @@ button:focus {
background: #AB1A25;
border-color: #AB1A25;
}
.cmd:active.capper,
.cmd.active.capper {
background: white;
color: #272b30;
}
.cmd:active i,
.cmd.active i {
color: #272b30;
@ -650,14 +663,44 @@ button:focus {
::-webkit-scrollbar-thumb:window-inactive {
background: rgba(0, 0, 0, 0.05);
}
#settings h4 {
margin-bottom: 1px;
}
#settings > div {
width: 300px;
margin: 0 auto;
}
#settings > div.left {
float: left;
padding-left: 30px;
}
#settings > div.right {
float: right;
padding-right: 30px;
}
#settings > div.right input[type=number] {
min-width: 200px;
width: 200px;
}
#settings > div.right input[readonly] {
cursor: not-allowed;
}
#settings > div.right .spacer {
height: 62px;
}
#settings > div.right .proj_time {
height: 111px;
}
#settings > div.right .cam_time {
height: 111px;
}
#settings > div.right > div {
width: 270px;
}
#settings > div > div {
width: 360px;
}
#settings input[type=text],
#settings input[type=number],
#settings select {
display: block;
border-radius: 5px;
@ -672,33 +715,43 @@ button:focus {
padding: 6px 12px;
font-size: 21px;
min-width: 300px;
max-width: 300px;
}
#settings input[type=text] span,
#settings input[type=number] span,
#settings select span {
display: block;
font-size: 16px;
font-weight: 200;
}
#settings input[type=text]:active,
#settings input[type=number]:active,
#settings select:active,
#settings input[type=text] .active,
#settings input[type=number] .active,
#settings select .active {
background: #fff;
color: #272b30;
outline: none;
}
#settings input[type=text]:focus,
#settings input[type=number]:focus,
#settings select:focus {
outline: none;
}
#settings input[type=text].active,
#settings input[type=number].active,
#settings select.active {
border-color: #DAE035;
color: #DAE035;
}
#settings input[type=text] {
width: 200px;
}
#settings button {
margin-top: -1px;
margin-top: 0px;
float: right;
padding: 8px 16px 9px;
}
#settings input[type=radio] {
float: right;
@ -707,6 +760,17 @@ button:focus {
#settings .spacer {
margin-top: 10px;
}
#settings #version {
position: absolute;
right: 20px;
bottom: 10px;
z-index: 1000;
height: 14px;
width: auto;
font-size: 14px;
line-height: 14px;
color: #999;
}
.cm-s-monokai.CodeMirror {
background: #272b30 !important;
}
@ -795,9 +859,11 @@ button:focus {
}
#path_bar select {
line-height: 41px;
height: 41px;
height: 37px;
margin-right: 5px;
float: right;
box-sizing: content-box;
padding: 0 0 0 8px;
}
#filmout_monitor {
display: none;
@ -837,20 +903,22 @@ button:focus {
#filmout_position_wrap input {
margin-right: 5px;
margin-left: 5px;
width: 308px !important;
box-sizing: border-box;
}
#filmout_position_wrap button,
#filmout_position_wrap input {
float: left;
}
#filmout_position_wrap > div {
width: 410px;
width: 425px;
margin: 0 auto;
}
#filmout_functions {
padding-top: 5px;
}
#filmout_functions > div {
width: 410px;
width: 425px;
margin: 0 auto;
}
#filmout_stats_video,
@ -872,6 +940,12 @@ button:focus {
#filmout_stats_monitor {
right: 5px;
}
.hide {
display: none;
}
.show {
display: block;
}
#screens {
overflow-x: hidden;
}
@ -1124,19 +1198,23 @@ button:focus {
float: right;
}
.cam2,
.proj2 {
.proj2,
.black {
display: none;
}
.cam2 > *,
.proj2 > * {
.proj2 > *,
.black > * {
visibility: hidden;
}
.cam2.on,
.proj2.on {
.proj2.on,
.black.on {
display: block;
}
.cam2.on > *,
.proj2.on > * {
.proj2.on > *,
.black.on > * {
visibility: visible;
}
#overlay {

View File

@ -1,5 +1,5 @@
{
"version": "1.5.1",
"version": "1.8.120",
"ext_port": 1111,
"profiles": {
"mcopy": {
@ -15,8 +15,8 @@
"momentary": 0
},
"black": {
"before": 0,
"after": 0
"before": 100,
"after": 100
},
"light": false
},
@ -87,6 +87,20 @@
"delay": 50,
"momentary": 130
},
"proj": {
"time": 1340,
"delay": 50,
"momentary": 300
},
"light": false
},
"norris": {
"label": "Norris",
"cam": {
"time": 650,
"delay": 50,
"momentary": 130
},
"light": false
}
},
@ -164,7 +178,24 @@
"cameras": "4",
"camera_projectors_identifier": "5",
"cameras_projector_identifier": "6",
"cameras_projectors_identifier": "7"
"cameras_projectors_identifier": "7",
"capper_identifier": "C",
"camera_capper_identifier": "8",
"camera_capper_projector_identifier": "9",
"camera_capper_projectors_identifier": "0",
"capper_on": "A",
"capper_off": "B",
"camera_open_forward": "J",
"camera_open_backward": "K",
"camera_close_forward": "L",
"camera_close_backward": "M",
"takeup_forward": "D",
"takeup_backward": "F",
"error": "E",
"camera_exposure": "G",
"state": "H",
"home": "I",
"offset": "O"
}
}
}

View File

@ -13,6 +13,16 @@
body.meter {
background: rgb(117, 117, 117);
}
body.meter #img,
body.meter #can {
display: none;
}
body.image #can{
display: none;
}
body.image #img {
display: block;
}
#img {
position: absolute;
/*background-image: url(".../img/background.jpg");*/
@ -46,32 +56,48 @@
</canvas>
<script>
'use strict';
const { remote, ipcRenderer } = require('electron')
const { ipcRenderer } = require('electron')
const remote = require('@electron/remote')
let imgTmp;
function delay (ms) {
return new Promise((resolve) => {
return setTimeout(resolve, ms)
})
}
async function setImage (src) {
return new Promise(async (resolve, reject) => {
//let img = new Image()
imgTmp = new Image()
let img = document.getElementById('img')
let body = document.querySelector('body')
if (body.classList.contains('meter')) {
body.classList.remove('meter')
body.className = ''
body.classList.add('image')
imgTmp.onload = function () {
img.style.backgroundImage = `url('${src}')`
return resolve(src)
}
imgTmp.src = src
})
}
img.style.backgroundImage = `url('${src}')`;
});
function setBlank () {
let img = document.getElementById('img')
img.style.background = ''
img.style.backgroundUrl = ''
img.style.backgroundColor = 'black'
}
async function onMeter () {
console.log('meter')
const body = document.querySelector('body')
if (!body.classList.contains('meter')) {
body.classList.add('meter')
}
body.className = ''
body.classList.add('meter')
}
async function onFocus () {
console.log('focus')
const can = document.getElementById('can')
const dpr = window.devicePixelRatio || 1
const body = document.querySelector('body')
let ctx;
body.className = ''
if (!can.classList.contains('show')) {
can.classList.add('show')
}
@ -104,7 +130,7 @@
//console.log(`o: ${opp}`)
for (let i = 0; i < count; i++) {
ctx.beginPath()
ctx.beginPath()
ctx.moveTo(w / 2, h / 2)
ctx.lineTo((w / 2) + opp, longest)
ctx.lineTo((w / 2) - opp, longest)
@ -119,7 +145,9 @@
const can = document.getElementById('can')
const dpr = window.devicePixelRatio || 1
const screen = window.outerWidth / window.outerHeight
let ctx;
const body = document.querySelector('body')
let ctx
body.className = ''
if (!can.classList.contains('show')) {
can.classList.add('show')
}
@ -128,7 +156,7 @@
can.width = (window.innerHeight * arg.ratio) * dpr
can.height = window.innerHeight * dpr
} else {
can.width =window.innerWidth * dpr
can.width = window.innerWidth * dpr
can.height = (window.innerWidth / arg.ratio) * dpr
}
} else {
@ -142,7 +170,7 @@
can.style.width = `${window.innerHeight * arg.ratio}px`
can.style.height = `${window.innerHeight}px`
} else {
can.style.width = `${window.inneWidth}px`
can.style.width = `${window.innerWidth}px`
can.style.height = `${window.innerWidth / arg.ratio}px`
}
} else {
@ -205,17 +233,28 @@
}
async function onDigital (event, arg) {
if (arg.src) {
if (arg.exposure) {
setBlank()
await delay(10)
}
try {
await setImage(arg.src)
await setImage(arg.src)
} catch (err) {
console.error(err)
}
if (arg.exposure) {
await delay(arg.exposure)
setBlank()
}
ipcRenderer.send('display_load', { src : arg.src })
}
return event.returnValue = true
}
async function onEscape (evt) {
let isEscape = false
let win
evt = evt || window.event
if ('key' in evt) {
@ -223,6 +262,7 @@
} else {
isEscape = (evt.keyCode == 27)
}
if (isEscape) {
win = remote.getCurrentWindow()
win.close()

12
app/entitlements.plist Normal file
View File

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>com.apple.security.cs.allow-jit</key>
<true/>
<key>com.apple.security.cs.allow-unsigned-executable-memory</key>
<true/>
<key>com.apple.security.cs.debugger</key>
<true/>
</dict>
</plist>

View File

@ -13,7 +13,7 @@
</head>
<body onload="init();" style="background:#272b30;">
<nav id="toolbar"></nav>
<div id="screens">
<div id="screens" class="hide">
<div id="sequencer" class="screen" style="display: block;">
<div id="counters">
<div class="cam">
@ -45,6 +45,8 @@
<div id="camera_second_backward" class="row cam2" y="2"></div>
<div id="projector_backward" class="row" y="1"></div>
<div id="projector_second_backward" class="row proj2" y="3"></div>
<div id="black" class="row black"></div>
<div id="light_set" class="row spacer"></div>
<div id="numbers" class="row"></div>
@ -60,6 +62,8 @@
<div><span>PROJ </span><i class="fa fa-minus"></i></div>
<div class="proj2"><span>PROJ2 </span><i class="fa fa-minus"></i></div>
<div class="black"><span>BLANK </span><i class="fa fa-times"></i></div>
<div class="spacer"><span>LIGHT</span></div>
</div>
</div>
@ -144,20 +148,34 @@
<i class="fa fa-step-backward"></i>
</button>
</div>
<div>
<div class="hide">
<button id="cmd_black_forward" onclick="cmd.black_forward();" class="cmd fwd">
<i class="fa fa-times-circle"></i>
BLANK +1
<i class="fa fa-step-forward"></i>
</button>
</div>
<div>
<div class="hide">
<button id="cmd_black_backward" onclick="cmd.black_backward();" class="cmd bwd">
<i class="fa fa-times-circle"></i>
BLANK -1
<i class="fa fa-step-backward"></i>
</button>
</div>
<div class="hide">
<button id="cmd_capper_on" onclick="cmd.capper_on();" class="cmd capper">
<i class="fa fa-times-circle"></i>
CAPPER ON
<i class="fa fa-eye"></i>
</button>
</div>
<div class="hide">
<button id="cmd_capper_off" onclick="cmd.capper_off();" class="cmd capper active">
<i class="fa fa-eye"></i>
CAPPER OFF
<i class="fa fa-eye"></i>
</button>
</div>
</div>
<div>
<div>
@ -389,7 +407,7 @@
</div>
</div>
<div id="settings" class="screen">
<div>
<div class="left">
<div>
<h4>Devices</h4>
<select id="devices">
@ -419,6 +437,13 @@
<input type="text" id="intval" name="intval" placeholder="INTVAL3 URL"/>
<input type="radio" id="camera_type_intval" name="camera_type" value="intval" onclick="devices.intval();" />
</div>
<div class="spacer">
<input type="text" id="processing" name="processing" placeholder="PROCESSING URL" />
<input type="radio" id="camera_type_processing" name="camera_type" value="processing" onclick="devices.processing();" />
</div>
<div>
<div id="version"></div>
</div>
<div>
<h4>Light</h4>
<select id="light_device">
@ -432,6 +457,19 @@
</select>
</div>
</div>
<div class="right">
<div class="spacer"></div>
<div class="proj_time">
<h4>Projector Time (ms)</h4>
<input type="number" readonly id="proj_time" value="0" />
<button id="submit_proj_time" class="hide"></button>
</div>
<div class="cam_time">
<h4>Camera Time (ms)</h4>
<input type="number" readonly id="cam_time" value="0" />
<button id="submit_cam_time" class="hide" onclick="cam.exposure($('#cam_time').val());"></button>
</div>
</div>
</div>
</div>
<div id="overlay" onclick="gui.overlay(false);gui.spinner(false);"></div>

View File

@ -2474,8 +2474,9 @@ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
!function(a,b){"object"==typeof exports?module.exports=b():"function"==typeof define&&define.amd?define(b):a.Spinner=b()}(this,function(){"use strict";function a(a,b){var c,d=document.createElement(a||"div");for(c in b)d[c]=b[c];return d}function b(a){for(var b=1,c=arguments.length;c>b;b++)a.appendChild(arguments[b]);return a}function c(a,b,c,d){var e=["opacity",b,~~(100*a),c,d].join("-"),f=.01+c/d*100,g=Math.max(1-(1-a)/b*(100-f),a),h=j.substring(0,j.indexOf("Animation")).toLowerCase(),i=h&&"-"+h+"-"||"";return l[e]||(m.insertRule("@"+i+"keyframes "+e+"{0%{opacity:"+g+"}"+f+"%{opacity:"+a+"}"+(f+.01)+"%{opacity:1}"+(f+b)%100+"%{opacity:"+a+"}100%{opacity:"+g+"}}",m.cssRules.length),l[e]=1),e}function d(a,b){var c,d,e=a.style;for(b=b.charAt(0).toUpperCase()+b.slice(1),d=0;d<k.length;d++)if(c=k[d]+b,void 0!==e[c])return c;return void 0!==e[b]?b:void 0}function e(a,b){for(var c in b)a.style[d(a,c)||c]=b[c];return a}function f(a){for(var b=1;b<arguments.length;b++){var c=arguments[b];for(var d in c)void 0===a[d]&&(a[d]=c[d])}return a}function g(a,b){return"string"==typeof a?a:a[b%a.length]}function h(a){this.opts=f(a||{},h.defaults,n)}function i(){function c(b,c){return a("<"+b+' xmlns="urn:schemas-microsoft.com:vml" class="spin-vml">',c)}m.addRule(".spin-vml","behavior:url(#default#VML)"),h.prototype.lines=function(a,d){function f(){return e(c("group",{coordsize:k+" "+k,coordorigin:-j+" "+-j}),{width:k,height:k})}function h(a,h,i){b(m,b(e(f(),{rotation:360/d.lines*a+"deg",left:~~h}),b(e(c("roundrect",{arcsize:d.corners}),{width:j,height:d.width,left:d.radius,top:-d.width>>1,filter:i}),c("fill",{color:g(d.color,a),opacity:d.opacity}),c("stroke",{opacity:0}))))}var i,j=d.length+d.width,k=2*j,l=2*-(d.width+d.length)+"px",m=e(f(),{position:"absolute",top:l,left:l});if(d.shadow)for(i=1;i<=d.lines;i++)h(i,-2,"progid:DXImageTransform.Microsoft.Blur(pixelradius=2,makeshadow=1,shadowopacity=.3)");for(i=1;i<=d.lines;i++)h(i);return b(a,m)},h.prototype.opacity=function(a,b,c,d){var e=a.firstChild;d=d.shadow&&d.lines||0,e&&b+d<e.childNodes.length&&(e=e.childNodes[b+d],e=e&&e.firstChild,e=e&&e.firstChild,e&&(e.opacity=c))}}var j,k=["webkit","Moz","ms","O"],l={},m=function(){var c=a("style",{type:"text/css"});return b(document.getElementsByTagName("head")[0],c),c.sheet||c.styleSheet}(),n={lines:12,length:7,width:5,radius:10,rotate:0,corners:1,color:"#000",direction:1,speed:1,trail:100,opacity:.25,fps:20,zIndex:2e9,className:"spinner",top:"50%",left:"50%",position:"absolute"};h.defaults={},f(h.prototype,{spin:function(b){this.stop();{var c=this,d=c.opts,f=c.el=e(a(0,{className:d.className}),{position:d.position,width:0,zIndex:d.zIndex});d.radius+d.length+d.width}if(e(f,{left:d.left,top:d.top}),b&&b.insertBefore(f,b.firstChild||null),f.setAttribute("role","progressbar"),c.lines(f,c.opts),!j){var g,h=0,i=(d.lines-1)*(1-d.direction)/2,k=d.fps,l=k/d.speed,m=(1-d.opacity)/(l*d.trail/100),n=l/d.lines;!function o(){h++;for(var a=0;a<d.lines;a++)g=Math.max(1-(h+(d.lines-a)*n)%l*m,d.opacity),c.opacity(f,a*d.direction+i,g,d);c.timeout=c.el&&setTimeout(o,~~(1e3/k))}()}return c},stop:function(){var a=this.el;return a&&(clearTimeout(this.timeout),a.parentNode&&a.parentNode.removeChild(a),this.el=void 0),this},lines:function(d,f){function h(b,c){return e(a(),{position:"absolute",width:f.length+f.width+"px",height:f.width+"px",background:b,boxShadow:c,transformOrigin:"left",transform:"rotate("+~~(360/f.lines*k+f.rotate)+"deg) translate("+f.radius+"px,0)",borderRadius:(f.corners*f.width>>1)+"px"})}for(var i,k=0,l=(f.lines-1)*(1-f.direction)/2;k<f.lines;k++)i=e(a(),{position:"absolute",top:1+~(f.width/2)+"px",transform:f.hwaccel?"translate3d(0,0,0)":"",opacity:f.opacity,animation:j&&c(f.opacity,f.trail,l+k*f.direction,f.lines)+" "+1/f.speed+"s linear infinite"}),f.shadow&&b(i,e(h("#000","0 0 4px #000"),{top:"2px"})),b(d,b(i,h(g(f.color,k),"0 0 1px rgba(0,0,0,.1)")));return d},opacity:function(a,b,c){b<a.childNodes.length&&(a.childNodes[b].style.opacity=c)}});var o=e(a("group"),{behavior:"url(#default#VML)"});return!d(o,"transform")&&o.adj?i():j=d(o,"animation"),h});
const mcopy = {};
const { remote, ipcRenderer } = require('electron');
const dialog = require('electron').remote.dialog;
const remote = require('@electron/remote');
const { ipcRenderer } = require('electron');
const { dialog } = remote;
const notifier = require('node-notifier');
const fs = require('fs');
const uuid = require('uuid').v4;
@ -2495,8 +2496,13 @@ const cmd = require('./lib/ui/cmd.js');
const devices = require('./lib/ui/devices.js');
const filmout = require('./lib/ui/filmout.js');
const mse = require('./lib/ui/mscript.js');
const capper = require('./lib/ui/capper.js');
const timing = require('./lib/ui/timing.js');
const Mscript = require('./lib/mscript');
const { delay } = require('./lib/delay');
const alertObj = require('./lib/ui/alert.js');
const { Log } = require('./lib/log');
let log;
/******
@ -2510,9 +2516,10 @@ mcopy.state = {
async function init () {
'use strict';
log = await require('log')({})
log = await Log({ label : 'ui' })
nav.init();
gui.init();
grid.init();
mse.mscript.init();
mse.console.init();
@ -2523,4 +2530,7 @@ async function init () {
proj.init();
cam.init();
seq.init();
capper.init();
alertObj.init();
timing.init();
};

View File

@ -10,6 +10,13 @@
@import "./mscript.less";
@import "./filmout.less";
.hide {
display: none;
}
.show {
display: block;
}
#screens{
overflow-x: hidden;
}
@ -168,7 +175,8 @@
}
.cam2,
.proj2{
.proj2,
.black{
display : none;
> * {
visibility: hidden;

View File

@ -42,6 +42,10 @@
background: @BACKWARD;
border-color: @BACKWARD;
}
&.capper{
background: white;
color: @BG;
}
i{
color: @BG;
}

View File

@ -27,9 +27,11 @@
}
select{
line-height: 41px;
height: 41px;
height: 37px;
margin-right: 5px;
float: right;
box-sizing: content-box;
padding: 0 0 0 8px;
}
}
#filmout_file {
@ -73,12 +75,14 @@
input{
margin-right: 5px;
margin-left: 5px;
width: 308px !important;
box-sizing: border-box;
}
button, input{
float: left;
}
> div{
width: 410px;
width: 425px;
margin: 0 auto;
}
}
@ -86,7 +90,7 @@
#filmout_functions{
padding-top: 5px;
> div{
width: 410px;
width: 425px;
margin: 0 auto;
}
}

View File

@ -28,6 +28,7 @@
float: right;
width: 90px;
margin-right: 60px;
height: 32px;
}
}
#seq_stats{
@ -126,6 +127,13 @@
color: @BACKWARD + @SECOND;
}
}
#black{
input[type=checkbox]{
&:checked{
background: white;
}
}
}
input[type=checkbox]{
-webkit-appearance: none;
-moz-appearance: none;
@ -141,6 +149,10 @@
display: inline-block;
box-sizing: border-box;
cursor: pointer;
&.disabled{
cursor: not-allowed;
border-color: rgb(100, 100, 100);
}
}
.L{
display: inline-block;

View File

@ -1,25 +1,61 @@
#settings{
h4{
margin-bottom: 1px;
}
> div{
width: 300px;
margin: 0 auto;
&.left{
float: left;
padding-left: 30px;
}
&.right{
float: right;
padding-right: 30px;
input[type=number] {
min-width: 200px;
width: 200px;
}
input[readonly]{
cursor: not-allowed;
}
.spacer{
height: 62px;
}
.proj_time{
height: 111px;
}
.cam_time{
height: 111px;
}
& > div {
width: 270px;
}
}
}
> div > div{
width: 360px;
}
input[type=text], select{
input[type=text],
input[type=number],
select{
.button();
display: inline-block;
padding: 6px 12px;
font-size: 21px;
min-width: 300px;
max-width: 300px;
&.active{
border-color: @SELECTED;
color: @SELECTED;
}
}
input[type=text]{
width: 200px;
}
button{
margin-top: -1px;
float: right;
margin-top: 0px;
float: right;
padding: 8px 16px 9px;
}
input[type=radio]{
float: right;
@ -28,4 +64,15 @@
.spacer{
margin-top: 10px;
}
#version{
position: absolute;
right: 20px;
bottom: 10px;
z-index: 1000;
height: 14px;
width: auto;
font-size: 14px;
line-height: 14px;
color: #999;
}
}

40
app/lib/alert/Readme.md Normal file
View File

@ -0,0 +1,40 @@
<a name="module_lib/alert"></a>
## lib/alert
* [lib/alert](#module_lib/alert)
* [~Alert](#module_lib/alert..Alert)
* [.init()](#module_lib/alert..Alert+init)
* [.listen()](#module_lib/alert..Alert+listen)
* [.listener()](#module_lib/alert..Alert+listener)
* [.start()](#module_lib/alert..Alert+start)
<a name="module_lib/alert..Alert"></a>
### lib/alert~Alert
Class for pushing an alert to the UI from the backend.
**Kind**: inner class of [<code>lib/alert</code>](#module_lib/alert)
* [~Alert](#module_lib/alert..Alert)
* [.init()](#module_lib/alert..Alert+init)
* [.listen()](#module_lib/alert..Alert+listen)
* [.listener()](#module_lib/alert..Alert+listener)
* [.start()](#module_lib/alert..Alert+start)
<a name="module_lib/alert..Alert+init"></a>
#### alert.init()
**Kind**: instance method of [<code>Alert</code>](#module_lib/alert..Alert)
<a name="module_lib/alert..Alert+listen"></a>
#### alert.listen()
**Kind**: instance method of [<code>Alert</code>](#module_lib/alert..Alert)
<a name="module_lib/alert..Alert+listener"></a>
#### alert.listener()
**Kind**: instance method of [<code>Alert</code>](#module_lib/alert..Alert)
<a name="module_lib/alert..Alert+start"></a>
#### alert.start()
**Kind**: instance method of [<code>Alert</code>](#module_lib/alert..Alert)

29
app/lib/alert/index.d.ts vendored Normal file
View File

@ -0,0 +1,29 @@
import type { WebContents } from 'electron';
/** @module lib/alert */
/**
* Class for pushing an alert to the UI from the backend.
*/
export declare class Alert {
private ipc;
private log;
private id;
private cb;
private ui;
constructor(ui: WebContents);
/**
*
**/
private init;
/**
*
**/
private listen;
/**
*
**/
private listener;
/**
*
**/
start(cmd: string): Promise<number>;
}

62
app/lib/alert/index.js Normal file
View File

@ -0,0 +1,62 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Alert = void 0;
const electron_1 = require("electron");
const log_1 = require("log");
/** @module lib/alert */
/**
* Class for pushing an alert to the UI from the backend.
*/
class Alert {
constructor(ui) {
this.ipc = electron_1.ipcMain;
this.id = 'alert';
this.cb = null;
this.ui = ui;
this.init();
}
/**
*
**/
async init() {
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
*
**/
listen() {
this.ipc.on(this.id, this.listener.bind(this));
}
/**
*
**/
async listener(event, arg) {
if (this.cb !== null) {
try {
await this.cb(arg.state, arg.id);
}
catch (err) {
this.log.error(err);
}
}
event.returnValue = true;
}
/**
*
**/
async start(cmd) {
const start = +new Date();
const msg = (cmd + '').replace('ALERT', '').replace('Alert', '').replace('alert', '').trim();
this.ui.send(this.id, { msg });
return new Promise(function (resolve, reject) {
this.cb = function () {
const ms = (+new Date()) - start;
return resolve(ms);
};
}.bind(this));
}
}
exports.Alert = Alert;
module.exports = { Alert };
//# sourceMappingURL=index.js.map

View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/alert/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;AAEb,uCAAmC;AAEnC,6BAA0B;AAI1B,wBAAwB;AAExB;;GAEG;AAEH,MAAa,KAAK;IAOjB,YAAc,EAAgB;QANtB,QAAG,GAAoB,kBAAO,CAAA;QAE9B,OAAE,GAAY,OAAO,CAAA;QACrB,OAAE,GAAc,IAAI,CAAA;QAI3B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;QACZ,IAAI,CAAC,IAAI,EAAE,CAAA;IACZ,CAAC;IAED;;QAEI;IACI,KAAK,CAAC,IAAI;QACjB,IAAI,CAAC,GAAG,GAAG,MAAM,IAAA,SAAG,EAAC,EAAE,KAAK,EAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAA;QACzC,IAAI,CAAC,MAAM,EAAE,CAAA;IACd,CAAC;IAED;;QAEI;IACI,MAAM;QACb,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/C,CAAC;IAED;;QAEI;IACI,KAAK,CAAC,QAAQ,CAAE,KAAoB,EAAE,GAAS;QACtD,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,EAAE;YACrB,IAAI;gBACH,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC,CAAA;aAChC;YAAC,OAAO,GAAG,EAAE;gBACb,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;aACnB;SACD;QACD,KAAK,CAAC,WAAW,GAAG,IAAI,CAAA;IACzB,CAAC;IAED;;QAEI;IACG,KAAK,CAAC,KAAK,CAAE,GAAY;QAC/B,MAAM,KAAK,GAAY,CAAC,IAAI,IAAI,EAAE,CAAC;QACnC,MAAM,GAAG,GAAY,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QACrG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAA;QAC9B,OAAO,IAAI,OAAO,CAAC,UAAU,OAAkB,EAAE,MAAiB;YACjE,IAAI,CAAC,EAAE,GAAG;gBACT,MAAM,EAAE,GAAY,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC1C,OAAO,OAAO,CAAC,EAAE,CAAC,CAAC;YACpB,CAAC,CAAA;QACF,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACf,CAAC;CACD;AAvDD,sBAuDC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,KAAK,EAAE,CAAA"}

View File

@ -1,43 +1,146 @@
<a name="Arduino"></a>
## Modules
## Arduino
Class representing the arduino communication features
<dl>
<dt><a href="#module_lib/arduino">lib/arduino</a></dt>
<dd></dd>
</dl>
**Kind**: global class
## Constants
* [Arduino](#Arduino)
* [.enumerate()](#Arduino+enumerate) ⇒ <code>Promise</code>
* [.sendAsync(device, cmd)](#Arduino+sendAsync) ⇒ <code>Promise</code>
* [.writeAsync(device, str)](#Arduino+writeAsync) ⇒ <code>Promise</code>
* [.openArduino(device)](#Arduino+openArduino) ⇒ <code>Promise</code>
* [.closeArduino(device)](#Arduino+closeArduino) ⇒ <code>Promise</code>
<dl>
<dt><a href="#delay_1">delay_1</a></dt>
<dd><p>2023-07-16 Clarification</p>
<p>Previous versions of this script intermingled and even
swapped the usage of the terms &#39;serial&#39; and &#39;device&#39;.
From here on out, the terms will be used as such:</p>
<p>serial - a hardware address of a serial port
device - common name of a type of mcopy device (eg. camera,
projector, light) that is aliased to a serial port</p>
</dd>
</dl>
<a name="Arduino+enumerate"></a>
<a name="module_lib/arduino"></a>
### arduino.enumerate() ⇒ <code>Promise</code>
## lib/arduino
* [lib/arduino](#module_lib/arduino)
* [~Arduino](#module_lib/arduino..Arduino)
* [.enumerate()](#module_lib/arduino..Arduino+enumerate) ⇒ <code>Promise</code>
* [.sendAsync(device, cmd)](#module_lib/arduino..Arduino+sendAsync) ⇒ <code>Promise</code>
* [.send(device, cmd)](#module_lib/arduino..Arduino+send) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
* [.sendString(device, str)](#module_lib/arduino..Arduino+sendString) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
* [.stateAsync()](#module_lib/arduino..Arduino+stateAsync)
* [.state()](#module_lib/arduino..Arduino+state)
* [.writeAsync(device, str)](#module_lib/arduino..Arduino+writeAsync) ⇒ <code>Promise</code>
* [.end(serial, data)](#module_lib/arduino..Arduino+end) ⇒ <code>any</code>
* [.aliasSerial(device, serial)](#module_lib/arduino..Arduino+aliasSerial)
* [.connect(device, serial, confirm)](#module_lib/arduino..Arduino+connect) ⇒ <code>Promise.&lt;string&gt;</code>
* [.confirmEnd(data)](#module_lib/arduino..Arduino+confirmEnd)
* [.verify()](#module_lib/arduino..Arduino+verify) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.distinguish()](#module_lib/arduino..Arduino+distinguish) ⇒ <code>Promise.&lt;string&gt;</code>
* [.close()](#module_lib/arduino..Arduino+close) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.fakeConnect(serial)](#module_lib/arduino..Arduino+fakeConnect) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.openArduino(device)](#module_lib/arduino..Arduino+openArduino) ⇒ <code>Promise</code>
* [.closeArduino(device)](#module_lib/arduino..Arduino+closeArduino) ⇒ <code>Promise</code>
<a name="module_lib/arduino..Arduino"></a>
### lib/arduino~Arduino
Class representing the arduino communication features.
**Kind**: inner class of [<code>lib/arduino</code>](#module_lib/arduino)
* [~Arduino](#module_lib/arduino..Arduino)
* [.enumerate()](#module_lib/arduino..Arduino+enumerate) ⇒ <code>Promise</code>
* [.sendAsync(device, cmd)](#module_lib/arduino..Arduino+sendAsync) ⇒ <code>Promise</code>
* [.send(device, cmd)](#module_lib/arduino..Arduino+send) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
* [.sendString(device, str)](#module_lib/arduino..Arduino+sendString) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
* [.stateAsync()](#module_lib/arduino..Arduino+stateAsync)
* [.state()](#module_lib/arduino..Arduino+state)
* [.writeAsync(device, str)](#module_lib/arduino..Arduino+writeAsync) ⇒ <code>Promise</code>
* [.end(serial, data)](#module_lib/arduino..Arduino+end) ⇒ <code>any</code>
* [.aliasSerial(device, serial)](#module_lib/arduino..Arduino+aliasSerial)
* [.connect(device, serial, confirm)](#module_lib/arduino..Arduino+connect) ⇒ <code>Promise.&lt;string&gt;</code>
* [.confirmEnd(data)](#module_lib/arduino..Arduino+confirmEnd)
* [.verify()](#module_lib/arduino..Arduino+verify) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.distinguish()](#module_lib/arduino..Arduino+distinguish) ⇒ <code>Promise.&lt;string&gt;</code>
* [.close()](#module_lib/arduino..Arduino+close) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.fakeConnect(serial)](#module_lib/arduino..Arduino+fakeConnect) ⇒ <code>Promise.&lt;boolean&gt;</code>
* [.openArduino(device)](#module_lib/arduino..Arduino+openArduino) ⇒ <code>Promise</code>
* [.closeArduino(device)](#module_lib/arduino..Arduino+closeArduino) ⇒ <code>Promise</code>
<a name="module_lib/arduino..Arduino+enumerate"></a>
#### arduino.enumerate() ⇒ <code>Promise</code>
Enumerate all connected devices that might be Arduinos
**Kind**: instance method of [<code>Arduino</code>](#Arduino)
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise</code> - Resolves after enumerating
<a name="Arduino+sendAsync"></a>
<a name="module_lib/arduino..Arduino+sendAsync"></a>
### arduino.sendAsync(device, cmd) ⇒ <code>Promise</code>
#### arduino.sendAsync(device, cmd) ⇒ <code>Promise</code>
Send a command to an Arduino using async/await
**Kind**: instance method of [<code>Arduino</code>](#Arduino)
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise</code> - Resolves after sending
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | Arduino identifier |
| device | <code>string</code> | The Arduino device identifier |
| cmd | <code>string</code> | Single character command to send |
<a name="Arduino+writeAsync"></a>
<a name="module_lib/arduino..Arduino+send"></a>
### arduino.writeAsync(device, str) ⇒ <code>Promise</code>
#### arduino.send(device, cmd) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
Sends a command to the specified Arduino and waits for a response.
Handles the communication lock to prevent sending multiple commands simultaneously.
Emits an 'arduino_send' event after successfully sending the command.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;(boolean\|string)&gt;</code> - Returns 'false' if the communication is locked, otherwise returns the response from the device.
**Throws**:
- <code>Error</code> Throws an error if the sendAsync method encounters an error.
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | The Arduino device identifier. |
| cmd | <code>string</code> | The command to be sent to the Arduino. |
<a name="module_lib/arduino..Arduino+sendString"></a>
#### arduino.sendString(device, str) ⇒ <code>Promise.&lt;(boolean\|string)&gt;</code>
Sends a string to the specified Arduino.
Handles different types of devices, including fake devices for testing purposes.
Waits for a specified delay before sending the string.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;(boolean\|string)&gt;</code> - Returns 'true' if the string is sent successfully, otherwise returns an error message.
**Throws**:
- <code>Error</code> Throws an error if the writeAsync method encounters an error.
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | The Arduino device identifier. |
| str | <code>string</code> | The string to be sent to the Arduino. |
<a name="module_lib/arduino..Arduino+stateAsync"></a>
#### arduino.stateAsync()
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
<a name="module_lib/arduino..Arduino+state"></a>
#### arduino.state()
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
<a name="module_lib/arduino..Arduino+writeAsync"></a>
#### arduino.writeAsync(device, str) ⇒ <code>Promise</code>
Send a string to an Arduino using async/await
**Kind**: instance method of [<code>Arduino</code>](#Arduino)
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise</code> - Resolves after sending
| Param | Type | Description |
@ -45,27 +148,149 @@ Send a string to an Arduino using async/await
| device | <code>string</code> | Arduino identifier |
| str | <code>string</code> | String to send |
<a name="Arduino+openArduino"></a>
<a name="module_lib/arduino..Arduino+end"></a>
### arduino.openArduino(device) ⇒ <code>Promise</code>
#### arduino.end(serial, data) ⇒ <code>any</code>
Handles the end of communication with the Arduino.
Calculates the time taken for the communication, executes the callback,
and emits an 'arduino_end' event. Handles errors and stray data received.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>any</code> - The time taken for the communication in milliseconds.
| Param | Type | Description |
| --- | --- | --- |
| serial | <code>string</code> | The serial address of the Arduino device. |
| data | <code>string</code> | The data received from the Arduino. |
<a name="module_lib/arduino..Arduino+aliasSerial"></a>
#### arduino.aliasSerial(device, serial)
Associates an alias with an Arduinos serial address.
Used to map multi-purpose devices onto the same serial connection.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | The serial number of the target Arduino. |
| serial | <code>string</code> | The alias to be associated with the target device. |
<a name="module_lib/arduino..Arduino+connect"></a>
#### arduino.connect(device, serial, confirm) ⇒ <code>Promise.&lt;string&gt;</code>
Connects to an Arduino using its serial number.
Sets up the SerialPort instance and path for the device, and handles data communication.
Handles opening the connection and emitting 'arduino_end' or 'confirmEnd' events upon receiving data.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;string&gt;</code> - Resolves with the device path if the connection is successful.
**Throws**:
- <code>Error</code> Rejects with an error message if the connection fails.
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | The device identifier (common name). |
| serial | <code>string</code> | The serial address of the target Arduino (e.g., COM port on Windows). |
| confirm | <code>function</code> | A callback function to be executed upon receiving confirmation data. |
<a name="module_lib/arduino..Arduino+confirmEnd"></a>
#### arduino.confirmEnd(data)
Handles the confirmation data received from an Arduino.
Executes the confirmation callback function if the received data is present in the list of expected values.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
| Param | Type | Description |
| --- | --- | --- |
| data | <code>string</code> | The data received from the Arduino. |
<a name="module_lib/arduino..Arduino+verify"></a>
#### arduino.verify() ⇒ <code>Promise.&lt;boolean&gt;</code>
Verifies the connection to an Arduino by sending a connect command.
The confirmation callback checks if the received data matches the expected connect command.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;boolean&gt;</code> - Resolves with 'true' if the connection is verified successfully.
**Throws**:
- <code>Error</code> Rejects with an error message if the connection verification fails.
<a name="module_lib/arduino..Arduino+distinguish"></a>
#### arduino.distinguish() ⇒ <code>Promise.&lt;string&gt;</code>
Distinguishes the type of Arduino connected.
Sends a command to the device to identify its type and resolves the promise with the received type.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;string&gt;</code> - Resolves with the type of the connected Arduino-based device.
**Throws**:
- <code>Error</code> Rejects with an error message if the distinguish operation fails.
<a name="module_lib/arduino..Arduino+close"></a>
#### arduino.close() ⇒ <code>Promise.&lt;boolean&gt;</code>
Closes the connection to an Arduino.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;boolean&gt;</code> - Resolves with 'true' if the connection is closed successfully.
**Throws**:
- <code>Error</code> Throws an error if the closeArduino method encounters an error.
<a name="module_lib/arduino..Arduino+fakeConnect"></a>
#### arduino.fakeConnect(serial) ⇒ <code>Promise.&lt;boolean&gt;</code>
Establishes a fake connection to an Arduino for testing purposes.
Creates a fake SerialPort instance with custom write and string methods.
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise.&lt;boolean&gt;</code> - Resolves with 'true' if the fake connection is established successfully.
| Param | Type | Description |
| --- | --- | --- |
| serial | <code>string</code> | The device identifier of the fake Arduino. |
<a name="module_lib/arduino..Arduino+openArduino"></a>
#### arduino.openArduino(device) ⇒ <code>Promise</code>
Connect to an Arduino using async/await
**Kind**: instance method of [<code>Arduino</code>](#Arduino)
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise</code> - Resolves after opening
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | Arduino identifier |
<a name="Arduino+closeArduino"></a>
<a name="module_lib/arduino..Arduino+closeArduino"></a>
### arduino.closeArduino(device) ⇒ <code>Promise</code>
#### arduino.closeArduino(device) ⇒ <code>Promise</code>
Close a connection to an Arduino using async/await
**Kind**: instance method of [<code>Arduino</code>](#Arduino)
**Kind**: instance method of [<code>Arduino</code>](#module_lib/arduino..Arduino)
**Returns**: <code>Promise</code> - Resolves after closing
| Param | Type | Description |
| --- | --- | --- |
| device | <code>string</code> | Arduino identifier |
<a name="delay_1"></a>
## delay\_1
2023-07-16 Clarification
Previous versions of this script intermingled and even
swapped the usage of the terms 'serial' and 'device'.
From here on out, the terms will be used as such:
serial - a hardware address of a serial port
device - common name of a type of mcopy device (eg. camera,
projector, light) that is aliased to a serial port
**Kind**: global constant

179
app/lib/arduino/index.d.ts vendored Normal file
View File

@ -0,0 +1,179 @@
/// <reference types="node" />
import type { EventEmitter } from 'events';
import type { Config } from 'cfg';
/** @module lib/arduino */
/**
* Class representing the arduino communication features.
*/
export declare class Arduino {
private log;
private eventEmitter;
private cfg;
private path;
private known;
private serial;
private baud;
private queue;
private timer;
private locks;
private confirmExec;
private errorState;
private keys;
private values;
alias: any;
stateStr: any;
hasState: any;
constructor(cfg: Config, ee: EventEmitter, errorState: Function);
init(): Promise<void>;
/**
* Enumerate all connected devices that might be Arduinos
*
* @async
* @returns {Promise} Resolves after enumerating
**/
enumerate(): Promise<string[]>;
/**
* Send a command to an Arduino using async/await
*
* @param {string} device The Arduino device identifier
* @param {string} cmd Single character command to send
*
* @async
* @returns {Promise} Resolves after sending
**/
private sendAsync;
/**
* Sends a command to the specified Arduino and waits for a response.
* Handles the communication lock to prevent sending multiple commands simultaneously.
* Emits an 'arduino_send' event after successfully sending the command.
*
* @async
* @param {string} device - The Arduino device identifier.
* @param {string} cmd - The command to be sent to the Arduino.
* @returns {Promise<boolean|string>} Returns 'false' if the communication is locked, otherwise returns the response from the device.
* @throws {Error} Throws an error if the sendAsync method encounters an error.
**/
send(device: string, cmd: string): Promise<number>;
/**
* Sends a string to the specified Arduino.
* Handles different types of devices, including fake devices for testing purposes.
* Waits for a specified delay before sending the string.
*
* @async
* @param {string} device - The Arduino device identifier.
* @param {string} str - The string to be sent to the Arduino.
* @returns {Promise<boolean|string>} Returns 'true' if the string is sent successfully, otherwise returns an error message.
* @throws {Error} Throws an error if the writeAsync method encounters an error.
**/
sendString(device: string, str: string): Promise<number>;
/**
*
**/
private stateAsync;
/**
*
**/
state(device: string, confirm?: boolean): Promise<string>;
/**
* Send a string to an Arduino using async/await
*
* @param {string} device Arduino identifier
* @param {string} str String to send
*
* @returns {Promise} Resolves after sending
**/
private writeAsync;
/**
* Handles the end of communication with the Arduino.
* Calculates the time taken for the communication, executes the callback,
* and emits an 'arduino_end' event. Handles errors and stray data received.
*
* @param {string} serial - The serial address of the Arduino device.
* @param {string} data - The data received from the Arduino.
* @returns {any} The time taken for the communication in milliseconds.
**/
private end;
private error;
/**
* Associates an alias with an Arduinos serial address.
* Used to map multi-purpose devices onto the same serial connection.
*
* @param {string} device - The serial number of the target Arduino.
* @param {string} serial - The alias to be associated with the target device.
**/
aliasSerial(device: string, serial: string): void;
/**
* Connects to an Arduino using its serial number.
* Sets up the SerialPort instance and path for the device, and handles data communication.
* Handles opening the connection and emitting 'arduino_end' or 'confirmEnd' events upon receiving data.
*
* @async
* @param {string} device - The device identifier (common name).
* @param {string} serial - The serial address of the target Arduino (e.g., COM port on Windows).
* @param {function} confirm - A callback function to be executed upon receiving confirmation data.
* @returns {Promise<string>} Resolves with the device path if the connection is successful.
* @throws {Error} Rejects with an error message if the connection fails.
**/
connect(device: string, serial: string, confirm: any): Promise<any>;
/**
* Handles the confirmation data received from an Arduino.
* Executes the confirmation callback function if the received data is present in the list of expected values.
*
* @param {string} data - The data received from the Arduino.
**/
private confirmEnd;
/**
* Verifies the connection to an Arduino by sending a connect command.
* The confirmation callback checks if the received data matches the expected connect command.
*
* @async
* @returns {Promise<boolean>} Resolves with 'true' if the connection is verified successfully.
* @throws {Error} Rejects with an error message if the connection verification fails.
**/
verify(): Promise<unknown>;
/**
* Distinguishes the type of Arduino connected.
* Sends a command to the device to identify its type and resolves the promise with the received type.
*
* @async
* @returns {Promise<string>} Resolves with the type of the connected Arduino-based device.
* @throws {Error} Rejects with an error message if the distinguish operation fails.
**/
distinguish(): Promise<string>;
/**
* Closes the connection to an Arduino.
*
* @async
* @returns {Promise<boolean>} Resolves with 'true' if the connection is closed successfully.
* @throws {Error} Throws an error if the closeArduino method encounters an error.
**/
close(): Promise<boolean>;
/**
* Establishes a fake connection to an Arduino for testing purposes.
* Creates a fake SerialPort instance with custom write and string methods.
*
* @async
* @param {string} serial - The device identifier of the fake Arduino.
* @returns {Promise<boolean>} Resolves with 'true' if the fake connection is established successfully.
**/
fakeConnect(device: string): Promise<boolean>;
/**
* Connect to an Arduino using async/await
*
* @param {string} device Arduino identifier
*
* @returns {Promise} Resolves after opening
**/
private openArduino;
/**
* Close a connection to an Arduino using async/await
*
* @param {string} device Arduino identifier
*
* @returns {Promise} Resolves after closing
**/
private closeArduino;
private lock;
private unlock;
private isLocked;
}

View File

@ -1,16 +1,25 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
//import Log = require('log');
exports.Arduino = void 0;
/**
* 2023-07-16 Clarification
*
* Previous versions of this script intermingled and even
* swapped the usage of the terms 'serial' and 'device'.
* From here on out, the terms will be used as such:
*
* serial - a hardware address of a serial port
* device - common name of a type of mcopy device (eg. camera,
* projector, light) that is aliased to a serial port
*
**/
const delay_1 = require("delay");
const SerialPort = require('serialport');
const Readline = SerialPort.parsers.Readline;
const exec = require('child_process').exec;
const parser = new Readline('');
const log_1 = require("log");
const { SerialPort } = require('serialport');
const { ReadlineParser } = require('@serialport/parser-readline');
const parser = new ReadlineParser({ delimiter: '\r\n' });
const newlineRe = new RegExp('\n', 'g');
const returnRe = new RegExp('\r', 'g');
let eventEmitter;
let cfg;
let arduino;
const KNOWN = [
'/dev/tty.usbmodem1a161',
'/dev/tty.usbserial-A800f8dk',
@ -21,24 +30,36 @@ const KNOWN = [
'/dev/ttyACM0',
'COM3'
];
/** @module lib/arduino */
/**
* Class representing the arduino communication features
**/
* Class representing the arduino communication features.
*/
class Arduino {
constructor() {
constructor(cfg, ee, errorState) {
this.path = {};
this.known = KNOWN;
this.alias = {};
this.serial = { connect: {}, projector: {}, camera: {}, light: {} };
this.serial = {};
this.baud = 57600;
this.queue = {};
this.timer = 0;
this.lock = false;
this.locks = {};
this.alias = {};
this.stateStr = {};
this.hasState = {};
this.cfg = cfg;
this.eventEmitter = ee;
this.errorState = errorState;
this.init();
}
async init() {
this.log = await (0, log_1.Log)({ label: 'arduino' });
this.keys = Object.keys(this.cfg.arduino.cmd);
this.values = this.keys.map((key) => this.cfg.arduino.cmd[key]);
}
/**
* Enumerate all connected devices that might be Arduinos
*
* @async
* @returns {Promise} Resolves after enumerating
**/
async enumerate() {
@ -50,6 +71,8 @@ class Arduino {
catch (err) {
throw err;
}
this.log.info('Available ports:');
this.log.info(ports.map((port) => { return port.path; }).join(','));
ports.forEach((port) => {
if (this.known.indexOf(port.path) !== -1) {
matches.push(port.path);
@ -77,62 +100,149 @@ class Arduino {
/**
* Send a command to an Arduino using async/await
*
* @param {string} device Arduino identifier
* @param {string} device The Arduino device identifier
* @param {string} cmd Single character command to send
*
* @async
* @returns {Promise} Resolves after sending
**/
async sendAsync(device, cmd) {
return new Promise((resolve, reject) => {
//this.log.info(`sendAsync ${cmd} -> ${device}`)
this.queue[cmd] = (ms) => {
return resolve(ms);
};
return this.serial[device].write(cmd, (err, results) => {
//this.log.info(`Device: ${device}`)
return this.serial[this.alias[device]].write(cmd, (err, results) => {
if (err) {
//console.error(err)
//this.log.error(err)
return reject(err);
}
//
});
});
}
async send(serial, cmd) {
const device = this.alias[serial];
let results;
if (this.locks[serial]) {
return false;
/**
* Sends a command to the specified Arduino and waits for a response.
* Handles the communication lock to prevent sending multiple commands simultaneously.
* Emits an 'arduino_send' event after successfully sending the command.
*
* @async
* @param {string} device - The Arduino device identifier.
* @param {string} cmd - The command to be sent to the Arduino.
* @returns {Promise<boolean|string>} Returns 'false' if the communication is locked, otherwise returns the response from the device.
* @throws {Error} Throws an error if the sendAsync method encounters an error.
**/
async send(device, cmd) {
const serial = this.alias[device];
let ms;
this.log.info(`send ${cmd} -> ${device}`);
if (this.isLocked(serial)) {
this.log.error(`send Serial ${serial} is locked`);
return 0;
}
this.timer = new Date().getTime();
this.locks[serial] = true;
await delay_1.delay(cfg.arduino.serialDelay);
this.lock(serial);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
try {
results = await this.sendAsync(device, cmd);
ms = await this.sendAsync(device, cmd);
}
catch (e) {
return console.error(e);
this.log.error(`Failed to send to ${device} @ ${serial}`, e);
return 0;
}
this.locks[serial] = false;
await eventEmitter.emit('arduino_send', cmd);
return results;
this.unlock(serial);
await this.eventEmitter.emit('arduino_send', cmd);
return ms;
}
async string(serial, str) {
const device = this.alias[serial];
let writeSuccess;
await delay_1.delay(cfg.arduino.serialDelay);
if (typeof this.serial[device].fake !== 'undefined'
&& this.serial[device].fake) {
return this.serial[device].string(str);
/**
* Sends a string to the specified Arduino.
* Handles different types of devices, including fake devices for testing purposes.
* Waits for a specified delay before sending the string.
*
* @async
* @param {string} device - The Arduino device identifier.
* @param {string} str - The string to be sent to the Arduino.
* @returns {Promise<boolean|string>} Returns 'true' if the string is sent successfully, otherwise returns an error message.
* @throws {Error} Throws an error if the writeAsync method encounters an error.
**/
async sendString(device, str) {
let ms;
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (typeof this.serial[this.alias[device]].fake !== 'undefined'
&& this.serial[this.alias[device]].fake) {
return this.serial[this.alias[device]].string(str);
}
else {
this.log.info(`sendString ${str} -> ${device}`);
try {
writeSuccess = await this.writeAsync(device, str);
ms = await this.writeAsync(device, str);
}
catch (e) {
return console.error(e);
this.log.error(`Error sending string to ${device}`, e);
return 0;
}
return writeSuccess;
this.unlock(this.alias[device]);
return ms;
}
}
/**
*
**/
async stateAsync(device, confirm = false) {
const cmd = this.cfg.arduino.cmd.state;
const serial = confirm ? this.alias['connect'] : this.alias[device];
return new Promise((resolve, reject) => {
this.queue[cmd] = (state) => {
this.stateStr[device] = state;
if (confirm) {
this.hasState[device] = true;
this.log.info(`Device ${device} supports state [${state}]`);
}
return resolve(state);
};
if (confirm) {
setTimeout(function () {
if (typeof this.queue[cmd] !== 'undefined') {
delete this.queue[cmd];
this.hasState[device] = false;
this.log.info(`Device ${device} does not support state`);
return resolve(null);
}
}.bind(this), 1000);
}
this.log.info(`stateAsync ${cmd} -> ${device}`);
return this.serial[serial].write(cmd, (err, results) => {
if (err) {
//this.log.error(err)
return reject(err);
}
});
});
}
/**
*
**/
async state(device, confirm = false) {
const serial = confirm ? this.alias['connect'] : this.alias[device];
let results;
if (this.isLocked(serial)) {
this.log.warn(`state Serial ${serial} is locked`);
return null;
}
this.timer = new Date().getTime();
this.lock(serial);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
try {
results = await this.stateAsync(device, confirm);
}
catch (e) {
this.log.error(`Error getting state from ${device}`, e);
return null;
}
this.unlock(serial);
await this.eventEmitter.emit('arduino_state', this.cfg.arduino.cmd.state);
return results;
}
/**
* Send a string to an Arduino using async/await
*
@ -143,7 +253,7 @@ class Arduino {
**/
async writeAsync(device, str) {
return new Promise((resolve, reject) => {
this.serial[device].write(str, function (err, results) {
this.serial[this.alias[device]].write(str, function (err, results) {
if (err) {
return reject(err);
}
@ -151,53 +261,104 @@ class Arduino {
});
});
}
/**
* Handles the end of communication with the Arduino.
* Calculates the time taken for the communication, executes the callback,
* and emits an 'arduino_end' event. Handles errors and stray data received.
*
* @param {string} serial - The serial address of the Arduino device.
* @param {string} data - The data received from the Arduino.
* @returns {any} The time taken for the communication in milliseconds.
**/
end(serial, data) {
const end = new Date().getTime();
const ms = end - this.timer;
let complete;
//this.log.info(`end ${serial} -> ${data}`)
if (this.queue[data] !== undefined) {
this.locks[serial] = false;
this.unlock(serial);
complete = this.queue[data](ms); //execute callback
eventEmitter.emit('arduino_end', data);
this.eventEmitter.emit('arduino_end', data);
delete this.queue[data];
}
else if (data[0] === this.cfg.arduino.cmd.state) {
//this.log.info(`end serial -> ${serial}`)
this.unlock(serial);
complete = this.queue[this.cfg.arduino.cmd.state](data);
this.eventEmitter.emit('arduino_end', data);
delete this.queue[this.cfg.arduino.cmd.state];
return data;
}
else if (data[0] === this.cfg.arduino.cmd.error) {
this.log.error(`Received error from device ${serial}`);
this.unlock(serial);
this.error(serial, data);
//error state
//stop sequence
//throw error in ui
}
else {
//console.log('Received stray "' + data + '"'); //silent to user
this.log.info('Received stray "' + data + '"'); //silent to user
}
return ms;
}
aliasSerial(serial, device) {
//this.log.info(`Making "${serial}" an alias of ${device}`);
this.alias[serial] = device;
error(serial, data) {
this.log.error("ERROR", data);
}
async connect(serial, device, confirm) {
/**
* Associates an alias with an Arduinos serial address.
* Used to map multi-purpose devices onto the same serial connection.
*
* @param {string} device - The serial number of the target Arduino.
* @param {string} serial - The alias to be associated with the target device.
**/
aliasSerial(device, serial) {
//this.log.info(`Making "${serial}" an alias of ${device}`)
this.alias[device] = serial;
}
/**
* Connects to an Arduino using its serial number.
* Sets up the SerialPort instance and path for the device, and handles data communication.
* Handles opening the connection and emitting 'arduino_end' or 'confirmEnd' events upon receiving data.
*
* @async
* @param {string} device - The device identifier (common name).
* @param {string} serial - The serial address of the target Arduino (e.g., COM port on Windows).
* @param {function} confirm - A callback function to be executed upon receiving confirmation data.
* @returns {Promise<string>} Resolves with the device path if the connection is successful.
* @throws {Error} Rejects with an error message if the connection fails.
**/
async connect(device, serial, confirm) {
//this.log.info(`connect device ${device}`)
//this.log.info(`connect serial ${serial}`)
return new Promise(async (resolve, reject) => {
let connectSuccess;
this.path[serial] = device;
this.alias[serial] = device;
this.serial[device] = new SerialPort(this.path[serial], {
this.path[device] = serial;
this.aliasSerial(device, serial);
this.serial[serial] = new SerialPort({
path: serial,
autoOpen: false,
baudRate: cfg.arduino.baud,
parser: parser
baudRate: this.cfg.arduino.baud,
parser
});
this.locks[device] = false;
this.unlock(serial);
try {
connectSuccess = await this.openArduino(device);
}
catch (e) {
console.error('failed to open: ' + e);
this.log.error(`Failed to open ${device} @ ${serial}: ` + e);
return reject(e);
}
//console.log(`Opened connection with ${this.path[serial]} as ${serial}`);
this.log.info(`Opened connection with ${this.path[device]} as ${device}`);
if (!confirm) {
this.serial[device].on('data', async (data) => {
this.serial[this.alias[device]].on('data', async (data) => {
let d = data.toString('utf8');
d = d.replace(newlineRe, '').replace(returnRe, '');
return this.end(serial, d);
});
}
else {
this.serial[device].on('data', async (data) => {
this.serial[this.alias[device]].on('data', async (data) => {
let d = data.toString('utf8');
d = d.replace(newlineRe, '').replace(returnRe, '');
return await this.confirmEnd(d);
@ -206,46 +367,47 @@ class Arduino {
return resolve(this.path[serial]);
});
}
/**
* Handles the confirmation data received from an Arduino.
* Executes the confirmation callback function if the received data is present in the list of expected values.
*
* @param {string} data - The data received from the Arduino.
**/
confirmEnd(data) {
//console.dir(data)
if (data === cfg.arduino.cmd.connect
|| data === cfg.arduino.cmd.projector_identifier
|| data === cfg.arduino.cmd.camera_identifier
|| data === cfg.arduino.cmd.light_identifier
|| data === cfg.arduino.cmd.projector_light_identifier
|| data === cfg.arduino.cmd.projector_camera_light_identifier
|| data === cfg.arduino.cmd.projector_camera_identifier
|| data === cfg.arduino.cmd.projector_second_identifier
|| data === cfg.arduino.cmd.projectors_identifier
|| data === cfg.arduino.cmd.projector_second_forward
|| data === cfg.arduino.cmd.projector_second_backward
|| data === cfg.arduino.cmd.projector_second
|| data === cfg.arduino.cmd.projectors
|| data === cfg.arduino.cmd.camera_second_identifier
|| data === cfg.arduino.cmd.cameras_identifier
|| data === cfg.arduino.cmd.camera_second_forward
|| data === cfg.arduino.cmd.camera_second_backward
|| data === cfg.arduino.cmd.camera_second
|| data === cfg.arduino.cmd.cameras) {
if (this.values.indexOf(data) !== -1 && typeof this.confirmExec === 'function') {
this.confirmExec(null, data);
this.confirmExec = {};
this.confirmExec = null;
this.unlock(this.alias['connect']);
}
else if (data[0] === this.cfg.arduino.cmd.state) {
this.queue[this.cfg.arduino.cmd.state](data);
delete this.queue[this.cfg.arduino.cmd.state];
this.unlock(this.alias['connect']);
}
}
/**
* Verifies the connection to an Arduino by sending a connect command.
* The confirmation callback checks if the received data matches the expected connect command.
*
* @async
* @returns {Promise<boolean>} Resolves with 'true' if the connection is verified successfully.
* @throws {Error} Rejects with an error message if the connection verification fails.
**/
async verify() {
return new Promise(async (resolve, reject) => {
const device = this.alias['connect'];
const device = 'connect';
let writeSuccess;
this.confirmExec = function (err, data) {
if (data === cfg.arduino.cmd.connect) {
if (data === this.cfg.arduino.cmd.connect) {
return resolve(true);
}
else {
return reject('Wrong data returned');
}
};
await delay_1.delay(cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
try {
writeSuccess = await this.sendAsync(device, cfg.arduino.cmd.connect);
writeSuccess = await this.sendAsync(device, this.cfg.arduino.cmd.connect);
}
catch (e) {
return reject(e);
@ -253,64 +415,92 @@ class Arduino {
return resolve(writeSuccess);
});
}
/**
* Distinguishes the type of Arduino connected.
* Sends a command to the device to identify its type and resolves the promise with the received type.
*
* @async
* @returns {Promise<string>} Resolves with the type of the connected Arduino-based device.
* @throws {Error} Rejects with an error message if the distinguish operation fails.
**/
async distinguish() {
return new Promise(async (resolve, reject) => {
const device = this.alias['connect'];
const device = 'connect';
let writeSuccess;
let type;
this.confirmExec = function (err, data) {
if (data === cfg.arduino.cmd.projector_identifier) {
if (data === this.cfg.arduino.cmd.projector_identifier) {
type = 'projector';
}
else if (data === cfg.arduino.cmd.camera_identifier) {
else if (data === this.cfg.arduino.cmd.camera_identifier) {
type = 'camera';
}
else if (data === cfg.arduino.cmd.light_identifier) {
else if (data === this.cfg.arduino.cmd.light_identifier) {
type = 'light';
}
else if (data === cfg.arduino.cmd.projector_light_identifier) {
else if (data === this.cfg.arduino.cmd.projector_light_identifier) {
type = 'projector,light';
}
else if (data === cfg.arduino.cmd.projector_camera_light_identifier) {
else if (data === this.cfg.arduino.cmd.projector_camera_light_identifier) {
type = 'projector,camera,light';
}
else if (data === cfg.arduino.cmd.projector_camera_identifier) {
else if (data === this.cfg.arduino.cmd.projector_camera_identifier) {
type = 'projector,camera';
}
else if (data === cfg.arduino.cmd.projector_second_identifier) {
else if (data === this.cfg.arduino.cmd.projector_second_identifier) {
type = 'projector_second';
}
else if (data === cfg.arduino.cmd.projectors_identifier) {
else if (data === this.cfg.arduino.cmd.projectors_identifier) {
type = 'projector,projector_second';
}
else if (data === cfg.arduino.cmd.camera_second_identifier) {
else if (data === this.cfg.arduino.cmd.camera_second_identifier) {
type = 'camera_second';
}
else if (data === cfg.arduino.cmd.cameras_identifier) {
else if (data === this.cfg.arduino.cmd.cameras_identifier) {
type = 'camera,camera_second';
}
else if (data === cfg.arduino.cmd.camera_projectors_identifier) {
else if (data === this.cfg.arduino.cmd.camera_projectors_identifier) {
type = 'camera,projector,projector_second';
}
else if (data === cfg.arduino.cmd.cameras_projector_identifier) {
else if (data === this.cfg.arduino.cmd.cameras_projector_identifier) {
type = 'camera,camera_second,projector';
}
else if (data === cfg.arduino.cmd.cameras_projectors_identifier) {
else if (data === this.cfg.arduino.cmd.cameras_projectors_identifier) {
type = 'camera,camera_second,projector,projector_second';
}
else if (data === this.cfg.arduino.cmd.capper_identifier) {
type = 'capper';
}
else if (data === this.cfg.arduino.cmd.camera_capper_identifier) {
type = 'camera,capper';
}
else if (data === this.cfg.arduino.cmd.camera_capper_projector_identifier) {
type = 'camera,capper,projector';
}
else if (data === this.cfg.arduino.cmd.camera_capper_projectors_identifier) {
type = 'camera,capper,projector,projector_second';
}
return resolve(type);
};
await delay_1.delay(cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
try {
writeSuccess = await this.sendAsync(device, cfg.arduino.cmd.mcopy_identifier);
writeSuccess = await this.sendAsync(device, this.cfg.arduino.cmd.mcopy_identifier);
this.log.info(writeSuccess);
}
catch (e) {
return reject(e);
}
});
}
/**
* Closes the connection to an Arduino.
*
* @async
* @returns {Promise<boolean>} Resolves with 'true' if the connection is closed successfully.
* @throws {Error} Throws an error if the closeArduino method encounters an error.
**/
async close() {
const device = this.alias['connect'];
const device = 'connect';
let closeSuccess;
try {
closeSuccess = await this.closeArduino(device);
@ -320,31 +510,40 @@ class Arduino {
}
return closeSuccess;
}
;
async fakeConnect(serial) {
const device = '/dev/fake';
this.alias[serial] = device;
this.serial[device] = {
/**
* Establishes a fake connection to an Arduino for testing purposes.
* Creates a fake SerialPort instance with custom write and string methods.
*
* @async
* @param {string} serial - The device identifier of the fake Arduino.
* @returns {Promise<boolean>} Resolves with 'true' if the fake connection is established successfully.
**/
async fakeConnect(device) {
const serial = '/dev/fake';
this.aliasSerial(device, serial);
this.serial[serial] = {
write: async function (cmd, cb) {
const t = {
c: cfg.arduino.cam.time + cfg.arduino.cam.delay,
p: cfg.arduino.proj.time + cfg.arduino.proj.delay
c: this.cfg.arduino.cam.time + this.cfg.arduino.cam.delay,
p: this.cfg.arduino.proj.time + this.cfg.arduino.proj.delay,
A: 180,
B: 180
};
let timeout = t[cmd];
if (typeof timeout === 'undefined')
timeout = 10;
arduino.timer = +new Date();
await delay_1.delay(timeout);
arduino.end(serial, cmd);
this.timer = +new Date();
await (0, delay_1.delay)(timeout);
this.end(serial, cmd);
return cb();
},
}.bind(this),
string: async function (str) {
//do nothing
return true;
},
fake: true
};
//console.log('Connected to fake arduino! Not real! Does not exist!');
//this.log.info('Connected to fake arduino! Not real! Does not exist!')
return true;
}
/**
@ -356,7 +555,7 @@ class Arduino {
**/
async openArduino(device) {
return new Promise((resolve, reject) => {
return this.serial[device].open((err) => {
return this.serial[this.alias[device]].open((err) => {
if (err) {
return reject(err);
}
@ -373,7 +572,7 @@ class Arduino {
**/
async closeArduino(device) {
return new Promise((resolve, reject) => {
return this.serial[device].close((err) => {
return this.serial[this.alias[device]].close((err) => {
if (err) {
return reject(err);
}
@ -381,13 +580,18 @@ class Arduino {
});
});
}
lock(serial) {
//this.log.info(`Locked serial ${serial}`)
this.locks[serial] = true;
}
unlock(serial) {
//this.log.info(`Unlocked serial ${serial}`)
this.locks[serial] = false;
}
isLocked(serial) {
return typeof this.locks[serial] !== 'undefined' && this.locks[serial] === true;
}
}
if (typeof module !== 'undefined' && module.parent) {
module.exports = function (c, ee) {
eventEmitter = ee;
cfg = c;
arduino = new Arduino();
return arduino;
};
}
exports.Arduino = Arduino;
module.exports = { Arduino };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

View File

@ -1,49 +1,76 @@
<a name="Camera"></a>
<a name="module_lib/cam"></a>
## Camera
class representing camera functions
## lib/cam
**Kind**: global class
* [lib/cam](#module_lib/cam)
* [~Camera](#module_lib/cam..Camera)
* [.init()](#module_lib/cam..Camera+init)
* [.listen()](#module_lib/cam..Camera+listen)
* [.set()](#module_lib/cam..Camera+set)
* [.cap()](#module_lib/cam..Camera+cap)
* [.move()](#module_lib/cam..Camera+move)
* [.exposure()](#module_lib/cam..Camera+exposure)
* [.connectIntval()](#module_lib/cam..Camera+connectIntval)
* [.connectProcessing()](#module_lib/cam..Camera+connectProcessing)
* [.listener()](#module_lib/cam..Camera+listener)
* [.end()](#module_lib/cam..Camera+end)
* [Camera](#Camera)
* [.init()](#Camera+init)
* [.listen()](#Camera+listen)
* [.set()](#Camera+set)
* [.move()](#Camera+move)
* [.exposure()](#Camera+exposure)
* [.connectIntval()](#Camera+connectIntval)
* [.listener()](#Camera+listener)
* [.end()](#Camera+end)
<a name="module_lib/cam..Camera"></a>
<a name="Camera+init"></a>
### lib/cam~Camera
Class representing camera functions.
### camera.init()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+listen"></a>
**Kind**: inner class of [<code>lib/cam</code>](#module_lib/cam)
### camera.listen()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+set"></a>
* [~Camera](#module_lib/cam..Camera)
* [.init()](#module_lib/cam..Camera+init)
* [.listen()](#module_lib/cam..Camera+listen)
* [.set()](#module_lib/cam..Camera+set)
* [.cap()](#module_lib/cam..Camera+cap)
* [.move()](#module_lib/cam..Camera+move)
* [.exposure()](#module_lib/cam..Camera+exposure)
* [.connectIntval()](#module_lib/cam..Camera+connectIntval)
* [.connectProcessing()](#module_lib/cam..Camera+connectProcessing)
* [.listener()](#module_lib/cam..Camera+listener)
* [.end()](#module_lib/cam..Camera+end)
### camera.set()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+move"></a>
<a name="module_lib/cam..Camera+init"></a>
### camera.move()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+exposure"></a>
#### camera.init()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+listen"></a>
### camera.exposure()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+connectIntval"></a>
#### camera.listen()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+set"></a>
### camera.connectIntval()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+listener"></a>
#### camera.set()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+cap"></a>
### camera.listener()
**Kind**: instance method of [<code>Camera</code>](#Camera)
<a name="Camera+end"></a>
#### camera.cap()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+move"></a>
### camera.end()
**Kind**: instance method of [<code>Camera</code>](#Camera)
#### camera.move()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+exposure"></a>
#### camera.exposure()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+connectIntval"></a>
#### camera.connectIntval()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+connectProcessing"></a>
#### camera.connectProcessing()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+listener"></a>
#### camera.listener()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)
<a name="module_lib/cam..Camera+end"></a>
#### camera.end()
**Kind**: instance method of [<code>Camera</code>](#module_lib/cam..Camera)

71
app/lib/cam/index.d.ts vendored Normal file
View File

@ -0,0 +1,71 @@
import type { Arduino } from 'arduino';
import type { FilmOut } from 'filmout';
import type { Config } from 'cfg';
import type { WebContents } from 'electron';
interface CameraState {
pos: number;
dir: boolean;
capper: boolean;
}
/** @module lib/cam */
/**
* Class representing camera functions.
*/
export declare class Camera {
state: CameraState;
arduino: Arduino;
private intval;
private processing;
private log;
private cfg;
private filmout;
private ui;
private ipc;
private id;
/**
*
**/
constructor(arduino: Arduino, cfg: Config, ui: WebContents, filmout: FilmOut, second?: boolean);
/**
*
**/
private init;
/**
*
**/
private listen;
/**
*
**/
set(dir: boolean, id: string): Promise<number>;
/**
*
**/
cap(state: boolean, id: string): Promise<number>;
/**
*
**/
move(id: string): Promise<number>;
both(id: string): Promise<number>;
/**
*
**/
exposure(exposure: number, id: string): Promise<number>;
/**
*
**/
private connectIntval;
/**
*
**/
private connectProcessing;
/**
*
**/
private listener;
/**
*
**/
private end;
}
export {};

View File

@ -1,7 +1,15 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Camera = void 0;
const electron_1 = require("electron");
const intval_1 = require("intval");
/** class representing camera functions **/
const processing_1 = require("processing");
const delay_1 = require("delay");
const log_1 = require("log");
/** @module lib/cam */
/**
* Class representing camera functions.
*/
class Camera {
/**
*
@ -9,10 +17,13 @@ class Camera {
constructor(arduino, cfg, ui, filmout, second = false) {
this.state = {
pos: 0,
dir: true
dir: true,
capper: false
};
this.arduino = null;
this.intval = null;
this.processing = null;
this.ipc = electron_1.ipcMain;
this.id = 'camera';
this.arduino = arduino;
this.cfg = cfg;
@ -26,9 +37,7 @@ class Camera {
*
**/
async init() {
const Log = require('log');
this.log = await Log({ label: this.id });
this.ipc = require('electron').ipcMain;
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
@ -37,6 +46,7 @@ class Camera {
listen() {
this.ipc.on(this.id, this.listener.bind(this));
this.ipc.on('intval', this.connectIntval.bind(this));
this.ipc.on('processing', this.connectProcessing.bind(this));
}
/**
*
@ -51,7 +61,15 @@ class Camera {
cmd = this.cfg.arduino.cmd[`${this.id}_backward`];
}
this.state.dir = dir;
if (this.intval) {
if (this.processing) {
try {
ms = await this.processing.setDir(dir);
}
catch (err) {
this.log.error(err);
}
}
else if (this.intval) {
try {
ms = await this.intval.setDir(dir);
}
@ -72,18 +90,47 @@ class Camera {
/**
*
**/
async move(frame, id) {
async cap(state, id) {
let cmd;
let ms;
if (state) {
cmd = this.cfg.arduino.cmd[`${this.id}_forward`];
}
else {
cmd = this.cfg.arduino.cmd[`${this.id}_backward`];
}
this.state.capper = state;
try {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(err);
}
return await this.end(cmd, id, ms);
}
/**
*
**/
async move(id) {
const cmd = this.cfg.arduino.cmd[this.id];
let ms;
if (this.filmout.state.enabled) {
await this.filmout.start();
}
if (this.intval) {
if (this.processing) {
try {
ms = await this.processing.move();
}
catch (err) {
this.log.error(err);
}
}
else if (this.intval) {
try {
ms = await this.intval.move();
}
catch (err) {
this.log.error(err);
this.log.error(`Error moving intval ${this.id}: ${id}`, err);
}
}
else {
@ -101,14 +148,14 @@ class Camera {
//this.log.info('Camera move time', { ms });
return this.end(cmd, id, ms);
}
async both(frame, id) {
async both(id) {
const cmd = this.cfg.arduino.cmd[id];
let ms;
try {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(`Error moving ${this.id}`, err);
this.log.error(`Error moving both ${this.id}: ${id}`, err);
}
//this.log.info('Cameras move time', { ms });
return await this.end(cmd, id, ms);
@ -116,11 +163,55 @@ class Camera {
/**
*
**/
exposure(exposure, id) {
let cmd = 'E';
this.intval.setExposure(this.id, exposure, (ms) => {
this.end(cmd, id, ms);
});
async exposure(exposure, id) {
const cmd = this.cfg.arduino.cmd.camera_exposure;
const str = `${exposure}`;
const started = +new Date();
let ms;
let confirmState;
let parts;
let confirmExposure;
if (this.intval) {
return this.intval.setExposure(exposure, (ms) => {
this.ui.send('timing', { c: 'c', ms: exposure });
return this.end(cmd, id, ms);
});
}
else if (this.arduino.hasState[this.id]) {
try {
ms = this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error('Error sending camera exposure command', err);
}
await (0, delay_1.delay)(1);
try {
ms = await this.arduino.sendString(this.id, str);
}
catch (err) {
this.log.error('Error sending camera exposure string', err);
}
await ms;
await (0, delay_1.delay)(1);
try {
confirmState = await this.arduino.state(this.id, false);
}
catch (err) {
this.log.error(`Error confirming set state`, err);
}
parts = this.arduino.stateStr[this.id].split('G');
if (parts.length > 1) {
parts = parts[1].split('H');
confirmExposure = parseInt(parts[0]);
if (!isNaN(confirmExposure)) {
this.log.info(`Exposure successfully set to ${confirmExposure}ms`);
this.ui.send('timing', { c: 'c', ms: exposure });
}
}
ms = (+new Date()) - started;
return await this.end(cmd, id, ms);
}
return 0;
}
/**
*
@ -129,6 +220,7 @@ class Camera {
return new Promise((resolve, reject) => {
if (arg.connect) {
this.intval = new intval_1.Intval(arg.url);
this.processing = null;
this.intval.connect((err, ms, state) => {
if (err) {
this.ui.send('intval', { connected: false });
@ -148,6 +240,17 @@ class Camera {
}
});
}
/**
*
**/
async connectProcessing(event, arg) {
return new Promise((resolve, reject) => {
this.processing = new processing_1.Processing(arg.url);
this.intval = null;
this.ui.send('processing', { connected: true, url: arg.url });
return resolve(true);
});
}
/**
*
**/
@ -160,9 +263,9 @@ class Camera {
this.log.error(err);
}
}
else if (typeof arg.frame !== 'undefined') {
else if (typeof arg.move !== 'undefined') {
try {
await this.move(arg.frame, arg.id);
await this.move(arg.id);
}
catch (err) {
this.log.error(err);
@ -171,6 +274,22 @@ class Camera {
else if (typeof arg.val !== 'undefined') {
this.state.pos = arg.val;
}
else if (typeof arg.capper !== 'undefined') {
try {
await this.cap(arg.capper, arg.id);
}
catch (err) {
this.log.error(err);
}
}
else if (typeof arg.exposure !== 'undefined') {
try {
await this.exposure(arg.exposure, arg.id);
}
catch (err) {
this.log.error(err);
}
}
event.returnValue = true;
}
/**
@ -213,12 +332,15 @@ class Camera {
else if (cmd === this.cfg.arduino.cmd.camerass) {
message += 'Cameras both MOVED 1 frame each';
}
else if (cmd === this.cfg.arduino.camera_exposure) {
message += 'Camera set exposure';
}
message += ` ${ms}ms`;
this.log.info(message);
this.ui.send(this.id, { cmd: cmd, id: id, ms: ms });
await this.ui.send(this.id, { cmd: cmd, id: id, ms: ms });
return ms;
}
}
module.exports = function (arduino, cfg, ui, filmout, second) {
return new Camera(arduino, cfg, ui, filmout, second);
};
exports.Camera = Camera;
module.exports = { Camera };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

46
app/lib/capper/Readme.md Normal file
View File

@ -0,0 +1,46 @@
<a name="module_lib/capper"></a>
## lib/capper
* [lib/capper](#module_lib/capper)
* [~Capper](#module_lib/capper..Capper)
* [.init()](#module_lib/capper..Capper+init)
* [.listen()](#module_lib/capper..Capper+listen)
* [.capper()](#module_lib/capper..Capper+capper)
* [.listener()](#module_lib/capper..Capper+listener)
* [.end()](#module_lib/capper..Capper+end)
<a name="module_lib/capper..Capper"></a>
### lib/capper~Capper
Class representing capper functions.
**Kind**: inner class of [<code>lib/capper</code>](#module_lib/capper)
* [~Capper](#module_lib/capper..Capper)
* [.init()](#module_lib/capper..Capper+init)
* [.listen()](#module_lib/capper..Capper+listen)
* [.capper()](#module_lib/capper..Capper+capper)
* [.listener()](#module_lib/capper..Capper+listener)
* [.end()](#module_lib/capper..Capper+end)
<a name="module_lib/capper..Capper+init"></a>
#### capper.init()
**Kind**: instance method of [<code>Capper</code>](#module_lib/capper..Capper)
<a name="module_lib/capper..Capper+listen"></a>
#### capper.listen()
**Kind**: instance method of [<code>Capper</code>](#module_lib/capper..Capper)
<a name="module_lib/capper..Capper+capper"></a>
#### capper.capper()
**Kind**: instance method of [<code>Capper</code>](#module_lib/capper..Capper)
<a name="module_lib/capper..Capper+listener"></a>
#### capper.listener()
**Kind**: instance method of [<code>Capper</code>](#module_lib/capper..Capper)
<a name="module_lib/capper..Capper+end"></a>
#### capper.end()
**Kind**: instance method of [<code>Capper</code>](#module_lib/capper..Capper)

45
app/lib/capper/index.d.ts vendored Normal file
View File

@ -0,0 +1,45 @@
import type { FilmOut } from 'filmout';
import type { Arduino } from 'arduino';
import type { WebContents } from 'electron';
interface CapperState {
capper: boolean;
}
/** @module lib/capper */
/**
* Class representing capper functions.
*/
export declare class Capper {
private state;
private arduino;
private log;
private cfg;
private filmout;
private ui;
private ipc;
private id;
/**
*
**/
constructor(arduino: Arduino, cfg: any, ui: WebContents, filmout: FilmOut);
/**
*
**/
private init;
/**
*
**/
private listen;
/**
*
**/
capper(state: boolean, id: string): Promise<number>;
/**
*
**/
private listener;
/**
*
**/
private end;
}
export type { CapperState };

94
app/lib/capper/index.js Normal file
View File

@ -0,0 +1,94 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Capper = void 0;
const electron_1 = require("electron");
const log_1 = require("log");
/** @module lib/capper */
/**
* Class representing capper functions.
*/
class Capper {
/**
*
**/
constructor(arduino, cfg, ui, filmout) {
this.state = {
capper: false
};
this.arduino = null;
this.ipc = electron_1.ipcMain;
this.id = 'capper';
this.arduino = arduino;
this.cfg = cfg;
this.ui = ui;
this.filmout = filmout;
this.init();
}
/**
*
**/
async init() {
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
*
**/
listen() {
this.ipc.on(this.id, this.listener.bind(this));
}
/**
*
**/
async capper(state, id) {
let cmd;
let ms;
if (state) {
cmd = this.cfg.arduino.cmd[`${this.id}_on`];
}
else {
cmd = this.cfg.arduino.cmd[`${this.id}_off`];
}
this.state.capper = state;
try {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(err);
}
return await this.end(cmd, id, ms);
}
/**
*
**/
async listener(event, arg) {
if (typeof arg.state !== 'undefined') {
try {
await this.capper(arg.state, arg.id);
}
catch (err) {
this.log.error(err);
}
}
event.returnValue = true;
}
/**
*
**/
async end(cmd, id, ms) {
let message = '';
if (cmd === this.cfg.arduino.cmd.capper_on) {
message = 'Capper set to ON';
}
else if (cmd === this.cfg.arduino.cmd.capper_off) {
message = 'Capper set to OFF';
}
message += ` ${ms}ms`;
this.log.info(message);
await this.ui.send(this.id, { cmd: cmd, id: id, ms: ms });
return ms;
}
}
exports.Capper = Capper;
module.exports = { Capper };
//# sourceMappingURL=index.js.map

View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/capper/index.ts"],"names":[],"mappings":"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"}

30
app/lib/cfg/index.d.ts vendored Normal file
View File

@ -0,0 +1,30 @@
interface ConfigCommands {
[key: string]: string;
}
interface ConfigDeviceProfile {
time: number;
delay: number;
momentary: number;
}
interface ConfigBlackProfile {
before: number;
after: number;
}
interface ConfigProfile {
label: string;
cam: ConfigDeviceProfile;
proj?: ConfigDeviceProfile;
black?: ConfigBlackProfile;
light: boolean;
}
interface ConfigProfiles {
[key: string]: ConfigProfile;
}
interface Config {
version: string;
ext_port: number;
profiles: ConfigProfiles;
cmd: ConfigCommands;
arduino: any;
}
export type { Config };

3
app/lib/cfg/index.js Normal file
View File

@ -0,0 +1,3 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
//# sourceMappingURL=index.js.map

1
app/lib/cfg/index.js.map Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cfg/index.ts"],"names":[],"mappings":""}

287
app/lib/client/index.js Normal file

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,267 @@
<a name="module_lib/cmd"></a>
## lib/cmd
* [lib/cmd](#module_lib/cmd)
* [~Assign all connected devices and mock devices as private classes.](#module_lib/cmd..Assign all connected devices and mock devices as private classes.)
* [new Assign all connected devices and mock devices as private classes.(cfg, proj, cam, light, alert, cam2, proj2, capper)](#new_module_lib/cmd..Assign all connected devices and mock devices as private classes._new)
* [~Commands](#module_lib/cmd..Commands)
* [.projector_forward()](#module_lib/cmd..Commands+projector_forward) ⇒ <code>integer</code>
* [.projector_backward()](#module_lib/cmd..Commands+projector_backward) ⇒ <code>integer</code>
* [.camera_forward(cmd)](#module_lib/cmd..Commands+camera_forward) ⇒ <code>integer</code>
* [.black_forward()](#module_lib/cmd..Commands+black_forward) ⇒ <code>integer</code>
* [.camera_backward(cmd)](#module_lib/cmd..Commands+camera_backward) ⇒ <code>integer</code>
* [.black_backward()](#module_lib/cmd..Commands+black_backward) ⇒ <code>integer</code>
* [.camera_second_forward(cmd)](#module_lib/cmd..Commands+camera_second_forward) ⇒ <code>integer</code>
* [.camera_second_backward(cmd)](#module_lib/cmd..Commands+camera_second_backward) ⇒ <code>integer</code>
* [.cameras_forward(cmd)](#module_lib/cmd..Commands+cameras_forward) ⇒ <code>integer</code>
* [.cameras_backward(cmd)](#module_lib/cmd..Commands+cameras_backward) ⇒ <code>integer</code>
* [.camera_forward_camera_second_backward(cmd)](#module_lib/cmd..Commands+camera_forward_camera_second_backward) ⇒ <code>integer</code>
* [.camera_backward_camera_second_forward(cmd)](#module_lib/cmd..Commands+camera_backward_camera_second_forward) ⇒ <code>integer</code>
* [.projector_second_forward()](#module_lib/cmd..Commands+projector_second_forward) ⇒ <code>integer</code>
* [.projector_second_backward()](#module_lib/cmd..Commands+projector_second_backward) ⇒ <code>integer</code>
* [.projectors_forward()](#module_lib/cmd..Commands+projectors_forward) ⇒ <code>integer</code>
* [.projectors_backward()](#module_lib/cmd..Commands+projectors_backward) ⇒ <code>integer</code>
* [.projector_forward_projector_second_backward()](#module_lib/cmd..Commands+projector_forward_projector_second_backward) ⇒ <code>integer</code>
* [.projector_backward_projector_second_forward()](#module_lib/cmd..Commands+projector_backward_projector_second_forward) ⇒ <code>integer</code>
* [.alert()](#module_lib/cmd..Commands+alert) ⇒ <code>integer</code>
* [.pause()](#module_lib/cmd..Commands+pause) ⇒ <code>integer</code>
* [.camera_exposure()](#module_lib/cmd..Commands+camera_exposure)
<a name="module_lib/cmd..Assign all connected devices and mock devices as private classes."></a>
### lib/cmd~Assign all connected devices and mock devices as private classes.
**Kind**: inner class of [<code>lib/cmd</code>](#module_lib/cmd)
<a name="new_module_lib/cmd..Assign all connected devices and mock devices as private classes._new"></a>
#### new Assign all connected devices and mock devices as private classes.(cfg, proj, cam, light, alert, cam2, proj2, capper)
| Param | Type | Description |
| --- | --- | --- |
| cfg | <code>object</code> | Configuration object |
| proj | <code>object</code> | Projector 1 |
| cam | <code>object</code> | Camera 1 |
| light | <code>object</code> | Light source |
| alert | <code>object</code> | Alert object |
| cam2 | <code>object</code> | (optional) Camera 2 |
| proj2 | <code>object</code> | (optional) Projector 2 |
| capper | <code>object</code> | Capper object |
<a name="module_lib/cmd..Commands"></a>
### lib/cmd~Commands
Class representing all commands bundled into methods.
**Kind**: inner class of [<code>lib/cmd</code>](#module_lib/cmd)
* [~Commands](#module_lib/cmd..Commands)
* [.projector_forward()](#module_lib/cmd..Commands+projector_forward) ⇒ <code>integer</code>
* [.projector_backward()](#module_lib/cmd..Commands+projector_backward) ⇒ <code>integer</code>
* [.camera_forward(cmd)](#module_lib/cmd..Commands+camera_forward) ⇒ <code>integer</code>
* [.black_forward()](#module_lib/cmd..Commands+black_forward) ⇒ <code>integer</code>
* [.camera_backward(cmd)](#module_lib/cmd..Commands+camera_backward) ⇒ <code>integer</code>
* [.black_backward()](#module_lib/cmd..Commands+black_backward) ⇒ <code>integer</code>
* [.camera_second_forward(cmd)](#module_lib/cmd..Commands+camera_second_forward) ⇒ <code>integer</code>
* [.camera_second_backward(cmd)](#module_lib/cmd..Commands+camera_second_backward) ⇒ <code>integer</code>
* [.cameras_forward(cmd)](#module_lib/cmd..Commands+cameras_forward) ⇒ <code>integer</code>
* [.cameras_backward(cmd)](#module_lib/cmd..Commands+cameras_backward) ⇒ <code>integer</code>
* [.camera_forward_camera_second_backward(cmd)](#module_lib/cmd..Commands+camera_forward_camera_second_backward) ⇒ <code>integer</code>
* [.camera_backward_camera_second_forward(cmd)](#module_lib/cmd..Commands+camera_backward_camera_second_forward) ⇒ <code>integer</code>
* [.projector_second_forward()](#module_lib/cmd..Commands+projector_second_forward) ⇒ <code>integer</code>
* [.projector_second_backward()](#module_lib/cmd..Commands+projector_second_backward) ⇒ <code>integer</code>
* [.projectors_forward()](#module_lib/cmd..Commands+projectors_forward) ⇒ <code>integer</code>
* [.projectors_backward()](#module_lib/cmd..Commands+projectors_backward) ⇒ <code>integer</code>
* [.projector_forward_projector_second_backward()](#module_lib/cmd..Commands+projector_forward_projector_second_backward) ⇒ <code>integer</code>
* [.projector_backward_projector_second_forward()](#module_lib/cmd..Commands+projector_backward_projector_second_forward) ⇒ <code>integer</code>
* [.alert()](#module_lib/cmd..Commands+alert) ⇒ <code>integer</code>
* [.pause()](#module_lib/cmd..Commands+pause) ⇒ <code>integer</code>
* [.camera_exposure()](#module_lib/cmd..Commands+camera_exposure)
<a name="module_lib/cmd..Commands+projector_forward"></a>
#### commands.projector\_forward() ⇒ <code>integer</code>
Move the projector one frame forward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projector_backward"></a>
#### commands.projector\_backward() ⇒ <code>integer</code>
Move the projector one frame backward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+camera_forward"></a>
#### commands.camera\_forward(cmd) ⇒ <code>integer</code>
Move the camera one frame forward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+black_forward"></a>
#### commands.black\_forward() ⇒ <code>integer</code>
Move the camera one frame forward with light off
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+camera_backward"></a>
#### commands.camera\_backward(cmd) ⇒ <code>integer</code>
Move the camera one frame backward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+black_backward"></a>
#### commands.black\_backward() ⇒ <code>integer</code>
Move the camera one frame forward, light set to black or off
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+camera_second_forward"></a>
#### commands.camera\_second\_forward(cmd) ⇒ <code>integer</code>
Move the second camera one frame forward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+camera_second_backward"></a>
#### commands.camera\_second\_backward(cmd) ⇒ <code>integer</code>
Move the second camera one frame backward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+cameras_forward"></a>
#### commands.cameras\_forward(cmd) ⇒ <code>integer</code>
Move the both cameras one frame forward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+cameras_backward"></a>
#### commands.cameras\_backward(cmd) ⇒ <code>integer</code>
Move the both cameras one frame backward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+camera_forward_camera_second_backward"></a>
#### commands.camera\_forward\_camera\_second\_backward(cmd) ⇒ <code>integer</code>
Move first camera one frame forward and rewind secondary camera one frame backward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+camera_backward_camera_second_forward"></a>
#### commands.camera\_backward\_camera\_second\_forward(cmd) ⇒ <code>integer</code>
Rewind first camera one frame backward and move secondary camera one frame forward
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>object</code> | Full cmd object |
<a name="module_lib/cmd..Commands+projector_second_forward"></a>
#### commands.projector\_second\_forward() ⇒ <code>integer</code>
Move the secondary projector forward one frame
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projector_second_backward"></a>
#### commands.projector\_second\_backward() ⇒ <code>integer</code>
Rewind the secondary projector backward one frame
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projectors_forward"></a>
#### commands.projectors\_forward() ⇒ <code>integer</code>
Move the both projectors forward one frame
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projectors_backward"></a>
#### commands.projectors\_backward() ⇒ <code>integer</code>
Rewind both projectors backwards one frame
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projector_forward_projector_second_backward"></a>
#### commands.projector\_forward\_projector\_second\_backward() ⇒ <code>integer</code>
Move the primary projector forward one frame and rewind the secondary projector
one frame backwards.
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+projector_backward_projector_second_forward"></a>
#### commands.projector\_backward\_projector\_second\_forward() ⇒ <code>integer</code>
Rewind the primary projector backwards one frame and move the secondary
projector forward one frame.
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+alert"></a>
#### commands.alert() ⇒ <code>integer</code>
Throws an alert to pause a sequence
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+pause"></a>
#### commands.pause() ⇒ <code>integer</code>
Pauses a sequence for a length of time
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)
**Returns**: <code>integer</code> - Length of action in ms
<a name="module_lib/cmd..Commands+camera_exposure"></a>
#### commands.camera\_exposure()
Sets the camera exposure (if supported).
**Kind**: instance method of [<code>Commands</code>](#module_lib/cmd..Commands)

179
app/lib/cmd/index.d.ts vendored Normal file
View File

@ -0,0 +1,179 @@
import type { Projector } from 'proj';
import type { Camera } from 'cam';
import type { Light } from 'light';
import type { Capper } from 'capper';
import type { Alert } from 'alert';
import type { Config } from 'cfg';
/** @module lib/cmd */
/**
* Class representing all commands bundled into methods.
*/
export declare class Commands {
proj: Projector;
cam: Camera;
light: Light;
cam2: Camera;
proj2: Projector;
capper: Capper;
alertObj: Alert;
private cfg;
private ipc;
/**
* @constructor
* Assign all connected devices and mock devices as private classes.
*
* @param {object} cfg Configuration object
* @param {object} proj Projector 1
* @param {object} cam Camera 1
* @param {object} light Light source
* @param {object} alert Alert object
* @param {object} cam2 (optional) Camera 2
* @param {object} proj2 (optional) Projector 2
* @param {object} capper Capper object
*
**/
constructor(cfg: Config, proj: Projector, cam: Camera, light: Light, alert: Alert, cam2?: Camera, proj2?: Projector, capper?: Capper);
/**
* Move the projector one frame forward
*
* @returns {integer} Length of action in ms
**/
projector_forward(): Promise<number>;
/**
* Move the projector one frame backward
*
* @returns {integer} Length of action in ms
**/
projector_backward(): Promise<number>;
/**
* Move the camera one frame forward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_forward(): Promise<number>;
/**
* Move the camera one frame forward with light off
*
* @returns {integer} Length of action in ms
**/
black_forward(): Promise<number>;
/**
* Move the camera one frame backward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_backward(): Promise<number>;
/**
* Move the camera one frame forward, light set to black or off
*
* @returns {integer} Length of action in ms
**/
black_backward(): Promise<number>;
/**
* Move the second camera one frame forward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_second_forward(): Promise<number>;
/**
* Move the second camera one frame backward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_second_backward(): Promise<number>;
/**
* Move the both cameras one frame forward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
cameras_forward(): Promise<number>;
/**
* Move the both cameras one frame backward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
cameras_backward(): Promise<number>;
/**
* Move first camera one frame forward and rewind secondary camera one frame backward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_forward_camera_second_backward(): Promise<number>;
/**
* Rewind first camera one frame backward and move secondary camera one frame forward
*
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
camera_backward_camera_second_forward(): Promise<number>;
/**
* Move the secondary projector forward one frame
*
* @returns {integer} Length of action in ms
**/
projector_second_forward(): Promise<number>;
/**
* Rewind the secondary projector backward one frame
*
* @returns {integer} Length of action in ms
**/
projector_second_backward(): Promise<number>;
/**
* Move the both projectors forward one frame
*
* @returns {integer} Length of action in ms
**/
projectors_forward(): Promise<number>;
/**
* Rewind both projectors backwards one frame
*
* @returns {integer} Length of action in ms
**/
projectors_backward(): Promise<number>;
/**
* Move the primary projector forward one frame and rewind the secondary projector
* one frame backwards.
*
* @returns {integer} Length of action in ms
**/
projector_forward_projector_second_backward(): Promise<number>;
/**
* Rewind the primary projector backwards one frame and move the secondary
* projector forward one frame.
*
* @returns {integer} Length of action in ms
**/
projector_backward_projector_second_forward(): Promise<number>;
/**
* Throws an alert to pause a sequence
*
* @returns {integer} Length of action in ms
**/
alert(cmd: any): Promise<number>;
/**
* Pauses a sequence for a length of time
*
* @returns {integer} Length of action in ms
**/
pause(cmd: any): Promise<number>;
/**
* Sets the camera exposure (if supported).
*
**/
camera_exposure(cmd: any): Promise<number>;
}

View File

@ -1,6 +1,13 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Commands = void 0;
const electron_1 = require("electron");
const uuid_1 = require("uuid");
const delay_1 = require("delay");
/** @module lib/cmd */
/**
* Class representing all commands bundled into methods.
*/
class Commands {
/**
* @constructor
@ -10,19 +17,25 @@ class Commands {
* @param {object} proj Projector 1
* @param {object} cam Camera 1
* @param {object} light Light source
* @param {object} alert Alert object
* @param {object} cam2 (optional) Camera 2
* @param {object} proj2 {optional} Projector 2
* @param {object} proj2 (optional) Projector 2
* @param {object} capper Capper object
*
**/
constructor(cfg, proj, cam, light, cam2 = null, proj2 = null) {
constructor(cfg, proj, cam, light, alert, cam2 = null, proj2 = null, capper = null) {
this.ipc = electron_1.ipcMain;
this.cfg = cfg;
this.proj = proj;
this.cam = cam;
this.light = light;
if (cam2)
this.alertObj = alert;
if (cam2 !== null)
this.cam2 = cam2;
if (proj2)
if (proj2 !== null)
this.proj2 = proj2;
this.ipc = require('electron').ipcMain;
if (capper !== null)
this.capper = capper;
}
/**
* Move the projector one frame forward
@ -30,14 +43,15 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_forward() {
const id = (0, uuid_1.v4)();
let ms;
try {
if (!this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.proj.move();
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.proj.move(id);
}
catch (err) {
throw err;
@ -50,14 +64,15 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_backward() {
const id = (0, uuid_1.v4)();
let ms;
try {
if (this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.proj.move();
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.proj.move(id);
}
catch (err) {
throw err;
@ -67,24 +82,26 @@ class Commands {
/**
* Move the camera one frame forward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_forward(rgb = [255, 255, 255]) {
async camera_forward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let ms;
try {
if (!this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.cam.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -97,19 +114,27 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async black_forward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let ms;
let ms = 0;
try {
if (!this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(true, id);
}
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.capper) {
ms += await this.capper.capper(true, id);
}
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id); //make sure set to off
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms += await this.cam.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
if (this.capper) {
ms += await this.capper.capper(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off); //make sure set to off
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
}
catch (err) {
throw err;
@ -119,24 +144,26 @@ class Commands {
/**
* Move the camera one frame backward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_backward(rgb = [255, 255, 255]) {
async camera_backward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let ms;
try {
if (this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.cam.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -149,19 +176,26 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async black_backward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let ms;
let ms = 0;
try {
if (this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(false, id);
}
if (this.capper) {
ms += await this.capper.capper(true, id);
}
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id); //make sure set to off
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms += await this.cam.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
if (this.capper) {
ms += await this.capper.capper(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off); //make sure set to off
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
}
catch (err) {
throw err;
@ -171,24 +205,26 @@ class Commands {
/**
* Move the second camera one frame forward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_second_forward(rgb = [255, 255, 255]) {
async camera_second_forward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let ms;
try {
if (!this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam2.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.cam2.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -198,24 +234,26 @@ class Commands {
/**
* Move the second camera one frame backward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_second_backward(rgb = [255, 255, 255]) {
async camera_second_backward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let ms;
try {
if (this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.cam2.move();
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.cam2.move(id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -225,37 +263,37 @@ class Commands {
/**
* Move the both cameras one frame forward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async cameras_forward(rgb = [255, 255, 255]) {
async cameras_forward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let both;
let ms;
try {
if (!this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(true, id);
}
if (!this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.cam && this.cam2 && this.cam.arduino.alias.camera === this.cam.arduino.alias.camera_second) {
ms = await this.cam.both();
ms = await this.cam.both(id);
}
else {
this.cam.move();
this.cam2.move();
both = [await this.cam.move, await this.cam2.move];
both = await Promise.all([this.cam.move(id), this.cam2.move(id)]);
ms = Math.max(...both);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -265,37 +303,37 @@ class Commands {
/**
* Move the both cameras one frame backward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async cameras_backward(rgb = [255, 255, 255]) {
async cameras_backward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let both;
let ms;
try {
if (this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(false, id);
}
if (this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.cam && this.cam2 && this.cam.arduino.alias.camera === this.cam.arduino.alias.camera_second) {
ms = await this.cam.both();
ms = await this.cam.both(id);
}
else {
this.cam.move();
this.cam2.move();
both = [await this.cam.move, await this.cam2.move];
both = await Promise.all([this.cam.move(id), this.cam2.move(id)]);
ms = Math.max(...both);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -305,37 +343,37 @@ class Commands {
/**
* Move first camera one frame forward and rewind secondary camera one frame backward
*
* @param {array} rgb Color to set light for frames
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_forward_camera_second_backward(rgb = [255, 255, 255]) {
async camera_forward_camera_second_backward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let both;
let ms;
try {
if (!this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(true, id);
}
if (this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.cam && this.cam2 && this.cam.arduino.alias.camera === this.cam.arduino.alias.camera_second) {
ms = await this.cam.both();
ms = await this.cam.both(id);
}
else {
this.cam.move();
this.cam2.move();
both = [await this.cam.move, await this.cam2.move];
both = await Promise.all([this.cam.move(id), this.cam2.move(id)]);
ms = Math.max(...both);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -345,37 +383,37 @@ class Commands {
/**
* Rewind first camera one frame backward and move secondary camera one frame forward
*
* @param {array} rgb Color to set light for frame
* @param {object} cmd Full cmd object
*
* @returns {integer} Length of action in ms
**/
async camera_backward_camera_second_forward(rgb = [255, 255, 255]) {
async camera_backward_camera_second_forward() {
const id = (0, uuid_1.v4)();
const off = [0, 0, 0];
let rgb = [255, 255, 255];
let both;
let ms;
try {
if (this.cam.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam.set(false, id);
}
if (!this.cam2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.cam2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.cam2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(rgb);
await delay_1.delay(this.cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(rgb, id);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.cam && this.cam2 && this.cam.arduino.alias.camera === this.cam.arduino.alias.camera_second) {
ms = await this.cam.both();
ms = await this.cam.both(id);
}
else {
this.cam.move();
this.cam.move();
both = [await this.cam.move, await this.proj2.move];
both = await Promise.all([this.cam.move(id), this.cam2.move(id)]);
ms = Math.max(...both);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.light.set(off);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.light.set(off, id);
}
catch (err) {
throw err;
@ -388,14 +426,15 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_second_forward() {
const id = (0, uuid_1.v4)();
let ms;
try {
if (!this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.proj2.move();
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.proj2.move(id);
}
catch (err) {
throw err;
@ -408,14 +447,15 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_second_backward() {
const id = (0, uuid_1.v4)();
let ms;
try {
if (this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
ms = await this.proj2.move();
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
ms = await this.proj2.move(id);
}
catch (err) {
throw err;
@ -428,25 +468,24 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projectors_forward() {
const id = (0, uuid_1.v4)();
let both;
let ms;
try {
if (!this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(true, id);
}
if (!this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.proj && this.proj2 && this.proj.arduino.alias.projector === this.proj.arduino.alias.projector_second) {
ms = await this.proj.both();
ms = await this.proj.both(id);
}
else {
this.proj.move();
this.proj2.move();
both = [await this.proj.move, await this.proj2.move];
both = await Promise.all([this.proj.move(id), this.proj2.move(id)]);
ms = Math.max(...both);
}
}
@ -461,26 +500,24 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projectors_backward() {
const id = (0, uuid_1.v4)();
let both;
let ms;
try {
if (this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(false, id);
}
if (this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
//run one projector without await?
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.proj && this.proj2 && this.proj.arduino.alias.projector === this.proj.arduino.alias.projector_second) {
ms = await this.proj.both();
ms = await this.proj.both(id);
}
else {
this.proj.move();
this.proj2.move();
both = [await this.proj.move, await this.proj2.move];
both = await Promise.all([this.proj.move(id), this.proj2.move(id)]);
ms = Math.max(...both);
}
}
@ -496,26 +533,24 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_forward_projector_second_backward() {
const id = (0, uuid_1.v4)();
let both;
let ms;
try {
if (!this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(true, id);
}
if (this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(false, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
//run one projector without await?
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.proj && this.proj2 && this.proj.arduino.alias.projector === this.proj.arduino.alias.projector_second) {
ms = await this.proj.both();
ms = await this.proj.both(id);
}
else {
this.proj.move();
this.proj2.move();
both = [await this.proj.move, await this.proj2.move];
both = await Promise.all([this.proj.move(id), this.proj2.move(id)]);
ms = Math.max(...both);
}
}
@ -531,26 +566,24 @@ class Commands {
* @returns {integer} Length of action in ms
**/
async projector_backward_projector_second_forward() {
const id = (0, uuid_1.v4)();
let both;
let ms;
try {
if (this.proj.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj.set(false);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj.set(false, id);
}
if (!this.proj2.state.dir) {
await delay_1.delay(this.cfg.arduino.serialDelay);
await this.proj2.set(true);
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
await this.proj2.set(true, id);
}
await delay_1.delay(this.cfg.arduino.serialDelay);
//run one projector without await?
await (0, delay_1.delay)(this.cfg.arduino.serialDelay);
if (this.proj && this.proj2 && this.proj.arduino.alias.projector === this.proj.arduino.alias.projector_second) {
ms = await this.proj.both();
ms = await this.proj.both(id);
}
else {
this.proj.move();
this.proj2.move();
both = [await this.proj.move, await this.proj2.move];
both = await Promise.all([this.proj.move(id), this.proj2.move(id)]);
ms = Math.max(...both);
}
}
@ -559,8 +592,54 @@ class Commands {
}
return ms;
}
/**
* Throws an alert to pause a sequence
*
* @returns {integer} Length of action in ms
**/
async alert(cmd) {
const id = (0, uuid_1.v4)();
let ms;
try {
ms = await this.alertObj.start(cmd.light); //change this meta
}
catch (err) {
throw err;
}
return ms;
}
/**
* Pauses a sequence for a length of time
*
* @returns {integer} Length of action in ms
**/
async pause(cmd) {
const id = (0, uuid_1.v4)();
let ms;
try {
ms = await (0, delay_1.delay)(cmd.light * 1000); //delay is in seconds
}
catch (err) {
throw err;
}
return ms;
}
/**
* Sets the camera exposure (if supported).
*
**/
async camera_exposure(cmd) {
const id = (0, uuid_1.v4)();
let ms;
try {
ms = await this.cam.exposure(cmd.light, id);
}
catch (err) {
throw err;
}
return ms;
}
}
module.exports = function (cfg, proj, cam, light, cam2, proj2) {
return new Commands(cfg, proj, cam, light, cam2, proj2);
};
exports.Commands = Commands;
module.exports = { Commands };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

8
app/lib/delay/index.d.ts vendored Normal file
View File

@ -0,0 +1,8 @@
/**
* Delay in an async/await function
*
* @param {integer} ms Milliseconds to delay for
*
* @returns {Promise} Promise to resolve after timeout
**/
export declare function delay(ms: number): Promise<number>;

View File

@ -1,4 +1,6 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.delay = void 0;
/**
* Delay in an async/await function
*
@ -8,8 +10,9 @@
**/
function delay(ms) {
return new Promise((resolve) => {
return setTimeout(resolve, ms);
return setTimeout(() => { resolve(ms); }, ms);
});
}
module.exports.delay = delay;
exports.delay = delay;
module.exports = { delay };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/delay/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb;;;;;;IAMI;AAEJ,SAAS,KAAK,CAAE,EAAW;IAC1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAa,EAAE,EAAE;QACpC,OAAO,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAChC,CAAC,CAAC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/delay/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;AAEb;;;;;;IAMI;AAEJ,SAAgB,KAAK,CAAE,EAAW;IACjC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAa,EAAE,EAAE;QACpC,OAAO,UAAU,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAAA,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACJ,CAAC;AAJD,sBAIC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,KAAK,EAAE,CAAC"}

View File

@ -1,74 +1,116 @@
<a name="Devices"></a>
<a name="module_lib/devices"></a>
## Devices
class representing the device discovery features
## lib/devices
**Kind**: global class
* [lib/devices](#module_lib/devices)
* [~Devices](#module_lib/devices..Devices)
* [new Devices()](#new_module_lib/devices..Devices_new)
* [.init()](#module_lib/devices..Devices+init)
* [.listen()](#module_lib/devices..Devices+listen)
* [.listener()](#module_lib/devices..Devices+listener)
* [.enumerate()](#module_lib/devices..Devices+enumerate)
* [.favor()](#module_lib/devices..Devices+favor)
* [.distinguish()](#module_lib/devices..Devices+distinguish)
* [.fakeProjector()](#module_lib/devices..Devices+fakeProjector)
* [.fakeCamera()](#module_lib/devices..Devices+fakeCamera)
* [.fakeLight()](#module_lib/devices..Devices+fakeLight)
* [.fakeCapper()](#module_lib/devices..Devices+fakeCapper)
* [.connectDevice()](#module_lib/devices..Devices+connectDevice)
* [.all()](#module_lib/devices..Devices+all)
* [.remember()](#module_lib/devices..Devices+remember)
* [.ready()](#module_lib/devices..Devices+ready)
* [Devices](#Devices)
* [.init()](#Devices+init)
* [.listen()](#Devices+listen)
* [.listener()](#Devices+listener)
* [.enumerate()](#Devices+enumerate)
* [.favor()](#Devices+favor)
* [.distinguish()](#Devices+distinguish)
* [.fakeProjector()](#Devices+fakeProjector)
* [.fakeCamera()](#Devices+fakeCamera)
* [.fakeLight()](#Devices+fakeLight)
* [.connectDevice()](#Devices+connectDevice)
* [.all()](#Devices+all)
* [.remember()](#Devices+remember)
* [.ready()](#Devices+ready)
<a name="module_lib/devices..Devices"></a>
<a name="Devices+init"></a>
### lib/devices~Devices
Class representing the device discovery features.
### devices.init()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+listen"></a>
**Kind**: inner class of [<code>lib/devices</code>](#module_lib/devices)
### devices.listen()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+listener"></a>
* [~Devices](#module_lib/devices..Devices)
* [new Devices()](#new_module_lib/devices..Devices_new)
* [.init()](#module_lib/devices..Devices+init)
* [.listen()](#module_lib/devices..Devices+listen)
* [.listener()](#module_lib/devices..Devices+listener)
* [.enumerate()](#module_lib/devices..Devices+enumerate)
* [.favor()](#module_lib/devices..Devices+favor)
* [.distinguish()](#module_lib/devices..Devices+distinguish)
* [.fakeProjector()](#module_lib/devices..Devices+fakeProjector)
* [.fakeCamera()](#module_lib/devices..Devices+fakeCamera)
* [.fakeLight()](#module_lib/devices..Devices+fakeLight)
* [.fakeCapper()](#module_lib/devices..Devices+fakeCapper)
* [.connectDevice()](#module_lib/devices..Devices+connectDevice)
* [.all()](#module_lib/devices..Devices+all)
* [.remember()](#module_lib/devices..Devices+remember)
* [.ready()](#module_lib/devices..Devices+ready)
### devices.listener()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+enumerate"></a>
<a name="new_module_lib/devices..Devices_new"></a>
### devices.enumerate()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+favor"></a>
#### new Devices()
Constructor assigns arduino, settings, UI browser window and cam objects
locally to this class for reference.
### devices.favor()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+distinguish"></a>
<a name="module_lib/devices..Devices+init"></a>
### devices.distinguish()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+fakeProjector"></a>
#### devices.init()
Initialize the log for "devices". Establish an ipc connection to the UI.
Start listening on that ipc connection.
### devices.fakeProjector()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+fakeCamera"></a>
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+listen"></a>
### devices.fakeCamera()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+fakeLight"></a>
#### devices.listen()
Listen to the "profile" channel for messages from the UI.
### devices.fakeLight()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+connectDevice"></a>
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+listener"></a>
### devices.connectDevice()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+all"></a>
#### devices.listener()
The "profile" channel callback. If a profile is changed, set it in the
local settings object.
### devices.all()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+remember"></a>
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+enumerate"></a>
### devices.remember()
**Kind**: instance method of [<code>Devices</code>](#Devices)
<a name="Devices+ready"></a>
#### devices.enumerate()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+favor"></a>
### devices.ready()
**Kind**: instance method of [<code>Devices</code>](#Devices)
#### devices.favor()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+distinguish"></a>
#### devices.distinguish()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+fakeProjector"></a>
#### devices.fakeProjector()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+fakeCamera"></a>
#### devices.fakeCamera()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+fakeLight"></a>
#### devices.fakeLight()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+fakeCapper"></a>
#### devices.fakeCapper()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+connectDevice"></a>
#### devices.connectDevice()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+all"></a>
#### devices.all()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+remember"></a>
#### devices.remember()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)
<a name="module_lib/devices..Devices+ready"></a>
#### devices.ready()
**Kind**: instance method of [<code>Devices</code>](#module_lib/devices..Devices)

84
app/lib/devices/index.d.ts vendored Normal file
View File

@ -0,0 +1,84 @@
import type { Settings } from 'settings';
import type { Arduino } from 'arduino';
import type { BrowserWindow } from 'electron';
interface Device {
serial: string;
device: string;
}
/** @module lib/devices */
/**
* Class representing the device discovery features.
*/
export declare class Devices {
settings: Settings;
connected: any;
private arduino;
private log;
private ui;
private ipc;
private mainWindow;
/**
* Constructor assigns arduino, settings, UI browser window and cam objects
* locally to this class for reference.
**/
constructor(arduino: Arduino, settings: Settings, mainWindow: BrowserWindow);
/**
* Initialize the log for "devices". Establish an ipc connection to the UI.
* Start listening on that ipc connection.
**/
private init;
/**
* Listen to the "profile" channel for messages from the UI.
**/
private listen;
/**
* The "profile" channel callback. If a profile is changed, set it in the
* local settings object.
**/
private listener;
/**
*
**/
enumerate(): Promise<boolean>;
/**
*
**/
private favor;
/**
*
**/
private distinguish;
/**
*
**/
private fakeProjector;
/**
*
**/
private fakeCamera;
/**
*
**/
private fakeLight;
/**
*
**/
private fakeCapper;
/**
*
**/
private connectDevice;
/**
*
**/
private all;
/**
*
**/
private remember;
/**
*
**/
private ready;
}
export type { Device };

View File

@ -1,24 +1,25 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Devices = void 0;
const electron_1 = require("electron");
const delay_1 = require("delay");
const Log = require("log");
const log_1 = require("log");
/** @module lib/devices */
/**
* class representing the device discovery features
*
*
**/
* Class representing the device discovery features.
*/
class Devices {
/**
* Constructor assigns arduino, settings, UI browser window and cam objects
* locally to this class for reference.
**/
constructor(arduino, settings, mainWindow, cam) {
constructor(arduino, settings, mainWindow) {
this.connected = {};
this.ipc = electron_1.ipcMain;
this.arduino = arduino;
this.settings = settings;
this.mainWindow = mainWindow;
this.ui = this.mainWindow.webContents;
this.cam = cam;
this.init();
}
/**
@ -26,57 +27,64 @@ class Devices {
* Start listening on that ipc connection.
**/
async init() {
this.log = await Log({ label: 'devices' });
this.ipc = require('electron').ipcMain;
this.log = await (0, log_1.Log)({ label: 'devices' });
this.listen();
}
/**
* Listen to the "profile" channel for messages from the UI.
**/
listen() {
this.ipc.on('profile', this.listener.bind(this));
this.ipc.handle('profile', this.listener.bind(this));
}
/**
* The "profile" channel callback. If a profile is changed, set it in the
* local settings object.
**/
listener(event, arg) {
this.log.info(`Saving profile ${arg.profile}`, 'SETTINGS', false, false);
this.settings.update('profile', arg.profile);
this.settings.save();
async listener(event, arg) {
if (typeof arg.profile !== 'undefined') {
this.log.info(`Saving profile ${arg.profile}`, 'SETTINGS', false, false);
this.settings.update('profile', arg.profile);
await this.settings.save();
}
if (typeof arg.timing !== 'undefined') {
this.log.info(`Saving timing info`, 'SETTINGS', false, false);
this.settings.update('timing', arg.timing);
await this.settings.save();
}
return true;
}
/**
*
**/
async enumerate() {
let devices;
let serials;
try {
devices = await this.arduino.enumerate();
serials = await this.arduino.enumerate();
}
catch (err) {
this.log.warn(err, 'SERIAL', false, true);
await delay_1.delay(1000);
await (0, delay_1.delay)(1000);
return this.all([]);
}
this.log.info(`Found ${devices.length} USB devices`, 'SERIAL', true, true);
devices = this.favor(devices);
return await this.all(devices);
this.log.info(`Found ${serials.length} USB devices`, 'SERIAL', true, true);
serials = this.favor(serials);
return await this.all(serials);
}
/**
*
**/
favor(devices) {
favor(serials) {
const past = this.settings.state.devices.filter((device) => {
if (device.arduino) {
if (device.serial) {
return device;
}
}).map((device) => {
return device.arduino;
return device.serial;
});
if (past.length === 0) {
return devices;
return serials;
}
devices.sort((a, b) => {
serials.sort((a, b) => {
if (past.indexOf(a) !== -1 && past.indexOf(b) === -1) {
return 1;
}
@ -85,23 +93,24 @@ class Devices {
}
return 0;
});
return devices;
return serials;
}
/**
*
**/
async distinguish(device) {
async distinguish(serial) {
let connectSuccess;
let verifySuccess;
let type;
let device;
//this.log.info(`distinguish() ${serial}`)
try {
connectSuccess = await this.arduino.connect('connect', device, true);
connectSuccess = await this.arduino.connect('connect', serial, true);
}
catch (err) {
this.log.error('Error connecting', err);
return null;
}
await delay_1.delay(2000);
await (0, delay_1.delay)(2000);
try {
verifySuccess = await this.arduino.verify();
}
@ -109,18 +118,25 @@ class Devices {
this.log.error('Error verifying device', err);
return null;
}
this.log.info(`Verified ${device} as mcopy device`, 'SERIAL', true, true);
await delay_1.delay(1000);
this.log.info(`Verified ${serial} as mcopy device`, 'SERIAL', true, true);
await (0, delay_1.delay)(1000);
try {
type = await this.arduino.distinguish();
device = await this.arduino.distinguish();
}
catch (err) {
this.log.error('Error distinguishing device', err);
return null;
}
this.remember('arduino', device, type);
this.log.info(`Determined ${device} to be ${type}`, 'SERIAL', true, true);
return type;
this.remember(device, serial, 'arduino');
this.log.info(`Determined ${device} to be ${device}`, 'SERIAL', true, true);
await (0, delay_1.delay)(100);
try {
await this.arduino.state(device, true);
}
catch (err) {
this.log.error('Error checking state capability', err);
}
return device;
}
/**
*
@ -131,24 +147,24 @@ class Devices {
await this.arduino.fakeConnect('projector');
}
catch (err) {
console.error(err);
this.log.error(`Error connecting to fake PRONECTOR device`, 'SERIAL', true, true);
this.log.error(`Error connecting to fake PROjECTOR device`, 'SERIAL', true, true);
this.log.error(err);
return false;
}
this.log.info('Connected to fake PROJECTOR device', 'SERIAL', true, true);
return true;
}
/**
*
**/
*
**/
async fakeCamera() {
this.connected.camera = '/dev/fake';
try {
await this.arduino.fakeConnect('camera');
}
catch (err) {
console.error(err);
this.log.error(`Error connecting to fake CAMERA device`, 'SERIAL', true, true);
this.log.error(err);
return false;
}
this.log.info('Connected to fake CAMERA device', 'SERIAL', true, true);
@ -163,17 +179,33 @@ class Devices {
await this.arduino.fakeConnect('light');
}
catch (err) {
console.error(err);
this.log.error(`Error connecting to fake LIGHT device`, 'SERIAL', true, true);
this.log.error(err);
return false;
}
this.log.info('Connected to fake LIGHT device', 'SERIAL', true, true);
return true;
}
/**
*
**/
async connectDevice(device, type) {
*
**/
async fakeCapper() {
this.connected.capper = '/dev/fake';
try {
await this.arduino.fakeConnect('capper');
}
catch (err) {
this.log.error(`Error connecting to fake CAPPER device`, 'SERIAL', true, true);
this.log.error(err);
return false;
}
this.log.info('Connected to fake CAPPER device', 'SERIAL', true, true);
return true;
}
/**
*
**/
async connectDevice(device, serial) {
let closeSuccess;
let connectSuccess;
try {
@ -183,10 +215,10 @@ class Devices {
this.log.error('Error closing arduino connection', err);
return false;
}
if (type === 'projector') {
this.connected.projector = device;
if (device === 'projector') {
this.connected.projector = serial;
try {
connectSuccess = await this.arduino.connect('projector', device, false);
connectSuccess = await this.arduino.connect('projector', serial, false);
}
catch (err) {
this.log.error('Error connecting to projector', err);
@ -194,10 +226,10 @@ class Devices {
}
this.log.info(`Connected to ${device} as PROJECTOR`, 'SERIAL', true, true);
}
else if (type === 'camera') {
this.connected.camera = device;
else if (device === 'camera') {
this.connected.camera = serial;
try {
connectSuccess = await this.arduino.connect('camera', device, false);
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera', err);
@ -205,10 +237,10 @@ class Devices {
}
this.log.info(`Connected to ${device} as CAMERA`, 'SERIAL', true, true);
}
else if (type === 'light') {
this.connected.light = device;
else if (device === 'light') {
this.connected.light = serial;
try {
connectSuccess = await this.arduino.connect('light', device, false);
connectSuccess = await this.arduino.connect('light', serial, false);
}
catch (err) {
this.log.error('Error connecting to light', err);
@ -216,12 +248,12 @@ class Devices {
}
this.log.info(`Connected to ${device} as LIGHT`, 'SERIAL', true, true);
}
else if (type === 'projector,light') {
this.connected.projector = device;
this.connected.light = device;
this.arduino.aliasSerial('light', device);
else if (device === 'projector,light') {
this.connected.projector = serial;
this.connected.light = serial;
this.arduino.aliasSerial('light', serial);
try {
connectSuccess = await this.arduino.connect('projector', device, false);
connectSuccess = await this.arduino.connect('projector', serial, false);
}
catch (err) {
this.log.error('Error connecting to projector and light', err);
@ -229,14 +261,14 @@ class Devices {
}
this.log.info(`Connected to ${device} as PROJECTOR + LIGHT`, 'SERIAL', true, true);
}
else if (type === 'projector,camera,light') {
this.connected.projector = device;
this.connected.camera = device;
this.connected.light = device;
this.arduino.aliasSerial('camera', device);
this.arduino.aliasSerial('light', device);
else if (device === 'projector,camera,light') {
this.connected.projector = serial;
this.connected.camera = serial;
this.connected.light = serial;
this.arduino.aliasSerial('camera', serial);
this.arduino.aliasSerial('light', serial);
try {
connectSuccess = await this.arduino.connect('projector', device, false);
connectSuccess = await this.arduino.connect('projector', serial, false);
}
catch (err) {
this.log.error('Error connecting to projector, camera and light', err);
@ -244,12 +276,12 @@ class Devices {
}
this.log.info(`Connected to ${device} as PROJECTOR + CAMERA + LIGHT`, 'SERIAL', true, true);
}
else if (type === 'projector,camera') {
this.connected.projector = device;
this.connected.camera = device;
this.arduino.aliasSerial('camera', device);
else if (device === 'projector,camera') {
this.connected.projector = serial;
this.connected.camera = serial;
this.arduino.aliasSerial('camera', serial);
try {
connectSuccess = await this.arduino.connect('projector', device, false);
connectSuccess = await this.arduino.connect('projector', serial, false);
}
catch (err) {
this.log.error('Error connecting to projector and camera', err);
@ -257,10 +289,10 @@ class Devices {
}
this.log.info(`Connected to ${device} as PROJECTOR + CAMERA`, 'SERIAL', true, true);
}
else if (type === 'projector_second') {
this.connected.projector_second = device;
else if (device === 'projector_second') {
this.connected.projector_second = serial;
try {
connectSuccess = await this.arduino.connect('projector_second', device, false);
connectSuccess = await this.arduino.connect('projector_second', serial, false);
}
catch (err) {
this.log.error('Error connecting to secondary projector', err);
@ -268,115 +300,171 @@ class Devices {
}
this.log.info(`Connected to ${device} as PROJECTOR_SECOND`, 'SERIAL', true, true);
}
else if (type === 'projector,projector_second') {
this.connected.projector = device;
this.connected.projector_second = device;
this.arduino.aliasSerial('projector_second', device);
else if (device === 'projector,projector_second') {
this.connected.projector = serial;
this.connected.projector_second = serial;
this.arduino.aliasSerial('projector_second', serial);
try {
connectSuccess = await this.arduino.connect('projector', device, false);
connectSuccess = await this.arduino.connect('projector', serial, false);
}
catch (err) {
this.log.error('Error connecting to projector and secondary projector', err);
return false;
}
}
else if (type === 'camera_second') {
this.connected.camera_second = device;
else if (device === 'camera_second') {
this.connected.camera_second = serial;
try {
connectSuccess = await this.arduino.connect('camera_second', device, false);
connectSuccess = await this.arduino.connect('camera_second', serial, false);
}
catch (err) {
console.error(err);
this.log.error(err);
return false;
}
}
else if (type === 'camera,camera_second') {
this.connected.camera = device;
this.connected.camera_second = device;
this.arduino.aliasSerial('camera_second', device);
else if (device === 'camera,camera_second') {
this.connected.camera = serial;
this.connected.camera_second = serial;
this.arduino.aliasSerial('camera_second', serial);
try {
connectSuccess = await this.arduino.connect('camera', device, false);
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, camera_secondary and projector', err);
return false;
}
}
else if ('camera,projector,projector_second') {
this.connected.camera = device;
this.connected.projector = device;
this.connected.projector_second = device;
this.arduino.aliasSerial('projector', device);
this.arduino.aliasSerial('projector_second', device);
else if (device === 'camera,projector,projector_second') {
this.connected.camera = serial;
this.connected.projector = serial;
this.connected.projector_second = serial;
this.arduino.aliasSerial('projector', serial);
this.arduino.aliasSerial('projector_second', serial);
try {
connectSuccess = await this.arduino.connect('camera', device, false);
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, projector and projector_second', err);
return false;
}
}
else if ('camera,camera_second,projector') {
this.connected.camera = device;
this.connected.camera_second = device;
this.connected.projector = device;
this.arduino.aliasSerial('camera_second', device);
this.arduino.aliasSerial('projector', device);
else if (device === 'camera,camera_second,projector') {
this.connected.camera = serial;
this.connected.camera_second = serial;
this.connected.projector = serial;
this.arduino.aliasSerial('camera_second', serial);
this.arduino.aliasSerial('projector', serial);
try {
connectSuccess = await this.arduino.connect('camera', device, false);
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, camera_second and projector', err);
return false;
}
}
else if ('camera,camera_second,projector,projector_second') {
this.connected.camera = device;
this.connected.camera_second = device;
this.connected.projector = device;
this.connected.projector_second = device;
this.arduino.aliasSerial('camera_second', device);
this.arduino.aliasSerial('projector', device);
this.arduino.aliasSerial('projector_second', device);
else if (device === 'camera,camera_second,projector,projector_second') {
this.connected.camera = serial;
this.connected.camera_second = serial;
this.connected.projector = serial;
this.connected.projector_second = serial;
this.arduino.aliasSerial('camera_second', serial);
this.arduino.aliasSerial('projector', serial);
this.arduino.aliasSerial('projector_second', serial);
try {
connectSuccess = await this.arduino.connect('camera', device, false);
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, camera_second, projector and projector_second', err);
return false;
}
}
else if (device === 'capper') {
this.connected.capper = serial;
try {
connectSuccess = await this.arduino.connect('capper', serial, false);
}
catch (err) {
this.log.error('Error connecting capper', err);
return false;
}
}
else if (device === 'camera,capper') {
this.connected.camera = serial;
this.connected.capper = serial;
this.arduino.aliasSerial('capper', serial);
try {
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera and capper', err);
return false;
}
}
else if (device === 'camera,capper,projector') {
this.connected.camera = serial;
this.connected.capper = serial;
this.connected.projector = serial;
this.arduino.aliasSerial('capper', serial);
this.arduino.aliasSerial('projector', serial);
try {
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, capper and projector', err);
return false;
}
}
else if (device === 'camera,capper,projector,projector_second') {
this.connected.camera = serial;
this.connected.capper = serial;
this.connected.projector = serial;
this.connected.projector_second = serial;
this.arduino.aliasSerial('capper', serial);
this.arduino.aliasSerial('projector', serial);
this.arduino.aliasSerial('projector_second', serial);
try {
connectSuccess = await this.arduino.connect('camera', serial, false);
}
catch (err) {
this.log.error('Error connecting to camera, capper, projector and projector_second', err);
return false;
}
}
return connectSuccess;
}
/**
*
**/
*
**/
//Cases for 1 or 2 arduinos connected
async all(devices) {
async all(serials) {
let c = {};
let p = {};
let l = {};
let type;
let device;
let d;
let cs = {};
let ps = {};
let capper = {};
let checklist = [];
let exposure;
let parts;
this.connected = {
projector: false,
camera: false,
light: false,
projector_second: false
projector_second: false,
capper: false
};
for (let device of devices) {
for (let serial of serials) {
try {
type = await this.distinguish(device);
device = await this.distinguish(serial);
}
catch (err) {
this.log.error('Error distinguishing device', err);
throw err;
}
try {
await this.connectDevice(device, type);
await this.connectDevice(device, serial);
}
catch (err) {
this.log.error('Error connecting to device', err);
@ -387,56 +475,82 @@ class Devices {
if (!this.connected.projector) {
await this.fakeProjector();
}
else if (this.arduino.hasState['projector']) {
p.state = true;
}
p.arduino = this.connected.projector;
if (!this.connected.camera) {
await this.fakeCamera();
}
else if (this.arduino.hasState['camera']) {
if (device.indexOf('camera') !== -1) {
parts = this.arduino.stateStr[device].split('G');
if (parts.length > 1) {
parts = parts[1].split('H');
exposure = parseInt(parts[0]);
if (!isNaN(exposure)) {
this.log.info(`Timing for [${device}] = ${exposure}`);
this.ui.send('timing', { c: 'c', ms: exposure });
}
}
}
c.state = true;
c.exposure = true;
}
c.arduino = this.connected.camera;
if (!this.connected.light) {
await this.fakeLight();
}
l.arduino = this.connected.light;
if (this.connected.camera_second) {
cs = { arduino: this.connected.camera_second };
cs.arduino = this.connected.camera_second;
}
if (this.connected.projector_second) {
ps = { arduino: this.connected.projector_second };
ps.arduino = this.connected.projector_second;
}
if (this.connected.capper) {
capper.arduino = this.connected.capper;
}
if (this.settings.state.camera && this.settings.state.camera.intval) {
c.intval = this.settings.state.camera.intval;
}
return this.ready(p, c, l, cs, ps);
return this.ready(p, c, l, cs, ps, capper);
}
/**
*
**/
remember(which, device, type) {
*
**/
remember(device, serial, type) {
let deviceEntry;
const match = this.settings.state.devices.filter((dev) => {
if (dev[which] && dev[which] === device) {
if (typeof dev.device !== 'undefined' && dev.device === device &&
typeof dev.serial !== 'undefined' && dev.serial === serial) {
return dev;
}
});
if (match.length === 0) {
deviceEntry = {
type: type
device,
type,
serial
};
deviceEntry[which] = device;
this.settings.state.devices.push(deviceEntry);
this.settings.update('devices', this.settings.state.devices);
this.settings.save();
}
}
/**
*
**/
ready(projector, camera, light, camera_second, projector_second) {
*
**/
ready(projector, camera, light, camera_second, projector_second, capper) {
let args = {
camera,
projector,
light,
profile: this.settings.state.profile
};
if (this.settings.state.timing) {
args.timing = this.settings.state.timing;
}
if (projector_second && projector_second.arduino) {
args.projector_second = projector_second;
this.settings.update('projector_second', projector_second);
@ -452,6 +566,11 @@ class Devices {
this.mainWindow.setSize(800, 800);
}
}
if (capper && capper.arduino) {
args.capper = capper;
this.mainWindow.setSize(800, 800);
this.settings.update('capper', capper);
}
this.settings.update('camera', camera);
this.settings.update('projector', projector);
this.settings.update('light', light);
@ -460,7 +579,6 @@ class Devices {
return true;
}
}
module.exports = function (arduino, settings, mainWindow, cam) {
return new Devices(arduino, settings, mainWindow, cam);
};
exports.Devices = Devices;
module.exports = { Devices };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,9 @@
<a name="module_lib/display"></a>
## lib/display
<a name="module_lib/display..electron_1"></a>
### lib/display~electron\_1
Provides features for displaying a full screen display of images for the digital module.
**Kind**: inner constant of [<code>lib/display</code>](#module_lib/display)

18
app/lib/display/index.d.ts vendored Normal file
View File

@ -0,0 +1,18 @@
import type { System } from 'system';
export declare class Display {
private platform;
private displays;
private display;
private tmpdir;
private wv;
constructor(sys: System);
open(): Promise<void>;
show(src: string): Promise<void>;
showPath(pathStr: string): Promise<unknown>;
hide(): void;
close(): Promise<boolean>;
focus(): Promise<boolean>;
field(ratio: number): Promise<boolean>;
meter(): Promise<boolean>;
change(id: string): void;
}

View File

@ -1,29 +1,28 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Display = void 0;
/**
* @module lib/display */
/**
* @module display
* Provides features for displaying a full screen display of images for the digital module.
**/
const spawn = require("spawn");
const electron_1 = require("electron");
const path_1 = require("path");
const url_1 = require("url");
const delay_1 = require("delay");
const { BrowserWindow } = require('electron');
function padded_frame(i) {
let len = (i + '').length;
let str = i + '';
for (let x = 0; x < 5 - len; x++) {
str = '0' + str;
}
return str;
}
const log_1 = require("log");
class WebView {
constructor(platform, display) {
this.opened = false;
this.showing = false;
this.loadWait = {};
this.ipc = electron_1.ipcMain;
const prefs = {
webPreferences: {
nodeIntegration: true,
allowRunningInsecureContent: false
allowRunningInsecureContent: false,
//enableRemoteModule: true,
contextIsolation: false
},
width: 800,
height: 600,
@ -31,12 +30,19 @@ class WebView {
minHeight: 600 //,
//icon: path.join(__dirname, '../../assets/icons/icon.png')
};
const pagePath = (0, path_1.normalize)((0, path_1.join)(__dirname, '../../display.html'));
const pageUrl = (0, url_1.format)({
pathname: pagePath,
protocol: 'file:'
});
this.init();
if (!display.primary) {
prefs.x = display.x + 50;
prefs.y = display.y + 50;
}
this.digitalWindow = new BrowserWindow(prefs);
this.digitalWindow.loadURL('file://' + __dirname + '../../../display.html');
this.digitalWindow = new electron_1.BrowserWindow(prefs);
require('@electron/remote/main').enable(this.digitalWindow.webContents);
this.digitalWindow.loadURL(pageUrl);
if (process.argv.indexOf('-d') !== -1 || process.argv.indexOf('--dev') !== -1) {
this.digitalWindow.webContents.openDevTools();
}
@ -47,69 +53,81 @@ class WebView {
//this.digitalWindow.hide();
this.platform = platform;
this.display = display;
this.ipc.on('display_load', this.onLoad.bind(this));
}
async init() {
this.log = await (0, log_1.Log)({ label: 'devices' });
}
async open() {
this.digitalWindow.show();
this.showing = true;
this.opened = true;
await this.digitalWindow.setFullScreen(true);
await delay_1.delay(300);
await (0, delay_1.delay)(300);
if (this.platform === 'osx') {
await delay_1.delay(300); //give macs an extra 300ms to open fullscreen
await (0, delay_1.delay)(300); //give macs an extra 300ms to open fullscreen
}
}
async show(src) {
const normalSrc = (0, path_1.normalize)((0, path_1.join)(src));
if (!this.digitalWindow) {
console.warn(`Cannot show "${src}" because window does not exist`);
this.log.warn(`Cannot show "${src}" because window does not exist`);
return false;
}
try {
this.digitalWindow.webContents.send('display', { src });
this.digitalWindow.webContents.send('display', { src: normalSrc });
}
catch (err) {
console.error(err);
this.log.error(err);
}
this.showing = true;
await delay_1.delay(200);
return true;
return new Promise(function (resolve) {
this.loadWait[src] = resolve;
}.bind(this));
}
onLoad(evt, arg) {
if (this.loadWait[arg.src]) {
this.loadWait[arg.src]();
delete this.loadWait[arg.src];
}
}
async focus() {
if (!this.digitalWindow) {
console.warn(`Cannot show focus screen because window does not exist`);
this.log.warn(`Cannot show focus screen because window does not exist`);
return false;
}
await delay_1.delay(500);
await (0, delay_1.delay)(500);
try {
this.digitalWindow.webContents.send('focus', { focus: true });
}
catch (err) {
console.error(err);
this.log.error(err);
}
}
async field(ratio) {
if (!this.digitalWindow) {
console.warn(`Cannot show field guide because window does not exist`);
this.log.warn(`Cannot show field guide because window does not exist`);
return false;
}
await delay_1.delay(500);
await (0, delay_1.delay)(500);
try {
this.digitalWindow.webContents.send('field', { field: true, ratio });
}
catch (err) {
console.error(err);
this.log.error(err);
}
}
async meter() {
if (!this.digitalWindow) {
console.warn(`Cannot show meter screen because window does not exist`);
this.log.warn(`Cannot show meter screen because window does not exist`);
return false;
}
await delay_1.delay(500);
await (0, delay_1.delay)(500);
try {
this.digitalWindow.webContents.send('meter', { meter: true });
}
catch (err) {
console.error(err);
this.log.error(err);
}
}
hide() {
@ -130,33 +148,11 @@ class WebView {
return true;
}
}
class EOG {
constructor() {
}
open() {
this.hide();
}
async show(src) {
//timeout 3 eog --fullscreen ${src}
this.cp = spawn('eog', ['--fullscreen', src]);
await delay_1.delay(200);
return true;
}
hide() {
if (this.cp) {
this.cp.kill();
this.cp = null;
}
}
close() {
this.hide();
}
}
class Display {
constructor(sys) {
this.platform = sys.platform;
this.displays = sys.displays;
this.tmpdir = path_1.join(sys.tmp, 'mcopy_digital');
this.tmpdir = (0, path_1.join)(sys.tmp, 'mcopy_digital');
this.display = this.displays.find((display) => {
if (display.primary)
return true;
@ -171,12 +167,8 @@ class Display {
await this.wv.open();
}
}
async show(frame) {
let padded = padded_frame(frame);
let ext = 'png';
let tmppath;
tmppath = path_1.join(this.tmpdir, `export-${padded}.${ext}`);
await this.wv.show(tmppath);
async show(src) {
await this.wv.show(src);
}
async showPath(pathStr) {
return await this.wv.show(pathStr);
@ -202,7 +194,6 @@ class Display {
});
}
}
module.exports = function (sys) {
return new Display(sys);
};
exports.Display = Display;
module.exports = { Display };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

17
app/lib/exec/index.d.ts vendored Normal file
View File

@ -0,0 +1,17 @@
interface ExecOutput {
stdout: string;
stderr: string;
}
/**
* Promisified child_process.exec
*
* @param cmd
* @param arg
* @param opts See child_process.exec node docs
* @param {stream.Writable} opts.stdout If defined, child process stdout will be piped to it.
* @param {stream.Writable} opts.stderr If defined, child process stderr will be piped to it.
*
* @returns {Promise<{ stdout: string, stderr: stderr }>}
*/
export declare function exec(...args: string[]): Promise<ExecOutput>;
export type { ExecOutput };

View File

@ -1,5 +1,7 @@
'use strict';
const execRaw = require('child_process').exec;
Object.defineProperty(exports, "__esModule", { value: true });
exports.exec = void 0;
const child_process_1 = require("child_process");
/**
* Promisified child_process.exec
*
@ -28,7 +30,7 @@ async function exec(...args) {
opts = { maxBuffer: 1024 * 1024 };
}
return new Promise((resolve, reject) => {
const child = execRaw(cmd, opts, (err, stdout, stderr) => err ? reject(err) : resolve({
const child = (0, child_process_1.exec)(cmd, opts, (err, stdout, stderr) => err ? reject(err) : resolve({
stdout,
stderr
}));
@ -40,5 +42,6 @@ async function exec(...args) {
}
});
}
module.exports.exec = exec;
exports.exec = exec;
module.exports = { exec };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/exec/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;AAEZ,MAAM,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,IAAI,CAAA;AAE7C;;;;;;;;;;GAUG;AACH,KAAK,UAAU,IAAI,CAAC,GAAG,IAAe;IACrC,IAAI,GAAG,GAAY,IAAI,CAAC,CAAC,CAAC,CAAA;IAC1B,IAAI,IAAI,GAAY,IAAI,CAAA;IACxB,IAAI,IAAI,GAAS,IAAI,CAAA;IAErB,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;QAC1D,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;IACD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;QACjD,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;SAAM,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;QACvC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;IACD,IAAI,IAAI,KAAK,IAAI,EAAE;QAClB,IAAI,GAAG,EAAE,SAAS,EAAG,IAAI,GAAG,IAAI,EAAE,CAAA;KAClC;IACE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACtC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,IAAI,EACjC,CAAC,GAAW,EAAE,MAAe,EAAE,MAAc,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;YAC7E,MAAM;YACN,MAAM;SACN,CAAC,CAAC,CAAC;QACC,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClC;QACD,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClC;IACL,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAA"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/exec/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;;;AAEZ,iDAA+C;AAO/C;;;;;;;;;;GAUG;AACI,KAAK,UAAU,IAAI,CAAC,GAAG,IAAe;IAC5C,IAAI,GAAG,GAAY,IAAI,CAAC,CAAC,CAAC,CAAA;IAC1B,IAAI,IAAI,GAAY,IAAI,CAAA;IACxB,IAAI,IAAI,GAAS,IAAI,CAAA;IAErB,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;QAC1D,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;IACD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;QACjD,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;SAAM,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE;QACvC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;KACd;IACD,IAAI,IAAI,KAAK,IAAI,EAAE;QAClB,IAAI,GAAG,EAAE,SAAS,EAAG,IAAI,GAAG,IAAI,EAAE,CAAA;KAClC;IACE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAkB,EAAE,MAAiB,EAAE,EAAE;QAC5D,MAAM,KAAK,GAAG,IAAA,oBAAO,EAAC,GAAG,EAAE,IAAI,EACjC,CAAC,GAAW,EAAE,MAAe,EAAE,MAAc,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;YAC7E,MAAM;YACN,MAAM;SACN,CAAC,CAAC,CAAC;QACC,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClC;QACD,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClC;IACL,CAAC,CAAC,CAAC;AACP,CAAC;AA7BD,oBA6BC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAE,CAAA"}

8
app/lib/exit/index.d.ts vendored Normal file
View File

@ -0,0 +1,8 @@
/**
* Exit process with either a 0 code or other
* specified failure code. Print message to console first.
*
* @param {string} msg Reason for exit
* @param {integer} code process exit code, default 0
**/
declare function exit(msg: string, code?: number): void;

View File

@ -16,5 +16,5 @@ function exit(msg, code = 0) {
process.exit(code);
}
}
module.exports.exit = exit;
module.exports = { exit };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/exit/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb;;;;;;IAMI;AAEJ,SAAS,IAAI,CAAE,GAAY,EAAE,OAAgB,CAAC;IAC7C,IAAI,IAAI,KAAK,CAAC,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjB,OAAO,CAAC,IAAI,EAAE,CAAC;KACf;SAAM;QACN,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACnB;AACF,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/exit/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb;;;;;;IAMI;AAEJ,SAAS,IAAI,CAAE,GAAY,EAAE,OAAgB,CAAC;IAC7C,IAAI,IAAI,KAAK,CAAC,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjB,OAAO,CAAC,IAAI,EAAE,CAAC;KACf;SAAM;QACN,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACnB;AACF,CAAC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAE,CAAC"}

View File

@ -0,0 +1,138 @@
## Modules
<dl>
<dt><a href="#module_ffmpeg">ffmpeg</a></dt>
<dd></dd>
<dt><a href="#module_lib/ffmpeg">lib/ffmpeg</a></dt>
<dd></dd>
</dl>
<a name="module_ffmpeg"></a>
## ffmpeg
<a name="module_lib/ffmpeg"></a>
## lib/ffmpeg
* [lib/ffmpeg](#module_lib/ffmpeg)
* [~Creates an ffmpeg class](#module_lib/ffmpeg..Creates an ffmpeg class)
* [new Creates an ffmpeg class(sys)](#new_module_lib/ffmpeg..Creates an ffmpeg class_new)
* [~FFMPEG](#module_lib/ffmpeg..FFMPEG)
* [.init()](#module_lib/ffmpeg..FFMPEG+init)
* [.padded_frame(i)](#module_lib/ffmpeg..FFMPEG+padded_frame) ⇒ <code>string</code>
* [.parseStderr(line)](#module_lib/ffmpeg..FFMPEG+parseStderr)
* [.frame(state, light)](#module_lib/ffmpeg..FFMPEG+frame) ⇒ <code>string</code>
* [.frames(video, obj)](#module_lib/ffmpeg..FFMPEG+frames) ⇒ <code>?</code>
* [.clear(frame)](#module_lib/ffmpeg..FFMPEG+clear) ⇒ <code>boolean</code>
* [.clearAll()](#module_lib/ffmpeg..FFMPEG+clearAll)
* [.checkDir()](#module_lib/ffmpeg..FFMPEG+checkDir)
<a name="module_lib/ffmpeg..Creates an ffmpeg class"></a>
### lib/ffmpeg~Creates an ffmpeg class
**Kind**: inner class of [<code>lib/ffmpeg</code>](#module_lib/ffmpeg)
<a name="new_module_lib/ffmpeg..Creates an ffmpeg class_new"></a>
#### new Creates an ffmpeg class(sys)
| Param | Type | Description |
| --- | --- | --- |
| sys | <code>object</code> | System object to be used to get temp directory |
<a name="module_lib/ffmpeg..FFMPEG"></a>
### lib/ffmpeg~FFMPEG
Class representing all ffmpeg features.
**Kind**: inner class of [<code>lib/ffmpeg</code>](#module_lib/ffmpeg)
* [~FFMPEG](#module_lib/ffmpeg..FFMPEG)
* [.init()](#module_lib/ffmpeg..FFMPEG+init)
* [.padded_frame(i)](#module_lib/ffmpeg..FFMPEG+padded_frame) ⇒ <code>string</code>
* [.parseStderr(line)](#module_lib/ffmpeg..FFMPEG+parseStderr)
* [.frame(state, light)](#module_lib/ffmpeg..FFMPEG+frame) ⇒ <code>string</code>
* [.frames(video, obj)](#module_lib/ffmpeg..FFMPEG+frames) ⇒ <code>?</code>
* [.clear(frame)](#module_lib/ffmpeg..FFMPEG+clear) ⇒ <code>boolean</code>
* [.clearAll()](#module_lib/ffmpeg..FFMPEG+clearAll)
* [.checkDir()](#module_lib/ffmpeg..FFMPEG+checkDir)
<a name="module_lib/ffmpeg..FFMPEG+init"></a>
#### ffmpeG.init()
Async method to call async functions from constructor
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
<a name="module_lib/ffmpeg..FFMPEG+padded_frame"></a>
#### ffmpeG.padded\_frame(i) ⇒ <code>string</code>
Add padding to a number to 5 places. Return a string.
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
**Returns**: <code>string</code> - Padded string
| Param | Type | Description |
| --- | --- | --- |
| i | <code>integer</code> | Integer to pad |
<a name="module_lib/ffmpeg..FFMPEG+parseStderr"></a>
#### ffmpeG.parseStderr(line)
Parse the stderr output of ffmpeg
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Stderr line |
<a name="module_lib/ffmpeg..FFMPEG+frame"></a>
#### ffmpeG.frame(state, light) ⇒ <code>string</code>
Render a single frame from a video or image to a png.
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
**Returns**: <code>string</code> - Path of frame
| Param | Type | Description |
| --- | --- | --- |
| state | <code>object</code> | State object containing file data |
| light | <code>object</code> | Object containing color information for frame |
<a name="module_lib/ffmpeg..FFMPEG+frames"></a>
#### ffmpeG.frames(video, obj) ⇒ <code>?</code>
Render all frames in a video to the temp directory.
Not in use.
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
| Param | Type | Description |
| --- | --- | --- |
| video | <code>string</code> | Path to video |
| obj | <code>object</code> | Not sure |
<a name="module_lib/ffmpeg..FFMPEG+clear"></a>
#### ffmpeG.clear(frame) ⇒ <code>boolean</code>
Clears a specific frame from the tmp directory
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
**Returns**: <code>boolean</code> - True if successful, false if not
| Param | Type | Description |
| --- | --- | --- |
| frame | <code>integer</code> | Integer of frame to clear |
<a name="module_lib/ffmpeg..FFMPEG+clearAll"></a>
#### ffmpeG.clearAll()
Deletes all frames in temp directory.
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)
<a name="module_lib/ffmpeg..FFMPEG+checkDir"></a>
#### ffmpeG.checkDir()
Checks if mcopy temp directory exists. If it doesn't,
creates it.
**Kind**: instance method of [<code>FFMPEG</code>](#module_lib/ffmpeg..FFMPEG)

89
app/lib/ffmpeg/index.d.ts vendored Normal file
View File

@ -0,0 +1,89 @@
import type { FilmOutState } from 'filmout';
import type { System } from 'system';
import type { LightState } from 'light';
interface StdErr {
frame: number;
fps: number;
time: string;
speed: number;
size: string;
remaining?: number;
progress?: number;
estimated?: number;
}
/** @module lib/ffmpeg */
/**
* Class representing all ffmpeg features.
*/
export declare class FFMPEG {
private bin;
private log;
private id;
private TMPDIR;
private child;
onProgress: Function;
/**
* @constructor
* Creates an ffmpeg class
*
* @param {object} sys System object to be used to get temp directory
**/
constructor(sys: System);
/**
* Async method to call async functions from constructor
**/
init(): Promise<void>;
/**
* Add padding to a number to 5 places. Return a string.
*
* @param {integer} i Integer to pad
*
* @returns {string} Padded string
**/
private padded_frame;
/**
* Parse the stderr output of ffmpeg
*
* @param {string} line Stderr line
**/
private parseStderr;
/**
* Render a single frame from a video or image to a png.
*
* @param {object} state State object containing file data
* @param {object} light Object containing color information for frame
*
* @returns {string} Path of frame
**/
frame(state: FilmOutState, light: LightState): Promise<string>;
/**
* Render all frames in a video to the temp directory.
* Not in use.
*
* @param {string} video Path to video
* @param {object} obj Not sure
*
* @returns {?}
**/
frames(state: FilmOutState): Promise<unknown>;
cancel(): void;
/**
* Clears a specific frame from the tmp directory
*
* @param {integer} frame Integer of frame to clear
*
* @returns {boolean} True if successful, false if not
**/
clear(state: any): Promise<boolean>;
/**
* Deletes all frames in temp directory.
*
**/
clearAll(): Promise<void>;
/**
* Checks if mcopy temp directory exists. If it doesn't,
* creates it.
**/
private checkDir;
}
export type { StdErr };

View File

@ -1,9 +1,16 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.FFMPEG = void 0;
/** @module ffmpeg **/
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const exec_1 = require("exec");
/** @class FFMPEG **/
const child_process_1 = require("child_process");
const log_1 = require("log");
/** @module lib/ffmpeg */
/**
* Class representing all ffmpeg features.
*/
class FFMPEG {
/**
* @constructor
@ -13,17 +20,16 @@ class FFMPEG {
**/
constructor(sys) {
this.id = 'ffmpeg';
this.onProgress = () => { };
this.bin = sys.deps.ffmpeg;
this.convert = sys.deps.convert;
this.TMPDIR = path_1.join(sys.tmp, 'mcopy_digital');
this.TMPDIR = (0, path_1.join)(sys.tmp, 'mcopy_digital');
this.init();
}
/**
* Async method to call async functions from constructor
**/
async init() {
const Log = require('log');
this.log = await Log({ label: this.id });
this.log = await (0, log_1.Log)({ label: this.id });
await this.checkDir();
}
/**
@ -36,11 +42,49 @@ class FFMPEG {
padded_frame(i) {
let len = (i + '').length;
let str = i + '';
for (let x = 0; x < 5 - len; x++) {
for (let x = 0; x < 8 - len; x++) {
str = '0' + str;
}
return str;
}
/**
* Parse the stderr output of ffmpeg
*
* @param {string} line Stderr line
**/
parseStderr(line) {
//frame= 6416 fps= 30 q=31.0 size= 10251kB time=00:03:34.32 bitrate= 391.8kbits/s speed= 1x
const obj = {
frame: 0,
fps: 0,
time: '',
speed: 0,
size: ''
};
let frameStr;
let fpsStr;
let speedStr;
if (line.substring(0, 'frame='.length) === 'frame=') {
try {
frameStr = line.split('frame=')[1].split('fps=')[0];
obj.frame = parseInt(frameStr);
fpsStr = line.split('fps=')[1].split('q=')[0];
obj.fps = parseFloat(fpsStr);
obj.time = line.split('time=')[1].split('bitrate=')[0];
speedStr = line.split('speed=')[1].trim().replace('x', '');
obj.speed = parseFloat(speedStr);
obj.size = line.split('size=')[1].split('time=')[0].trim();
}
catch (err) {
this.log.error('Error parsing stderr line', err);
this.log.info(line);
process.exit();
}
}
else {
}
return obj;
}
/**
* Render a single frame from a video or image to a png.
*
@ -51,55 +95,62 @@ class FFMPEG {
**/
async frame(state, light) {
const frameNum = state.frame;
const video = state.path;
const video = state.directory ? state.files[frameNum] : state.path;
const w = state.info.width;
const h = state.info.height;
const padded = this.padded_frame(frameNum);
let ext = 'tif';
let ext = 'png';
let rgb = light.color;
let rgba;
let tmpoutput;
let cmd;
let output;
let cmd2;
let output2;
let fileExists = false;
let scale = '';
if (w && h) {
scale = `,scale=${w}:${h}`;
if (state.directory) {
return video;
}
if (w && h) {
scale = `,scale=trunc(ih*dar):${h}`; //:force_original_aspect_ratio=decrease,pad=${w}:${h}:(ow-iw)/2:(oh-ih)/2
}
tmpoutput = (0, path_1.join)(this.TMPDIR, `${state.hash}-export-${padded}.${ext}`);
try {
fileExists = await (0, fs_extra_1.exists)(tmpoutput);
}
catch (err) {
//
}
if (fileExists) {
this.log.info(`File ${tmpoutput} exists`);
return tmpoutput;
}
//console.dir(state)
//if (system.platform !== 'nix') {
ext = 'png';
//}
tmpoutput = path_1.join(this.TMPDIR, `export-${padded}.${ext}`);
rgb = rgb.map((e) => {
return parseInt(e);
});
//
cmd = `${this.bin} -y -i "${video}" -vf "select='gte(n\\,${frameNum})'${scale}" -vframes 1 -compression_algo raw -pix_fmt rgb24 "${tmpoutput}"`;
cmd2 = `${this.convert} "${tmpoutput}" -resize ${w}x${h} -size ${w}x${h} xc:"rgb(${rgb[0]},${rgb[1]},${rgb[2]})" +swap -compose Darken -composite "${tmpoutput}"`;
cmd = `${this.bin} -hwaccel auto -y -i "${video}" -vf "select='gte(n\\,${frameNum})'${scale}" -vframes 1 -compression_algo raw -pix_fmt rgb24 -crf 0 "${tmpoutput}"`;
//cmd2 = `${this.convert} "${tmpoutput}" -resize ${w}x${h} -size ${w}x${h} xc:"rgb(${rgb[0]},${rgb[1]},${rgb[2]})" +swap -compose Darken -composite "${tmpoutput}"`;
//ffmpeg -i "${video}" -ss 00:00:07.000 -vframes 1 "export-${time}.jpg"
//ffmpeg -i "${video}" -compression_algo raw -pix_fmt rgb24 "export-%05d.tiff"
//-vf "select=gte(n\,${frame})" -compression_algo raw -pix_fmt rgb24 "export-${padded}.png"
try {
this.log.info(cmd);
output = await exec_1.exec(cmd);
output = await (0, exec_1.exec)(cmd);
}
catch (err) {
this.log.error(err);
}
if (output && output.stdout)
this.log.info(`"${output.stdout}"`);
if (this.convert && (rgb[0] !== 255 || rgb[1] !== 255 || rgb[2] !== 255)) {
this.log.info(`"${output.stdout.trim()}"`);
if (rgb[0] !== 255 || rgb[1] !== 255 || rgb[2] !== 255) {
rgb = rgb.map((e) => {
return typeof e === 'string' ? parseInt(e) : e;
});
rgba = { r: rgb[0], g: rgb[1], b: rgb[2], a: 255 };
try {
this.log.info(cmd2);
output2 = await exec_1.exec(cmd2);
//await Frame.blend(tmpoutput, rgba, tmpoutput);
}
catch (err) {
this.log.error(err);
}
}
if (output2 && output2.stdout)
this.log.info(`"${output2.stdout}"`);
return tmpoutput;
}
/**
@ -111,21 +162,95 @@ class FFMPEG {
*
* @returns {?}
**/
async frames(video, obj) {
async frames(state) {
const video = state.path;
const w = state.info.width;
const h = state.info.height;
const tmppath = this.TMPDIR;
let ext = 'tif';
let tmpoutput;
//if (system.platform !== 'nix') {
ext = 'png';
//}
tmpoutput = path_1.join(tmppath, `export-%05d.${ext}`);
let ext = 'png';
let tmpoutput = (0, path_1.join)(tmppath, `${state.hash}-export-%08d.${ext}`);
let args;
let output;
let estimated = -1;
//cmd = `${this.bin} -y -i "${video}" -vf "${scale}" -compression_algo raw -pix_fmt rgb24 -crf 0 "${tmpoutput}"`;
args = [
'-hwaccel',
'auto',
'-y',
'-i', video
];
if (w && h) {
args.push('-vf');
args.push(`scale=${w}:${h}`);
}
args = args.concat([
'-compression_algo', 'raw',
'-pix_fmt', 'rgb24',
'-crf', '0',
tmpoutput
]);
//console.dir(args)
//console.dir(state)
try {
await fs_extra_1.mkdir(tmppath);
await (0, fs_extra_1.mkdir)(tmppath);
}
catch (err) {
this.log.error(err);
if (err.code && err.code === 'EEXIST') {
//directory exists
}
else {
this.log.error(err);
}
}
//ffmpeg -i "${video}" -compression_algo raw -pix_fmt rgb24 "${tmpoutput}"
return new Promise((resolve, reject) => {
let stdout = '';
let stderr = '';
this.log.info(`${this.bin} ${args.join(' ')}`);
this.child = (0, child_process_1.spawn)(this.bin, args);
this.child.on('exit', function (code) {
//console.log('GOT TO EXIT');
if (code === 0) {
this.log.info(stderr);
this.log.info(stdout);
return resolve(true);
}
else {
this.log.error(`Process exited with code: ${code}`);
this.log.error(stderr);
return reject(stderr + stdout);
}
}.bind(this));
this.child.stdout.on('data', (data) => {
const line = data.toString();
stdout += line;
});
this.child.stderr.on('data', (data) => {
const line = data.toString();
const obj = this.parseStderr(line);
if (obj.frame && state.frames) {
obj.progress = obj.frame / state.frames;
}
if (obj.frame && obj.speed && state.frames && state.info.fps) {
//scale by speed
obj.remaining = ((state.frames - obj.frame) / state.info.fps) / obj.speed;
obj.estimated = state.info.seconds / obj.speed;
if (obj.estimated > estimated) {
estimated = obj.estimated;
}
}
if (obj.frame) {
//log.info(`${input.name} ${obj.frame}/${input.frames} ${Math.round(obj.progress * 1000) / 10}% ${Math.round(obj.remaining)} seconds remaining of ${Math.round(obj.estimated)}`);
this.onProgress(obj);
}
});
});
}
cancel() {
if (this.child) {
this.child.kill();
this.log.info(`Stopped exporting sequence with ffmpeg`);
}
}
/**
* Clears a specific frame from the tmp directory
@ -134,27 +259,22 @@ class FFMPEG {
*
* @returns {boolean} True if successful, false if not
**/
async clear(frame) {
const padded = this.padded_frame(frame);
let ext = 'tif';
async clear(state) {
const padded = this.padded_frame(state.frame);
let ext = 'png';
let tmppath;
let tmpoutput;
let cmd;
let fileExists;
//if (system.platform !== 'nix') {
ext = 'png';
//}
tmppath = path_1.join(this.TMPDIR, `export-${padded}.${ext}`);
tmppath = (0, path_1.join)(this.TMPDIR, `${state.hash}-export-${padded}.${ext}`);
try {
fileExists = await fs_extra_1.exists(tmppath);
fileExists = await (0, fs_extra_1.exists)(tmppath);
}
catch (err) {
this.log.error(err);
}
if (!fs_extra_1.exists)
if (!fileExists)
return false;
try {
await fs_extra_1.unlink(tmppath);
await (0, fs_extra_1.unlink)(tmppath);
this.log.info(`Cleared frame ${tmppath}`);
}
catch (err) {
@ -163,22 +283,28 @@ class FFMPEG {
return true;
}
/**
* Delete all frames in temp directory.
* Deletes all frames in temp directory.
*
**/
async clearAll() {
const tmppath = this.TMPDIR;
let files;
try {
files = await fs_extra_1.readdir(tmppath);
files = await (0, fs_extra_1.readdir)(tmppath);
}
catch (err) {
this.log.error(err);
}
files = files.filter((file) => {
if (file.indexOf('-export-') !== -1) {
return true;
}
return false;
});
if (files) {
files.forEach(async (file, index) => {
try {
await fs_extra_1.unlink(path_1.join(tmppath, file));
await (0, fs_extra_1.unlink)((0, path_1.join)(tmppath, file));
}
catch (err) {
this.log.error(err);
@ -188,19 +314,19 @@ class FFMPEG {
}
/**
* Checks if mcopy temp directory exists. If it doesn't,
* create it.
* creates it.
**/
async checkDir() {
let fileExists;
try {
fileExists = await fs_extra_1.exists(this.TMPDIR);
fileExists = await (0, fs_extra_1.exists)(this.TMPDIR);
}
catch (err) {
this.log.error('Error checking for tmp dir', err);
}
if (!fileExists) {
try {
await fs_extra_1.mkdir(this.TMPDIR);
await (0, fs_extra_1.mkdir)(this.TMPDIR);
this.log.info(`Created tmpdir ${this.TMPDIR}`);
}
catch (err) {
@ -215,7 +341,6 @@ class FFMPEG {
}
}
}
module.exports = (sys) => {
return new FFMPEG(sys);
};
exports.FFMPEG = FFMPEG;
module.exports = { FFMPEG };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,54 @@
<a name="module_lib/ffprobe"></a>
## lib/ffprobe
* [lib/ffprobe](#module_lib/ffprobe)
* [~FFPROBE](#module_lib/ffprobe..FFPROBE)
* [.parseFps()](#module_lib/ffprobe..FFPROBE+parseFps)
* [.info(video)](#module_lib/ffprobe..FFPROBE+info) ⇒ <code>object</code>
* [.frames(video)](#module_lib/ffprobe..FFPROBE+frames) ⇒ <code>integer</code>
<a name="module_lib/ffprobe..FFPROBE"></a>
### lib/ffprobe~FFPROBE
Class representing all ffprobe features.
**Kind**: inner class of [<code>lib/ffprobe</code>](#module_lib/ffprobe)
* [~FFPROBE](#module_lib/ffprobe..FFPROBE)
* [.parseFps()](#module_lib/ffprobe..FFPROBE+parseFps)
* [.info(video)](#module_lib/ffprobe..FFPROBE+info) ⇒ <code>object</code>
* [.frames(video)](#module_lib/ffprobe..FFPROBE+frames) ⇒ <code>integer</code>
<a name="module_lib/ffprobe..FFPROBE+parseFps"></a>
#### ffprobE.parseFps()
Parse the fps entry into a float representing the fps of a video
**Kind**: instance method of [<code>FFPROBE</code>](#module_lib/ffprobe..FFPROBE)
<a name="module_lib/ffprobe..FFPROBE+info"></a>
#### ffprobE.info(video) ⇒ <code>object</code>
Get info on a video in json format. Use for filmout.
**Kind**: instance method of [<code>FFPROBE</code>](#module_lib/ffprobe..FFPROBE)
**Returns**: <code>object</code> - Video info in an object
| Param | Type | Description |
| --- | --- | --- |
| video | <code>string</code> | Path to video |
<a name="module_lib/ffprobe..FFPROBE+frames"></a>
#### ffprobE.frames(video) ⇒ <code>integer</code>
Count the number of frames in the video using one of two methods.
The first uses -select_streams and is very fast. The second uses
-count_frames and is VERY slow.
**Kind**: instance method of [<code>FFPROBE</code>](#module_lib/ffprobe..FFPROBE)
**Returns**: <code>integer</code> - Number of frames in video
| Param | Type | Description |
| --- | --- | --- |
| video | <code>string</code> | Path to video |

33
app/lib/ffprobe/index.d.ts vendored Normal file
View File

@ -0,0 +1,33 @@
import type { System } from 'system';
/** @module lib/ffprobe */
/**
* Class representing all ffprobe features.
*/
export declare class FFPROBE {
private bin;
private log;
constructor(sys: System);
private init;
/**
* Parse the fps entry into a float representing the fps of a video
**/
private parseFps;
/**
* Get info on a video in json format. Use for filmout.
*
* @param {string} video Path to video
*
* @returns {object} Video info in an object
**/
info(video: string): Promise<any>;
/**
* Count the number of frames in the video using one of two methods.
* The first uses -select_streams and is very fast. The second uses
* -count_frames and is VERY slow.
*
* @param {string} video Path to video
*
* @returns {integer} Number of frames in video
**/
frames(video: string): Promise<any>;
}

View File

@ -1,14 +1,36 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
/** @module FFPROBE **/
exports.FFPROBE = void 0;
const fs_extra_1 = require("fs-extra");
const path_1 = require("path");
const exec_1 = require("exec");
//const spawn = require('spawn');
//const exit = require('exit');
const log_1 = require("log");
/** @module lib/ffprobe */
/**
* Class representing all ffprobe features.
*/
class FFPROBE {
constructor(sys) {
this.bin = sys.deps.ffprobe;
this.init();
}
async init() {
this.log = await (0, log_1.Log)({ label: 'ffprobe' });
}
/**
* Parse the fps entry into a float representing the fps of a video
**/
parseFps(fpsStr) {
let fps = 30.0;
let parts;
if (fpsStr.indexOf('/') !== -1) {
parts = fpsStr.split('/');
fps = parseFloat(parts[0]) / parseFloat(parts[1]);
}
else {
fps = parseFloat(fpsStr);
}
return fps;
}
/**
* Get info on a video in json format. Use for filmout.
@ -24,31 +46,36 @@ class FFPROBE {
let json;
let vid; //whether video has stream with video data
try {
fileExists = await fs_extra_1.exists(video);
fileExists = await (0, fs_extra_1.exists)(video);
}
catch (err) {
return exit(err, 5);
}
if (!fileExists) {
//return exit(`File ${video} does not exist`, 6);
console.error(new Error(`File ${video} does not exist`));
this.log.error(new Error(`File ${video} does not exist`));
return false;
}
try {
console.log(cmd);
raw = await exec_1.exec(cmd);
this.log.info(cmd);
raw = await (0, exec_1.exec)(cmd);
}
catch (err) {
//return exit(err, 7);
console.error(err);
this.log.error(err);
return false;
}
try {
json = JSON.parse(raw.stdout);
}
catch (err) {
this.log.error('Error parsing stdout', err);
this.log.error(raw.stdout);
return raw.stdout;
}
if (json.format && json.format.duration) {
json.seconds = parseFloat(json.format.duration);
}
if (json && json.streams) {
vid = json.streams.find((stream) => {
if (stream.width && stream.height)
@ -58,6 +85,7 @@ class FFPROBE {
if (vid) {
json.width = vid.width;
json.height = vid.height;
json.fps = this.parseFps(vid.r_frame_rate);
}
return json;
}
@ -71,19 +99,19 @@ class FFPROBE {
* @returns {integer} Number of frames in video
**/
async frames(video) {
const ext = path_1.extname(video.toLowerCase());
let cmd = `ffprobe -v error -select_streams v:0 -show_entries stream=nb_frames -of default=nokey=1:noprint_wrappers=1 "${video}"`;
let backup_cmd = `ffprobe -v error -count_frames -select_streams v:0 -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 "${video}"`;
const ext = (0, path_1.extname)(video.toLowerCase());
let cmd = `${this.bin} -v error -select_streams v:0 -show_entries stream=nb_frames -of default=nokey=1:noprint_wrappers=1 "${video}"`;
let backup_cmd = `${this.bin} -v error -count_frames -select_streams v:0 -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 "${video}"`;
let gif_cmd = `identify -format "%n\n" "${video}" | head -1`;
let fileExists;
let raw;
let frames;
try {
fileExists = await fs_extra_1.exists(video);
fileExists = await (0, fs_extra_1.exists)(video);
}
catch (err) {
//return exit(err, 5);
console.error(err);
this.log.error(err);
return false;
}
if (!fileExists) {
@ -98,11 +126,11 @@ class FFPROBE {
cmd = gif_cmd;
}
try {
console.log(cmd);
raw = await exec_1.exec(cmd);
this.log.info(cmd);
raw = await (0, exec_1.exec)(cmd);
}
catch (err) {
console.error(err);
this.log.error(err);
return false;
}
try {
@ -114,12 +142,11 @@ class FFPROBE {
return frames;
}
}
exports.FFPROBE = FFPROBE;
/*
function map (obj : any) {
console.dir(obj);
}
*/
module.exports = (sys) => {
return new FFPROBE(sys);
};
module.exports = { FFPROBE };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ffprobe/index.ts"],"names":[],"mappings":"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"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ffprobe/index.ts"],"names":[],"mappings":"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"}

View File

@ -1,44 +1,227 @@
<a name="Digital"></a>
<a name="module_lib/filmout"></a>
## Digital
**Kind**: global class
## lib/filmout
* [Digital](#Digital)
* [.init()](#Digital+init)
* [.listen()](#Digital+listen)
* [.set()](#Digital+set)
* [.move()](#Digital+move)
* [.start()](#Digital+start)
* [.end()](#Digital+end)
* [.connectDigital()](#Digital+connectDigital)
* [lib/filmout](#module_lib/filmout)
* [~FilmOut](#module_lib/filmout..FilmOut)
* [.init()](#module_lib/filmout..FilmOut+init)
* [.listen()](#module_lib/filmout..FilmOut+listen)
* [.hash(data)](#module_lib/filmout..FilmOut+hash)
* [.set(dir)](#module_lib/filmout..FilmOut+set)
* [.move()](#module_lib/filmout..FilmOut+move) ⇒ <code>number</code>
* [.start()](#module_lib/filmout..FilmOut+start)
* [.end()](#module_lib/filmout..FilmOut+end)
* [.onConnect(evt, arg)](#module_lib/filmout..FilmOut+onConnect) ⇒ <code>boolean</code>
* [.onPreExport(evt, arg)](#module_lib/filmout..FilmOut+onPreExport) ⇒ <code>any</code>
* [.isGifAnimated(pathStr)](#module_lib/filmout..FilmOut+isGifAnimated) ⇒ <code>boolean</code>
* [.stillInfo(pathStr)](#module_lib/filmout..FilmOut+stillInfo) ⇒ <code>object</code>
* [.dirInfo(images)](#module_lib/filmout..FilmOut+dirInfo) ⇒ <code>object</code>
* [.dirList(pathStr)](#module_lib/filmout..FilmOut+dirList) ⇒ <code>array</code>
* [.previewFrame(evt, arg)](#module_lib/filmout..FilmOut+previewFrame)
* [.preview(evt, arg)](#module_lib/filmout..FilmOut+preview)
* [.focus()](#module_lib/filmout..FilmOut+focus)
* [.field()](#module_lib/filmout..FilmOut+field)
* [.meter()](#module_lib/filmout..FilmOut+meter)
* [.close()](#module_lib/filmout..FilmOut+close)
* [.onDisplay()](#module_lib/filmout..FilmOut+onDisplay)
<a name="Digital+init"></a>
<a name="module_lib/filmout..FilmOut"></a>
### digital.init()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+listen"></a>
### lib/filmout~FilmOut
Class representing all filmout features.
### digital.listen()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+set"></a>
**Kind**: inner class of [<code>lib/filmout</code>](#module_lib/filmout)
### digital.set()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+move"></a>
* [~FilmOut](#module_lib/filmout..FilmOut)
* [.init()](#module_lib/filmout..FilmOut+init)
* [.listen()](#module_lib/filmout..FilmOut+listen)
* [.hash(data)](#module_lib/filmout..FilmOut+hash)
* [.set(dir)](#module_lib/filmout..FilmOut+set)
* [.move()](#module_lib/filmout..FilmOut+move) ⇒ <code>number</code>
* [.start()](#module_lib/filmout..FilmOut+start)
* [.end()](#module_lib/filmout..FilmOut+end)
* [.onConnect(evt, arg)](#module_lib/filmout..FilmOut+onConnect) ⇒ <code>boolean</code>
* [.onPreExport(evt, arg)](#module_lib/filmout..FilmOut+onPreExport) ⇒ <code>any</code>
* [.isGifAnimated(pathStr)](#module_lib/filmout..FilmOut+isGifAnimated) ⇒ <code>boolean</code>
* [.stillInfo(pathStr)](#module_lib/filmout..FilmOut+stillInfo) ⇒ <code>object</code>
* [.dirInfo(images)](#module_lib/filmout..FilmOut+dirInfo) ⇒ <code>object</code>
* [.dirList(pathStr)](#module_lib/filmout..FilmOut+dirList) ⇒ <code>array</code>
* [.previewFrame(evt, arg)](#module_lib/filmout..FilmOut+previewFrame)
* [.preview(evt, arg)](#module_lib/filmout..FilmOut+preview)
* [.focus()](#module_lib/filmout..FilmOut+focus)
* [.field()](#module_lib/filmout..FilmOut+field)
* [.meter()](#module_lib/filmout..FilmOut+meter)
* [.close()](#module_lib/filmout..FilmOut+close)
* [.onDisplay()](#module_lib/filmout..FilmOut+onDisplay)
### digital.move()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+start"></a>
<a name="module_lib/filmout..FilmOut+init"></a>
### digital.start()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+end"></a>
#### filmOut.init()
Async function for requiring log, ipcMain and bind events.
### digital.end()
**Kind**: instance method of [<code>Digital</code>](#Digital)
<a name="Digital+connectDigital"></a>
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+listen"></a>
### digital.connectDigital()
Use a file as the "digital" source on "projector"
#### filmOut.listen()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+hash"></a>
**Kind**: instance method of [<code>Digital</code>](#Digital)
#### filmOut.hash(data)
Create a hash of a string.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
| Param | Type | Description |
| --- | --- | --- |
| data | <code>string</code> | Data to produce hash of |
<a name="module_lib/filmout..FilmOut+set"></a>
#### filmOut.set(dir)
Sets filmout direction.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
| Param | Type | Description |
| --- | --- | --- |
| dir | <code>boolean</code> | Direction of filmout |
<a name="module_lib/filmout..FilmOut+move"></a>
#### filmOut.move() ⇒ <code>number</code>
Moves filmout a frame at a time.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>number</code> - Time since start
<a name="module_lib/filmout..FilmOut+start"></a>
#### filmOut.start()
Begin the process of exporting single frames from the video for display.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+end"></a>
#### filmOut.end()
Ends the filmout process and closes the display.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+onConnect"></a>
#### filmOut.onConnect(evt, arg) ⇒ <code>boolean</code>
Use a video file as a film out source on "projector"
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>boolean</code> - Success state
| Param | Type | Description |
| --- | --- | --- |
| evt | <code>object</code> | Original connect event |
| arg | <code>object</code> | Arguments from ipc message |
<a name="module_lib/filmout..FilmOut+onPreExport"></a>
#### filmOut.onPreExport(evt, arg) ⇒ <code>any</code>
Pre-export all frames from video for display.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>any</code> - UI send call
| Param | Type | Description |
| --- | --- | --- |
| evt | <code>object</code> | IPC event |
| arg | <code>object</code> | IPC args |
<a name="module_lib/filmout..FilmOut+isGifAnimated"></a>
#### filmOut.isGifAnimated(pathStr) ⇒ <code>boolean</code>
Return true if gif is animated, false if it is a still
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>boolean</code> - Whether or not gif is animated
| Param | Type | Description |
| --- | --- | --- |
| pathStr | <code>string</code> | Path to gif to check |
<a name="module_lib/filmout..FilmOut+stillInfo"></a>
#### filmOut.stillInfo(pathStr) ⇒ <code>object</code>
Return information on a still image using the Jimp module
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>object</code> - Info about still from sharp
| Param | Type | Description |
| --- | --- | --- |
| pathStr | <code>string</code> | Path to gif to check |
<a name="module_lib/filmout..FilmOut+dirInfo"></a>
#### filmOut.dirInfo(images) ⇒ <code>object</code>
Return information on the first still image found in a
directory using the Jimp module.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>object</code> - Info about first image
| Param | Type | Description |
| --- | --- | --- |
| images | <code>array</code> | List of image paths |
<a name="module_lib/filmout..FilmOut+dirList"></a>
#### filmOut.dirList(pathStr) ⇒ <code>array</code>
Returns a list of images within a directory, filtered
for supported types and sorted.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
**Returns**: <code>array</code> - Array of image paths
| Param | Type | Description |
| --- | --- | --- |
| pathStr | <code>string</code> | Path to directory |
<a name="module_lib/filmout..FilmOut+previewFrame"></a>
#### filmOut.previewFrame(evt, arg)
Preview a frame from the selected video.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
| Param | Type | Description |
| --- | --- | --- |
| evt | <code>object</code> | Original event |
| arg | <code>object</code> | Arguments from message |
<a name="module_lib/filmout..FilmOut+preview"></a>
#### filmOut.preview(evt, arg)
Open a single frame in a display window to preview filmout.
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
| Param | Type | Description |
| --- | --- | --- |
| evt | <code>object</code> | Original event |
| arg | <code>object</code> | Arguments from message |
<a name="module_lib/filmout..FilmOut+focus"></a>
#### filmOut.focus()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+field"></a>
#### filmOut.field()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+meter"></a>
#### filmOut.meter()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+close"></a>
#### filmOut.close()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)
<a name="module_lib/filmout..FilmOut+onDisplay"></a>
#### filmOut.onDisplay()
**Kind**: instance method of [<code>FilmOut</code>](#module_lib/filmout..FilmOut)

173
app/lib/filmout/index.d.ts vendored Normal file
View File

@ -0,0 +1,173 @@
import type { Server } from 'server';
import type { Display } from 'display';
import type { Light } from 'light';
import type { FFMPEG } from 'ffmpeg';
import type { FFPROBE } from 'ffprobe';
import type { WebContents, IpcMainEvent } from 'electron';
interface FilmOutState {
hash: string;
frame: number;
frames: number;
fps: number;
seconds: number;
still: boolean;
path: string;
fileName: string;
directory: boolean;
info: any;
dir: boolean;
enabled: boolean;
files: string[];
}
/** @module lib/filmout */
/**
* Class representing all filmout features.
*/
export declare class FilmOut {
private id;
private videoExtensions;
private stillExtensions;
private sequenceExtensions;
private gifExtension;
state: FilmOutState;
private ffmpeg;
private ffprobe;
private light;
private ipc;
private ui;
private log;
display: Display;
server: Server;
/**
* @constructor
* Builds FilmOut class with display, ffmpeg, ffprobe, ui and light as internal properties.
*
* @param {object} display Display object for showing frames
* @param {object} ffmpeg FFMPEG wrapper
* @param {object} ffprobe FFPROBE wrapper for file info
* @param {object} ui Electron ui object
* @param {object} light Light device object
**/
constructor(display: Display, server: Server, ffmpeg: FFMPEG, ffprobe: FFPROBE, ui: WebContents, light: Light);
/**
* Async function for requiring log, ipcMain and bind events.
**/
private init;
/**
*
**/
private listen;
/**
* Create a hash of a string.
*
* @param {string} data Data to produce hash of
*/
private hash;
/**
* Sets filmout direction.
*
* @param {boolean} dir Direction of filmout
**/
set(dir: boolean): void;
/**
* Moves filmout a frame at a time.
*
* @returns {number} Time since start
**/
move(): Promise<number>;
/**
* Begin the process of exporting single frames from the video for display.
**/
start(): Promise<void>;
/**
* Ends the filmout process and closes the display.
**/
end(): Promise<void>;
/**
* Use a video file as a film out source on "projector"
*
* @param {object} evt Original connect event
* @param {object} arg Arguments from ipc message
*
* @returns {boolean} Success state
**/
onConnect(evt: IpcMainEvent, arg: any): Promise<boolean>;
/**
* Pre-export all frames from video for display.
*
* @param {object} evt IPC event
* @param {object} arg IPC args
*
* @returns {any} UI send call
*/
onPreExport(evt: IpcMainEvent, arg: any): Promise<any>;
/**
* Return true if gif is animated, false if it is a still
*
* @param {string} pathStr Path to gif to check
*
* @returns {boolean} Whether or not gif is animated
**/
isGifAnimated(pathStr: string): Promise<boolean>;
/**
* Return information on a still image using the Jimp module
*
* @param {string} pathStr Path to gif to check
*
* @returns {object} Info about still from sharp
**/
stillInfo(pathStr: string): Promise<any>;
/**
* Return information on the first still image found in a
* directory using the Jimp module.
*
* @param {array} images List of image paths
*
* @returns {object} Info about first image
**/
dirInfo(images: string[]): Promise<any>;
/**
* Returns a list of images within a directory, filtered
* for supported types and sorted.
*
* @param {string} pathStr Path to directory
*
* @returns {array} Array of image paths
**/
dirList(pathStr: string): Promise<string[]>;
/**
* Preview a frame from the selected video.
*
* @param {object} evt Original event
* @param {object} arg Arguments from message
**/
previewFrame(evt: IpcMainEvent, arg: any): Promise<void>;
/**
* Open a single frame in a display window to preview filmout.
*
* @param {object} evt Original event
* @param {object} arg Arguments from message
**/
preview(evt: IpcMainEvent, arg: any): Promise<void>;
/**
*
**/
focus(evt: IpcMainEvent, arg: any): Promise<void>;
/**
*
**/
field(evt: IpcMainEvent, arg: any): Promise<void>;
/**
*
**/
meter(evt: IpcMainEvent, arg: any): Promise<void>;
/**
*
**/
close(evt: IpcMainEvent, arg: any): Promise<void>;
/**
*
**/
onDisplay(evt: IpcMainEvent, arg: any): void;
}
export type { FilmOutState };

View File

@ -3,14 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const sharp_1 = __importDefault(require("sharp"));
exports.FilmOut = void 0;
const electron_1 = require("electron");
const animated_gif_detector_1 = __importDefault(require("animated-gif-detector"));
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const delay_1 = require("delay");
const crypto_1 = require("crypto");
const frame_1 = require("frame");
const log_1 = require("log");
/** @module lib/filmout */
/**
* @module FilmOut
**/
* Class representing all filmout features.
*/
class FilmOut {
/**
* @constructor
@ -22,22 +27,30 @@ class FilmOut {
* @param {object} ui Electron ui object
* @param {object} light Light device object
**/
constructor(display, ffmpeg, ffprobe, ui, light) {
constructor(display, server, ffmpeg, ffprobe, ui, light) {
this.id = 'filmout';
this.videoExtensions = ['.mpg', '.mpeg', '.mov', '.mkv', '.avi', '.mp4'];
this.stillExtensions = ['.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp'];
this.sequenceExtensions = ['.png', '.jpg', '.jpeg'];
this.gifExtension = '.gif';
this.state = {
hash: null,
frame: 0,
frames: 0,
fps: 24,
seconds: 0,
still: false,
path: null,
fileName: null,
directory: false,
info: {},
dir: true,
enabled: false
enabled: false,
files: []
};
this.ipc = electron_1.ipcMain;
this.display = display;
this.server = server;
this.ffmpeg = ffmpeg;
this.ffprobe = ffprobe;
this.ui = ui;
@ -48,9 +61,7 @@ class FilmOut {
* Async function for requiring log, ipcMain and bind events.
**/
async init() {
const Log = require('log');
this.log = await Log({ label: this.id });
this.ipc = require('electron').ipcMain;
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
@ -65,6 +76,18 @@ class FilmOut {
this.ipc.on('preview', this.preview.bind(this));
this.ipc.on('preview_frame', this.previewFrame.bind(this));
this.ipc.on('display', this.onDisplay.bind(this));
this.ipc.on('pre_export', this.onPreExport.bind(this));
this.ffmpeg.onProgress = (obj) => {
this.ui.send('pre_export_progress', { progress: obj });
};
}
/**
* Create a hash of a string.
*
* @param {string} data Data to produce hash of
*/
hash(data) {
return (0, crypto_1.createHash)('sha1').update(data).digest('hex');
}
/**
* Sets filmout direction.
@ -76,11 +99,13 @@ class FilmOut {
}
/**
* Moves filmout a frame at a time.
*
* @returns {number} Time since start
**/
async move() {
let start = +new Date();
if (this.state.still) {
return false;
return -1;
}
if (this.state.dir) {
this.state.frame++;
@ -97,28 +122,26 @@ class FilmOut {
* Begin the process of exporting single frames from the video for display.
**/
async start() {
let path;
try {
await this.ffmpeg.clearAll();
path = await this.ffmpeg.frame(this.state, this.light.state);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
try {
await this.ffmpeg.frame(this.state, this.light.state);
if (this.server.displayImage(path)) {
await (0, delay_1.delay)(20);
return;
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
await this.display.show(this.state.frame);
await delay_1.delay(20);
await this.display.show(path);
await (0, delay_1.delay)(20);
}
/**
* Ends the filmout process and closes the display.
**/
async end() {
await delay_1.delay(20);
await (0, delay_1.delay)(20);
this.display.hide();
}
/**
@ -126,16 +149,29 @@ class FilmOut {
*
* @param {object} evt Original connect event
* @param {object} arg Arguments from ipc message
*
* @returns {boolean} Success state
**/
async onConnect(evt, arg) {
let frames = 0;
let isAnimated = false;
let info;
let ext;
ext = path_1.extname(arg.fileName.toLowerCase());
//console.dir(arg)
//console.log(ext)
if (ext === this.gifExtension) {
let stats;
let frameList;
try {
stats = await (0, fs_extra_1.lstat)(arg.path);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
return false;
}
ext = (0, path_1.extname)(arg.fileName.toLowerCase());
if (stats.isDirectory()) {
this.state.directory = true;
this.state.still = false;
}
else if (ext === this.gifExtension) {
try {
isAnimated = await this.isGifAnimated(arg.path);
}
@ -148,15 +184,46 @@ class FilmOut {
}
else if (this.stillExtensions.indexOf(ext) !== -1) {
this.state.still = true;
this.state.directory = false;
}
else if (this.videoExtensions.indexOf(ext) !== -1) {
this.state.still = false;
this.state.directory = false;
}
else {
this.log.error(`File is not of a valid file type`, 'FILMOUT', true, true);
return false;
}
if (this.state.still) {
try {
await this.ffmpeg.clearAll();
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
if (this.state.directory) {
try {
frameList = await this.dirList(arg.path);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid: false });
return false;
}
try {
info = await this.dirInfo(frameList);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid: false });
return false;
}
frames = frameList.length;
this.state.files = frameList;
}
else if (this.state.still) {
try {
info = await this.stillInfo(arg.path);
}
@ -188,16 +255,52 @@ class FilmOut {
return false;
}
}
//console.dir(info)
this.state.frame = 0;
this.state.path = arg.path;
this.state.fileName = arg.fileName;
this.state.frames = frames;
this.state.info = info;
this.state.hash = this.hash(arg.path);
if (info.fps) {
this.state.fps = info.fps;
}
else {
this.state.fps = 24; //default
}
if (info.seconds) {
this.state.seconds = info.seconds;
}
else if (info.fps && frames) {
this.state.seconds = frames / info.fps;
}
else if (this.state.directory) {
this.state.seconds = frames / 24;
}
this.log.info(`Opened ${this.state.fileName}`, 'FILMOUT', true, true);
this.log.info(`Frames : ${frames}`, 'FILMOUT', true, true);
this.state.enabled = true;
return await this.ui.send(this.id, { valid: true, state: JSON.stringify(this.state) });
await this.ui.send(this.id, { valid: true, state: JSON.stringify(this.state) });
return true;
}
/**
* Pre-export all frames from video for display.
*
* @param {object} evt IPC event
* @param {object} arg IPC args
*
* @returns {any} UI send call
*/
async onPreExport(evt, arg) {
if (!this.state.path) {
return await this.ui.send('pre_export', { complete: false, err: 'No file to pre export.' });
}
try {
await this.ffmpeg.frames(this.state);
}
catch (err) {
return await this.ui.send('pre_export', { complete: false, err });
}
return await this.ui.send('pre_export', { complete: true });
}
/**
* Return true if gif is animated, false if it is a still
@ -209,23 +312,77 @@ class FilmOut {
async isGifAnimated(pathStr) {
let gifBuffer;
try {
gifBuffer = await fs_extra_1.readFile(pathStr);
gifBuffer = await (0, fs_extra_1.readFile)(pathStr);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
return false;
}
return animated_gif_detector_1.default(gifBuffer);
return (0, animated_gif_detector_1.default)(gifBuffer);
}
/**
* Return information on a still image using the sharp module
* Return information on a still image using the Jimp module
*
* @param {string} pathStr Path to gif to check
*
* @returns {object} Info about still from sharp
**/
async stillInfo(pathStr) {
return sharp_1.default(pathStr).metadata();
let info;
try {
info = await frame_1.Frame.info(pathStr);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
return info;
}
/**
* Return information on the first still image found in a
* directory using the Jimp module.
*
* @param {array} images List of image paths
*
* @returns {object} Info about first image
**/
async dirInfo(images) {
let info;
try {
info = await this.stillInfo(images[0]);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
return info;
}
/**
* Returns a list of images within a directory, filtered
* for supported types and sorted.
*
* @param {string} pathStr Path to directory
*
* @returns {array} Array of image paths
**/
async dirList(pathStr) {
let frameList = [];
try {
frameList = await (0, fs_extra_1.readdir)(pathStr);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
frameList = frameList.filter((fileName) => {
let ext = (0, path_1.extname)(fileName);
if (this.sequenceExtensions.indexOf(ext) !== -1) {
return true;
}
return false;
});
frameList.sort();
frameList = frameList.map((fileName) => {
return (0, path_1.join)(pathStr, fileName);
});
return frameList;
}
/**
* Preview a frame from the selected video.
@ -242,13 +399,12 @@ class FilmOut {
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
;
throw err;
}
this.ui.send('preview_frame', { path, frame: arg.frame });
}
/**
*
* Open a single frame in a display window to preview filmout.
*
* @param {object} evt Original event
* @param {object} arg Arguments from message
@ -266,8 +422,11 @@ class FilmOut {
throw err;
}
try {
if (await this.server.displayImage(path)) {
return;
}
await this.display.open();
await this.display.show(arg.frame);
await this.display.show(path);
}
catch (err) {
this.log.error(err, 'FILMOUT', true, true);
@ -279,6 +438,9 @@ class FilmOut {
async focus(evt, arg) {
this.log.info(`Showing focus screen`);
try {
if (await this.server.cmdAll('focus')) {
return;
}
await this.display.open();
await this.display.focus();
}
@ -293,6 +455,9 @@ class FilmOut {
const ratio = arg.ratio;
this.log.info(`Showing field guide screen`);
try {
if (await this.server.cmdAll('field', { ratio })) {
return;
}
await this.display.open();
await this.display.field(ratio);
}
@ -306,6 +471,9 @@ class FilmOut {
async meter(evt, arg) {
this.log.info(`Showing meter screen`);
try {
if (await this.server.cmdAll('meter')) {
return;
}
await this.display.open();
await this.display.meter();
}
@ -318,6 +486,9 @@ class FilmOut {
**/
async close(evt, arg) {
try {
if (await this.server.cmdAll('blank')) {
return;
}
await this.display.hide();
await this.display.close();
}
@ -333,7 +504,6 @@ class FilmOut {
this.log.info(`Changing the display to ${arg.display}`);
}
}
module.exports = (display, ffmpeg, ffprobe, ui, light) => {
return new FilmOut(display, ffmpeg, ffprobe, ui, light);
};
exports.FilmOut = FilmOut;
module.exports = { FilmOut };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

9
app/lib/frame/Readme.md Normal file
View File

@ -0,0 +1,9 @@
<a name="module_lib/frame"></a>
## lib/frame
<a name="module_lib/frame..Frame"></a>
### lib/frame~Frame
Class representing the static Frame module.
**Kind**: inner class of [<code>lib/frame</code>](#module_lib/frame)

19
app/lib/frame/index.d.ts vendored Normal file
View File

@ -0,0 +1,19 @@
interface RGBA {
r: number;
g: number;
b: number;
a: number;
}
/** @module lib/frame */
/**
* Class representing the static Frame module.
*/
export declare class Frame {
static info(imagePath: string): Promise<{
width: any;
height: any;
}>;
static solidColor(width: number, height: number, color: RGBA): Promise<unknown>;
static blend(inPath: any, color: RGBA, imagePath: string): Promise<string>;
}
export type { RGBA };

75
app/lib/frame/index.js Normal file
View File

@ -0,0 +1,75 @@
'use strict';
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Frame = void 0;
const jimp_1 = __importDefault(require("jimp"));
/** @module lib/frame */
/**
* Class representing the static Frame module.
*/
class Frame {
static async info(imagePath) {
let image;
try {
image = await jimp_1.default.read(imagePath);
}
catch (err) {
throw err;
}
return {
width: image.bitmap.width,
height: image.bitmap.height
};
}
static async solidColor(width, height, color) {
//@ts-ignore
const colorInt = jimp_1.default.rgbaToInt(color.r, color.g, color.b, color.a);
return new Promise((resolve, reject) => {
return new jimp_1.default(width, height, colorInt, (err, image) => {
if (err) {
return reject(err);
}
return resolve(image);
});
});
}
static async blend(inPath, color, imagePath) {
//cmd2 = `${this.convert} "${tmpoutput}" -resize ${w}x${h} -size ${w}x${h} xc:"rgb(${rgb[0]},${rgb[1]},${rgb[2]})" +swap -compose Darken -composite "${tmpoutput}"`;
const options = {
mode: jimp_1.default.BLEND_DARKEN,
opacitySource: 1.0,
opacityDest: 1.0
};
let width;
let height;
let bottom;
let top;
try {
top = await jimp_1.default.read(inPath);
}
catch (err) {
throw err;
}
width = top.bitmap.width;
height = top.bitmap.height;
try {
bottom = await Frame.solidColor(width, height, color);
}
catch (err) {
throw err;
}
bottom.composite(top, 0, 0, options);
try {
await bottom.writeAsync(imagePath);
}
catch (err) {
throw err;
}
return imagePath;
}
}
exports.Frame = Frame;
module.exports = { Frame };
//# sourceMappingURL=index.js.map

View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/frame/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;;;;;;AAEb,gDAAwB;AASxB,wBAAwB;AAExB;;GAEG;AAEH,MAAa,KAAK;IACjB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAE,SAAkB;QACpC,IAAI,KAAW,CAAC;QAChB,IAAI;YACH,KAAK,GAAG,MAAM,cAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACnC;QAAC,OAAO,GAAG,EAAE;YACb,MAAM,GAAG,CAAC;SACV;QACD,OAAO;YACN,KAAK,EAAG,KAAK,CAAC,MAAM,CAAC,KAAK;YAC1B,MAAM,EAAG,KAAK,CAAC,MAAM,CAAC,MAAM;SAC5B,CAAC;IACH,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,UAAU,CAAE,KAAc,EAAE,MAAe,EAAE,KAAY;QACrE,YAAY;QACZ,MAAM,QAAQ,GAAY,cAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7E,OAAO,IAAI,OAAO,CAAC,CAAC,OAAkB,EAAE,MAAiB,EAAE,EAAE;YAC5D,OAAO,IAAI,cAAI,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;gBACrD,IAAI,GAAG,EAAE;oBACR,OAAO,MAAM,CAAC,GAAG,CAAC,CAAA;iBAClB;gBACD,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;YACzB,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,KAAK,CAAE,MAAY,EAAE,KAAY,EAAE,SAAkB;QACjE,oKAAoK;QACpK,MAAM,OAAO,GAAS;YACrB,IAAI,EAAE,cAAI,CAAC,YAAY;YACvB,aAAa,EAAE,GAAG;YAClB,WAAW,EAAE,GAAG;SAChB,CAAC;QACF,IAAI,KAAc,CAAC;QACnB,IAAI,MAAe,CAAC;QACpB,IAAI,MAAY,CAAC;QACjB,IAAI,GAAS,CAAC;QAEd,IAAI;YACH,GAAG,GAAG,MAAM,cAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAC9B;QAAC,OAAO,GAAG,EAAE;YACb,MAAM,GAAG,CAAC;SACV;QAED,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC;QACzB,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC;QAE3B,IAAI;YACH,MAAM,GAAG,MAAM,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;SACtD;QAAC,OAAO,GAAG,EAAE;YACb,MAAM,GAAG,CAAC;SACV;QAED,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;QAErC,IAAI;YACH,MAAM,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;SACnC;QAAC,OAAO,GAAG,EAAE;YACb,MAAM,GAAG,CAAC;SACV;QAED,OAAO,SAAS,CAAC;IAClB,CAAC;CACD;AA/DD,sBA+DC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,KAAK,EAAE,CAAA"}

View File

@ -1,5 +1,5 @@
{
"name": "exit",
"name": "frame",
"version": "1.0.0",
"description": "",
"main": "index.js",

View File

@ -0,0 +1,9 @@
<a name="module_lib/intval"></a>
## lib/intval
<a name="module_lib/intval..Intval"></a>
### lib/intval~Intval
Class representing all intval3 camera features.
**Kind**: inner class of [<code>lib/intval</code>](#module_lib/intval)

12
app/lib/intval/index.d.ts vendored Normal file
View File

@ -0,0 +1,12 @@
/** @module lib/intval */
/**
* Class representing all intval3 camera features.
*/
export declare class Intval {
private _baseUrl;
constructor(url: string);
move(): Promise<number>;
setDir(dir: boolean): Promise<number>;
setExposure(exposure: number, cb: Function): Promise<number>;
connect(cb: Function): void;
}

View File

@ -1,15 +1,44 @@
'use strict';
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Intval = void 0;
const request = __importStar(require("request"));
/** @module lib/intval */
/**
* Class representing all intval3 camera features.
*/
class Intval {
constructor(url) {
this._baseUrl = `http://${url}`;
this.req = require('request');
}
async move() {
return new Promise((resolve, reject) => {
const timeStart = +new Date();
const url = `${this._baseUrl}/frame`;
//console.log(url)
return this.req(url, (err, res, body) => {
return request(url, (err, res, body) => {
let ms = (+new Date()) - timeStart;
if (err) {
return reject(err);
@ -23,7 +52,7 @@ class Intval {
const timeStart = +new Date();
const url = `${this._baseUrl}/dir?dir=${dir}`;
//console.log(url)
return this.req(url, (err, res, body) => {
return request(url, (err, res, body) => {
let ms = (+new Date()) - timeStart;
if (err) {
return reject(err);
@ -36,8 +65,7 @@ class Intval {
return new Promise((resolve, reject) => {
const timeStart = +new Date();
const url = `${this._baseUrl}/exposure?exposure=${exposure}`;
//console.log(url)
return this.req(url, (err, res, body) => {
return request(url, (err, res, body) => {
let ms = (+new Date()) - timeStart;
if (err) {
return reject(err);
@ -54,15 +82,15 @@ class Intval {
uri: url,
timeout: 5000
};
this.req(opts, (err, res, body) => {
request(opts, (err, res, body) => {
let ms = (+new Date()) - timeStart;
if (err) {
//console.error(err)
return cb(err, ms);
}
cb(null, ms, body);
});
}
}
module.exports.Intval = Intval;
exports.Intval = Intval;
module.exports = { Intval };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/intval/index.ts"],"names":[],"mappings":"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"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/intval/index.ts"],"names":[],"mappings":"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"}

View File

@ -1,32 +1,46 @@
<a name="Light"></a>
<a name="module_lib/light"></a>
## Light
**Kind**: global class
## lib/light
* [Light](#Light)
* [.init()](#Light+init)
* [.listen()](#Light+listen)
* [.listener()](#Light+listener)
* [.set()](#Light+set)
* [.end()](#Light+end)
* [lib/light](#module_lib/light)
* [~Light](#module_lib/light..Light)
* [.init()](#module_lib/light..Light+init)
* [.listen()](#module_lib/light..Light+listen)
* [.listener()](#module_lib/light..Light+listener)
* [.set()](#module_lib/light..Light+set)
* [.end()](#module_lib/light..Light+end)
<a name="Light+init"></a>
<a name="module_lib/light..Light"></a>
### light.init()
**Kind**: instance method of [<code>Light</code>](#Light)
<a name="Light+listen"></a>
### lib/light~Light
Class representing the all light features.
### light.listen()
**Kind**: instance method of [<code>Light</code>](#Light)
<a name="Light+listener"></a>
**Kind**: inner class of [<code>lib/light</code>](#module_lib/light)
### light.listener()
**Kind**: instance method of [<code>Light</code>](#Light)
<a name="Light+set"></a>
* [~Light](#module_lib/light..Light)
* [.init()](#module_lib/light..Light+init)
* [.listen()](#module_lib/light..Light+listen)
* [.listener()](#module_lib/light..Light+listener)
* [.set()](#module_lib/light..Light+set)
* [.end()](#module_lib/light..Light+end)
### light.set()
**Kind**: instance method of [<code>Light</code>](#Light)
<a name="Light+end"></a>
<a name="module_lib/light..Light+init"></a>
### light.end()
**Kind**: instance method of [<code>Light</code>](#Light)
#### light.init()
**Kind**: instance method of [<code>Light</code>](#module_lib/light..Light)
<a name="module_lib/light..Light+listen"></a>
#### light.listen()
**Kind**: instance method of [<code>Light</code>](#module_lib/light..Light)
<a name="module_lib/light..Light+listener"></a>
#### light.listener()
**Kind**: instance method of [<code>Light</code>](#module_lib/light..Light)
<a name="module_lib/light..Light+set"></a>
#### light.set()
**Kind**: instance method of [<code>Light</code>](#module_lib/light..Light)
<a name="module_lib/light..Light+end"></a>
#### light.end()
**Kind**: instance method of [<code>Light</code>](#module_lib/light..Light)

45
app/lib/light/index.d.ts vendored Normal file
View File

@ -0,0 +1,45 @@
import type { Arduino } from 'arduino';
import type { Config } from 'cfg';
import type { WebContents } from 'electron';
interface LightState {
color: number[];
}
/** @module lib/light */
/**
* Class representing the all light features.
*/
export declare class Light {
state: LightState;
private arduino;
private cfg;
private ui;
private log;
private ipc;
private enabled;
private id;
/**
*
**/
constructor(arduino: Arduino, cfg: Config, ui: WebContents);
/**
*
**/
private init;
/**
*
**/
private listen;
/**
*
**/
private listener;
/**
*
**/
set(rgb: number[], id: string, on?: boolean): Promise<number>;
/**
*
**/
private end;
}
export type { LightState };

View File

@ -1,13 +1,20 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Light = void 0;
const electron_1 = require("electron");
const delay_1 = require("delay");
const Log = require("log");
const log_1 = require("log");
/** @module lib/light */
/**
* Class representing the all light features.
*/
class Light {
/**
*
**/
constructor(arduino, cfg, ui) {
this.state = { color: [0, 0, 0] };
this.ipc = electron_1.ipcMain;
this.enabled = true;
this.id = 'light';
this.arduino = arduino;
@ -19,15 +26,14 @@ class Light {
*
**/
async init() {
this.log = await Log({ label: this.id });
this.ipc = require('electron').ipcMain;
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
*
**/
listen() {
this.ipc.on(this.id, this.listener.bind(this));
this.ipc.handle(this.id, this.listener.bind(this));
}
/**
*
@ -47,41 +53,48 @@ class Light {
else if (typeof arg.disable !== 'undefined') {
this.enabled = false;
}
event.returnValue = true;
}
/**
*
**/
async set(rgb, id, on) {
async set(rgb, id, on = true) {
const str = rgb.join(',');
let ms;
this.state.color = rgb;
try {
ms = this.arduino.send(this.id, this.cfg.arduino.cmd.light);
ms = await this.arduino.send(this.id, this.cfg.arduino.cmd.light);
}
catch (err) {
this.log.error('Error sending light command', err);
}
await delay_1.delay(1);
await (0, delay_1.delay)(1);
try {
this.arduino.string(this.id, str);
ms += await this.arduino.sendString(this.id, str);
}
catch (err) {
this.log.error('Error sending light string', err);
}
await delay_1.delay(1);
await ms;
return await this.end(rgb, id, ms);
await (0, delay_1.delay)(1);
ms += 2;
await this.end(rgb, id, ms);
return ms;
}
/**
*
**/
async end(rgb, id, ms) {
let res;
this.log.info(`Light set to ${rgb.join(',')}`, 'LIGHT', true, true);
return await this.ui.send(this.id, { rgb: rgb, id: id, ms: ms });
try {
res = await this.ui.send(this.id, { rgb, id, ms });
}
catch (err) {
this.log.error(`Error ending light`, err);
throw err;
}
return res;
}
}
module.exports = function (arduino, cfg, ui) {
return new Light(arduino, cfg, ui);
};
exports.Light = Light;
module.exports = { Light };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/light/index.ts"],"names":[],"mappings":"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"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/light/index.ts"],"names":[],"mappings":"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"}

View File

@ -1,3 +1,16 @@
## Functions
<dl>
<dt><a href="#logFile">logFile()</a><code>string</code></dt>
<dd><p>Determine the location of the log file based on the operating system
and return as an absolute string from os.homedir()</p>
</dd>
<dt><a href="#Log">Log(arg)</a><code>object</code></dt>
<dd><p>Create and return the logger transport based on settings determined in
arguments object</p>
</dd>
</dl>
<a name="logFile"></a>
## logFile() ⇒ <code>string</code>
@ -6,3 +19,16 @@ and return as an absolute string from os.homedir()
**Kind**: global function
**Returns**: <code>string</code> - Path to log file
<a name="Log"></a>
## Log(arg) ⇒ <code>object</code>
Create and return the logger transport based on settings determined in
arguments object
**Kind**: global function
**Returns**: <code>object</code> - Logger transport
| Param | Type | Description |
| --- | --- | --- |
| arg | <code>object</code> | Arguments from process |

10
app/lib/log/index.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
import type { Logger } from 'winston';
/**
* Create and return the logger transport based on settings determined in
* arguments object
*
* @param {object} arg Arguments from process
*
* @returns {object} Logger transport
**/
export declare function Log(arg: any): Promise<Logger>;

View File

@ -1,11 +1,11 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Log = void 0;
const winston_1 = require("winston");
const path_1 = require("path");
const fs_extra_1 = require("fs-extra");
const os_1 = require("os");
const logTime = 'MM/DD/YY-HH:mm:ss';
let transport;
/**
* Determine the location of the log file based on the operating system
* and return as an absolute string from os.homedir()
@ -13,23 +13,34 @@ let transport;
* @returns {string} Path to log file
**/
async function logFile() {
const homeDir = os_1.homedir();
const linuxDir = `/.config/mcopy/`;
const homeDir = (0, os_1.homedir)();
const linuxDir = `/.mcopy/`;
const macDir = `/Library/Logs/mcopy/`;
const winDir = `/AppData/Roaming/mcopy/`;
let logPath = path_1.join(homeDir, linuxDir);
let logPath = (0, path_1.normalize)((0, path_1.join)(homeDir, linuxDir));
let dirExists;
if (process.platform === 'darwin') {
logPath = path_1.join(homeDir, macDir);
logPath = (0, path_1.normalize)((0, path_1.join)(homeDir, macDir));
}
else if (process.platform === 'win32') {
logPath = path_1.join(homeDir, winDir);
logPath = (0, path_1.normalize)((0, path_1.join)(homeDir, winDir));
}
try {
dirExists = await (0, fs_extra_1.exists)(logPath);
}
catch (err) {
console.error(err);
}
dirExists = await fs_extra_1.exists(logPath);
if (!dirExists) {
await fs_extra_1.mkdir(logPath);
try {
await (0, fs_extra_1.mkdir)(logPath);
}
catch (err) {
console.error(`Error creating directory for mcopy log file, ${logPath}`);
console.error(err);
}
}
return path_1.join(logPath, 'mcopy.log');
return (0, path_1.join)(logPath, 'mcopy.log');
}
/**
* Create and return the logger transport based on settings determined in
@ -39,7 +50,8 @@ async function logFile() {
*
* @returns {object} Logger transport
**/
module.exports = async function (arg) {
async function Log(arg) {
let transport;
let consoleFormat = {
colorize: true
};
@ -47,28 +59,21 @@ module.exports = async function (arg) {
filename: await logFile(),
json: true
};
if (arg && arg.quiet) {
transport = {
info: function () { return false; },
warn: function () { return false; },
error: function () { return false; }
};
}
else {
if (arg && arg.label) {
consoleFormat.label = arg.label;
fileFormat.label = arg.label;
}
transport = winston_1.createLogger({
format: winston_1.format.combine(winston_1.format.label({ label: arg.label || 'mcopy' }), winston_1.format.timestamp({
format: 'YYYY-MM-DD HH:mm:ss'
}), winston_1.format.printf((info) => `${info.timestamp} [${info.label}] ${info.level}: ${info.message}` + (info.splat !== undefined ? `${info.splat}` : " "))),
transports: [
new (winston_1.transports.Console)(consoleFormat),
new (winston_1.transports.File)(fileFormat)
]
});
if (arg && arg.label) {
consoleFormat.label = arg.label;
fileFormat.label = arg.label;
}
transport = (0, winston_1.createLogger)({
format: winston_1.format.combine(winston_1.format.label({ label: arg.label || 'mcopy' }), winston_1.format.timestamp({
format: 'YYYY-MM-DD HH:mm:ss'
}), winston_1.format.printf((info) => `${info.timestamp} [${info.label}] ${info.level}: ${info.message}` + (info.splat !== undefined ? `${info.splat}` : " "))),
transports: [
new (winston_1.transports.Console)(consoleFormat),
new (winston_1.transports.File)(fileFormat)
]
});
return transport;
};
}
exports.Log = Log;
module.exports = { Log };
//# sourceMappingURL=index.js.map

View File

@ -1 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/log/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;;AAEZ,qCAA2D;AAC3D,+BAA4B;AAC5B,uCAAyC;AACzC,2BAA6B;AAE7B,MAAM,OAAO,GAAG,mBAAmB,CAAA;AACnC,IAAI,SAAe,CAAA;AAEnB;;;;;IAKI;AACJ,KAAK,UAAU,OAAO;IACrB,MAAM,OAAO,GAAY,YAAO,EAAE,CAAC;IACnC,MAAM,QAAQ,GAAY,iBAAiB,CAAC;IAC5C,MAAM,MAAM,GAAY,sBAAsB,CAAC;IAC/C,MAAM,MAAM,GAAY,yBAAyB,CAAC;IAClD,IAAI,OAAO,GAAY,WAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC/C,IAAI,SAAmB,CAAC;IAExB,IAAI,OAAO,CAAC,QAAQ,KAAK,QAAQ,EAAE;QAClC,OAAO,GAAG,WAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;KAChC;SAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE;QACxC,OAAO,GAAG,WAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;KAChC;IACD,SAAS,GAAG,MAAM,iBAAM,CAAC,OAAO,CAAC,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE;QACf,MAAM,gBAAK,CAAC,OAAO,CAAC,CAAC;KACrB;IACD,OAAO,WAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;AACnC,CAAC;AACD;;;;;;;IAOI;AACJ,MAAM,CAAC,OAAO,GAAG,KAAK,WAAW,GAAS;IACzC,IAAI,aAAa,GAAS;QACzB,QAAQ,EAAG,IAAI;KACf,CAAA;IACD,IAAI,UAAU,GAAS;QACtB,QAAQ,EAAG,MAAM,OAAO,EAAE;QAC1B,IAAI,EAAG,IAAI;KACX,CAAA;IACD,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,EAAE;QACrB,SAAS,GAAG;YACX,IAAI,EAAG,cAAc,OAAO,KAAK,CAAA,CAAC,CAAC;YACnC,IAAI,EAAG,cAAc,OAAO,KAAK,CAAA,CAAC,CAAC;YACnC,KAAK,EAAG,cAAc,OAAO,KAAK,CAAA,CAAC,CAAC;SACpC,CAAA;KACD;SAAM;QACN,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,EAAE;YACrB,aAAa,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;YAChC,UAAU,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;SAC7B;QACD,SAAS,GAAG,sBAAY,CAAC;YACxB,MAAM,EAAG,gBAAM,CAAC,OAAO,CACnB,gBAAM,CAAC,KAAK,CAAC,EAAE,KAAK,EAAG,GAAG,CAAC,KAAK,IAAI,OAAO,EAAE,CAAC,EACjD,gBAAM,CAAC,SAAS,CAAC;gBAChB,MAAM,EAAE,qBAAqB;aAC7B,CAAC,EACF,gBAAM,CAAC,MAAM,CAAC,CAAC,IAAU,EAAG,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,GAAC,CAAC,IAAI,CAAC,KAAK,KAAG,SAAS,CAAA,CAAC,CAAA,GAAG,IAAI,CAAC,KAAK,EAAE,CAAA,CAAC,CAAA,GAAG,CAAC,CAAC,CAC7I;YACH,UAAU,EAAE;gBACX,IAAI,CAAC,oBAAU,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC;gBACvC,IAAI,CAAC,oBAAU,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC;aACjC;SACD,CAAC,CAAA;KACF;IACD,OAAO,SAAS,CAAA;AACjB,CAAC,CAAA"}
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/log/index.ts"],"names":[],"mappings":"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"}

View File

@ -3,57 +3,83 @@
## lib/mscript
* [lib/mscript](#module_lib/mscript)
* [~Create new Mscript interpreter](#module_lib/mscript..Create new Mscript interpreter)
* [~Mscript](#module_lib/mscript..Mscript)
* [.clear()](#module_lib/mscript..Mscript+clear)
* [.interpret()](#module_lib/mscript..Mscript+interpret)
* [.basic_cmd()](#module_lib/mscript..Mscript+basic_cmd)
* [.new_loop()](#module_lib/mscript..Mscript+new_loop)
* [.end_loop()](#module_lib/mscript..Mscript+end_loop)
* [.move_cam()](#module_lib/mscript..Mscript+move_cam)
* [.move_proj()](#module_lib/mscript..Mscript+move_proj)
* [.set_state()](#module_lib/mscript..Mscript+set_state)
* [.last_loop()](#module_lib/mscript..Mscript+last_loop)
* [.parent_loop()](#module_lib/mscript..Mscript+parent_loop)
* [.loop_count()](#module_lib/mscript..Mscript+loop_count)
* [.fade()](#module_lib/mscript..Mscript+fade)
* [.fade_count()](#module_lib/mscript..Mscript+fade_count)
* [.fade_start()](#module_lib/mscript..Mscript+fade_start)
* [.fade_end()](#module_lib/mscript..Mscript+fade_end)
* [.update()](#module_lib/mscript..Mscript+update)
* [.str_to_arr()](#module_lib/mscript..Mscript+str_to_arr)
* [.light_to_arr()](#module_lib/mscript..Mscript+light_to_arr)
* [.light_state()](#module_lib/mscript..Mscript+light_state)
* [.fail()](#module_lib/mscript..Mscript+fail)
* [~startsWith()](#module_lib/mscript..startsWith)
* [.interpret(text, callback)](#module_lib/mscript..Mscript+interpret) ⇒ <code>object</code>
* [.variable(line)](#module_lib/mscript..Mscript+variable)
* [.variable_replace(line)](#module_lib/mscript..Mscript+variable_replace) ⇒ <code>string</code>
* [.basic_cmd(line, short)](#module_lib/mscript..Mscript+basic_cmd)
* [.new_loop(line, fade)](#module_lib/mscript..Mscript+new_loop)
* [.end_loop(line)](#module_lib/mscript..Mscript+end_loop)
* [.move_cam(line)](#module_lib/mscript..Mscript+move_cam)
* [.move_cam2(line)](#module_lib/mscript..Mscript+move_cam2)
* [.move_proj(line)](#module_lib/mscript..Mscript+move_proj)
* [.move_proj2(line)](#module_lib/mscript..Mscript+move_proj2)
* [.set_state(line)](#module_lib/mscript..Mscript+set_state)
* [.last_loop()](#module_lib/mscript..Mscript+last_loop) ⇒ <code>object</code>
* [.parent_loop()](#module_lib/mscript..Mscript+parent_loop) ⇒ <code>object</code>
* [.loop_count()](#module_lib/mscript..Mscript+loop_count) ⇒ <code>integer</code>
* [.fade(line)](#module_lib/mscript..Mscript+fade)
* [.fade_count(str)](#module_lib/mscript..Mscript+fade_count)
* [.fade_start(str)](#module_lib/mscript..Mscript+fade_start) ⇒ <code>array</code>
* [.fade_end(str)](#module_lib/mscript..Mscript+fade_end) ⇒ <code>array</code>
* [.fade_rgb(start, end, len, x)](#module_lib/mscript..Mscript+fade_rgb) ⇒ <code>array</code>
* [.rgb(str)](#module_lib/mscript..Mscript+rgb)
* [.rgb_str(arr)](#module_lib/mscript..Mscript+rgb_str) ⇒ <code>string</code>
* [.update(cmd)](#module_lib/mscript..Mscript+update)
* [.str_to_arr(str, cmd)](#module_lib/mscript..Mscript+str_to_arr) ⇒ <code>array</code>
* [.light_to_arr(str, cmd)](#module_lib/mscript..Mscript+light_to_arr) ⇒ <code>array</code>
* [.light_state(Color)](#module_lib/mscript..Mscript+light_state)
* [.delay(line)](#module_lib/mscript..Mscript+delay)
* [.alert(line)](#module_lib/mscript..Mscript+alert)
* [.pause(line)](#module_lib/mscript..Mscript+pause)
* [.fail(msg)](#module_lib/mscript..Mscript+fail)
* [.contains(arr, arr2)](#module_lib/mscript..Mscript+contains) ⇒ <code>boolean</code>
<a name="module_lib/mscript..Create new Mscript interpreter"></a>
### lib/mscript~Create new Mscript interpreter
**Kind**: inner class of [<code>lib/mscript</code>](#module_lib/mscript)
<a name="module_lib/mscript..Mscript"></a>
### lib/mscript~Mscript
class Mscript
Class representing the mscript language.
**Kind**: inner class of [<code>lib/mscript</code>](#module_lib/mscript)
* [~Mscript](#module_lib/mscript..Mscript)
* [.clear()](#module_lib/mscript..Mscript+clear)
* [.interpret()](#module_lib/mscript..Mscript+interpret)
* [.basic_cmd()](#module_lib/mscript..Mscript+basic_cmd)
* [.new_loop()](#module_lib/mscript..Mscript+new_loop)
* [.end_loop()](#module_lib/mscript..Mscript+end_loop)
* [.move_cam()](#module_lib/mscript..Mscript+move_cam)
* [.move_proj()](#module_lib/mscript..Mscript+move_proj)
* [.set_state()](#module_lib/mscript..Mscript+set_state)
* [.last_loop()](#module_lib/mscript..Mscript+last_loop)
* [.parent_loop()](#module_lib/mscript..Mscript+parent_loop)
* [.loop_count()](#module_lib/mscript..Mscript+loop_count)
* [.fade()](#module_lib/mscript..Mscript+fade)
* [.fade_count()](#module_lib/mscript..Mscript+fade_count)
* [.fade_start()](#module_lib/mscript..Mscript+fade_start)
* [.fade_end()](#module_lib/mscript..Mscript+fade_end)
* [.update()](#module_lib/mscript..Mscript+update)
* [.str_to_arr()](#module_lib/mscript..Mscript+str_to_arr)
* [.light_to_arr()](#module_lib/mscript..Mscript+light_to_arr)
* [.light_state()](#module_lib/mscript..Mscript+light_state)
* [.fail()](#module_lib/mscript..Mscript+fail)
* [.interpret(text, callback)](#module_lib/mscript..Mscript+interpret) ⇒ <code>object</code>
* [.variable(line)](#module_lib/mscript..Mscript+variable)
* [.variable_replace(line)](#module_lib/mscript..Mscript+variable_replace) ⇒ <code>string</code>
* [.basic_cmd(line, short)](#module_lib/mscript..Mscript+basic_cmd)
* [.new_loop(line, fade)](#module_lib/mscript..Mscript+new_loop)
* [.end_loop(line)](#module_lib/mscript..Mscript+end_loop)
* [.move_cam(line)](#module_lib/mscript..Mscript+move_cam)
* [.move_cam2(line)](#module_lib/mscript..Mscript+move_cam2)
* [.move_proj(line)](#module_lib/mscript..Mscript+move_proj)
* [.move_proj2(line)](#module_lib/mscript..Mscript+move_proj2)
* [.set_state(line)](#module_lib/mscript..Mscript+set_state)
* [.last_loop()](#module_lib/mscript..Mscript+last_loop) ⇒ <code>object</code>
* [.parent_loop()](#module_lib/mscript..Mscript+parent_loop) ⇒ <code>object</code>
* [.loop_count()](#module_lib/mscript..Mscript+loop_count) ⇒ <code>integer</code>
* [.fade(line)](#module_lib/mscript..Mscript+fade)
* [.fade_count(str)](#module_lib/mscript..Mscript+fade_count)
* [.fade_start(str)](#module_lib/mscript..Mscript+fade_start) ⇒ <code>array</code>
* [.fade_end(str)](#module_lib/mscript..Mscript+fade_end) ⇒ <code>array</code>
* [.fade_rgb(start, end, len, x)](#module_lib/mscript..Mscript+fade_rgb) ⇒ <code>array</code>
* [.rgb(str)](#module_lib/mscript..Mscript+rgb)
* [.rgb_str(arr)](#module_lib/mscript..Mscript+rgb_str) ⇒ <code>string</code>
* [.update(cmd)](#module_lib/mscript..Mscript+update)
* [.str_to_arr(str, cmd)](#module_lib/mscript..Mscript+str_to_arr) ⇒ <code>array</code>
* [.light_to_arr(str, cmd)](#module_lib/mscript..Mscript+light_to_arr) ⇒ <code>array</code>
* [.light_state(Color)](#module_lib/mscript..Mscript+light_state)
* [.delay(line)](#module_lib/mscript..Mscript+delay)
* [.alert(line)](#module_lib/mscript..Mscript+alert)
* [.pause(line)](#module_lib/mscript..Mscript+pause)
* [.fail(msg)](#module_lib/mscript..Mscript+fail)
* [.contains(arr, arr2)](#module_lib/mscript..Mscript+contains) ⇒ <code>boolean</code>
<a name="module_lib/mscript..Mscript+clear"></a>
@ -63,124 +89,343 @@ Clear the state of the script
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
<a name="module_lib/mscript..Mscript+interpret"></a>
#### mscript.interpret()
#### mscript.interpret(text, callback)<code>object</code>
Main function, accepts multi-line string, parses into lines
and interprets the instructions from the text. Returns an array
of steps to be fed into the mcopy.
of steps to be fed into the mcopy sequence.
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>object</code> - if callback is not provided
| Param | Type | Description |
| --- | --- | --- |
| text | <code>string</code> | Mscript text to interpret |
| callback | <code>function</code> | Function to call when string is interpreted |
<a name="module_lib/mscript..Mscript+variable"></a>
#### mscript.variable(line)
Interprets variables for complex sequence behavior.
TODO: Fully implement, add test coverage
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line containing a variable assignment |
<a name="module_lib/mscript..Mscript+variable_replace"></a>
#### mscript.variable\_replace(line) ⇒ <code>string</code>
Replace variable with value at time of interpretation
TODO: Implement this please
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>string</code> - New string to be interpreted
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line containing variable to be replaced with value |
<a name="module_lib/mscript..Mscript+basic_cmd"></a>
#### mscript.basic\_cmd()
Apply a basic two character command
#### mscript.basic\_cmd(line, short)
Interpret a basic two character command
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line of script to interpret |
| short | <code>string</code> | The short command to use |
<a name="module_lib/mscript..Mscript+new_loop"></a>
#### mscript.new\_loop()
#### mscript.new\_loop(line, fade)
Start a new loop
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line to evaluate as either loop or fade |
| fade | <code>boolean</code> | Flag as true if fade |
<a name="module_lib/mscript..Mscript+end_loop"></a>
#### mscript.end\_loop()
#### mscript.end\_loop(line)
Close the most recent loop
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line to interpret |
<a name="module_lib/mscript..Mscript+move_cam"></a>
#### mscript.move\_cam()
#### mscript.move\_cam(line)
Move camera to explicitly-defined frame
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line to interpret with camera move statement |
<a name="module_lib/mscript..Mscript+move_cam2"></a>
#### mscript.move\_cam2(line)
Move secondary camera to explicitly-defined frame
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line to interpret with camera move statement |
<a name="module_lib/mscript..Mscript+move_proj"></a>
#### mscript.move\_proj()
#### mscript.move\_proj(line)
Move projector to explicitly-defined frame
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line containing `move` statement to interpret |
<a name="module_lib/mscript..Mscript+move_proj2"></a>
#### mscript.move\_proj2(line)
Move projector to explicitly-defined frame
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line containing `move` statement to interpret |
<a name="module_lib/mscript..Mscript+set_state"></a>
#### mscript.set\_state()
#### mscript.set\_state(line)
Set the state of either the cam or projector
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | String containing set statement |
<a name="module_lib/mscript..Mscript+last_loop"></a>
#### mscript.last\_loop()
#### mscript.last\_loop()<code>object</code>
Return the last loop
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
<a name="module_lib/mscript..Mscript+parent_loop"></a>
#### mscript.parent\_loop()
#### mscript.parent\_loop()<code>object</code>
Return the second-last loop
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>object</code> - Loop array
<a name="module_lib/mscript..Mscript+loop_count"></a>
#### mscript.loop\_count()
#### mscript.loop\_count()<code>integer</code>
Extract the loop count integer from a LOOP cmd
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>integer</code> - Loop count in string parsed into integer
<a name="module_lib/mscript..Mscript+fade"></a>
#### mscript.fade()
#### mscript.fade(line)
Execute a fade of frame length, from color to another color
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | Line containing a fade initiator |
<a name="module_lib/mscript..Mscript+fade_count"></a>
#### mscript.fade\_count()
#### mscript.fade\_count(str)
Extract the fade length integer from a FADE cmd
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | Line containing the length of fade in frames |
<a name="module_lib/mscript..Mscript+fade_start"></a>
#### mscript.fade\_start()
#### mscript.fade\_start(str)<code>array</code>
Extract the start color from a string
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>array</code> - Array containing RGB color values
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | Line containing the start color value in a fade initiator |
<a name="module_lib/mscript..Mscript+fade_end"></a>
#### mscript.fade\_end()
#### mscript.fade\_end(str)<code>array</code>
Extract the end color from a string
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>array</code> - Array containing RGB color values
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | Line containing the end color value in a fade initiator |
<a name="module_lib/mscript..Mscript+fade_rgb"></a>
#### mscript.fade\_rgb(start, end, len, x) ⇒ <code>array</code>
Determine the state of a fade at a particular frame in the sequence, x
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>array</code> - Array containing RGB color values
| Param | Type | Description |
| --- | --- | --- |
| start | <code>array</code> | Color the fade starts at |
| end | <code>array</code> | Color the fade finishes at |
| len | <code>integer</code> | Total length of the fade in frames |
| x | <code>integer</code> | Position of the fade to get color value of |
<a name="module_lib/mscript..Mscript+rgb"></a>
#### mscript.rgb(str)
Parse string into array of RGB color values. 0-255 octet.
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | String containing only color values as `#,#,#` |
<a name="module_lib/mscript..Mscript+rgb_str"></a>
#### mscript.rgb\_str(arr) ⇒ <code>string</code>
Cast RGB color values as string
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>string</code> - String of RGB values
| Param | Type | Description |
| --- | --- | --- |
| arr | <code>array</code> | Array to join into string |
<a name="module_lib/mscript..Mscript+update"></a>
#### mscript.update()
#### mscript.update(cmd)
Increase the state of a specific object, such as the camera/projector,
by the value defined in val
by the value defined in val.
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| cmd | <code>string</code> | String representing command to interpret and update state |
<a name="module_lib/mscript..Mscript+str_to_arr"></a>
#### mscript.str\_to\_arr()
Split string on command, extract any integers from string
#### mscript.str\_to\_arr(str, cmd) ⇒ <code>array</code>
Split string on command, turn into array of commands
as long as count variable. Default 1.
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>array</code> - Array containing commands
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | String to split |
| cmd | <code>string</code> | String representing command to split at |
<a name="module_lib/mscript..Mscript+light_to_arr"></a>
#### mscript.light\_to\_arr()
#### mscript.light\_to\_arr(str, cmd)<code>array</code>
Split a string on a command to extract data for light array
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>array</code> - An RGB array containing the color values
| Param | Type | Description |
| --- | --- | --- |
| str | <code>string</code> | String containing light command |
| cmd | <code>string</code> | String representing command |
<a name="module_lib/mscript..Mscript+light_state"></a>
#### mscript.light\_state()
#### mscript.light\_state(Color)
Split a string to extract an rgb color value
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| Color | <code>string</code> | string assign to color property |
<a name="module_lib/mscript..Mscript+delay"></a>
#### mscript.delay(line)
Interpret a delay command
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | String containing delay command |
<a name="module_lib/mscript..Mscript+alert"></a>
#### mscript.alert(line)
Interpret an alert command
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | String containing alert message |
<a name="module_lib/mscript..Mscript+pause"></a>
#### mscript.pause(line)
Interpret an pause command
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
| Param | Type | Description |
| --- | --- | --- |
| line | <code>string</code> | String containing alert message |
<a name="module_lib/mscript..Mscript+fail"></a>
#### mscript.fail()
#### mscript.fail(msg)
Throw an error with specific message
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
<a name="module_lib/mscript..startsWith"></a>
### lib/mscript~startsWith()
startswith function from lodash, do not want the entire lib for this
| Param | Type | Description |
| --- | --- | --- |
| msg | <code>string</code> | Error message to print |
<a name="module_lib/mscript..Mscript+contains"></a>
#### mscript.contains(arr, arr2) ⇒ <code>boolean</code>
Determine if array contains matching elements of
another array
**Kind**: instance method of [<code>Mscript</code>](#module_lib/mscript..Mscript)
**Returns**: <code>boolean</code> - Whether arr contains elements in arr2
| Param | Type | Description |
| --- | --- | --- |
| arr | <code>Array</code> | Original array to compare |
| arr2 | <code>Array</code> | Array to compare elements from |
**Kind**: inner method of [<code>lib/mscript</code>](#module_lib/mscript)

260
app/lib/mscript/index.d.ts vendored Normal file
View File

@ -0,0 +1,260 @@
interface MscriptOutput {
success: boolean;
arr: string[];
meta: string[];
cam: number;
proj: number;
cam2?: number;
proj2?: number;
}
interface RGB extends Array<number> {
[index: number]: number;
}
/** @module lib/mscript */
/**
* Class representing the mscript language.
*/
export default class Mscript {
private output;
private lines;
private cam;
private cam2;
private proj;
private proj2;
private color;
private loops;
private rec;
private two;
private three;
private four;
private arr;
private meta;
private target;
private dist;
private variables;
/**
* @constructor
* Create new Mscript interpreter
**/
constructor();
/**
* Clear the state of the script
*/
private clear;
/**
* Main function, accepts multi-line string, parses into lines
* and interprets the instructions from the text. Returns an array
* of steps to be fed into the mcopy sequence.
*
* @param {string} text Mscript text to interpret
* @param {function} callback Function to call when string is interpreted
*
* @returns {object} if callback is not provided
*/
interpret(text: string): void | MscriptOutput;
/**
* Interprets variables for complex sequence behavior.
* TODO: Fully implement, add test coverage
*
* @param {string} line Line containing a variable assignment
*
**/
private variable;
/**
* Replace variable with value at time of interpretation
* TODO: Implement this please
*
* @param {string} line Line containing variable to be replaced with value
*
* @returns {string} New string to be interpreted
**/
private variable_replace;
/**
* Interpret a basic two character command
*
* @param {string} line Line of script to interpret
* @param {string} short The short command to use
*/
private basic_cmd;
/**
* Start a new loop
*
* @param {string} line Line to evaluate as either loop or fade
* @param {boolean} fade Flag as true if fade
*/
private new_loop;
/**
* Close the most recent loop
*
* @param {string} line Line to interpret
*/
private end_loop;
/**
* Move camera to explicitly-defined frame
*
* @param {string} line Line to interpret with camera move statement
*/
private move_cam;
/**
* Move secondary camera to explicitly-defined frame
*
* @param {string} line Line to interpret with camera move statement
*/
private move_cam2;
/**
* Move projector to explicitly-defined frame
*
* @param {string} line Line containing `move` statement to interpret
*/
private move_proj;
/**
* Move projector to explicitly-defined frame
*
* @param {string} line Line containing `move` statement to interpret
*/
private move_proj2;
/**
* Set the state of either the cam or projector
*
* @param line {string} String containing set statement
*/
private set_state;
/**
* Return the last loop
*
* @returns {object}
*/
private last_loop;
/**
* Return the second-last loop
*
* @returns {object} Loop array
*/
private parent_loop;
/**
* Extract the loop count integer from a LOOP cmd
*
* @returns {integer} Loop count in string parsed into integer
*/
private loop_count;
/**
* Execute a fade of frame length, from color to another color
*
* @param {string} line Line containing a fade initiator
*/
private fade;
/**
* Extract the fade length integer from a FADE cmd
*
* @param {string} str Line containing the length of fade in frames
*/
private fade_count;
/**
* Extract the start color from a string
*
* @param {string} str Line containing the start color value in a fade initiator
*
* @returns {array} Array containing RGB color values
*/
private fade_start;
/**
* Extract the end color from a string
*
* @param {string} str Line containing the end color value in a fade initiator
*
* @returns {array} Array containing RGB color values
*/
private fade_end;
/**
* Determine the state of a fade at a particular frame in the sequence, x
*
* @param {array} start Color the fade starts at
* @param {array} end Color the fade finishes at
* @param {integer} len Total length of the fade in frames
* @param {integer} x Position of the fade to get color value of
*
* @returns {array} Array containing RGB color values
*/
private fade_rgb;
/**
* Parse string into array of RGB color values. 0-255 octet.
*
* @param {string} str String containing only color values as `#,#,#`
**/
private rgb;
/**
* Cast RGB color values as string
*
* @param {array} arr Array to join into string
*
* @returns {string} String of RGB values
**/
private rgb_str;
/**
* Increase the state of a specific object, such as the camera/projector,
* by the value defined in val.
*
* @param {string} cmd String representing command to interpret and update state
*/
private update;
/**
* Split string on command, turn into array of commands
* as long as count variable. Default 1.
*
* @param {string} str String to split
* @param {string} cmd String representing command to split at
*
* @returns {array} Array containing commands
*/
private str_to_arr;
/**
* Split a string on a command to extract data for light array
*
* @param {string} str String containing light command
* @param {string} cmd String representing command
*
* @returns {array} An RGB array containing the color values
*/
private light_to_arr;
/**
* Split a string to extract an rgb color value
*
* @param {string} Color string assign to color property
*/
private light_state;
/**
* Interpret a delay command
*
* @param {string} line String containing delay command
**/
private delay;
/**
* Interpret an alert command
*
* @param {string} line String containing alert message
**/
private alert;
/**
* Interpret an pause command
*
* @param {string} line String containing alert message
**/
private pause;
/**
* Throw an error with specific message
*
* @param {string} msg Error message to print
*/
private fail;
/**
* Determine if array contains matching elements of
* another array
*
* @param {Array} arr Original array to compare
* @param {Array} arr2 Array to compare elements from
*
* @returns {boolean} Whether arr contains elements in arr2
**/
private contains;
}
export type { RGB };

View File

@ -1,4 +1,5 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
const BLACK = '0,0,0';
const WHITE = '255,255,255';
const CMD = [
@ -7,7 +8,35 @@ const CMD = [
'BF',
'CB',
'PB',
'BB'
'BB',
'C2F',
'C2B',
'CCF',
'CCB',
'P2F',
'P2B',
'PPF',
'PPB',
'CFCB',
'CBCF',
'PFPB',
'PBPF'
];
const CAMERA_SECONDARY = [
'C2F',
'C2B',
'CCF',
'CCB',
'CFCB',
'CBCF'
];
const PROJECTOR_SECONDARY = [
'P2F',
'P2B',
'PPF',
'PPB',
'PFPB',
'PBPF'
];
const ALTS = {
'CF': ['CAMERA FORWARD', 'CAM FORWARD'],
@ -17,38 +46,40 @@ const ALTS = {
'PB': ['PROJECTOR FORWARD', 'PROJ FORWARD', 'PROJECTOR BACK', 'PROJ BACK'],
'BB': ['BLACK BACKWARD', 'BLACK BACK', 'BLANK BACK'],
'L ': ['LIGHT', 'COLOR', 'LAMP'],
'F ': ['FADE']
'F ': ['FADE'],
'C2F': ['CAMERA2 FORWARD', 'CAM2 FORWARD'],
'C2B': ['CAMERA2 BACKWARD', 'CAM2 BACKWARD', 'CAMERA2 BACK', 'CAM2 BACK'],
'CCF': ['CAMERAS FORWARD', 'CAMS FORWARD'],
'CCB': ['CAMERAS BACKWARD', 'CAMS BACKWARD', 'CAMERAS BACK', 'CAMS BACK'],
'P2F': ['PROJECTOR2 FORWARD', 'PROJ2 FORWARD'],
'P2B': ['PROJECTOR2 BACKWARD', 'PROJ2 BACKWARD', 'PROJECTOR2 BACK', 'PROJ2 BACK'],
'PPF': ['PROJECTORS FORWARD', 'PROJS FORWARD'],
'PPB': ['PROJECTORS BACKWARD', 'PROJS BACKWARD', 'PROJECTORS BACK', 'PROJS BACK'],
'CFCB': [],
'CBCF': [],
'PFPB': [],
'PBPF': []
};
const DELAY = 'DELAY';
const PAUSE = 'PAUSE';
const ALERT = 'ALERT';
/** helper functions */
/** startswith function from lodash, do not want the entire lib for this
* @param str {string} Text to evaluate
* @param target {string} Text to compare string against
* @param position {integer} Position in the string to make comparison at
*
* @returns {boolean} True for match, false for no match
**/
function startsWith(str, target, position) {
const { length } = str;
position = position == null ? 0 : position;
if (position < 0) {
position = 0;
}
else if (position > length) {
position = length;
}
target = `${target}`;
return str.slice(position, position + target.length) == target;
}
/** class Mscript */
/** @module lib/mscript */
/**
* Class representing the mscript language.
*/
class Mscript {
/**
* @constructor
* Create new Mscript interpreter
**/
constructor() {
this.output = {};
this.output = {
success: false,
arr: [],
meta: [],
cam: 0,
proj: 0
};
}
/**
* Clear the state of the script
@ -56,17 +87,27 @@ class Mscript {
clear() {
this.lines = [];
this.cam = 0;
this.cam2 = 0;
this.proj = 0;
this.proj2 = 0;
this.color = '';
this.loops = [];
this.rec = -1;
this.two = '';
this.three = '';
this.four = '';
this.arr = [];
this.meta = [];
this.target = 0; //move to target using CAM # or PROJ #
this.dist = 0;
this.variables = {};
this.output = {};
this.output = {
success: false,
arr: [],
meta: [],
cam: 0,
proj: 0
};
}
/**
* Main function, accepts multi-line string, parses into lines
@ -78,76 +119,88 @@ class Mscript {
*
* @returns {object} if callback is not provided
*/
interpret(text, callback) {
interpret(text) {
this.clear();
if (typeof text === 'undefined') {
return this.fail('No input');
}
//split string into lines, each containing a command
this.lines = text.split('\n');
this.lines = this.lines.map(line => {
line = line.replace(/\t+/g, ''); //strip tabs
this.lines = this.lines.map((line) => {
line = line.replace(/\t+/g, ' '); //strip tabs
line = line.trim(); //remove excess whitespace before and after command
line = line.toUpperCase();
return line;
});
for (let line of this.lines) {
this.two = line.substring(0, 2);
if (CMD.indexOf(this.two) !== -1) {
this.basic_cmd(line);
this.three = line.substring(0, 3);
this.four = line.substring(0, 4);
if (CMD.indexOf(this.four) !== -1) {
this.basic_cmd(line, this.four);
}
else if (startsWith(line, PAUSE)) {
else if (CMD.indexOf(this.three) !== -1) {
this.basic_cmd(line, this.three);
}
else if (CMD.indexOf(this.two) !== -1) {
this.basic_cmd(line, this.two);
}
else if (line.startsWith(DELAY)) {
this.delay(line);
}
else if (line.startsWith(PAUSE)) {
this.pause(line);
}
else if (startsWith(line, ALERT)) {
else if (line.startsWith(ALERT)) {
this.alert(line);
}
else if (startsWith(line, '@') || line.indexOf('@') !== -1) {
else if (line.startsWith('@') || line.indexOf('@') !== -1) {
this.variable(line);
}
else if (startsWith(line, 'LOOP')) {
else if (line.startsWith('LOOP')) {
this.new_loop(line);
}
else if (startsWith(line, 'L ')) {
else if (line.startsWith('L ')) {
this.light_state(line);
}
else if (startsWith(line, 'F ')) {
else if (line.startsWith('F ')) {
this.new_loop(line, true);
}
else if (startsWith(line, 'END')) {
else if (line.startsWith('END')) {
this.end_loop(line);
}
else if (startsWith(line, 'CAM')) { //directly go to that frame (black?)
else if (line.startsWith('CAM2')) { //directly go to that frame
this.move_cam2(line);
}
else if (line.startsWith('CAM')) { //directly go to that frame
this.move_cam(line);
}
else if (startsWith(line, 'PROJ')) { //directly go to that frame
else if (line.startsWith('PROJ2')) { //directly go to that frame
this.move_proj2(line);
}
else if (line.startsWith('PROJ')) { //directly go to that frame
this.move_proj(line);
}
else if (startsWith(line, 'SET')) { //set that state
else if (line.startsWith('SET')) { //set that state
this.set_state(line);
}
else if (startsWith(line, '#') || startsWith(line, '//')) {
else if (line.startsWith('#') || line.startsWith('//')) {
//comments
//ignore while parsing
}
else if (startsWith(line, 'ALERT')) {
}
else if (startsWith(line, 'PAUSE')) {
this.pause(line);
}
}
this.output.success = true;
this.output.arr = this.arr; //all instructions
this.output.meta = this.meta; //all metadata for instructions
this.output.cam = this.cam;
this.output.proj = this.proj;
if (typeof callback !== 'undefined') {
//should only be invoked by running mscript.tests()
callback(this.output);
if (this.contains(this.arr, CAMERA_SECONDARY)) {
this.output.cam2 = this.cam2;
}
else {
return this.output;
if (this.contains(this.arr, PROJECTOR_SECONDARY)) {
this.output.proj2 = this.proj2;
}
return this.output;
}
/**
* Interprets variables for complex sequence behavior.
@ -161,6 +214,7 @@ class Mscript {
let key = parts[0];
let value = parts[1];
let update = false;
let num;
if (value && value.indexOf('#') !== -1) {
value = value.split('#')[0];
}
@ -176,7 +230,7 @@ class Mscript {
}
if (line.indexOf(',') === -1) { //if not color string
try {
value = parseInt(value);
num = parseInt(value);
}
catch (err) {
//supress parsing error
@ -184,7 +238,7 @@ class Mscript {
}
//console.dir(parts)
if (!this.variables[key] || update) {
this.variables[key] = value;
this.variables[key] = num;
}
//console.dir(this.variables)
}
@ -203,25 +257,26 @@ class Mscript {
* Interpret a basic two character command
*
* @param {string} line Line of script to interpret
* @param {string} short The short command to use
*/
basic_cmd(line) {
basic_cmd(line, short) {
if (this.rec !== -1) {
//hold generated arr in state loop array
this.loops[this.rec].arr
.push.apply(this.loops[this.rec].arr, this.str_to_arr(line, this.two));
.push.apply(this.loops[this.rec].arr, this.str_to_arr(line, short));
this.loops[this.rec].meta
.push.apply(this.loops[this.rec].meta, this.light_to_arr(line, this.two));
.push.apply(this.loops[this.rec].meta, this.light_to_arr(line, short));
}
else {
this.arr.push.apply(this.arr, this.str_to_arr(line, this.two));
this.meta.push.apply(this.meta, this.light_to_arr(line, this.two));
this.arr.push.apply(this.arr, this.str_to_arr(line, short));
this.meta.push.apply(this.meta, this.light_to_arr(line, short));
}
}
/**
* Start a new loop
*
* @param {string} line Line to evaluate as either loop or fade
* @param {boolean} fade Flag as boolean if true
* @param {boolean} fade Flag as true if fade
*/
new_loop(line, fade) {
this.rec++;
@ -230,6 +285,8 @@ class Mscript {
meta: [],
cam: 0,
proj: 0,
cam2: 0,
proj2: 0,
cmd: line + ''
};
if (fade) {
@ -252,7 +309,7 @@ class Mscript {
start = this.loops[this.rec].start;
end = this.loops[this.rec].end;
len = this.loops[this.rec].fade_len;
meta_arr = meta_arr.map(l => {
meta_arr = meta_arr.map((l) => {
return this.fade_rgb(start, end, len, x);
});
}
@ -315,6 +372,50 @@ class Mscript {
}
}
}
/**
* Move secondary camera to explicitly-defined frame
*
* @param {string} line Line to interpret with camera move statement
*/
move_cam2(line) {
this.target = parseInt(line.split('CAM2 ')[1]);
if (this.rec !== -1) {
if (this.target > this.cam2) {
this.dist = this.target - this.cam2;
for (let x = 0; x < this.dist; x++) {
this.loops[this.rec].arr.push('C2F');
this.loops[this.rec].meta.push(BLACK);
this.update('C2F');
}
}
else {
this.dist = this.cam2 - this.target;
for (let x = 0; x < this.dist; x++) {
this.loops[this.rec].arr.push('C2B');
this.loops[this.rec].meta.push(BLACK);
this.update('C2B');
}
}
}
else {
if (this.target > this.cam2) {
this.dist = this.target - this.cam2;
for (let x = 0; x < this.dist; x++) {
this.arr.push('C2F');
this.meta.push(BLACK);
this.update('C2F');
}
}
else {
this.dist = this.cam2 - this.target;
for (let x = 0; x < this.dist; x++) {
this.arr.push('C2B');
this.meta.push(BLACK);
this.update('C2B');
}
}
}
}
/**
* Move projector to explicitly-defined frame
*
@ -359,16 +460,66 @@ class Mscript {
}
}
}
/**
* Move projector to explicitly-defined frame
*
* @param {string} line Line containing `move` statement to interpret
*/
move_proj2(line) {
this.target = parseInt(line.split('PROJ2 ')[1]);
if (this.rec !== -1) {
if (this.target > this.proj2) {
this.dist = this.target - this.proj2;
for (let x = 0; x < this.dist; x++) {
this.loops[this.rec].arr.push('P2F');
this.loops[this.rec].meta.push('');
this.update('P2F');
}
}
else {
this.dist = this.proj2 - this.target;
for (let x = 0; x < this.dist; x++) {
this.loops[this.rec].arr.push('P2B');
this.loops[this.rec].meta.push('');
this.update('P2B');
}
}
}
else {
if (this.target > this.proj2) {
this.dist = this.target - this.proj2;
for (let x = 0; x < this.dist; x++) {
this.arr.push('P2F');
this.meta.push('');
this.update('P2F');
}
}
else {
this.dist = this.proj2 - this.target;
for (let x = 0; x < this.dist; x++) {
this.arr.push('P2B');
this.meta.push('');
this.update('P2B');
}
}
}
}
/**
* Set the state of either the cam or projector
*
* @param line {string} String containing set statement
*/
set_state(line) {
if (startsWith(line, 'SET CAM')) {
if (line.startsWith('SET CAM2')) {
parseInt(line.split('SET CAM2')[1]);
}
else if (line.startsWith('SET PROJ2')) {
this.cam2 = parseInt(line.split('SET PROJ2')[1]);
}
else if (line.startsWith('SET CAM')) {
this.cam = parseInt(line.split('SET CAM')[1]);
}
else if (startsWith(line, 'SET PROJ')) {
else if (line.startsWith('SET PROJ')) {
this.proj = parseInt(line.split('SET PROJ')[1]);
}
}
@ -402,9 +553,9 @@ class Mscript {
* @param {string} line Line containing a fade initiator
*/
fade(line) {
let len = this.fade_count(line);
let start = this.fade_start(line);
let end = this.fade_end(line);
const len = this.fade_count(line);
const start = this.fade_start(line);
const end = this.fade_end(line);
this.loops[this.rec].start = start;
this.loops[this.rec].end = end;
this.loops[this.rec].fade = true;
@ -438,7 +589,7 @@ class Mscript {
* @returns {array} Array containing RGB color values
*/
fade_end(str) {
let color = str.split(' ')[3];
const color = str.split(' ')[3];
return this.rgb(color.trim());
}
/**
@ -475,7 +626,7 @@ class Mscript {
* @param {string} str String containing only color values as `#,#,#`
**/
rgb(str) {
let rgb = str.split(',');
const rgb = str.split(',');
return rgb.map((char) => {
return parseInt(char);
});
@ -503,10 +654,14 @@ class Mscript {
if (this.rec === 0) {
this.cam += this.loops[this.rec].cam;
this.proj += this.loops[this.rec].proj;
this.cam2 += this.loops[this.rec].cam2;
this.proj2 += this.loops[this.rec].proj2;
}
else if (this.rec >= 1) {
this.loops[this.rec - 1].cam += this.loops[this.rec].cam;
this.loops[this.rec - 1].proj += this.loops[this.rec].proj;
this.loops[this.rec - 1].cam2 += this.loops[this.rec].cam2;
this.loops[this.rec - 1].proj2 += this.loops[this.rec].proj2;
}
}
}
@ -523,7 +678,7 @@ class Mscript {
this.cam -= val;
}
else {
this.loops[this.rec].cam--;
this.loops[this.rec].cam -= val;
}
}
else if (cmd === 'PF') {
@ -539,7 +694,7 @@ class Mscript {
this.proj -= val;
}
else {
this.loops[this.rec].proj--;
this.loops[this.rec].proj -= val;
}
}
else if (cmd === 'BF') {
@ -558,6 +713,118 @@ class Mscript {
this.loops[this.rec].cam -= val;
}
}
else if (cmd === 'C2F') {
if (this.rec === -1) {
this.cam2 += val;
}
else {
this.loops[this.rec].cam2 += val;
}
}
else if (cmd === 'C2B') {
if (this.rec === -1) {
this.cam2 -= val;
}
else {
this.loops[this.rec].cam2 -= val;
}
}
else if (cmd === 'CCF') {
if (this.rec === -1) {
this.cam += val;
this.cam2 += val;
}
else {
this.loops[this.rec].cam2 += val;
this.loops[this.rec].cam2 += val;
}
}
else if (cmd === 'CCB') {
if (this.rec === -1) {
this.cam -= val;
this.cam2 -= val;
}
else {
this.loops[this.rec].cam2 -= val;
this.loops[this.rec].cam2 -= val;
}
}
else if (cmd === 'P2F') {
if (this.rec === -1) {
this.proj2 += val;
}
else {
this.loops[this.rec].proj2 += val;
}
}
else if (cmd === 'P2B') {
if (this.rec === -1) {
this.proj2 -= val;
}
else {
this.loops[this.rec].proj2 -= val;
}
}
else if (cmd === 'PPF') {
if (this.rec === -1) {
this.proj += val;
this.proj2 += val;
}
else {
this.loops[this.rec].proj += val;
this.loops[this.rec].proj2 += val;
}
}
else if (cmd === 'PPB') {
if (this.rec === -1) {
this.proj -= val;
this.proj2 -= val;
}
else {
this.loops[this.rec].proj -= val;
this.loops[this.rec].proj2 -= val;
}
}
else if (cmd === 'CFCB') {
if (this.rec === -1) {
this.cam += val;
this.cam2 -= val;
}
else {
this.loops[this.rec].cam += val;
this.loops[this.rec].cam2 -= val;
}
}
else if (cmd === 'CBCF') {
if (this.rec === -1) {
this.cam -= val;
this.cam2 += val;
}
else {
this.loops[this.rec].cam -= val;
this.loops[this.rec].cam2 += val;
}
}
else if (cmd === 'PFPB') {
if (this.rec === -1) {
this.proj += val;
this.proj2 -= val;
}
else {
this.loops[this.rec].proj += val;
this.loops[this.rec].proj2 -= val;
}
}
else if (cmd === 'PBPF') {
if (this.rec === -1) {
this.proj -= val;
this.proj2 += val;
}
else {
this.loops[this.rec].proj -= val;
this.loops[this.rec].proj2 += val;
}
}
else if (cmd === 'L ') {
}
}
@ -628,11 +895,11 @@ class Mscript {
this.color = color;
}
/**
* Interpret a pause command
* Interpret a delay command
*
* @param {string} line String containing pause command
* @param {string} line String containing delay command
**/
pause(line) {
delay(line) {
let lenStr = line.split(' ')[1] || '';
let len;
lenStr = lenStr.trim();
@ -649,23 +916,42 @@ class Mscript {
if (this.rec !== -1) {
//hold generated arr in state loop array
this.loops[this.rec].arr
.push('PA');
.push('DE');
this.loops[this.rec].meta
.push(lenStr);
}
else {
this.arr.push('AL');
this.arr.push('DE');
this.meta.push(lenStr);
}
}
/**
* Interpret an alert command
*
* @param {string} line String containing pause command
* @param {string} line String containing alert message
**/
alert(line) {
let msg = line.split(' ')[1] || '';
msg = msg.trim();
if (this.rec !== -1) {
//hold generated arr in state loop array
this.loops[this.rec].arr
.push('AL');
this.loops[this.rec].meta
.push(line);
}
else {
this.arr.push('AL');
this.meta.push(line);
}
}
/**
* Interpret an pause command
*
* @param {string} line String containing alert message
**/
pause(line) {
const msg = "Paused script. Click OK to continue.";
if (this.rec !== -1) {
//hold generated arr in state loop array
this.loops[this.rec].arr
@ -686,6 +972,19 @@ class Mscript {
fail(msg) {
throw new Error(msg);
}
/**
* Determine if array contains matching elements of
* another array
*
* @param {Array} arr Original array to compare
* @param {Array} arr2 Array to compare elements from
*
* @returns {boolean} Whether arr contains elements in arr2
**/
contains(arr, arr2) {
return arr.some((r) => arr2.includes(r));
}
}
exports.default = Mscript;
module.exports = Mscript;
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

View File

@ -0,0 +1,9 @@
<a name="module_lib/processing"></a>
## lib/processing
<a name="module_lib/processing..Processing"></a>
### lib/processing~Processing
Class representing all Processing camera features.
**Kind**: inner class of [<code>lib/processing</code>](#module_lib/processing)

10
app/lib/processing/index.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
/** @module lib/processing */
/**
* Class representing all Processing camera features.
*/
export declare class Processing {
private _baseUrl;
constructor(url: string);
move(): Promise<number>;
setDir(dir: boolean): Promise<number>;
}

View File

@ -0,0 +1,39 @@
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.Processing = void 0;
const exec_1 = require("exec");
/** @module lib/processing */
/**
* Class representing all Processing camera features.
*/
class Processing {
constructor(url) {
this._baseUrl = (url.indexOf('http') === -1 && url.indexOf('://') === -1) ? `http://${url}` : url;
}
async move() {
return new Promise(async (resolve, reject) => {
const timeStart = +new Date();
const url = `${this._baseUrl}`;
const cmd = `curl --http0.9 ${url}`;
let res;
let ms;
//console.log(url)
try {
res = await (0, exec_1.exec)(cmd);
}
catch (err) {
return reject(err);
}
ms = (+new Date()) - timeStart;
return resolve(ms);
});
}
async setDir(dir) {
return new Promise((resolve, reject) => {
return resolve(0);
});
}
}
exports.Processing = Processing;
module.exports = { Processing };
//# sourceMappingURL=index.js.map

View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/processing/index.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;;;AAEZ,+BAA4B;AAG5B,6BAA6B;AAE7B;;GAEG;AACH,MAAa,UAAU;IAEtB,YAAa,GAAY;QACxB,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAA;IAClG,CAAC;IAEM,KAAK,CAAC,IAAI;QAChB,OAAO,IAAI,OAAO,CAAE,KAAK,EAAE,OAAkB,EAAE,MAAiB,EAAE,EAAE;YACnE,MAAM,SAAS,GAAY,CAAC,IAAI,IAAI,EAAE,CAAA;YACtC,MAAM,GAAG,GAAY,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAA;YACvC,MAAM,GAAG,GAAY,kBAAkB,GAAG,EAAE,CAAA;YAC5C,IAAI,GAAgB,CAAA;YACpB,IAAI,EAAW,CAAA;YACf,kBAAkB;YAClB,IAAI;gBACH,GAAG,GAAG,MAAM,IAAA,WAAI,EAAC,GAAG,CAAC,CAAA;aACrB;YAAC,OAAO,GAAG,EAAE;gBACb,OAAO,MAAM,CAAC,GAAG,CAAC,CAAA;aAClB;YACD,EAAE,GAAG,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,GAAG,SAAS,CAAA;YAC9B,OAAO,OAAO,CAAC,EAAE,CAAC,CAAA;QACnB,CAAC,CAAC,CAAA;IACH,CAAC;IACM,KAAK,CAAC,MAAM,CAAE,GAAa;QACjC,OAAO,IAAI,OAAO,CAAE,CAAC,OAAkB,EAAE,MAAiB,EAAE,EAAE;YAC7D,OAAO,OAAO,CAAC,CAAC,CAAC,CAAA;QAClB,CAAC,CAAC,CAAA;IACH,CAAC;CACD;AA5BD,gCA4BC;AAED,MAAM,CAAC,OAAO,GAAG,EAAE,UAAU,EAAE,CAAA"}

View File

@ -1,37 +1,52 @@
<a name="Projector"></a>
<a name="module_lib/proj"></a>
## Projector
**Kind**: global class
## lib/proj
* [Projector](#Projector)
* [.init()](#Projector+init)
* [.listen()](#Projector+listen)
* [.set()](#Projector+set)
* [.move()](#Projector+move)
* [.listener()](#Projector+listener)
* [.end()](#Projector+end)
* [lib/proj](#module_lib/proj)
* [~Projector](#module_lib/proj..Projector)
* [.init()](#module_lib/proj..Projector+init)
* [.listen()](#module_lib/proj..Projector+listen)
* [.set()](#module_lib/proj..Projector+set)
* [.move()](#module_lib/proj..Projector+move)
* [.listener()](#module_lib/proj..Projector+listener)
* [.end()](#module_lib/proj..Projector+end)
<a name="Projector+init"></a>
<a name="module_lib/proj..Projector"></a>
### projector.init()
**Kind**: instance method of [<code>Projector</code>](#Projector)
<a name="Projector+listen"></a>
### lib/proj~Projector
Class representing all projector features.
### projector.listen()
**Kind**: instance method of [<code>Projector</code>](#Projector)
<a name="Projector+set"></a>
**Kind**: inner class of [<code>lib/proj</code>](#module_lib/proj)
### projector.set()
**Kind**: instance method of [<code>Projector</code>](#Projector)
<a name="Projector+move"></a>
* [~Projector](#module_lib/proj..Projector)
* [.init()](#module_lib/proj..Projector+init)
* [.listen()](#module_lib/proj..Projector+listen)
* [.set()](#module_lib/proj..Projector+set)
* [.move()](#module_lib/proj..Projector+move)
* [.listener()](#module_lib/proj..Projector+listener)
* [.end()](#module_lib/proj..Projector+end)
### projector.move()
**Kind**: instance method of [<code>Projector</code>](#Projector)
<a name="Projector+listener"></a>
<a name="module_lib/proj..Projector+init"></a>
### projector.listener()
**Kind**: instance method of [<code>Projector</code>](#Projector)
<a name="Projector+end"></a>
#### projector.init()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)
<a name="module_lib/proj..Projector+listen"></a>
### projector.end()
**Kind**: instance method of [<code>Projector</code>](#Projector)
#### projector.listen()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)
<a name="module_lib/proj..Projector+set"></a>
#### projector.set()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)
<a name="module_lib/proj..Projector+move"></a>
#### projector.move()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)
<a name="module_lib/proj..Projector+listener"></a>
#### projector.listener()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)
<a name="module_lib/proj..Projector+end"></a>
#### projector.end()
**Kind**: instance method of [<code>Projector</code>](#module_lib/proj..Projector)

53
app/lib/proj/index.d.ts vendored Normal file
View File

@ -0,0 +1,53 @@
/** class representing the Projector features **/
import type { Arduino } from 'arduino';
import type { FilmOut } from 'filmout';
import type { Config } from 'cfg';
import type { WebContents } from 'electron';
interface ProjectorState {
pos: number;
dir: boolean;
}
/** @module lib/proj */
/**
* Class representing all projector features.
*/
export declare class Projector {
state: ProjectorState;
arduino: Arduino;
private log;
private cfg;
private ui;
private ipc;
filmout: FilmOut;
private id;
/**
*
**/
constructor(arduino: Arduino, cfg: Config, ui: WebContents, filmout: FilmOut, second?: boolean);
/**
*
**/
private init;
/**
*
**/
private listen;
/**
*
**/
set(dir: boolean, id: string): Promise<number>;
/**
*
**/
move(id: string): Promise<number>;
both(id: string): Promise<number>;
/**
*
**/
private listener;
/**
*
**/
end(cmd: string, id: string, ms: number): Promise<number>;
}
export type { ProjectorState };

View File

@ -1,7 +1,13 @@
"use strict";
/** class representing the Projector features **/
Object.defineProperty(exports, "__esModule", { value: true });
const Log = require("log");
exports.Projector = void 0;
const electron_1 = require("electron");
const log_1 = require("log");
/** @module lib/proj */
/**
* Class representing all projector features.
*/
class Projector {
/**
*
@ -12,6 +18,7 @@ class Projector {
dir: true
};
this.arduino = null;
this.ipc = electron_1.ipcMain;
this.id = 'projector';
this.arduino = arduino;
this.cfg = cfg;
@ -25,8 +32,7 @@ class Projector {
*
**/
async init() {
this.log = await Log({ label: this.id });
this.ipc = require('electron').ipcMain;
this.log = await (0, log_1.Log)({ label: this.id });
this.listen();
}
/**
@ -56,7 +62,7 @@ class Projector {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(`Error setting ${this.id} direction`, err);
this.log.error(`Error setting ${this.id} direction: ${id}`, err);
}
}
return await this.end(cmd, id, ms);
@ -64,7 +70,7 @@ class Projector {
/**
*
**/
async move(frame, id) {
async move(id) {
const cmd = this.cfg.arduino.cmd[this.id];
let ms;
if (this.filmout.state.enabled) {
@ -80,20 +86,20 @@ class Projector {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(`Error moving ${this.id}`, err);
this.log.error(`Error moving ${this.id}: ${id}`, err);
}
}
//this.log.info('Projector move time', { ms });
return await this.end(cmd, id, ms);
}
async both(frame, id) {
async both(id) {
const cmd = this.cfg.arduino.cmd[this.id + 's'];
let ms;
try {
ms = await this.arduino.send(this.id, cmd);
}
catch (err) {
this.log.error(`Error moving ${this.id}`, err);
this.log.error(`Error moving ${this.id}: ${id}`, err);
}
//this.log.info('Projectors move time', { ms });
return await this.end(cmd, id, ms);
@ -110,12 +116,12 @@ class Projector {
this.log.error(err);
}
}
else if (typeof arg.frame !== 'undefined') {
else if (typeof arg.move !== 'undefined') {
try {
await this.move(arg.frame, arg.id);
await this.move(arg.id);
}
catch (err) {
this.log.error(err);
this.log.error(`Error moving ${this.id}: ${arg.id}`, err);
}
}
else if (typeof arg.val !== 'undefined') {
@ -166,10 +172,10 @@ class Projector {
}
message += ` ${ms}ms`;
this.log.info(message, 'PROJECTOR');
return await this.ui.send(this.id, { cmd: cmd, id: id, ms: ms });
await this.ui.send(this.id, { cmd, id, ms });
return ms;
}
}
module.exports = function (arduino, cfg, ui, filmout, second) {
return new Projector(arduino, cfg, ui, filmout, second);
};
exports.Projector = Projector;
module.exports = { Projector };
//# sourceMappingURL=index.js.map

File diff suppressed because one or more lines are too long

Some files were not shown because too many files have changed in this diff Show More