Histórico da Página
Uso das Templates
A Navegação dentro dos Programas
O primeiro programa a ser executado deve ser o BC9200.EXE, nele deve ser escolhida a opção desejada. Com a opção escolhida o programa descompactará na memória RAM e chamará o programa da transação correspondente; é necessário utilizar “<enter>” para confirmar os campos, “seta para cima” para voltar ao campo anterior, e “clear” para voltar a tela anterior. O registro é definitivamente gravado, quando o último campo da tela for confirmado. Ao voltar para o menu principal, o programa da transação que estava aberto é eliminado da RAM.
O menu traz também algumas funcionalidades como:
• Envio do arquivo com as transações para o coletor;
• Eliminação do arquivo;
• Estorno do backup do arquivo.
Como baixar um arquivo gerado na RAM
Para baixar os arquivos gerados na RAM para o PC, deve ser instalado no PC o TNTERM, e no coletor deve existir o programa TDREM.
Primeiro é necessário deixar o coletor preparado para comunicação com a execução do TDREM, por intermédio do comando abaixo ou da opção envia do menu:
• tdrem-rp1 -rs3
Após isso deve ser executada a seguinte linha de comando no PC:
• TFT3000 - S38 - P1 G (nome do arquivo a ser baixado).
Quando terminar a transmissão, deve ser fechada a comunicação com o comando:
• TFT3000 - S38 -P1 -X
Quando na execução do menu das templates for necessária baixar o arquivo com os registros, utilizar os seguintes comandos:
• Selecionar a opção 6 do menu (Manut Dados).
• No submenu selecionar a opção 1 (Envia Dados).
• Execute o programa download.bat da pasta Comunica_Coletor.
• Será copiado o arquivo bcreg.txt para a máquina; e nesse caso, o arquivo existente no coletor é eliminado e feita uma cópia do backup para o arquivo bcreg.bak, sobrescrevendo o último backup.
• Para voltar o backup para uso, deve-se executar.
• Opção 3 (Recupera Arq.), que vai renomear o arquivo “_bcreg.bak” para “bcreg.txt”.
• Para recomeçar o arquivo de transações sem envia-lo, é só executar a opção 2 (Elimina Dados).
Como Compilar os Programas
• Instalar no PC o compilador Microsoft C.
• Instalar no PC o kit ADK de desenvolvimento da symbol.
• Setar no Microsoft C, o diretório base do ADK.
• Compilar os programas; no caso das transações utilizando o menu bc9200.c, os programas devem ser compactados depois de compilados, utilizando o programa PKZIP, porque os programas são descompactados e eliminados em tempo de execução. Isso é necessário devido a quantidade de memória não volátil (NVM) ser muito pequena. A descompactação em tempo de execução é feita por intermédio de um programa .bat que utiliza o aplicativo unzipjr.
Como Customizar o Menu
O menu pode ser customizado, sendo inicializado a estrutura menu_princ com os seguintes campos:
char_op_menu | Opção que deve ser escolhida na tela para o programa identificar a opção desejada. |
char *item_menu | Deve ser inicializada com a label desejada para aparecer na tela. |
char *programa | Nome do programa sem a extensão a ser executado. |
Também pode ser customizada a função abre_menu, onde no local que está sendo impresso “MENU” pode ser substituído pelo título desejado para a tela.
A função abre_menu deve ser chamada com os parâmetros dos registros inicial e final que irão para a tela.
Como Customizar um Programa de Transações
Para customizar um programa, deve ser seguido os seguintes passos:
Escolha a template que melhor se adapte a situação do cliente; a template tem variações no seu corpo conforme o tipo de navegação.
O primeiro trecho a ser colocado no programa são as definições, que devem ser mantidas conforme abaixo:
#pragma pack(1)
Bibliotecas C Microsoft
#include <ctype.h>
#include <dos.h>
#include <fcntl.h>
#include <io.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <sys\types.h>
#include <sys\stat.h>
Biblioteca ADK
#include <3000\bios.h>
#include <3000\dos.h>
#include <3000\urm.h>
Bibliotecas Definições Data Collection */
#include <bc9200a.h>
Após isso, devem ser definidos os pré-processadores com os intervalos da tela, título, tamanho da tela do coletor, e arquivo para gravação, por exemplo:
#define COL_TELA 16 /*Número de Colunas da tela*/
#define LIN_TELA 8 /*Número de Linhas da tela*/
#define REG_INI_1 0 /*Índice do primeiro registro da primeira tela*/
#define REG_FIM_1 5 /*Índice do último registro da primeira tela*/
#define TITULO_1 “Transf Mat ½ “ /*Título da primeira tela*/
>#define TITULO_1 6 /*Índice do primeiro registro da segunda tela*/
#define REG_FIM_2 11 /*Índice do segundo registro da segunda tela*/
#define TITULO_2 “Transf Mat 2/2” /*Titulo da segunda tela*/
>#define ARQUIVO_GRAVAÇÃO “d:bc9201.txt” /*Arquivo para gravação do registro*/
Deve ser colocado o restante do código antes do MainBlock, e deve ser definido o número de campos que existem na tela, na declaração de quantos registros terá a estrutura, e na declaração global da matriz valor[][15].
/*Deve ser trocado o índice abaixo pelo número de registros da estrutura, que equivale ao número de campos */
Struct reg_campos_tela_campos_tela[12];
/*Variáveis Globais*/
int con_handle;
int handle_comm = -1;
/*Deve ser trocado o primeiro índice pelo número de registros da estrutura, que equivale ao número de campos da tela*/
char valor[12][15];
/*Declaração das Funções*/
void mostra_erro (int nr_erro);
void monta_string (char *registro);
short após_leitura(char titulo[], short,short);
/*Bibliotecas Funções Data Collection*/
#include <bc9200.h>
Inicialização da Estrutura de campos
/*Inicialização dos campos para construção do programa*/
campos_tela[0].cd_campo= 1; /*Número para identificação do campo*/
strcpy(campos_tela[0].label,”Estab”); /*Labeldo campo*/
strcpy(camos_tela[0].tipo,”int”); /*Tipo de dados do campo: “int”, “chr”, “dat” e “dec”*/
campos_tela[0].tamanho= 3; /*Tamanho do campo para leitura*/
strcpy(campos_tela[0].inicial,”014”); /*Valorque é inicializado o campo*/
campos_tela[0].dec_ano = 0; /*Quant de decimais para o caso de ser uma campo “dec”, e quant de casas p/ ano no caso de ser “dat”*/
Essa inicialização deve ser repetida para cada campo enviado para a tela, variando o índice do registro, Ex: campos_tela[1], campos_tela[2] etc.
Quando o campo não solicita informação na tela, deve ser modificado o campo cd_campo para 0, que então é tratado internamente. Um exemplo desse procedimento está no programa bc9204.
Observação 1: Campo da estrutura que seja uma string sem valor, deve ser inicializada com o primeiro byte da string com ‘\0’.
Exemplo:
campos_tela[0].inicial[0] = ‘\0’
Observação 2: Campo da estrutura que seja uma string com valor, deve ser inicializado com a função strcpy.
Exemplo:
strcpy(campos_tela[0].label,”Estab”)
Após a inicialização da estrutura é criado o corpo do programa, se o programa tem somente duas telas, sendo a segunda repetitiva, pode-se seguir o modelo do corpo dos programas bc9201.c, bc9202.c e bc9205.c; nesse caso, o único ponto a ser alterado no corpo principal é o nome do programa, passando para função_execlp, que executa o programa de menu e aborta o atual.
Para uma estrutura mais complexa o programa ideal para se basear é o bc9203.c, preparado para quantas telas forem necessárias, com navegação independente.
No exemplo abaixo é utilizada a estrutura mais complexa.
Primeiro deve ser feita a validação de todas as telas do programa no seguinte código:
If((exec_erro = valida_tela(REG_INI_1,REG_FIM_1) == 1) && (valida_tela(REG_INI_2,REG_FIM_2)==1)
&&..... ..........&& (valida_tela(REG_INI_6, REG_FIM_6) == 1))
O programa somente prossegue quando todas as telas estão OK.
Caso passe pela validação, é necessário entrar na tela inicial, que deve sempre se basear neste modelo, pois no caso de abortar essa tela, retorna ao menu:
if (tela== 1)
{
do
{
constroi_tela(TITULO_1,REG_INI_1, REG_FIM_1);
ex_erro = le_campos(REG_INI_1,REG_FIM_1);
if (exec_erro == 1)
{
exit_erro = _execlp(“bc9200”,”bc9200”,”d:bc9203.exe”, NULL);
if (exec_erro == 1)
{
mostra_erro(6);
exit(0);
}
}
tela = 2
}while((valor[3][0]<’1’)||(valor[3][0]>’3’));
}
}
No exemplo acima existe um menu para navegação, onde a tela é identificada como 1, seguindo os passos:
• Constrói a tela com o comando constroi_tela.
• Lê os campos com o comando le_campos, caso o comando le_campos retorne aborto da tela(1), o programa retorna ao menu principal.
• Valida a tela para a qual quer navegar, com o valor lido pelas funções.
• Fecha com o while, que obriga a tela a ser reconstruída, enquanto não possuir os valores desejados.
No próximo exemplo passa para a tela 2, que corresponde a tela de Reporte Repetitivo. Essa segunda tela é simples, ao terminar a leitura (caso correta), vai para outra tela sem se repetir.
if (tela== 2)
{
switch(valor[3][0])
{
case ’1’ : campos_tela[8].cd_campo = 0;
campos_tela[9].cd_campo = 0;
break;
case ’2’ : campos_tela[8].cd_campo = 9;
campos_tela[9].cd_campo = 0;
normal'>break;
case ’3’ : campos_tela[8].cd_campo = 0;
campos_tela[9].cd_campo = 10;
break;
}
do
{
constroi_tela(TITULO_2,REG_INI_2,REG_FIM_2);
if(exec_erro = le_campos(REG_INI_2,REG_FIM_2) ! = 0)
{
tela = 1;
break;
}
tela = 3;
}while (!após_leitura(TITULO_2,REG_INI_2,REG_FIM_2));
}
Assim, como no caso anterior, o programa:
• Constrói a tela.
• Lê os campos.
• O comando SWITCH faz a habilitação e desabilitação dos campos, conforme foi selecionado na primeira tela.
• No caso do usuário abortar, a tela não irá sair do programa, simplesmente atribui 1 para tela, retornando para a tela 1. Caso contrário, passa para a tela 3.
• Antes de sair é utilizada a função apos_leitura para fazer as validações e atualização de valores, se essa função retornar 0, ele entenderá como erro e voltará a pedir todos os registros, caso contrario, passa para a tela 3.
• A tela 3 é o último tipo de tela, é a tela final que é repetitiva, esta tela grava os registro, e o programa somente saíra dela quando o usuário abortar com a tecla “clear”.
f (tela == 3)
{
do
{
constroi_tela(TITULO_3,REG_INI_3,REG_FIM_3);
inicializa_campos(REG_INI_3,REG_FIM_3);
if(exec_erro= le_campos(REG_INI_3,REG_FIM_3) != 0)
{
tela= 2;
break;
}
tela = 3;
}while(!apos_leitura(TITULO_3,REG_INI_3,REG_FIM_3));
>if (exec_erro == 0)
{
monta_string(registro);
erro_gravacao = grava_registro(registro,ARQUIVO_GRAVACAO);
if(erro_gravação!= 0)
mostra_erro(erro_gravação);
}
}
• Constrói a tela.
• Inicializa os campos, caso a tela se repetir não é necessário reconstruí-la cada vez, somente limpar os campos.
• Chama a função de leitura novamente, caso o usuário abortar a tela 2; saindo do bloco de leitura do registro, depois da validação, passa pela função monta_string, que retorna o registro construído no layout numa string. Passa a string para ser gravada no registro e caso o usuário não tenha escolhido abortar a tela, volta a pedir os campos da tela para gravação de um novo registro.
Observação: Depois desse bloco, o tronco do programa pode ser fechado.
Como Fazer a Transação Utilizar o Padrão Americano Para Decimais?
Para o programa obedecer ao padrão americano em campos decimais, é necessário alterar a constante NUM_TYPE que está definida no programa bc9200a.h para o valor “1”.
Como criar uma mensagem de ERRO?
Para criar uma nova mensagem de erro, deve ser adicionado na função mostra_erro um case no fim do switch, alimentado a variável desc_erro, e especificando um número para a função no case. Para mostrar a mensagem utilizar o código: mostra_erro (<nr erro>);
Para parametrizar a mensagem, é necessário definir uma variável global.
Como validar um registro ao fim de cada tela?
Colocar conforme nos exemplos, um bloco do... while... chamando a função apos_leitura, assim pode ser validado os registros.
A função apos_leitura recebe os valores do título da tela a ser validada, e quais os índices iniciais e finais dos campos que devem ser validados. Nessa função pode ser validado e atualizado os valores da tela.
Os valores validados estão na matriz valor, e possuem os mesmos índices da estrutura campos_tela correspondente. EX: O valor[4], e o valor digitado para o campo campos_tela[4].
Primeiro verificar se o campo validado corresponde a tela que está sendo validada, caso obedeça a essa condição, pode ser feita a validação ou atualização do valor do campo conforme solicitado. Caso contrario, a variável retorna_erro deve ter seu valor alterado para 0. Veja o exemplo abaixo:
short retorna_erro = 1
if (registro_fim == REG_FIM_2)
{
if(strcmp(valor[3],”0”)
{
mostra_erro(15);
retorna_erro = 0;
}
if (valor[5][0] != ‘\0’)
{
mostra_erro(16);
retorna_erro = 0;
}
}
if (registro_fim == REG_FIM_3)
int_to_float(valor[14], valor[14],dec_ano); /*faz conversão dos valores para “dec”*/
if (retorna_erro == 0)
constroi_tela(titulo,registro_ini,registro_fim);
return retorna_erro;
Observação Importante: Os campos decimais têm seus valores gravados como números inteiros. Para gravar com casas decimais, é necessário utilizar a função int_to_float na função após_leitura como no exemplo acima.
Como personalizar o layout de registro?
O Layout de exportação é construído na função monta_string, possibilitando personalizar o layout de forma exclusiva. A função recebe o ponteiro para uma string qualquer e grava sobre ela o registro dentro do layout, pronto para ser gravado no arquivo. Para importação pelo Data Collection, deve ser utilizado o caracter “|” para separação dos campos, e a string deve ser terminada com a soma dos caracteres asc 13 + 10; também deve ser cadastrado nos parâmetros do Data Collection o caracter “|” como separador.
Visão Geral
Import HTML Content
Conteúdo das Ferramentas
Tarefas