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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/grav-fw-pvi.js +123 -139
  2. package/package.json +1 -1
package/grav-fw-pvi.js CHANGED
@@ -5,182 +5,167 @@ class GravaFW {
5
5
  * @param {string} dirFirm formato esperado: "I:\\\Documentos\\\Softwares\\\STM8\\\STM8S003F3\\\INV-173\\\173v01\\\173v01_1.50_Com.stp"
6
6
  * @param {string} dirOpt formato esperado: "I:\\\Documentos\\\Softwares\\\STM8\\\STM8S003F3\\\INV-173\\\173v01\\\173v01_1.50_Com.stp"
7
7
  * @param {string} modelo_uC formato esperado: "STM8S003F3"
8
- * @param {function} callback
9
- * @param {number} timeOut
10
8
  */
11
- static STM8(dirFirm = null, dirOpt = null, modelo_uC = null, callback = () => { }, timeOut = 5000) {
12
-
13
- if (dirFirm != null && dirOpt != null) {
14
-
15
- let result = pvi.runInstructionS(`ST.writefirmwarestm8_stlink`, [
16
- dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
17
- dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
18
- modelo_uC
19
- ])
9
+ static async STM8(dirFirm = null, dirOpt = null, modelo_uC = null, timeOut = 5000) {
20
10
 
21
- let monitor = setInterval(() => {
11
+ return new Promise(async (resolve) => {
22
12
 
23
- if (result != null) {
13
+ let ObjWriteSTM8 = await defineWriteSTM8(dirFirm, dirOpt, modelo_uC)
24
14
 
25
- clearInterval(monitor)
26
- clearTimeout(timeoutMonitor)
15
+ let logGravacao = ""
27
16
 
28
- if (result.includes(`Verify OPTION BYTE succeeds`)) {
17
+ if (ObjWriteSTM8.sucess) {
29
18
 
30
- console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
31
- callback(true, result)
19
+ const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
32
20
 
33
- } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
21
+ console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
22
+ logGravacao = logGravacao + param[0]
34
23
 
35
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
36
- callback(null, `Gravador não respondeu`)
24
+ if (param[0] != undefined) {
37
25
 
38
- } else {
26
+ if (param[0].includes(`Verify OPTION BYTE succeeds`)) {
39
27
 
40
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
41
- callback(false, `Falha na gravação do firmware final`)
28
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
29
+ clearTimeout(timeOutGravacao)
42
30
 
43
- }
44
- }
45
- }, 100)
31
+ resolve({ sucess: true, msg: logGravacao })
46
32
 
47
- let timeoutMonitor = setTimeout(() => {
48
- clearInterval(monitor)
49
- callback(false, `Tempo de gravação excedido`)
50
- }, timeOut)
33
+ } else if (param[0].includes(`ERROR : Cannot communicate with the tool`)) {
51
34
 
52
- } else if (dirFirm != null) {
35
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
36
+ clearTimeout(timeOutGravacao)
53
37
 
54
- let result = pvi.runInstructionS(`ST.writeprogramstm8_stlink`, [
55
- dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
56
- modelo_uC
57
- ])
38
+ resolve({ sucess: null, msg: `Gravador não respondeu` })
58
39
 
59
- let monitor = setInterval(() => {
40
+ }
60
41
 
61
- clearInterval(monitor)
62
- clearTimeout(timeoutMonitor)
42
+ }
63
43
 
64
- if (result != null) {
44
+ }, "sniffer.exec")
65
45
 
66
- if (result.includes(`Verifying PROGRAM MEMORY succeeds`)) {
46
+ } else {
47
+ console.log(`%cNenhum diretório de firmware ou option byte informado`, ' color: #EE0033')
48
+ resolve({ sucess: false, msg: `Nenhum diretório de firmware ou option byte informado` })
49
+ }
67
50
 
68
- console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
69
- callback(true)
51
+ pvi.runInstructionS("EXEC", [`C:/Program Files (x86)/STMicroelectronics/st_toolset/stvp/STVP_CmdLine.exe`, ObjWriteSTM8.commandLineArguments, "true", "true"])
70
52
 
71
- } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
53
+ let timeOutGravacao = setTimeout(() => {
72
54
 
73
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
74
- callback(null, `Gravador não respondeu`)
55
+ console.log(`%cLog Program:\n\n${logGravacao}`, ' color: #EE0033')
56
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
75
57
 
76
- } else {
58
+ resolve({ sucess: false, msg: `Falha na gravação do firmware final` })
77
59
 
78
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
79
- callback(false, `Falha na gravação do firmware`)
60
+ }, timeOut)
80
61
 
81
- }
82
- }
83
- }, 100)
62
+ })
84
63
 
85
- let timeoutMonitor = setTimeout(() => {
86
- clearInterval(monitor)
87
- callback(false, `Tempo de gravação excedido`)
88
- }, timeOut)
89
64
 
90
- } else if (dirOpt != null) {
65
+ async function defineWriteSTM8(dirFirm, dirOpt, modelo_uC) {
91
66
 
92
- let result = pvi.runInstructionS(`ST.writeoptionstm8_stlink`, [
93
- dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`),
94
- modelo_uC
95
- ])
67
+ return new Promise((resolve) => {
96
68
 
97
- let monitor = setInterval(() => {
69
+ if (dirFirm != null && dirOpt != null) {
98
70
 
99
- clearInterval(monitor)
100
- clearTimeout(timeoutMonitor)
71
+ dirFirm = dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
72
+ dirOpt = dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
101
73
 
102
- if (result != null) {
74
+ resolve({
75
+ sucess: true,
76
+ 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}`,
77
+ })
103
78
 
104
- if (result.includes(`Verify OPTION BYTE succeeds`)) {
79
+ } else if (dirFirm != null) {
105
80
 
106
- console.log(`%cLog Desprotect:\n\n${result}`, ' color: #00EE66')
107
- callback(true, result)
81
+ dirFirm = dirFirm.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
108
82
 
109
- } else if (result.includes(`ERROR : Cannot communicate with the tool`)) {
83
+ resolve({
84
+ sucess: true,
85
+ commandLineArguments: `-BoardName=ST-LINK -Tool_ID=0 -NbTools=1 -Port=USB -ProgMode=SWIM -Device=${modelo_uC} -verbose -no_loop -no_warn_protect -FileProg=${dirFirm}`,
86
+ })
110
87
 
111
- console.log(`%cLog Desprotect:\n\n${result}`, ' color: #EE0033')
112
- callback(null, `Gravador não respondeu`)
88
+ } else if (dirOpt != null) {
113
89
 
114
- } else {
90
+ dirOpt = dirOpt.replace(/[\\]/g, `\/`).replace(/\.stp|\.STP/, `.HEX`)
115
91
 
116
- console.log(`%cLog Desprotect:\n\n${result}`, ' color: #EE0033')
117
- callback(false, `Falha na gravação do option byte`)
92
+ resolve({
93
+ sucess: true,
94
+ commandLineArguments: `-BoardName=ST-LINK -Tool_ID=0 -NbTools=1 -Port=USB -ProgMode=SWIM -Device=${modelo_uC} -verbose -no_loop -no_warn_protect -FileOption=${dirOpt}`,
95
+ })
118
96
 
119
- }
97
+ } else {
98
+ resolve({
99
+ sucess: false,
100
+ })
120
101
  }
121
- }, 100)
122
102
 
123
- let timeoutMonitor = setTimeout(() => {
124
- clearInterval(monitor)
125
- callback(false, `Tempo de gravação excedido`)
126
- }, timeOut)
103
+ })
127
104
 
128
- } else {
129
- callback(false, `Nenhum diretório de firmware ou option byte informado.`)
130
105
  }
131
106
  }
132
107
 
133
108
  /**
134
109
  * Realiza gravacao nos microcontroladores renesas atraves do PVI, via renesas flash programmer command line
135
110
  * @param {string} dirProject Formato esperado: "I:\\\Documentos\\\Softwares\\\RENESAS\\\R5F51303ADFL\\\INV-301\\\301v06\\\301v06.rpj"
136
- * @param {function} callback
137
111
  * @param {number} timeOut
138
112
  */
139
- static Renesas(dirProject = null, callback = () => { }, timeOut = 5000) {
113
+ static Renesas(dirProject = null, timeOut = 5000) {
114
+
115
+ return new Promise((resolve) => {
116
+
117
+ if (dirProject != null) {
140
118
 
141
- if (dirProject != null) {
119
+ let logGravacao = ""
142
120
 
143
- let result = pvi.runInstructionS(`RENESAS.gravafw`, [dirProject])
121
+ const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
144
122
 
145
- let monitor = setInterval(() => {
123
+ console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
124
+ logGravacao = logGravacao + param[0]
146
125
 
147
- if (result != null) {
126
+ if (param[0] != undefined) {
148
127
 
149
- clearInterval(monitor)
150
- clearTimeout(timeoutMonitor)
128
+ if (param[0].includes(`Operation completed.`)) {
151
129
 
152
- if (result.includes(`Operation completed.`)) {
130
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
131
+ clearTimeout(timeOutGravacao)
153
132
 
154
- console.log(`%cLog Program:\n\n${result}`, ' color: #00EE66')
155
- callback(true, result)
133
+ resolve({ sucess: true, msg: logGravacao })
156
134
 
157
- } else if (result.includes(`Cannot find the specified tool.`)) {
135
+ } else if (param[0].includes(`Cannot find the specified tool.`)) {
158
136
 
159
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
160
- callback(null, `Gravador não respondeu`)
137
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
138
+ clearTimeout(timeOutGravacao)
161
139
 
162
- } else if (result.includes(`Error: No project file specifed.`)) {
140
+ resolve({ sucess: null, msg: `Gravador não respondeu` })
163
141
 
164
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
165
- callback(false, `Projeto informado é inválido`)
142
+ } else if (param[0].includes(`Error: No project file specifed.`)) {
166
143
 
167
- } else {
144
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
145
+ clearTimeout(timeOutGravacao)
168
146
 
169
- console.log(`%cLog Program:\n\n${result}`, ' color: #EE0033')
170
- callback(false, `Falha na gravação do firmware final`)
147
+ resolve({ sucess: false, msg: `Projeto informado é inválido` })
148
+
149
+ }
171
150
 
172
151
  }
173
- }
174
- }, 100)
175
152
 
176
- let timeoutMonitor = setTimeout(() => {
177
- clearInterval(monitor)
178
- callback(false, `Tempo de gravação excedido`)
179
- }, timeOut)
153
+ }, "sniffer.exec")
180
154
 
181
- } else {
182
- callback(false, `Caminho do firmware não informado`)
183
- }
155
+ pvi.runInstructionS("EXEC", [`${pvi.runInstructionS("GETPVIPATH", [])}/Resources/Renesas/RFPV3.Console.exe`, dirProject, "true", "true"])
156
+
157
+ let timeOutGravacao = setTimeout(() => {
158
+
159
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
160
+ resolve({ sucess: false, msg: `Tempo de gravação excedido` })
161
+
162
+ }, timeOut)
163
+
164
+ } else {
165
+ resolve({ sucess: false, msg: `Caminho do firmware não informado` })
166
+ }
167
+
168
+ })
184
169
  }
185
170
 
186
171
  /**
@@ -188,45 +173,44 @@ class GravaFW {
188
173
  * @param {string} dirProject Formato esperado: "C:\\Users\\eduardo.rezzadori\\Desktop\\Farmwar\\193M3PL3v01_3.02.hex"
189
174
  * @param {string} commandFile Arquivo de comandos JLink, pseudo-script de gravação
190
175
  * @param {string} device modelo do micrcontrolador
191
- * @param {function} callback
192
176
  * @param {number} timeOut
193
177
  */
194
- static JLink_v7(dirProject = null, commandFile = null, device, callback = () => { }, timeOut = 10000) {
178
+ static JLink_v7(dirProject = null, commandFile = null, device, timeOut = 10000) {
179
+
180
+ let logGravacao = ""
195
181
 
196
- let error = null, observer = null, logGravacao = [], controleGravacao = null
197
- const pathPVI = pvi.runInstructionS("GETPVIPATH", [])
182
+ const id = PVI.FWLink.globalDaqMessagesObservers.add((msg, param) => {
183
+
184
+ console.log(`%cLog Program: ${param[0]}`, ' color: #B0E0E6')
185
+ logGravacao = logGravacao + param[0]
198
186
 
199
- observer = pvi.FWLink.globalDaqMessagesObservers.add((m, data) => {
200
- console.log(m, data)
201
- logGravacao.push(data)
202
187
  if (data == "Script processing completed.") {
203
- pvi.FWLink.globalDaqMessagesObservers.clear()
204
- pvi.daq.init()
205
- logGravacao.forEach((e) => {
206
- if (e == "O.K.") {
207
- observer = () => { }
208
- controleGravacao = true
209
- } else if (e == "Cannot connect to target.") {
210
- error = e
211
- }
212
- })
213
- if (controleGravacao) {
214
- clearTimeout(timeOutGravacao)
215
- callback(true, `Gravado com sucesso, caminho: ${dirProject}`)
216
- } else if (error) {
188
+
189
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
190
+
191
+ if (logGravacao.includes(`O.K.`)) {
192
+
217
193
  clearTimeout(timeOutGravacao)
218
- callback(false, `Falha na gravação, ${error}`)
219
- } else {
194
+ resolve({ sucess: true, msg: `Gravado com sucesso, caminho: ${dirProject}` })
195
+
196
+ } else if (logGravacao.includes(`Cannot connect to target.`)) {
197
+
220
198
  clearTimeout(timeOutGravacao)
221
- callback(false, `Falha na gravação, caminho: ${dirProject}`)
199
+ resolve({ sucess: false, msg: `Cannot connect to target.` })
200
+
222
201
  }
202
+
223
203
  }
224
204
  }, "sniffer.exec")
225
- pvi.runInstructionS("EXEC", [`${pathPVI}\\Plugins\\JLINK7\\JLink.exe`, `-device ${device} -CommandFile ${commandFile}`, "true", "true"])
205
+
206
+ pvi.runInstructionS("EXEC", [`${pvi.runInstructionS("GETPVIPATH", [])}\\Plugins\\JLINK7\\JLink.exe`, `-device ${device} -CommandFile ${commandFile}`, "true", "true"])
207
+
226
208
  let timeOutGravacao = setTimeout(() => {
227
- pvi.FWLink.globalDaqMessagesObservers.clear()
228
- pvi.daq.init()
229
- callback(false, `Falha na gravação, verifique a conexão USB do gravador`)
209
+
210
+ PVI.FWLink.globalDaqMessagesObservers.remove(id)
211
+ resolve({ sucess: false, msg: `Falha na gravação, verifique a conexão USB do gravador.` })
212
+
230
213
  }, timeOut)
214
+
231
215
  }
232
216
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@libs-scripts-mep/grav-fw-pvi",
3
- "version": "1.2.0",
3
+ "version": "2.0.0",
4
4
  "description": "Auxilia na gravação de microcontroladores por linha de comando através do PVI",
5
5
  "main": "grav-fw-pvi.js",
6
6
  "scripts": {