Mascaramento de Bits
SET // Por um RLO
R M100.0 // Ressete a M100.0
L MW32 // Ler os primeiros 16 bits
L MW34 // Ler os próximos 16 bits
OW // Faz uma OR da palavra com a qual o resultado em ACCU
L MW36 // Posicione os útimos 16 bits
OW // Faz uma OR entre o conteúdo de ACCU 1 e MW36 e transferi-lo de volta para ACCU1
L 0 // Posição zero no ACCU 1 e, portanto, o resultado do OR se move para ACU2
== I // comparação entre zero e o conteúdo de ACCU 1 ACCU 2
JC EXITE // Se zero (RLO é 1), saltar e não fazer nada
SET // Pondo RLO uma
S M100.0 // Pondo em um a M100.0
EXITE: NOP 0
Como fazemos isso?
A idéia é: criar um grupo de bits que queremos com os quais faremos uma AND com os sinais de modo que a resultante um alarme quando existir um alarme e será zero quando não houver ou não for o bit esperado.
Exemplo:
Imagine que você tem a M32.1 e M32.3 em 1 e ao resto do byte zero ok? Seria desta forma:
MB32 = 0 0 0 0 1 0 1 0
(Em 0.1 e 0.3 esta em um) é lido da direita para a esquerda.
Agora ao fazer uma AND com o byte seguinte temos:
MB32 = 0 0 0 0 1 0 1 0
Máscara = 1 1 1 1 1 1 0 1
Resutado = 0 0 0 0 1 0 0 0
L MB32 -> Carrega o primeiro byte que são os triger dos alarmes
L 2 # 1 1 1 1 1 1 0 1 -> Carga número binário que será o filtro (MÁSCARA)
SET
R M100.0 // Como antes de repor o sinal começou
L MB32 // Coloque o primeiro byte
G # 2 1 1 1 1 1 1 0 1 // Carregar os bits mascarados para o byte 32
UW // fazemos e
L MB33 // carregar o Byte 33
OW // Nós OR entre o resultado eo filtro 33 byte não
L MB34 // Coloque o byte 34
OW // Nós OR entre o resultado do OR e 34 byte nenhum filtro
T MW20 // Uma marca de meio caminho e que precisamos para armazenar o resultado
L MB33 // Coloque o byte 35
L 2 # 0 1 1 1 1 1 1 1 // Coloque a máscara a desprezar 35,7
UW // Nós o DNA para ficar com tudo, mas 35,7
L MW20 // carregar os resultados até agora
OW // Nós OR com o resultado
T MW20 // A transferência para a marca de metade novamente
L MB36 // carregar o Byte 36
L 2 # 1 1 1 1 1 0 0 0 // Coloque a máscara para 36,0, 36,1 e 36,2
UW // executar bits de mascaramento
L MW20 // Cobramos o que temos até agora
OW // OR
L 37 MB // Coloque o último byte
G # 1 2 1 1 1 0 1 1 1 //Carregar a máscara 37.3
UW // executar bits de mascaramento
L MW20 // carregar o temporário
OW // OR
T MW20 // Tornamos a última transferência de MW20
L MW20 // Coloque o temporal com o resultado
L0 // corregue zero
== I // Compara se Igual
SPB EXITE // Se o MW20 = 0, nós saltar para o fim, pois não há alarmes.
SET
S M100.0 // Se não é zero, nós colocamos o sinal de alarme 1. SAIR: NOP 0
Qual a vantagem desse método?
Dessa forma consigo especificar um filtro que designa quais serão os alarmes, falhas e avisos separadamente. E isto se torna seletivel através da mascara que estará a ser utilizada.
Tenha em atenção que este código é para exemplificar a utilização de um método, e deve ser tomado como modelo de aplicação apenas.
Rodrigo Menger Hoffmann
Técnico em Eletrotécnica
Recentemente tive a necessidade de fazer o seguinte: Eu tenho uma série de alarmes em uma máquina A, eu preciso definir oque será alarme, aviso e falha.
Se for poucos alarmes podemos resolver com algumas OR e ANDs, mas se forem muitas será um tanto extenso de fazer e podendo se tornar grande de mais. veja o código exemplo abaixo.
Queremos saber sua opinião sobre este artigo, clique na imagem ao lado e preencha o formulário que retornaremos o mais breve possivel.
Obrigado por sua visita