fix cnc feedrates for imperial. update grid when changing units

src/kiri/init.js

@@ -78,6 +78,11 @@
         return false;
     }
 
+    function unitsSave() {
+        API.conf.update();
+        platform.update_size();
+    }
+
     function booleanSave() {
         let control = settings().controller;
         let isDark = control.dark;
@@ -1246,7 +1251,7 @@
             freeLayout:       UC.newBoolean(LANG.op_free_s, booleanSave, {title:LANG.op_free_l, modes:ALL}),
             reverseZoom:      UC.newBoolean(LANG.op_invr_s, booleanSave, {title:LANG.op_invr_l, modes:ALL}),
             thinRender:       UC.newBoolean(LANG.op_thin_s, booleanSave, {title:LANG.op_thin_l, modes:ALL}),
-            units:            UC.newSelect(LANG.op_unit_s, {title: LANG.op_unit_l, modes:CAM}, "units"),
+            units:            UC.newSelect(LANG.op_unit_s, {title: LANG.op_unit_l, modes:CAM, action:unitsSave}, "units"),
             prefadd:          UC.checkpoint(),
 
             export:           UC.newGroup(LANG.xp_menu, $('prefs-out'), {inline: true}),
@@ -1674,20 +1679,7 @@
         $('mode-cam').appendChild(mksvg(icons.cnc));
         $('mode-laser').appendChild(mksvg(icons.laser));
 
-        SPACE.platform.setSize(
+        API.platform.update_size();
-            settings().device.bedWidth,
-            settings().device.bedDepth,
-            settings().device.bedHeight
-        );
-
-        if (dark) {
-            SPACE.platform.setGrid(25, 5, 0x999999, 0x333333);
-            SPACE.platform.opacity(0.8);
-            DOC.body.classList.add('dark');
-        } else {
-            SPACE.platform.setGrid(25, 5, 0x999999, 0xcccccc);
-            SPACE.platform.opacity(0.3);
-        }
 
         SPACE.mouse.downSelect(function(int,event) {
             // lay flat with meta or ctrl clicking a selected face

src/kiri/main.js

@@ -985,6 +985,19 @@
             depth = parseInt(dev.bedDepth),
             height = parseFloat(dev.bedHeight)
         );
+        let ctrl = settings.controller,
+            unitMM = ctrl.units === 'mm',
+            gridMajor = unitMM ? 25 : 25.4,
+            gridMinor = unitMM ? 5 : 25.4 / 4;
+        if (ctrl.dark) {
+            SPACE.platform.setGrid(gridMajor, gridMinor, 0x999999, 0x333333);
+            SPACE.platform.opacity(0.8);
+            DOC.body.classList.add('dark');
+        } else {
+            SPACE.platform.setGrid(gridMajor, gridMinor, 0x999999, 0xcccccc);
+            SPACE.platform.opacity(0.3);
+            DOC.body.classList.remove('dark');
+        }
         SPACE.platform.setGZOff(height/2 - 0.1);
         platform.update_origin();
         SPACE.scene.freeze(frozen);

src/kiri/print.js

@@ -335,13 +335,15 @@
             origin = settings.origin,
             mode = settings.mode,
             tools = [],
-            driver = KIRI.driver[mode];
+            driver = KIRI.driver[mode],
+            mark = Date.now();
 
         if (mode === 'FDM') {
             tools = settings.device.extruders || [];
         }
 
         driver.printRender(this, {tools, aslines:settings.controller.thinRender});
+        if (KIRI.api.const.LOCAL) console.log({printRender: Date.now() - mark});
     };
 
     function pref(a,b) {

src/kiri/widget.js

@@ -713,7 +713,9 @@
      * render all slice and processed data
      */
     PRO.render = function() {
+        let mark = Date.now();
         DRIVERS[this.settings.mode.toUpperCase()].sliceRender(this);
+        if (KIRI.api.const.LOCAL) console.log({sliceRender: Date.now() - mark});
     };
 
     PRO.hideSlices = function() {

src/mode/cam/driver.js

@@ -1272,8 +1272,8 @@
                 }
                 lastTool = toolID;
             }
-            feedRate = feed;
+            feedRate = feed * units;
-            plungeRate = plunge;
+            plungeRate = plunge * units;
         }
 
         function emitDrills(polys) {
@@ -1709,9 +1709,11 @@
             cmdSpindle = gcodes.gcodeSpindle || [ "M3 S{speed}" ],
             cmdDwell = gcodes.gcodeDwell || [ "G4 P{time}" ],
             bounds = widget.getCamBounds(settings),
-            units = 1,//settings.controller.units === 'in' ? 25.4 : 1,
-            spro = settings.process,
             dev = settings.device,
+            spro = settings.process,
+            units = settings.controller.units === 'in' ? 25.4 : 1,
+            maxZd = spro.camFastFeedZ * units,
+            maxXYd = spro.camFastFeed * units,
             decimals = 4,
             pos = { x:null, y:null, z:null, f:null, t:null },
             line,
@@ -1732,10 +1734,10 @@
             consts = {
                     tool: 0,
                     tool_name: "unknown",
-                    top: (offset ? dev.bedDepth : dev.bedDepth/2) * units,
+                    top: (offset ? dev.bedDepth : dev.bedDepth/2),
-                    left: (offset ? 0 : -dev.bedWidth/2) * units,
+                    left: (offset ? 0 : -dev.bedWidth/2),
-                    right: (offset ? dev.bedWidth : dev.bedWidth/2) * units,
+                    right: (offset ? dev.bedWidth : dev.bedWidth/2),
-                    bottom: (offset ? 0 : -dev.bedDepth/2) * units,
+                    bottom: (offset ? 0 : -dev.bedDepth/2),
                     time_sec: 0,
                     time_ms: 0,
                     time: 0
@@ -1826,12 +1828,12 @@
                 moveTo({
                     tool: out.tool,
                     point: { x: 0, y: 0, z: newpos.z },
-                    speed: spro.camFastFeedZ
+                    speed: maxZd
                 });
                 moveTo({
                     tool: out.tool,
                     point: { x: newpos.x, y: newpos.y, z: newpos.z },
-                    speed: spro.camFastFeed
+                    speed: maxXYd
                 });
                 points--;
                 return;
@@ -1843,7 +1845,7 @@
                 dy = newpos.y - pos.y,
                 dz = newpos.z - pos.z,
                 dist = Math.sqrt(dx * dx + dy * dy + dz * dz),
-                feed = Math.min(speed || spro.camFastFeed, dz ? spro.camFastFeedZ : spro.camFastFeed);
+                feed = Math.min(speed || maxXYd, dz ? maxZd : maxXYd);
 
             // drop dup points (all deltas are 0)
             if (!(dx || dy || dz)) {
@@ -1854,23 +1856,23 @@
                 pos.x = newpos.x;
                 runbox.min.x = Math.min(runbox.min.x, pos.x);
                 runbox.max.x = Math.max(runbox.max.x, pos.x);
-                nl.append(space).append("X").append(add0(pos.x * units));
+                nl.append(space).append("X").append(add0(pos.x));
             }
             if (newpos.y !== pos.y) {
                 pos.y = newpos.y;
                 runbox.min.y = Math.min(runbox.min.y, pos.y);
                 runbox.max.y = Math.max(runbox.max.y, pos.y);
-                nl.append(space).append("Y").append(add0(pos.y * units));
+                nl.append(space).append("Y").append(add0(pos.y));
             }
             if (newpos.z !== pos.z) {
                 pos.z = newpos.z;
                 runbox.min.z = Math.min(runbox.min.z, pos.z);
                 runbox.max.z = Math.max(runbox.max.z, pos.z);
-                nl.append(space).append("Z").append(add0(pos.z * units));
+                nl.append(space).append("Z").append(add0(pos.z));
             }
             if (feed && feed !== pos.f) {
                 pos.f = feed;
-                nl.append(space).append("F").append(feed * units);
+                nl.append(space).append("F").append(feed);
             }
 
             // update time calculation

src/moto/space.js

@@ -230,27 +230,32 @@
         let x = platform.scale.x,
             y = isRound ? platform.scale.z : platform.scale.y,
             z = isRound ? platform.scale.y : platform.scale.z,
-            xr = ROUND(x / unitMajor) * unitMajor,
+            xr = Math.round(x / unitMinor) * unitMinor,
-            yr = ROUND(y / unitMajor) * unitMajor,
+            yr = Math.round(y / unitMinor) * unitMinor,
-            xo = isRound ? Math.floor(x/2) : Math.ceil(xr / 2),
+            xo = isRound ? x/2 : xr/2,
-            yo = isRound ? Math.floor(y/2) : Math.ceil(yr / 2),
+            yo = isRound ? y/2 : yr/2,
+            divs = Math.round(unitMajor / unitMinor),
             w = x / 2,
             h = y / 2,
             d = z / 2,
             zp = -d - platformZOff + gridZOff,
             majors = [], minors = unitMinor ? [] : null, i;
-        for (i = -xo; i <= xo; i++) {
+        for (i = -xo; i <= xo; i += unitMinor) {
-            if (i >= -w && i <= w) {
+            let oh = isRound ? Math.sqrt(1-(i/xo)*(i/xo)) * h : h,
-                let oh = isRound ? Math.sqrt(1-(i/xo)*(i/xo)) * h : h;
+                dM = Math.abs(i % unitMajor);
-                if (i % unitMajor === 0) majors.append({x:i, y:-oh, z:zp}).append({x:i, y:oh, z:zp});
+            if (dM < 0.1 || Math.abs(unitMajor - dM) < 0.1) {
-                else if (minors && i % unitMinor === 0) minors.append({x:i, y:-oh, z:zp}).append({x:i, y:oh, z:zp});
+                majors.append({x:i, y:-oh, z:zp}).append({x:i, y:oh, z:zp});
+            } else {
+                minors.append({x:i, y:-oh, z:zp}).append({x:i, y:oh, z:zp});
             }
         }
-        for (i = -yo; i <= yo; i++) {
+        for (i = -yo; i <= yo; i += unitMinor) {
-            if (i >= -h && i <= h) {
+            let ow = isRound ? Math.sqrt(1-(i/yo)*(i/yo)) * w : w,
-                let ow = isRound ? Math.sqrt(1-(i/yo)*(i/yo)) * w : w;
+                dM = Math.abs(i % unitMajor);
-                if (i % unitMajor === 0) majors.append({x:-ow, y:i, z:zp}).append({x:ow, y:i, z:zp});
+            if (dM < 0.1 || Math.abs(unitMajor - dM) < 0.1) {
-                else if (minors && i % unitMinor === 0) minors.append({x:-ow, y:i, z:zp}).append({x:ow, y:i, z:zp});
+                majors.append({x:-ow, y:i, z:zp}).append({x:ow, y:i, z:zp});
+            } else {
+                minors.append({x:-ow, y:i, z:zp}).append({x:ow, y:i, z:zp});
             }
         }
         gridView.add(makeLinesFromPoints(majors, gridColorMajor || 0x999999, 1));