250 REV 00 VBA para RSView32 Manual Do Aluno

Índice
ÍNDICE
Objetivo do curso............................................................................................................3
A quem se destina o curso:.......................................................................................................3
Descrição do curso....................................................................................................................3
Introdução do VBA ao RSView32...................................................................................4
O que é Visual Basic for Application (VBA)...........................................................................4
Introdução.................................................................................................................................7
Visão geral do VBA.......................................................................................................10
Programação Orientada ao Objeto:.........................................................................................10
Fundamentos da Linguagem VBA.........................................................................................12
Laboratório – VBA, criando um procedimento no Microsoft Excel......................................19
Laboratório Adicional.............................................................................................................22
Projeto do RSView32 com VBA....................................................................................23
Antes de começar:...................................................................................................................23
Modelo do diagrama de Objeto..............................................................................................24
Modelo do diagrama de Objeto do RSView contem os seguintes objetos.............................29
Como o RSView32 utiliza o VBA..........................................................................................35
Lab – Um procedi-mento VBA que trabalha com um registro ativo (Activity Log) e executa
comandos do RSView32.........................................................................................................37
Lab - Adicional#1...................................................................................................................41
Lab - Adicional#2...................................................................................................................41
Lab – Criando um Procedimento que trabalha com as Tags em RSView32..........................42
Lab – Usando uma função InputBox......................................................................................44
Lab – Adicional#3..................................................................................................................46
Lab – Usando o Método BrowseForTags...............................................................................47
Lab – Adicional#4..................................................................................................................48
Lab – Usando VBA para escrever para na base de dados do RSView32...............................49
Lab – Usando Formulários no VBA.......................................................................................51
Lab – Adicional#5..................................................................................................................54
1
Índice
Usando Eventos............................................................................................................56
Eventos de Objeto do RSView32:..........................................................................................56
Lab – Usando objetos de eventos no RSView32....................................................................60
Lab – Adicional#6..................................................................................................................63
Ferramentas de depuração e manipulação de erros...................................................64
Depurador de código VBA.....................................................................................................64
Lab – Ferramentas de depuração para VBA em RSView32..................................................69
Manipulação de erro em código de VBA...............................................................................72
Lab – Manipulando erros no VBA para RSView32...............................................................76
Coleção de Objetos do RSView32...............................................................................79
Coleções:.................................................................................................................................79
Otimizando a escrita de tags...................................................................................................82
Lendo tags Eficazmente..........................................................................................................85
Lab – Usando coleções e otimizando escrita/leitura de Tag...................................................88
Acessando modelos de objetos para controle externo ao RSView32.........................90
Introdução:..............................................................................................................................90
Lab – Acessando o modelo de objeto do RSView32 a partir do VBA do Excel...................92
2
Objetivo do curso Capítulo 1
Objetivo do curso
A quem se destina o Este curso é destinado a pessoas que precisam criar ou

curso: modificar aplicações desenvolvidas no RSView32 utilizando a
ferramenta VBA.
Descrição do curso Este curso apresenta laboratórios práticos que possibilitam criar
uma aplicação, através do Software RSView32 com VBA. O
instrutor demonstrará todos os procedimentos relevantes,
incluindo uma seção de prática integrada que habilita o usuário
a utilizar uma aplicação desenvolvida por ele mesmo.
3
Visão geral do VBA Capítulo 3
Introdução do VBA ao RSView32
O que é Visual Basic Visual Basic para Aplicações faz parte da família de tecnologia
for Application (VBA) do Visual Basic. Seu nome completo é sistema de programação
do Microsoft® Visual Basic©, Edição de Aplicações (VBA).
Em um aplicativo, o VBA fornece todos os recursos possíveis

que existem no Visual Basic exceto a capacidade de compilar
códigos e criar arquivos extensão EXEs, DLLs & objetos do
ActiveX (OCXs).
Porém, o VBA não existe sozinho. Ele deve estar incorporado e
sendo executado dentro de uma outra aplicação, como por
exemplo, no RSView32, ou em um produto do pacote Microsoft
Office97 ou em um software de terceiros que possibilite o uso
do VBA naquele produto.
O Visual Basic para Aplicações possibilita aos desenvolvedores
construir soluções customizadas além das já fornecidas pelo
aplicativo, no nosso caso o RSView-32, O VBA pode
automatizar e estender as funcionalidades, integrando assim
todos os recursos permitidos em uma aplicação (disponível para
o desenvolvedor na forma de um conjunto de objetos),
diminuindo o tempo de desenvolvimento para automatização e
customização de acordo com as soluções e regras de negócio.
4
O Visual Basic para Aplicações inclui um compilador de
linguagem, em um editor extremamente poderoso, além de
possuir um navegador de objetos, e ferramentas de depuração. O
RSView32, assim como o Microsoft Office 97, fornece aos
desenvolvedores a capacidade de construir aplicações
complexas, com mais flexibilidade possibilitando soluções
customizadas estendendo assim as características do aplicativo
através do Visual Basic para Aplicações e melhorando o
ambiente de desenvolvimento.
As soluções criadas com Visual Basic para Aplicações são
executadas mais rápido desde que o código seja executado no
mesmo espaço de memória, juntamente com a aplicação em que
ele está incorporado tornando direta a integração com a
aplicação. Este permite que os desenvolvedores escrevam um
código o qual irá responder de acordo com as ações do usuário,
possibilitando que um usuário abra, feche, salve ou modifique
um documento, projetos ou manipule os objetos do RSView32.
Finalmente, as distribuições de soluções customizadas em um
RSView32 são BASEADAS EM VBA tornando-se
simplificadas desde que o código esteja incorporado na
aplicação ou no projeto.
O produto RSView32 com VBA fornece um ambiente de
desenvolvimento completo pelo fato de permitir customizações
estendendo assim as funcionalidades do produto. O Microsoft
VBA além de poderoso possui toda a tecnologia da família
Microsoft, possibilitando que você aprenda uma linguagem de
desenvolvimento, habilitando-o a trabalhar com múltiplas
aplicações.
Agora com a integração do VBA, o RSView32 fornece um nível
de interoperabilidade indisponível na maioria dos outros
Softwares de IHM.
5
O Visual Basic para Aplicações fornece um ambiente de
desenvolvimento integrado (IDE) isso inclui elementos
disponíveis em um Visual Basic 6.0, incluindo uma Janela de
Projeto, Páginas de Propriedade, depuração completa,
navegação nos objetos e no software.
6
Introdução A Rockwell Software está orgulhosa em anunciar que o
RSView32 como a primeira interface homem-máquina (IHM),
disponível entre os pacotes de softwares da companhia, que está
preparado e homologado para utilizar o Microsoft Visual Basic
para aplicações (VBA), como extensão e customização de
soluções através de programação códigos no produto.
O RSView32 com VBA foi o primeiro produto a ser lançado

com esta tecnologia em agosto de 97. O Microsoft VBA fornece
para os usuários um meio de customizar aplicações no
RSView32, simultaneamente elevar o nível de conhecimento e
necessidade de treinamento em produtos Microsoft Office97 com
VBA.
Embora o VBA seja uma ferramenta poderosa, seu uso em
projetos no RSView32 é opcional, os desenvolvedores de IHM
podem utilizar ou não o VBA.
O RSView32 com VBA é uma extensão do produto que

possibilita manipular todos os modelos de objetos do VBA,
permitindo customizações de aplicações e interoperabilidade nos
desenvolvimentos integrando produtos do pacote Microsoft
Office, outros produtos de software da Rockwell e de terceiros
através de manipulações de modelos de objetos e componentes
disponíveis dentro do RSView32.
Diferentemente de alguns pacotes de IHM que usam código
proprietário através de linguagens próprias (também conhecidos
7
como "scripting", entretanto e preferível que não se use esse
termo para se referenciar ao VBA), o RSView32 além de
permitir a utilização de scripts próprios, possibilita também a
utilização de códigos de programação VBA.
O RSView32 com VBA aproveita todas as funcionalidades do
Microsoft VBA convencional. O VBA do RSView32 tem a
mesma linguagem de programação e desenvolvimento de macros
que pode ser construído em produtos de software do pacote
Microsoft Office97.
O VBA permite ao usuário elevar seu nível de conhecimento
através de treinamentos das aplicações a serem utilizados no
escritório ou em casa. Este por sua vez, reduz o tempo de
aprendizado para adquirir conhecimento para configurar e
customizar aplicações com VBA no RSView32.
Com o VBA, o produto RSView32 pode interagir diretamente
com todos os produtos oficiais da linha Microsoft, como o
Microsoft BackOffice e também com outras aplicações de
Software da Rockwell. O usuário pode incorporar planilhas
eletrônicas do Microsoft Excel, documentos do Word, e
controles ActiveX nas telas gráficas do RSView32 sem ter que
importar ou exportar arquivos ou navegar em telas especifica.
Mais de 100 dos principais fabricantes de software tinham sido
licenciados pela Microsoft para usar o ambiente de
desenvolvimento do VBA em seus produtos. Estes fabricantes
são expertises em produzir mais de 200 produtos diferentes com
VBA, em mais de 23 diferentes setores industriais. Isto fornece
ao desenvolvedor do RSView32 uma habilidade de criar
facilmente soluções por interface com outros produtos
compatíveis com VBA.
Estas soluções são criadas com maior rapidez e seu uso mais
fácil porque os desenvolvedores e os usuários podem reutilizar as
8
características da aplicação existente em um ambiente de
desenvolvedor, através de aplicações.
 Para aprender mais sobre o Visual Basic da Microsoft
para Aplicações, veja o seguinte website:
http://msdn.microsoft.com/vba/
 Para aprender mais sobre as tecnologias mais recentes no
RSView32, veja o conteúdo de IHM no website da
Rockwell Software no:
http://www.software.rockwell.com
9
Visão geral do VBA
Programação Quando você criar uma aplicação no Visual Basic, você irá
Orientada ao Objeto: trabalhar com objetos. Você pode usar os objetos fornecidos pela
Visual Basic para Aplicações, e ainda poderá controlar outros
objetos da aplicação de dentro da sua aplicação no VBA. Um
objeto é uma combinação de código e dados que podem ser
tratados como uma unidade. Um objeto pode ser um pedaço de
uma aplicação, como um controle ou um formulário. Uma
aplicação inteira pode ser também considerada um objeto no
VBA.
Os objetos do Visual Basic fornecem Propriedades, métodos, e
eventos. As informações de um objeto (configurações ou
atributos) são chamadas a suas propriedades. Os procedimentos
(procedures) que podem atuar em um objeto são chamados de
métodos ("incorporado" na procedure que contem o objeto). Um
evento é uma ação reconhecida por um objeto, como um click no
mouse ou o pressionamento de uma tecla, você poderá escrever
códigos para responder a estes eventos.
Por exemplo, vamos considerar o seguinte, um formulário no
VBA :
Este formulário tem uma propriedade de cor de fundo

(BackColor) que controla a cor do formulário. Esta propriedade
10
poderia ter seu valor fixo em tempo de projeto e mudado em
tempo de execução através de um código de VBA. A propriedade
poderia ser alterada através de um código utilizando a sintaxe
FormName.Backcolor.
Este formulário pode ter ainda dois métodos um chamado Show
e o outro Hide. Estes métodos poderiam ser chamados através de
um código VBA, para que pudéssemos aplicar neste Formulário
os métodos para que este seja exibido ou escondido.
Este formulário teria vários eventos que puderam ser usados para
executar códigos durante a sua execução através de ações. Por
exemplo, o evento de um clique de um mouse sempre seria
executado quando o usuário clicasse no formulário com o mouse.
11
Fundamentos da Procedimentos ou Sub-rotinas - Os procedimentos ou sub-rotinas
Linguagem VBA nada mais são do que uma determinada seqüência de comandos
que são executados de uma só vez ao serem chamados, operando
como um bloco de código para o aplicativo localizado numa área
chamado janela de código. Um Sub-procedimento é normalmente
o tipo mais comum de procedimento. No ambiente de
desenvolvimento VBA, existe no menu de seleção um item aonde
é possível criar um procedimento. Se um procedimento deste tipo
é criado e nomeado de "Test", as linhas seguintes seriam
automaticamente colocadas na janela de código:
Public Sub Test()

End Sub
As linhas de código a serem executados quando este

procedimento for carregado ou "chamado" seria entre o Públic
Sub Test() e a declaração End Sub. Em alguns casos a chave
"Private" poderia ser usada em vez da chave "Public". Esta chave
resultará em um escopo mais limitado no procedimento, fazendo
que este procedimento se torne inacessível para outros
procedimentos em outros códigos no módulo.
Variáveis - Variáveis podem ser usadas para armazenar
diferentes tipos de informações. Embora não são exigidas, é uma
boa idéia declarar uma variável como de um certo tipo antes de
usar a mesma. A declaração Dim é usada para declarar a
variáveis.
Dim Store1 as Integer

Dim FirstName as String
= (Expressão) - O sinal igual é usado para transferir um valor ou

informação de um lugar para o outro, como armazenar
12
informações em uma variável. A sintaxe é Destino = Fonte, em
outras palavras à informação a ser armazenada na variável estará
no lado direito seguido pelo sinal de igual e sendo colocado em
uma variável declarada ao lado esquerdo.
Store1 = 255
Store2 = Store1 * 150
Inputbox - Esta função é usada tipicamente para conseguir

armazenar informações de um usuário em uma variável.
FirstName = Inputbox (“Please enter your first name”)
No exemplo anterior, qualquer tipo de informação pode ser

entrada e então armazenada na variável FirstName.
MessageBox - Esta função é usada para exibir uma mensagem
para o usuário com um botão "OK".
MsgBox “Good Morning”
Em um uso mais avançado do MsgBox ele pode ser usado para

exibir uma mensagem e permitir que o usuário faça uma seleção,
que então poderia ser usada para mudar o conteúdo de uma
13
variável.
Store1 = MsgBox ("É seu nome Mike?", vbYesNo)
Se o usuário clicar no botão "Sim" (Yes) então a variável Store1

terá o valor de “vbYes". Se o usuário clicar no botão “Não” (No),
então a variável Store1 teria o valor de "vbNo".
(Apóstrofo ou Cotas Únicas) - O caractere de apóstrofo ou cota
única é usada para adicionar comentários ou observações usados
para documentar um código. Em um procedimento, tudo que
estiver à direita de um apóstrofo é considerado um comentário e é
exibido com uma cor verde.
Store1 = 50 ‘Store a fifity in a variable named Store1

Store2 = InputBox (“Enter a Value”) ‘Ask user to type in a number
MsgBox Store1 + Store2 ‘Display a message that shows sum of 50
& (Companhia) - Este caracter é usado para concatenar ou

"combinar" informações dentro de uma string. Note que o texto
ou "Strings" são especificadas dentro de cotas duplas.
Store1 = InputBox (“Enter a number”)

FirstName = InputBox (“What is your name?”)
MsgBox “You entered a “& Store1 & “and you name is “& FirstName
_ (Sublinhado) - O sublinhado é um caracter de continuação

usado para manter código contínuo em linhas diferentes evitando
que o mesmo não se torne muito longo. Uma linha de código
pode começar em uma linha e continuar na próxima linha.
Quando usar uma continuação de linha, você deverá identificar as
14
próximas linhas para facilitar a leitura, e também, esteja certo que
você digitará com um espaço em branco antes do sublinhado em
cada linha que irá dar continuidade ao código que ficou faltando.
MsgBox “This messagebox is to inform you that” _

& “information provided is to be kept confidential” _
& “and is considered company property”
If...Then - Uma simples estrutura de decisão no VBA é

declarado por If... Then. Estes serão usados no VBA para decidir
alguma ação baseada em uma condição de verdade.
If Store1 = 30 Then MsgBox “The value entered is 30”
Se várias ações acontecerão, então as mesmas deverão ser

colocadas em linhas separadas e no final é exigida uma
declaração End If:
If Store1 = 55 Then
Store2 = Store1 + 20
MsgBox “Data has changed”
End if
Mais opções estão disponíveis usando as declarações ElseIf e

Else.
Store1 = InputBox (“Please enter you age”)

If Store1 < 13 Then
15
Msgbox “You are a youngster”
ElseIf (Store1>=13) And (Store1<=19) Then
Msgbox “You are a teenager”
Else
Msgbox “You are a grown-up”
End If
Cases - Semelhante às declarações If...Then... a seleção de casos

utiliza uma estrutura de decisão para executar funções especificas
baseadas em condições certas.
Storel = InputBox("Please enter your age")

Select Case Storel
Case Is < 13
MsgBox "You are a youngster"
Case 13 To 19
MsgBox "You are a teenager"
Case Else
MsgBox "You are a grown-up"
End Select
For...Next Loops - Se você quiser repetir linhas específicas de

códigos sabendo o número de tempos, um laço For/Next pode ser
usado. O laço usa uma variável que incrementa por 1 toda vez
que o laço repete (1 é o padrão, mas pode ser modificado). O
exemplo seguinte resulta na soma de quatro números entrados
pelo usuário e serão exibido em um MessageBox.
Dim Num As Integer

For X = 1 To 4
Num = InputBox("Enter number")
TotaINum = TotaINum + Num
Next X
MsgBox "The total of the four values is " _
& TotaINum
16
Laço Do...While/Until - Se um número específico de linhas

precisa ser repetido, mas o número de tempos não é conhecido
(ou pode variar), qualquer um dos laços Do... While ou Do...
Until podem ser usados.
Do
strPassword = InputBox("Enter your password")
Loop While strPassword <> "Lefty"
Outro exemplo :
Do While strPassword <> "Lefty"

strPassword = InputBox("Enter your password")
Loop
Os dois exemplos acima exatamente estão fazendo a mesma

coisa, porém existe uma diferença entre as duas estruturas. No
laço Do... While do exemplo (a segunda versão) o conteúdo da
variável strPassword está sendo conferido antes do laço ser
executado. Pode ser possível que esta variável já contenha o texto
"Lefty". Se isto for o caso, o conteúdo do laço não seria
executado nenhuma vez. Em um laço Do... While, as linhas do
laço seriam executadas pelo menos uma vez.
Semelhante ao laço Do... While e ao laço Do... Loop While a
estrutura, existente faz o laço ate o Until..Loop e Do...Loop Until
tipos de laços estruturados no VBA.
With...End With - Freqüentemente é desejável mudar os tempos

e/ou ler muitas propriedades de um objeto através de um código
VBA. Por exemplo, se existisse um objeto com o nome
IbIMainTitleOnForm e fosse necessário mudar muitas
propriedades deste objeto, as próximas linhas seguintes de código
17
poderiam fazer isso:
IbIMainTitIeOnForm.ForeColor = vbBlue
IbIMainTitIeOnForm.Caption = "Production Report"
IbIMainTitIeOnForm.FontBold = True
IbIMainTitIeOnForm.Fontltalic = True
IbIMainTitIeOnForm.Visible = True
Usando as declarações With...End With, o mesmo código poderia

ser escrito de outra forma como a seguir:
With IbIMainTitIeOnForm
.ForeColor = vbBlue
.Caption = "Production Report"
.FontBold = True
.Fontltalic = True
.Visible = True
End With
Embora existam atualmente mais linhas de código, com a sintaxe

With...End With é possível fazer códigos mais legíveis e
estruturados, especialmente quando se está trabalhando com
nomes longos para objetos.
18
Laboratório – VBA, 1. Inicie o Microsoft Excel
criando um 2. No Excel, mostre a caixa de ferramentas do VBA
procedimento no clicando em View – Toolbars – Control Toolbox nos
Microsoft Excel menus listados.
3. Clique na ferramenta Command Button (Botão de

Commando), que se encontra na caixa de ferramentas,
clique sobre a planilha Excel, e arraste para formar um
botão de comando, como mostra a figura a seguir.
4. Clique com o botão da direita sobre o botão e selecione

“View Code”.
5. Uma tela similar a seguinte irá aparecer:
6. Esta é uma tela de edição do VBA, que é acessado através

do Excel. Este editor pode ser referenciado com um IDE
(Integrated Development Environment). Na pasta
“Sheet”, localizada no canto inferior esquerdo do Excel,
um procedimento ou evento chamado
19
“CommandButton1_Click” é gerado automaticamente
para você, com uma linha de começo (Private Sub
CommandButton1_Click) e outra linha finalizando (End
Sub).
7. Entre essas linhas do procedimento, desenvolva o código
de programação conforme as linhas abaixo:
Private Sub CommandButtonl_Click()
Dim Cel As Integer
Dim Fahr As Integer
Cel = InputBox("Por favor, entre com a temperatura emCelcius")
Fahr = (9 / 5 * Cel) + 32
MsgBox ("A temperatura convertida é " & Fahr & _
" Graus Fahrenheit")
End Sub
8. Antes você executa (RUN) o procedimento, informe-se
que seu código “não bate”, uma caixa de diálogo pode
aparecer dando a opção para terminar (end) ou depurar
(debug) do procedimento. Se você selecionar depuração
(a escolha recomendada), o IDE realçaria a linha do
código que causou o erro. O botão de reset na caixa de
ferramenta pode ser clicado para reiniciar o código.
9. Para testar seu procedimento, clique em algum lugar na

tela de programação e clique no botão RUN na caixa de
ferramenta.
10. Se necessário, depure alguns erros. Seu procedimento

perguntaria uma temperatura em Graus Celsius, converta
isso para Fahrenheit, e mostrar uma mensagem indicando
o valor convertido.
NOTA: Nesta hora seu código não faz check algum para garantir
20
o valor entrado, para testar se é um número válido. Por exemplo,
caso você coloque um caracter alfanumérico e clicar em OK no
InputBox, ou mesmo clicar no botão Cancel, o código irá travar
(tente isto). Depois nesta aula, você verá exemplos de códigos
para verificar que o dado entrado na caixa é um número válido
com uma especificação de range, por exemplo. Se você está
familiar com cada código, vá em frente e adicione isto em seu
procedimento. Se ainda não está familiarizado, você agora algo a
mais para procurar aprender na aula.
11. Documente seu código com comentários explicando o que
cada linha do código faz.
12. Retorne à planilha Excel clicando no botão “View
Microsoft Excel” ou clique na tarefa do Excel sobre a
janela da caixa de ferramentas.
13. Nesta hora, clique no botão que acabou de criar e
configurar na planilha para executar o procedimento.
Você pegaria os mesmo resultados de quando você rodou
o procedimento de dentro do IDE (Ambiente de
desenvolvimento integrado).
14. Da planilha, se você quiser retornar para o IDE, você
pode fazer da seguinte maneira:
Botão Design Mode

 No menu, selecionar Tools-Macro-Visual Basic
Editor
 Na caixa de ferramentas, clique no botão “Design
Mode”. Uma vez no modo de projeto (design mode),
você pode clicar com o botão da direita sobre o
código selecionado.
 Se você quiser pode trocar a aparência de seu botão
21
indo a propriedades. Trocando as propriedades com
Caption (Título), Font (Fonte), BackColor (cor de
fundo) entre outros.
Laboratório Seguindo o procedimento detalhado do laboratório anterior,
Adicional crie um segundo botão para fazer a conversão de fahrenheit
para Celsius. O cálculo requer a seguinte fórmula
Celsius = (Fahrenheit – 32) * 5/9
Tenha certeza que seu código esteja correto.
22
Projeto do RSView32 com VBA Capítulo 4
Projeto do RSView32 com VBA
Antes de começar: O Modelo de Objetos do RSView32 é formado por objetos

automatizados através da tecnologia OLE que representam a
funcionalidade do RSView32. Usando estes objetos, você
poderá interagir com um projeto do RSView32 executando
códigos do VBA o mesmo com fosse uma execução de uma
macro no RSView32. As vantagens do código em VBA em
relação a uma macro são:
 •Possibilidade de controlar a execução de um código
através de uma lógica condicional
 •Utilização de objetos do modelo através dos objetos
gráficos do RSView32 para executar diferentes
operações e comandos, como, por exemplo,
acrescentar novas tags na base de dados
 •Possibilidade de utilizar modelos de objetos de
terceiros
 •Criar Formulários, Módulos, e Classe de módulos
que serão chamados através de sub-rotinas a partir de
uma seqüência de códigos VBA que você poderá
escrever no objeto do projeto do VBA, chamado
ThisProject
 •Exibição de caixas de diálogos contendo controles
do VB ou algum controle ActiveX
O IDE (Ambiente de Desenvolvimento Integrado) do VBA
permite que você visualize todas as propriedades, métodos e
eventos do seu projeto através do Objeto Browser. O Objeto
Browser está disponível abaixo do menu View.
Para ver as propriedades, métodos, e eventos de um objeto do
RSView32
23
1. 1.Selecione o Object Browser no menu de Visualização
do IDE do VBA, ou clique com o botão do lado direito
na janela de Código para exibir um menu e então
selecione o Object Browser.
2. 2.Na janela Object Browser faça a seleção de uma
biblioteca de objetos do RSView32 na listagem
disponível
3. 3.Clique em um objeto do RSView32 na janela
selecionando as Classes,para ter acesso as suas
propriedades, métodos, e eventos que serão exibidos na
área de Membros.
4. 4.Pressione F1 para exibir a ajuda, mantendo um objeto
destacado ou clicando em uma propriedade, método, ou
evento na janela de Membros, pressionando F1 ou
clicando no ícone "?" será exibido a ajuda necessária
para este objeto, propriedades, métodos ou eventos.
Você pode utilizar também uma ajuda mais completa através da
Ajuda dos Modelos de Objetos do RSView32, dentro do menu
ajuda do RSView32. Selecione o item Conteúdo, Modelos de
Objetos do RSView32.
Modelo do diagrama Nesta parte será mostrado a estrutura de objeto que existe dentro
de Objeto do software RSView 32. Os termos aparecerão em inglês, pois
na programação toda a lógica e comando a ser criado é baseada
no inglês.
24
25
26
27
28
Modelo do diagrama Activity – Representa a atividade de registros do RSView32. O
de Objeto do RSView objeto Activity leva a você registra atividades para o registro do
contem os seguintes projeto do RSView32.
objetos
AlarmThreshold – Objeto para ler e escrever as informações
dos limites do alarme para uma tag analógica.
AlarmThresholds – Coleção para acessar os limites dos

alarmes para uma tag analógica.
AnalogTagAlarmCfg – Objeto para ler e escrever as

informações de configuração para os alarmes para uma tag
analógica.
Application – Representa uma aplicação ao RSView32.
Channel – Representa um canal de comunicação do RSView32.

Use este objeto para ler e escrever as informações do canal de
configuração.
Channels – Permite acessar para todos os canais disponíveis no

projeto. O nome da variável global para a coleção de canais é o
gChannels.
Command – Este representa o servidor de comando do

RSView32 e leva você publicar os comando do RSView32. Use
a propriedade do Command do objeto do projeto para pegar uma
referência do objeto de comando. O nome da variável global
para o servidor de comandos é gCommand.
DataLog – Representa o subsistema de registro de dados do
29
RSView32. O objeto DataLog proporciona acesso para todos os
modelos de registro de dados no projeto. Use a propriedade do
DataLog do objeto do projeto para obter uma referência para o
objeto de registro de dados.
DataLogModel – Objeto que representa um modelo de registro

de dados do RSView32. As propriedades e métodos deste objeto
permitem aos usuários:
 Ler e escrever dados para este modelo
 Acessar a configuração do modelo
DataLogModelCfg – Objeto é acostumado a ler e escrever

informações da configuração do modelo.
DataLogModels – Uma coleção de modelos de registro de

dados. Use este objeto para acessar, adicionar ou remover
modelo de registro de dados do projeto.
DataLogNarrowRecord – Objeto contém todas as informações

para um registro de um modelo de formatação específica. Use
este objeto para ler e escrever dados para ou de um modelo.
Use o método CreateNarrowRecord do objeto DataLogModel
ou método de um item da coleção DataLogNarrowRecords para
obter uma referência para o objeto DataLogNarrowRecord.
DataLogNarrowRecords – Objeto é uma coleção de objetos de

registros específicos do registro de dados. Use este objeto para
ler e escrever dados para ou de um modelo.
Use os métodos CreateNarrowRecords e ReadTagDataNarrow
do objeto DataLogModel para obter uma referência para uma
coleção DataLogNarrowRecords.
30
DataLogTagValue – Coleção que permite acessar informações

de uma tag que pertence a um objeto particular
DataLogWideRecord.
Use a propriedade DataLogTagValues do objeto
DataLogWideRecord para obter uma referência para uma
coleção DataLogTagValues.
DataLogTagValues – Coleção que permite acessar informações

à tag que pertence a um objeto exclusivo DataLogWideRecord.
Use a propriedade DataLogTagValues do objeto
DataLogWideRecord para obter uma referência para ler e
escrever para ou de um modelo.
DataLogWideRecord – Objeto contém todas informações para

um registro de um modelo de formato oculto. Use este objeto
para ler e escrever para ou de um modelo.
Use o método CreateWideRecord do objeto DataLogModel ou o
item do método da coleção DataLogWideRecords para obter
uma referência para um objeto DataLogWideRecord.
DICA – um DataLogWideRecord contém uma coleção de
objetos DataLogTagValue (Valores de Tags de registro de
dados) que é acostumado a gerenciar informações de Tags
(valores, estados e nome) para um registro.
DataLogWideRecords – Objeto é uma coleção de objetos

DataLogWideRecord. Use este objeto para ler e escrever dados
para ou de um modelo.
Use o CreateWideRecords e métodos ReadTagDataWide do
objeto DataLogModel para obter uma referência para uma
coleção DataLogWideRecords.
31
DigitalTagAlarmCfg – Objeto para ler e escrever as

informações de configurações de alarme para uma tag digital.
Use a propriedade DigitalTagAlarmCfg do objeto Tag para
obter uma referência à um objeto DigitalTagAlarmCfg.
Folder – Representa um pasta dentro da hierarquia da base de

dados de tags do RSView32. Use este objeto para acessar
alguma sub pasta ou tag que possa conter em uma pasta.
Use os métodos CreateFolder, DuplicateFolder e GetFolder para
o objeto TagDb, ou o método Item e Add para as coleções de
Pastas (Folders), para obter uma referência para um objeto
Folder.
Folders – Representa coleção ou grupo de pastas dentro de uma

hierarquia da base de dados de tag do RSView32. Use este
objeto para acessar, adicionar ou remover pastas de um nível
exclusivo na hierarquia de base de dados de tags.
Use a propriedade Folders do objeto Folder ou a propriedade
RootFolder do objeto TagDb para obter uma referência para
uma coleção de Folders.
Node – Representa um simples nó. Use este objeto para ler e

escrever informações de configuração de nó.
Use o método Add e Item de uma coleção de nós para obter uma
referência para um objeto Node.
Nodes – Uma coleção de objetos Nós (Node) do RSView32.

Use este objeto para acessar, adicionar ou remover nós de um
projeto.
O nome da variável global para coleção de Nós é gNodes. Este é
32
mostrado somente para RSView32 VBA.
ODBCAdministrator – Permite para a enumeração dos dados

de origem ODBC e a criação da tabela dentro de uma origem de
dados existentes.
Use a propriedade ODBCAdministrator do objeto Application
para obter uma referência para este objeto.
O nome da variável global para este objeto é
gODBCAdministrator. Isto é mostrado somente no RSView32
VBA.
Project – Representa um simples projeto do RSView32. O

VBA para RSView32 tem um objeto de projeto global chamado
gProject.
Quando você quer acessar o modelo do objeto do RSView32 de
um controle automático externo, cada qual uma aplicação do
Visual Basic, use a propriedade ActiveProject de um objeto
Application para obter uma referência do objeto Project.
O objeto Project lhe permite acesso para outro objeto do
RSView32 através das propriedades: Activity, Channels,
Command, Nodes, Security e TagDb.
Desde de quando o RSView32 VBA expôs objetos globais a
estes objetos, não há necessidade para uso destas propriedades
de VBA. Use estas propriedades para obter referências para os
objetos do RSView32 de um controlador automático externo.
Security – Representa um sub-sistema de segurança do

RSView32. Use isto para um login de usuário, logoff do usuário
atual, trocar o password do usuário, e verificar a segurança para
um usuário específico. Security não é um objeto de criação.
Use o propriedade Security para o objeto Project para obter uma
33
referência do objeto Security.
O nome da variável global para o objeto Security é gSecurity.
Este só é mostrado no RSView32 VBA.
StringList – Uma coleção de String.

Você pode usar a palavra chave “New” para criar uma instancia
deste objeto.
Este objeto Stringlist criado pelo usuário permite a adição e
remoção de string para uma ou de uma coleção. A maior parte
dos objetos StringList retorna as propriedades dos objetos do
RSView32 são somente de leitura e não permitem adição ou
remoção de String.
Tag - Representa uma tag do RSView32. Você pode usar as

propriedades ou métodos do objeto Tag para:
 Ler e escrever um valor da Tag.
 Ler e escrever informações de configuração da Tag.
Você não pode criar uma nova instância de um objeto Tag. Use
a GetTag, CreateTag e métodos QueryForTagdo objeto TagDb
para obter referência para um objeto Tag.
TagDb – Representa a base de dados do RSView32.

Use a propriedade TagDb do projeto para obter uma referência
para o objeto TagDb.
O nome da variável global para TagDb é o objeto gTagDb. Este
é mostrado somente no RSView32 VBA.
Use o objeto TagDb para:
 Criar, editar ou apagar as tags do RSView32
 Pegar ou consultar objetos Tag
 Criar uma coleção de objetos Tag baseado na consulta
de tag.
34
Tags – Uma coleção de objetos Tag.

Você pode usar a palavra chave “New” para criar uma instância
deste objeto.
Use o objeto Tags para trabalhar com tags em um grupo e
executar transação de blocos.
Os seguintes métodos retornam objetos Tag: TagDb.CreateTags,
TagDb.BrowerForTags, TagDb.QueryForTags e Folder.Tags.
AVISO: Para a maioria dos objetos, você não pode usar a

palavra-chave ”New” para criar uma instância do objeto.
Como o RSView32 Você pode executar um procedimento do VBA em qualquer

utiliza o VBA lugar que você pode executar um comando do RSView32.
Por exemplo, no editor de Eventos do RSView32, você pode
criar um evento para executar um procedimento quando um
alarme acontecer. No editor de telas gráficas do RSView32,
você pode criar um botão que executará um procedimento
quando este for clicado no modo runtime.
Dois comandos do RSView32 são usados para o VBA:
VbaExec - Executa um código em VBA, exemplo:

VbaExec <Nome do Procedimento>
VbaEdit - Abre o editor de códigos do VBA, exemplo: VbaEdit

< Nome do procedimento>
35
Janela de Projeto
Janela de
Propriedade
O objeto de pesquisa é
aberto com este ícone
Janela de Código
Selecione RSView32
para mostrar somente
objetos do RSView32
Selecione um objeto para

ver suas propriedades,
eventos, métodos e
constante (se existir).
36
Lab – Um procedi- 1. Inicie o RSLogix Emulate 5 e o RSView32 Works. No
mento VBA que RSView32, abra um projeto chamado “Projeto VBA”
trabalha com um (C:\Projeto VBA\ Projeto VBA.rsv). Do gerenciador de
registro ativo projetos, abra a pasta lógica e controle e abra o editor
(Activity Log) e Visual Basic com um duplo clique.
executa comandos
do RSView32
Uma janela similar a esta abaixo aparecerá.
AVISO: Quando o editor VBA é aberto, o ícone abaixo do

Microsoft Visual Basic será alocado na barra de tarefa. Isto
ajudará facilmente a retornar para o editor do RSView32 se
outro janela cobrir esta.
37
2. Entre com o seguinte código na janela:
Public Sub StartFan()
gActivity.Log “Exaustor Ligado!”
End Sub
Public Sub StopFan()

gActivity.Log “Exaustor Desligado!”
End Sub
3. Retorne ao RSView32 clicando na tarefa RSView32, na

barra de tarefas do Windows, ou clicando no botão
“View RSView32” na barra de ferramentas do Visual
Basic IDE.
4. No gerenciamento de projeto na aba Edit Mode (modo
de edição), abrir a pasta Graphics dando um duplo
clique sobre ele. Sobre Diplay, de um clique da direita
para criar uma tela como a mostrado abaixo. Criar um
botão FECHAR, com o comando ABORT. Na botoeira,
colocar o seguinte comando em Press Action MEM\
BIT0 = 1 (Antes é necessário criar esta TAG).
5. Na barra de ferramenta, que aparece no topo da tela,
38
clique sobre o botão de teste de operação TEST RUN.
6. Como a tela está no modo de TEST RUN clique no botão

vermelho e verde. Na tela, a mudança de cor da botoeira
indica se o exaustor ligado ou desligado.
7. Pare o modo de teste da tela.
8. Sobre a botoeira clique com o botão da direita e

selecione Animation-Touch. Uma tela como a seguinte
irá aparecer:
9. No campo Press Action, use o comando VBAExec para

produzir seu procedimento StartFun ser executado.
Desta forma é necessário acrescentar o seguinte:
MEM\BIT0 = 1; VBAExec StartFan

10. Clique em Apply, então o botão Close nesta caixa de
39
diálogo para aceitar suas trocas. Clique no botão para
salvar suas trocas para esta tela.
11. Novamente, vá a Test Run e clique na botoeira. O

exaustor iniciaria o processo e deverá aparecer uma
informação no Activity Log.
12. Pare o teste, e abrirão Activity Log dando um duplo
clique sobre Activity Log Viewer, que fica na pasta
System no gerenciador de processo.
13. Seguindo um procedimento similar, o botão vermelho

para o Exaustor da tela, para executar o procedimento
StopFan. Quando completo, sua aplicação será
registrado as informações sobre Ligar/Desligar exaustor,
incluindo hora, data, para o registro de atividades do
RSView32. Quando satisfeito com sua aplicação,
continue com o próximo passo.
14. Modifique seus procedimentos StartFan e StopFan e
deixe da seguinte forma:
Public SubStartFan()
gActivity.Log “Exaustor Ligado!”
Dim Resposta as String
Resposta = msgbox(“Você gostaria de visualizar o registro?”, vbYesNo)
If Resposta = vbYes Then gCommand.Execute “ActivityViewer”
End Sub
Public SubStopFan()
gActivity.Log “Exaustor Desligado!”
40
End Sub
15. Test Run a tela Exaustor, e clique nos botões vermelho e
verde. Você agora deveria ver uma tela de PopUp
aparecer perguntando “Você gostaria de visualizar o
registro”, depois abrir a tela de Activity Log Viewer.
Lab - Adicional#1 1. Modifique o procedimento StartFun para ficar parecido
com as linhas seguintes:
Dim Comentario as String
Comentario = inputbox(“Entre com comentário sobre sua ação.”)
gActivity.Log Comentario
End Sub
2. Teste os botões verde e vermelho para ver o
funcionamento deste procedimento.
Lab - Adicional#2 No exercício anterior, foi usado o método do objeto Command
para executar os comandos do RSView32 através do VBA (por
exemplo, o gCommand.Execute). O objeto Command também
tem um método chamado BrowseForCommand que mostrará
um “Localizador de Comandos” com potencial de permissão ao
usuário para selecionar um comando de sua escolha para
executar.
AVISO IMPORTANTE: Se usado este método em uma
aplicação real, será necessário tomar cuidado para ver se o
usuário tem permissão para acessar os comandos chamados.
1. Modifique o procedimento da seguinte forma:
Dim Comentario as String
Comentario = inputbox(“Entre com comentário sobre sua ação.”)
gActivity.Log Comentario
41
Dim CMD as String
Resposta = msgbox(“Você deseja selecionar um comando a ser
executado?”, vbYesNo)
If Resposta = vbYes Then
CMD = gCommand.BrowserForCommand
gCommand.Execute CMD
End If
End Sub
2. Teste estas modificações, pressionando os botões Verde
e Vermelho.
Lab – Criando um 1. No RSView32 “Projeto VBA”, abra o editor Visual

Procedimento que Basic (IDE).
trabalha com as Tags 2. Na tela de código do VBA, coloque as linhas abaixo
em RSView32 (para ganhar tempo, pode-se usar as funções COPIAR e
COLAR)
Sub Incrementar()
Dim TL as Tag
Set TL = gTagDb.GetTag(”nivel_tanque”)
If TL.Value<=80 Then
TL.Value=TL.Value + 20
Else
MsgBox “Valor máximo da Tag excedido”, vbCritical
EndIf
Set TL = Nothing
End Sub
Sub Decrementar()
Dim TL as Tag
If TL.Value>=20 Then
TL.Value=TL.Value - 20
Else
MsgBox “Valor mínimo da Tag excedido”, vbCritical
42
EndIf
Set TL = Nothing
End Sub
Sub AmostraTag()
Dim TL as Tag
Dim sMensagem as String
sMensagem = Tl.Name & “=” & Tl.Value & “ “ & Tl.Units
MsgBox sMensagem & “até” & Now, vbInformation, “Nível do Tanque”
Set TL = Nothing
End Sub
3. Salve o código com freqüência, para que você não perca

lógica alguma durante a programação.
4. Retorne ao RSView32. No gerenciador de Projetos, abra
a pasta Graphics e com um simples clique em Display
com o botão da direita, crie uma tela chamada Tanque e
crie a seguinte tela com 3 botões, um Numeric Display e
um Tank, pego na Library Tank2.
Qualquer dúvida pergunte ao instrutor.

5. Sobre o botão Incrementar, de um duplo clique, e
selecione a aba Action para configurá-lo usando o
comando VbaExec em Release Action como segue:
43
6. Faça o mesmo para os outros botões, Decrementar e

Informações de Tag.
7. Salve suas mudanças para a tela Tanque.
8. Para testar este novo exercício, vá a TEST RUN e veja
clique sobre os botões para ver o que acontece.
Lab – Usando uma No Menu do editor VBA, selecione o botão para inserir um
função InputBox novo Procedimento, como mostra a figura abaixo:
1. Coloque em Name MEU_INPUT e clique em OK para
44
criar um novo Sub procedimento.
2. Neste novo procedimento, entre com as seguintes linhas
de código (Entre as declarações “Public Sub
MEU_INPUT()” e “End Sub”):
Dim Armazena As Variant
Dim TL As Tag
Armazena = InputBox (“Por Favor, entre com um valor para carregar”)
Set TL = gTagDb.GetTag (“nivel_tanque”)
TL.Value = Armazena
Set TL = Nothing
End If
3. Salve o código no Computador
4. Adicione um botão na tela TANQUE que irá executar
este novo procedimento (pelo comando VbaExec
MRU_INPUT)
5. Coloque o projeto em TEST RUN e coloque uma letra,
valores entre 0 e 110 e fora desta faixa para ver o que
ocorre.
6. O que aconteceu quando colocou algum caracter?
___________________________________________________
___________________________________________________
7. Quando colocou um valor entre 0 e 100?
___________________________________________________
___________________________________________________
8. E quando colocou qualquer outro valor?

___________________________________________________
___________________________________________________
Para que não ocorra falha alguma, é necessário criar uma lógica
45
que preveja que a variável tem um range, e que não se pode
passar deste, desta forma é necessário colocar a seguinte lógica:
Dim Armazena As Variant
Dim TL As Tag
Armazena = InputBox (“Por Favor, entre com um valor para carregar”)
If IsNumeric(Armazena) Then
If Armazena >=0 And Armazena<=100 Then
Set TL = gTagDb.GetTag (“nivel_tanque”)
TL.Value = Armazena
Set TL = Nothing
Else
MsgBox “Valor entrado está for a do Range”, vbExclamation
End If
Else
MsgBox “Valor entrado não é um número”, vbExclamation
End If
Lab – Adicional#3 1. Entre com um procedimento sem segurança (sem prever

o range da variável) e verifique um potencial problema.
2. Modifique sua lógica para entrar com valores apenas
entre 20 e 50.
3. Adicionar no procedimento mostrar na tela uma
mensagem apropriada se o valor carregado não for
válido.
46
Lab – Usando o 1. Adicione um procedimento VBA para o projeto com as
Método seguintes características:
BrowseForTags Sub Pegar_tags()
Dim MinhasTags As Tags
Dim Conta As Integer
Dim sComando As String
Set MinhasTags = gTagDb.BrowseForTags
sComando = "Display Grafico /T"
For Conta = 1 To MinhasTags.Count
sComando = sComando & MinhasTags(Conta).FullName
If Conta <> MinhasTags.Count Then
sComando = sComando & ","
End If
Next Conta
gCommand.Execute sComando
End Sub
2. No gerenciador de Projeto vá a Graphics, Display, e
com o botão direito do mouse, crie uma nova tela
chamada Gráfico. Nesta tela, coloque um gráfico de
tendência, para que se possa visualizar variáveis dentro
dele, como mostra a figura abaixo, por exemplo.
3. Sobre gráfico (mostrado com a seta na figura acima) de

um duplo clique, até entrar nas configurações do Trend.
Vá à aba Pen Configuration e na Canetas (Pen) coloque
47
Lab – Adicional#4 Usando o Lab anterior, crie uma tela chamada MONITOR e
nela acrescente um botão, que quando apertado, seleciona-se até
3 variáveis para ser monitoradas toda vez que clicarmos neste
botão.
48
Lab – Usando VBA 1. No projeto RSView32, crie uma tela chamada “Nível”.
para escrever para na Como mostra a figura abaixo
base de dados do
RSView32.
2. Esta tela está trabalhando com Tags ”DEVICE\T4ACC”

e “DEVICE\T4PRE”. Incluindo textos PRESET e
ACUMULADO, para as tags citadas acima
respectivamente. Com a entrada numérica (Numeric
Input), permite-se trocar o preset do temporizador, e um
display numérico para visualizar o acumulador, tempo
contado no temporizador, e por fim dois Labels
indicando o mínimo e máximo da tag DEVICE\T4ACC
da base de dados.
3. Se você clicar em Test Run esta tela, o retângulo (bar
graphic) deveria crescer de acordo com o aumento do
acumulado do temporizador. Troque o valor do PRESET
entre 1 e 3000 e pressione ENTER, qualquer dúvida
pergunte ao instrutor com fazer.
4. Vá para o editor VBA e crie um procedimento descrito
49
abaixo:
Public Sub TROCAMax()
Dim pre As Tag
Dim acc As Tag
Set pre = gTagDb.GetTag("Device\t4pre")
Set acc = gTagDb.GetTag("Device\t4acc")
acc.MaximumValue = pre.Value
acc.WriteConfiguration
End Sub
5. Adicione um botão na tela Nível que irá executar o
Procedimento TROCA_MAX, com o título “Troca de
Range”.
6. Depois de criar o botão coloque a tela em Test Run e
troque o valor de preset e clique no botão criado. Repare
que o valor do máximo ainda não foi trocado, pois será
necessário clicar em Normal, e depois em Test Run
novamente, para que a variável seja trocada.
7. Se quiser uma tela mais dinâmica, que após clicar no
botão a variável troque de valor, será necessário
adicionar mais duas linha a lógica anterior.
gCommand.Execute “Abort Nivel”
gCommand.Execute “Display Nivel”
8. Desta forma, a tela fechará e abrirá sozinha sem que se
perceba.
AVISO: Na primeira vez que pressionar o botão uma mensagem
irá aparecer perguntando se você quer salvar as alterações da
tela Nível.gfx. Clique em SIM (YES). Isto é normal porque a
tela vai para o modo de edição (EDIT) para RUN e isso não
ocorrerá mais depois do primeiro clique.
50
Lab – Usando 1. Do gerenciador de projeto do RSView32, Crie uma tela
Formulários no VBA chamada TelaInicial. Nela entre em propriedades (clicar
com o botão direito, vá a Display Settings), vá a aba
Behavior e em CommandsStartup coloque a seguinte
sentença “VbaExec MostrarFormulario”. Depois no
gerenciador de projetos vá até aba System Startup, na
aba Startup coloque a TelaInicial em Inicial Graphic.
2. Vá ao editor do Visual Basic do RSView32 e selecione
no menu o item inserir UserForm.
3. Um UserForm e uma caixa de ferramenta aparecerão
conforme mostra a figura abaixo.
4. Também, pode-se notar que na pasta Forms, foi

adicionado um novo formulário com o nome
UserForm1, encontrado na janela de projetos.
5. Você verá que abrirá a tela de propriedades. Se não

aparecer, selecione “View-Properties Window”
51
6. Usando a caixa de ferramentas crie uma tela conforme

mostra a figura abaixo. É necessário criar o Frame antes
dos OptionButton.
7. Com um simples clique no objeto Image do seu

formulário. Vá para a Janela Properties e troque a
propriedade Picture para C:\projetoVBA\Msgbox04.ico.
Se não encontrar este arquivo, por favor, pergunte ao
instrutor onde encontrar, ou selecionar outra imagem.
8. Para trocar o nome (título) dos objetos do formulário, vá
à tela de propriedades no item Caption colocando os
seguintes nomes, conforme mostra a figura. Em Tanque
Option Button vá a Value que fica em propriedades e
coloque True.
52
9. Duplo clique esquerdo sobre o botão, após fazer isso irá

aparecer a janela do código onde você entrará com os
seguintes dados:
Private Sub CommandButton1_Click()

If OptionButton1.Value = True Then
gCommand.Execute "display Tanque /T"
gCommand.Execute "display Nivel /T"
gCommand.Execute "display Exaustor /T"
Unload Userform1
End Sub
10. Na janela do Projeto, duplo clique sobre “ThisProject”

para abrir ou retornar para o projeto principal da janela
de código VBA.
11. Criar um procedimento chamado “MostrarFormulario”

que irá chamar o formulário criado anteriormente, que
usará as seguintes linhas de programação.
53
Public Sub MostrarFormulario()
Userform1.Show
End Sub
12. Caso queira, colocar um botão na janela principal para

executar o comando acima, ou fazer o que está
referenciado no item 1.
Lab – Adicional#5 1. Criar um segundo formulário para o projeto
2. A este novo formulário, adicionar uma caixa combo e
um botão e editar o formulário para aparecer como segue
a figura abaixo.
3. Duplo clique sobre o formulário e crie um evento

Activate para adicionar a seleções na caixa combo. Para
isso, na janela de código, coloque estes campos como
segue a figura.
Private Sub UserForm_Activate()

ComboBox1.AddItem "Exaustor"
ComboBox1.AddItem "Nivel"
ComboBox1.AddItem "Tanque"
End Sub
4. No botão “Mostrar Tela” coloque o seguinte código e

veja o que acontece:
54
Private Sub CommandButton1_Click()
If ComboBox1.Value = "Nivel" Then
gCommand.Execute "Display Nivel"
If ComboBox1.Value = "Exaustor" Then
gCommand.Execute "Display Exaustor"
If ComboBox1.Value = "Tanque" Then
gCommand.Execute "Display Tanque"
Unload UserForm2
End Sub
5. Como no Lab anterior, criar um procedimento para
chamar este novo formulário, ou colocando na
inicialização da tela, ou em um botão.
55
Usando Eventos Capítulo 5
Usando Eventos
Eventos de Objeto do Os objetos do Visual Basic para Aplicações têm em comum,

RSView32: Propriedades, Eventos e Métodos. Nos exercícios anteriores,
estes foram endereçados manualmente através das Propriedades
dos Objetos, tais como a Propriedade de Valor de um Objeto de
uma tag, Métodos dos Objetos, como o método Log das
atividades de um Objeto entre outros.
Certos objetos nos Modelos de Objetos do RSView32 têm
Eventos que você pode usar em seus procedimentos do VBA.
Por exemplo, o Objeto de Atividade tem um "Evento” de
LoggedToActivityBar. Também, o Objeto de tags e a Coleção
de tags têm os seguintes eventos:
 Acknowledge
 AlarmFault
 AlarmSuppress
 IntoAlarm
 OutOfAlarm
 ReadFromSourceComplete
 StatusChange
 ValueChange
 WritePendingValueComplete
Variável de Objeto de tag - O primeiro passo para usar
Eventos está no dimensionamento do módulo de uma variável
de Objeto de tag usando a palavra chave WithEvents. Uma
variável de "nível módulo" é uma que pode ser reconhecida por
todos os procedimentos dentro do mesmo módulo de código.
Isto é tipicamente feito na seção de Declarações Gerais da janela
de código (veja abaixo).
56
Por exemplo,
a linha
seguinte de
código na
seção de Declarações Gerais declarará uma variável de nível de
módulo nomeado "Main_Temp":
Private WithEvents Main_Temp As Tag
Uma vez esta linha de código é inserido, o nome da variável de

objeto da tag (Main_Temp neste caso) aparecerá na caixa de
listagem de Objeto.
Isto é a caixa de listagem que normalmente mostra o "(Geral)".
Os eventos possíveis para um objeto são apresentados na caixa
de listagem de Procedimentos. Esta é a caixa de listagem que
normalmente mostra os nomes das seqüências de dados e
funções (veja o diagrama seguinte).
Caixa de Lista de Objetos Caixa de Procedimento
Uma vez a monitoração de um evento iniciado, o código

inserido em um procedimento de evento é executado toda vez
que o evento acontece.
57
Começando a Monitoração de Evento - Quando esta variável
de objeto de tag for enviado para uma tag, o processo de evento
começará e o evento será continuamente monitorado (como uma
atividade em segundo plano) para uma "condição verdadeira”.
Para enviar a variável de objeto de tag para uma tag, um
procedimento parecido com a seguir, poderia ser usado, que
enviaria a variável de Main_Temp para uma tag na base de
dados chamada mem1:
Sub Tag_EventsStart()
Set Main_Temp = gTagDb.GetTag("mem1 ")
End Sub
Parando Monitoração de Evento - Se ele for desejado a

parada da "monitoração” em segundo plano para os eventos, as
variáveis de tag precisam ser enviadas para um lugar inexistente
(nothing), por exemplo:
Sub Tag_EventsStop()
Set Main_Temp = Nothing
End Sub
Exemplo de um Evento - Pretensiosamente uma aplicação
declarou uma Variável de Objeto de tag de "Main_ Temp", e o
processo de eventos foi inicializado com a execução de um
procedimento como "Tag_ EventsStart", o procedimento
seguinte escreverá informações registro de Atividade do
RSView32:
Private Sub Main_Temp_ValueChange(Value As Variant)

gActivity.Log Main_Temp.TagName & "::ValueChange() Event"
gActivity.Log "Value changed to: " & Value
End Sub
58
Um exemplo do que o registro de Atividade estaria fazendo
depois que procedimento anterior "Main_Temp_ ValueChange"
fosse executado :
Muito Importante: Se um procedimento exibir uma caixa de

mensagem ou form, ele não termina de executar até que a caixa
de mensagem ou form é despedida (fechada). Procedimentos
podem somente ser executado um a um, como exemplo caixa de
mensagem ou exibição de formulário. Procedimentos
subseqüentes serão procurados para cima. Quando a caixa de
mensagem ou forma é despedida o procedimento terminará de
executar, depois de que, o próximo procedimento na fila
executará.
Além disto, eventos de objetos que não forem executados
quando uma caixa de mensagem for exibida serão perdidos
porque eles não são pesquisados de uma execução mais nova
para uma execução mais velha. Porém, os eventos de um objeto
serão executados enquanto um formulário de VBA for exibido.
Você deverá usar formulários em lugar de caixas de mensagem
para evitar eventos perdidos.
Este procedimento mostrará como criar manualmente uma base
de dados através da criação de folders e tags de um projeto.
Dentro desta base de dados, serão definidos os pontos que o seu
projeto irá monitorar.
59
Lab – Usando 1. Na área de Declaração geral (General Declaration) da
objetos de eventos sua janela de código “ThisProject”, declare uma variável
no RSView32 chamada Timer4Pre. Esta linha de código deverá
aparecer da seguinte forma.
2. Criar um procedimento chamado “InicioMonitor” que

começará monitoração do Timer4Pre de ajuste para uma
Tag na base de dados chamada Device\t4Pre
3. Criar um procedimento chamado “FimMonitor” que
parará monitoração do Timer4Pre de ajuste para
Nothing.
4. Neste ponto, serão adicionados estes procedimentos que
aparecem abaixo:
Sub InicioMonitor()
Set Timer4Pre = gTagDb.GetTag("Device\t4pre")
End Sub
Sub FimMonitor()
Set Timer4Pre = Nothing
End Sub
5. Na Caixa de Lista Objeto (list Box) da janela de código,
selecione o objeto Timer4Pre (caixa da esquerda).
6. Na caixa de lista procedimento (list Box), selecione o
procedimento StatusChange.
7. Dentro da janela de código, aparecerão a seguintes
linhas.
Private Sub Timer4Pre_StatusChange(ByVal Status As Long)
End Sub
8. Dentro deste procedimento, entre com uma linha de
código que aparecerá uma caixa de mensagem (message
Box) dizendo, “Perda de comunicação com o PLC”.
60
MsgBox "Comunicação com o PLC, trocou de estado"
9. Salve suas alterações do VBA

10. Retorne ao RSView32 e crie uma tela que consiste de
um display numérico e um Numeric Input da tag
DEVICE\T4PRE. Também adicionar dois botões, um
configurado para rodar seu procedimento
INICIOMONITOR, e outro para rodar o procedimento
FIMMONITOR. Sua tela deverá ficar como a seguinte.
11. Salve as alterações da tela e de o nome “Lab–Eventos”.

12. Teste a tela. Você será capaz de usa a entrada numérica
(Numeric Input) para trocar o valor do device\t4pre
(tenha certeza do valor colocado esteja correto, dentro
do range).
13. Simule a perda de comunicação do PLC fechando a
aplicação do RSLogix Emulate 5. A entrada numérica e
o display numérico deveria aparecer ambos como
“vazios”, indicando que não há dados.
14. Reinicie o RSLogix Emulate 5, aparecerá novamente a
tela referente a comunicação com PLC.
15. Teste seus procedimento em VBA, na tela LAB-Eventos
pressionando o botão Início, ligue e desligue o RSLogix
Emulate 5, depois clique no botão Fim, e repita o
procedimento.
16. O evento StatusChange inclui uma constante que você
pode usar dentro do código, chamada “Status”. Note que
61
a palavra Status foi declarada como uma variável Long
(Long Integer) na primeira linha de seu procedimento:
17. Em um procedimento StatusChange, a variável “Status”
passará pelos seguintes valores: 0, 1, 2, 3 ou 4. O
conteúdo deste valores podem ser usados dentro de um
procedimento StatusChange para que o código possa
determinar qual status foi alterado. Os valores e as
definições seguem abaixo:
0 – roTagStatusValid – O valor da Tag é válida.
1 – roTagStatusState – O valor da Tag foi lido, mas não foi escaneado.
2 – roTagStatusError – Um erro ocorreu enquanto o valor da tag estava sendo
lido ou escrito
3 – roTagStatusDisabled – O valor de origem da Tag (o nó) foi desativado
4 – roTagStatusUninitialized – O valor da Tag nunca foi lido pelo
dispositivo.
18. Modifique o procedimento StatusChange à seguinte
linhas:
If Status=0 Then MsgBox “Valor do PLC é valido”
If Status=2 Then MsgBox “Valor do PLC está com erro”
End Sub
19. Retorne para o RSView32 coloque a tela “Lab –
Eventos” para funcionar. Então feche o software
RSLogix Emulate 5, veja o que aparece no RSView32,
depois abra novamente o RSLogix Emulate 5, e veja o
que aparece no RSView32.
62
Lab – Adicional#6 Criar um evento que execute somente se os valores da tag
DEVICE\T4PRE trocar. Quando este evento ocorrer, seu
procedimento registrar para o Activity Log e mostrar uma
mensagem ao usuário. A informação de registro e a mensagem
para o usuário indicariam que “Valor device\t4pre foi trocado” e
incluiria também que o valor foi trocado. Por exemplo, uma
mensagem pode aparecer como ilustrado.
63
Ferramentas de depuração e manipulação de erros Capítulo 6
Ferramentas de depuração e
manipulação de erros
Depurador de código Ainda que um programador seja muito cuidadoso, procedimentos
VBA do VBA podem conter além dos erros de sintaxe, erros de lógica
("bugs") também. Estes erros são os mais difíceis de serem achados,
pois uma aplicação pode ter além dos códigos, sintaxe e outros, que
podem ser executados sem qualquer operação de erro, e ainda
produzir resultados incorretos. Encontrar e remover estes bugs são
chamados de depuração.
Break Mode - Quando você desenvolve uma aplicação no VBA,

você trabalha principalmente em dois modos: O modo de projeto e
o mode de execução. Em modo de Projeto, o código é criado e
editado, embora os resultados não podem ser verificados até o
código ser executado. No modo execução, a execução do programa
pode ser verificado, mas nenhum tipo de mudança podem ser feito
para o código. Um terceiro modo, Break Mode, paralisa a operação
de uma aplicação e dá a você uma visualização instantânea de sua
condição lógica em qualquer momento do programa.
No modo Break Mode, você pode:
 Modificar o código de sua aplicação.
 Observar a condição da interface na aplicação.
 Visualizar os procedimentos ativos e os que já foram
chamados.
 Acompanhar em tempo real os valores das variáveis,
propriedades, e declarações.
 Alterar os valores das variáveis e propriedades.
 Alterar o fluxo de programa.
 Executar as declarações no VBA imediatamente.
64
O código do VBA entrará em Break Mode quando:
 Encontrar um Breakpoint quando seu código for executado.
 Encontrar uma declaração de Parada.
 Um Watch que você colocou for ativado.
 Você apertar a tecla CTRL+BREAK, clicar no Break Mode,
ou pressionar F5 enquanto seu programa estiver sendo
executado.
 Uma declaração em uma linha de código gera uma
interrupção de erro em tempo de execução e tipo de
depuração é escolhido na caixa de diálogo que irá aparecer.
Breakpoints - Um breakpoint é um marcador em seu código que
diz ao Visual Basic para suspender uma execução. A inserção de
um breakpoint em um lugar é feita quando você suspeitar de um
problema, permitindo que você pare seu programa e use as
ferramentas de depuração para investigar. Os breakpoints são
temporários e não são salvos em seu código. Para inserir um
breakpoint:
 Posicione a inserção apontando em qualquer lugar em uma
linha do procedimento onde a execução de programa é para
ser paralisado. Nota: você não pode fixar breakpoint em
linhas que contem um código não executável como
comentários, declarações de uma declaração, ou linhas em
branco.
Use qualquer um dos métodos seguintes para adicionar um
breakpoint:
 No menu depurar, clique no botão breakpoint.
 Aperte a tecla F9.
 Clique no botão de breakpoint e depurar na barra de
ferramentas.
 Clique com o botão do lado Direito em uma linha de código
e clique no botão breakpoint no menu de atalhos.
65
 Clique na barra do indicador de Margem próximo à linha de
código.
O breakpoint é adicionado e a linha ganha uma cor no definido no
breakpoint na caixa de diálogo no ToolsOptions. Você poderá usar
o mesmo procedimento acima para limpar um breakpoint do
código. Uma alternativa seria de clicar no menu depurar, selecione
a opção para limpar todos os breakpoints e remova todos os
breakpoints do seu código.
Declaração de parada - A declaração de Parada é semelhante a um
breakpoint, porém ele não executa o resto do código que não foi
marcado até que ele seja removido. As declarações de parada
deverão ser usadas com precaução. Esquecendo de remover as
declarações de Parada no código isso poderá resultar em problemas
futuros.
Barra de ferramentas depurar - Uma vez a depuração executada
em seu programa a paralisação é feita próximo a um ponto que você
está imaginando que um problema está acontecendo, você pode usar
as ferramentas de depuração fornecidas pelo Visual Basic para
investigar e encontrar os problemas. Estas ferramentas incluem a
barra de ferramentas de depuração, a janela de Relógio, a janela
Imediata, e a Pilha de chamadas. A barra de ferramentas de
depuração oferece um acesso rápido a várias e mais freqüentemente
características usadas para depuração.
Estas ferramentas, da esquerda para a direita, seguem abaixo:

 Botão Design Mode - botão entrar ou sair do modo de
Projeto.
 Start - Executa o procedimento que está atualmente
selecionado. Se estiver com breakpoints, o botão de
comando deverá ser pressionado para que ele continue a
66
execução do código.
 Break - Pára a execução de um programa temporariamente.
Clique no botão continuar retornar a execução do programa.
 End - Pára de executar o programa e retorna ao modo de
projeto.
 Breakpoints - Podem ser inseridos ou removidos. Um
breakpoint é um lugar no código aonde o VBA irá
automaticamente parar a execução do código e entrar no
modo de parada.
 Step Into - Executará a próxima linha de código, passo a
passo através de cada linha seqüencialmente. Se o código
fizer uma chamada a um outro procedimento, o passo a
passos será feito em cada linha deste novo procedimento
chamado.
 Step Over - Executará a próxima linha de código, passo a
passo através de cada linha de código seqüencialmente. Se o
código fizer uma chamada a um outro procedimento, este
procedimento será executado completamente antes do passo
a passo para a próxima linha de código do primeiro
procedimento.
 Step Out - Executará os procedimentos remanescentes e os
breakpoints atuais na próxima linha ao chamar o
procedimento.
 Janelas locais - Exibem o valor corrente de cada variável
local.
 Janela Imediata - Exiba a janela Imediata se ele não for
exibida. A janela Imediata permite a execução de código ou
a busca de valores enquanto a aplicação estiver no modo
break.
 Janela de Relógio - Exiba a janela do Relógio se ela não for
exibido. A janela do Relógio exibirá os valores das
67
expressões selecionadas.
 Relógio Rápido - Exibe o valor corrente da expressão
através do cursor enquanto estiver no modo break. A
expressão pode ser facilmente adicionada para a janela do
Relógio.
 Call Stack - Exiba a caixa de diálogo Call Stack se ele não
for exibido. Enquanto estiver no modo Break, o Call Stack
listará o procedimento ativo atualmente chamado
apresentando uma caixa de diálogo que mostrará todos os
procedimentos que já foram executados e chamados, mas
não os executará.
Watch Windows - A janela do Relógio permite que você monitore
o comportamento de uma variável ou expressão que o programa
estiver executando. Você pode entrar com expressões no relógio
para dizer ao VBA que a variável ou as expressões deverão ser
monitoradas. O VBA irá monitorar as expressões que você escolheu
e, quando o programa entrar no modo Break, dirá a você seus
valores (se eles estiverem dentro do contexto). Você também ter no
VBA o modo break quando uma das expressões do Relógio
encontrar um valor transitando para verdadeiro ou para falso ou
quando tiver este valor mudado. Isto é especialmente útil para
visualizar as mudanças de uma variável dentro de um laço. Quando
utilizado junto com Relógio Rápido (veja Usar o Relógio Rápido e
a Janela Imediata), a janela do Relógio é uma ferramenta eficaz
para detectar e fixar erros.
Janela imediata - Use a janela Imediata para procurar variáveis,
valores de propriedade de objeto, e para executar o código. Por
exemplo, durante a depuração ou teste do código, você poderá usar
a janela Imediata para testar procedimentos, avaliar expressões, e
atribuir novos valores para as variáveis ou propriedades. A
informação de exibição na janela Imediata resulta as declarações de
68
depuração que você colocou no código (método Debug.Print) ou o
comando ou o que você escreveu diretamente na janela.
Para avaliar as expressões, você visualizará seus valores. Qualquer
expressão válida pode ser avaliada usando a janela Imediata,
inclusive expressões envolvendo propriedades.
Call Stack - O Call Stack cria uma lista de procedimentos que irá
localizar o fluxo do código através de múltiplos procedimentos
chamados ativos. Os procedimentos chamados ativos são os
procedimentos na aplicação que foram iniciados, mas não foram
terminados. Usando esta ferramenta, a seqüência correta dos
procedimentos podem ser verificados. Por exemplo, um
procedimento pode chamar um segundo procedimento, que pode
chamar um terceiro procedimento - todos antes do primeiro
procedimento foi completado. Tais procedimentos chamados
podem ser difíceis de serem seguidos. O Call Stack mostra este
fluxo a você. Você poderá exibir as pilhas de chamadas quando seu
código estiver em modo break.
Este procedimento mostrará como configurar um Tag Monitor.
Lab – Ferramentas 1. No editor do VBA para o RSView32, ligue a caixa de

de depuração para ferramenta de depuração para selecionar
VBA em RSView32 ViewToolbarsDebug.
2. Entre com os seguintes procedimentos:
Public Sub PartsTotalizer ()
Dim Store1 As Integer
Dim Total As Integer
msgbox "This will totalize number of parts made"
For x = 1 To 3
Storel = InputBox("Please enter parts made on Line " & x)
Total = Store1 + Total
Next x
msgbox "The total number of parts made is " & Total
End Sub
69
3. Clique em algum lugar dentro deste procedimento e clique
no Run Sub/UserForm na barra de ferramentas de
depuração. O procedimento perguntaria por três números e
dá a você um total. Na primeira vez, assumindo que você
entrou com valores inteiro válidos, seu procedimento
funcionaria sem erros. AVISO: Quando você roda o
procedimento de dentro do ambiente do editor de
RSView32. Quando você estiver acabado retorne para o
editor VBA, clicando no ícone do Visual Basic que fica na
barra de tarefa do Windows.
4. Retorne ao editor VBA
5. Abra a janela Watch selecionado da janela View-Watch.
6. Dentro da janela View-Watch clique com o botão da direita
e selecione “Add Watch...”. Para uma expressão, tipo
“Store1” (sem aspas) e clique OK.
7. Seguindo um procedimento similar, adicione uma variável
TOTAL.
8. Sua janela Watch deveria aparecer o seguinte:
9. Adicione um BreakPoint (ponto de quebra) para a terceira

linha do seu procedimento (abaixo das duas linhas “DIM”).
10. Rode o procedimento clicando em Run Sub/UserFom. O
procedimento deveria ir para dentro do modo Break e
pararia na linha do ponto de quebra com uma indicação em
amarelo. Esta indicação diz a você que esta linha do código
será executado este passo quando o botão Step Into for
clicado.
11. Note que a janela Watch que os valores das duas variáveis
70
estão agora referenciadas como Integer e atualmente estão
com o valor ZERO. Também, note que se você passar o
cursor do mouse sobre uma das variáveis na janela de
código que uma “dica sobre a ferramenta” (tooltip) irá
aparecer dizendo a você o valor das variáveis.
12. Passe através das linhas do código no procedimento
repetidamente clicando no botão Step Into e clicando em
OK e/ou entrando com números dentro das caixas de
entrada quando apropriado. Você deveria estar habilitado a
sentir como estas ferramentas de depuração poderiam ser
usadas para passar através dos procedimentos, ajudando-o a
encontrar erros, caso existissem.
13. Quando você estiver confortável com estes procedimentos
de depuração, clique no botão Reset sobre a barra de
depuração para terminar o procedimento.
14. Feche a janela Watch e abra a janela Immediate clicando na
janela ViewImmediate.
15. Inicie o procedimento novamente. Passe através dos
procedimentos até você ter entrado com um valor para a
“linha 2”. Note, como antes você pode passar o cursos pelas
variáveis e visualizar seus valores. Desta vez, Store1 seria
igual ao valor que você colocou. Tipo “?Store” (sem aspas)
na janela Immediate e pressione ENTER. Isto deveria
Mostrar o mesmo valor e mostrar a você um uso para esta
janela, mostrando os valores das variáveis.
16. A janela Immediate pode ser usada também para trocar
variáveis durante o modo Break. Tipo “Store1=99”(sem
aspas) dentro da janela Immediate e pressione ENTER.
Você deveria estar apto a verificar que o valor de Store1 tem
sido trocado para 99 e como você continua executando o
procedimento este valor será usado até Store1 é escrito
71
novamente. Este é outro uso da janela Immediate, trocando
os valores das variáveis no modo break.
17. Remova o BreakPoint de seu procedimento
18. Adicione linha e código para seu procedimento que mostrará
o valor da variável total para a janela Immediate antes dos
cálculos matemáticos estão realizados nesta variável e
posteriormente faça de novo. Test Run seu procedimento e
verifique a funcionalidades.
Manipulação de erro Às vezes erros acontecem quando seu programa for executado, e
em código de VBA freqüentemente estes erros não podem ser evitados. Por
exemplo, um procedimento poderia tentar ler o valor de uma
etiqueta (label) de RSView32 que está em erro, ou sua aplicação
poderia tentar abrir um arquivo que não existe no sistema do
usuário. Para uma lista de todos os erros que são “armadilhas”
(trappable) em VBA, veja "Erros de Trappable" em Ajuda de
VBA.
Se você estiver executando um programa no ambiente de
projeto do VBA e um erro de execução acontecer sem que a
interrupção de erro esteja habilitada, o VBA exibirá uma
mensagem e o permitirá entrar no modo Depuração, utiliza-se
de uma referência de ajuda, ou terminar a aplicação. Se você
não estiver com a interrupção de erro habilitado e acontecer um
erro de execução enquanto seu procedimento estiver sendo
executado, o VBA exibirá uma mensagem de erro e a aplicação
e terminada (o código "travará").
Você pode escrever um código que irá fazer a manipulação dos
erros durante a execução e então permitir a correção em
qualquer situação, iniciando uma ação para o usuário, ou
salvando os dados antes de terminar o programa. A manipulação
72
de erros deste modo faz com que sua aplicação se torne muito
mais robusta e permita uma saída sem maiores problemas,
ambos os casos são qualidade muito apreciada por usuários.
Em declaração de Erro - Em uma declaração de Erro a
interrupção de erros e habilitada e é especificado o salto durante
a execução quando um erro acontecer. Por exemplo, a
declaração "Em Erro GoTo CheckError" executará um salto
para o código de seu programa intitulado como "CheckError",
que executará tipicamente um código de manipulação de erros,
seguido por uma declaração que ira retomar e indicar onde o
procedimento deverá continuar. A declaração “Em Erro Retoma
Próxima” irá ignorar os erros. Se um erro de execução
acontecer, o aplicativo irá continuar com a próxima linha.
A declaração "On Erro GoTo 0" desabilita o tratamento dos
erros.
Uma vez programado o tratamento dos erros, estes terão seus
valores fixados, eles estarão habilitados até que execução do
procedimento termine ou o tratamento de um erro acabe sendo
inválido.
Objeto Err - O objeto erro contém as informações sobre um
erro que acabou de acontecer. O objeto Err tem suas
propriedades e métodos que você pode verificar assim que o
erro acontecer, para limpar um valor de erro, ou para causar um
erro.
Propriedades
 Number - A propriedade Número é um inteiro que
indica o último erro que aconteceu. Em alguns casos, seu
manipulador de erros poderá ser capaz de corrigir um
erro e continuar o procedimento sem interromper o
usuário. Caso contrário, notificará o usuário de um erro,
e então tomar uma ação baseada na resposta do usuário.
73
 Description - A propriedade de descrição é uma string
que contém a descrição do erro.
 Origem - A propriedade origem contém o nome da
aplicação do objeto que gerou o erro. Por exemplo, se
você acessar o Microsoft Excel e ele gerar um erro, o
Microsoft Excel irá apresentar um erro no Err.Number
para que o código corrija e fixe o Err.Source para
Excel.Application.
 Clear - O método Clear limpa um erro, colocando o
valor do Err.Number anterior para 0. Use este método
principalmente quando você manipular erros nas linhas.
 Raise - O método Raise causa um erro. Para manter o
código do duplicado do errortrapping, use o método de
Raise para passar por um erro e retornar de volta ao
procedimento que irá chamar ou para testar seu próprio
código de manipulação de erros.
Resume - Use a declaração resume para especificar onde sua
aplicação deverá retomar um procedimento depois de manipular
o erro. Existem três variações na declaração resume:
 Resume - Retorna para a declaração que causou o erro.
Use esta declaração para repetir uma operação depois de
corrigir o erro.
 Resume Next - Retorna a declaração imediatamente
seguindo o que causou o erro.
 Resume Line ou Label - Retorna a um número
especifico de linha ou label.
Resumo de Manipulação de erro e Exemplo - O VBA usa o
objeto Err object como um mecanismo normal para lidar com
erros. Quando o modelo de objeto do RSView32 encontra um
erro, ele indica o erro usando este mecanismo que e um
mecanismo normal do VBA. Se você não criar uma
74
manipulação de erros, durante a execução do VBA o
manipulador de erros exibirá um erro de execução para o
usuário, avisando que o procedimento irá terminar
inesperadamente. Em alguns casos, esta ocorrência não seria
aceitável.
O código seguinte é um exemplo do que acontece quando uma
seqüência de dados que não tem nenhum tipo de manipulação de
erro, e este gera um erro. Assuma que a tag do RSView32 Tag1
não existe. Quando este procedimento for executado, o erro
(tentando colocar uma variável para uma tag que não existe)
será interceptado pelo manipulador de erros durante a execução
do VBA. O VBA exibirá uma mensagem com um erro de
execução em um caixa de diálogo, e então irá parar a seqüência
de dados (o código "travara"). Qualquer código adicional no
procedimento nunca seria executado. Isto devia ser SEMPRE
evitado.
Sub ExampIeBadErrorHandling()
Dim r As Single
r = gTagDb.GetTag("Tag1 ").Value
. . . other code. . .
End Sub
Como alternativa, o código seguinte usará a manipulação de

erro e exibirá pelo menos uma mensagem para o usuário que
existe um problema. Depois do erro ser detectado, uma
mensagem indicando o número do erro e a descrição será
informada para o usuário, e a execução de código retornaria a
linha depois do que causou o erro:
Sub ErrorHandling()
On Error GoTo Handler
Dim r As Single
75
r = gTagDb.GetTag("Tag1 ").Value
. . . other code..
Exit Sub
Handler:
msgbox "Error number " & Err.Number & ", " & Err.Description
Resume Next
End Sub
No procedimento anterior, note o uso do seguinte:

 "Em Erro GoTo Handler" - Isto e uma declaração que
esta indicando que o "Handler:" é um label que ira saltar
durante um erro de execução no procedimento.
 "Exit Sub" - Isto e uma declaração que fará com que a
seqüência de dados ou procedimento seja terminado de
forma que o restante do código (o manipulador de erro)
não seja executado normalmente como parte do
procedimento.
 "Handler:" - Isto é um label que fará com o código salte
e um erro durante a execução acontecer.
 "Resume Next" - Este diz ao procedimento do VBA para
retornar e executar a linha do código imediatamente
seguindo a linha de código que causou o erro durante sua
execução.
Lab – Manipulando 1. Remova o breakpoint que você inseriu no procedimento
erros no VBA para PartsTotalizer.
RSView32 2. Rode o procedimento novamente e verifique que
procedimento ele roda sem erros tão longe quanto você
forme um número de exemplos válidos dentro das caixas
de entrada (InputBoxes) e não clique no botão CANCEL.
3. O que acontece se você clicar no botão CANCEL
quando estão perguntando por um número? Qual é
76
especificamente o número do erro e descrição?
4. Clique no botão “End” na caixa de erro e rode o
procedimento novamente. Nesta hora entre com
caracteres alfanuméricos em vez de um número. Você
pegaria o mesmo erro, numero 13 “Type mismatch” (tipo
não válido, não bate) porque o procedimento está
esperando um número inteiro porque Store1 foi
declarado com Inteiro.
5. Modifique o procedimento PartsTotalizer para incluir
um código de manipulação de erro para recuperar-se
deste tipo de erro. Seu código pode ter:
 Uma declaração On Error no topo do procedimento para
identificar a “etiqueta” (Label) em caso de erro.
 Uma seção de “manipulação de erro” (error-handling)
que checa para ver se o”type mismatch” é um erro que
foi ocorrido. Se for, mostrar uma mensagem, “Entrar
com um Dado válido” e retornar para a linha que gerou o
erro.
6. Seu procedimento deverá ficar parecido com este:
Public Sub PartsTotalizer()
On Error GoTo error_handler
Dim Store1 As Integer
Dim Total As Integer
msgbox "This will totalize number of parts made"
For x = 1 To 3
Store1 = InputBox("Please enter parts made on Line " & x)
Total = Store1 + Total
Next x
msgbox "The total number of parts made is " & Total
Exit Sub
error_handler:
If Err.Number = 13 Then
msgbox "Enter valid data"
77
Resume
End If
End Sub
7. Rode o procedimento novamente. Seu procedimento

deverá agora, recuperar os erros que causam uma “pane”
antes da sugestão do usuário para reentrar com um novo
dado e continuar.
8. Adicione um Breakpoint para o procedimento como
você fez antes e passe através das linhas dos códigos no
mode Break para assistir como um manipulador de erros
(error handler) é executado.
78
Coleção de Objetos do RSView32 Capítulo 7
Coleção de Objetos do RSView32
Coleções: Introdução - No Modelo de Objetos do RSView32, alguns dos

objetos são consideradas “coleções". Se referem ao diagrama de
Modelos de Objetos no Capítulo 3 deste manual. Os objetos do
RSView32 que são consideradas coleções são:
 AlarmThresholds
 Channels
 DataLogModels
 DataLogNarrowRecords
 DataLogWideRecords
 DataLogTagValues
 Folders
 Nodes
 StringList
 Tags
Basicamente, uma coleção é um "grupo" de outros objetos. A
coleção de tags é um grupo de um ou mais objetos de tags,
coleção de Pastas é um grupo de um ou mais objetos de Pasta,
etc. Trabalhando com estes objetos de uma coleção e possível
fazer um código mais fácil e muito mais eficiente.
Criando uma Coleção de tags - Para criar uma coleção de tags,
você primeiro precisaria declarar uma variável de objeto de
coleção como uma coleção de tags. Você teria que criar também
sua coleção como uma nova "instância" do objeto de tags
usando o comando de Conjunto. Por exemplo, as linhas
seguintes de código declararam que um objeto da coleção de
tags (grupo de tags) com o nome Receita 1 criariam uma
coleção (embora estaria vazio neste momento):
79
Dim Recipe1 As Tags Set Recipe1 = New Tags
Povoando a Coleção - Uma vez uma coleção declarada e

parametrizado como igual a uma "Nova” coleção, a coleção
pode ser "povoada" com tags reais da base de dados do
RSView32. De antemão isto pode ser feito usando o método
Add do objeto de coleções como a seguir:
Recipe1.Add gTagDb.GetTag("mem1")
No exemplo anterior, o método Add da coleção de tags foi

usado para adicionar tags para as coleções (como Recipe1.Add
gTagDb.GetTag("mem1")). Um caminho muito mais poderoso e
mais fácil para criar uma coleção de tags é usando métodos
específicos que alguns objetos disponibilizam. Os métodos
seguintes retornam valores para os objetos de tags:
TagDb.CreateTags, TagDb.BrowseForTags,
TagDb.QueryForTags, e Folder.Tags.
Usando o método TagDb.QueryForTags, você poderá usar os
Wild Cards “*” e "?" na busca de strings. Por exemplo, a linha
seguinte povoaria uma coleção de tags chamada Recipe1 com as
mesmas tags que o exemplo anterior criou (mem1-mem4):
Set Recipe1 = gTagDb.QueryForTags("mem?")
Provendo referência Etiquetas na Coleção - Uma vez estas

tags adicionadas a sua coleção, eles podem prover referências
através de um número de índice (começando em 1, por
exemplo), pretensiosamente a coleção acima foi criada e
"povoada", a linha seguinte irá exibir uma caixa de mensagem
80
com o valor da terceira tag da coleção:
MsgBox Recipe1 (3).Value
Uma vez existindo uma coleção e possível ter um caminho

muito mais eficiente para trabalhar com os membros das
coleções através de uma declaração For Each... Next. Este tipo
de declaração no VBA permite que você pare um laço de forma
muito mais eficaz através de cada membro de uma coleção,
interagindo com cada membro de algum modo. Por exemplo, o
exemplo seguinte usa uma variável chamada DADOS para
manter o caminho de cada membro da coleção Recipe1,
exibindo cada nome e cada valor dos membros (um de cada vez)
em um MessageBox:
Dim DATA As Tag

For Each DATA In Recipe1
MsgBox DATA.Name & "_" & DATA.Value
Next DATA
Uma diferença em povoar uma coleção de tags usando o método

Add do objeto de Coleção ou o método QueryForTags do objeto
TagDB é que as tags podem ser localizadas em posições
“diferentes" na coleção. Anteriormente, dois exemplos foram
usados para povoar uma coleção de tags, um usando o método
Add da coleção de tags e o outro exemplo usando o método
QueryForTags do objeto TagDB. No exemplo criado, usando o
método somar, a tag meml, entretanto seria um número de um
índice atribuído na ordem em que as tags seriam "adicionadas",
1-4. Porém, quando o método QueryForTags for usado, os
números dos índices 1-4 serão atribuídos para as etiquetas
mem4, mem3, mem2 e mem1 respectivamente. Em outras
81
palavras, o número de índice e o nome da tag poderiam precisar
ser monitorados pelo procedimento do VBA para verificar se a
tag esta correta e se está provida de uma referência antes de
qualquer código atuar naquela tag.
Otimizando a escrita Quando trabalhamos com a Interface de Modelo de Objeto do

de tags RSView32 (ROI), existem abordagens diferentes ao ler e ao
escrever dados em um tag. Três abordagens diferentes devem
ser verificadas, a sintaxe simplificada, o objeto individual da
tag, e a coleção de objetos da tag.
Sintaxe simplificada - A sintaxe simplificada é bastante usada e
freqüente por causa de sua simplicidade com através de
pequenas abordagens individuais adicionais em cima de uma
demanda. Um exemplo de código desta sintaxe a seguir:
gTagDb.GetTag("Mytag").value = 10
Quando esta linha for executada, o valor 10 é escrito para a

etiqueta e este estando configurado para ser uma tag de
dispositivo, então o valor 10 é escrito para o dispositivo. Este
tipo de sintaxe pode ser usado para ler e escrever todas as
propriedades de uma tag, mas é muito custoso e ineficiente
quando acessado para múltiplas propriedades do mesmo objeto
de tag. Isto é porque a tag precisa ser recuperada da coleção
toda vez que uma propriedade prover uma referência no código,
e um objeto é então criado e então um tempo muito grande e
desperdiçado quando este código e executado.
Objeto de tags individuais - O objeto de tags individuais é

usado quando o designer da aplicação entender quando e para
ser usado o comando de um Conjunto no VBA. O comando de
um Conjunto é exigido quando inicializamos objetos, mas não é
82
exigido quando inicializamos variáveis. O mesmo exemplo de
código, mas agora usando a sintaxe de objetos de tag a seguir:
Dim Mytag as Tag

Set Mytag = gtagDb.GetTag("MyTag")
Mytag.value = 10
Como você pode ver existem visualmente mais linhas de código

usando esta abordagem. Porém, se existir uma necessidade de se
colocar uma tag, ou para acessar mais de uma propriedade de
objeto de uma tag. Isto e muito bom, pois será executado fora da
sintaxe simplificada porque o objeto é criado na memória
apenas uma vez. A sintaxe simplificada usa um objeto
implicado, e deve continuamente pré-dimensionar-se a este
objeto com cada referência para o mesmo. O objeto individual
da tag só será destruído quando o objeto de Mytag conflitar pelo
âmbito ou explicitamente falando inserindo um valor
inexistente, como a linha seguinte de código.
Set Mytag = Nothing
Coleção de Objetos de tag - A coleção de tags é muito superior

em relação a qualquer outro, pois a coleção cria todas as tags na
área de memória de uma só vez, além disso, ele disponibiliza
uma forma para bloquear a escrita de dados. Isto é realizado
através da propriedade PendingValue e do método
WritePendingValues. Um exemplo de código para escrever
valores múltiplos em um bloco se parecerá com:
Dim Mytag as Tag

Dim AIIMytags as Tags
Set AIIMytags = gTagDb.QueryForTags("Setpoints"")
For Each Mytag in AIIMytags 'loop through all tags in the AIIMytags
83
collection
‘ initializing the PendingValue does not perform a
' write to the PLC device
Mytag.PendingValue = 0
Next Mytag
' blocks all pending values into one request to RSLinx
' this example waits for the write to complete
' Please note the actual write behavior is dependent an
' the node definition DDE/OPC or Direct
AIIMytags.WritePendingValues RoWait
Os exemplos anteriores criaram uma coleção de tags com todas

as tags na base de dados do RSView32 que se iniciam com a
palavra Setpoints. Uma vez estas coleções criadas, o
procedimento armazenaria todas as etiquetas da coleção,
entretanto, colocaria a propriedade PendingValue para zero.
Então, uma vez o laço completo, o procedimento escreveria para
todos os valores pendentes para as etiquetas reais. Isto é o
método mais eficiente para escrever valores para múltiplas tags
em uma base de dados no RSView32.
Resultados de comparação - Mudanças no RSView32 6.2
incluem uma escrita aperfeiçoada de tags quando usada em uma
coleção de tags através do método WritePendingValues. Este é
o método mais eficiente de escrever múltiplos valores de tags
em um PLC.
Usando a sintaxe simplificada para escrever valores múltiplos é
extremamente ineficiente, e devia ser evitado na maioria dos
casos. A sintaxe simplificada pode ser eficaz quando usada para
prover uma referência a uma propriedade de uma tag.
Utilizar uma coleção de objetos de tags e escrever para a
propriedade de valor em vez de usar a propriedade
PendingValue não é recomendado para se ter um processamento
mais otimizado, e devia ser evitado sempre que possível. Porém,
84
existem ainda vantagens de desempenho para este tipo de
abordagem utilizando a sintaxe simplificada, como a tag não
precisa ser verificada antes o objeto de tag, este não precisa
estar implicitamente criado e seria destruído ao escrever as
chamadas.
Lendo tags Introdução - O modelo de objeto do RSView32 expõe o valor

Eficazmente de uma tag através da propriedade de Valor do objeto de tag.
Acessando a propriedade de Valor sem antes chamar o método
ScanOn do RSView32 para ler o valor da fonte de dados da tag
(para Drivers Diretos o valor é lido do PLC; e para os servidores
DDE e OPC o valor é lido do servidor). Isto e freqüentemente
chamado de uma "Leitura com um tiro". Se os valores de muitas
tags são lidos desta maneira, o tempo para ler todos os valores
de tags pode ser significante. Isto é devido ao fato que os
valores de tags estão sendo individualmente lidos. Isto é, os
solicitados não estão sendo bloqueados juntos.
Quando se lê os valores de muitas tags, é melhor adicionar as
tags para uma coleção e pôr a coleção em uma varredura
(Tags.ScanOn). Isto fará com que o RSView32 bloqueie os
pedidos junto as tags. Quando RSView32 fizer uma varredura
em um tag, ele esconderá o último valor varrido na "tabela de
valores". Para Drivers Diretos, a tabela de Valor é atualizada
baseada na classe de varredura das tags. Para servidores DDE e
OPC, a tabela de Valores é atualizada quando o servidor
informar ao RSView32 que o valor da tag mudou. Quando a
primeira tag for colocada na varredura, o valor é imediatamente
lido da fonte de dados e a tabela de Valores é atualizada. Note
que outros subsistemas como (gráficos, alarmes, datalogging,
etc) do RSView32 podem colocar as tag em varredura. Se uma
tag está em varredura, lendo a propriedade de Valor será
85
recuperado o último valor varrido na tabela de Valores. A
atualização do valor depende da taxa em que o valor da etiqueta
é solicitado.
Exemplos - Os dois próximos procedimentos demonstram que a
leitura de valores nas tags são muito mais rápida se as tags
forem colocadas primeiro em varredura. A sub-rotina pesquisa o
banco de dados para todas as tags da pasta device e então quanto
tempo ele leva para ler e produzir os valores das tags para a
janela Imediata. A primeira seqüência de dados lê os valores das
tags sem colocar as tags em varredura. A segunda seqüência de
dados coloca as tags em varredura antes de ler os valores da tag.
Sub OneShotReads()
Dim oTags As Tags
Dim oTag As Tag
Dim fCount As Single
'Query the tag database for all tags in the Device folder
Set oTags = gTagDb.QueryForTags("device\*”)
'Get the current time fCount = Timer
'Loop through all tags in the collection
For Each oTag In oTags
'Output the Tag name and value to the Immediate window
Debug.Print oTag.Name & " _ " & oTag.Value
Next
'Calculate and display the time to read the tag values
fCount = Timer - fCount
msgbox "Time to get values: " & fCount & " seconds. "
End Sub
Sub ScannedReads()
Dim oTags As Tags Dim oTag As Tag
Dim fCount As Single
'Query the tag database for all tags in the Device folder
Set oTags = gTagDb.QueryForTags("device\*")
'Get the current time fCount = Timer
86
'Place all of the tags in the collection on scan
oTags.ScanOn roWait
'Loop through all tags in the collection
For Each oTag In oTags
'Output the Tag name and value to the Immediate window
Debug.Print oTag.Name & " = " & oTag.Value
Next
'Take all of the tags in the collection off scan
oTags.ScanOff
'Calculate and display the time to read the tag values
fCount = Timer - fCount
msgbox "Time to get values: " & fCount & " seconds. "
End Sub
Na segunda sub-rotina, o método oTags.ScanOn usa o

parâmetro "roWait". Este assegura que as tags na coleção são
todas colocadas em varredura antes do método retornar. É
melhor usar o "roWait" e evitar usar "roNoWait". O "roNoWait"
implicara o método Tags.ScanOn para iniciar e colocar as tags
em varredura, porém a chamada deste método retornará
imediatamente e continuará a processar a sub-rotina. Isto pode
implicar solicitação da propriedade valor antes da tabela de
Valores das tags ser atualizada. Este resultado do estado de uma
tag será reportada como "Stale" ou "Uninitialized", com o
último valor conhecido (se ele estivesse previamente varrido). O
"roNoWait" pode ser usado em sub-rotinas onde as tags
recebem bastante tempo para serem colocadas em varredura e
atualizadas, antes que o valor seja pedido.
87
Lab – Usando 1. Em seu editor VBA, para RSView32 em
coleções e “Projeto_VBA”, entre com o seguinte procedimento em
otimizando “ThisProject” que fica em RSView32 Objects.
escrita/leitura de Tag Sub AssignTagsToCollection()
Dim Recipe1 As Tags
Set Recipe1 = New Tags
Set Recipe1 = gTagDb.QueryForTags("device\int*")
Dim DATA As Tag
For Each DATA In Recipe1
msgbox DATA.Name & "=" & DATA.Value
Next DATA
Set Recipe1 = Nothing
End Sub
2. Salve seu código VBA e teste o procedimento. Isto

criaria uma coleção de tags, populando a coleção com
todas as tags na base de dados do RSView32 que
começam com DEVICE\INT, e então mostrar caixas de
mensagem na qual incluir cada tag com seu nome e
valor.
3. Mudar para o RSView32 e usar a linha de comando para
trocar a soma de valores das Tags DEVICE\INT0,
DEVICE\INT1 e DEVICE\INT4 (cada qual usando o
comando DEVICE\INT0 = 24, por exemplo). Volte para
o editor VBA, Test Run seu procedimento e confirme
que os valores corretos estão sendo mostrados.
4. Usando os exemplos dados nos capítulos anteriores a
este, adicione um código necessário para melhorar a
performance da leitura dos valores deste procedimento.
Suas modificações teriam que fazer com que a aplicação
de tags ligue a varredura antes da leitura dos valores e
desligar a varredura posteriormente. Embora que você
não tenha notado diferença alguma quando rodou seu
88
código alterado, use a coleção de tags e aplique-las
ligando e desligando a varredura (Scan) é altamente
recomendado para melhorar a performance de seus
procedimentos em VBA.
5. Uma vez satisfeito com o procedimento atual, apague a
linha de código que causou as caixas de mensagem para
serem mostradas. Adicione uma linha de código para
que o nome, endereço e valor de cada tag será impresso
na tela da janela Immediate. Teste em Run seu
procedimento e localize os erros se necessário.
6. Adicione um código para seu procedimento para induzir
o usuário para um valor a ser carregado para cada uma
das tags na coleção. Seu código melhoraria a escrita de
tags, fazendo uso das propriedades PendingValue e
métodos WritePendingValues. Como antes, seu código
também imprimirá o nome, endereço e valor das tags na
janela Immediate.
89
Acessando modelos de objetos para controle externo ao RSView32 Capítulo 8
Acessando modelos de objetos

para controle externo ao RSView32
Introdução: Você pode acessar o Modelo de Objeto do RSView32 através de

um controlador de automatização externa como Visual Basic ou
Visual C++. Você poderá acessar também o Modelo de Objeto
do RSView32 por uma outra aplicação que suporte o VBA
como Microsoft Word e o Excel.
A fim de fazer isto, dentro de uma aplicação externa ao
RSView, você teria primeiro que colocar uma referência para o
Modelo de Objeto do RSView32 (em VB, isto seria feito através
da seleção de menu no ProjectReferences). Você criaria também
um novo objeto na Aplicação do RSView32 e colocar uma
variável de objeto de Projeto para o RSView32 com o atual
projeto carregado. O exemplo seguinte mostra como realizar isto
no VB ou VBA
Dim RsvApp as RSView32.Application

Dim RsvProj as RSView32.Project
Set RsvApp = New RSView32.Application
Set RsvProj = RsvApp.ActiveProject
'Continue on with code using RsvProj
No exemplo acima, seu código continuaria a prover referências

para os objetos do RSView32 com o RsvProj como um prefixo.
Dentro do VBA no RSView32, os nomes dos objetos do
RSView32 têm uma letra "g" na frente deles, costumava indicar
estes são "objetos Globais (como gCommand, gActivity, etc).
Em um controlador de automatização externa, estes objetos
seriam providos sem a referências "g". Por exemplo, a linha
seguinte de código adicionado ao código de cima executará o
90
Commandline que será aberto no RSView32.
RsvProj.Command.Execute "Commandline"
Pode estar um pouco confundindo ao escrever o VB no VBA

codificando o código no editor do VBA de fora do RSView32
por causa das diferenças em sintaxe como o exemplo acima
onde "Command" é usado em vez de "gCommand" e
"Command" têm que ser prefixado com "RsvProj.". Em outras
palavras, a linha acima de código é ser bastante diferente que se
fosse escrito no VBA do RSView32 que seria
gCommand.Execute "Commandline”: A sintaxe diferente
poderia ser indesejável e causar uma certa confusão. Algo que
podia ser feito para ajudar o VB/VBA na hora de codificar fora
do RSView32 fosse se o código pudesse ser dentro do editor do
VBA no RSView32 que propriamente é como a seguir:

Dim gProject as RSView32.Project
Dim gCommand as RSView32.Command
Set gProject = RsvApp.ActiveProject
Set gCommand = gProject.Command
gCommand.Execute "Commandline"
No exemplo anterior, declarando gCommand como um

RSView32.Commandtype de um objeto, e colocação esta
variável de objeto igual para um objeto de Comando do
RSView32 (gProject.Command), o código poderia executar
comandos do RSView32 como o gcommand.Execute sintaxe de
"comando" que ira iniciar a sintaxe no VBA do RSView32.
Embora não seja necessário e exigindo como código extra, isto
podia ser útil para um desenvolvedor porque a sintaxe seria o
91
mais próximo dos exemplos iniciais da documentação fornecida
em sistemas de ajuda do RSView32 e outras fontes de exemplos
como as bibliotecas de suporte ao Software de Rockwell.
Lab – Acessando o 1. Inicie o Microsoft Excel

modelo de objeto do 2. No Excel, mostre a barra de ferramentas clicando em
RSView32 a partir do View Toolbars Control Toolbox no menu.
VBA do Excel
3. Um clique sobre o comando Botão, encontrado na barra

de ferramentas. Em algum lugar na planilha, clique e
arraste com o cursor do mouse para criar o botão.
Quando você soltar o botão do mouse aparecerá algo
similar a esta figura.
4. Clique com o botão da direita e selecione “View Code”.

5. Uma janela similar a esta aparecerá
6. Neste editor VBA, selecione no menu Tools 

Reference e configure uma referência para o modelo do
92
objeto RSView32.
7. Abaixo da linha de código “Private Sub” entre com as
seguintes linhas de código para declararem variáveis.
Dim gProject as RSView32.Project
Dim gTagDb as RSView32.TagDb
Dim gActivity as RSView32.Activity
Dim gCommand as RSView32.Command
8. Entre o começo e fim deste procedimento (linha “Private

Sub” e “End Sub”), adicione o código abaixo:
Private Sub CommandButtonl Click()
Set gProject = RsvApp.ActiveProject
Set gCommand = gProject.Command
Set gTagDb = gProject.TagDb
Set gActivity = gProject.Activity
End Sub
9. Neste ponto, suas variáveis de objeto declaradas na
aplicação na área General Declaration e o evento
CommandButton1 Click é configurado a referência dos
objetos destas variáveis.
10. Primeiro garanta que o RSView32 está iniciado com o
“projeto_VBA”, se em teste Run seu procedimento do
editor VBA ou retorne a planilha Excel, saia do modo de
Projeto (Design) e clique o botão para rodar seu
procedimento. Nada notável deve ter ocorrido neste
ponto porque seu procedimento está simplesmente
configurando variáveis, mas ao menos você estará
checando seu código para tipógrafo (encontrar erros de
escrita) ou outros erros óbvios neste ponto.
11. Antes da linha de código Sub End adicione o seguinte:
gCommand.Execute”Commandline”
12. Quando você rodar seu processo agora você deveria
93
notar que o RSView32 abra um Command Line. Isto foi
concluído pelo seu procedimento criado no VBA do
Excel interagindo com o modelo de objeto do
RSView32.
13. Adicione e teste o código para produzir um comando
diferente do RSView32 para ser executado do seu
procedimento do Excel (pode ser ActivityViewer,
display, etc).
14. Adicione e teste o código para produzir mensagem de
algum tipo para ser registrado para o Activity Log do
RSView32.
15. Adicione e teste o código para gerar um valor a ser lido
por uma tag do RSView32 e mostrado em uma MsgBox.
16. Adicione e teste o código para permitir um usuário entrar
com um valor em uma InputBox e ter este valor
carregado para uma tag no RSView32.
94

250 REV 00 VBA para RSView32 Manual Do Aluno

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

250 REV 00 VBA para RSView32 Manual Do Aluno

Enviado por

Direitos autorais:

Formatos disponíveis

Índice

A quem se destina o Este curso é destinado a pessoas que precisam criar ou

Introdução do VBA ao RSView32

Em um aplicativo, o VBA fornece todos os recursos possíveis

O RSView32 com VBA foi o primeiro produto a ser lançado

O RSView32 com VBA é uma extensão do produto que

Visão geral do VBA

Este formulário tem uma propriedade de cor de fundo

Public Sub Test()

As linhas de código a serem executados quando este

Dim Store1 as Integer

= (Expressão) - O sinal igual é usado para transferir um valor ou

Inputbox - Esta função é usada tipicamente para conseguir

FirstName = Inputbox (“Please enter your first name”)

No exemplo anterior, qualquer tipo de informação pode ser

MsgBox “Good Morning”

Em um uso mais avançado do MsgBox ele pode ser usado para

Store1 = MsgBox ("É seu nome Mike?", vbYesNo)

Se o usuário clicar no botão "Sim" (Yes) então a variável Store1

Store1 = 50 ‘Store a fifity in a variable named Store1

& (Companhia) - Este caracter é usado para concatenar ou

Store1 = InputBox (“Enter a number”)

_ (Sublinhado) - O sublinhado é um caracter de continuação

MsgBox “This messagebox is to inform you that” _

If...Then - Uma simples estrutura de decisão no VBA é

If Store1 = 30 Then MsgBox “The value entered is 30”

Se várias ações acontecerão, então as mesmas deverão ser

Mais opções estão disponíveis usando as declarações ElseIf e

Store1 = InputBox (“Please enter you age”)

Cases - Semelhante às declarações If...Then... a seleção de casos

Storel = InputBox("Please enter your age")

For...Next Loops - Se você quiser repetir linhas específicas de

Dim Num As Integer

Laço Do...While/Until - Se um número específico de linhas

Do While strPassword <> "Lefty"

Os dois exemplos acima exatamente estão fazendo a mesma

With...End With - Freqüentemente é desejável mudar os tempos

Usando as declarações With...End With, o mesmo código poderia

Embora existam atualmente mais linhas de código, com a sintaxe

3. Clique na ferramenta Command Button (Botão de

4. Clique com o botão da direita sobre o botão e selecione

6. Esta é uma tela de edição do VBA, que é acessado através

9. Para testar seu procedimento, clique em algum lugar na

10. Se necessário, depure alguns erros. Seu procedimento

Botão Design Mode

Celsius = (Fahrenheit – 32) * 5/9

Tenha certeza que seu código esteja correto.

Projeto do RSView32 com VBA

Antes de começar: O Modelo de Objetos do RSView32 é formado por objetos

AlarmThresholds – Coleção para acessar os limites dos

AnalogTagAlarmCfg – Objeto para ler e escrever as

Application – Representa uma aplicação ao RSView32.

Channel – Representa um canal de comunicação do RSView32.

Channels – Permite acessar para todos os canais disponíveis no

Command – Este representa o servidor de comando do

DataLog – Representa o subsistema de registro de dados do

DataLogModel – Objeto que representa um modelo de registro

DataLogModelCfg – Objeto é acostumado a ler e escrever

DataLogModels – Uma coleção de modelos de registro de

DataLogNarrowRecord – Objeto contém todas as informações

DataLogNarrowRecords – Objeto é uma coleção de objetos de

DataLogTagValue – Coleção que permite acessar informações

DataLogTagValues – Coleção que permite acessar informações