Árvore de páginas

Versões comparadas

Chave

  • Esta linha foi adicionada.
  • Esta linha foi removida.
  • A formatação mudou.
Comentário: Migration of unmigrated content due to installation of a new plugin

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.