lib-niveis-2_4.mpam 19.2 KB
Newer Older
1
include('lib-blocos-2_2.mpam')
2
include('lib-utils-1_1.mpam')
3
include('lib-controle-2_0.mpam')
4
include('lib-valvula-2_0.mpam')
5
include('lib-list-1_10.mpam')
6
include('lib-math-1_2.mpam')
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543

class{ id = "controle_nao_linear_diagnostico", name = "Controle Não-Linear por Diagnóstico", group = "Controle Não-Linear de Níveis",
	bases = {},
	description = [[Classe para controle de níveis, verificando e diagnosticando perturbações.]],
	attributes = {
		{ id = "chave",
			name   = "Chave Controle",
			type   = "BOOLEAN_POINT",
			access = "r",
			description = [[O ponto que habilita ou desabilita o controle não-linear do controlador de nível.]],
		},
		{ id = "realizar_controle",
			name   = "Realizar Controle",
			type   = "BOOLEAN",
			access = "gs",
			description = [[Informa se o controlador de nível deve ter o procedimento de controle não-linear realizado.]],
		},
		{ id = "inibe_ajuste_modo",
			name   = "Inibe Ajuste de Modo",
			type   = "BOOLEAN",
			access = "g",
			description = [[Inibe, quando verdadeiro, a alteração de modo do controlador para aplicar uma nova sintonia.]],
		},
		{ id = "controlador_pid",
			name   = "Controlador PID",
			type   = "controlador",
			access = "g",
			description = [[O equipamento controlador de nível do PLC.]],
		},
		{ id = "algoritmo_pid",
			name   = "Algoritmo PID",
			type   = "pid",
			access = "g",
			description = [[O equipamento controlador de nível do MPA.]],
		},
		{ id = "banda",
			name   = "Banda",
			type   = "REAL_POINT",
			access = "r",
			description = [[O ponto que define a banda a ser utilizada no ajuste do controlador de nível.]],
		},
		{ id = "filtro_pv",
			name   = "Filtro de nível",
			type   = "bloco_filtro",
			access = "g",
			description = [[O filtro de primeira ordem que será aplicado ao nível.]],
		},
		{ id = "filtro_mv",
			name   = "Filtro de saída",
			type   = "bloco_filtro",
			access = "g",
			description = [[O filtro de primeira ordem que será aplicado à saída do controlador.]],
		},
		{ id = "tempo_morto",
			name   = "Tempo morto de nível",
			type   = "bloco_tempo_morto",
			access = "g",
			description = [[O tempo morto que será aplicado ao nível ao determinar sua variação.]],
		},
		{ id = "sp_ref",
			name   = "SP referência",
			type   = "REAL_POINT",
			access = "",
			description = [[O ponto que define o valor de referência para o set point do controlador de nível.]],
		},
		{ id = "kp_ref",
			name   = "KP referência",
			type   = "REAL_POINT",
			access = "",
			description = [[O ponto que define o valor de referência para ganho proporcional do controlador de nível.]],
		},
		{ id = "ki_ref",
			name   = "KI referência",
			type   = "REAL_POINT",
			access = "",
			description = [[O ponto que define o valor de referência para ganho integral do controlador de nível.]],
		},
		{ id = "var_sig_kp",
			name   = "Variação Significativa de KP",
			type   = "REAL",
			access = "g",
			description = [[Valor a partir do qual a variação de KP pode ser considerada significativa.]],
		},
		{ id = "var_sig_ki",
			name   = "Variação Significativa de KI",
			type   = "REAL",
			access = "g",
			description = [[Valor a partir do qual a variação de KI pode ser considerada significativa.]],
		},
		{ id = "var_sig_mv",
			name   = "Variação Significativa da MV",
			type   = "REAL",
			access = "g",
			description = [[Valor a partir do qual a variação de MV pode ser considerada significativa.]],
		},
		{ id = "mv_min",
			name   = "MV Mínima",
			type   = "REAL_POINT",
			access = "rw",
			description = [[O ponto que define o valor mínimo que pode ser aplicado à MV do controlador de nível.]],
		},
		{ id = "mv_max",
			name   = "MV Máxima",
			type   = "REAL_POINT",
			access = "rw",
			description = [[O ponto que define o valor máximo que pode ser aplicado à MV do controlador de nível.]],
		},
		{ id = "diagnostico_banda",
			name   = "Diagnóstico de Banda",
			type   = "janela_diagnostico",
			access = "g",
			description = [[.]],
		},
		{ id = "diagnostico_meia_banda",
			name   = "Diagnóstico de Meia Banda",
			type   = "janela_diagnostico",
			access = "g",
			description = [[.]],
		},
		{ id = "diagnostico_grande_perturbacao",
			name   = "Diagnóstico de Grande Perturbação",
			type   = "janela_diagnostico",
			access = "g",
			description = [[.]],
		},
		{ id = "superficie_kp",
			name   = "Superfície KP",
			type   = "superficie_interpolada",
			access = "g",
			description = [[Superfície que determina o valor de KP em função da banda e grau de perturbação.]],
		},
		{ id = "superficie_ki",
			name   = "Superfície KI",
			type   = "superficie_interpolada",
			access = "g",
			description = [[Superfície que determina o valor de KI em função da banda e grau de perturbação.]],
		},
		{ id = "ffw_perturbacao",
			name   = "Antecipação para Grande Perturbação",
			type   = "REAL",
			access = "g",
			description = [[Valor que deve ser usado na antecipação do PID em casos que uma grande perturbação é diagnosticada.]],
		},
		{ id = "intervalo_perturbacao",
			name   = "Intervalo para Grande Perturbação",
			type   = "REAL",
			access = "g",
			description = [[Tempo mínimo entre dois diagnósticos de grande perturbação.]],
		},
		{ id = "protecao_nivel_min",
			name   = "Proteção de Nível Mínimo",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor abaixo do qual deve ser aplicada uma antecipação na saída do controlador.]],
		},
		{ id = "ffw_protecao_nivel_baixo",
			name   = "Ant. Prot. de Nível Baixo",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor de antecipação que deve ser aplicado na saída do controlador quando for identificado
	um nível (PV) abaixo do mínimo.]],
		},
		{ id = "protecao_nivel_max",
			name   = "Proteção de Nível Máximo",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor acima do qual deve ser aplicada uma antecipação na saída do controlador.]],
		},
		{ id = "ffw_protecao_nivel_alto",
			name   = "Ant. Prot. de Nível Alto",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor de antecipação que deve ser aplicado na saída do controlador quando for identificado
	um nível (PV) acima do máximo.]],
		},
		{ id = "pert_inicial",
			name   = "Grau de Pert. Inicial",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor inicial que será considerado para o grau de perturbação.

  Se esse valor não for configurado, o método "Calcular Grau de Perturbação Atual" será usado para avaliar a perturbação que
  combinada à banda atual leva à sintonia calculada com a menor diferença quadrátida para a sintonia atual do controlador.]],
		},
		{ id = "pert_violacao_banda",
			name   = "Grau de Pert. Violação Banda",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor que será somado ao grau de perturbação quando for identificada uma violação banda.]],
		},
		{ id = "pert_contencao_mbanda",
			name   = "Grau de Pert. Contenção Meia Banda",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor que será subtraído do grau de perturbação quando for identificada uma contenção em meia-banda.]],
		},
		{ id = "pert_violacao_grande",
			name   = "Grau de Pert. Violação Grande Perturbação",
			type   = "REAL",
			access = "g",
			description = [[Indica o valor que será somado ao grau de perturbação quando for identificada uma grande perturbação.]],
		},
	},
	methods = {
		{ id = "informar_efetuar_controle",
			name        = "Informar Efetuar Controle",
			description =
[[Informa com base nos atributos configurados
e os valores lidos se o controle deve ser realizado.]],
			parameters = {
			},
			results = {
				{ name = "Efetuar Controle", type = "BOOLEAN" },
			},
			code = [==============================================================[
						 function(self)
							local chave = self.chave
							local do_ctrl = self.realizar_controle
							if type(do_ctrl) ~= "boolean" then
								do_ctrl = true
								if self.realizar_controle == "false" then
									do_ctrl = false
								end
							end
							return chave and chave:read() and do_ctrl
						 end
						 ]==============================================================],
		},
		{ id = "informar_mv_min",
			name        = "Informar MV Mínimo",
			description = [[Informa o valor mínimo para MV do controlador, se não houver um ponto definido para valor mínimo retorna nil.]],
			parameters = {
			},
			results = {
				{ name = "Valor Mínimo da MV", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							local mv_min = self.mv_min
							return mv_min and mv_min:read()
						 end
						 ]==============================================================],
		},
		{ id = "informar_mv_max",
			name        = "Informar MV Máximo",
			description = [[Informa o valor máximo para MV do controlador, se não houver um ponto definido para valor máximo retorna nil.]],
			parameters = {
			},
			results = {
				{ name = "Valor Máximo da MV", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							local mv_max = self.mv_max
							return mv_max and mv_max:read()
						 end
						 ]==============================================================],
		},
		{ id = "aplicar_sintonia_referencia",
			name        = "Aplicar Sintonia de Referência",
			description = [[Aplica os valores definidos para a sintonia de referência.

Se não houver um setpoint de referência definido a PV atual será usada para zerar o erro.

Esse método executa com o controlador PID em modo manual. O controlador será passado para automático se o parâmetro partir for verdadeiro.]],
			parameters = {
				{ name = "Partir", type = "BOOLEAN" },
			},
			results = {
			},
			code = [==============================================================[
						 function(self, run)
							local pid = self.controlador_pid
							local recover_auto = false

							local ki = self.ki_ref and self.ki_ref:read()
							local kp = self.kp_ref and self.kp_ref:read()
							local sp = (self.sp_ref or pid.pv):read()

							local recover_auto = run or false
							if not pid:informar_manual() then
								pid:definir_modo_manual(2, 3)
								recover_auto = true
							end

							if ki then pid.ki:write(ki) end
							if kp then pid.kp:write(kp) end

							pid.sp:write(sp)

							if recover_auto then
								pid:definir_modo_automatico(1, 0)
							end
						 end
						 ]==============================================================],
		},
		{ id = "salvar_sintonia_referencia",
			name        = "Salvar Sintonia de Referência",
			description = [[Salva a sintonia atual do controlador como sintonia de referência.]],
			parameters = {
			},
			results = {
			},
			code = [==============================================================[
						 function(self)
							local pid = self.controlador_pid
							local ki = pid.ki:read()
							local kp = pid.kp:read()
							self.ki_ref:write(ki)
							self.kp_ref:write(kp)
						 end
						 ]==============================================================],
		},
		{ id = "informar_maior_perturbacao_tratada",
			name        = "Informar Maior Perturbação Tratada",
			description = [[Informar, a partir das superfícies de KI e KP o maior valor configurado para perturbação.]],
			parameters = {
			},
			results = {
				{ name = "Maior Pertubação", type = "REAL" },
			},
			code = [==============================================================[
						 function(self, b, p)
							local sup_ki = self.superficie_ki
							local sup_kp = self.superficie_kp
							if sup_kp and sup_ki then
								return math.max(
									sup_ki:informar_maior_z(),
									sup_kp:informar_maior_z()
								)
							elseif not sup_ki and sup_kp then
								return sup_kp:informar_maior_z()
							elseif not sup_kp and sup_ki then
								return sup_ki:informar_maior_z()
							end
						 end
						 ]==============================================================],
		},
		{ id = "informar_menor_perturbacao_tratada",
			name        = "Informar Menor Perturbação Tratada",
			description = [[Informar, a partir das superfícies de KI e KP o menor valor configurado para perturbação.]],
			parameters = {
			},
			results = {
				{ name = "Menor Pertubação", type = "REAL" },
			},
			code = [==============================================================[
						 function(self, b, p)
							local sup_ki = self.superficie_ki
							local sup_kp = self.superficie_kp
							if sup_kp and sup_ki then
								return math.min(
									sup_ki:informar_menor_z(),
									sup_kp:informar_menor_z()
								)
							elseif not sup_ki and sup_kp then
								return sup_kp:informar_menor_z()
							elseif not sup_kp and sup_ki then
								return sup_ki:informar_menor_z()
							end
						 end
						 ]==============================================================],
		},
		{ id = "calcular_grau_perturbacao_atual",
			name = "Calcular Grau de Perturbação Atual",
			description = [[Calcula a perturbação em função da banda, kp e ki atuais.
	]],
			parameters = {
			},
			results = {
				{ name = "Perturbação", type = "REAL"},
			},
			code = [====[ function(self)
				local banda = self.banda:read()
				local kp = self.controlador_pid.kp:read()
				local ki = self.controlador_pid.ki:read()
				local dif_min
				local pert_dif_min
				for pert=0, 100, 5 do
					local kp_calc = self:calcular_kp(banda, pert) and self:informar_kp_calculado()
					local ki_calc = self:calcular_ki(banda, pert) and self:informar_ki_calculado()
					local dif = math.sqrt((kp_calc - kp)^2 + (ki_calc - ki)^2)
					if (dif_min==nil) or (dif < dif_min) then
						dif_min = dif
						pert_dif_min = pert
					end
				end
				return pert_dif_min
			end ]====],
		},
		{ id = "calcular_kp",
			name        = "Calcular KP",
			description = [[Realiza o cálculo do KP aplicando os valores da banda e grau de perturbação à respectiva superfície.]],
			parameters = {
				{ name = "Banda", type = "REAL" },
				{ name = "Perturbação", type = "REAL" },
			},
			results = {
				{ name = "KP calculado", type = "REAL" },
			},
			code = [==============================================================[
						 function(self, b, p)
							local superficie = assert(self.superficie_kp, "superfície não foi configurada para cálculo de kp")
							self.kp_calculado = superficie:informar_valor_superficie(p, b)

							return self.kp_calculado
						 end
						 ]==============================================================],
		},
		{ id = "informar_kp_calculado",
			name        = "Informar KP Calculado",
			description = [[Informa o último valor calculado para o ganho proporcional (KP).
Caso um valor não tenha sido calculado para KP o método retornará nil.
Esse método apaga o valor retornado, inviabilizando duas chamadas seguidas.]],
			parameters = {
			},
			results = {
				{ name = "Valor de KP Calculado", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							local val = self.kp_calculado
							self.kp_calculado = nil
							return val
						 end
						 ]==============================================================],
		},
		{ id = "calcular_ki",
			name        = "Calcular KI",
			description = [[Realiza o cálculo do KI aplicando os valores da banda e grau de perturbação à respectiva superfície.]],
			parameters = {
				{ name = "Banda", type = "REAL" },
				{ name = "Perturbação", type = "REAL" },
			},
			results = {
				{ name = "KI calculado", type = "REAL" },
			},
			code = [==============================================================[
						 function(self, b, p)
							local superficie = assert(self.superficie_ki, "superfície não foi configurada para cálculo de ki")
							self.ki_calculado = superficie:informar_valor_superficie(p, b)
							return self.ki_calculado
						 end
						 ]==============================================================],
		},
		{ id = "informar_ki_calculado",
			name        = "Informar KI Calculado",
			description = [[Informa o último valor calculado para o ganho integral (KI).
Caso um valor não tenha sido calculado para KP o método retornará nil.
Esse método apaga o valor retornado, inviabilizando duas chamadas seguidas.]],
			parameters = {
			},
			results = {
				{ name = "Valor de KI Calculado", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							local val = self.ki_calculado
							self.ki_calculado = nil
							return val
						 end
						 ]==============================================================],
		},
		{ id = "ajustar_ffw_acumulado",
			name        = "Ajustar Antecipação Acumulada",
			description = [[Ajusta a antecipação acumulada.]],
			parameters = {
				{ name = "Antecipação", type = "REAL" },
			},
			results = {
			},
			code = [==============================================================[
						 function(self, v)
							self.ffw_acumulado = v
						 end
						 ]==============================================================],
		},
		{ id = "informar_ffw_acumulado",
			name        = "Informar Antecipação Acumulada",
			description = [[Informa a antecipação acumulada.]],
			parameters = {
			},
			results = {
				{ name = "Antecipação Acumulada", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							return self.ffw_acumulado or 0
						 end
						 ]==============================================================],
		},
		{ id = "somar_ffw_acumulado",
			name        = "Somar Antecipação Acumulada",
			description = [[Ajusta a Antecipação acumulada.]],
			parameters = {
				{ name = "Antecipação", type = "REAL" },
			},
			results = {
			},
			code = [==============================================================[
						 function(self, v)
							self:ajustar_ffw_acumulado(v + self:informar_ffw_acumulado())
						 end
						 ]==============================================================],
		},
		{ id = "informar_mv_anterior",
			name        = "Informar MV Anterior",
			description = [[Informa o valor da MV armazenado no passo anterior.
Caso não haja nenhuma mv_anterior definida o método retorna o valor atual da MV do Controlador PID definido.]],
			parameters = {
			},
			results = {
				{ name = "Valor de MV", type = "REAL" },
			},
			code = [==============================================================[
						 function(self)
							return self.mv_anterior or
								self.controlador_pid.mv:read()
						 end
						 ]==============================================================],
		},
		{ id = "ajustar_mv_anterior",
			name        = "Ajustar MV Anterior",
			description = [[Ajusta o valor da MV que será informado no próximo passo.]],
			parameters = {
				{ name = "Valor de MV", type = "REAL" },
			},
			results = {
			},
			code = [==============================================================[
						 function(self, v)
							self.mv_anterior = v
						 end
						 ]==============================================================],
		},
	},
}