Apostila CicodeV1

Treinamento Cicode
Apostila - Junho / 2009 Ref.: 2-043.100
1
.
2
•
! ! "
! !
# $%
! & .
' $ " (")* +

,-" $
& ! *-** (.-/ ,,* 0 1
"
2
3
3
CONVENÇÕES UTILIZADAS
• 1' ' ' $ "

!
•2 '! !
! ! 4&
# + 5 " 5
• 6 ! " $ 7 8
,*.9":
" ! $ 7 8
,*$: $ ;
• 0 ! '
+ ! # '
!
<
$ 8
=
! ' !
>
= !
!
@ ? $ !&
>
= "
$ $
' >
' ?
+
$ $
4
Índice
C APÍ TULO 1 ............................................................................................... 9
INTRODUÇ ÃO A PROGRAM AÇ ÃO COM CICODE ........................................... 9
Objetivos do Capítulo ............................................................................................... 11
Os Objetivos do Curso.............................................................................................. 11
Programa do Curso .................................................................................................. 11
C APÍ TULO 2 .............................................................................................. 14
INTRODUÇ ÃO AO CICODE ......................................................................... 14
Comandos ............................................................................................................... 16
Configuração de Variáveis ........................................................................................ 19
Expressões .............................................................................................................. 20
Executando Cálculos ................................................................................................ 20
Visualização de Dados ............................................................................................. 21
Declarações Múltiplas............................................................................................... 21
Obtendo Entrada de Dados do Operador ................................................................... 22
Chamando Funções em Comandos e Expressões ...................................................... 26
Passando Dados para as Funções ............................................................................ 28
Argumentos do tipo STRING ..................................................................................... 28
Passando Múltiplos Argumentos ............................................................................... 30
Passando Argumentos Numéricos ............................................................................. 30
Passando Variáveis como Argumentos ...................................................................... 30
Retornando dados das Funções ................................................................................ 34
Executando funções quando partindo o sistema......................................................... 37
C APÍ TULO 3 .............................................................................................. 39
OPER ADORES DE VARI ÁVEI S .................................................................... 39
Classes de Operadores ............................................................................................ 41
Operadores Matemáticos .......................................................................................... 41
Operadores Lógicos ................................................................................................. 42
Operadores de Bit .................................................................................................... 45
Operadores Relacionais ........................................................................................... 45
Operador de Formato ............................................................................................... 46
Ordem de Precedência dos Operadores .................................................................... 47
C APÍ TULO 4 .............................................................................................. 49
O EDI TOR DO CICO DE ............................................................................... 49
Como iniciar o Editor do Cicode ................................................................................ 51
Criando um novo Arquivo do Cicode.......................................................................... 52
5
Uso do Goto para acessar erros ............................................................................... 52
Compilando e executando ........................................................................................ 53
Navegação por Arquivos .......................................................................................... 54
Ferramentas de Edição ............................................................................................ 59
Ferramentas de Funções.......................................................................................... 62
Preferências ............................................................................................................ 65
9. Selecione o elemento Strings, marque as opções Bold e Italic. Clique no
botão OK. Comprove sua alt ..................................................................................... 67
C APÍ TULO 5 .............................................................................................. 69
FUNÇÕES DO CICO DE ............................................................................... 69
Escrevendo Funções Simples ................................................................................... 71
Sintaxe das Funções ................................................................................................ 72
Elementos das Funções ........................................................................................... 72
Funções Public e Private (Scope) ............................................................................. 73
Declarando Funções ................................................................................................ 73
Nomeando Funções ................................................................................................. 73
Declarações ............................................................................................................ 74
Funções do tipo Void ............................................................................................... 74
Variáveis do Cicode ................................................................................................. 77
Variáveis Globais ..................................................................................................... 79
Variáveis Modulares - Module................................................................................... 80
Variáveis Locais ...................................................................................................... 81
Padrões Quando Atribuindo Nomes para Variáveis .................................................... 81
Tags de Variáveis .................................................................................................... 81
Conversão e Designação de formato para as variáveis do Cicode .............................. 83
C APÍ TULO 6 .............................................................................................. 89
EXECUTORES CO NDICION AI S ................................................................... 89
Declaração IF .......................................................................................................... 91
FOR Loop................................................................................................................ 93
Loop WHILE ............................................................................................................ 94
A Declaração SELECT CASE ................................................................................... 95
C APÍ TULO 7 .............................................................................................. 99
OUTR AS FUNÇÕES CICODE ....................................................................... 99
Objetivo do Capítulo ...............................................................................................101
Funções do Tipo Return ..........................................................................................101
Arrays 104
Sintaxe 105
Inicializando um Array .............................................................................................105
6
Dimensões de Arrays ............................................................................................. 106
Utilizando Arrays .................................................................................................... 106
Comentários .......................................................................................................... 108
C APÍ TULO 8 ............................................................................................ 111
CICODE DEBUGGER ................................................................................ 111
Objetivo do Capítulo ............................................................................................... 113
O Ambiente do Editor do Cicode ............................................................................. 113
Passo Seguinte – Avançando pelo código ............................................................... 117
APÊNDICE A ........................................................................................... 123
TÉCNIC AS DE PRO GR AM AÇ ÃO ESTRUTUR AD A ....................................... 123
Objetivos do Apêndice ............................................................................................ 125
Diagramas Lógicos de Fluxo ................................................................................... 125
Conclusão.............................................................................................................. 128
APÊNDICE B ........................................................................................... 129
GUI A DE PROGR AM AÇ ÃO NO CICODE ..................................................... 129
Introdução ............................................................................................................. 131
Definições e Convenções de Nomes ....................................................................... 131
Variáveis ............................................................................................................................................................131
Nome de Variáveis.........................................................................................................................................131
Funções................................................................................................................. 133
Formato de Arquivos de Biblioteca e Funções.......................................................... 134
Funções: ............................................................................................................................................................134
Formato de Declarações de Programa..................................................................... 135

Formatando declarações Simples ......................................................................................................................135
Formatando Declarações Executáveis ...............................................................................................................135
Formatando Expressões ....................................................................................................................................137
Comentários .......................................................................................................... 137

Programação Defensiva.......................................................................................... 137
APÊNDICE C ........................................................................................... 139
SQL, VIJEO CI TECT E ODBC .................................................................... 139
Setup da Base de Dados ........................................................................................ 141
Windows XP - Exemplo........................................................................................... 141
Como se conectar a sua Base de Dados via Vijeo Citect .......................................... 144
Utilizando a Classe de Funçoes SQL do Cicode SQL class of functions .................... 145
Exemplo Típico de uma Conexão e Query ............................................................... 145
Resumo Rápido de SQL ......................................................................................... 146
A Declaração SELECT............................................................................................ 146
Selecionando uma Tabela inteira ............................................................................ 147
A basic conditional query ........................................................................................ 147
Queries baseadas em conjuntos de dados - Operadores IN e NOT IN ..................... 148
7
Queries com condições Booleanas ..........................................................................148
Operadores AND e OR ...................................................................................................................................... 148
Querying um range de valores - Operador BETWEEN.............................................149

Querying search style - the LIKE operator ..............................................................149
Querying Tabelas Múltiplas - Unindo duas Tabelas.................................................150
A declaração INSERT .............................................................................................150
A declaração UPDATE ............................................................................................151
A declaração DELETE.............................................................................................152
Declarando Data e Hora no SQL..............................................................................152
Sintaxe Data/Hora independente Base de Dados......................................................153
APÊNDICE D ........................................................................................... 155
EXEM PLOS DE CÓDIGOS DE PROGR AM A................................................. 155
Objetivos do Apêndice ............................................................................................157
8
! " # $ #%# " & %
&
9
! " # $ #%# " & % &
10
! " # $ #%# " & % &
O Cicode é uma linguagem de programação de computador simples, fácil de utilizar

que foi projetada especialmente para aplicações de controle e monitoração. Ela é
uma linguagem estruturada, similar ao “C” ou ao Visual Basic. Entretanto, nenhum
conhecimento prévio de programação é necessário quando fazendo uso do Cicode.
Quando fazendo uso do Cicode, você tem acesso a todas as variáveis, alarmes,
tendências, relatórios, etc em tempo real de um projeto do Vijeo Citect. Além disso,
você pode utilizar o Cicode para intercomunicar-se com diversos recursos do seu
computador tais como sistema operacional e portas de comunicação.
O Cicode suporta características avançadas que incluem multitarefa preemptivo,
multi-treads e chamadas de procedimentos remotos que iremos discutir durante este
curso.
Neste curso, você irá apreender como executar uma série de tarefas. Elas estão
compreendidas em três categorias principais: comandos, expressões e funções.
'( #) *
6 ' & $ 8
- Visão Geral do Curso;
- Programa do Curso.
'(
Ao final deste Curso de Treinamento você:
- Terá um bom conhecimento do Cicode e estará apto a fazer uso do
mesmo.
- Poderá utilizar o Cicode em comandos e expressões.
- Estará habilitado para aplicar o que você aprendeu na sua aplicação.
- Poderá escrever suas próprias funções do Cicode.
- Saberá como depurar suas próprias funções do Cicode.
$ #%#
Este curso de treinamento tem uma duração de dois dias. O programa delineado
abaixo apresenta o que será coberto em cada dia
Primeiro dia
- Introdução ao Cicode
- Operadores de Variáveis utilizados no Cicode
- Editor do Cicode
- Escrita de Funções Simples
- Uso de variáveis do Cicode
- Funções de Conversão
- Arquivos de Inclusão
11
! " # $ #%# " & % &
Segundo dia
- Executores Condicionais
- Tipos de Função
- Matrizes
- Depuração de Código
12
! " # $ #%# " & % &
13
+
! " # &
14
! " # &
15
! " # &
Neste capítulo nós iremos aprender a realizar uma série de tarefas. Elas se encontram
dentro de três categorias: comandos, expressões e funções.
'( #) *
Neste capítulo você irá aprender:
• Comandos
• Configuração de Variáveis
• Expressões
• Instruções Variadas
• Obtenção de Entrada do Operador
• Chamada de funções em comandos e expressões
• Passar dados para funções
• Passar vários argumentos
• Passar argumentos numéricos
• Passar argumentos de variáveis
• Retorno de dados das funções
• Início de funções quando arrancando com o sistema
%#!
Os comandos do Cicode constituem os elementos de controle através do qual o Vijeo Citect
controla e monitora um sistema. Você utiliza estes comandos para controlar o seu sistema do
Vijeo Citect e conseqüentemente os processos na planta.
Cada comando tem seu próprio mecanismo de ativação. Os comandos podem ser emitidos
manualmente através de uma seqüência digitada pelo operador ou clicando-se em um botão
ou objeto em uma página gráfica. Podemos inclusive configurar comandos para serem
executados automaticamente:
• Quando o operador faz o login ou o logout no sistema;
• Quando uma página gráfica é acessada, quando está sendo mostrada ou quando é
fechada;
• Quando um alarme é disparado;
• Em um relatório
• Quando um evento é disparado;

Para definir um comando do Cicode, você deve inserir uma declaração (ou grupo de
declarações) no campo da execução do comando (tab horizontal Input) para um determinado
objeto.
16
! " # &
Cada declaração em um comando, usualmente executa uma única tarefa tal como
atribuir um valor a uma determinada variável, calcular um valor, mostrar uma
mensagem na tela ou emitir um relatório.
, &)
& +-
Na página “Treinamento” crie dois botões para ligar/desligar o Agitador do Silo.
1. Abra a página “Treinamento”.
2. Apague o objeto de texto que diz “Crie os botões embaixo do capítulo
correspondente........”
3. Crie um botão abaixo do título Capítulo 2 conforme mostrado nas figuras abaixo.
17
! " # &
4. Selecione o tab horizontal Appearance e o tab vertical General.

5. No campo Text digite conforme mostrado na figura acima. Atenção para o caractere de
controle ^n.
6. Selecione Alignment igual a Centre.
7. Selecione o tab horizontal Input e o tab vertical Touch.
8. No campo Up command digite: SILO_CMD=1.
9. Clique no botão OK.

10. Repita o procedimento acima de forma a criar um segundo botão abaixo do
primeiro que irá desligar o Agitador do Silo.
11. Salve sua página.
12. Compile e execute seu projeto, alternando a visualização entre as páginas
Treinamento e Pasteuriser para testar o novo comando.
18
! " # &
!.$ # " # /
Os comandos executam tarefas específicas tais como atribuir valores à variáveis ou
mudar o status de um bit. Como vimos no exercício anterior, nós podemos alterar o
status do Agitador do Silo de Leite. Se definirmos um tag digital chamado
BOMBA_CMD para controlar a bomba, nós podemos ligar esta bomba fazendo este
tag igual a 1. Isto é implementado inserindo o seguinte comando:
Execute
BOMBA_CMD = 1;
Command
De modo similar, podemos desligá-la da seguinte forma:
Execute BOMBA_CMD = 0;
Command
Da mesma forma, podemos atribuir valores para variáveis analógicas.
Se por exemplo, temos um tag analógico chamado TIC_P4_SP pode-se atribuir o valor 10
emitindo o seguinte comando:
Execute
TIC_P4_SP = 10;
Command
Podemos também atribuir a esta variável o valor de uma outra variável analógica da seguinte
forma:
Execute TIC_P4_SP = TIC_P1_SP;

Command
Ao valor de TIC_P4_SP é atribuído o valor da TIC_P1_SP. Isto, no entanto só ocorre quando

o comando é emitido. O valor de TIC_P1_SP pode inclusive mudar imediatamente, mas o
valor TIC_P4_SP fica inalterado até que o comando seja novamente emitido.
, &)
& +-+
Crie botões na sua página “Treinamento” para atribuir valores aos tags TIC_COOL_PV e
TIC_P2_PV.
1. Abaixo do titulo Capítulo 2, crie um botão para atribuir o valor -3 para
TIC_COOL_PV.
2. Crie um novo botão para atribuir a TIC_P2_PV o valor de TIC_COOL_PV.
3. Salve sua página, compile seu projeto e teste os novos comandos.
19
! " # &
Você também pode fazer uso de variáveis do tipo STRING em expressões. Por
exemplo, se NOME_BATELADA é um tag de variável do tipo string, você pode usar o
seguinte comando para atribuir ao tag o valor “RACAO ESPECIAL”:
Execute
NOME_BATELADA = "RACAO ESPECIAL";
Command
Quando fazendo uso de string literal, você deve colocá-la entre aspas.
, &)
& +-0
Utilize um comando do tipo Touch para trocar o valor de um Tag do tipo STRING para um
string literal.
1. Crie um botão na página “Treinamento” para atribuir a string
“Full Cream Milk?” à variável Recipe.
2. Salve sua página
3. Compile, execute e teste seu projeto.
, 1
Uma expressão do Cicode é o elemento básico da Linguagem do Cicode. Uma expressão
pode ser uma constante, o valor de um tag de variável ou o resultado de uma equação
complexa. Você pode utilizar expressões para mostrar e armazenar dados de forma a
possibilitar monitoração e análise, como também para disparar vários elementos em seu
sistema, tais como alarmes, eventos, relatórios, etc.
Você pode inserir uma expressão do Cicode em qualquer propriedade do objeto e ou figura.
Diferentemente de um comando, uma expressão não executa uma tarefa específica. Em vez
disso, ela é simplesmente alguma coisa que pode ser avaliada. O processo de avaliação
retorna um valor que você pode utilizar para mostrar informações na tela (por ex. uma barra
gráfica) ou para tomar decisões.
A seguinte expressão simples retorna o resultado 12:
Numeric
8+4
Expression
No exemplo acima, o valor da expressão é sempre uma constante (12) dado que os
elementos da expressão também são constantes.
, & #! /*
&*
Você pode também executar cálculos matemáticos em declarações do Cicode, como por
exemplo:
Execute MILL1_SPEED = MILL2_SPEED + MILL3_SPEED - 100;
Command
20
! " # &
Quando o comando for executado, à variável MILL1_SPEED, será atribuído o valor da soma
das variáveis MILL2_SPEED e MILL3_SPEED menos o valor 100. Observe a sintaxe que se
utiliza nestes cálculos. A variável que contêm o resultado da expressão se coloca a esquerda
da sequência de comandos.
Resultado = Operando1 + Operando2 + Operando3;
#*2# " 3#
No exemplo seguinte, o valor da expressão é o valor da variável TIC_HOLD_PV.
Quando seu valor muda, o valor da expressão também muda. Você pode utilizar esta
expressão para mostrar um número em uma página gráfica.
Numeric TIC_HOLD_PV
Expression
As expressões podem também incluir cálculos matemáticos. Por exemplo, você pode
adicionar duas variáveis e mostrar o valor total combinado conforme mostrado abaixo:
Numeric
TIC_HOLD_PV + TIC_P4_PV
Expression
Neste caso, o valor da expressão é o valor combinado total. Se uma das variáveis (ou
ambas) muda(m), o valor da expressão também muda.
, &)
& +-4
Crie um botão para adicionar o valor de 02 tags analógicos
1. Na página “Treinamento” crie um botão chamado “TIC_P4_PV” que deverá adicionar os
tags TIC_P1_PV e TIC_P2_PV e retornar o valor no tag TIC_P4_PV.
2. Salve sua página
3. Compile, execute o projeto e teste o novo comando.
3 &*
## 1 5* *
#
Para executar diversas tarefas ao mesmo tempo, você pode combinar declarações nas
propriedades dos comandos separando-as por ponto e vírgula (;) conforme mostrado abaixo:
TIC_HOLD_PV = TIC_P4_PV;
Execute
NOME_BATELADA = ”RACAO ESPECIAL”;
Command
LIC_SILO_SP = 450;
A primeira declaração atribui à variável TIC_HOLD_PV o valor da variável TIC_P4_PV. A

segunda declaração atribui à variável NOME_BATELADA a string “RACAO ESPECIAL”. A
terceira declaração atribui à variável LIC_SILO_SP o valor constante 450. As declarações
são executadas nesta ordem.
21
! " # &
O numero de declarações que você pode inserir em uma propriedade de comando está
limitado apenas ao tamanho do campo. Entretanto, para uma melhor visualização e clareza,
é melhor não utilizar muitas declarações – insira as declarações em um arquivo “Include” ou
escreva uma função do Cicode. Você pode então fazer referência ao Include File ou chamar
a função do Cicode por um comando. (Include Files e funções serão discutidas
posteriormente)
Para mais informações sobre Include Files, procure no Vijeo Citect Help Topics por Using
Include (Text) Files
, &)
& +-6
Crie uma declaração múltipla
1. Na página “Treinamento” modifique o botão configurado anteriormente para calcular a
soma de TIC_P1_PV e TIC_P2_PV. Adicione uma segunda declaração para fazer com
que à mensagem “Cálculo Terminado” apareça na linha de Prompt.
2. Salve sua página.
3. Compile, execute seu projeto e comprove o resultado.
Utilize a função do Cicode chamada Prompt(string). Procure no Help do Vijeo Citect

maiores detalhes sobre esta função. Nós estaremos olhando os tipos de funções
mais comuns ainda durante este capítulo.
' ! ! ## 3# #
Você pode definir um comando de teclado como uma seqüência de teclas, para executar uma
tarefa específica cada vez que a seqüência for digitada, como por exemplo:
Key Sequence F2 Enter
Execute
LIC_BALANCE_SP = 10
Command
Uma seqüência de teclas pode fornecer meios para, por exemplo, permitir ao operador inserir
dados, estabelecer novos setpoints, etc. No seguinte exemplo, o operador pode atribuir um
valor para a variável LIC_BALANCE_SP. A figura abaixo ilustra:
22
! " # &
A entrada do operador…..
…………é passada ao comando como ArgValue1

O operador emite o comando pressionando a tecla F2, em seguida inseri até quatro
caracteres e finalmente pressiona a tecla ENTER. A seqüência de quatro caracteres
(identificada pelos caracteres #) é denominada argumento. O argumento é passado para
dentro do comando como ArgValue1 quando o comando é completado, isto é, quando o
operador pressiona a tecla ENTER.
O valor 123 é passado para o comando e o valor 123 é atribuído para

LIC_BALANCE_PV.
Você deve sempre utilizar uma tecla específica (por ex., ENTER) para sinalizar a
finalização de uma seqüência de teclas.
Se, por exemplo, você utilizar a seqüência de teclas F2 ####, o operador deve inserir 4
caracteres para que o comando seja executado – o Vijeo Citect espera sempre pelo quarto
caractere. Mas se você utilizar F2 #### Enter, o operador poderá executar o comando
inserindo algo entre 1 e 4 caracteres, conforme necessário. O comando é executado tão
logo a tecla ENTER seja pressionada
Você também pode passar mais de um argumento para um comando. Para tanto, separe
os argumentos por vírgulas (,) na seqüência de teclas conforme mostrado abaixo:
23
! " # &
Os valores 123 e 18 são passados ao comando. A LIC_BALANCE_SP é atribuída o valor

123 e a PIC_HOMOG_SP é atribuída o valor 18. Quando passando múltiplos argumentos
eles serão atribuídos a Arg1, Arg2, Arg3 .... Argn.
Existem duas formas de se definir um argumento. ArgValueX e ArgX.
Existe uma diferença importante entre os dois. O argumento ArgValueX comprova

que o operador introduziu um número, enquanto que ArgX não. Isto significa que se
o operador utiliza ArgX para efetuar uma entrada, este poderá introduzir um número
ou uma letra, que será escrito no tag. Assim, por exemplo, se um tag do tipo inteiro
irá receber o input proveniente de ArgX e acidentalmente uma letra é inserida no
meio dos caracteres, resultará num valor 0 (zero) escrito no tag.
= $7
! ! 89 =
$ #* 79; $ #* 7
! ! A! #* 3# #B
!
, &)
& +-:
Crie um comando de teclado de objeto para alterar a string mostrada em STRING3.
1. Na página “Treinamento” modifique o texto ao lado de STRING3. Selecione o tab
horizontal Input e o tab vertical Keyboard Commands.
4. Preencha a caixa de diálogo conforme mostrado acima.

5. Pressione o botão OK.
6. Crie uma tecla de teclado de comando de objeto, para ser utilizada em uma nova
seqüência de teclas. Abra o Editor de Projetos do Vijeo Citect e selecione o menu
24
! " # &
System|Keyboard Keys.
7. Crie uma tecla denominada F2 que utilize o código de tecla KEY_F2.
8. Preencha a caixa de diálogo conforme mostrado abaixo.

9. Compile, execute seu projeto e observe o resultado.
10. Posicione o mouse sobre STRING3 (objeto dinâmico), pressione a tecla F2 e
insira um texto qualquer de 10 caracteres e observe sua tela.
11. Modifique o comando acima em Key Sequence inserindo o texto ENTER depois
do último caractere #. A figura abaixo ilustra:
12. Verifique agora que você pode inserir qualquer numero de caracteres (limitado a 10)
que ao pressionar ENTER os caracteres serão mostrados no campo dinâmico.
, &)
& +-;
Defina uma seqüência de teclas para trocar o valor de INT3 quando o mouse for
posicionado em cima do número.
1. Crie uma nova tecla de teclado para ser utilizada em uma nova seqüência de teclas.
Abra o Editor de Projetos do Vijeo Citect e selecione o menu System|Keyboard
Keys.
2. Crie uma tecla denominada F3 que utilize o código de tecla KEY_F3.
25
! " # &
3. Na página Treinamento aplique um duplo clique em cima do objeto dinâmico INT3 para
abrir o quadro de diálogo de propriedades.
4. Selecione o tab horizontal Input e o tab vertical Keyboard Commands e adicione a nova
sequência de teclas. Clique em OK para continuar.
5. Salve sua página, compile o projeto e teste o novo comando.
<#%#! =!1 % %#!

, 1
Você pode chamar uma função inserindo o nome dela em qualquer comando ou expressão.
A sintaxe está mostrada abaixo:
Execute
FunctionName(Arg1, Arg2, ...);
Command
26
! " # &
Onde: FunctionName é o nome da Função e Arg1, Arg2, ... são os argumentos que você
passa para a função
Um exemplo desta chamada poderia ser o comando de teclado abaixo:
Key Sequence End_Key
Execute Command Shutdown();
Quando a tecla END é pressionada, a função Shutdown() é chamada e o Vijeo Citect deixa
de ser executado (retirado do modo de run time).
Configure o comando de teclado de sistema acima. Salve sua página, compile e execute seu
projeto e comprove o resultado de sua alteração.
Configure primeiramente a tecla END_KEY em Keyboard Keys e somente depois configure
o comando de sistema em Keyboard Commands. As figuras abaixo ilustram.
, &)
& +->
Adicione um botão na página Treinamento para chamar a função CSV_Tag_Debug();

1. Desenhe um botão abaixo do texto Capítulo 2. Selecione o tab horizontal Input e o tab
vertical Touch.
2. Insira a chamada da função CSV_Tag_Debug();no campo Up command.
3. Selecione o tab horizontal Appearance e mantenha o tab vertical Touch selecionado.
Digite TagDebug() no campo Text.
27
! " # &
4. Salve sua página, compile o projeto e teste sua alteração.
# #! 3# # ## = ! 1
O parêntese () em uma declaração a identifica como uma função e contêm seus
argumentos (quando aplicável). Os argumentos são valores ou variáveis que são
passadas para dentro da função quando ela é executada.
$ % ! 8
As funções podem requerer diversos argumentos ou, como no seguinte exemplo, um
único argumento.
Execute
PageDisplay("Caldeira1");
Command
Esta função quando executada, mostra a página gráfica “Caldeira1”. Observe que
quando você passa uma STRING para uma função, você deve sempre inseri-la entre
aspas duplas (“”).
Para obter informações sobre parâmetros requeridos em qualquer função do

Cicode, acesse Help | Vijeo Citect Help Topics e procure pela função no Índex
O seguinte exemplo utiliza a função Prompt() para mostrar a mensagem "Pressione F1
para Ajuda" quando o comando for executado.
Execute
Prompt("Pressione F1 para Ajuda");
Command
28
! " # &
, &)
& +-?
Crie um comando de teclado de sistema que mostre a página de Treinamento quando o
operador clicar com o botão direito do mouse.
1. Abra o Editor de Projetos do Vijeo Citect e selecione o menu System|keyboard
Commands. Clique no botão Add.
2. No campo Key Sequence selecione RBUTTON_UP.
3. No campo Command digite o comando PageDisplay(“Treinamento”).
4. Digite um comentário qualquer informativo.
5. Compile, execute e teste seu projeto quando estiver mostrando a página de Menu.
, &)
& +- @
Crie um botão na sua página “Treinamento” chamado “Excel” que utiliza a função
Exec() para iniciar o Excel.
1. Abra o Editor Gráfico e em seguida a página Treinamento e crie um novo botão embaixo
de Capítulo 1.
2. Selecione o TAB horizontal Appearance e digite EXCEL no campo Texto. Selecione
agora o TAB horizontal Input e o TAB vertical Touch. Digite o path completo onde pode
ser encontrado o EXCEL.EXE (veja dica abaixo).
3. Salve sua página, compile o projeto e execute-o novamente para comprovar o novo
comando.
4. Feche o projeto.
Tente o seguinte comando para o Office 2003

Exec("C:\Program Files\Microsoft Office\OFFICE11\excel.exe")
29
! " # &
# #! 5* * $ % !
Algumas funções requerem diversos argumentos. Você deve listar todos os argumentos
entre os parênteses e separa-los por vírgula, como no seguinte exemplo.
Execute
Login("Manager", "ABC");
Command
A ordem dos argumentos é importante para a operação de qualquer função. A função
Login() quando executada, valida um determinado usuário no sistema de tempo real. O
primeiro argumento ("Manager") indica o nome do usuário e o segundo argumento ("ABC")
a senha (“Password”) do mesmo. Se você inverte a ordem dos argumentos, a função irá
tentar validar o usuário “ABC” e não existindo este, uma mensagem de erro será mostrada.
# #! $ % ! %A &
Você pode passar números (inteiros e de ponto flutuante) diretamente para uma função,
como por exemplo:
Execute AlarmAck(2, 35);

Command
# #! # / &% $ % !
Quando variáveis (tais como dados de tempo real) são utilizadas como argumentos, o valor
da variável é que é passado e não a própria variável. O seguinte exemplo utiliza a função
DspStr() para mostrar o valor de uma variável de processo no Ponto de Animação
(Animation Point) 25:
Execute
DspStr(25, "TextFont", NIVEL);
Command
Neste caso, o valor do nível é mostrado. Se ela é uma variável de tempo real, o número
mostrado depende do valor dela naquele momento.
Se você inclui o tag entre aspas na função acima, como por exemplo, “NIVEL” então
a string NIVEL e não seu valor é que será mostrado.
30
! " # &
, &)
& +-
Crie uma página emergente de tendências e especifique os tags de tendência que serão
mostrados.
1. Crie uma página baseado no template CES_Style Pop Trend.
2. Selecione no menu File|New.
3. Selecione Page na figura abaixo.
4. Salve a página como !MyPopTrend.

5. Crie um botão na sua página Treinamento abaixo do texto Capítulo 2 e chame-o de Pop
Trend.
6. Selecione agora o TAB horizontal Input e o TAB vertical Touch. Digite o seguinte
comando:
7. TrendPopUP(“!MyPopTrend”,”TIC_P1_PV”,”TIC_P2_PV”,”TIC_P3_PV”,”TIC_P4_PV”)
31
! " # &
No Editor Gráfico do Vijeo Citect, selecione no menu Tools|Options a opção List

System Pages de forma a poder visualizar a página que você acabou de criar
quando selecionar a opção File|Open
8. Salve a página e compile seu projeto.

9. Execute o projeto e comprove o novo comando.
, &)
& +- +
Podemos passar números (inteiros e de ponto flutuante) diretamente a uma função, como por
exemplo:
Comando AlarmAck(2,35)
1. Adicione um comando de botão na página Treinamento para abrir uma página emergente
em uma localização determinada.
2. Selecione o tab horizontal Appearance e o tab vertical General. No campo Text
digite PUMP FEED.
3. Mantenha o tab vertical General selecionado e selecione agora o tab horizontal
Input.
4. Adicione a função AssWin() conforme mostrado na figura abaixo:
AssWin("!Pump",485,310,1+8+512,"PUMP_FEED_CMD", “PUMP_FEED_M");
5. Salve sua página, compile o projeto e execute o comando inserido.

6. A página emergente deverá ser apresentada conforme figura abaixo:
32
! " # &
7. Adicione outro comando para mostrar o nome do Tag na barra de título da página
emergente.
8. Abra o Editor Gráfico do Vijeo Citect e selecione a página Treinamento. Abra as
propriedades do botão PUMP FEED e adicione o seguinte comando a entrada Input.
Observe que será necessário acrescentar um (;) - ponto e vírgula - depois do comando
superior de forma a separar os comandos.
WinTitle(“PUMP_FEED”);
9. Abra a página Treinamento e comprove o funcionamento do novo comando. A página

emergente deverá ser mostrada conforme figura abaixo:
33
! " # &
, &)
& +- 0
Utilize uma função com argumentos de variável para mostrar o valor de um tag em um objeto
de Cicode.
1. Abra a página Pasteuriser e coloque um objeto Cicode sobre o objeto.
2. Crie um botão na página Pasteuriser denominado LEVEL BALANCE^n TANK.

Selecione o tab horizontal Input e o tab Vertical General e adicione a seguinte
função:
DspStr(XXX,”ControlLimits”, LIC_BALANCE_PV) onde XXX é o número referente
ao Animation Number do Objeto Cicode f(x) que você adicionou. Para identificar
este número, aplique um duplo clique no objeto f(x), selecione o tab Access
conforme mostrado abaixo:

!#! # # =!1
Algumas funções retornam dados para a declaração de chamada (um comando ou
expressão). Algumas funções simplesmente retornam um valor que indica sucesso ou falha
na execução da função. As seguintes funções PageNext() e PageDisplay() retornam 0
(zero) se a página foi mostrada com sucesso. De outra forma irão retornar um número de
erro. Para a maioria das aplicações, você poderá ignorar este valor de retorno.
34
! " # &
Algumas funções retornam dados que você pode utilizar em uma expressão ou comando. A
função Date() retorna a data corrente como um string. Para mostrar a data corrente em uma
página gráfica, utilize a seguinte expressão em um objeto do tipo texto.
Numeric
Date();
expression
O seguinte exemplo mostra um evento de comando de entrada para uma página gráfica que
combina duas funções. A função FullName() informa o nome do usuário que está
correntemente logado no sistema, passando então este nome para a função de chamada
Prompt() que concatena então as duas strings. Quando a página é aberta, uma mensagem
de boas vindas é mostrada na linha de prompt.
On page Prompt("Ola," + FullName()) entry
Por exemplo, se o usuário corrente se chama Paulo Silva, então teremos a mensagem "Ola,
Paulo Silva” mostrada na linha de prompt.
, &)
& +- 4
Na página “Pasteuriser” utilize a função FormNumPad() para adicionar um comando para
alterar os valores dos tags LIC_BALANCE_PV, SIC_CENT_PV e PIC_HOMOG_PV, de tal
forma que um teclado deverá aparecer quando clicarmos com o botão esquerdo do mouse
em cima dos valores das variáveis.
1. Os valores dos tags acima são controlados mediante um Genie utilizado na página
Pasteuriser chamado ChangeValue.
2. Este Genie se encontra na biblioteca Training. Abra o Genie ChangeValue.
3. A figura abaixo ilustra o Genie ChangeValue.
4. Aplique um duplo clique em cima do objeto para abrir suas propriedades. Selecione o tab
horizontal Input e o tab horizontal Touch. Adicione o comando mostrado na figura abaixo.
No run time, quando se clicar com o botão direito do mouse em cima do objeto, um
teclado emergente será mostrado e será possível alterar os valores dos tags.
35
! " # &
5. Salve o Genie utilizando File|Close.

6. No Editor Gráfico do Vijeo Citect, selecione o menu Tools|Update Pages.
7. Compile e execute seu projeto. Abra a página Pasteuriser e clique com o botão esquerdo
do mouse nos objetos que mostram os valores dos tags LIC_BALANCE_PV,
SIC_CENT_PV e PIC_HOMOG_PV. As figuras abaixo ilustram:
36
! " # &
, & #! .! 1 B #! # !
%#
O Vijeo Citect possui um parâmetro especial que pode executar uma determinada função
quando o sistema é iniciado.
Para fazer o setup do Parâmetro de Startup:
1. Avance pelo Wizard de Setup do Computador até encontrar o seguinte diálogo:
37
! " # &
2. Clique no botão Modify. A seguinte caixa de diálogo será mostrada.
3. Digite Startup() e pressione o botão OK. A figura abaixo ilustra:
4. Pressione o botão Next até concluir o Wizard de Setup do Computador. No arranque do

aplicativo, a função Startup() será executada. Esta função faz parte do aplicativo
entregue por seu instrutor e tentará entre outras coisas, estabelecer uma conexão com
um banco ACESS exibindo a mensagens ao operador.
5. Se a conexão for feita com sucesso, a seguinte mensagem será ecoada na tela. Caso
contrário, a mensagem de erro se fará presente.
38
0
# # /
39
# # /
40
# # /
O Cicode é utilizado para manipular dados e executar tarefas. A manipulação de dados é

alcançada utilizando-se cinco classes de operadores. São eles: matemáticos, Bit, Lógicos,
Relacionais e de formatação.
Neste capítulo nós iremos aprender como utilizar os operadores em cada uma das diferentes
classes.
'( #) *
Neste capítulo você irá aprender sobre:
• Operadores matemáticos;
• Operadores lógicos;
• Operadores de bits;
• Operadores relacionais;
• Operadores de formato;
• A ordem de precedência dos operadores.
*
# #
O texto abaixo descreve as cinco classes de operadores disponíveis no Vijeo Citect.
# # %/ &
Os operadores matemáticos padrões são utilizados para executar cálculos em variáveis
numéricas tais como números inteiros e de ponto flutuante. Os operadores matemáticos
disponíveis são:
Operadores Descrição
+ Adição (para valores numéricos)
+ Concatenação (para variáveis do tipo string)
- Subtração
* Multiplicação
/ Divisão
MOD Módulo (resto da divisão)
Abaixo vemos um exemplo do operador MOD:
TAG_1 = TAG_2 MOD 100
Assim, se TAG_2 é igual a 101, então TAG_1 resulta em 1 ( que é igual ao resto da divisão
de TAG_2 por 100)
Um exemplo do operador de concatenação é mostrado abaixo:
41
# # /
Prompt(“O valor do Tag 1 é” + IntToStr(Tag_1));
Isto é um String Isto é um String
Apenas variáveis do tipo string podem ser passadas para a função Prompt() e uma forma
de se mostrar o valor de TAG_1 é através do uso da concatenação como mostrado acima.
Observe que desde que TAG_1 é do tipo inteiro, necessitamos converte-lo para string
antes de utilizá-lo na função, daí a utilização da função IntToStr().
, &)
& 0-
Na sua página “Treinamento” debaixo do texto Capitulo 3, crie um botão que realize um
cálculo mediante o uso do operador MOD.
1. No campo texto digite MODULO para o botão acima.
2. Selecione o TAB horizontal Input e o TAB vertical Touch.
3. Insira o seguinte comando
TIC_P2_PV = TIC_P4_PV MOD 10
, &)
& 0-+
Na sua página “Treinamento” debaixo do texto Capitulo 3, crie um botão que realize uma
concatenação.
1. No campo texto digite CONCATENAÇÃO para o botão acima.
3. Insira o seguinte comando
Message(“Temperatura Zona 2”, “TIC_P2_PV = “ + IntToStr(TIC_P2_PV), 64)

4. Salve sua página e compile o projeto.
5. Na página Treinamento, altere o valor do tag TIC_P2_PV para 10.
6. Na página Treinamento, altere o valor do tag TIC_P4_PV para 43.
7. Clique no botão MODULO e comprove o resultado.
8. Clique no botão CONCATENAÇÃO. A seguinte mensagem será ecoada na tela.
# C$ &
42
# # /
Operadores Lógicos podem ser utilizados para testar o estado lógico de um operador. O
resultado retornado após o teste pode ser apenas TRUE (1) ou FALSE (0). Os três
operadores lógicos são:
Operador Descrição
AND Logica AND
OR Logica OR
NOT Logica NOT
, &)
& 0-0
Na sua página “Pasteuriser” comprove a condição de Lógica AND.
1. Aplique um duplo clique em cima da tubulação que interliga a Feed Pump e Centrifuge
Clarifier. O seguinte quadro de diálogo será mostradro:
2. Preencha conforme mostrado no quadro acima
3. Pressione o botão OK.
4. Salve sua página e compile seu projeto
5. Execute novamente seu projeto e comprove o funcionamento do operador lógico

AND ligando/desligando a Feed Pump e o Centrifuge Clarifier.
6. Feche seu projeto.
, &)
& 0-4
Na sua página “Pasteuriser” crie um objeto de texto que troque seu valor em função da
condição de um tag de alarme. A condição A será mostrada se a propriedade de alarme tiver
no estado de alarme ALTO (HI) ou MUITO ALTO (HI HI). A condição B será mostrada se
43
# # /
propriedade de alarme tiver no estado de alarme BAIXO (LOW) ou MUITO BAIXO (LOW
LOW).
1. Adicione um objeto de texto perto do Holding Tube.
2. Selecione o TAB horizontal Appearance e o TAB vertical Display Value.
3. Selecione em Type a animação do tipo Multi-State e preencha as propriedades como

mostrado abaixo.
4. Salve sua página e compile o projeto novamente.
5. Execute seu projeto novamente e comprove o operador lógico OR alterando o valor de

TIC_HOLD_PV.
, &)
& 0-6
Crie um alarme digital que se ativa quando um determinado tag digital se desativa.
1. Abra o Editor de Projetos do Citect e selecione Alarms|Digital Alarms.
2. Adicione o seguinte alarme ao formulário.
Alarm Tag ALFAST

Alarm Name ALFAST AGITATOR
Alarm Desc STOPPED
Variable Tag A NOT ALFAST_CMD
3. Compile e execute seu projeto.
4. Abra a página Pasteuriser e desligue o Alfast Agitator
5. A barra de ferramenta de alarmes situada na parte inferior da página mostrará o novo

44
# # /
alarme.
#
Os seguintes padrões de operadores de bit são fornecidos com o Cicode:
BITAND Bitwise AND
BITOR Bitwise OR
BITXOR Exclusive OR
Os operadores de bit podem ser utilizados em palavras ou em bits individuais.
Ex -1. 11011 AND 1101 resulta em 01001.
# *
#& !#
Para testar a relação entre dois valores podemos utilizar os operadores relacionais.
= IGUAL
<> DIFERENTE DE
< MENOR QUE
> MAIOR QUE
<= MENOR OU IGUAL QUE
>= MAIOR OU IGUAL QUE
, &)
& 0-:
Crie um alarme avançado que se ativa quando um determinado tag alcança um valor maior
ou igual a 3.
1. Abra o Editor de Projetos do Citect e selecione Alarms|Advanced Alarms.
2. Adicione o seguinte alarme ao formulário.
Alarm Tag COOL_A

Alarm Name COOLANT OVERHEATED
Alarm Desc COOLANT TEMP>=3
Expression TIC_COOL_PV >= 3
3. Compile e execute seu projeto.
4. Abra a página Pasteuriser e faça o TIC_COOL_PV >= 3.
5. A barra de ferramenta de alarmes situada na parte inferior da página mostrará o novo

45
# # /
alarme.
# = %#
O operador de formato é utilizado para converter valores numéricos em strings formatadas
para propósitos de apresentação em telas.
: (colon) Formatação em String
Por exemplo, para converter um valor numérico em uma string nós teríamos:
TAG_1: ####.#
Neste exemplo, TAG_1 seria mostrado com quatro casas decimais e uma casa depois da
vírgula. Este tipo de formatação pode ser utilizado quando mostrando um número como uma
string. Nós fazemos uso freqüente disto quando formatando relatórios no Vijeo Citect.
, &)
& 0-;
Utilize o operador de formato em um quadro de mensagem para mostrar o valor de um
determinado tag.
1. No Editor Gráfico, abra a página Pasteuriser.
2. Crie um botão abaixo do texto Capítulo 3 cujo texto seja Pasteuriser 3.
4. Insira o seguinte comando:
Message(“Temperatura Zona 3”, TIC_P3_PV:###.##,64)
46
# # /
5. Salve sua página, compile o projeto e execute-o novamente.
6. Pressione o botão Pasteuriser 3 e comprove o funcionamento do operador de formato. A

figura abaixo ilustra.
% & D!&# #
No Cicode, cada operador tem uma determinada precedência. Isto significa que um operador
de mais alta precedência será executado antes de operadores de mais baixa precedência. A
precedência dos operadores, da mais alta para a mais baixa esta mostrada abaixo:
1. ()
2. NOT
3. *, /, MOD
4. :
5. +, -
6. <, >, < =, > =
7. =, < >
8. AND
47
# # /
9. OR
10. BITAND, BITOR, BITXOR
Por exemplo, na seguinte expressão temos:
TAG_1 OR TAG_2 AND NOT TAG_3
NOT TAG_3 é calculado primeiro, ao resultado será aplicada lógica END com TAG_2.
Finalmente ao resultado será aplicada lógica OR com TAG_1. Isto é equivalente a:
(TAG_1 OR (TAG_2 AND (NOT TAG_3)))
A utilização dos parênteses mostra de uma forma mais clara como a ordem de
precedência será aplicada.
, &)
& 0->
Na sua página “Treinamento”, crie um botão chamado “Declaração” de forma a executar a
seguinte expressão lógica.
BIT3 = BIT1 AND NOT BIT2
48
4
&
49
&
50
&
O Editor do Cicode é um ambiente de programação totalmente integrado, projetado

especificamente para se escrever rotinas em Cicode/VBA (Visual Basic for Application). O
Editor do Cicode também inclui um debugger (depurador) que irá facilitar sua tarefa de
escrever e depurar suas rotinas. Um help On Line permite achar ajuda sobre as funções de
forma instantânea.
'( #) *
• Como iniciar o Editor de Cicode;
• Acessar erros nas linhas numeradas;
• Navegação por arquivos;
• Ferramentas de Edição;
• Ferramentas de Funções;
• Preferências.
% ! &# &
O Editor do Cicode pode ser iniciado clicando-se no botão do Editor do Cicode ou via
menu TOOLS|Cicode Editor quando no Vijeo Citect Explorer.
Para obter ajuda em qualquer dos ícones, selecione Help | Cicode Editor Help no Editor do
Cicode. Uma vez no Help, clique em menus, botões e outros elementos de tela para uma
melhor explicação. (Você pode inclusive fazer uso dos chamados Tool tips – dicas de
ferramentas)
51
&
#! %! B &
, &)
& 4-
No Editor do Cicode, crie um novo arquivo do Cicode chamado Treinamento. Ele será usado
no próximo capítulo para todas as nossas rotinas e funções do Cicode. Para criar um novo
arquivo do Cicode:
i. No Editor do Cicode, clique no botão .
-ou-
No menu, selecione File | New.
ii. Selecione Cicode e pressione o botão OK.

iii. Salve seu arquivo como Treinamento.
8 # ##& #
O Suporte do Compilador para erros permite um rápido acesso a erros de compilação.
Quando um erro do Cicode é encontrado, um diálogo como o apresentado abaixo será
mostrado.
No campo de contexto, o número da linha onde o erro ocorreu será mostrado bem como um
par de chaves envolvendo a provável causa do erro.
Pressionando o botão , o editor do Cicode irá abrir o arquivo do Cicode contendo o

erro na linha onde o erro ocorreu.
Você pode também, uma vez no editor do Cicode, ganhar acesso a linha selecionando Edit |
Go to line... ou pressionando CTRL-G
52
&
% *
#! , & #!
Você pode compilar e executar um projeto de dentro do Editor do Cicode utilizando a barra de
ferramentas e clicando no botão . Você também pode compilar um projeto sem executá-lo
clicando no botão .
, &)
& 4-+
Crie uma função para comprovar o compilador.
1. No Editor do Cicode, selecione File | Open ou clique no ícone para abrir o arquivo
Treinamento.ci que você criou anteriormente.
2. Escreva a seguinte função simples:
FUNCTION
ChangeValue()
TagValue=10;
END
3. Salve seu arquivo.
4. Compile o projeto. O depurador lhe indicará que existem 04 erros conforme figuras
abaixo:
5. Clique no botão OK.

6. Para acessar o Warning detectado, selecione no Editor de Projetos a opção
File|Compile Errors.....
53
&
7. Pressione o botão GoTo na figura acima para acessar o erro detectado. A seguinte
figura mostra o Editor do Cicode aberto com o local do erro apontado.
8. Substitua TagValue por TIC_P2_PV.

9. Salve o arquivo e volte a compilar o projeto novamente.
10. Clique em OK.
# $# " B
O Editor do Cicode foi melhorado de forma a permitir a modificação de códigos mais
rapidamente e também mais facilmente. Uma destas novas características é a janela Files,
que permite visualizar os arquivos do Cicode de um determinado projeto em uma vista do tipo
árvore. A figura abaixo ilustra:
54
&
Foi adicionado um sistema de fichas (TABS) para proporcionar três vistas distintas dos
arquivos. São elas:
Open Files
Na ficha Open Files tem-se a listagem de todos os arquivos de código atualmente abertos no
Editor do Cicode. Nesta janela temos o path completo destes arquivos mostrados.
55
&
Esta característica é muito útil quando é necessário abrir arquivos que tem o mesmo nome,
mas que pertencem a projetos diferentes. Na lista da janela do Editor do Cicode se mostrará
o nome do arquivo. Não podemos utilizar esta vista para diferenciar entre arquivos que tem o
mesmo nome, mas que pertencem a projetos diferentes.
Já na janela Open Files são mostrados os arquivos e suas rotas completas. Se você
deseja trocar de arquivo, basta aplicar um duplo clique no nome do arquivo desejado e
pronto, ele será aberto pelo Editor do Cicode para Edição.
Open Project
56
&
Na ficha Open Project tem-se a listagem de todos os arquivos de código do projeto que está
atualmente selecionado no Citect Explorer. Podemos abrir os arquivos a partir desta ficha
aplicando um duplo clique no nome do arquivo desejado.
All Projects
Na ficha All Projects tem-se a listagem de todos os arquivos de código de todos os
projetos que estão atualmente vinculados ao Citect Explorer. Podemos também abrir os
arquivos a partir desta ficha aplicando um duplo clique no nome do arquivo desejado.
57
&
58
&
= #% ! # "
Janelas acopláveis e barras de ferramentas
O Editor do Cicode permite ao usuário manipular a área de visualização da área de trabalho.
Pode-se mostrar e ocultar janelas e barras de ferramentas com apenas um clique do botão
direito do mouse na parte superior da área de menus. Isto ativará um menu emergente em
que aparecerão as barras de ferramentas e as janelas disponíveis. As janelas e as barras de
ferramentas atualmente mostradas estão selecionadas na lista.
Movimentação das barras de ferramentas

Para mudar a localização de barras de ferramentas, clique e mantenha pressionado o botão
esquerdo do mouse e arraste a barra para o local desejado.
Controlador de translado
Formatação e Comentários
59
&
Foi adicionada também uma barra de ferramentas de formato ao Editor do Cicode para
formatar e converter linhas de código em comentários.
Procedimento para converter código em comentários

Marque as linhas de código que deseja converter em comentários e pressione o botão
adequado. Por exemplo, para converter em comentários várias linhas, marque o código
conforme mostrado abaixo:
Clique no botão Comentar . Todas as linhas de código selecionadas se

converterão em
comentários.
Barra indicadora de marcadores e breakpoints

Os marcadores e breakpoints são ferramentas úteis que se usam ao modificar e depurar
códigos. A barra indicadora de marcadores e breakpoints está colocada na lateral
esquerda da janela de código.
60
&
# &#
#E !
Insira um marcador clicando com o botão direito do mouse na barra indicadora. Para remover
o marcador, clique novamente com o botão direito sobre ele. Ao clicar com o botão esquerdo
do mouse na barra indicadora será inserido/removido um breakpoint. Uma nova barra de
ferramentas foi adicionada para controlar a inserção/remoção de marcadores bem como a
navegação entre eles. A figura abaixo ilustra:
, &)
& 4-0
Utilize algumas das novas funções de edição para criar uma função do tipo ActiveX.
1. Selecione a ficha (TAB) All Projects para acessar e abrir o arquivo Sample.ci no projeto
Example.
2. Marque e copie a função CreateCiMeter() e coloque um marcador na barra
indicadora.
3. Cole o texto copiado sobre o texto original CreateCiMeter().
4. Marque o texto colado e utilize CTRL+H para abrir o formulário Substituir. Substitua
o texto CiMeter por WebBrowser no texto selecionado.
5. Troque o texto em negrito nestas nas seguintes linhas:

nAN = AnByName("MyMeter");
DspSetTip(nAN, "Click me to record the number of clicks");
Por este texto:

nAN = AnByName("WebBrowser");
DspSetTip(nAN, "My Web Browser");
61
&
6. Selecione várias linhas de texto na nova função e clique no ícone Comment . Se não
estiver visualizando o ícone, clique com o botão direito do mouse na barra de ferramentas
e selecione Format nas opções do menu. Em seguida elimine os comentários das linhas
de código marcando o texto e em seguida clicando no ícone Uncomment .
7. Selecione algumas linhas de texto e clique no ícone Indent . Retorne

com o texto em sua localização original, marcando-o e clicando no ícone Outdent
.
8. Coloque um marcador ao lado da nova função clicando com o botão direito
do mouse na barra indicadora ao lado do novo código. Pressione F2 no teclado. O
cursor irá parar em todos os marcadores.
= #% ! # =!1
Lista de Funções no Cicode e no CiVBA
Agora está disponível uma lista de funções que dependem do contexto (Cicode ou VBA).
Clique com o botão direito do mouse no arquivo e selecione List Functions no menu ou
CTRL+SPACE no teclado. Este procedimento mostrará uma lista das funções do Cicode ou
uma lista das funções do CitectVBA, no caso a mais adequada para o arquivo atual.
62
&
Funções do Cicode Funções do CitectVBA

Pode-se encontrar a função que se necessita escrevendo-se o nome do arquivo ou usando a
barra de navegação. Ao escrever o nome da função, a lista se deslocará até abaixo da
primeira função cujos caracteres iniciais coincidem com os que foram escritos. Observe que a
ajuda de ferramentas passa ser um quadro em que se mostra a função completa com todos
os seus parâmetros. Ao aplicar um clique duplo na função, ela é inserida no documento no
ponto de inserção.
Mensagem Automática de Intellisense

No exemplo anterior uma mensagem automática é mostrada na parte superior da lista de
funções quando uma determinada função é selecionada. Esta mensagem automática
também será mostrada por ocasião da digitação do nome correto da função e do primeiro
parênteses na área edição conforme mostrado abaixo:
, &)
& 4-4
Escreva uma nova função do Cicode para calcular a área de um círculo.
1. Abra o arquivo Treinamento.ci que você criou anteriormente.
2. Crie uma função simples para calcular a área de um círculo.
REAL
FUNCTION
AreaofCircle(REAL rRaio)
REAL Area;
63
&
Area = pi()* POW(rRaio,2);

RETURN Area;
END
3. Salve seu arquivo e compile.
4. Feche o arquivo Training.ci e pressione F5 para atualizar a lista de arquivos. Abra a

árvore de projetos Cicode_Milk_V700_S com o tab Open Project selecionado de forma a
visualizar o arquivo Treinamento.ci.
5. Abra o arquivo Treinamento.ci aplicando um duplo clique em seu nome na lista Open
Project. Agora a função aparecerá em azul.
6. Crie uma função para comprovar sua nova função de usuário AreaOfCircle().
7. Debaixo do código da função AreaOfCircle() escreva o seguinte código:
8. Elimine o texto AreaOfCircle digitado acima e pressione CTRL+SPACE para listar as

funções do Cicode.
64
&
9. Todas as funções incorporadas e qualquer função que foram criadas pelo usuário e
compiladas aparecerão na lista. Ao clicar em uma das funções, será mostrada a função
completa na barra de ferramentas de ajuda. Aplique um duplo clique na função
AreaOfCircle() para inserir a função no ponto de inserção.
10. Utilize a instrução END para terminar a função.
FUNCTION
Teste()
AreaofCircle(20)
END
11. Salve seu arquivo e compile seu projeto.
. D!&#
Troca da aparência da janela de código
A janela de código pode ser personalizada de forma a refletir suas preferências quando
visualizando o código. Ao clicar com o botão direito do mouse na área de código e selecionar
Preferences no menu, aparecerá o quadro de diálogo mostrado abaixo:
O quadro acima permite ao usuário aumentar a largura do tabulador, marcar/desmarcar

tabulação automática, determinar sintaxe colorida ou não, identificação/mudança automática
para letras maiúsculas de palavras chaves e também tipo, cor e tamanho da fonte do código.
, &)
& 4-4
Troque as preferências default do Editor do Cicode utilizando um arquivo de Cicode
existente.
1. Abra o arquivo Sample.ci no projeto Example.
2. Clique com o botão direito do mouse na área de edição e selecione Preferences no

menu.
3. No quadro de diálogo Preferences troque o valor de Ancho Tab para 8 e clique em OK.
65
&
4. Todas as linhas com um tabulador se moverão para a direita.
5. Abra novamente o quadro de diálogos Preferences e clique agora no botão Font..
6. Troque a fonte default e clique no botão OK.
7. Elimine a seleção default de Sintax Coloring. Verifique no texto a mudança. Marque

novamente o quadro de seleção de Sintax Coloring.
8. Selecione o elemento Comments na lista de cores do quadro de diálogo Preferences.
Troque a cor default e comprove a alteração em sua área de trabalho.
66
&
9. Selecione o elemento Strings, marque as opções Bold e Italic. Clique no botão OK.
Comprove sua alt
67
&
68
6
=!1 &
69
=!1 &
70
=!1 &
O Vijeo Citect é fornecido com mais de 600 funções prontas em sua biblioteca. Uma função
ou combinação destas, pode usualmente executar a maioria das tarefas em seu sistema.
Entretanto, quando uma determinada funcionalidade não poder ser alcançada com as
funções disponíveis na biblioteca, você poderá escrever suas próprias funções.
Uma função do Cicode consiste de um pequeno programa que pode conter uma coleção de
declarações, variáveis, operadores, executores condicionais e funções.
'( #) *
• Escrita de funções Simples;

• Elementos das funções;
• O que são funções do tipo Public e Private;
• Declarações de Funções;
• O que são funções do tipo Void e Return;
• Como Atribuir nomes as Funções;
• Variáveis de Cicode;
• Conversão e designação de formato as variáveis do Cicode;
• Sobre Arrays no Cicode;
• Como utilizar comentários;
• Arquivos de Inclusão.
& ! =!1 % *
As funções do Cicode podem ter diferentes propósitos. Algumas são simples, criadas de
forma a substituir um comando ou expressão muito longa.
Por exemplo, o seguinte comando incrementa a variável tag COUNTER:
Execute IF COUNTER < 100 THEN COUNTER = COUNTER + 1;

command ELSE COUNTER = 0; END;
Este comando seria utilizado de maneira mais fácil (podendo ser reutilizado) se tivesse sido
escrito como uma função que pudesse ser chamado via um comando do tipo:
Execute
IncContador();
command
A função é escrita em um arquivo de Cicode:
71
=!1 &
SINTAXE DESCRIÇÃO
Scope Public ou Private
FUNCTION Informa ao Compilador onde começar a
compilar a função
IncContador() Que função será chamada
IF CONTADOR < 100 THEN O código que será executado quando a função
é chamada
CONTADOR = CONTADOR + 1;
ELSE
CONTADOR = 0;
END Termina a Declaração IF
END Isto indica ao compilador o final do código
O código pretendido é equivalente ao longo comando acima. O código

compilado executa as declarações uma a uma de cada vez, da mesma forma
que faz dentro dos comandos e das expressões.
! #, # =!1
Para aprender como escrever suas próprias funções, nós precisamos utilizar a sintaxe
correta. Nós iniciaremos tomando como exemplo um simples comando em um pseudocódigo.
Imagine que você está indo dizer “levante-se” para alguém.
Escrita em pseudocódigo, iria se parecer com o seguinte:
OLA
Levante()
SE dito ENTÃO
Levante;
SENÃO
Permaneça sentado;
TERMINADO
TCHAU
*% ! # =!1
As funções podem conter quatro elementos básicos, a saber:
• Scope - Escopo
• Declaration - Declaração
72
=!1 &
• Name – Nome da Função

• Statement - Declarações da Função
Neste capítulo, iremos olhar cada um destes quatro elementos individualmente.
=!1 '*& # F& G

Por default, o escopo de uma função é definido como PUBLIC. Entretanto, vamos considerar
uma boa prática utilizar a palavra PUBLIC explicitamente. Em outras palavras, elas podem
ser compartilhadas através dos arquivos de Cicode e podem ser chamadas de todas as
páginas dentro do projeto. Algumas vezes você pode necessitar escrever uma função cujo
escopo seja PRIVATE de forma a economizar memória. Isto significa que ela só está
disponível dentro do arquivo onde foi concebida (escrita). Para que uma função seja feita
PRIVATE, você deve adicionar este prefixo antes da função conforme mostrado abaixo. Se
nenhum escopo é declarado, então a função é PUBLIC por default. Entretanto, por motivo de
claridade nestes primeiros exemplos, nós iremos utilizar sempre a palavra PUBLIC.
Scope (PUBLIC or PRIVATE)

FUNCTION
NomeFuncao()
Statement;
END
3 &*
# #! =!1
No Cicode, as funções devem ser declaradas. Em outras palavras, você necessita fazer com
que o Cicode saiba o começo e o final do código da função. Você declara as funções
utilizando a palavra FUNCTION conforme mostrado abaixo;
Scope
FUNCTION
Par NomeFuncao()
companheiro
Statements;
END
Você deve finalizar sua função com a palavra END.
% #! =!1
Depois que uma função é declarada, você deve fornecer a ela um nome. Você pode utilizar
até 32 caracteres para nomear suas funções. Você pode utilizar qualquer nome válido exceto
palavras reservadas. O compilador não diferencia letras maiúsculas de minúsculas.
73
=!1 &
Quando escrevendo suas funções, constitui-se uma boa prática a mistura de letras
maiúsculas e minúsculas para melhor visualização, MyPageDisplay() é mais fácil de
ler do que mypagedisplay() ou MYPAGEDISPLAY().
Uma declaração de uma função deve conter parênteses () para acomodar os argumentos
(falaremos deles mais adiante), não importando se a função faz ou não uso deles, por
exemplo:
SCOPE
FUNCTION
NomeFuncao()
Statements;
END
3 &*
## 1
As declarações constituem o essencial sobre o que estamos fazendo. A declaração
representa o código que será executado quando a função é chamada. Por exemplo, se você
necessita escrever uma função para mostrar um aviso quando a bomba de pasta estiver
ligada, então a função poderia ser como a mostrada abaixo:
PUBLIC
FUNCTION
DeclaracaoExemplo ()
IF STATUS_BMB_PASTA THEN
PROMPT(“Bomba Pasta Ligada”);
Par ELSE As declarações
Companheiro
PROMPT(“Bomba Pasta Desligada”);
END
END
=!1
Todas as funções retornam alguma coisa após a execução, mesmo se for uma confirmação
de que a função foi executada com sucesso ou não. Entretanto, as funções do tipo Void,
quando chamadas, não retornam qualquer dado para a função de chamada ou para a linha
de comando. O comando ShutDown() utilizado no curso de configuração não retornou
nenhuma informação ou dado, ele apenas executou uma ação. As funções do tipo Void são
tipicamente utilizadas para executar um conjunto de tarefas em botões ou comandos de
teclado. As funções que estivemos tratando até o presente momento, com algumas exceções
são do tipo Void.
PUBLIC
FUNCTION
ExemploVoid()
74
=!1 &
IF STATUS_BMB_PASTA THEN
Prompt(“Bomba Pasta Ligada”);
ELSE
Prompt(“Bomba Pasta Desligada”)’
END
END
Observe que nada é retornado desta função, mas uma ação é executada quando é
mostrado se a bomba está ou não ligada na linha de Prompt.
Para chamar esta função nós poderíamos executar um comando tal como o mostrado abaixo:
Execute
ExemploVoid();
command
, &)
& 6-
1. No editor do cicode, abra o arquivo Treinamento.ci que criamos anteriormente. Escreva

uma função chamada DataHora() que irá mostrar a data no tag de variável STRING1 e a
hora no tag de variável STRING2.
2. Comece sua função definindo o Scope
PUBLIC
3. Em seguida declare a função
PUBLIC
FUNCTION
4. Adicione o nome da Função
PUBLIC
FUNCTION
DataHora()
5. Adicione as intruções que mostraram a data no STRING1 e a hora no STRING2
PUBLIC
FUNCTION
DataHora()
STRING1 = Date(3);
STRING2 = Time(1);
6. Termine (END) a função.
75
=!1 &
PUBLIC
FUNCTION
DataHora()
STRING1 = Date(3);
STRING2 = Time(1);
END
7. Crie um botão na página Treinamento abaixo do texto “Capítulo 5” para fazer a
chamada da função.
, &)
& 6-+
Crie uma função que podemos usar para gerar um alarme sonoro com uma mensagem do
tipo emergente na tela.
1. No editor do cicode, abra o arquivo Treinamento.ci Escreva uma função chamada
AudAlarm(). Esta função irá reproduzir um arquivo wav e mostrará um quadro de
mensagem.
2. Defina o Scope, a declaração e o nome da função
PUBLIC
FUNCTION
AudAlarm()
3. Utilize a função DspPlaySound() para reproduzir o arquivo wav FT1800ALF.wav. Este
arquivo se encontra dentro do diretório de projeto
PUBLIC
FUNCTION
AudAlarm()
DspPlaySound(“[RUN]: TT4200CH.wav”,0);
4. Adicione a função Message() para mostrar uma mensagem de advertência ao mesmo
tempo. Termine (END) a função.
PUBLIC
FUNCTION
AudAlarm()
DspPlaySound(“[RUN]: TT4200CH.wav”,0);
Message(“ATENCAO OPERADOR”, “ALTA TEMPERATURA^n GERADOR 3”, 48);
END
5. Utilize um evento para ativar a função quando HTA (Holding Tube Alarm) tenha a
condição .H (ALTA) ou .HH (ALTA ALTA).
6. Abra o Editor de Projetos do Vijeo Citect e selecione no menu System|Events.
7. Adicione um evento de alarme que ative esta função quando o Holding Tube Alarm
76
=!1 &
alcançar o estado ALTA ou ALTA ALTA. A figura abaixo ilustra.
8. Utilize o Computer Setup Wizard no modo Custom Setup para ativar o evento de
alarme conforme mostrado abaixo.
# / &
Uma variável do Cicode representa uma posição de memória nomeada onde dados podem
ser armazenados. São similares aos PLC’s no que tange a forma de armazenamento de
variáveis.
Registros PLC Memoria Computador
Valor Nivel_Silo iMedia

Valor Temp_Forno rArea
Valor Tag_String sMeuNome
77
=!1 &
Desde que tags de variáveis estão habilitados para armazenar informação, eles podem ser
utilizados em suas funções de Cicode. Entretanto, se você deseja armazenar algum dado
temporariamente e não deseja utilizar um tag de variável da base de dados do Vijeo Citect,
você deve declarar e fazer uso de uma variável do Cicode.
As variáveis do Cicode podem armazenar os seguintes tipos básicos de dados:
- STRINGS;
- INTEIROS;
- REAIS;
Cada variável é específica para seu tipo de dados. Por exemplo, se você fizer o setup de uma
variável para armazenar um valor inteiro, você não pode utilizá-la para armazenar valores
reais ou do tipo strings.
Conseqüentemente, se você pretende utilizar uma variável em uma de suas funções do
cicode, você precisa declarar o tipo de dado que esta variável irá utilizar. Você também
precisa declaração a localização desta variável.
Os tags de variáveis da base de dados são declarados mediante o uso do formulário
Variable Tags encontrado no Editor de Projetos do Vijeo Citect. A figura abaixo ilustra:
No exemplo anterior, a função foi criada para retornar a média de dois números. O Cicode
não sabe que tipo de dado estará contido na média. Conseqüentemente, você precisa
informar o cicode que tipo de dado a média irá retornar. Por isso é necessário incluir a
linha INT Media; de forma a fazer com que o cicode saiba que tipo de dado a média irá
retornar.
Uma variável do Cicode pode ser definida como um dos seguintes três tipos: GLOBAL,
MODULE, e LOCAL. Por default, as variáveis são do tipo MODULE, a menos que
declaradas dentro das funções.
Esta é a sintaxe quando declarando variáveis:
78
=!1 &
SCOPE TIPODADO NOME = VALOR INICIAL COMENTÁRIO

ReturnTipoDado
Este é o escopo da
FUNCTION variável não o escopo
da Função. Não
NomeFuncao()
confunda os dois.
Statement;
RETURN Valor;
END
Quando declarando variáveis, vocês devem utilizar uma formatação consistente. Uma
declaração de variável pode ter até 05 partes. Cada parte deve ser separada por pelo
menos um TAB.
Para maiores informações sobre Declarações de Variáveis no Cicode, veja Vijeo

Citect Help Topics - Variable Declaration
# / 8*'#
Uma variável Global do Cicode pode ser compartilhada entre todos os Cicode files
existentes no sistema (bem como entre projetos include). Elas não podem ser acessadas em
páginas ou base de dados (por ex., Alarm.dbf)
As variáveis Globais do Cicode possuem como prefixo a palavra chave GLOBAL. É
recomendado que elas sejam declaradas no início de um arquivo do Cicode. Por exemplo:
GLOBAL STRING sPaginaDefault ="Mimic";
EXEMPLO:
INT
FUNCTION
ExemploGlobal(STRING sPagina)
INT iStatus;
iStatus = PageDisplay(sPagina);
IF iStatus <> 0 THEN
PageDisplay(sPaginaDefault);
END
RETURN iStatus;
END
A variável sPaginaDefault poderia então ser utilizada em qualquer função de qualquer
arquivo do Cicode no sistema.
79
=!1 &
Você deve utilizar variáveis Globais com cautela no seu sistema – se você tem
muitas destas variáveis sendo utilizadas por muitas funções, procurar por problemas
quando depurando seu programa pode tomar muito tempo. Utilizem variáveis
Locais sempre que possível.
# / *
# - *
Uma variável do tipo Module do Cicode é específica ao arquivo do Cicode na qual foi
declarada. Isto significa que ela pode ser utilizada por qualquer função naquele arquivo, mas
não por uma função de outros arquivos. Por default, as variáveis do Cicode são definidas
como Module (Modulares). Conseqüentemente, o prefixo não é requerido, mas deve ser
colocado por melhorar a visualização.
As variáveis do tipo Module devem ser declaradas antes das funções que farão uso delas,
por exemplo:
MODULE STRING sPaginaDefault = "Mimic";
Isto estabelece que o valor inicial para sPaginaDefault é “Mimic”. Ele pode então ser
utilizado por todas as funções no arquivo corrente.
EXEMPLO:
MODULE STRING sPaginaDefault = "Mimic";
PUBLIC
INT
FUNCTION
MostraMinhaPagina(STRING sPagina)
INT iStatus;
iStatus = PageDisplay(sPagina);
IF iStatus <> 0 THEN
END
RETURN iStatus;
END
PUBLIC
FUNCTION
MostraMinhaPagina()
END
Você deve, assim como para variáveis Globais, fazer um uso moderado das
variáveis ditas Modulares – Se você tem muitas destas variáveis sendo utilizadas
por diversas funções, procurar por problemas quando depurando seu programa
pode tomar muito tempo. Utilizem variáveis Locais sempre que possível.
80
=!1 &
# / &#
Uma variável Local do Cicode é apenas reconhecida pela Function dentro da qual ela foi
declarada e apenas pode ser utilizada por aquela função. Você deve declarar as variáveis
locais antes de utilizá-las.
Qualquer variável definida dentro de uma função (por exemplo, depois do nome da
função é uma variável local, portanto não necessita de prefixo).
As variáveis Locais são destruídas quando a função deixa de existir.
As variáveis Locais sempre têm precedência sobre as variáveis Globais e Modulares.
Se você define uma variável Local em uma função com o mesmo nome que uma
variável Global ou Module, a variável Local será utilizada. As variáveis Global/Module
não são afetadas pela função. Esta situação deve ser evitada, dado que possivelmente
irá causar confusão, ambigüidade e com certeza pesadelos quando da manutenção das
rotinas.
EXEMPLO:
PUBLIC
INT
FUNCTION
ExemploLocal(INT a, INT b)
INT iMedia
iMedia = (a + b) /2;
RETURN iMedia
END
# 1 H #! ' ! % ##
# /
Cada tipo de dado da variável necessita ser nomeado quando da declaração da variável. A
seguinte convenção é adotada:
INT (32 bits) i Indices, contador de loops
BOOLEAN (32 bits) i True/False
REAL (32 bits) r Variáveis reais
STRING (255 bytes) s Variáveis do tipo string
Para maiores informações sobre padrões, veja Citect Help Topics - Variable Naming
Standards.
#$ # /
Você pode utilizar qualquer variável que tenha declarado na base de dados (no formulário
Variable Tags) em suas funções. Elas foram utilizadas no exercício 1-1. Para fazer uso de
uma variável da base de dados, especifique o nome do tag da seguinte form:
81
=!1 &
<Tag>
Onde <Tag> é o nome da variável da base de dados. Por exemplo, para alterar o
valor da variável VEL_MOINHO da base de dados, você utilizaria a seguinte
declaração em sua função:
VEL_MOINHO =1200; Isto iria trocar o valor de VEL_MOINHO 1200.
, &)
& 6-4
Depure três diferentes funções do Cicode
1. Abra o arquivo do Cicode denominado “Ch4Bugs.ci” e visualize seus componentes.
2. Retire os comentários de uma função por vez, compile o projeto e depure os erros
encontrados. As funções a serem depuradas são AreaofCircle(), ShowPrompt () e
Average ().
, &)
& 6-6
Crie outra função de alarme sonoro com variáveis locais
1. A função existente deveria ter um aspecto similar a este:
PUBLIC
FUNCTION
AudAlarm()
DspPlaySound("[RUN]: TT4200CH.wav",0);
Message("ATENCAO OPERADOR", "ALTA TEMPERATURA^n GERADOR 3", 48);

END
2. Copie e cole a função abaixo de sua função original. Em seguida troque o nome da
função copiada para AudAlarm2().
3. Substitua todos os argumentos das funções internas a ela por variáveis locais do
Cicode. A figura abaixo ilustra:
PUBLIC
FUNCTION
AudAlarm2()
DspPlaySound(sFile,0);
Message(sTitle, sMessage, 48);
END
4. Declare as variáveis internas utilizadas acima dentro dos parênteses do nome da função
conforme mostrado abaixo
82
=!1 &
PUBLIC
FUNCTION
AudAlarm2(STRING sFile, STRING sTitle, STRING sMessage)
DspPlaySound(sFile,0);
Message(sTitle, sMessage, 48);
END
5. Chame a função através de um novo botão a ser desenhado na página Treinamento

abaixo do texto Capítulo 5. Agora que foram utilizadas variáveis internas do Cicode, é
possível introduzir o nome e o path do arquivo, o título da mensagem bem com a
mensagem quando a função é chamada através de um botão. Em outras palavras, a
função poderá ser utilizada repetidamente com argumentos distintos.
AudAlarm2(“C:\Schneider Application\Vijeo Citect 7.0\User\CicodeV710_S\

TT4200CH.wav”, “ATENÇÃO OPERADOR”, “ALTA TEMPERATURA^nGERADOR
3”)

7. Execute seu projeto para comprovar sua nova função.
! " 3 $!# " . %# ###

# / &
83
=!1 &
Tipos de dados
Os tipos de dados são gerenciados de forma bastante rígida no Cicode. Se desejamos
introduzir números mediante a função Input() e utilizamos estes números em um cálculo, é
necessário trocar o tipo de dado de um STRING para um número INTEIRO ou REAL. O
motivo é que a função Input() devolve dados do tipo STRING. Não se pode utilizar STRINGS
nos cálculos matemáticos. Por outro lado, se desejamos mostrar o valor de um número
INTEIRO ou REAL em um relatório, precisamos trocar seu tipo para STRING.
Este processo denomina-se Conversão. O Vijeo Citect proporciona quatro funções para
converter números inteiros e reais para string e vice versa.
TIPO FUNÇÃO
IntToStr() Converte um número inteiro em uma STRING
RealToStr() Converte um número real em uma STRING
StrToInt() Converte uma string em um número inteiro
StrToReal() Converte uma string em um número real
Também está disponível uma série de funções de data e hora que convertem as variáveis de
hora em STRINGS para sua visualização.
TIPO FUNÇÃO
TimeToStr() Converte uma variável de hora e data em uma
string
StrToDate() Converte uma string de data em uma variável de
hora e data
, &)
& 6-:
Utilize a função RealToStr() o valor do tag TIC_HOLD_PV em uma mensagem emergente.
1. Abra a página Treinamento e crie um botão denominado Holding Tube abaixo do texto
Capítulo 5.
2. Adicione a função Message() a entrada ÙP Command com o tab horizontal Input e o tab
vertical Touch selecionados.
Message(“Holding Tube”, “TIC_HOLD_PV”, 64)

3. O problema com esta função é que o tag TIC_HOLD_PV é do tipo REAL e a função
Message() somente pode mostrar STRINGS. Aqui é necessário usar a função
RealToStr(). Esta função tem três argumentos: o número de ponto flutuante que será
convertido, o tamanho da STRING e o número de casas decimais.
RealToStr(TIC_HOLD_PV,6,3);
4. No comando Message() original, substitua o tag TIC_HOLD_PV pela função função. A
expressão resultante terá o aspecto similar a este:
84
=!1 &
Message(“Holding Tube”, RealToStr(TIC_HOLD_PV,6,3), 64)

, &)
& 6-;
Crie uma função que lhe permita utilizar um quadro de entrada para introduzir um valor do
tipo string, que em seguida seja transferido para um tag inteiro.
1. Crie uma nova função denominada OperatorInput().
FUNCTION
OperatorInput()
2. Adicione a função Input() conforme mostrado abaixo:
FUNCTION
OperatorInput()
Input(“Entrada de Valores”,”Insira Valor Desejado”, “”);
3. Vamos definir uma variável local do cicode denominada sTag para receber o valor
retornado pela Input().
FUNCTION
OperatorInput()
STRING sTag = “”;
sTAg = Input(“Entrada de Valores”,”Insira Valor Desejado”, “”);
4. Adicione uma instrução para transferir o valor de sTag para o tag LIC_SILO_PV.
FUNCTION
OperatorInput()
LIC_SILO_PV = sTag;
5. Converta o valor de sTag em um valor inteiro antes de atribuí-lo ao tag LIC_SILO_PV e

termine sua função (END)
85
=!1 &
FUNCTION
OperatorInput()
LIC_SILO_PV = StrToInt(sTag);
END
6. Crie um novo botão na sua página de Treinamento denominado Input. Adicione a função
acima no Up command.
7. Salve seu arquivo e compile o projeto.
8. Execute seu projeto. Na página de Treinamento pressione o botão Operator Input.
9. Insira um novo valor, pressione o botão OK e verifique se o valor é encaminhado para o

tag LIC_SILO_PV.
10. O objeto de texto LIC_SILO_PV mostrará o input realizado pelo operador conforme
mostrado abaixo:
86
=!1 &
, &)
& 6->
Crie um arquivo de inclusão (Include File) para poder utilizar a função AudAlarm2() criada
anteriormente como ação em um Evento.
1. Abra o Notepad do Windows.
2. Crie um arquivo denominado Alarms.cii. Salve este arquivo dentro do seu diretório de
projeto.
No quadro de diálogo de Salvar do Notepad, selecione o tipo como tipo: Todos os

arquivos. Do contrário o Notepad salvará o arquivo como Alarms.cii.txt e o Vijeo Citect
não o reconhecerá.
3. Adicione a função abaixo ao arquivo Alarms.cii e salve-o.
AudAlarm2("C:\Schneider Application\Vijeo Citect

7.0\User\CicodeV710_S\TT4200CH.wav", "ATENÇÃO OPERADOR", "ALTA
TEMPERATURA^nGERADOR 3")
4. Abra o Editor de Projetos do Vijeo Citect e crie um evento para executar a função
AudAlarm2() quando o alarme HTA alcançar seu estado BAIXO ou BAIXO BAIXO.
5. Adicione o evento abaixo ao formulário. Não se esqueça de executar o Computer Setup
Wizard para assegurar-se de que os eventos estão habilitados.
Estamos considerando que o Include File Alarms.cii estará inserido no diretório do

projeto. Se utilizar outra localização será necessário especificar o path completo da
pasta seguido do nome do arquivo.
6. Compile e execute seu projeto. Abra a página de treinamento, altere a temperatura do

87
=!1 &
Holding Tube de forma a forçar as condições de alarmes desejadas.
88
:
,& ! & !#
89
,& ! & !#
90
,& ! & !#
As declarações que controlam decisões e loop’s em suas funções são chamadas de

executores condicionais. O Cicode utiliza quatro executores condicionais: IF, FOR, WHILE e
SELECT CASE.
'( #) *
Neste capítulo você irá aprender sobre:
• Os quatros executores condicionais:
- IF
- FOR
- WHILE
- SELECT CASE.
3 &*
## " =
A declaração IF é utilizada para executar uma seção do código baseada no resultado de
algum teste condicional. Existem dois formatos de declaração IF; IF THEN ou IF THEN
ELSE. A sintaxe para ambas está mostrada abaixo:
IF Expressão THEN
Statement(s);
END
- ou -
IF Expressao THEN
TRUE Statement(s);
ELSE
FALSE Statement(s);
END
Exemplo:
// O seguinte fragmento de código utiliza uma declaração IF
FUNCTION TestaServer()
STRING sServer;
sServer = ServerInfo("CLIENT", 0);

IF (sServer="CTCitect1") THEN
iflagheartbit = 1;
iflagbooleana = 1;
END
IF (sServer="CTCitect2") THEN
IF NOT iflagheartbit THEN
91
,& ! & !#
!Se o flag de heartbeat FOR 0, quer dizer que o server não está mudando !ele. Nós
temos que assumir a escrita
iflagbooleana = 1;
ELSE
!Se o flag = 1, então o server está rodando. Zera ele para detectar na !próxima vez
iflagheartbit = 0;
iflagbooleana = 0;
END
END
END
Para o formato IF THEN as declarações são apenas executadas se a expressão é TRUE (1).
O formato IF THEN ELSE é utilizado para ramificação. As declarações TRUE são executadas
se a expressão é TRUE. De outra forma, as declarações FALSE é que serão executados.
Você também pode encadear declarações IF. Mas se você tem diversas declarações IF’s,
então você deve considerar a utilização das declarações SELECT CASE.
, &)
& :-
Escreva uma função do Cicode que utilize a instrução IF THEN ELSE.
1. Crie uma função denominada IF_Example1.
2. Utilize a instrução IF THEN ELSE para abrir um quadro de mensagem que venha a
mostra as mensagens running ou stopped dependendo do status do tag
CENTRIFUGE_CMD.
FUNCTION
IF_EXAMPLE1()
IF CENTRIFUGE_CMD =1 THEN
Message(“Clarifier Status”, “Running”,64);
ELSE
Message(“Clarifier Status”, “Stopped”,64);
END
END
Quando se está escrevendo funções é conveniente tabular o código de forma a

facilitar a leitura e compreensão do mesmo. Observe que existem duas instruções
END, uma para terminar a declaração IF THEN ELSE e a outra para terminar a
FUNCAO. Com a tabulação podemos perceber isto facilmente.
3. Salve seu arquivo e compile o projeto.
4. Desenhe um novo botão denominado CLARIFIER STATUS na página Treinamento,

abaixo do texto “Capítulo 6” para chamar a nova função.
5. Adicione o nome da função na entrada Up Command. Salve seu projeto e compile-o
novamente.
6. Comprove o funcionamento da nova função.
, &)
& :-+
92
,& ! & !#
Escreva uma função do Cicode que utilize a instrução IF THEN ELSE que use variáveis
locais do Cicode
1. Copie a função que criou no exercício anterior e cole abaixo da mesma. Dê o nome de
IF_Example2() para a nova função.
2. Declare variáveis para o tag, para o título e para as mensagens de entrada e saída dentro
dos parênteses do nome da função conforme mostrado abaixo.
IF_Example2(INT iTag1, STRING sTitle, STRING sOnMessage, STRING sOffMessage)
3. Substitua as variáveis originais pelas variáveis que você acabou de declarar.
FUNCTION
IF_EXAMPLE2(INT iTag1, STRING sTitle, STRING sOnMessage, STRING
sOffMessage)
IF iTag1 =1 THEN
Message(sTitle, sOnMessage,64);
ELSE
Message(sTitle, sOffMessage,64);
END
END
4. Crie um botão na página Treinamento chamado STATUS^n AGITADOR SILO.
5. Selecione a ficha Input(Touch) e adicione o comando abaixo na entrada UP Command.

IF_EXAMPLE2(SILO_CMD, “STATUS AGITADOR”, “AGITADOR
RUNNING”,”AGITADOR STOPPED”)
6. Salve sua página e compile seu projeto.
7. Execute seu projeto e comprove o novo comando.
=
O loop FOR é utilizado para executar um conjunto de declarações um determinado número
de vezes.
FOR Variável = Expressao1 TO Expressao2 DO

Statement(s);
END
Onde:
Variavel : é uma variável definida utilizada para contar o número de
vezes que a declaração foi executada
Expressao1 : é o valor de contagem inicial
93
,& ! & !#
Expressao2 : é o valor de contagem final
Considere o seguinte exemplo:

STRING ArrayA[5]="Este","e","um","String","Array";
INT
FUNCTION
MostraArray()
INT Contador;
FOR Contador = 0 TO 4 DO
Prompt(ArrayA[Contador]);
Sleep(2);
END
RETURN 0;
END
, &)
& :-0
Crie as seguintes funções abaixo dentro de sua pasta Treinamento.ci.
1. Crie uma função denominada FOR_Example1() que incremente o tag LIC_BALANCE_PV
de LIC_BALANCE_PV a LIC_BALANCE_SP.
2. Crie uma função denominada FOR_Example2() que decremente o tag
LIC_BALANCE_PV de LIC_BALANCE_PV a LIC_BALANCE_SP.
3. Crie uma terceira função denominada FOR_Example3() que altere o valor do tag
LIC_BALANCE_PV a LIC_BALANCE_SP independentemente se LIC_BALANCE_PV é
maior ou menor que LIC_BALANCE_SP.
Neste terceiro exercício procure utilizar IF THEN ELSE com FOR
IJ
O loop WHILE é utilizado para executar declarações de forma repetitiva enquanto a
declaração condicional é TRUE (1).
WHILE Expressao DO
Statement(s);
END
Por exemplo:
// O seguinte fragmento de código utiliza o loop WHILE:
FUNCTION AnimaMaq()
INT WAIT_TIME = 1000; ! numero ms chamadas Animações

INT hTask1 = -1; !handle Task Animaçoes Maquina1
WHILE TRUE DO
94
,& ! & !#
hTask1 = TaskNew("AnimacoesMaq1","",4+8);
IF hTask1 = <> -1 THEN

TraceMsg(“Task AnimacoesMaq1 criada com sucesso!”);
ELSE
TraceMsg(“Falha na criação da Task AnimacoesMaq1!”);
END
SleepMS(WAIT_TIME);
END
END
, &)
& :-4
Crie as seguintes funções abaixo dentro de sua pasta Treinamento.ci.
1. Crie uma função denominada WHILE_Example1() que decremente o tag
LIC_BALANCE_PV enquanto PUMP_FEED_CMD seja TRUE e faça a
LIC_BALANCE_PV = 100 quando PUMP_FEED_CMD for FALSE.
2. Adicione uma condição extra na rotina acima de tal forma que faça LIC_BALANCE_PV =
100 quando LIC_BALANCE_PV <20.
3. Crie um botão na página Treinamento de forma a comprovar a função.
3 &*
## "
A declaração SELECT CASE executa um dos diversos grupos de declarações, dependendo
do resultado de uma expressão. As declarações SELECT CASE constituem a maneira mais
eficiente de se escrever códigos que de outra forma teriam de ser escritos com declarações
encadeadas do tipo IF THEN.
SELECT CASE Expressao

CASE CaseExpressao1
Statement(s);
CASE CaseExpressao2
Statement(s);
------------------------
CASE CaseExpressaoN
Statement(s);
CASE ELSE
Statement(s);
END SELECT
Onde :
Expressao Expressão a ser testada

CaseExpressao1 Teste para a primeira condição
95
,& ! & !#
CaseExpressao2 Teste para a segunda condição
CaseExpressaoN Teste para a enézima condição
CASE ELSE Teste de execução caso nenhuma das condições anteriores

tenha sido encontrada
Se a Expressao iguala-se a qualquer CaseExpressao, as declarações que se seguem a

aquela condição CASE são executadas até a próxima condição CASE ou (para a última
condição) até a END SELECT. Se a Expressao iguala-se a CaseExpressao em mais de
uma condição CASE, apenas as declarações que se seguem após a primeira serão
executadas.
A condição CASE ELSE é utilizada para indicar as declarações que serão executadas se
nenhuma igualdade é encontrada entre Expressao e qualquer das CaseExpressao. Quando
não existir a declaração CASE ELSE e nenhuma igualdade é encontrada entre Expressao e
qualquer das CaseExpressao, a execução continua na próxima declaração do Cicode
seguinte a END SELECT.
Por exemplo, se os quatro possíveis estados de um navio quando atracado são:
- Esperando;
- Ancorado;
- Carregando;
- Carregado;
Uma declaração Select Case poderia ser executada de um botão para mostrar uma
mensagem detalhando o status corrente do navio como mostrado abaixo:
SELECT CASE iStatus
CASE 1
Prompt(“Esperando”);
CASE 2
Prompt(“Ancorado”);
CASE 3
Prompt(“Carregando”);
CASE 4
Prompt(“Carregado”);
CASE ELSE
Prompt(“Sem Status”);
END SELECT
, &)
& #! # :-6
Escreva uma função do Cicode chamada QueDiaeHoje() e que utiliza a declaração
SELECT CASE;
96
,& ! & !#
1. Utilize a função Input() para aceitar um número entre 0 e 6. Você deve checar se um
número válido foi inserido, ecoando uma mensagem na linha de Prompt se ocorrer um
número inválido. Sua declaração SELECT CASE deverá atribuir ao tag de variável
STRING1 o dia da semana representado pelo número, por exemplo, 0 representaria
Domingo, 1 representaria segunda-feira e assim sucessivamente.
2. Defina a função:
FUNCTION
QueDiaeHoje()
STRING sInput = “” ;
INT iDelivery_day;
sInput =Input(“Entrada Valores”, “Insira Valor Desejado”,””);
iDelivery_day = StrToTInt(sInput)
SELECT CASE iDelivery_day
CASE 0
STRING1 = “SUNDAY”;
CASE 1
STRING1 = “MONDAY”;
CASE 2
STRING1 = “TUESDAY”;
CASE 3
STRING1 = “WEDNESDAY”;
CASE 4
STRING1 = “THURSDAY”;
CASE 5
STRING1 = “FRIDAY”;
CASE 6
STRING1 = “SATURDAY”;
CASE ELSE
Message(“ERRO”, “DADO INVALIDO”, 64)
END SELECT
END
97
,& ! & !#
98
;
# .! 1 &
99
# .! 1 &
100
# .! 1 &
No capítulo 5 vimos às funções simples do Cicode. Neste capítulo amplia-se a funcionalidade

das funções do Cicode através da introdução de técnicas de programação mais complexas
'( #) *
Neste capítulo você ira aprender
• Funções do Tipo Return;
• Depuração de código;
• Arrays;
• Comentários.
=!1 !
As funções ou expressões do tipo Return retornam informação para a função de chamada ou
para a linha de comando. A função Time() é uma função do tipo Return. Ela retorna a hora
corrente que poderia ser utilizada em um relatório. Funções do tipo Return são tipicamente
utilizadas para mostrar informações em relatórios, alarmes, etc e para retornar handles
(manipuladores), erros codificados em números, etc.
Uma função do tipo Return requisita que uma resposta retorne para você. If você está para
dizer para alguém “Como vai você?”, então o valor esperado de retorno poderia ser “Estou
bem!”.
Em pseudocódigo, esta função poderia ser como a mostrada abaixo:
DIALOGO
FUNCTION
ComoVaiVoce()
RETURN Estou Bem;
END
A sintaxe da função do tipo Return é mostrada abaixo:
Isto indica o tipo de

SCOPE dado retornado pela
função; INT, REAL ou
TipoDadoRetornado STRING
FUNCTION
2 NomeFuncao({Arg1DataType Arg1} {=DefaultValue}, ...,
# "
Statement(s);
Este é o dado que
RETURN RetornaDado;
será retornado
END
101
# .! 1 &
Um exemplo de uma função do tipo Return está mostrado abaixo:
PUBLIC
INT
FUNCTION
ExemploReturn (INT a, INT b)
INT iMedia; Esta é uma
iMedia = (a + b) /2
variável local já
RETURN iMedia;
END
A função recebe o valor de dois números inteiros e calcula a média entre eles. Para chamar
esta função, você pode utilizar a seguinte expressão:
Numeric
ExemploReturn(TAG1 , TAG2);
expression
Onde TAG1 e TAG2 são tags inteiros. O valor mostrado na página gráfica será a média entre
estes dois tags.
Funções do tipo Return proporcionam maior flexibilidade que uma função do tipo Void No
exemplo seguinte, a função coloca informação em um tag específico denominado Recipe.
Por isto necessitamos das funções do tipo Return.
, &)
& ;-
Crie uma função do tipo Return denominada AverageEx2().
1. Localize no arquivo Treinamento.ci a função AverageEx1() criada anteriormente. O
código deveria ter o seguinte aspecto.
FUNCTION
AverageEx1()
TIC_P2_PV = (TIC_P1_PV + TIC_P4_PV)/2
END
2. Copie e cole esta função em um novo arquivo de cicode. Salve este novo arquivo como
MoreFunctions.ci.
3. Converta esta função em uma função do tipo Return. Primeiro adicione o tipo de dado de
devolução.
INT
FUNCTION
AverageEx2()
TIC_P2_PV = (TIC_P1_PV + TIC_P4_PV)/2
END
4. Defina uma variável local para receber o resultado da operação. Adicione em seguida o
comando Return.
INT
FUNCTION
102
# .! 1 &
AverageEx2()
INT iMedia;
iMedia = (TIC_P1_PV + TIC_P4_PV)/2;
Return iMedia;
END
5. Salve seu arquivo. Crie um botão na página Treinamento abaixo do texto Capítulo 7 que
chame esta função e devolva o resultado no tag TIC_P3_PV.
7. Crie outra função de devolução que utilize somente variáveis locais do Cicode para
calcular o valor médio de dois tags.
8. Copie o código anterior e cole abaixo a função AverageEx2(). Altere o nome da função
para AverageEx3().
9. Troque os tags TIC_P1_PV e TIC_P4_PV pelas variáveis locais iTagX e iTagY.
10. Defina estas variáveis dentro dos parentes conforme mostrado anteriormente.
11. O código alterado deverá ter a seguinte aparência:
INT
FUNCTION
AverageEx3(INT iTagX, INT iTagY)
INT iMedia;
iMedia = (iTagX + iTagY)/2;
Return iMedia;
END
12. Salve o arquivo. Crie um botão na página Treinamento abaixo do texto Capítulo 7 que
calcule o valor médio dos tags TIC_P4_PV e TIC_HW_PV e devolva o resultado em
TIC_HOLD_PV.
13. Salve a página, compile seu projeto e comprove a nova função.
103
# .! 1 &
, &)
& ;-+
Converta a função OperatorInput() em uma função do tipo Return.
1. Copie a função OperatorInput() criada anteriormente no arquivo Treinamento.ci e salve
com o nome EnterTagValue() na pasta MoreFunctions.ci.
FUNCTION
EnterTagValue()
STRING sTag;
LIC_SILO_PV = StrToInt(sTag);
END
2. Converta a função em uma função do tipo Return.
INT
FUNCTION
EnterTagValue()
STRING sTag;
Return StrToInt(sTag);
END
3. Salve seu arquivo.
4. Abra a página Treinamento e adicione a nova função aos objetos de texto dos tags INT,
por exemplo:
INT1 = EnterTagValue()
5. Salve a página e compile o projeto.
6. Execute o projeto e comprove os novos comandos.
, &)
& ;-0
Converta a função OperatorInput() em uma função do tipo Return.
1. O arquivo Ch7Bugs.ci contem três funções com pequenos erros. Depure estas funções.
2. Abra o arquivo e verifique seu conteúdo.
3. Elimine o comentário de uma função por vez, compile o projeto e depure os erros.
#K
Um array é uma coleção de variáveis do mesmo tipo de dado, organizados em forma de uma
lista ou tabela. Você atribui nomes e declara um array da mesma forma que qualquer outro
tipo de variável. Você pode então fazer referência a cada elemento no array da mesma forma
que qualquer outra variável fazendo uso de um index para indicar sua posição no array.
UNIT A UNIT B UNIT C UNIT D
104
# .! 1 &
Considere uma fila de unidades habitacionais numeradas com A,B,C e D. Esta fila é como um
array e cada uma das unidades é um elemento deste array. Cada elemento contém um valor.
Neste exemplo comparativo, cada unidade contém um numero de pessoas.
O array poderia ser nomeado da seguinte forma:
Apartamento[4]
desde que existem 4 elementos no array. No Cicode, os arrays são numerados a partir do
zero (0). Desta forma, nós poderíamos fazer referência a cada uma das unidades da seguinte
forma:
UNIT A Apartamento[0]
UNIT B Apartamento[1]
UNIT C Apartamento[2]
UNIT D Apartamento[3]
Os argumentos (valores) para cada um dos apartamentos (variáveis) são os números de

pessoas em cada apartamento em qualquer hora.
! #,
Os arrays possuem a seguinte sintaxe:
TipodeDado Nome[tamanho] =Valores;
Onde: TipodeDado pode ser INT, REAL ou STRING

Nome é o nome do array
[Tamanho] é o tamanho do array
=Valores são os valores default para o array.
Nota: Valores são opcionais
Por todo o corpo da função, o array é referenciado por seu nome e seus elementos
individuais são referenciados por seus índices. O índice do primeiro elemento de um array é
zero (0) (por exemplo, um array de quatro elementos possui os índices 0,1,2 e 3). Você pode
utilizar qualquer nome exceto palavras reservadas, por exemplo:
STRING StrArray[5];
Você deve sempre declarar o tamanho do array (o numero de elementos que o array
contém) como no exemplo abaixo:
STRING StrArray[5];
Este array contém 05 elementos. O compilador multiplica o número de elementos no array
pelo tamanho de cada elemento (que depende do tipo de dado utilizado) e aloca posições de
memória consecutiva para armazenagem do array.
! &#*2#! % #K
105
# .! 1 &
Quando você declara um array, você pode (opcionalmente) inicializar seus elementos
individuais para valores iniciais (de startup) como mostrados abaixo:
STRING ArrayA[5]="Este","e","um","String","Array";
Este conjunto inicializa os seguintes elementos:
ArrayA[0]="Este"
ArrayA[1]="e"
ArrayA[2]="um"
ArrayA[3]="String"
ArrayA[4]="Array"
3% ! 1 #K
Os arrays podem também possuir mais de uma dimensão. Se você deseja utilizar mais de
uma dimensão, a sintaxe abaixo mostra como fazê-lo:
TipoDado Nome[Dimensao1Tamanho][Dimensao2Tamanho][Dimensao3Tamanho] =Values;
Quando você inicializa seu array, as alternativas abaixo são aplicáveis:
STRING StrArray[5]; ! lista

REAL Resultado[5][2]; ! 2-D table
INT IntArray[4][3][2]; ! 3-D table
*2#! #K
Algumas coisas importantes quando utilizando arrays são:
• Você não pode declarar um array local a uma função. Eles apenas podem ser
Modulares ou Globais (por ex., no início de um arquivo do Cicode).
• Quando fazendo referência ao array dentro de sua função, você não deve
exceder o tamanho do conjunto que você declarou para o array. O seguinte
exemplo poderia causar um erro fatal:
STRING StrArray[5];
Assim, se você tenta fazer uso da seguinte declaração
StrArray[10] = “Jorge”;
você estaria extrapolando o tamanho do array que definiu.

O compilador permite armazenagem para 05 strings. Atribuindo um valor para o 11o
elemento, você estaria fazendo com que a string fosse armazenada fora dos limites do array,
podendo estar sobrescrevendo outro valor armazenado na memória.
• Você não pode passar um array inteiro para uma função do Cicode.
106
# .! 1 &
, &)
& ;-4
Escreva uma função do tipo Return denominada RecipeSelection() que most a descrição
de uma receita.
1. Declare a nova função e designe um nome. O valor retornado será do tipo STRING.
STRING
FUNCTION
RecipeSelection()
2. Crie um Array de STRING que defina as descrições de texto das receitas de leite.
STRING sRecipeArray[5] = “FULL CREAM”, “LITE”, “SPORT”, “SKIM”, “HIGH PROTEIN”
STRING
FUNCTION
RecipeSelection()
3. Crie duas variáveis locais de Cicode, uma para o nome da receita como STRING e outra
para o número da receita como INT.
STRING sRecipeArray[5] = “FULL CREAM”, “LITE”, “SPORT”, “SKIM”, “HIGH PROTEIN”

STRING
FUNCTION
RecipeSelection()
STRING sRecipe;
INT iRecipe;
4. Adicione a expressão que abrirá o quadro de entrada e salve o resultado na variável de
cicode sRecipe.
sRecipe = Input(“Número Receita”,”Insira um número entre 0 e 4”, “0”)
5. Converta o valor de sRecipe de STRING para INT. Salve o resultado na variável iRecipe.
iRecipe = StrToInt(sRecipe);
6. Utilize a instrução SELECT CASE para designar as descrições de texto para CASE 0 TO
4. Utilize CASE ELSE para gerar uma mensagem de erro quando se introduzir um
número não válido.
SELECT CASE iRecipe
CASE 0 TO 4
RETURN sRecipeArray[iRecipe];
CASE ELSE
Message(“ERRO”,”NUMERO INVALIDO”,64);
END SELECT
7. Termine sua função (END) e salve o arquivo.
107
# .! 1 &
8. Adicione um botão denominado Recipe Array na página Treinamento abaixo do texto

Capítulo 7 para chamar a função e comprovar o funcionamento. O valor retornado deverá
ser mostrado no tag RECIPE.
Para mais informações sobre tamanhos de arrays, ver KB article Q1128
Maximum Size of Cicode Array
Article number: Q1128

Updated on: 20/02/2002
For Citect versions: 1.x 2.x 3.x 4.x 5.x
Summary
Question: What is the maximum size of a Cicode array variable?
Solution
The total size of a Cicode array is limited to 64k. The number of acceptable elements
will therefore depend on the size of each element in the array. For INT and REAL data
types, each element is 4 bytes plus some overhead -- this allows for a maximum of
15,359 elements in the array (16,364 elements in Vijeo Citect v1.x and v2.x).
Cicode STRINGs in an array are 128 bytes each plus overhead. CitectSCADA
versions before V5.10 allowed up to 479 STRINGs in each array (512 elements in
Vijeo Citect v1.x and v2.x).
However, after Version 5.10 this changed. Now CitectSCADA supports

Cicode STRINGs in an array that are 255 bytes each plus overhead. This means that
now only 250 STRINGs are supported in each array.
OBJECT arrays are not supported at this time. There is no limit to the total number of
Cicode variables. You can have many large arrays as long as each array is less than
64k in size.
% !/
A utilização de comentários constitui uma boa prática quando programando em Cicode. Os
comentários permitem a você rapidamente entender como a função trabalha na próxima vez
que você (ou outro projetista) precisar modificá-la.
O compilador do Cicode reconhece os seguintes comentários estilo linguagem C e C++:
! Um comentário de linha simples

WHILE DevNext(hDev) DO
Contador = Contador + 1; ! Comentário dentro da linha
END
108
# .! 1 &
/* Um bloco de comentário no estilo da linguagem C pode-se estender pro diversas linhas.

Blocos de comentários devem iniciar e terminar com um delimitador. Entretanto,
delimitadores no início de cada linha são opcionais */
// Uma barra dupla implica em um comentário no estilo C++ :
C # 7 #: D
D
E & $
" F G
109
# .! 1 &
110
>
& 3 ' $$
111
& 3 ' $$
112
& 3 ' $$
O Editor do Cicode pode funcionar no modo Debug (depuração) para analisar códigos do
Cicode quando sendo executado. Para se depurar rotinas em Cicode, necessitamos que o
Vijeo Citect esteja sendo executado, conseqüentemente você pode ativar e desativar a
depuração quando necessário. A operação do Debugger é controlada através das opções de
Debug, com algumas opções apenas tendo efeito durante o startup.
'( #) *
Neste capítulo você ira aprender
• Como iniciar o Debugger;
• Sobre as opções de Debug;
• A depurar um código do Cicode.
%' ! &
Para aprender mais sobre o Debugger, nós iremos utilizar o arquivo do Cicode denominado
Debug.ci parte integrante de nosso projeto de treinamento.
Para abrir o arquivo DEBUG.CI proceda da seguinte forma:
1. No Citect Explorer, clique no ícone para abrir o Editor do Cicode.

2. Abra o arquivo DEBUG.CI via Citect Explorer para visualizar o código abaixo:
, &)
& >-
O Debugger do Citect detecta automaticamente erros de hardware que ocorrem nas
funções do Cicode. Neste exercício, você irá utilizar o arquivo debug.ci para testar o
Citect Debugger.
1. Abra a barra de ferramentas debug.
2. No Editor do Cicode, clique com o botão direito do mouse em uma seção vazia da barra
de ferramentas. Marque a opção Debug conforme mostrado abaixo:
113
& 3 ' $$
3. Aparecerá a seguinte barra de ferramentas na barra de menus:
Comprove o funcionamento do depurador do Cicode utilizando o arquivo Debug.ci
1. Abra o arquivo Debug.ci.
2. Execute o projeto e acesse a página pizza;
3. Execute a função GetPizzaInfo() pressionando o botão Pizza Info na página. Você verá
que nesta função existem dois lugares onde é necessário interação do usuário.
4. No Editor do Cicode, clique no botão Toggle Debuging na barra de ferramentas. Observe
um inseto verde no canto inferior direito de sua tela indicando ativação do modo
depurador.
5. Coloque um breakpoint na barra indicadora situada a esquerda da linha que se mostra a

seguir.
114
& 3 ' $$
6. Selecione no menu View|Stack Window. Nesta janela se mostra o nome da função, os

valores dos argumentos passados para a função e todas as variáveis de stack(variáveis
locais).
7. Volte a pagina de Treinamento e clique no botão Pizza Info.
8. O Editor do Cicode piscará na barra de tarefas. Abra o Editor do Cicode e verá que
apareceu uma flexa amarela sobre o breakpoint inserido anteriormente. Ela indica a
seguinte linha de código que será executada.
9. Também verá uma lista das variáveis de memória e seus valores atuais na Stack
Window.
10. Clique no botão Step Into na barra de ferramentas Debug. Isto executará a linha
seguinte do código. Na linha seguinte se utiliza a função Input(). Trata-se de uma função
de bloqueio (blocking function) e não permitirá que o subprocesso continue até que haja
uma ação do usuário. Volte ao runtime do Vijeo Citect e introduza um valor para Pizza
Number, clique no botão OK.
115
& 3 ' $$
11. Retorne ao Editor do Cicode e olha a Stack Window. O número introduzido será mostrado
na variável sPizzaNumber.
12. Clique novamente no botão Step Into na barra de ferramentas Debug para executar a
linha seguinte do código. Esta linha designa um número de identificadro de dispositivo.
13. Repita passo a passo pelas instruções até que as linhas que atribuem valores as
variáveis sPizzaName e sPizzaPrice sejam executadas.
14. Clique no botão Continue para executar o restante do código. Quando se executa
Pizza information Message será necessário novamente retornar a página Treinamento
para confirmar o quadro de mensagem pressionando o botão OK. Isto funciona desta
forma porque a função Message() também é uma Blocking Function e por isto requer
uma ação do usuário antes que o subprocesso possa continuar.
15. Feche o projeto.
, &)
& >-+
116
& 3 ' $$
Utilize o depurador do Cicode para localizar erros no código.

1. Volte ao arquivo Debug.ci.
2. Localize esta instrução:
DevFind(hDev,sPizzaNumber,"Number");
3. Troque a string Number por Num :
DevFind(hDev,sPizzaNumber,"Num");
4. Salve o arquivo e compile o projeto. Dado que se trata de uma string, o código será
compilado sem problemas. Como não existe um campo chamado Num no device, a
função irá gerar um erro neste ponto quando o código for executado.
5. Execute o projeto
6. Inicie o depurador.
7. Clique no botão Pizza Info para iniciar a função.
8. Utilize o botão Step Into para executar o código linha a linha. Quando se executar a
linha DevFind, a mensagem de erro abaixo será ecoada na tela.
9. Clique no botão OK e o subprocesso será terminado.
# $ ! L #! #! * &C $
Quando tenha detido um subprocesso, o depurador marcará como vimos anteriormente o
código com uma flexa amarela. A partir daí, podemos avançar pela função linha a linha e
observar o que ocorre nas janelas de depuração (consulte a seguir). No Editor do Cicode são
disponibilizadas as seguintes ferramentas para controlar o avance através das funções:
Passo a passo por instruções: Avança o subprocesso do cicode atual uma instrução. Se a
instrução chama uma função definida pelo usuário, o depurador localizará a definição desta
função e entrará nela.
Passo a passo procedimento: Avança o subprocesso do cicode atual uma instrução. Se a
instrução chama uma função definida pelo usuário, o depurador passará por cima dela (a
função não se expandirá).
117
& 3 ' $$
Passo a passo para sair: Avança até o final da função atual e volta. Se não existe nenhuma
função a ser chamada, o processo será terminado.
Todas as linhas de código são executadas, inclusive quando se utilizam

procedimentos passo a passo e passo a passo para sair.
, &)
& >-0
Utilize as funções de passo a passo avançadas do depurador para avançar por uma função.
1. Volte ao arquivo Debug.ci e localize a função CheckTag().
2. Coloque um breakpoint na barra indicadora ao lado da instrução SetValues() conforme

mostrado a seguir.
3. Crie um botão na página Treinamento abaixo do texto Capítulo 8 denominado Check Tag
para chamar a função CheckTag().
4. Compile seu projeto e execute-o.
5. Ative o depurador. Na página Treinamento, pressione o botão Check Tag.
6. O depurador irá se deter junto ao breakpoint inserido.
7. Clique no botão Step Into para avançar pelo código.
8. A flexa passará para a função SetValues(). Ao utilizar o botão Step Into , cada linha
da função acima será executada.
118
& 3 ' $$
9. Quando a execução da função for completada, o depurador voltará a função que fez a
chamada.
10. Escreva o nome de um tag quando aparecer o quadro de entrada. Clique no boão OK
para continuar avançando pelo código.
11. Continue avançando por cada linha. O depurador voltará a função que realizou a
chamada original.
119
& 3 ' $$
12. Clique no botão Continue para executar o restante da função.
, &)
& >-4
Utilize a função avançada para passo a passo procedimento e passo a passo para sair das
funções.
1. Inicie a função CheckTag().
2. Quando o depurador se deter no breakpoint, entre em cada linha até entrar na primeira
linha da função SetValues().
3. Agora, em vez de executar esta função linha a linha, selecione o botão Step Out .
120
& 3 ' $$
4. Isto fará com que o restante da função SetValues(). Em seguida, o depurador voltará a
função que realiza a chamada no ponto imediatamente após a chamada de SetValues().
5. Execute a linha seguinte e introduza um nome de tag no quadro de entrada.
6. Neste ponto, a flecha irá se deslocar para a linha TagRead().
7. Esta vez, em vez de entrar na função TagRead(), selecione o botão Step Over .
8. Em lugar de entrar na função TagRead(), o depurador permitirá que a função seja
executada e fará uma pausa na linha de código seguinte da função CheckTag().
4.
9. Clique no botão continuar para executar o restante do código.
10. Feche o projeto.
121
& 3 ' $$
122
D! &
A&! &# $ #%# "
##
123
A&! &# $ #%# " ##
124
A&! &# $ #%# " ##
As rotinas escritas em Cicode até agora foram simples e com um mínimo de lógica requerida.
Entretanto, os programas mais complexos requerem um caminho mais estruturado para
facilitar a programação, a depuração e a manutenção.
'( D! &
Ao final deste capítulo você aprenderá:
• Como utilizar pseudocódigos ;
• Como utilizar diagramas de fluxo.
3 #$ #%# C$ & =* ,
Existem inúmeras técnicas disponíveis para assistir ao programador no sentido de projetar
um código estruturado. A mais simples e comumente técnica utilizada é o diagrama de fluxo.
Esta técnica se aplica bem a todos os tipos de sistemas, independentemente se médios ou
de grande complexidade. Isto significa que programadores familiarizados com escrita de
código para PLC’s podem utilizar as mesmas habilidades para escrever códigos para o Vijeo
Citect.
O principio básico do diagrama lógico de fluxo está centralizado no croqui que detalhe o fluxo
do programa através de vários estágios. O diagrama de fluxo consiste em quatro principais
componentes:
Blocos de Decisão
Contagem é > 10?
Blocos de Execução
Faça Contagem = 10
Caminhos Condicionais
SIM
Caminhos não Condicionais
Loop retorn
Exemplo A:
125
A&! &# $ #%# " ##
Abaixo podemos ver um diagrama de fluxo mostrando o fluxo lógico para checar se um
determinado valor está dentro de um range (entre 1 e 10). Se estiver dentro do range, atribua
o valor para o tag. Se não, mostre a string de mensagem “Range inválido”.
Valor
SIM
Valor é > 10? Prompt “Range é inválido”
NÃO
SIM
Valor é < 1? Prompt “Range é inválido”
NÃO
Retorna o valor
Este é um exemplo simples, entretanto ele mostra que deste croqui, uma pequena rotina
pode facilmente ser escrita utilizando os operadores condicionais (IF, WHILE, FOR) para
executar corretamente a lógica desejada.
Exemplo B:
Uma rotina mais complexa pode ser necessária para, ou fechar o formulário ou executar uma
tarefa se um botão é pressionado, qualquer que ocorrer primeiro. Esta tarefa poderia ser
representada como o seguinte diagrama de fluxo:
126
A&! &# $ #%# " ##
Contagem = 0
SIM
Contagem é > 60? Feche o formulário
NÃO
SIM
Botão Pressionado? Executa a tarefa
NÃO
Contagem = Contagem+1
O único inconveniente do diagrama de fluxo é sua manutenção após cada pequena alteração
na estrutura do programa, depois de inicialmente confeccionado. Além disso, são
normalmente colocados em um documento separado dos códigos, de tal forma que você
deverá sempre visualizar os dois documentos ao mesmo tempo.
Uma solução mais elegante para projetar e documentar uma tarefa seria a utilização de
pseudocódigos.
Pseudocódigos são auto documentados (não necessitando outros comentários adicionais),

fáceis de entender, fáceis de dar manutenção e podem ser adicionados no cabeçalho de
arquivos de biblioteca do Cicode.
Em pseudocódigos, o exemplo B ficaria da seguinte forma:
contagem = 0;
WHILE (contagem < 60) DO
IF botao_press THEN
executa_tarefa();
Saida_while_loop();
ELSE
contagem = contagem + 1;
ENDIF;
ENDWHILE;
fecha_formulario();
127
A&! &# $ #%# " ##
!&* "
Como os exemplos puderam demonstrar, a utilização de pseudocódigos ou diagramas de
fluxo auxiliam os programadores a construir um código bem estruturado e fácil de interpretar
para depuração e manutenção.
Sempre que um código é necessário e envolve operadores/declarações condicionais, é
recomendado que os programadores gastem algum tempo com o projeto dos pseudocódigos
ou com a construção do diagrama lógico de fluxo.
128
D! &
8 # $ #%# " ! &
129
8 # $ #%# " ! &
130
8 # $ #%# " ! &
Neste Apêndice nós iremos definir as linhas guias para a produção de código de funções
CICODE pelo usuário.
'( D! &
Ao final deste capítulo você estará apto a:
• Utilizar a convenção de nomes;
• Entender e utilizar o formato de biblioteca de Arquivos e funções;
• Entender e utilizar o formato de declarações de programa;
• Praticar uma programação defensiva e procurar por erros quando depurando.
! "
Este apêndice tem o como propósito ensinar os padrões da linguagem Cicode no sentido de
aumentar a uniformidade e melhorar a manutenção quando desenvolvendo rotinas em
Cicode independentemente do(s) autor(es).
A manutenção à nível de código é otimizada primeiramente assegurando-se uma
documentação adequada através da utilização de cabeçalhos explicativos nos módulos e
finalmente pelo formato do código, que tem sua leitura e interpretação melhorada de forma
sensível.
A uniformidade do código fonte por si só já denota um produto bem desenvolvido por um time
ao invés de um grupo de indivíduos. Isto encoraja os programadores de manutenção a tomar
um caminho de disciplina similar quando fazendo upgrades.
3 .! 1 ! !1 %
Variáveis
Nome de Variáveis
• Poderia ter uma letra minúscula como prefixo de identificação (veja lista abaixo)
• Pode possuir até três palavras concatenadas, cada uma delas começando por letra
maiúscula.
Tipo Prefixo Utilizado para
INT i Indexador, contador loop
INT n Numero de contagens
INT h handle
INT b Variáveis booleanas (TRUE/FALSE)
REAL r Variáveis do tipo real
STRING s Variáveis do tipo string
Exemplo: nTipoTendencia, rPeriodo, sNomeArquivo
131
8 # $ #%# " ! &
Uma declaração de variável possui até 5 (cinco) partes. Cada parte é separada por pelo
menos um TAB (oito caracteres espaço) e todas as partes devem ser alinhadas verticalmente
em uma declaração. Se uma parte de uma declaração está ausente, ela deve ser deixada em
branco. A próxima parte irá iniciar no mesmo lugar se não houvesse a ausência.
• A primeira parte é o escopo da variável. No momento deixaremos em
branco;
• A segunda parte define o tipo padrão de variável do Cicode;
• A terceira parte é o nome da variável. Nomes de variáveis devem ser tão
descritivos quanto possíveis considerando o propósito geral da mesma;
• A quarta parte é o valor inicial da variável;
• A quinta parte é um comentário opcional que fornece um breve comentário
da variável;
[scopo] [tipo] [nome] [=<valor inicial>] [comentário]
As variáveis do Cicode podem ser classificadas como

• Variáveis Locais (Variáveis de Funções): Estas variáveis são declaradas no
começo de uma função e apenas podem ser utilizadas dentro desta função. Elas
são destruídas quando a função termina sua execução e retorna ao programa
principal. A inicialização destas variáveis constitui uma boa prática de
programação:
INT iArquivo = 0;
STRING sNome = “”;
INT bSucesso = FALSE;
• Variáveis Globais (Variáveis de Bibliotecas, Variáveis de Arquivos): Estas

variáveis são privativas de arquivos de bibliotecas. Eles devem ser declarados no
começo do arquivo e podem ser utilizadas em quaisquer (ou todas) funções
dentro do arquivo. A letra “g” (um prefixo extra) é utilizada para identificar as
variáveis globais. Elas devem sempre ser inicializadas.
INT ghForm = -1;

STRING gsNomePagina = “Loop”;
• Constantes: No Cicode não existe o equivalente a #defines da Linguagem C ou

um tipo que irá forçar variáveis se tornarem constantes (variáveis do tipo apenas
leitura). Entretanto, a convenção adotada permite uma fácil identificação das
mesmas.
1) Devem possuir o prefix “c”;
2) Devem ser declaradas e inicializadas no início do arquivo de biblioteca e
nunca poderão receber outro valor;
INT cTendTipoPeriodic = 1;
132
8 # $ #%# " ! &
INT cTendTipoEvent = 2;
STRING cNomePagina = “Mimic”;

ou
STRING csNomePagina = “Mimic”;
• Variable Tags: Tags de variáveis que foram definidos na base de dados (no
formulário Variable Tags) podem ser utilizados em todas as funções nos arquivos
de biblioteca. Os tags de variáveis são normalmente com letras maiúsculas e os
usuários poderiam utilizar seu próprio padrão para defini-las.
=!1
As funções do Cicode podem possuir até seis partes:
1. A primeira parte define o tipo de retorno da função. Deve ser colocado em uma
linha separada;
2. A segunda parte consiste da palavra chave FUNCTION, que também deve ser
inserida em uma linha em separado.
3. A terceira parte aparece o nome da função. Os nomes das funções devem
possuir até 32 caracteres. Você pode utilizar qualquer nome valido, exceto
palavras reservadas e deve inserir em uma linha em separado.
4. A quarta parte é a lista de argumentos. Os argumentos são separados por
vírgulas e podem possuir valores iniciais (default). A lista de argumentos está
normalmente na mesma linha do nome da função, mas múltiplas linhas de
argumentos são aceitáveis quando facilitam a leitura.
5. Na quinta parte aparece às declarações, uma por linha.
6. Na sexta parte aparece a palavra chave END, que determina o final da função,
sendo também inserida em uma linha em separado.
Por exemplo;
FUNCTION
PlotInit()
<Declarações>
END
INT
FUNCTION
PlotOpen(STRING sName, INT nMode)
INT hPlot = BAD_HANDLE;
.
hPlot = …..;
.
RETURN hPlot;
END
STRING
FUNCTION
133
8 # $ #%# " ! &
WasteInfoName(INT nType, INT nMode)
STRING sName = “Sydney”;

.
sName = …..;
.
RETURN sName;
END
= %# B '* &# =!1
//** Arquivo: <nome do arquivo.CI>

//**
//** DESCRIÇÃO: <descrição do arquivo>
//**
//** NOTAS: <informações importantes ou comentarios sobre o conteudo>
//**
//********************* CONSTANTES**************************
<constantes> //<comentários (opcional>
//**************** VARIÁVEIS GLOBAIS ***********************
<variáveis globais> //<comentários (opcional)>
//*********************************************************
<funções>
Variáveis Globais devem ser utilizadas com cautela. Se estas variáveis são utilizadas por
muitas funções, achar bugs em seu programa pode tomar muito tempo. Variáveis locais (da
função) devem ser utilizadas sempre que possível.
Funções:
//** FUNCTION : <nome da Função>
//**
//** DESCRIÇÃO : <Sugestão da aplicação, operação
//** e outros detalhes importantes>
//** REVISÃO
//** DATA POR COMENTARIOS
134
8 # $ #%# " ! &
//** <data> <autor> <commentarios aplicáveis>

//**
//** VALOR RETORNADO: < Descrição dos possíveis valores //**
retornáveis>
//**
//** NOTAS:
= %# 3 &*
## 1 $ #%#
Formatando declarações Simples
• Apenas um item deve ser declarado por declaração, não deve haver variáveis
separadas por vírgulas.
• Tabulação de 8 espaços deve ser utilizado para declarações.
Por exemplo;
INT hFile,hForm; // ERRADO
INT hFile; // CERTO

INT hForm; // CERTO
As razões para isto são:

• Todos com exceção do caso errado são visualizados facilmente.
• É muito difícil adicionar comentários ou inicializações no caso errado.
• Todos os tipos, itens e inicializações dentro de um grupo de declarações
devem estar alinhados verticalmente.
Por exemplo;
STRING sFileName = "temp.dat"; // ERRADO

INT nOffset = -1; // ERRADO
INT nState = 3; // ERRADO
STRING sFileName = "temp.dat"; // CERTO

INT nOffset = -1; // CERTO
INT nState = 3; // CERTO
Formatando Declarações Executáveis

Declarações são colocadas em novas linhas separadas por um TAB. Não é aceitável ter mais
de uma declaração por linha.
Por exemplo;
hFile = -1; hForm = -1; // ERRADO
hFile = -1; // CERTO

hForm = -1; // CERTO
Declarações do tipo IF podem ser utilizadas em um dos formatos abaixo. Quando utilizando
uma declaração IF, utilize um TAB.
135
8 # $ #%# " ! &
• Bloco IF simples
IF <expressão> THEN
.
.
END
• Bloco IF-THEN-ELSE
.
.
ELSE
.
.
END
Quaisquer dos estilos abaixo podem ser utilizados por blocos ELSEIF.
.
.
ELSE
.
.
ELSE
.
.
ELSE
.
.
END
END
END
• In line
.
.
ELSE IF <expressão> THEN
.
.
ELSE IF <expressão> THEN
.
.
ELSE
.
END END END
136
8 # $ #%# " ! &
Formatando Expressões
Quando uma expressão forma uma declaração completa, ela deve, como qualquer outra
declaração ocupar uma ou mais linhas. Operadores binários devem ser separados por
espaços
i= i*10+c-' 0'; // ERRADO

i = i * 10 + c - '
0'; // CERTO
Quando uma expressão está colocada entre parênteses, o primeiro símbolo dela deve ser
colocado encostado ao parêntese. O parêntese de fechamento deve ser inserido
imediatamente após o último caractere da expressão.
a = b * ( c - d ); // ERRADO
a = b * (c - d); // CERTO
Não deixar espaços entre os parênteses e as aspas e os argumentos.

DisplayText( "hello" ); // ERRADO
DisplayText("hi^n"); // CERTO
Quando utilizando vírgulas como operadores ou separadores, as mesmas deverão ser

inseridas logo depois do símbolo que a antecede. Um espaço deverá separá-la do próximo
símbolo.
DevSeek(hDev ,Offset); // ERRADO

DevSeek(hDev, Offset); // CERTO
% !/
A maior parte deste documento está concentrada em formatação dirigida na melhoria da
interpretação e leitura de códigos. A suposição é de que códigos bem documentados são
mais fáceis de serem entendidos. Os comentários não melhoram a leitura do código, mas
ajudam bastante no entendimento e na manutenção.
Comentários inseridos no meio do código tendem a criar uma massa densa de texto
atrapalhando o fluxo do código. Os comentários devem todos ser inseridos nas notas do
cabeçalho da função. Pequenos comentários de uma linha são aceitáveis para explicar
algumas pequenas partes do código que porventura poderiam ficar perdidos nos comentários
do cabeçalho.
$ #%# " 3 . ! #
• Procure se assegurar sempre que seu código não irá nunca produzir alarmes de hardware
não explicáveis;
• Sempre cheque por divisões por zero;
• Sempre cheque para que os índices dos Arrays não saiam do range especificado;
• Cheque se os argumentos de fontes externas são válidos;
• Cheque se terminações de loop são óbvios e alcançáveis;
• Nunca escreva um código duas vezes. Se você achar que duas sessões do código
parecem idênticas ou quase idênticas, vale a pena gastar tempo para reescrevê-la ou
reprojetá-la. Isto irá certamente cortar o tamanho do código em um terço ou mais,
137
8 # $ #%# " ! &
reduzindo a complexidade e conseqüentemente a manutenção e o tempo de depuração. O

método mais eficiente de se alcançar isto consiste em converter o código idêntico em uma
nova função.
• O Cicode é uma linguagem multitask. Diversas tarefas (comandos, expressões e tarefas
criadas pela função TaskNew) podem ser executadas simultaneamente. Esta
característica possante do Cicode deve ser utilizada com cuidado, dado que algumas
destas funções podem estar modificando dados globais. É essencial que o número de
tarefas rodando em um dado ponto no tempo seja minimizado. Isto pode requerer a
utilização de semaphoros no sentido de proteger os dados globais de interferência e
corrupção. Para utilização de semáforos, favor fazer referência as funções SemOpen,
SemClose, SemSignal and SemWait no help on-line ou no Programmer’s Reference.
138
D! &
H M ( & 3
139
H M ( & 3
140
H M ( & 3
O Vijeo Citect suporta o padrão ODBC (Open DataBase Connectivity). Muitos fabricantes de
pacotes de base de dados fornecem atualmente um driver ODBC para o seu pacote de
software. Além deles, fabricantes independentes também disponibilizam drivers ODBC para
uma vasta variedade de Base de Dados. Um desses fornecedores é a Intersolv Q+E com o
seu DataDirect ODBC Pack. Na maioria dos casos, entretanto, qualquer driver ODBC
funcionará para a sua base de dados.
'( D! &
Ao final deste apêndice você terá uma boa informação sobre:
• Como se conectar a uma base de dados do Access através do Vijeo Citect via um
driver ODBC.
# # 3#
Antes de conectar sua base de dados ao Vijeo Citect, você irá necessitar fazer algum
trabalho de configuração no Windows Control Panel para criar uma fonte de dados (Data
Source). Uma fonte de dados é aquela com a qual o Vijeo Citect se comunica buscando e
atualizando dados no seu banco de dados. Para criar uma base de dados, siga as instruções
abaixo:
I ! N 7 - ,% *
• Acesse o Windows Control Painel conforme mostrado abaixo:
• Selecione Ferramentas Administrativas através do ícone mostrado abaixo:
• Em seguida aplique um clique duplo no ícone Fontes de Dados (ODBC) conforme

mostrado na figura abaixo. A seguinte figura será mostrada:
141
H M ( & 3
• Selecione o TAB Fonte de dados do Sistema e em seguida selecione o Driver

ODBC que você deseja utilizar via o botão Adicionar. A figura abaixo ilustra:
142
H M ( & 3
Pressione o botão Adicionar. A seguinte figura será mostrada:
Selecione o driver desejado na lista apresentada. Para o nosso Treinamento, selecione

Microsoft Access Driver e aplique um clique duplo nele. As figuras abaixo ilustram:
143
H M ( & 3
Preencha o formulário conforme mostrado na figura acima. Pressione o botão OK para

finalizar. A figura abaixo ilustra.
Observe que a Fonte de Dados criada agora aparece listada na lista disponibilizada nesta
figura. Pressione o botão OK para encerrar este procedimento. Feche o Windows Control
Panel.
Isto é tudo o que você necessita fazer. Você acabou de criar uma fonte de dados (Data
Source) que está pronta para ser utilizada de dentro do Vijeo Citect.
% & ! &# # # # 3# #
( &
144
H M ( & 3
O Vijeo Citect disponibiliza dois métodos de comunicação com sua base de dados: através
da utilização de Devices do Vijeo Citect e através da Classe de funções SQL. A utilização de
Devices é mais aconselhada para o uso de relatórios logging automáticos. As funções SQL
por outro lado, fornecem controle absoluto e flexibilidade sobre suas conexões e queries. A
execução de um query via um Device do Sistema é sempre mais lenta do que uma conexão
via uma função do SQL devido à natureza do Device.
*2#! # *# =! H
& H &*
# .. !& !
As funções SQLxxx() do Cicode fornecem os meios mais flexíveis de você se comunicar
com sua base de dados de dentro do Vijeo Citect. Você tem controle completo sobre
suas conexões. Através de uma construção cuidadosa de suas queries e da utilização
de índices, você também terá a forma mais rápida de acessar grandes volumes de
dados.
,% * )& %# ! ," H K
A query abaixo mostra como localizar e obter dados de uma determinada base de dados
denominada Personnel:
INT
FUNCTION
GetNames()
INT hSQL;
STRING sName;
INT Status;
hSQL = SQLConnect( “DSN=Personnel” );

IF hSQL <> -1 THEN
Status = SQLExec( hSQL, “SELECT CNAME FROM FETISH” );
IF Status = 0 THEN
WHILE SQLNext( hSQL ) = 0 DO
sName = SQLGetField( hSQL, “CNAME” );
:
// Qualquer coisa voce deseje fazer com dado...
:
END;
SQLEnd( hSQL );
ELSE
Message( “Erro”, SQLErrMsg(), 48 );
END;
SQLDisconnect( hSQL );
ELSE
Message( “Error”, SQLErrMsg(), 48 );
END;
END
Algumas coisas a se observar é que para toda conexão via SQLConnect() deverá também
existir uma instrução de desconexão via SQLDisconnect(). Geralmente, uma conexão ODBC
demanda certo tempo, especialmente quando conectando clientes em rede sendo servidos
por um servidor de base de dados. Por esta razão, você deve evitar ficar conectando e
desconectando frequentemente.
145
H M ( & 3
Outro ponto importante a destacar é que para cada query feita via SQLExec(), você deve
eventualmente também chamar a função SQLEnd() de forma a liberar memória utilizada por
aquela query.
Finalmente, você deve verificar sempre o handle de retorno de todas as funções SQLxxx()
para verificar se foram executadas com sucesso e se for o caso, tomar alguma providência.
Para maiores informações sobre o porque da falha da função SQL, chame a função
SQLErrMsg().
% / H
Esta seção fornece um rápido resumo sobre Structured Query Language (SQL). Para
maiores informações, favor fazer referência a texto específico. A maioria dos pacotes de
software de base de dados que suportam SQL queries terão maiores informações. Uma boa
parte desta seção está focada em mostrar instruções através de exemplos. Todos estes
exemplos estarão baseados nas seguintes tabelas:
Tabela FETISH
CNAME SURNAME PERSONID STARTDATE PET FETISH
Harold Heel 654 25-06-1994 Horse Hair
Jill Jumpy 854 14-05-1994 Jackal Jewels
Arnold Amore 935 12-06-1994 Aardvark Armpits
Catherine Crispy 367 15-08-1994 Cat Cold
David Dandy 746 21-07-1994 Deer Dandruff
Percival Point 153 07-07-1994 Python Pins
James Joint 946 08-05-1994 Jaguar Juice
Englebert Engine 479 10-06-1994 Elephant Earlobes
Tracy Titan 294 11-04-1994 Tortoise Toe Slime
Tabela COUNTRY
PERSONID COUNTRY
654 Hungary
854 Jamaica
935 Australia
367 Cuba
746 Denmark
153 Portugal
946 Jamaica
479 Ethiopia
294 Thailand
3 &*
## "
146
H M ( & 3
A declaração SELECT será provavelmente a declaração mais comum que você irá
utilizar. A sintaxe desta declaração possui diversas variações proporcionando tornando-a
poderosa. Na maioria dos casos, entretanto, todas as suas necessidades de queries
serão satisfeitas por uma declaração SELECT com o seguinte formato:
SELECT <Fields>
FROM <Tables>
[WHERE <conditions>]
Quando especificando mais de um campo ou tabela, você deve delimitá-los por vírgulas.
*& !#! %# #' *

#! #
Existem duas formas para você selecionar uma tabela inteira. A primeira foca uma
variação da sintaxe da declaração SQL vista acima. Se você desejar selecionar a tabela
FETISH inteira, então você poderia executar a declaração “SELECT FETISH” através da
seguinte função do Cicode:
SQLExec(hSQL, “SELECT * FROM FETISH”);
O outro método envolve a seleção de todos os campos da Tabela. Isto poderia ser feito da
seguinte forma:
SQLExec(hSQL ,“SELECT CNAME,SURNAME,PERSONID, STARTDATE, PET,
FETISH” + “FROM FETISH” );
Quando você desejar especificar todos os campos, você poderá utilizar um

Wildcard(*). A declaração acima ficaria conforme ilustrado abaixo:
SQLExec(hSQL, “SELECT * ” + “FROM FETISH” );
'# && ! !#*B K

Quando querying base de dados é importante observar letras maiúsculas/minúsculas.
SQLExec(hSQL ,“SELECT CNAME ”+ FROM FETISH ” + “WHERE SURNAME =

‘Jumpy’ ” );
que resultaria em:

CNAME
Jill
Letras maiúsculo-minúsculas são muito importantes quando comparando strings. O

exemplo seguinte destaca um erro comum que dá impressão de uma falha no query.
SQLExec(hSQL, “SELECT CNAME “+ “FROM FETISH “+ “WHERE SURNAME = ‘JUMPY’ ” )
que resultaria em:
CNAME
Observe que nada foi selecionado. Você pode, entretanto utilizar a função SQL UPPER()
para contornar este problema.
147
H M ( & 3
Nem todos os sistemas de base de dados ou seus drivers ODBC irão necessariamente
suportar a função UPPER(). Verifique a documentação disponível.
SQLExec(hSQL, “SELECT CNAME “+ “FROM FETISH “+ “WHERE UPPER(SURNAME) =

‘JUMPY’ ” )
que resultaria em:
CNAME
Jill
H '# # # % & !( ! # -
#
Você pode fazer um query em uma base de dados procurando por todos os registros nos
quais os conteúdos dos campos se igualam a valores de um conjunto de dados. Isto poderia
ser configurado da seguinte forma:
SQLExec(hSQL, “SELECT CNAME, PERSONID “ + “FROM FETISH “+ “WHERE

SURNAME IN ( ‘Jumpy’, ‘Engine’ ) ” );
que resultaria em:
CNAME PERSONID
Jill 854
Englebert 479
Ou de outra forma, você poderia procurar por todos os registros nos quais determinados
campos não se igualam a nenhum dos valores encontrados em um conjunto de dados. Isto é
implementado via o operador NOT IN conforme mostrado abaixo:
SQLExec(hSQL, “SELECT CNAME, PERSONID “+“FROM FETISH “+ “WHERE SURNAME
NOT IN ( ‘Jumpy’, ‘Engine’ ) ” );
que resultaria em:
CNAME PERSONID
Harold 654
Arnold 935
Catherine 367
David 746
Percival 153
James 946
Tracy 294
H &% &! 1 *#!#

Operadores AND e OR
Você pode fazer um query em uma base de dados procurando por todos os registros que
satisfaçam condições múltiplas. Estas condições são separadas pelos operadores AND e OR
respeitando a condição lógica que você deseja. Isto poderia ser configurado da seguinte
forma:
148
H M ( & 3
SQLExec(hSQL, “SELECT CNAME, PERSONID “+“FROM FETISH “+“WHERE SURNAME =

‘Jumpy’ “+“OR SURNAME = ‘Engine’ ) ” );
que resultaria em:
CNAME PERSONID
Jill 854
Englebert 479
SQLExec(hSQL, “SELECT * “+“FROM FETISH “+“WHERE SURNAME IN ( ‘Jumpy’, ‘Engine’,

‘Point’ )“+“AND FETISH IN ( ‘Earlobes’, ‘Armpits’, ‘Pins’ ) ” );
que resultaria em:

H K!$ % #!$ #* - #
I
É possível especificar um range em um query utilizando-se o operador BETWEEN conforme
mostrado abaixo:
SQLExec(hSQL, “SELECT * “+ “FROM FETISH “+ “WHERE STARTDATE

BETWEEN ‘1994-06-20’ AND ‘1994-07-30’ “ );
que resultaria em:

H K!$ # &< K* - < O #

É possível executar queries comparando parcialmente strings através do operador LIKE.
Você pode especificar se a comparação deve-se igualar ao começo, ao fim ou a qualquer
porção da string. Por exemplo ‘p%’ procuraria por strings iniciados com a letra ‘p’; ‘%p’
procuraria por strings terminados com a letra ‘p’; ‘%p%’ procuraria por strings que contém a
letra ‘p’ em qualquer lugar dentro dela;
SQLExec(hSQL, “SELECT * “+ “FROM FETISH “+ “WHERE CNAME LIKE ‘%n%’ “ );
que resultaria em:

149
H M ( & 3
H K!$ #' *
# 5* *
# - !! #
#' *
#
Com SQL é possível executar queries dentro de varias tabelas. Isto envolve conectar as
tabelas em uma query. Tabelas podem ser conectadas se elas possuem uma coluna comum
com valores que podem ser comparados. Deve-se então listar todas as tabelas na porção
FROM da declaração e então especificar as colunas comuns (join condition) na porção
WHERE da declaração. Os dois seguintes exemplos como as tabelas FETISH e COUNTRY
foram unidas para queries.
SQLExec(hSQL, “SELECT * “+ “FROM FETISH, COUNTRY “+ “WHERE

FETISH.PERSONID = COUNTRY.PERSONID”)
que resultaria em:
CNAME PERSONID STARTDATE PET FETISH COUNTRY

SURNAME
Harold Heel 654 25-06-1994 Horse Hair Hungary
Jill Jumpy 854 14-05-1994 Jackal Jewels Jamaica
Arnold Amore 935 12-06-1994 Aardvark Armpits Australia
Catherine Crispy 367 15-08-1994 Cat Cold Cuba
David Dandy 746 21-07-1994 Deer Dandruff Denmark
Percival Point 153 07-07-1994 Python Pins Portugal
James Joint 946 08-05-1994 Jaguar Juice Jamaica
Englebert Engine 479 10-06-1994 Elephant Earlobes Ethiopia
Tracy Titan 294 11-04-1994 Tortoise Toe Thailand
Slime
SQLExec(hSQL, “SELECT CNAME, FETISH “+ “FROM FETISH, COUNTRY “+

“WHERE COUNTRY = ‘Jamaica’ “+ “AND FETISH.PERSONID =
COUNTRY.PERSONID” );
que resultaria em:
CNAME FETISH
Jill Jewels
James Juice
Quando querying múltiplas tabelas, pode ser necessário utilizar qualificadores quando
referenciando nomes de campos. Isto pode ser necessário quando ambas as tabelas tem
campos de mesmo nome. Isto pode ser observado nos exemplos acima quando fazemos
referência ao campo PERSONID. A declaração foi prefixada com FETISH.’ e ‘COUNTRY.’
quando necessário.
&*
## "
Para adicionar registros a uma tabela de base de dados, utilize a declaração INSERT. A
sintaxe desta declaração está mostrada abaixo:
INSERT INTO <table> [(<fields>)]
VALUES (<expr>, ...)
150
H M ( & 3
Os nomes dos campos são opcionais, e se utilizados, devem ser delimitados por vírgulas.
Se você omitir os nomes das colunas, então os valores deverão estar na ordem das
colunas onde deverão ser inseridos. Portanto por motivos de segurança, não omita os
nomes das colunas. Esta função é utilizada para adicionar novos registros a base de
dados. Um exemplo razoável seria o mostrado abaixo:
SQLExec(hSQL, “INSERT INTO FETISH “ + “( CNAME, SURNAME,
PERSONID,STARTDATE, PET, FETISH ) “ +“VALUES( ‘Wallace’, ‘Wretch’, 783,
{10/27/1994}, ‘Wallaby’, ‘Whips’ ) ” );
que resultaria na seguinte aparência para a base de dados:
CNAME SURNAM PERSONI STARTDAT PET FETISH

E D E
Jill Jumpy 854 21-06-1994 Jackal Jelly
Wallace Wretch 783 27-10-1994 Wallaby Whips
&*
## " 3
Para modificar registros de uma tabela de base de dados, utilize a declaração UPDATE. A
sintaxe para esta declaração está mostrada abaixo:
UPDATE <table>
SET <field> = <expression>,...
A expressão pode ser um valor constante ou uma subquery. Esteja atento quando utilizando
a declaração UPDATE, desde que ela irá modificar todo registro que obedecer o critério
definido na porção WHERE.
SQLExec(hSQL, “UPDATE FETISH “+ “SET FETISH = ‘Cold-cream’“ + “WHERE
PERSONID = 367” );
CNAME SURNAME PERSONID STARTDAT PET FETISH

E
Jill Jumpy 854 14-05-1994 Jackal Jewels
Catherine Crispy 367 15-08-1994 Cat Cold-cream
151
H M ( & 3
SQLExec(hSQL, “UPDATE FETISH “+ “SET STARTDATE = {06/21/1994}, FETISH =

‘Jelly’ “+ “WHERE CNAME = ‘Jill’ ” );

&*
## " 3
Para apagar registros em uma tabela de base de dados, utilize a declaração DELETE. A
sintaxe para esta declaração está mostrada abaixo:
DELETE FROM <table>

Este atento, pois se você não especificar a condição WHERE, então todos os registros da
tabela serão apagados.
SQLExec(hSQL, “DELETE FROM FETISH “+“WHERE CNAME = ‘James’” );

Wallace Wretch 783 27-10-1994 Wallaby Whips
3 &*
# #! 3# # J #! H
O modo pelo qual você declara data em SQL varia entre os systemas de base de dados.
Com DBase, você iria normalmente declarar data entre chaves {02/18/95}, no Oracle você
utilizaria o formato to_date(‘02/18/95’, ’MM/DD/YY’).
Para tornar isto um pouco mais complicado, o driver ODBC você irá utilizar um outro formato
- ‘YYYY-MM-DD’.
152
H M ( & 3
! #, 3# #PJ # ! ! ! #
3#
Se você deseja seus queries ser independentes da base de dados sendo utilizada, você
poderá utilizar a seguinte sintaxe para datas e horas.
[d’YYYY-MM-DD HH:MM:SS.FFFFFF’]
A primeira letra depois do colchete deverá ser:
d Data,
t Hora, ou
dt Data e hora.
Independentemente se você está especificando uma data, hora ou data/hora, você sempre
deverá fornecer a string completa de 26 caracteres. Um exemplo de como especificar uma
data está mostrado abaixo:
[d’1995-02-18 00:00:00.000000’]
153
H M ( & 3
154
D! & 3
,% * C $
$ #%#
155
,% * &C $ $ #%#
156
,% * &C $ $ #%#
O aprendizado de programação é provavelmente mais eficiente visualizando-se códigos de

programas. Este capítulo contém diferentes tipos de programas, que podem ser úteis a você
quando você está começando a elaborar suas próprias rotinas de Cicode.
Os códigos destes programas estão disponibilizados no arquivo do Cicode Exemplos.ci do
projeto de Treinamento.
'( D! &
Ao final deste apêndice, você poderá:
• Visualizar rotinas de programas do Cicode e, portanto se tornar mais
familiarizado com o mesmo.
Exemplo C.1
Tag de Variable STRING1 recebe a data atual e o tag variável STRING2 recebe a hora atual
FUNCTION
TimeDate()
STRING1 = Date(3);
STRING2 = Time(2);
END
Exemplo C.2
Retorna a media entre os Tags de Variáveis INT1 e INT2
INT
FUNCTION
MyAverage()
Return ((INT1 + INT2) /2);
END
Exemplo C.3
Atribui ao parâmetro [MESSAGE]Test do arquivo USER.INI uma determinada String
FUNCTION
PutINI()
STRING sValue;
sValue=Input("Enter Value for parameter " ,"NoSpaces","MyMessage");

WndPutFileProfile("Message","Test", sValue ,"USER.INI");
END
Exemplo C.4
A função abaixo irá mostrar uma caixa de diálogo do tipo popup com o status de um
bit digital
FUNCTION
IfEg(INT Bit)
IF Bit THEN
157
,% * &C $ $ #%#
Message(“IF Example”,”The Bit is on”,48);

ELSE
Message(“IF Example”,”The Bit is off”,48);
END
END
Exemplo C.5
Esta função irá contra de 0 até um valor inteiro passado para ela e irá mostrar esta
contagem na linha de prompt.
FUNCTION
ForEg(INT IntX)
INT Count;
FOR Count = 1 To IntX DO

Prompt(IntToStr(Count));
Sleep(1);
END
Prompt(“”);
END
Exemplo C.6
Esta função do Cicode irá incrementar o tag de variável analogical INT3 enquanto a o
tag digital BIT1 é TRUE e irá zerar a mesma variável quando BIT1 se torna FALSE.
FUNCTION
WhileEg()
WHILE Bit1 DO
Int3 = Int3 + 1;
Sleep(1);
ReRead(1);
END
Int3 = 0;
END
Exemplo C.7
Esta função faz o Tag STRING1 receber o dia da semana
STRING
FUNCTION
WhatDayIsIt()
STRING sDay;
INT iDay;
sDay = Input("Returns the day corresponding to a number 0-6","Type a number(0-

6)","0");
iDay = STRTOINT(sDay);
IF ((iDay<0) OR (iDay)>6) THEN
Message("Error","Invalid number entered. Try again",0);
RETURN "ERROR";
158
,% * &C $ $ #%#
END
SELECT CASE iDay

CASE 0
RETURN "SUNDAY";
CASE 1
RETURN "MONDAY";
CASE 2
RETURN "TUESDAY";
CASE 3
RETURN "WEDNESDAY";
CASE 4
RETURN "THURSDAY";
CASE 5
RETURN "FRIDAY";
CASE 6
RETURN "SATURDAY";
CASE ELSE
Message("Error","Invalid number entered",0); END SELECT
END
159
,% * &C $ $ #%#
160

Apostila CicodeV1

Enviado por

Direitos autorais:

Formatos disponíveis

Apostila CicodeV1

Enviado por

Dados do documento

Descrição 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

Apostila CicodeV1

Enviado por

Direitos autorais:

Formatos disponíveis

Treinamento Cicode

Apostila - Junho / 2009 Ref.: 2-043.100

' $ " (")* +

• 1' ' ' $ "

Formato de Declarações de Programa..................................................................... 135

Comentários .......................................................................................................... 137

Querying um range de valores - Operador BETWEEN.............................................149

O Cicode é uma linguagem de programação de computador simples, fácil de utilizar

• Quando o operador faz o login ou o logout no sistema;

• Quando um alarme é disparado;

• Quando um evento é disparado;

4. Selecione o tab horizontal Appearance e o tab vertical General.

9. Clique no botão OK.

De modo similar, podemos desligá-la da seguinte forma:

Execute TIC_P4_SP = TIC_P1_SP;

Ao valor de TIC_P4_SP é atribuído o valor da TIC_P1_SP. Isto, no entanto só ocorre quando

A primeira declaração atribui à variável TIC_HOLD_PV o valor da variável TIC_P4_PV. A

Utilize a função do Cicode chamada Prompt(string). Procure no Help do Vijeo Citect

Key Sequence F2 Enter

…………é passada ao comando como ArgValue1

O valor 123 é passado para o comando e o valor 123 é atribuído para

Os valores 123 e 18 são passados ao comando. A LIC_BALANCE_SP é atribuída o valor

Existem duas formas de se definir um argumento. ArgValueX e ArgX.

Existe uma diferença importante entre os dois. O argumento ArgValueX comprova

4. Preencha a caixa de diálogo conforme mostrado acima.

8. Preencha a caixa de diálogo conforme mostrado abaixo.

<#%#! =!1 % %#!

Adicione um botão na página Treinamento para chamar a função CSV_Tag_Debug();

4. Salve sua página, compile o projeto e teste sua alteração.

Para obter informações sobre parâmetros requeridos em qualquer função do

Tente o seguinte comando para o Office 2003

Execute AlarmAck(2, 35);

4. Salve a página como !MyPopTrend.

No Editor Gráfico do Vijeo Citect, selecione no menu Tools|Options a opção List

8. Salve a página e compile seu projeto.

5. Salve sua página, compile o projeto e execute o comando inserido.

9. Abra a página Treinamento e comprove o funcionamento do novo comando. A página

2. Crie um botão na página Pasteuriser denominado LEVEL BALANCE^n TANK.

3. Salve a página e compile seu projeto.

On page Prompt("Ola," + FullName()) entry

5. Salve o Genie utilizando File|Close.

1. Avance pelo Wizard de Setup do Computador até encontrar o seguinte diálogo:

2. Clique no botão Modify. A seguinte caixa de diálogo será mostrada.

3. Digite Startup() e pressione o botão OK. A figura abaixo ilustra:

4. Pressione o botão Next até concluir o Wizard de Setup do Computador. No arranque do

O Cicode é utilizado para manipular dados e executar tarefas. A manipulação de dados é

Abaixo vemos um exemplo do operador MOD:

TAG_1 = TAG_2 MOD 100

Prompt(“O valor do Tag 1 é” + IntToStr(Tag_1));

Isto é um String Isto é um String

2. Selecione o TAB horizontal Input e o TAB vertical Touch.

3. Insira o seguinte comando

TIC_P2_PV = TIC_P4_PV MOD 10

2. Selecione o TAB horizontal Input e o TAB vertical Touch.

3. Insira o seguinte comando

Message(“Temperatura Zona 2”, “TIC_P2_PV = “ + IntToStr(TIC_P2_PV), 64)

5. Na página Treinamento, altere o valor do tag TIC_P2_PV para 10.

6. Na página Treinamento, altere o valor do tag TIC_P4_PV para 43.

7. Clique no botão MODULO e comprove o resultado.