ATOS AUTOMAÇÃO INDUSTRIAL

Itens deste manual:

1. Introdução
2. Implementação
3. Observações
4. Funcionamento
5. Códigos de erro

Atos2Pc.dll versão 1.1 julho 2000

1. Introdução
Atos2Pc é um pacote de softwares destinado a desenvolvedores que permite a comunicação
serial de um Pc com um ou mais CLP's Atos que suportem o protocolo APR03.

Este pacote prevê uma dll (Atos2Pc.dll) que contém as implementações das funções de leitura
e escrita em endereços do CLP. Chamando estas funções de dentro do seu programa pode-se
acessar facilmente o CLP.

O pacote prevê ainda exemplos de aplicativos que utilizam esta dll em várias linguagens de
programação, com Visual Basic, Visual C++, Delphi e C++Builder.

A linguagem C/C++ permite a utilização de funções de uma dll de duas maneiras:

• Utilizando o arquivo lib para obter informações da link-edição, mais o arquivo header
para a declaração das funções (Atos2Pc.h e Atos2Pc.lib).
• Utilizando diretamente a dll carregando-a em runtime com a função LoadLibrary e
declarando ponteiros para as funções da dll.

Como a dll foi desenvolvida com o compilador C++ da Borland, o arquivo lib gerado
(Atos2Pc.lib) pode não funcionar com outros compiladores C++. Neste caso, opte por utilizar a
dll carregando-a dinamicamente com a função LoadLibrary. Veja exemplo com o compilador
Visual C++ 6.

A dll possui código de 32 bits e é compatível com Windows 95, Windows 98 e Windows NT.
2. Implementação
Neste item estão descritas todas as funções que estão implementadas na dll.

===========================================================================
Função:
void GetDllVersion( )

Sintaxe:
GetDllVersion(char* Versao)

Objetivo:
Esta função escreve na área apontada por Versao, a versão atual da dll, em caracteres ASCII.

Argumentos:
char* Versao = ponteiro char para uma área livre de pelo menos 3 bytes.

Valor de retorno:
Não retorna nenhum valor.

===========================================================================
Função:
int GetChannel( )

Sintaxe:
GetChannel(HANDLE* AddhCom, int* Erro, int Canal, int Timeout, int Baud, int StopBits, int DataBits, char
paridade)

Objetivo:
Esta função aloca um canal serial dentro do Windows. Este canal serial será utilizado durante todo
o processo de comunicação com o CLP.

Argumentos:
HANDLE* AddhCom = Endereço do HANDLE do canal serial.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
int Canal = Valor inteiro que deve valer 1, 2, 3 ou 4, representando o canal COMx.
int Timeout = Valor inteiro que representa o tempo que será esperado para cada
comunicação com o CLP. Valor em milissegundos.
int Baud = Valor que representa a velocidade de comunicação (Baud Rate)
int StopBits = Numero de Stop Bits de cada byte. Pode ser 1 ou 2.
int DataBits = Tamanho do byte de dados da comunicação Pode ser 7 ou 8.
char Paridade = Paridade da comunicação. Pode ser 'N' (nenhuma), 'E' (par) ou 'O'
(impar)

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int ReleaseChannel( )

Sintaxe:
ReleaseChannel(HANDLE hCom)

Objetivo:
Esta função libera um canal serial previamente alocado.

Argumentos:
HANDLE hCom = HANDLE do canal serial.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int EnviaAck( )

Sintaxe:
EnviaAck(int PlcAddress, HANDLE hCom, int Timeout, int* Erro, char* bShowTx, char* bShowRx)

Objetivo:
Enviar um Ack para um determinado CLP.

Argumentos:
int PlcAddress = Endereço do CLP destino.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.

===========================================================================
Função:
int PedeByte( )

Sintaxe:
PedeByte(int PlcAddress, int MemoryAddress, char *Value, HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Buscar 1 byte de um endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço a buscar o byte.
char* Value = Endereço onde será devolvido o byte recebido do CLP
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int EnviaByte( )

Sintaxe:
EnviaByte(int PlcAddress, int MemoryAddress, char Value, HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Enviar 1 byte para um determinado endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço a enviar o byte.
char Value = Byte a ser enviado
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.

===========================================================================
Função:
int PedeVar( )

Sintaxe:
PedeVar(int PlcAddress, int MemoryAddress, char* Value,HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Buscar 2 bytes de um endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço que possui o byte desejado.
char* Value = Endereço onde será retornado o valor lido. Alocar pelo menos 2 bytes.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int EnviaVar( )

Sintaxe:
EnviaVar(int PlcAddress, int MemoryAddress, char* Value, HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Enviar 2 bytes para um determinado endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço a enviar o valor.
char* Value = Endereço onde estão os dois bytes a serem enviados.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.

===========================================================================
Função:
int PedeVarInt( )

Sintaxe:
PedeVarInt(int PlcAddress, int MemoryAddress, int* Value,HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Buscar 2 bytes de um endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço que possui o valor desejado.
int* Value = Endereço do número inteiro onde será retornado o valor lido.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int EnviaVarInt( )

Sintaxe:
EnviaVarInt(int PlcAddress, int MemoryAddress, int Value, HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Enviar 2 bytes para um determinado endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço a enviar o valor.
int Value = Inteiro a ser enviado para o CLP. Deve valer no máximo 65.535
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.

===========================================================================
Função:
int PedeVarIntBcd( )

Sintaxe:
PedeVarIntBcd(int PlcAddress, int MemoryAddress, int* Value,HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Buscar 2 bytes de um endereço do CLP, considerando uma representação BCD para o retorno, ou
seja,
o que se vê no endereço do CLP através da IHM é o que se vê no retorno.

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço que possui o valor desejado.
int* Value = Endereço do número inteiro onde será retornado o valor lido.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int EnviaVarIntBcd( )

Sintaxe:
EnviaVarIntBcd(int PlcAddress, int MemoryAddress, int Value, HANDLE hCom, int Timeout, int* Erro, char*
bShowTx, char* bShowRx)

Objetivo:
Enviar 2 bytes para um determinado endereço do CLP, considerando uma representação BCD
para o retorno, ou seja,
o que se vê no endereço do CLP através da IHM é o que se vê no retorno.

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço a enviar o valor.
int Value = Inteiro a ser enviado para o CLP. Deve valer no máximo 65.535
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
===========================================================================
Função:
int PedeBloc( )

Sintaxe:
PedeBloc(int PlcAddress, int MemoryAddress, int Amount, char* Value, HANDLE hCom, int Timeout, int* Erro,
char* bShowTx, char* bShowRx)

Objetivo:
Buscar até 8 bytes de um endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço inicial de onde se quer trazer os bytes.
int Amount = Quantidade de bytes que se deseja receber.
char* Value = Endereço do Array onde os bytes serão escritos
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.

===========================================================================
Função:
int EnviaBloc( )

Sintaxe:
EnviaBloc(int PlcAddress, int MemoryAddress, int Amount, char* Value, HANDLE hCom, int Timeout, int* Erro,
char* bShowTx, char* bShowRx)

Objetivo:
Enviar até 8 bytes para um endereço do CLP

Argumentos:
int PlcAddress = Endereço do CLP destino.
int MemoryAddress = Inteiro que representa o endereço inicial onde se quer enviar os bytes.
int Amount = Quantidade de bytes que se deseja enviar.
char* Value = Endereço do Array onde os bytes serão lidos para serem enviados.
HANDLE = HANDLE do canal serial, setado após a chamada de GetChannel( ).
int Timeout = Timeout utilizado na comunicação, em milissegundos.
int* Erro = Endereço onde será retornado o código inteiro do erro, caso ocorra.
char* bShowTx = Endereço de um Array char onde será retornado o pacote que foi enviado
para o CLP. Tipicamente uma área de 50 bytes.
char* bShowRx = Endereço de um Array char onde será retornado o pacote que foi recebido
do CLP. Tipicamente uma área de 50 bytes.

Valor de retorno:
Inteiro. Caso ocorra erro, retorna 0, caso contrário retorna 1.
3. Funcionamento

Antes de enviar qualquer comando para um CP, é preciso conectar-se a um canal serial. Esta
conexão é feita através da função GetChannel. Você precisa declarar uma variável global que vai
ser o identificador da conexão, criado pelo Windows.

Quando chamar a função GetChannel passando o endereço do identificador (handle) como

argumento, caso o canal serial desejado esteja livre, a função vai preencher este identificador com
um valor válido. O identificador deverá ser utilizado na chamada de qualquer outra função da
biblioteca.

Para fechar a conexão chame a função ReleaseChannel.

A cada chamada de escrita/leitura ou ack em um clp, é retornado um código de erro, que vale 0,
caso não haja erro na função ou outro valor que identifica o erro.

Como pode-se perceber, toda função requer vários argumentos, que se repetem nas funções. A
razão disto é que as funções são discretas, e não enxergam as variáveis do seu programa, a não
ser que você as passe como argumentos. Você pode criar uma classe que encapsule estas
variáveis de argumentos como propriedades do objeto clp, que utilize as funções desta biblioteca,
para que não seja necessário ficar repetindo os argumentos a toda chamada de função.
Existem exemplos que utilizam uma classe Plc que mostram o exposto acima.

Nada melhor do que exemplos para entender como as funções da biblioteca funcionam. Logo, este
pacote possui exemplos nas principais linguagens de programação.

4. Observações

1. Todas as funções de leitura e escrita possuem campos chamados bShowRx e bShowTx.

Este retorno é interessante somente quando se deseja analisar o conteúdo dos pacotes enviados
e recebidos do CLP. Os bytes dos pacotes são gravados na área especificada pelo programador
em
ASCII, já separados por um espaço, para visualização direta.

2. Para maior facilidade, forma implementadas 3 funções para envio de variáveis e 3 funções para
leitura de
variáveis. A diferença entre elas está no tipo do dado de envio/leitura, que pode ser:
Área de memória - Array de bytes
Inteiro decimal
Inteiro BCD (hexadecimal)

3. O arquivo Atos2Pc.dll não necessita ser registrada para rodar com seu programa, pois ela não
implementa nenhum componente COM (Component Object Model, Microsoft).

4. Para rodar seu aplicativo não se esqueça de colocar em um dos diretórios onde o
Windows busca uma dll (diretório corrente, Windows/system, diretórios do path do
autoexec) os arquivos:
Atos2Pc.dll
Vcl40.bpl
5. Códigos de erro

1. Canal inválido
2. Canal não disponível
3. Impossível ler status do canal
4. Não conseguiu setar o timeout para o canal
5. Não conseguiu setar o canal serial
10. Timeout
11. Não conseguiu ler do canal serial (frame incorreto)
13. Foi recebido um 5a no meio do frame
14. Erro no cálculo do checksum
15. Não conseguiu escrever o frame no canal serial
40. O tipo da resposta não é compatível com o tipo da pergunta
50. Valor a enviar para uma variável é maior que 9999 ou menor que 0