ソースを参照

fix heap feeder function

Andrey Koryagin 3 週間 前
親
コミット
b75db40d2f

+ 1 - 1
pnpMachine/Flask/frontend/assets/AboutView.95c4c286.js → pnpMachine/Flask/frontend/assets/AboutView.6250e023.js

@@ -1 +1 @@
-import{_ as o,o as t,c as n,a as e}from"./index.440cd0bd.js";const c={},s=e("h1",null,"About pnpMachineVue",-1),_=e("div",null,null,-1),a=[s,_];function r(l,i){return t(),n("div",null,a)}var d=o(c,[["render",r]]);export{d as default};
+import{_ as o,o as t,c as n,a as e}from"./index.714bfe0f.js";const c={},s=e("h1",null,"About pnpMachineVue",-1),_=e("div",null,null,-1),a=[s,_];function r(l,i){return t(),n("div",null,a)}var d=o(c,[["render",r]]);export{d as default};

ファイルの差分が大きいため隠しています
+ 0 - 0
pnpMachine/Flask/frontend/assets/index.714bfe0f.js


+ 1 - 1
pnpMachine/Flask/frontend/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>pnpMachine</title>
-    <script type="module" crossorigin src="/assets/index.440cd0bd.js"></script>
+    <script type="module" crossorigin src="/assets/index.714bfe0f.js"></script>
     <link rel="stylesheet" href="/assets/index.e27dc412.css">
   </head>
   <body>

+ 58 - 0
pnpMachine/Vue/ToDo.txt

@@ -7,5 +7,63 @@ Check Mode
 
 - Soft Reset (Ctrl+X (0x18 = 24))
 
++ Імпорт фідерів у проєкт. Коли у проєкті вже є фідери не замінюються таблиця підходу.
+
 - Компенсація люфтів
 - Zoom
+
++ PSB Position Fix by CV
+
+
++'Fix' -> 'Adjustment', 'position adjustment', 'Position adjustment using CV'
++'fix' => 'adj'
++'Fix' => 'Adj'
+
+
++ pnpSafetyGoToXYZ_GCODE - Передивитися! G1 може бути ніфіга не Safety! Переробив! Перевірити!
++ Коррекція XY положення фідерів за допомогою CV
+
+
+----------------------------------------------
++ Рух без зупинок при зміні швидкості подачі:
+----------------------------------------------
+Треба у функціях позбавитися G0. перейти на G1 з вказанням подачі:
+
++ async pnpSafetyGoToXYZ(x, y, z)
++ async pnpGoToXYZA(x, y, z, a)
++ async pnpGoToXYZF(x, y, z, feed)
++ pnpSafetyUp(a)
+
+Спробувати обєднати функції:
+async pnpGoToXYZA(x, y, z, a)
+async pnpGoToXYZF(x, y, z, feed)
+
+Зробити функції типу 
++ pnpSafetyGoToXYZ_GCODE(x, y, z)
+які б повертали б масив команд, використовувати їх у функціях типу pnpSafetyGoToXYZ
+тоді можна буде їх використовувати для створення пулу команд і відправлят їх 
+sendCommands(cmdArray, wailIdle=false)
+тоді рух має бути без зупинок.
+
+Функції pnpPutOnNozzle, pnpPullOffNozzle переробити. pnpPullOffNozzle повертає false, якщо е пройшли перевырки. Винести перевырки в окрему функцію.
+Тоді можна буде в один пул зібрати команди зняття і одягання сопла. Це має прибрати мікрозупинки
+
+
++ (sendCommandsPool) Функція відправки пула команд приблизно така:
+
+    async testMove() {
+      console.log('testMove Start')
+      let commands = ['G0 X-100 Y-100 Z-25', 'G1 Z-35 F300', 'G1 Z-50 F600']
+      for (let cmd of commands) {
+        await this.sendCommand(cmd)
+      }
+      await this.sendCommands(['?'], true)
+      console.log('testMove Stop')
+    }
+
+await this.sendCommand(cmd) - запихує команди без очікування виконання. Це дає змогу планувальнику grblHAL нормально рухати без промыжної зупинки
+await this.sendCommands(['?'], true) - Чекає на закінчення всього пулу
+
+----------------------------------------------
+
+

+ 57 - 13
pnpMachine/Vue/src/js/pnp_mixin.js

@@ -533,17 +533,28 @@ export default {
               let wy = parseFloat(feeder.pos.wy) / 2.0
 
               for (let obj of cvData.objects.rect) {
-                let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
-                let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
 
-                let distance = Math.sqrt(dx*dx + dy*dy)
+                let minX = Math.min(...obj.box.map(p => p[0]));
+                let maxX = Math.max(...obj.box.map(p => p[0]));
+
+                let minY = Math.min(...obj.box.map(p => p[1]));
+                let maxY = Math.max(...obj.box.map(p => p[1]));
+                let objWidth = (maxX - minX) / this.settings.cams[topCamID].ppmm
+                let objHeight = (maxY - minY) / this.settings.cams[topCamID].ppmm
+
+                if ((objWidth < feeder.pos.wx) & (objHeight < feeder.pos.wy) ) {
+                  let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+                  let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
 
-                if ((Math.abs(dx) < wx) && (Math.abs(dy) < wy)) {
-                  if (distance < rectObjectDistance) {
-                    rectObject = Object.assign({}, obj)
-                    rectObject.dxmm = dx
-                    rectObject.dymm = dy
-                    rectObjectDistance = distance
+                  let distance = Math.sqrt(dx*dx + dy*dy)
+
+                  if ((Math.abs(dx) < wx) && (Math.abs(dy) < wy)) {
+                    if (distance < rectObjectDistance) {
+                      rectObject = Object.assign({}, obj)
+                      rectObject.dxmm = dx
+                      rectObject.dymm = dy
+                      rectObjectDistance = distance
+                    }
                   }
                 }
               }
@@ -562,7 +573,11 @@ export default {
             await this.pnpSafetyGoToXYZ(x, y, z)
             await this.pnpValveOn(head)
             await this.pnpSafetyUp()
-            await this.pnpGoToXYZA(NaN, NaN, NaN, a)
+
+            // Rotate if not uses correction by bottom Cam
+            if (feeder.posCorrection == false) {
+              await this.pnpGoToXYZA(NaN, NaN, NaN, a)
+            }
 
           } else {
             await alert('Can not see element in feeder "' + feeder.name + '"!', 'Warning', 'warning')
@@ -656,7 +671,9 @@ export default {
 
     async pnpAdjPCBPositionCV(project) {
       let topCamID = 0
-
+      project.pcb.pos.x = 0
+      project.pcb.pos.y = 0
+  
       // Find fiducials in elements array
       let fiducials = []
       for (let element of project.elements) {
@@ -680,6 +697,7 @@ export default {
           await new Promise(r => setTimeout(r, 2*this.settings.cv[topCamID].pauseBefore*1000))
           // Get CV data
           let cvData = await this.getCVData(topCamID)
+
           await this.pnpLightOff(topCamID)
 
           //console.log(cvData)
@@ -689,6 +707,7 @@ export default {
 
           // If object is found
           if (typeof cvData.objects !== 'undefined') {
+
             // If circle(s) is found
             if (typeof cvData.objects.circle !== 'undefined') {
               for (let obj of cvData.objects.circle) {
@@ -708,12 +727,34 @@ export default {
                 }
 
               }
-            }        
+            }
+
+            if (typeof cvData.objects.rect !== 'undefined') {
+              for (let obj of cvData.objects.rect) {
+
+                let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+                let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+
+                let distance = Math.sqrt(dx*dx + dy*dy)
+
+                if (distance < 2.0) {
+                  if (distance < circleObjectDistance) {
+                    circleObject = Object.assign({}, obj)
+                    circleObject.dxmm = dx
+                    circleObject.dymm = dy
+                    circleObjectDistance = distance
+                  }
+                }
+
+              }
+            }  
+
+
           }
 
           if (circleObject) {
             //console.log(circleObject.dxmm, circleObject.dymm)
-            xOffset += circleObject.dxmm
+            xOffset -= circleObject.dxmm
             yOffset += circleObject.dymm
             fiducialCount += 1
           } else {
@@ -722,6 +763,9 @@ export default {
 
         }
 
+        //console.log(xOffset)
+        //console.log(yOffset)
+
         // Set PSB Offset
         if (fiducialCount > 0) {
           project.pcb.pos.x = (xOffset / fiducialCount).toFixed(3)

+ 1186 - 0
pnpMachine/Vue/src/js/pnp_mixin.js.bak.bak

@@ -0,0 +1,1186 @@
+import { alert, confirm } from '../js/dialogs.js'
+
+export default {
+  methods: {
+    //--------------------------------------------------------
+    // Level 1
+    //--------------------------------------------------------
+    async sendCommandUI(cmd) {
+      this.consoleLogAppend('>>> ' + cmd)
+      if (this.portIsOpened) {
+
+        //if (cmd == '$H') {
+        //  this.machineState.status = 'Homing'
+        //}
+
+        await this.sendCommand(cmd)
+        this.consoleLogAppend(this.request)
+        if (cmd[0] == 'M') {
+          await this.sendCommand('$G')
+        }
+
+        if (cmd !== '?') {
+          await this.sendCommand('?')
+        }
+
+        while ((this.machineState.status !== 'Idle') && ( this.machineState.status !== 'Alarm') ) {
+          await new Promise(r => setTimeout(r, 100));
+          await this.sendCommand('?')
+        }
+      }
+    },
+
+    async sendCommands(cmdArray, wailIdle=false) {
+      if (this.pnpProcessing.stopFlag == true) {
+        return
+      }
+
+      // reset flags
+      this.gCodeProcess.stopFlag = false
+      this.gCodeProcess.pauseFlag = false
+
+      for (let cmd of cmdArray) {
+        console.log(cmd)
+        await this.sendCommand(cmd)
+        if (cmd !== '?') {
+          await this.sendCommand('?')
+        }
+        if (wailIdle) {
+          while (this.machineState.status !== 'Idle') {
+            await new Promise(r => setTimeout(r, 100));
+            await this.sendCommand('?')
+          }
+        }
+        while ((this.gCodeProcess.pauseFlag == true) || (this.pnpProcessing.pauseFlag == true)) {
+          //Wait
+          await new Promise(resolve => setTimeout(resolve, 200))
+        }
+        if ((this.gCodeProcess.stopFlag == true) || (this.pnpProcessing.stopFlag == true)) {
+          break
+        }
+      }
+
+      // reset flags
+      this.gCodeProcess.stopFlag = false
+      this.gCodeProcess.pauseFlag = false
+    },
+
+    /////
+    async sendCommandsPool(commands) {
+      console.log('sendCommandsPool Start')
+      for (let cmd of commands) {
+        await this.sendCommand(cmd)
+      }
+      await this.sendCommands(['?'], true)
+      console.log('sendCommandsPool Stop')
+    },
+
+    async sendCommand(cmd) {
+      if (this.portIsOpened) {
+        if (cmd == '$H') {
+          this.machineState.status = 'Homing'
+        }
+        
+        let command = Uint8Array.from(Array.from(cmd + "\n").map(letter => letter.charCodeAt(0)));
+        await this.portConnection.write(command)
+        await this.readRequest()
+      }
+    },
+
+    async readRequest() {
+      let request = await this.portConnection.read()
+      this.parseRequest(request)
+    },
+
+    parseRequest(request) {
+      let decoder = new TextDecoder();
+      let str = decoder.decode(request);
+      this.request = str
+
+      // Parse state get after command '?'
+      // <Idle|MPos:30.000,10.000,0.000,0.000>
+      let regexp = /<([a-z,A-Z]*)\|MPos:(.*)>/g
+      let matchAll = str.matchAll(regexp)
+      matchAll = Array.from(matchAll)
+      if (matchAll.length == 1) {
+        if (matchAll[0].length == 3) {
+          this.machineState.status = matchAll[0][1]
+          let pos = matchAll[0][2].split(',')
+          this.machineState.pos.x = parseFloat(pos[0])
+          this.machineState.pos.y = parseFloat(pos[1])
+          this.machineState.pos.z = parseFloat(pos[2])
+          this.machineState.pos.a = parseFloat(pos[3])
+        }
+      } else {
+        // Parse information get after commands '$I' or '$G'
+        let regexp = /\[([a-z,A-Z, ]*):(.*)]/g
+        let matchAll = str.matchAll(regexp)
+        matchAll = Array.from(matchAll)
+        if (matchAll.length > 0) {
+          for (let item of matchAll) {
+            if (item.length == 3) {
+              this.machineState.info[item[1]] = item[2]
+            }
+          }
+        } else {
+          // Parse settings get after command '$$' or '$[0..9]*' ($10, $23, ...)
+          let regexp = /\$([0-9]*)=(.*)/g
+          let matchAll = str.matchAll(regexp)
+          matchAll = Array.from(matchAll)
+          if (matchAll.length > 0) {
+            for (let item of matchAll) {
+              if (item.length == 3) {
+                this.machineState.settings[item[1]] = parseFloat(item[2])
+              }
+            }            
+          }
+        }
+      }
+    },
+
+    //--------------------------------------------------------
+    // Level 2
+    //--------------------------------------------------------
+    fetch_execute_async: async function (url, options) {
+      this.loading = true
+      try {
+        let response = await fetch(url, options)
+        let result = await response.json()
+        return result
+      }
+      catch (error) {
+        console.log(error)
+      }
+      finally {
+        this.loading = false
+      }
+    },
+
+    async getCVData(number) {
+      let url = 'http://localhost:5000/cv/'+number+'?'+Date.now()
+        let postdata = this.cvParams[number]
+      return await this.fetch_execute_async( url, { method: 'POST', credentials: 'same-origin', cache: 'no-cache', headers: {'Content-Type': 'application/json;charset=utf-8'}, body: JSON.stringify(postdata)} )
+    },
+
+    pnpGoToZero_GCODE() {
+      let commands = []
+      let safePosZ = parseFloat(this.settings.heads[0].safePosZ)
+      commands.push(`G0 Z${safePosZ}`)
+      commands.push(`G0 X0 Y0`)
+      commands.push(`G0 Z0`)
+      return commands
+    },
+
+    async pnpGoToZero() {
+      let commands = this.pnpGoToZero_GCODE()
+      await this.sendCommands(commands, true)
+    },
+
+    pnpGoToParking_GCODE() {
+      let commands = []
+      commands.push(`G0 Z${this.settings.parking.pos.z}`)
+      commands.push(`G0 X${this.settings.parking.pos.x} Y${this.settings.parking.pos.y} A0`)
+      return commands
+    },
+
+    async pnpGoToParking() {
+      let commands = this.pnpGoToParking_GCODE()
+      await this.sendCommands(commands, true)
+    },
+
+    pnpPumpOn_GCODE() {
+      let commands = []
+      commands.push(this.settings.pump.On)
+      commands.push(`$G`)
+      return commands
+    },
+
+    async pnpPumpOn() {
+      let commands = this.pnpPumpOn_GCODE()
+      await this.sendCommands(commands, true)
+    },
+
+    pnpPumpOff_GCODE() {
+      let commands = []
+      commands.push(this.settings.pump.Off)
+      commands.push(`$G`)
+      return commands
+    },
+
+    async pnpPumpOff() {
+      let commands = this.pnpPumpOff_GCODE()
+      await this.sendCommands(commands, true)
+    },
+
+    pnpValveOn_GCODE(head) {
+      let commands = []
+      commands.push(`G04 P${head.pauseBeforeOn}`)
+      commands.push(head.valveOn)
+      commands.push(`G04 P${head.pauseAfterOn}`)
+      commands.push(`$G`)
+      return commands
+    },
+    
+    async pnpValveOn(head) {
+     let commands = this.pnpValveOn_GCODE(head)
+     await this.sendCommands(commands, true)
+    },
+
+    pnpValveOff_GCODE(head) {
+      let commands = []
+      commands.push(`G04 P${head.pauseBeforeOff}`)
+      commands.push(head.valveOff)
+      commands.push(`G04 P${head.pauseAfterOff}`)
+      commands.push(`$G`)
+      return commands
+    },
+
+    async pnpValveOff(head) {
+      let commands = this.pnpValveOff_GCODE(head)
+      await this.sendCommands(commands, true)
+    },
+
+    pnpLightOn_GCODE(camN) {
+      let commands = []
+      commands.push(this.settings.cams[camN].lightOn)
+      commands.push(`$G`)
+      return commands
+    },
+    
+    async pnpLightOn(camN) {
+     let commands = this.pnpLightOn_GCODE(camN)
+     await this.sendCommands(commands, true)
+    },
+
+    pnpLightOff_GCODE(camN) {
+      let commands = []
+      commands.push(this.settings.cams[camN].lightOff)
+      commands.push(`$G`)
+      return commands
+    },
+
+    async pnpLightOff(camN) {
+      let commands = this.pnpLightOff_GCODE(camN)
+      await this.sendCommands(commands, true)
+    },
+
+
+    pnpSafetyUp_GCODE(a) {
+      let safePosZ = parseFloat(this.settings.heads[0].safePosZ)
+      let cmd = `G0 Z${safePosZ}`
+      if (!isNaN(a)) {
+        cmd = cmd + ` A${a}`
+      }
+      let commands = [cmd]
+      return commands
+    },
+
+    // this.pnpSafetyUp()    - just Up to Safety Z
+    // this.pnpSafetyUp(0)   - Up to Safety Z and Rotate to A=0
+    async pnpSafetyUp(a) {
+      let commands = this.pnpSafetyUp_GCODE(a)
+      await this.sendCommands(commands, true)
+    },
+
+
+    /////
+    pnpSafetyGoToXYZ_GCODE(x, y, z) {
+      let commands = []
+      //let safePosZ = parseFloat(this.settings.heads[0].safePosZ)
+      //commands.push(`G0 Z${safePosZ}`)
+      //commands.push(`G0 X${x} Y${y}`)
+
+
+      //commands.push(...this.pnpGoToXYZAF_GCODE(NaN, NaN, safePosZ, NaN, 5500))
+      commands.push(...this.pnpSafetyUp_GCODE())
+      commands.push(...this.pnpGoToXYZAF_GCODE(x, y, NaN, NaN, 5500))
+
+      if (!isNaN(z)) {
+        //commands.push(`G0 Z${z}`)
+        commands.push(...this.pnpGoToXYZAF_GCODE(NaN, NaN, z, NaN, 5500))
+      }
+      return commands
+    },
+
+    // this.pnpSafetyGoToXYZ(x=10, y=10, z=10)
+    // this.pnpSafetyGoToXYZ(10, 0, 10)
+    // this.pnpSafetyGoToXYZ(x=10, y=10, z=NaN)  - finally Z = safePosZ
+    // this.pnpSafetyGoToXYZ(10, 0, z=NaN)       - finally Z = safePosZ
+    async pnpSafetyGoToXYZ(x, y, z) {
+      let commands = this.pnpSafetyGoToXYZ_GCODE(x, y, z)
+      await this.sendCommands(commands, true)
+    },
+
+    /////
+    pnpGoToXYZA_GCODE(x, y, z, a) {
+      let cmd = 'G0'
+      if (!isNaN(x)) cmd = cmd + ` X${x}`
+      if (!isNaN(y)) cmd = cmd + ` Y${y}`
+      if (!isNaN(z)) cmd = cmd + ` Z${z}`
+      if (!isNaN(a)) cmd = cmd + ` A${a}`
+      let commands = [cmd]
+      return commands
+    },
+
+    // this.pnpGoToXYZA(x=NaN, y=NaN, z=-25, a=0)
+    // this.pnpGoToXYZA(10, 20, NaN, NaN)
+    // this.pnpGoToXYZA(NaN, NaN, 20, 0)
+    async pnpGoToXYZA(x, y, z, a) {
+      let commands = this.pnpGoToXYZA_GCODE(x, y, z, a)
+      await this.sendCommands(commands, true)
+    },
+
+/*
+    pnpGoToXYZF_GCODE(x, y, z, feed) {
+      let cmd = 'G1'
+      if (!isNaN(x)) cmd = cmd + ` X${x}`
+      if (!isNaN(y)) cmd = cmd + ` Y${y}`
+      if (!isNaN(z)) cmd = cmd + ` Z${z}`
+      if (!isNaN(feed)) cmd = cmd + ` F${feed}`
+      let commands = [cmd]
+      return commands
+    },
+
+    async pnpGoToXYZF(x, y, z, feed) {
+      let commands = this.pnpGoToXYZF_GCODE(x, y, z, feed)
+      await this.sendCommands(commands, true)
+    },
+*/
+
+    pnpGoToXYZAF_GCODE(x, y, z, a, feed=500) {
+      let cmd = 'G1'
+      if (!isNaN(x)) cmd = cmd + ` X${x}`
+      if (!isNaN(y)) cmd = cmd + ` Y${y}`
+      if (!isNaN(z)) cmd = cmd + ` Z${z}`
+      if (!isNaN(a)) cmd = cmd + ` A${a}`
+      if (!isNaN(feed)) cmd = cmd + ` F${feed}`
+      let commands = [cmd]
+      return commands
+    },
+
+
+    //--------------------------------------------------------
+    // Level 3
+    //--------------------------------------------------------
+
+    //@pnpDo
+    async pnpGoToBottomCam() {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let bottomCamID = 1
+        let x, y, z
+        x = parseFloat(this.settings.cams[bottomCamID].pos.x)
+        y = parseFloat(this.settings.cams[bottomCamID].pos.y)
+        z = parseFloat(this.settings.cams[bottomCamID].pos.z)
+
+        // Move to Bottom Cam X,Y
+        await this.pnpSafetyGoToXYZ(x, y, NaN, NaN)
+
+        // Light On
+        await this.pnpLightOn(bottomCamID)
+
+        // Move to Bottom Cam Z
+        await this.pnpGoToXYZA(NaN, NaN, z, NaN)
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    // ---------------------------------
+    // Go to feeder on safety Z position
+    // ---------------------------------
+    getFeederPos(feeder) {
+        let x = 0
+        let y = 0
+
+        // Type Liner
+        if (feeder.type == 0) {
+          x = feeder.pos.x
+          y = feeder.pos.y
+        }
+
+        // Type Push-Pull
+        if (feeder.type == 1) {
+          for (let point of feeder.pathPoints) {
+            if (point.pick == true) {
+              x = point.x
+              y = point.y
+            }
+          }
+        }
+
+        // Type Heap
+        if (feeder.type == 2) {
+          x = feeder.pos.x
+          y = feeder.pos.y
+        }
+
+        return {x:x, y:y}
+    },
+
+    async pnpGoToFeeder(feeder) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+        let pos = this.getFeederPos(feeder)
+        await this.pnpSafetyGoToXYZ(pos.x, pos.y, NaN)
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    async pnpGoToFeederCam(feeder) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let pos = this.getFeederPos(feeder)
+
+        pos.x = parseFloat(pos.x) - parseFloat(this.settings.cams[0].offset.x)
+        pos.y = parseFloat(pos.y) - parseFloat(this.settings.cams[0].offset.y)
+
+        await this.pnpSafetyGoToXYZ(pos.x, pos.y, NaN)
+
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    // ---------------------------------
+    // Pick element rom feeder
+    // ---------------------------------
+    async pnpPickFromFeeder(feeder, headN=0) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let x, y, z
+        let head = this.settings.heads[headN]
+
+        // Type Liner
+        if (feeder.type == 0) {
+          if (parseInt(feeder.current)+1 < parseInt(feeder.capacity)) {
+
+            if (this.valvesState[headN] == false) {
+              x = parseFloat(feeder.pos.x) + parseFloat(feeder.step.x) * parseFloat(feeder.current)
+              y = parseFloat(feeder.pos.y) + parseFloat(feeder.step.y) * parseFloat(feeder.current)
+              z = parseFloat(feeder.pos.z) + parseFloat(feeder.step.z) * parseFloat(feeder.current)
+
+              await this.pnpSafetyUp(0)
+              await this.pnpSafetyGoToXYZ(x, y, z)
+              await this.pnpValveOn(head)
+              await this.pnpSafetyUp()
+
+              feeder.current = parseInt(feeder.current)+1
+            } else {
+              await alert('Valve is On!', 'Warning', 'warning')
+              return false
+            }
+          } else {
+            await alert('Feeder is empty', 'Warning', 'warning')
+            return false
+          }
+        }
+
+        // Type Push-Pull
+        if (feeder.type == 1) {
+          await this.pnpSafetyUp(0)
+
+          let commands = []
+          for (let point of feeder.pathPoints) {
+            //await this.pnpGoToXYZA(point.x, point.y, NaN, NaN)
+            //await this.pnpGoToXYZA(NaN, NaN, point.z, NaN)
+            
+            commands.push(...this.pnpGoToXYZAF_GCODE(point.x, point.y, NaN, NaN, 5500))
+            commands.push(...this.pnpGoToXYZAF_GCODE(NaN, NaN, point.z, NaN, 5500))
+
+            if (point.pick == true) {
+              //await this.pnpValveOn(head)
+              commands.push(...this.pnpValveOn_GCODE(head))
+            }
+          }
+          console.log(commands)
+          await this.sendCommandsPool(commands)
+
+          await this.pnpSafetyUp()
+        }
+
+        // Type Heap
+        if (feeder.type == 2) {
+          let topCamID = 0
+
+          await this.pnpSafetyUp(0)
+          await this.pnpLightOn(topCamID)
+          await this.pnpGoToFeederCam(feeder)
+          
+          // Pause before make Photo :)
+          await new Promise(r => setTimeout(r, this.settings.cv[topCamID].pauseBefore*1000))
+          // Get CV data
+          let cvData = await this.getCVData(topCamID)
+          
+          await this.pnpLightOff(topCamID)
+
+          let rectObject
+          let rectObjectDistance = 10000
+
+          // If object is found
+          if (typeof cvData.objects !== 'undefined') {
+            // If rect(s) is found
+            if (typeof cvData.objects.rect !== 'undefined') {
+              let wx = parseFloat(feeder.pos.wx) / 2.0
+              let wy = parseFloat(feeder.pos.wy) / 2.0
+
+              for (let obj of cvData.objects.rect) {
+                let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+                let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+
+                let distance = Math.sqrt(dx*dx + dy*dy)
+
+                if ((Math.abs(dx) < wx) && (Math.abs(dy) < wy)) {
+                  if (distance < rectObjectDistance) {
+                    rectObject = Object.assign({}, obj)
+                    rectObject.dxmm = dx
+                    rectObject.dymm = dy
+                    rectObjectDistance = distance
+                  }
+                }
+              }
+
+            }
+          }
+
+          if (rectObject) {
+            //console.log(rectObject)
+            let x = parseFloat(feeder.pos.x) - rectObject.dxmm
+            let y = parseFloat(feeder.pos.y) + rectObject.dymm
+            let z = parseFloat(feeder.pos.z) + parseFloat(feeder.elementHeight)
+            let a = -rectObject.angle / 360
+            
+            //console.log(x,y,x,a)
+            await this.pnpSafetyGoToXYZ(x, y, z)
+            await this.pnpValveOn(head)
+            await this.pnpSafetyUp()
+            await this.pnpGoToXYZA(NaN, NaN, NaN, a)
+
+          } else {
+            await alert('Can not see element in feeder "' + feeder.name + '"!', 'Warning', 'warning')
+          }
+
+        }
+
+        return true
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    // ---------------------------------
+    // Correction of Feeder Position using Computer Vision
+    // ---------------------------------
+    async pnpAdjFeederPositionCV(feeder) {
+      let topCamID = 0
+
+      // Light On
+      await this.pnpLightOn(topCamID)
+      await this.pnpGoToFeederCam(feeder)
+      
+      // Pause before make Photo :)
+      await new Promise(r => setTimeout(r, this.settings.cv[topCamID].pauseBefore*1000))
+      // Get CV data
+      let cvData = await this.getCVData(topCamID)
+      let rectObject
+      let rectObjectDistance = 10000
+
+      // If object is found
+      if (typeof cvData.objects !== 'undefined') {
+        // If rect(s) is found
+        if (typeof cvData.objects.rect !== 'undefined') {
+          for (let obj of cvData.objects.rect) {
+            let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+            let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+
+            let distance = Math.sqrt(dx*dx + dy*dy)
+
+            if (distance < 2.0) {
+              if (distance < rectObjectDistance) {
+                rectObject = Object.assign({}, obj)
+                rectObject.dxmm = dx
+                rectObject.dymm = dy
+                rectObjectDistance = distance
+              }
+            }
+          }
+        }        
+      }
+
+      if (rectObject) {
+        // Line Feeder
+        if (feeder.type == 0) {
+          feeder.pos.x = (parseFloat(feeder.pos.x)- rectObject.dxmm).toFixed(3)
+          feeder.pos.y = (parseFloat(feeder.pos.y) + rectObject.dymm).toFixed(3)
+        }
+        // Push-Pull Feeder
+        if (feeder.type == 1) {
+          let pointY = 0
+          for (let point of feeder.pathPoints) {
+            point.x = (parseFloat(point.x) - rectObject.dxmm).toFixed(3)
+            if (point.pick == true) {
+              pointY = point.y
+            }
+          }
+          for (let point of feeder.pathPoints) {
+            if (point.y == pointY) {
+              point.y = (parseFloat(point.y) + rectObject.dymm).toFixed(3)
+            }
+          }
+        }
+
+        await this.pnpGoToFeederCam(feeder)
+      } else {
+        await alert('Can not see element in feeder "' + feeder.name + '"!', 'Warning', 'warning')
+      }
+      
+      await this.pnpLightOff(topCamID)
+    },
+
+    async pnpAdjFeedersPositionCV(feeders) {
+      for (let feeder of feeders) {
+        if (feeder.active == true) {
+          await this.pnpAdjFeederPositionCV(feeder)
+        }
+      }
+    },
+
+
+    async pnpAdjPCBPositionCV(project) {
+      let topCamID = 0
+
+      // Find fiducials in elements array
+      let fiducials = []
+      for (let element of project.elements) {
+        if (element.caption.toLowerCase().includes('fiducial')) {
+            fiducials.push(element)
+        }
+      }
+
+      // If fiducials is found
+      if (fiducials.length > 0) {
+        let xOffset = 0
+        let yOffset = 0
+        let fiducialCount = 0
+
+        for (let fiducial of fiducials) {
+          //
+          await this.pnpLightOn(topCamID)
+          await this.pnpGoToElementCam(fiducial)
+
+          // Pause before make Photo :)
+          await new Promise(r => setTimeout(r, 2*this.settings.cv[topCamID].pauseBefore*1000))
+          // Get CV data
+          let cvData = await this.getCVData(topCamID)
+          await this.pnpLightOff(topCamID)
+
+          //console.log(cvData)
+
+          let circleObject
+          let circleObjectDistance = 10000
+
+          // If object is found
+          if (typeof cvData.objects !== 'undefined') {
+            // If circle(s) is found
+            if (typeof cvData.objects.circle !== 'undefined') {
+              for (let obj of cvData.objects.circle) {
+
+                let dx = Math.round(obj.dx*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+                let dy = Math.round(obj.dy*1000.0 / this.settings.cams[topCamID].ppmm) / 1000.0
+
+                let distance = Math.sqrt(dx*dx + dy*dy)
+
+                if (distance < 2.0) {
+                  if (distance < circleObjectDistance) {
+                    circleObject = Object.assign({}, obj)
+                    circleObject.dxmm = dx
+                    circleObject.dymm = dy
+                    circleObjectDistance = distance
+                  }
+                }
+
+              }
+            }        
+          }
+
+          if (circleObject) {
+            //console.log(circleObject.dxmm, circleObject.dymm)
+            xOffset += circleObject.dxmm
+            yOffset += circleObject.dymm
+            fiducialCount += 1
+          } else {
+            await alert('Can not see Fiducials on the PCB!', 'Warning', 'warning')
+          }
+
+        }
+
+        // Set PSB Offset
+        if (fiducialCount > 0) {
+          project.pcb.pos.x = (xOffset / fiducialCount).toFixed(3)
+          project.pcb.pos.y = (yOffset / fiducialCount).toFixed(3)
+        }
+
+      } else {
+        await alert('Fiducials is not found! One or more elements must contain \'FIDUCIAL\' in field \'Caption\'!', 'Warning', 'warning')
+      }
+    },
+
+    // ---------------------------------
+    // Adjust position of picked element 
+    // ---------------------------------
+    async pnpAdjPosition() {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let bottomCamID = 1
+        let x, y, z, a
+        let cvData
+
+        x = parseFloat(this.settings.cams[bottomCamID].pos.x)
+        y = parseFloat(this.settings.cams[bottomCamID].pos.y)
+        z = parseFloat(this.settings.cams[bottomCamID].pos.z)
+        a = this.machinePos.a
+        //let aDegrees = a * 360.0
+
+        await this.pnpGoToBottomCam()
+
+        // Adjust position and rotation in 3 iterations
+        for (let i=0; i<3; i++) {
+          // Pause before make Photo :)
+          await new Promise(r => setTimeout(r, this.settings.cv[bottomCamID].pauseBefore*1000))
+          // Get CV data
+          cvData = await this.getCVData(bottomCamID)
+          console.log(cvData)
+          // If object is found
+          if (typeof cvData.objects.object !== 'undefined') {
+            // Adjust Position X,Y
+            let dx = Math.round(cvData.objects.object.dx*1000.0 / this.settings.cams[bottomCamID].ppmm) / 1000.0
+            let dy = Math.round(cvData.objects.object.dy*1000.0 / this.settings.cams[bottomCamID].ppmm) / 1000.0
+            x = x - dx
+            y = y - dy
+
+            // Adjust Rotation
+            let da = cvData.objects.object.angle_degrees
+
+            // Align to vertical or horizontal
+            if (da < -45.0) {
+              da = 90.0 + da
+            }
+            if (da > 45.0) {
+              da = -90.0 + da
+            }
+            // Recalculate to turn
+            da = da / 360
+            // Calculate absolute a
+            a = a - da
+
+            if ( (Math.abs(dx) < 5.0) && (Math.abs(dy) < 5.0) && (Math.abs(da) < 0.25) )  { // if dx, dy, da is in adequate range
+              // Move and rotate
+              await this.pnpGoToXYZA(x, y, NaN, a)
+            }
+          }
+        }
+        //
+
+        // Light off
+        await this.pnpLightOff(bottomCamID)
+
+        let el_x = parseFloat(this.machinePos.x) - parseFloat(this.settings.cams[bottomCamID].pos.x)
+        let el_y = parseFloat(this.machinePos.y) - parseFloat(this.settings.cams[bottomCamID].pos.y)
+        let element_offsets = {x: el_x, y: el_y}
+        return element_offsets
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+
+
+    },
+
+    // ---------------------------------
+    // To Basket
+    // ---------------------------------
+    async pnpDropIntoBasket() {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let x = this.settings.basket.pos.x
+        let y = this.settings.basket.pos.y
+        let z = this.settings.basket.pos.z
+
+        await this.pnpSafetyGoToXYZ(x, y, z)
+
+        for (let head of this.settings.heads) {
+          await this.pnpValveOff(head)
+        }
+        await this.pnpSafetyUp(0)
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    //--------------------------------------------------------
+    async pnpGoToElement(element) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let offsetPCB = this.project.pcb.pos
+        let x = parseFloat(element.pos.x) + parseFloat(offsetPCB.x)
+        let y = parseFloat(element.pos.y) + parseFloat(offsetPCB.y)
+
+        await this.pnpSafetyGoToXYZ(x, y, NaN)
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    async pnpGoToElementCam(element) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let offsetPCB = this.project.pcb.pos
+        let x = parseFloat(element.pos.x) + parseFloat(offsetPCB.x) - parseFloat(this.settings.cams[0].offset.x)
+        let y = parseFloat(element.pos.y) + parseFloat(offsetPCB.y) - parseFloat(this.settings.cams[0].offset.y)
+
+        await this.pnpSafetyGoToXYZ(x, y, NaN)
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+    //--------------------------------------------------------
+
+    getNozzle(id) {
+      for (let nozzle of this.settings.nozzles) {
+        if (nozzle.id == id) {
+          return nozzle
+        }
+      }
+    },
+
+    getNozzleOffset(nozzle, a) {
+      if (a < 0) {
+        a = 1.0 + a
+      }
+      for (let row of nozzle.calibrationData) {
+        if (row.a >= a) {
+          return row
+        }
+      }
+    },
+
+
+    async pnpPlaceElement(element) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let head = this.settings.heads[0]
+        let PCBTableZ = parseFloat(this.settings.table.pos.z)
+
+        let feederId = element.feeder
+        let offsetPos = {x:0, y:0}
+        let a = parseFloat(element.pos.a)
+
+        for (let feeder of this.project.feeders) {
+          if (feeder.id == feederId) {
+
+            if (await this.pnpPickFromFeeder(feeder) == false) {
+              return false
+            }
+            
+            // Rotate element if need
+            if (a !== 0.0) {
+              await this.pnpGoToXYZA(NaN, NaN, NaN, a) 
+            }
+
+            // Correct Position
+            if (feeder.posCorrection == true) {
+              offsetPos = await this.pnpAdjPosition() // Adjust position
+            } else {
+              // Get nuzzle offsets here
+              let nozzle = this.getNozzle(feeder.nozzle)
+              let nozzleOffset = this.getNozzleOffset(nozzle, a)
+              offsetPos.x = nozzleOffset.dx
+              offsetPos.y = nozzleOffset.dy
+            }
+
+            let offsetPCB = this.project.pcb.pos
+    
+            let x = parseFloat(element.pos.x) + parseFloat(offsetPos.x) + parseFloat(offsetPCB.x)
+            let y = parseFloat(element.pos.y) + parseFloat(offsetPos.y) + parseFloat(offsetPCB.y)
+            let z = PCBTableZ + parseFloat(offsetPCB.z) + parseFloat(feeder.elementHeight)
+
+            await this.pnpSafetyGoToXYZ(x, y, z)
+            await this.pnpValveOff(head)
+            await this.pnpSafetyUp()
+            await this.pnpGoToXYZA(NaN, NaN, NaN, 0) 
+
+          }
+        }
+        return true
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+    //--------------------------------------------------------
+
+    async pnpAutocalibrateNozzle(nozzle) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+        this.pnpProcessing.runFlag = true
+
+        let bottomCamID = 1
+        let ppmm = this.settings.cams[bottomCamID].ppmm
+
+        await this.pnpSafetyUp(0)
+        await this.pnpGoToBottomCam()
+
+        for (let row of nozzle.calibrationData) {
+          //if (row.a != 0) {
+            await this.pnpGoToXYZA(NaN, NaN, NaN, row.a)
+            // Pause before make Photo :)
+            await new Promise(r => setTimeout(r, this.settings.cv[bottomCamID].pauseBefore*1000))
+            let cvData = await this.getCVData(bottomCamID)
+            if (typeof cvData.objects.nozzle != 'undefined') {
+              row.dx = -(cvData.objects.nozzle.dx / ppmm).toFixed(3)
+              row.dy = -(cvData.objects.nozzle.dy / ppmm).toFixed(3)
+            } else {
+              await alert("Autocalibration is failed! Nozzle not found!", 'Error', 'error')
+              return
+            }
+
+          //}
+        }
+        
+        // Light off
+        await this.pnpLightOff(bottomCamID)
+        await this.pnpSafetyUp(0)
+
+        await alert("Calibration has been completed", 'Completed', 'success')
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    },
+
+    getNozzlePlace(nozzleId) {
+      for (let place of this.settings.nozzlesHolder.places) {
+        if (place.nozzleId == nozzleId) {
+          return place
+        }
+      }
+      return null
+    },
+
+    pnpGetEmptyNozzlePlace() {
+      let emptyPlace = null
+
+      // Return true if head without Nozzle
+      if (this.settings.heads[0].nozzle == -1) {
+        return true
+      }
+
+      // Find empty place
+      for (let place of this.settings.nozzlesHolder.places) {
+        if (place.nozzleId == -1) {
+          emptyPlace = place
+          break
+        }
+      }
+
+      if (emptyPlace == null) {
+        alert('Not found the empty place!', 'Error', 'error')
+        return null
+      }
+      return emptyPlace
+    },
+
+    async pnpPullOffNozzle(nozzlePlace) {
+      let emptyPlace = this.pnpGetEmptyNozzlePlace()
+      if (emptyPlace === true) { // Head without Nozzle
+        return true
+      }
+
+      if (emptyPlace == null) { // Not found the empty place!
+        return false
+      }
+
+      // Pull off the Nozzle
+      let commands = []
+      for (let i = emptyPlace.points.length-1; i >= 0; i--) {
+        let point = emptyPlace.points[i]
+        if (i == emptyPlace.points.length-1) {
+          //commands.push(...this.pnpGoToXYZAF_GCODE(point.x, point.y, point.z, NaN, 5500))
+          commands.push(...this.pnpSafetyGoToXYZ_GCODE(point.x, point.y, point.z))
+          
+          //await this.pnpSafetyGoToXYZ(point.x, point.y, point.z)
+        } else {
+          //await this.pnpGoToXYZF(point.x, point.y, point.z, nozzlePlace.feed)
+          commands.push(...this.pnpGoToXYZAF_GCODE(point.x, point.y, point.z, NaN, nozzlePlace.feed))
+        }
+      }
+      let safePosZ = parseFloat(this.settings.heads[0].safePosZ)
+      commands.push(...this.pnpGoToXYZAF_GCODE(NaN, NaN, safePosZ, NaN, 5500))
+
+      await this.sendCommandsPool(commands)
+
+      // Set current Nozzle to empty place
+      emptyPlace.nozzleId = this.settings.heads[0].nozzle
+      // Set head empty
+      this.settings.heads[0].nozzle = -1
+
+      return true
+    },
+
+    async pnpPutOnNozzle(nozzlePlace) {
+      if (nozzlePlace.nozzleId == -1) {
+        alert('Specified Nozzle place is empty!', 'Error', 'error')
+        return
+      }
+      if (nozzlePlace.points.length == 0) {
+        alert('Not specified the path to take!', 'Error', 'error')
+        return
+      }
+      
+      if (await this.pnpPullOffNozzle(nozzlePlace) == false) {
+          return
+      }
+
+      // Put on the Nozzle
+      console.log(nozzlePlace)
+      let commands = []
+      for (let i = 0; i < nozzlePlace.points.length; i++) {
+        let point = nozzlePlace.points[i]
+        console.log(point)
+        if (i == 0) {
+          //await this.pnpSafetyGoToXYZ(point.x, point.y, point.z)
+          commands.push(...this.pnpSafetyGoToXYZ_GCODE(point.x, point.y, point.z))
+        } else {
+          //await this.pnpGoToXYZF(point.x, point.y, point.z, nozzlePlace.feed)
+          commands.push(...this.pnpGoToXYZAF_GCODE(point.x, point.y, point.z, NaN, nozzlePlace.feed))
+        }
+      }
+      await this.sendCommandsPool(commands)
+
+      // Set The current Nozzle
+      this.settings.heads[0].nozzle = nozzlePlace.nozzleId
+
+      // Set The empty place
+      nozzlePlace.nozzleId = -1
+
+      await this.pnpSafetyUp(0)
+    },
+
+    //--------------------------------------------------------
+    async pnpJobStart(startElement = null) {
+      // Prepare elements list      
+      let elements = []
+
+      if (startElement !== null) {
+        elements = this.project.elements.slice(this.project.elements.indexOf(startElement), this.project.elements.length)
+      } else {
+        elements = this.project.elements
+      }
+
+      // Check required Nozzles in holder
+      for (let element of elements) {
+        if (element.active == true) {
+          if (element.nozzleId != this.settings.heads[0].nozzle) {
+            let nozzlePlace = this.getNozzlePlace(element.nozzleId)
+            if (nozzlePlace == null) {
+              let nozzle = this.getNozzle(element.nozzleId)
+              alert (`Can't start Job because the nozzles holder doesn't have the required nozzle '${nozzle.name}'`, 'Warning', 'warning')
+              return
+            }
+          }
+        }
+      }
+
+      // Checking current Nozzle and empty place
+      let nozzle = this.getNozzle(this.settings.heads[0].nozzle)
+      let emptyPlace = this.getNozzlePlace(-1)
+      await confirm(`Head is use the Nozzle '${nozzle.name}'. Empty place in the Nozzles Holder is '${emptyPlace.name}'. Is it correct? Shall we begin?`, 'Please check').then(async (res)=> {
+          if (res == true) {
+            // Start Job procesing
+            this.pnpJobProcessing(elements)
+          }
+      })
+    },
+    //--------------------------------------------------------
+
+    async pnpJobProcessing(elements) {
+      let pnpProcessing = this.pnpProcessing.runFlag
+      try {
+
+        this.pnpProcessing.runFlag = true
+        this.pnpProcessingRun()
+
+        await this.pnpPumpOn()
+
+        // Remember Current Nozzle
+        let RememberNozzleId = this.settings.heads[0].nozzle
+
+        for (let element of elements) {
+          if (this.pnpProcessing.stopFlag == false) {
+
+            if (element.active == true) {
+              this.pnpProcessing.element = element
+              this.pnpProcessing.message = `Element is being placed: ${element.name}`
+
+              // Check Nozzle
+              if (element.nozzleId != this.settings.heads[0].nozzle) {
+                let nozzlePlace = this.getNozzlePlace(element.nozzleId)
+                console.log('Change Nozzle')
+                console.log(nozzlePlace)
+                // Change Nozzle
+                await this.pnpPutOnNozzle(nozzlePlace)
+              }
+
+              if (await this.pnpPlaceElement(element) == false) {
+                await alert("Job is braked!", 'Warning', 'warning')
+                return false
+              }
+            }
+
+          }
+        }
+
+        // Restore Nozle
+        if (this.settings.heads[0].nozzle != RememberNozzleId) {
+          let nozzlePlace = this.getNozzlePlace(RememberNozzleId)
+          await this.pnpPutOnNozzle(nozzlePlace)
+        }
+
+        await this.pnpPumpOff()
+        await this.pnpGoToParking()
+
+        if (this.pnpProcessing.stopFlag == true) {
+          this.pnpProcessing.message = `The Job has been canceled on Element: ${this.pnpProcessing.element.name}`
+
+          await alert("The Job has been canceled!", 'Canceled', 'warning')
+          this.pnpProcessingReset()
+        } else {
+          this.pnpProcessing.message = 'Completed'
+          this.pnpProcessing.element = null
+          await alert("The project \"" +  this.project.name + "\" has been completed", 'Completed', 'success')
+          this.pnpProcessing.message = ''
+        }
+
+        //return true
+      } finally {
+        this.pnpProcessing.runFlag = pnpProcessing
+      }
+    }
+
+  }
+}

+ 66 - 0
pnpMachine/Vue/test.gcode

@@ -0,0 +1,66 @@
+;;;;;;;;;;;
+; Start init
+;;;;;;;;;;;
+$H
+G10 P0 L20 X0 Y0 Z0 ; Reset Zero
+
+G21 ; millimeters
+G90 ; absolute coordinate
+G17 ; XY plane
+G94 ; units per minute feed rate mode
+
+M3 ; Вимикаємо клапани
+M9 ; Вимикаємо клапани
+
+G0 Z 50.0 ; Піднімаємо голову
+
+G0 A 0 ; Повертаємо голову в нуль
+
+; Переміщуємость до підходу фідера
+G0 X -170 Y-170
+
+; Опускаємо голову до зацепу
+G0 Z 10
+
+; Заходимо у щеплення з фідером
+G0 X -170 Y -180 F500
+
+; Опускаємо голову для захвату
+G0 Z 2
+
+; Вмикаємо клапан
+M4
+; Пауза
+G04 P0.5
+
+; Піднімаємо голову
+G0 Z 12
+
+
+; Переміщуємость до підходу фідера (виходимо з зацеплення)
+G0 X-170 Y-170 F500
+
+; Піднімаємо голову
+G0 Z 50
+
+
+; Переміщуємость до місця встановлення
+G0 X -100 Y -100
+
+; Повертаємо голову якщо треба 0.25 - від повного оберта - тобто 90 градусів
+G0 A 0.25
+
+; Опускаємо голову для встановлення
+G0 Z 0 F2000
+
+; Вимикаємо клапан
+M3
+; Пауза
+G04 P0.5
+
+; Піднімаємо голову
+G0 Z 50
+
+; Повертаємо голову в нуль
+G0 A 0
+

BIN
pnpMachine/Vue/tmp/PickAndPlace_PCB_pnpBoard_2026-05-19.csv


この差分においてかなりの量のファイルが変更されているため、一部のファイルを表示していません