@libs-scripts-mep/grav-fw-pvi 1.1.0 → 2.0.0

package/README.md

@@ -24,6 +24,7 @@ npm uninstall @libs-scripts-mep/grav-fw-pvi
 | ---------- | ------------------------ | ------- |
 | ST         | STVP                     | ✔️       |
 | Renesas    | Renesas Flash Programmer | ✔️       |
+| Nuvoton    | JLink v7.82              | ✔️       |
 
 ## Resumo da Classe
 
@@ -82,5 +83,66 @@ static Renesas(params, callback, timeOut = 5000) {
         callback(false, `Falha na gravação do firmware final`)
     }    
 }
+
+/**
+ * Realiza gravacao nos microcontroladores Nuvoton atraves do PVI, via Jlink v7 command line
+ * @param {string} dirProject Formato esperado: "C:\\Users\\eduardo.rezzadori\\Desktop\\Farmwar\\193M3PL3v01_3.02.hex"
+ * @param {string} commandFile Arquivo de comandos JLink, pseudo-script de gravação
+ * @param {string} device modelo do micrcontrolador
+ * @param {function} callback 
+ * @param {number} timeOut 
+ */
+static JLink_v7(dirProject = null, commandFile = null, device, callback = () => { }, timeOut = 10000) {
+    // inicia as variaveis locais utilizadas
+    let error = null, observer = null, logGravacao = [], controleGravacao = null
+    const pathPVI = pvi.runInstructionS("GETPVIPATH", [])
+
+    // start do obsever para o retorno do cmd
+    observer = pvi.FWLink.globalDaqMessagesObservers.add((m, data) => {
+        console.log(m, data)
+
+        // monta um array para validar a gravação
+        logGravacao.push(data)
+
+        // aguarda a string final do processo de gravação
+        if (data == "Script processing completed.") {
+            pvi.FWLink.globalDaqMessagesObservers.clear()
+            pvi.daq.init()
+            logGravacao.forEach((e) => {
+
+                // mensagem que valida a gravação
+                if (e == "O.K.") {
+                    observer = () => { }
+                    controleGravacao = true
+                // erro conhecido    
+                } else if (e == "Cannot connect to target.") {
+                    error = e
+                }
+            })
+
+            // retorno convencional do script
+            if (controleGravacao) {
+                clearTimeout(timeOutGravacao)
+                callback(true, `Gravado com sucesso, caminho: ${dirProject}`)
+            } else if (error) {
+                clearTimeout(timeOutGravacao)
+                callback(false, `Falha na gravação, ${error}`)
+            } else {
+                clearTimeout(timeOutGravacao)
+                callback(false, `Falha na gravação, caminho: ${dirProject}`)
+            }
+        }
+    }, "sniffer.exec")
+
+    // execução do comando de gravação
+    pvi.runInstructionS("EXEC", [`${pathPVI}\\Plugins\\JLINK7\\JLink.exe`, `-device ${device} -CommandFile ${commandFile}`, "true", "true"])
+
+    // timeout para setar erro caso ocorra algum tipo de erro inesperado
+    let timeOutGravacao = setTimeout(() => {
+        pvi.FWLink.globalDaqMessagesObservers.clear()
+        pvi.daq.init()
+        callback(false, `Falha na gravação, verifique a conexão USB do gravador`)
+    }, timeOut)
+}
 ```
 

package/grav-fw-pvi.js

@@ -5,181 +5,212 @@ class GravaFW {
      * @param {string} dirFirm formato esperado: "I:\\\Documentos\\\Softwares\\\STM8\\\STM8S003F3\\\INV-173\\\173v01\\\173v01_1.50_Com.stp"
      * @param {string} dirOpt formato esperado: "I:\\\Documentos\\\Softwares\\\STM8\\\STM8S003F3\\\INV-173\\\173v01\\\173v01_1.50_Com.stp"
      * @param {string} modelo_uC formato esperado: "STM8S003F3"
-     * @param {function} callback 
-     * @param {number} timeOut 
      */
-    static STM8(dirFirm = null, dirOpt = null, modelo_uC = null, callback = () => { }, timeOut = 5000) {
-
-        if (dirFirm != null && dirOpt != null) {
-
-            let result = pvi.runInstructionS(`ST.writefirmwarestm8_stlink`, [
-                dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
-                dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
-                modelo_uC
-            ])
+    static async STM8(dirFirm = null, dirOpt = null, modelo_uC = null, timeOut = 5000) {
 
-            let monitor = setInterval(() => {
+        return new Promise(async (resolve) => {
 
-                if (result != null) {
+            let ObjWriteSTM8 = await defineWriteSTM8(dirFirm, dirOpt, modelo_uC)
 
-                    clearInterval(monitor)
-                    clearTimeout(timeoutMonitor)
+            let logGravacao = ""
 
-                    if (result.includes(`Verify OPTION BYTE succeeds`)) {
+            if (ObjWriteSTM8.sucess) {
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
-                        callback(true, result)
+                const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
 
-                    } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
+                    console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
+                    logGravacao = logGravacao + param[0]
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(null, `Gravador não respondeu`)
+                    if (param[0] != undefined) {
 
-                    } else {
+                        if (param[0].includes(`Verify OPTION BYTE succeeds`)) {
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(false, `Falha na gravação do firmware final`)
+                            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                            clearTimeout(timeOutGravacao)
 
-                    }
-                }
-            }, 100)
+                            resolve({ sucess: true, msg: logGravacao })
 
-            let timeoutMonitor = setTimeout(() => {
-                clearInterval(monitor)
-                callback(false, `Tempo de gravação excedido`)
-            }, timeOut)
+                        } else if (param[0].includes(`ERROR : Cannot communicate with the tool`)) {
 
-        } else if (dirFirm != null) {
+                            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                            clearTimeout(timeOutGravacao)
 
-            let result = pvi.runInstructionS(`ST.writeprogramstm8_stlink`, [
-                dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
-                modelo_uC
-            ])
+                            resolve({ sucess: null, msg: `Gravador não respondeu` })
 
-            let monitor = setInterval(() => {
+                        }
 
-                clearInterval(monitor)
-                clearTimeout(timeoutMonitor)
+                    }
 
-                if (result != null) {
+                }, "sniffer.exec")
 
-                    if (result.includes(`Verifying PROGRAM MEMORY succeeds`)) {
+            } else {
+                console.log(`%cNenhum diretório de firmware ou option byte informado`, ' color: #EE0033')
+                resolve({ sucess: false, msg: `Nenhum diretório de firmware ou option byte informado` })
+            }
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
-                        callback(true)
+            pvi.runInstructionS("EXEC", [`C:/Program Files (x86)/STMicroelectronics/st_toolset/stvp/STVP_CmdLine.exe`, ObjWriteSTM8.commandLineArguments, "true", "true"])
 
-                    } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
+            let timeOutGravacao = setTimeout(() => {
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(null, `Gravador não respondeu`)
+                console.log(`%cLog Program:\n\n${logGravacao}`, ' color: #EE0033')
+                PVI.FWLink.globalDaqMessagesObservers.remove(id)
 
-                    } else {
+                resolve({ sucess: false, msg: `Falha na gravação do firmware final` })
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(false, `Falha na gravação do firmware`)
+            }, timeOut)
 
-                    }
-                }
-            }, 100)
+        })
 
-            let timeoutMonitor = setTimeout(() => {
-                clearInterval(monitor)
-                callback(false, `Tempo de gravação excedido`)
-            }, timeOut)
 
-        } else if (dirOpt != null) {
+        async function defineWriteSTM8(dirFirm, dirOpt, modelo_uC) {
 
-            let result = pvi.runInstructionS(`ST.writeoptionstm8_stlink`, [
-                dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
-                modelo_uC
-            ])
+            return new Promise((resolve) => {
 
-            let monitor = setInterval(() => {
+                if (dirFirm != null && dirOpt != null) {
 
-                clearInterval(monitor)
-                clearTimeout(timeoutMonitor)
+                    dirFirm = dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
+                    dirOpt = dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
 
-                if (result != null) {
+                    resolve({
+                        sucess: true,
+                        commandLineArguments: `-BoardName=ST-LINK -Tool_ID=0 -NbTools=1 -Port=USB -ProgMode=SWIM -Device=${modelo_uC} -verbose -no_loop -no_warn_protect -FileProg=${dirFirm} -FileOption=${dirOpt}`,
+                    })
 
-                    if (result.includes(`Verify OPTION BYTE succeeds`)) {
+                } else if (dirFirm != null) {
 
-                        console.log(`%cLog Desprotect:\n\n${result}`, ' color: #00EE66')
-                        callback(true, result)
+                    dirFirm = dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
 
-                    } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
+                    resolve({
+                        sucess: true,
+                        commandLineArguments: `-BoardName=ST-LINK -Tool_ID=0 -NbTools=1 -Port=USB -ProgMode=SWIM -Device=${modelo_uC} -verbose -no_loop -no_warn_protect -FileProg=${dirFirm}`,
+                    })
 
-                        console.log(`%cLog Desprotect:\n\n${result}`, ' color: #EE0033')
-                        callback(null, `Gravador não respondeu`)
+                } else if (dirOpt != null) {
 
-                    } else {
+                    dirOpt = dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
 
-                        console.log(`%cLog Desprotect:\n\n${result}`, ' color: #EE0033')
-                        callback(false, `Falha na gravação do option byte`)
+                    resolve({
+                        sucess: true,
+                        commandLineArguments: `-BoardName=ST-LINK -Tool_ID=0 -NbTools=1 -Port=USB -ProgMode=SWIM -Device=${modelo_uC} -verbose -no_loop -no_warn_protect -FileOption=${dirOpt}`,
+                    })
 
-                    }
+                } else {
+                    resolve({
+                        sucess: false,
+                    })
                 }
-            }, 100)
 
-            let timeoutMonitor = setTimeout(() => {
-                clearInterval(monitor)
-                callback(false, `Tempo de gravação excedido`)
-            }, timeOut)
+            })
 
-        } else {
-            callback(false, `Nenhum diretório de firmware ou option byte informado.`)
         }
     }
 
     /**
      * Realiza gravacao nos microcontroladores renesas atraves do PVI, via renesas flash programmer command line
      * @param {string} dirProject Formato esperado: "I:\\\Documentos\\\Softwares\\\RENESAS\\\R5F51303ADFL\\\INV-301\\\301v06\\\301v06.rpj"
-     * @param {function} callback 
      * @param {number} timeOut 
      */
-    static Renesas(dirProject = null, callback = () => { }, timeOut = 5000) {
+    static Renesas(dirProject = null, timeOut = 5000) {
+
+        return new Promise((resolve) => {
 
-        if (dirProject != null) {
+            if (dirProject != null) {
 
-            let result = pvi.runInstructionS(`RENESAS.gravafw`, [dirProject])
+                let logGravacao = ""
 
-            let monitor = setInterval(() => {
+                const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
 
-                if (result != null) {
+                    console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
+                    logGravacao = logGravacao + param[0]
 
-                    clearInterval(monitor)
-                    clearTimeout(timeoutMonitor)
+                    if (param[0] != undefined) {
 
-                    if (result.includes(`Operation completed.`)) {
+                        if (param[0].includes(`Operation completed.`)) {
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
-                        callback(true, result)
+                            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                            clearTimeout(timeOutGravacao)
 
-                    } else if (result.includes(`Cannot find the specified tool.`)) {
+                            resolve({ sucess: true, msg: logGravacao })
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(null, `Gravador não respondeu`)
+                        } else if (param[0].includes(`Cannot find the specified tool.`)) {
 
-                    } else if (result.includes(`Error: No project file specifed.`)) {
+                            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                            clearTimeout(timeOutGravacao)
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(false, `Projeto informado é inválido`)
+                            resolve({ sucess: null, msg: `Gravador não respondeu` })
 
-                    } else {
+                        } else if (param[0].includes(`Error: No project file specifed.`)) {
 
-                        console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
-                        callback(false, `Falha na gravação do firmware final`)
+                            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                            clearTimeout(timeOutGravacao)
+
+                            resolve({ sucess: false, msg: `Projeto informado é inválido` })
+
+                        }
 
                     }
+
+                }, "sniffer.exec")
+
+                pvi.runInstructionS("EXEC", [`${pvi.runInstructionS("GETPVIPATH", [])}/Resources/Renesas/RFPV3.Console.exe`, dirProject, "true", "true"])
+
+                let timeOutGravacao = setTimeout(() => {
+
+                    PVI.FWLink.globalDaqMessagesObservers.remove(id)
+                    resolve({ sucess: false, msg: `Tempo de gravação excedido` })
+
+                }, timeOut)
+
+            } else {
+                resolve({ sucess: false, msg: `Caminho do firmware não informado` })
+            }
+
+        })
+    }
+
+    /**
+     * Realiza gravacao nos microcontroladores Nuvoton atraves do PVI, via JLink command line
+     * @param {string} dirProject Formato esperado: "C:\\Users\\eduardo.rezzadori\\Desktop\\Farmwar\\193M3PL3v01_3.02.hex"
+     * @param {string} commandFile Arquivo de comandos JLink, pseudo-script de gravação
+     * @param {string} device modelo do micrcontrolador
+     * @param {number} timeOut 
+     */
+    static JLink_v7(dirProject = null, commandFile = null, device, timeOut = 10000) {
+
+        let logGravacao = ""
+
+        const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
+
+            console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
+            logGravacao = logGravacao + param[0]
+
+            if (data == "Script processing completed.") {
+
+                PVI.FWLink.globalDaqMessagesObservers.remove(id)
+
+                if (logGravacao.includes(`O.K.`)) {
+
+                    clearTimeout(timeOutGravacao)
+                    resolve({ sucess: true, msg: `Gravado com sucesso, caminho: ${dirProject}` })
+
+                } else if (logGravacao.includes(`Cannot connect to target.`)) {
+
+                    clearTimeout(timeOutGravacao)
+                    resolve({ sucess: false, msg: `Cannot connect to target.` })
+
                 }
-            }, 100)
 
-            let timeoutMonitor = setTimeout(() => {
-                clearInterval(monitor)
-                callback(false, `Tempo de gravação excedido`)
-            }, timeOut)
+            }
+        }, "sniffer.exec")
+
+        pvi.runInstructionS("EXEC", [`${pvi.runInstructionS("GETPVIPATH", [])}\\Plugins\\JLINK7\\JLink.exe`, `-device ${device} -CommandFile ${commandFile}`, "true", "true"])
+
+        let timeOutGravacao = setTimeout(() => {
+
+            PVI.FWLink.globalDaqMessagesObservers.remove(id)
+            resolve({ sucess: false, msg: `Falha na gravação, verifique a conexão USB do gravador.` })
+
+        }, timeOut)
 
-        } else {
-            callback(false, `Caminho do firmware não informado`)
-        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libs-scripts-mep/grav-fw-pvi",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Auxilia na gravação de microcontroladores por linha de comando através do PVI",
   "main": "grav-fw-pvi.js",
   "scripts": {