Ainda há algumas dúvidas em relação à geração do arquivo da portaria CAT-52 e Ato Cotepe 17/04 para o estado de São Paulo.

Nesta edição de nosso Flash-tip, estaremos detalhando todos os procedimentos de geração deste arquivo, através de nossas ferramentas de comunicação.

A Bematech implementou em sua dll de alto-nível BemaFI32.dll, o controle e geração do arquivo da portaria CAT-52 (layout para as impressoras fiscais matriciais) e Ato Cotepe 17/04 (layout para as impressoras fiscais térmicas com MFD) automaticamente. A última versão disponível em nosso site é 5.8.0.0.

Basta atualizar a BemaFI32.dll juntamente com as dlls BemaMFD.dll, BemaMFD2.dll e o arquivo de configuração BemaFI32.ini, no diretório de sistema de seu Windows (C:\Windows\System32, por exemplo).

As chaves das seções [SoftwareHouse] e [ECF], no arquivo BemaFI32.ini, devem ser configuradas da seguinte forma:

Exemplo:

[SoftwareHouse]
COO=003351
NumeroAplicativo=01
CNPJ=11111111111111
IE=22222222222222
IM=33333333333333
RazaoSocial=EMPRESA DE SOFTWARE TESTE
NomeAplicativo=APLICATIVO TESTE
Versao=1.0
Linha1=LINHA1 TESTE
Linha2=LINHA2 TESTE

[ECF]
IM=44444444444444
UF=SP

Obs: Se a impressora fiscal utilizada for MP-20 FI II ou MP-40 FI II, a chave Impressora na seção [MFD] deve possuir o valor 0 (Impressora=0), caso contrário esta chave deve possuir o valor 1 (Impressora=1).

Configurando estas chaves, a dll estará controlando os dados para a geração da CAT-52 ou Ato Cotepe 17/04.

Quando é gerado o arquivo final pronto para ser validado?

Existem 3 situações:

1) Quando for executada a Redução Z pela aplicação de automação comercial;
2) Quando a impressora emitir automaticamente a Redução Z às 02:00 horas da manhã e, posteriormente, for aberto o cupom fiscal e;
3) Quando a impressora emitir automaticamente a Redução Z quando for ligada no dia seguinte e, posteriormente, for aberto o primeiro cupom fiscal do dia.

Nas impressoras fiscais matriciais, a dll irá criar e manter um arquivo de extensão .RFD durante o movimento do dia (este arquivo corresponde ao Registro de Fita-Detalhe e seu conteúdo é criptografado).

Quando ocorrer uma das 3 situações acima, a dll irá converter este arquivo em um novo arquivo (sem extensão .RFD) no formato e layout da portaria CAT-52, pronto para ser validado no site da SEFAZ/SP.

Nas impressoras fiscais térmicas, a dll irá gerar o arquivo final diretamente da MFD (Memória de Fita-Detalhe) da impressora, quando ocorrer uma das 3 situações acima, ou seja, a dll fará o download da MFD do dia do movimento, e criará o arquivo no formato e layout do Ato Cotepe 17/04.

Onde é gerado o arquivo final?

O arquivo da portaria CAT-52 ou Ato Cotepe 17/04 é gerado no caminho configurado na chave Path do arquivo BemaFI32.ini. Além do arquivo final, o arquivo .RFD ou .MFD também é gerado neste caminho.

Bematech Monitor (ambiente Windows e DOS)

O driver Bematech Monitor para acesso remoto às impressoras fiscais Bematech também está preparado para a portaria CAT-52 e Ato Cotepe 17/04, pois ele interage com a dll BemaFI32. Então, basta configurar as chaves citadas acima no arquivo BemaFI32.ini da estação.

Aplicações em ambiente DOS (janela DOS) também podem gerar o arquivo da CAT-52 e Ato Cotepe 17/04, comunicando com as impressoras fiscais Bematech, através do Bematech Monitor.

O Bematech Monitor foi criado para acessar às impressoras fiscais Bematech remotamente, porém seu "mecanismo" de comunicação é "troca de arquivos", ou seja, a dll cria um arquivo com um código e o Bematech Monitor transforma este código na função correspondente da dll. Portanto, sua aplicação em DOS pode criar este arquivo (BemaFI32.cmd) com o código da função correspondente ao processo que deseja executar na impressora e envia-o para o Bematech Monitor, este por sua vez lê o arquivo e realiza todo o processo de envio à impressora, controlando os dados para a geração da CAT-52 e Ato Cotepe 17/04 (veja no arquivo de ajuda BemaFI32.chm, tópico "Utilizando a DLL em aplicações 16 Bits", mais informações sobre seu uso).

Além disso, se sua aplicação DOS faz acesso às impressoras fiscais Bematech através do Bemafi.exe, você também poderá usar o Bematech Monitor.

O Bematech Monitor reconhece a sintaxe e nomenclatura do arquivo Bemafi.cmd. Então, basta retirar a chamada ao Bemafi.exe e criar o arquivo Bemafi.cmd normalmente, gravando-o na pasta de monitoramento do Bematech Monitor. Se o arquivo BemaFI32.ini estiver configurado para gerar a CAT-52 e Ato Cotepe 17/04, o arquivo final será gerado.

Geração do arquivo CAT-52 / Ato Cotepe 17/04 retroativo

É possível gerar o arquivo da portaria CAT-52 e Ato Cotepe 17/04 retroativo, de duas maneiras:

- pela BemaFI32.dll

Implementamos na dll a função Bematech_FI_GeraRegistrosCAT52MFD que permite gerar o arquivo final, a partir de informações contidas na MFD das impressoras fiscais térmicas ou a partir do arquivo .RFD ou .MFD gerados anteriormente.

A função Bematech_FI_GeraRegistrosCAT52MFD possui os seguintes parâmetros:

Arquivo: STRING com o nome do arquivo .MFD ou .RFD de onde os registros serão gerados. Informar o caminho completo.

DataGeracao: STRING com a data que os registros serão gerados, no formato ddmmaa, dd/mm/aa, ddmmaaaa ou dd/mm/aaaa.

E, funciona da seguinte maneira:

- Para os modelos de impressoras fiscais matriciais é obrigatório informar o arquivo .RFD como parâmetro. O parâmetro que corresponde a data não é obrigatório e será ignorado caso seja informado. O arquivo da CAT-52 será gerado com as informações contidas no arquivo .RFD informado.

- Para os modelos de impressoras fiscais térmicas com MFD temos as seguintes possibilidades:

a) se não forem informados o arquivo .MFD e a data como parâmetros, a função fará o download da MFD da data atual e fará a geração do arquivo do Ato Cotepe 17/04.

b) se for informado o arquivo .MFD e não for informada a data, a função retornará erro.

c) se for informada apenas a data, a função fará o download da MFD com base na data informada e fará a geração do arquivo do Ato Cotepe 17/04.

d) se forem informados o arquivo .MFD e a data, a função fará a geração do arquivo do Ato Cotepe 17/04 com as informações contidas no arquivo .MFD na data informada.

- Para o emulador da impressora fiscal a função terá efeito, se a comunicação com ele for realizada através de seu cabo serial fisicamente conectado ao micro (COM1 <-> COM2, por exemplo), pois é realizado o download da MFD para a geração do arquivo. A pinagem deste cabo está descrito no arquivo de ajuda do emulador.

Exemplo em Visual Basic:

iRetorno = Bematech_FI_GeraRegistrosCAT52MFD("C:\download.mfd", "30/07/2007")

ou

iRetorno = Bematech_FI_GeraRegistrosCAT52MFD("C:\BEB00007.M57.rfd", "30/07/2007")

Exemplo em Delphi:

Arquivo := 'C:\download.mfd';
Data := '30/07/2007';

iRetorno := Bematech_FI_GeraRegistrosCAT52MFD( pchar( Arquivo ), pchar( Data ) );

ou

Arquivo := 'C:\BEB00007.M57.rfd';
Data := '30/07/2007';

iRetorno := Bematech_FI_GeraRegistrosCAT52MFD( pchar( Arquivo ), pchar( Data ) );

- pelo WinMFD2

A Bematech disponibiliza em seu site um aplicativo chamado WinMFD2 que possibilita a geração do arquivo da portaria CAT-52 e Ato Cotepe 17/04 retroativo, nas impressoras fiscais matriciais e térmicas.

A utilização deste aplicativo se dá da seguinte maneira:

1) para impressoras fiscais térmicas com MFD

- No menu "Comunicação", selecione a porta de comunicação (fig. 1) onde a impressora está conectada e neste mesmo menu selecione o modelo da impressora (fig. 2).

fig. 1

fig. 2

- No menu "Arquivo", selecione a opção CAT-52 (fig. 3). 

fig. 3

- Na janela que surgir, selecione as opções desejadas e clique no botão "Gerar Registros".

A geração do Ato Cotepe 17/04, diretamente da impressora, leva aproximadamente 30 segundos para um dia de movimento fiscal com 350 cupons fiscais emitidos.

- pelo micro-terminal SB-2010/SB-2011/SB-3010

A geração do arquivo para os micro-terminais fiscais Bematech ocorrerá somente se a impressora fiscal utilizada por eles for térmicas (MFD). Desta forma, a impressora deverá ser conectada a um computador com o aplicativo WinMFD2 instalado, e proceder conforme orientações acima (tópico "pelo WinMFD2" ).

Obs: para os micro-terminais que usam impressoras fiscais matriciais a geração do arquivo para a portaria CAT-52 não será possível, pois ambos os equipamentos não possuem memória para armazenamento e emissão dos registros da portaria.

Nomenclatura do arquivo

O arquivo gerado para a portaria CAT-52 e Ato Cotepe 17/04 possui um conteúdo de texto, visível pelo "Bloco de Notas (notepad)" do Windows (por exemplo). Entretanto, sua nomenclatura é definida da seguinte forma:

- Nome do arquivo no formato FFM12345.DMA, sendo: 

Exemplo:

BEE28347.1C7, sendo:

Basicamente, são estas 3 funções que usaremos na implementação e comunicação com o SB-2030E.

Obs: A dll BemaSB32 é disponibilizada junto com a instalação do VisualSDK Builder.


- Declarando as funções da BemaSB32.dll

Abra um projeto novo e inclua estas linhas em seu início (se preferir, pode adicioná-las em seu módulo de declarações):

function Bematech_SB_SelecionaInterface( TipoInterface: Integer ): integer; StdCall; External 'BEMASB32.DLL';

function Bematech_SB_AdicionaIp( NumeroTerminal: Integer; NumeroIP : String): Integer; StdCall; far; External 'BEMASB32.DLL';

function Bematech_SB_RS485_EnviaCmdTamanho( Comando: String; IDterminal: String; nProcesso: String; Confirmacao: String; Dados: String; StRetorno: String; DataRetorno: String; TemRetorno: String; Tamanho: String ): Integer; StdCall; External 'BEMASB32.DLL';

Adicione um botão ao formulário chamado "Adiciona IP", que fará a associação do IP ao número do terminal. O código para este botão ficará assim:

procedure TForm1.Button1Click(Sender: TObject);
var
   iRetorno : integer;
   cIP : string;
begin
   cIP := '10.10.100.100';
   iRetorno := Bematech_SB_SelecionaInterface( 2 );
   if ( iRetorno <> 1 ) then
      Application.MessageBox( 'Erro ao selecionar interface!', 'Atenção', MB_IconError + MB_OK )
   else
      begin
         iRetorno := Bematech_SB_AdicionaIp( 1, pchar( cIP ) );
         if ( iRetorno <> 1 ) then
            Application.MessageBox( 'Erro ao adicionar IP!', 'Atenção', MB_IconError + MB_OK );
      end;
end;

Repare que neste código já estamos definindo, através da função Bematech_FI_SelecionaInterface, a interface de comunicação que será usada: TCP/IP (parâmetro da função igual a 2). Estamos associando o IP 10.10.100.100 do SB-2030E ao terminal de número 1. Isso deverá ser feito, respectivamente, para cada SB-2030E disponível na rede.

Obs: Nas edições anteriores do Flash-tip, vimos como procurar o SB-2030E na rede, retornando seu IP.

Todos os comandos disponíveis no modo remoto estão relacionados às funções do SDK. Por exemplo: para limpar o display do SB-2030E, usamos a função clrscrU() no modo programável e para o modo remoto usaremos o comando "111" com a sigla "U" - a sigla indica que é display do usuário.

Iremos utilizar alguns comandos básicos para conhecer esta funcionalidade do SB-2030E. Os demais comandos podem ser vistos no help do VisualSDK Builder, tópico "Trabalhando com o SB2000 remotamente". Baixe a versão atualizada aqui!


- Limpando o Display do Usuário

Adicione um botão ao formulário chamado "Limpa Display" e insira o seguinte código:

procedure TForm1.Button2Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Limpa o Display do Usuário.
   Função clrscrU do SDK. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '111';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '0';
   cBufferEnviado := 'U';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );
end;

A função Bematech_SB_RS485_EnviaCmdTamanho tem por finalidade enviar o comando para o micro-terminal. Esta é a função mais utilizada na comunicação, então vamos entender seus parâmetros:

Obs: mesmo possuindo o termo "RS485" (criado quando os modelos do SB-2030 eram de rede serial RS-485), a função também é compatível para o modelo SB-2030E (TCP/IP).


- Escrevendo uma Mensagem no Display do Usuário

Adicione um novo botão chamado "Imprime Mensagem" e insira o seguinte código:

procedure TForm1.Button3Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Imprime uma mensagem no Display do Usuário.
   Função printfU do SDK. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '117';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '0';
   cBufferEnviado := 'U,TESTE DE MENSAGEM NO DISPLAY !!!';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );
end;


- Ligando o Cursor no Display do Usuário

Adicione um novo botão chamado "Liga Cursor" e insira o seguinte código:

procedure TForm1.Button4Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Liga o cursor no Display do Usuário.
   Função setcursorU( ON ) do SDK. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '115';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '0';
   cBufferEnviado := 'U,3';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );
end;


- Solicitando uma String do Teclado

Adicione um novo botão chamado "Pede String" e insira o seguinte código:

procedure TForm1.Button5Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Habilita uma entrada de STRING via teclado.
   Função getstring do SDK. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '130';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '0';
   cBufferEnviado := '20,8,NULL,NULL';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );
end;


- Recebendo uma String do Teclado

Adicione um novo botão chamado "Recebe String" e insira o seguinte código:

procedure TForm1.Button6Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Recebe uma String do Teclado. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '101';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '1';
   cBufferEnviado := '0001';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );

   if ( copy( cStatusSB2000, 1, 1 ) = '1' ) and ( copy( cBufferRetornoSb2000, 1, 1 ) <> '2' ) then
      Application.MessageBox( pchar( copy( cBufferRetornoSb2000, 3, length( cBufferRetornoSb2000 ) - 2 ) ), 'Informação', MB_ICONINFORMATION + MB_OK )
   else
      Application.MessageBox( 'Não há dados !', 'Informação', MB_ICONINFORMATION + MB_OK );

   if copy( cBufferRetornoSb2000, 1, 1 ) = '2' then
      Application.MessageBox( 'Erro no retorno do Processo !', 'Erro',
MB_ICONERROR + MB_OK )
   else
      Application.MessageBox( 'Número do Processo OK !', 'Informação', MB_ICONINFORMATION + MB_OK );
end;


- Verificando qual tecla foi pressionada

Adicione um novo botão chamado "Verifica Tecla Pressionada" e insira o seguinte código:

procedure TForm1.Button7Click(Sender: TObject);
var
   cStatusSB2000 : string;
   cBufferRetornoSB2000 : string;
   cBufferEnviado : string;
   cComando : string;
   cNumeroTerminal : string;
   cNumeroProcesso : string;
   cEnviaStatus : string;
   cTemRetorno : string;
   cTamDados : string;

   iConta : integer;
   iRetorno : integer;
begin
   { Verifica qual tecla foi pressionada no SB-2030E.
   Função waitkey do SDK. }

   for iConta := 1 to 2 do cStatusSB2000 := cStatusSB2000 + ' ';
   for iConta := 1 to 256 do cBufferRetornoSB2000 := cBufferRetornoSB2000 + ' ';

   cComando := '134';
   cNumeroTerminal := '1';
   cNumeroProcesso := '0001';
   cEnviaStatus := '1';
   cTemRetorno := '1';
   cBufferEnviado := '0001';
   cTamDados := inttostr( length( cBufferEnviado ) );

   iRetorno := Bematech_SB_RS485_EnviaCmdTamanho( cComando, cNumeroTerminal, cNumeroProcesso, cEnviaStatus, cBufferEnviado, cStatusSB2000, cBufferRetornoSB2000, cTemRetorno, cTamDados );

   if ( copy( cStatusSB2000, 1, 1 ) = '1' ) and ( trim( cBufferRetornoSb2000 ) <> '' ) then
      Application.MessageBox( pchar( copy( cBufferRetornoSb2000, 1, length( cBufferRetornoSb2000 ) ) ), 'Informação', MB_ICONINFORMATION + MB_OK )
   else
      Application.MessageBox( 'Não há dados !', 'Informação', MB_ICONINFORMATION + MB_OK );
end;

Assim, já temos o "caminho das pedras" para implementar outros comando e controlar o micro-terminal SB-2030E remotamente pela aplicação.

Estaremos informando quando a nova versão da BemaFI32.dll estiver disponível em nosso site para download.

Caso você esteja utilizando outra interface de comunicação, segue abaixo algumas dicas que lhe ajudarão a entender um pouco mais sobre o RFD.



O nome do arquivo deverá ter o formato FFM12345.DMA, sendo:

• FF - dentificação do fabricante do ECF;
• M - identificação do modelo do ECF;
• 12345 - cinco últimos caracteres do número de fabricação do ECF;
• DMA - identificação do dia, mês e ano do movimento, codificados com números de 1 a 9 e letras de A a Z, sendo que a letra A corresponde ao número 10;

E, deverá:

• ser criado para cada dia de movimento do ECF;
• ser validado por meio de código gerado por função unidirecional MD5 (Message Digest nº 5), de conhecimento exclusivo do desenvolvedor do RFD, em todos os registros do arquivo (com exceção do registro EAD) para gerar código que garanta integridade do arquivo. Este código deverá ser assinado digitalmente utilizando o algoritmo RSA de chave pública de 128 bits e informado no registro EAD.
• conter o caracter “#” (sustenido) na primeira posição da descrição do item, para fins de controle de item manufaturado pelo próprio contribuinte emitente;
• ser gerado no momento de execução da Redução Z;
• constar os registros E00, E01, E02, E12, E13, E14, E15, E16, E21 e EAD, sendo:
• registro tipo E00 - Identificação da Software House.
• registro tipo E01 - Identificação do ECF.
• registro tipo E02 - Identificação do atual contribuinte usuário do ECF.
• registro tipo E12 - Relação de reduções Z.
• registro tipo E13 - Detalhe da Redução Z.
• registro tipo E14 - Cupom Fiscal, Nota Fiscal de Venda a Consumidor ou Bilhete de Passagem.
• registro tipo E15 - Detalhe do Cupom Fiscal, da Nota Fiscal de Venda a Consumidor ou do Bilhete de Passagem.
• registro tipo E16 - Demais documentos emitidos pelo ECF.
• registro tipo E21 - Detalhe do Cupom Fiscal e Documento Não Fiscal - Meio de Pagamento
  registro EAD - Assinatura digital.

Layout dos registros:

• Tipo: texto não delimitado.
• Tamanho: variável, acrescidos de CR/LF (Carriage Return/Line feed) ao final de cada registro.
• Organização: seqüencial.
• Codificação: ASCII.

Formato dos Campos:

• Numérico (N): sem sinal, não compactado, alinhado à direita, suprimidos a vírgula e os pontos decimais, com as posições não significativas zeradas.
• Alfanumérico (X): alinhado à esquerda, com as posições não significativas em branco.
• Data (D): somente os algarismos da data, no formato (AAAAMMDD).
• Hora (H): somente os algarismos da hora, no formato (HHMMSS).

Preencimento dos Campos:

• Numérico: na ausência de informação, os campos deverão ser preenchidos com zeros.
• Alfanumérico: na ausência de informação, os campos deverão ser preenchidos com brancos.
• Origem do dado: Memória Fiscal (MF), Memória de Fita-detalhe (MFD), Memória de Trabalho (MT), Redução Z (imagem de dados codificados, impressa de acordo com o disposto na alínea "d" do inciso II da cláusula terceira do Convênio ICMS 85/01 de 28 de setembro de 2001).
• Data: na ausência de informação, os campos deverão ser preenchidos com brancos.
• Hora: na ausência de informação, os campos deverão ser preenchidos com brancos.

Você poderá consultar o site da SEFAZ/SP para obter maiores informações a respeito, ou através do link direto:

http://info.fazenda.sp.gov.br/NXT/gateway.dll/legislacao_tributaria/portaria_cat/pcat522007.htm

Listamos aqui, algumas dúvidas que poderão surgir durante o desenvolvimento do RFD:

• Registro Tipo E00 / Campo 03 (MF Adicional):

Essa informação é retirada do *número de série da impressora. Se o último caracter do número de série for uma letra, essa letra deve ser incluída nesse campo. Se for um número ou qualquer outro valor esse campo deve ser preenchido com espaço em branco.

*O número de série da impressora é obtido através do comando ESC 35 00 (para os modelos MP-20 FI II ou MP-40 FI II, que retornam 15 bytes) ou ESC 35 40 (para os modelos MP-25 FI, MP-50 FI, MP-2000 TH FI, MP-2100 TH FI, MP-3000 TH FI ou MP-6000 TH FI, que retornam 20 bytes).

• Registro Tipo E00 / Campo 04 (Número do Usuário):

Este campo corresponde ao número de substituição do proprietário, que pode ser obtido através do comando ESC 35 11.

• Registro Tipo E00 / Campo 05 (Tipo de ECF):

Esse campo pode ser preenchido com o valor fixo "ECF-IF" porque todas as impressoras fiscais da Bematech são desse tipo. Caso você preferir, a informação pode ser lida através do comando ESC 35 60 (exceto nos equipamentos MP-20 FI II e MP-40 FI II que não possuem esse comando). O comando retorna marca, modelo e tipo de ECF.

• Registro Tipo E01 / Campos 12 (Casas decimais da quantidade) e 13 (Casas decimais de valor unitário):

Para as impressoras MP-20 FI II, MP-40 FI II, MP-25 FI, MP-50 FI, MP-2000 TH FI e MP-6000 TH FI o número de casas decimais é fixo em 3 casas.

Para as impressoras MP-2100 TH FI e MP-3000 TH FI essa informação é configurável, e só é realizada no momento da inicialização da impressora (programação do usuário). Entretanto, não ha nenhum comando que retorne essa informação.

Você deverá realizar essa configuração no software, por exemplo: no momento em que o software for instalado, você executa uma Leitura da Memória Fiscal (comando ESC 08) e verifica como a impressora está programada, se duas ou 3 casas decimais. Uma outra alternativa para verificar essa configuração é tentar realizar uma venda utilizando 3 casas decimais, se o comando for realizado a impressora está programada com 3 casas decimais, caso contrário o comando não será executado.

• Registro Tipo E01 / Campos 15 (CRZ inicial) e 16 (CRZ final):

Contador de redução Z poderá ser obtido pelo comando ESC 35 09. Para as impressoras MP-25 FI, MP-50 FI, MP-2000 TH FI, MP-2100 TH FI, MP-3000 TH FI e MP-6000 TH FI este retorno também poderá ser obtido pelo comando: ESC 88 (Leitura dos dados da última Redução completo).

• Registro Tipo E01 / Campos 19 (Versão da Biblioteca):

Caso esteja utilizando a BemaFI32.dll, através da função Bematech_FI_VersaoDll é possível recuperar esta informação. Caso esteja utilizando outra interface, esse campo pode ser preenchido com o valor 00.00.00.

• Registro Tipo E02 / Campos 11 (CRO - Contador de Reinício de Operação):

Informações do registro tipo E02 são informações referente ao atual usuário cadastrado na impressora. O CRO que deve ser incluído neste campo é o CRO que estava na impressora no momento que o atual usuário foi cadastrado e não o CRO atual da impressora.

Como conseguir essa informação?

Você terá que realizar uma leitura da memória fiscal pela serial e procurar essa informação no texto retornado. Não somente o campo CRO, mas também os campos Data do cadastro e Hora do cadastro do usuário (Campos 8 e 9 do Registro Tipo E02).

Veja um exemplo da Leitura da Memória Fiscal:

IMPRESSÃO FITA DETALHE
CFD DATA HORA COOi COOf
CNPJ:
000001 13/06/2007 10:25:29 002323 002325
CNPJ: 11111111111111111111
000002 13/06/2007 10:26:33 002326 002328
CNPJ: 11111111111111111111
USUÁRIOS
Usuário:0001 CRO:001 15/01/2007 16:24:01V
CNPJ: 11111111111111111111
IE: 22222222222222222222
IM: 33333333333333333333
GT: 19.287,79
.
.
.

Usaremos estruturas para a criação de tabelas dentro do SB-2030E. Veja um exemplo:

/*
A estrutura Produto receberá registros formados pelos campos:

   Codigo        tipo char com 14 posições;
   Descricao     tipo char com 30 posições;
   Aliquota      tipo char com 3 posições e;
   VlrUnitario   tipo long.

que serão armazenados na tabela TblPro.
*/

struct Produto
{
   char Codigo    [ 14 ];
   char Descricao [ 30 ];
   char Aliquota  [  3 ];
   long VlrUnitario;
};
.
.
.

Para que possamos definir o tipo (char, int, long e etc) e o tamanho de cada campo que a tabela conterá, precisamos usar uma formatação própria, da seguinte forma:

"XyXy"

onde:

"X" corresponde a primeira letra do tipo do campo (variável) em maiúscula (Char, Int, Long e etc) e;
"y" corresponde ao tamanho da área desejada.

Para entendermos melhor esta definição, vamos tomar como exemplo a estrutura Produto acima citada, onde temos 4 campos (variáveis), 3 são do tipo char e 1 do tipo long.

O formato de nossa tabela seria assim:

"C14C30C3L", 1000

onde:

C14 = char de 14 posições, usado para representar o primeiro campo "Codigo";
C30 = char de 30 posições, usado para representar o segundo campo "Descricao";
C3 = char de 3 posições, usado para representar o terceiro campo "Aliquota";
L= long, usado para representar o quarto campo "VlrUnitario" e;

1000 = quantidade de registros que a tabela armazenará.

Obs: Variáveis do tipo char são as únicas que usam definição de tamanho.

Vamos conhecer agora, as principais funções de acesso ao banco de dados que iremos usar em nosso exemplo.

- função formataSDK

A função formataSDK formata a memória não volátil destinada ao armazenamento dos dados, preparando-a para receber as tabelas e seus registros. Ao executarmos esta função, todas as tabelas existentes e seus registros serão apagados. Então, teremos que preparar uma rotina que verifique se a memória já está formatada, para que este processo não seja realizado toda vez que iniciar o sistema.

- função criatabelaSDK

A função criatabelaSDK cria uma tabela na memória não volátil, com um tamanho máximo que especificamos. Se a criação for bem sucedida, a tabela iniciará com 0 (zero) byte gravado. Caso a tabela já exista, receberemos um código de erro como retorno que poderemos tratar. Para que possamos criar as tabelas, a formatação da memória deve ter sido feita anteriormente.

- função addregistroSDK

A função addregistroSDK adiciona um novo registro ao final da tabela. Esta inclusão sempre será feita após o último registro existente na tabela. Caso for desejado, podemos exigir que o ponteiro da tabela fique posicionado sobre o novo registro incluído. Isso é configurado via parâmetro na função.

- função seekregistroSDK

A função seekregistroSDK posiciona o ponteiro da tabela sobre um determinado registro, utilizando um campo e uma condição definida, para localizá-lo. Se a pesquisa for bem sucedida, os campos contidos no registro localizado serão colocados na estrutura (struct) criada para a tabela. O campo usado para a pesquisa, poderá possuir um valor numérico (int) ou um texto (char). O início da pesquisa será determinado por um dos parâmetros da função e poderá ser realizada a partir do primeiro registro da tabela (após o BOF) ou a partir da posição atual. Para ambos os casos, a pesquisa só termina após encontrar o primeiro registro que satisfaça a condição imposta ou até atingir o fim da tabela (EOF). Ao localizar o registro, a tabela será posicionada, caso contrário o posicionamento atual não será afetado.

- função deleteregistroSDK

A função deleteregistroSDK apaga somente um determinado registro da tabela. Para isso, devemos primeiro posicionar o ponteiro da tabela sobre o registro que será excluído. Caso o ponteiro da tabela esteja posicionado sobre o <BOF> ou <EOF>, um código de retorno será enviado à função. Após a exclusão do registro, o ponteiro da tabela fica posicionado sobre o próximo registro, e se o registro deletado for o último, o ponteiro fica posicionado sobre o <EOF>.

- função positionregistroSDK

A função positionregistroSDK posiciona o ponteiro da tabela sobre um registro desejado. O ponteiro pode ser posicionado sobre qualquer registro compreendido entre <BOF> e <EOF>, mesmo que o registro esteja deletado. Esta função posiciona o ponteiro da tabela no registro para poder executar operações de escrita, consulta e exclusão. Se o número do registro a ser posicionado for maior que a quantidade total de registros da tabela, o ponteiro será posicionado sobre o <EOF>.

- função readregistroSDK

A função readregistroSDK lê um registro da tabela e coloca na estrutura (struct) criada para a tabela ou em uma nova estrutura, desde que possua os mesmos campos. Se o ponteiro da tabela estiver posicionado sobre o <BOF> ou <EOF> um código de retorno será enviado à função.

- função writeregistroSDK

A função writeregistroSDK escreve sobre um determinado registro eliminando o conteúdo anterior. Se o ponteiro da tabela estiver posicionado sobre o <BOF> ou <EOF>, um código de retorno será enviado à função.

- função zeratabelaSDK

A função zeratabelaSDK apaga todo o conteúdo da tabela especificada.

- função lestatustabelaSDK

A função lestatustabelaSDK retorna informações da tabela especificada, como:

Quantidade total de registros da tabela;
Quantidade de registros gravados na tabela;
Tamanho em bytes do registro e etc.

- Criando um projeto com banco de dados

Vamos iniciar um novo projeto no VisualSDK Builder (menu "File" - opção "New Project") para praticar as funções relacionadas ao banco de dados.

Obs: Não esqueça de configurar o ambiente para o modelo SB-2030E antes de compilar o projeto, e localizar o micro-terminal na rede antes de transferir a aplicação (menu "Project" - opção "Options" ).

O primeiro passo é criarmos a estrutura que estará recebendo os dados para posteriormente serem armazenados no banco. Para isso, abaixo das linhas de #include, insira a struct Produto da seguinte forma:

struct Produto
{
   char Codigo [ 14 ];
   char Descricao [ 30 ];
   char Aliquota [ 3 ];
   long VlrUnitario;
};

Ela será global e guardará informações sobre o código, descrição, alíquota e valor unitário de nosso produto.

Dentro do main(), vamos criar algumas variáveis que serão usadas no código e referenciar a struct.

void far main()
{
   int iOpcao,
       iResp,
       iRet;

   char cTempVlrUnitario[ 9 ];

   struct Produto CampoProduto;
.
.
.

Criamos um menu de rolagem para executar as funções separadamente, assim poderemos entender melhor o funcionamento de cada uma e usá-las em nossos projetos futuros.

As opções de nosso menu de rolagem são: "Formata Memoria BD", "Cria Tabela", "Insere Registro", "Pesquisa Registro", "Apaga Registro" e "Status Tabela".

O código para a criação deste menu fica assim:

.
.
.
   clrscrU();
   getopcao( &iOpcao, 0, "<- Formata Memoria BD ->,<- Cria Tabela ->,<- Insere Registro ->,<- Pesquisa Registro ->,<- Apaga Registro ->,<- Status Tabela ->" );
.
.
.

Iremos tratar a escolha das opções dentro de um "switch/case", sendo que o "case 0" corresponde à opção "Formata Memoria BD", conforme abaixo:

.
.
.
   switch( iOpcao )
   {
      case 0:
         clrscrU();
         printfU( "AVISO: Os dados serao apagados.\n" );
         printfU( "Deseja continuar ?: " );
         getopcao( &iResp, 0, "<- NAO ->,<- SIM ->" );
         if ( iResp == 1 )
         {
            clrscrU();
            centralizaU( 1, "<<< Formatando, aguarde... >>>" );
            espera0( 1000 );
            if ( ( formatSDK( 524288 ) ) != 0 )
            {
               clrscrU();
               centralizaU( 1, "<<< PROBLEMAS NA FORMATACAO >>>" );
               centralizaU( 2, "Pressione algo, p/ continuar..." );
               getch();
            }
            else
            {
               clrscrU();
               centralizaU( 1, "<<< FORMATACAO CONCLUIDA COM SUCESSO >>>" );
               centralizaU( 2, "Pressione algo, p/ continuar..." );
               getch();
            }
         }
      break;
.
.
.

Repare que neste código, fazemos uma pergunta ao operador antes de iniciar a formatação da memória reservada ao banco de dados e testamos o retorno da função "formataSDK". Caso o retorno seja 0 (zero) significa que a formatação foi bem sucedida e exibimos uma mensagem de OK, caso contrário exibimos uma outra mensagem para o operador. O tamanho da memória neste exemplo, é de 512KB representados em bytes (524288 bytes). Caso o micro-terminal seja o modelo SB-2030EP, temos um pente de expansão de 2MB para o banco de dados, então este deverá ser formatado no tamanho de 2097152 bytes.

O "case 1" corresponde à função "Cria Tabela":

.
.
.
      case 1:
         iRet = criatabelaSDK( "TblPro", "C14C30C3L", 1000 );
         clrscrU();
         switch( iRet )
         {
            case 1:
               centralizaU( 1, "<<< TABELA JA EXISTE ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 2:
               centralizaU( 1, "<<< NOME TABELA ACIMA DE 6 CARACTERES ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 3:
               centralizaU( 1, "<<< QTDE MAX DE TABELAS ATINGIDA ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 4:
               centralizaU( 1, "<<< ERRO NA DECLARACAO DA STRUCT ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 5:
               centralizaU( 1, "<<< STRUCT ACIMA DE 100 CARACTERES ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 6:
               centralizaU( 1, "<<< QTDE REGISTROS ACIMA DA ESPECIFICADA ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            case 7:
               centralizaU( 1, "<<< MEMORIA NAO FORMATADA ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
            default:
               centralizaU( 1, "<<< TABELA CRIADA COM SUCESSO ! >>>" );
               espera0( 2 SEGUNDOS );
            break;
         }
      break;
.
.
.

Na função criatabelaSDK estamos passando como parâmetros: o nome da tabela (TblPro), seu formato (C14C30C3I) e seu tamanho total de registros (1000). Estamos também analisando o retorno desta função, exibindo uma mensagem para cada situação ao operador.

No "case 2" adicionamos um registro à tabela "TblProd":

.
.
.
      case 2:
         memset( CampoProduto.Codigo, NULL, sizeof( CampoProduto.Codigo ) );
         memset( CampoProduto.Descricao, NULL, sizeof( CampoProduto.Descricao ) );
         memset( CampoProduto.Aliquota, NULL, sizeof( CampoProduto.Aliquota ) );
         memset( cTempVlrUnitario, NULL, sizeof( cTempVlrUnitario ) );
         CampoProduto.VlrUnitario = 0;

         clrscrU();
         setcursorU( ON );
         printfU( "Codigo: " );
         getstring( CampoProduto.Codigo, 13, NUMERICO, NULL, NULL );

         if ( ( seekregistroSDK( "TblPro", (char*)&CampoProduto, (char*)&CampoProduto.Codigo, "=", 'F' ) ) != 0 )
         {
            clrscrU();
            printfU( "Descricao......: " );
            getstring( CampoProduto.Descricao, 29, ALFA, NULL, NULL );
            printfU( "\nCodigo Aliquota: " );
            getstring( CampoProduto.Aliquota, 2, ALFA, NULL, NULL );
            clrscrU();
            printfU( "Valor Unitario:          " );
            getstring( cTempVlrUnitario, 8, FORMAT | REVERSO, " . , ", NULL );
            setcursorU( OFF );

            CampoProduto.VlrUnitario = atol( cTempVlrUnitario );

            if ( ( addregistroSDK( "TblPro", (char*)&CampoProduto, 0 ) ) == 0 )
            {
               clrscrU();
               setcursorU( OFF );
               centralizaU( 1, "<< Produto cadastrado com sucesso ! >>" );
               espera0( 2 SEGUNDOS );
            }
            else
            {
               clrscrU();
               setcursorU( OFF );
               centralizaU( 1, "<< Problemas com o cadastro ! >>" );
               espera0( 2 SEGUNDOS );
            }
         }
         else
         {
            clrscrU();
            setcursorU( OFF );
            centralizaU( 1, "<< Produto ja cadastrado ! >>" );
            espera0( 2 SEGUNDOS );
         }
      break;
.
.
.

Neste case, inicializamos as variáveis da struct em memória com NULL (\0) e fazemos a primeira entrada de dados, através do código do produto (função getstring). Repare que antes de entrar com as outras informações do produto, fazemos uma pesquisa na tabela para verificar se o código do produto informado já está cadastrado (função seekregistroSDK). Caso o retorno seja diferente de 0 (zero), entramos com as demais informações (descrição, alíquota e valor unitário), caso contrário exibimos uma mensagem ao operador informando que o produto já se encontrada cadastrado na tabela, evitando que o mesmo seja duplicado. Esta é uma operação normal quando se trabalha com banco de dados!

Fazemos a pesquisa do produto cadastrado, no case 3:

.
.
.
      case 3:
         memset( CampoProduto.Codigo, NULL, sizeof( CampoProduto.Codigo ) );

         clrscrU();
         setcursorU( ON );
         printfU( "Codigo: " );
         getstring( CampoProduto.Codigo, 13, NUMERICO, NULL, NULL );
         setcursorU( OFF );

         if ( ( seekregistroSDK( "TblPro", (char*)&CampoProduto, (char*)&CampoProduto.Codigo, "=", 'F' ) ) == 0 )
         {
            clrscrU();
            printfU( "Descricao......: %s\n", CampoProduto.Descricao );
            printfU( "Codigo Aliquota: %s ", CampoProduto.Aliquota );
            printfU( "Valor: %l", CampoProduto.VlrUnitario );
            getch();
         }
         else
         {
            clrscrU();
            setcursorU( OFF );
            centralizaU( 1, "<< Produto nao cadastrado ! >>" );
            espera0( 2 SEGUNDOS );
         }
      break;
.
.
.

Esta rotina é bem simples! Inicializamos a variável CampoProduto.Codigo e fazemos a entrada do código do produto. Através da função seekregistroSDK (vista anteriormente), fazermos a busca deste código na tabela. Se o código for encontrado, exibimos a decrição, o código da alíquota e o valor unitário do produto, caso contrário exibimos uma mensagem para o operador.

No case 4, excluímos o produto:

.
.
.
      case 4:
         memset( CampoProduto.Codigo, NULL, sizeof( CampoProduto.Codigo ) );

         clrscrU();
         setcursorU( ON );
         printfU( "Codigo: " );
         getstring( CampoProduto.Codigo, 13, NUMERICO, NULL, NULL );
         setcursorU( OFF );

         if ( ( seekregistroSDK( "TblPro", (char*)&CampoProduto, (char*)&CampoProduto.Codigo, "=", 'F' ) ) == 0 )
         {
            clrscrU();
            iRet = deleteregistroSDK( "TblPro" );
            switch( iRet )
            {
               case 1:
                  centralizaU( 1, "<< ERRO: Tabela inexistente ! >>" );
                  espera0( 2 SEGUNDOS );
               break;
               case 2:
                  centralizaU( 1, "<< ERRO: Encontrado <BOF> ! >>" );
                  espera0( 2 SEGUNDOS );
               break;
               case 3:
                  centralizaU( 1, "<< ERRO: Encontrado <EOF> ! >>" );
                  espera0( 2 SEGUNDOS );
               break;
               case 4:
                  centralizaU( 1, "<< AVISO: Produto ja excluido ! >>" );
                  espera0( 2 SEGUNDOS );
               break;
               default:
                  centralizaU( 1, "<< Registro excluido com sucesso ! >>" );
                  espera0( 2 SEGUNDOS );
               break;
            }
         }      
         else
         {
            clrscrU();
            setcursorU( OFF );
            centralizaU( 1, "<< Produto nao cadastrado ! >>" );
            espera0( 2 SEGUNDOS );
         }
      break;
.
.
.

Semelhante ao case 3, neste case fazemos a pesquisa do produto no banco de dados e caso seja encontrado, fazemos sua deleção (função deleteregistroSDK). É feito um tratamento de retorno para a função deleteregistroSDK exibindo mensagens para o operador.

E, no case 5 exibimos algumas informações do estado atual da tabela:

.
.
.
      case 5:
         if ( ( lestatustabelaSDK( "TblPro" ) ) == 0 )
         {
            clrscrU();
            printfU( "Tamanho da Tabela: %l registro(s)", SDK_STATUS.QtdeTotalRegistros );
            espera0( 2 SEGUNDOS );

            clrscrU();
            printfU( "Registros Gravados: %l registro(s)", SDK_STATUS.QtdeRegistrosGravados );
            espera0( 2 SEGUNDOS );
         }
         else
         {
            clrscrU();
            centralizaU( 1, "<<< TABELA INEXISTENTE >>>" );
            espera0( 2 SEGUNDOS );
         }
      break;
   }
} /* Fim do programa */

Aqui, apenas verificamos algumas situações, através da função lestatustabelaSDK, retornadas por constantes do banco de dados, como quantidade total de registros e o número de registros cadastrados na tabela.

  clrscrU();
  printfU( "<F1>Vendas  <F2>Manutencao  <F3>Operador\n" );
  printfU( "Escolha a opcao:" );
  setcursorU( ON|PISCANTE );
  gotoxyU( 18, 2 );
  iOpcao = getch();
  switch( iOpcao )
  {
    case F1:
      // ... rotina da opção Venda
      // ...
    break;
    case F2:
      // ... rotina da opção Manutencao
      // ...
    break;
    case F3:
      // ... rotina da opção Operador
      // ...
    break;
  }
}

Esta é a representação no display, após a telecarda:




- Menu de rolagem

Outro tipo de menu que podemos criar é o "menu de rolagem", onde o usuário escolhe a opção usando as setas do teclado (<- ou ->) e pressione <ENTER> sobre a selecionada.

O código para este tipo de menu fica assim:

void far main()
{
  int iOpcao;

  clrscrU();
  printfU( "Use as setas para escolher a opcao:\n" );
  getopcao( &iOpcao, 0, "<- Vendas     ->,<- Manutencao ->,<- Operador   ->" );
  switch( iOpcao )
  {
    case 0:
      // ... rotina da opção Venda
      // ...
    break;
    case 1:
      // ... rotina da opção Manutencao
      // ...
    break;
    case 2:
      // ... rotina da opção Operador
      // ...
    break;
  }
}

Esta é a representação no display, após a telecarda:




Repare que neste código estamos usando uma função nova - a função getopcao.

Esta função cria um menu de rolagem que retorna um valor inteiro quando pressionado <ENTER> sobre a opção selecionada. No exemplo acima, se for escolhida a opção "Vendas", ao pressionar o <ENTER> o retorno para a variável iOpcao será 0 (zero); se for escolhida a opção "Manutencao", o retorno será 1 (um); se for escolhida a opção "Operador", o retorno será 2 (dois) e, assim, sucessivamente.

As opções deste tipo de menu são numeradas, iniciando sempre em 0 (zero). A função getopcao possui 3 parâmetros, onde o primeiro corresponde à variável que receberá o valor da opção escolhida, o segundo corresponde ao índice inicial das opções (qual opção você deseja iniciar no display) e o terceiro é a string com as opções separadas por "," (vírgula).

Assim, disponibilizamos duas formas diferentes de menus para que o operador possa interagir com o aplicativo no SB-2030E.


- Funções de teclado e entrada de dados

Vamos conhecer agora, algumas funções importantes de acesso ao teclado e de entrada de dados - funções que são usadas na maioria das aplicações para o SB-2030E.

- getch()

Podemos usar a função getch para retornar o código da tecla pressionada ou efetuar uma pausa na aplicação.

Da mesma forma que usamos para criar menus fixos, podemos legendar as teclas de venda rápida (localizadas a esquerda do teclado do SB-2030E) e programá-las para agilizar determinadas operações, como por exemplo, vendas de combo de produtos ou escolher a forma de pagamento que se deseja pagar o cupom.

A tecla <Shift> é usada para inserir caracteres em formato maiúsculo ou acionar o segundo caracter disponível na tecla e <Alt> é usada para acionar o terceiro caractere disponível na tecla. Vamos tomar como exemplo a tecla "9", onde temos o símbolo "%" (porcentagem) e "&" (E comercial). Para acionarmos o símbolo de "%" pressionamos a tecla "9" juntamente com <Shift> (<Shift>+<9>) e para acionarmos o símbolo "&" pressionamos a tecla "9" juntamente com <Alt> (<Alt>+<9>).

O código abaixo pode ser usado para testarmos esta funcionalidade:

void far main()
{
  int iTecla;

  clrscrU();
  printfU( "Pressione alguma tecla..." );
  iTecla = getch();
  printfU( "\nCodigo da tecla pressionada: %c", iTecla );
  getch();
}

Esta é a representação no display, após a telecarda e teste do exemplo:




Obs: Para que possamos receber o código da tecla <Shift> ou <Alt>, precisamos usar a função getkeys() ao invés de getch(). Esta função retornará um valor inteiro, correspondente à estas teclas, caso seja necessário usá-las para controlar alguma rotina na aplicação.

- gets()

A função gets permite entradas de texto via teclado. Entretanto, esta função não protege a variável que estará recebendo o texto (string), fazendo com que seu tamanho seja extrapolado. Veja o exemplo:

void far main()
{
  char cCodigo[ 13 ];

No exemplo acima, utilizamos a variável cCodigo (parâmetro 1), limitamos o seu tamanho em 13 caracteres (parâmetro 2), restringimos somente entradas numéricas (parâmetro 3), não usamos formatação (parâmetro 4) e, caso o operador pressione <ENTER>, a variável vai para a memória preenchida com nulos (parâmetro 5).

Esta é a representação no display, após a telecarda e teste do exemplo:




- getstringvirgula

É possível fazermos entrada de dados com vírgula, principalmente quando tratamos de entrada de valores com 2 ou 3 casas decimais - a função que usamos para isso é a getstringvirgula.

Esta função possui os mesmos parâmetros da função getstring que vimos anteriormente, incluindo apenas um parâmetro que defini o número de casas decimais que será usado, onde 0 (zero) é usado para 2 casas decimais e 1 (um) para 3 casas decimais. Veja o exemplo:

void far main()
{
  char cValor[ 9 ];

  memset( cValor, NULL, sizeof( cValor ) );
  clrscrU();
  setcursorU( ON|PISCANTE );
  printfU( "Entre com o Valor Unitario: " );
  gotoxyU( 40, 1 );
  getstringvirgula( cValor, 8, NUMERICO|REVERSO, NULL, NULL, 0 );
  setcursorU( OFF );
}

Esta é a representação no display, após a telecarda e teste do exemplo:

Tools / Edit Options - guia General

Na guia "Format", podemos modificar as propriedades, como cor e formatação, dos elementos que são apresentados na área de inserção do código-fonte, quando programamos (semelhante às configurações que existem nos editores, como VB e Delphi).

Tools / Edit Options - guia Format

Todos os modelos acima permitem a instalação de um kit de expansão de memória adicional de 2MB para armazenamento de dados.

- Conhecendo o micro-terminal (Vista Frontal)

O micro-terminal Bematech modelo SB-2030 E possui um display LCD composto por 2 linhas e 40 colunas, aonde iremos "printar" as mensagem de interação com o usuário/operador. Este display já possui a função de backligth, essencial para ambientes com pouca iluminação.

Seu teclado é composto por 43 teclas, distribuídas assim:

•  16 teclas relegendáveis com descrição de produtos e formas de pagamento;
•  10 teclas relegendáveis de funções + <Shift> e <Alt>;
•  12 teclas numéricas e;
•  03 teclas de controle.

Existe, também, um leitor de cartão magnético (Slot Reader) que permite a leitura de informações gravadas em cartões magnéticos através de operação manual. Ele pode ser utilizado para controle de acesso, controle de ponto, em supermercados, com cartões de fidelidade, cartões de crédito e outras aplicações.

Em específico para o modelo SB-2090, existe um leitor de CMC-7 que permite a leitura de cheques e código de barras, para envio à instituições de crédito e captura de informações bancárias. Aliado as conexões de Internet, possibilita a verificação da situação bancária do documento (por exemplo).

figura 1 - vista frontal

•  Interfaceamento realizado através do protocolo ATR2000 a 6 fios;
•  Operação no modo assíncrono ou síncrono 1200/2400 bps, 8 (oito) bits por caractere, Sem Paridade e 1 (um) Stop Bit;
•  Conexão nos padrões V22 (1200 bps) e V22-Bis (2400 bps), conforme descrição nas recomendações V22 e V22-Bis da CCITT para modems;
•  Operação nos modos V22 e V22-Bis, ANSWER ou ORIGINATE e;
•  Subconjunto dos Comandos AT.

Além dos comandos ATs, o modem V22-Bis implementa um conjunto de comandos, denominados COMANDOS DLE, que permitem ao sistema executar diretamente várias funções importantes para o gerenciamento da comunicação.A conexão é feita através do conector RJ-12.

Na próxima edição do Flash Tip, iremos:

- Conhecer a BIOS, o BOOT e os segmentos de memória, onde nossa aplicação será armazenada;
- O SDK - kit de desenvolvimento e seu conjunto de funções e;
- O Visual SDK Builder que é o nosso ambiente de desenvolvimento, onde criaremos toda nossa aplicação.

Não perca!

Até lá e boas implementações!