Caro Parceiro,

Esta é nossa última edição do mini-curso sobre a programação do microterminal FIT Básico. Nesta edição, vamos usar funções de acesso às portas seriais e acessar periféricos conectados ao FIT Básico, como leitor de código de barras e impressora não fiscal, tendo uma idéia básica para depois poder evoluir no desenvolvimento.

Então, as funções serão:

• Bematech_FIT_LeituraCodigoBarras
• Bematech_FIT_EnviaSerial

Lendo Código de Barras

Vamos começar implementando a rotina para o uso do leitor de código de barras serial. Para isso, teremos que utilizar um conjunto de funções: uma para ler o código de barras, propriamente dito, e outra para receber byte a byte a informação do código lido. Então, a função Bematech_FIT_LeituraCodigoBarras apenas solicitará ao microterminal que acesse o leitor para ativar a leitura do código de barras, e a função Bematech_FIT_LerBuffer receberá byte a byte o código.

Em nosso formulário, criamos um botão para executar a função Bematech_FIT_LeituraCodigoBarras juntamente com a Bematech_FIT_LerBuffer, e para apresentar o código lido usaremos o mesmo campo “Memo” (para o Delphi) ou “List” (para o VB), já criado anteriormente.

Mão na massa… ou melhor, no código!

Abrimos o botão “Código de Barras” para implementar:

- Em Delphi

procedure TForm1.Button7Click(Sender: TObject);
var
  iRetorno: Integer;
  tmp: Char;
  buffer: String;
begin
  application.MessageBox( ‘Leia o código de barras’, ‘Informação’, MB_ICONINFORMATION + MB_OK );
  // Comando para ativar o FIT a retornar o código de barras
  iRetorno := Bematech_FIT_LeituraCodigoBarras( strtoint( Edit1.Text ) );
  if ( iRetorno = 0 ) then
    begin
      application.MessageBox( ‘Erro na execução do comando!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK );
    end
  else
    begin
      // Rotina para a leitura byte a byte dos caracteres do cód. de barras 
      while ( tmp <> #13 ) do
        begin
          sleep( 100 );
          tmp := Bematech_FIT_LerBuffer( strtoint( Edit1.Text ) );
          buffer := buffer + tmp;
        end;
      Memo1.Text := buffer;
    end;
end;

- Em VB

Private Sub Command7_Click()
  Dim iRetorno As Integer
  Dim buffer As String
  Dim tmp As Byte

  MsgBox “Leia o Cód. de Barras”, vbInformation + vbOKOnly, “Atenção”

  ‘ Comando para leitura do código de barras’
  iRetorno = Bematech_FIT_LeituraCodigoBarras(CInt(Text1.Text))

  ‘ Rotina para a leitura byte a byte dos caracteres do cód. de barras’
  If iRetorno = 0 Then 
    MsgBox “Erro na execução do comando”, vbInformation + vbOKOnly, “Atenção”
  Else
    buffer = “”
    Do While (Chr(tmp) <> Chr(13))
      Sleep (100)
      tmp = Bematech_FIT_LerBuffer(CInt(Text1.Text))
      buffer = buffer + Chr(tmp)
    Loop
  End If
  List1.AddItem (buffer)
End Sub

Enviando Texto pela Serial

Para testar a função Bematech_FIT_EnviaSerial, iremos acrescentar em nosso formulário, além de um novo botão, uma caixa de texto onde entraremos com uma mensagem qualquer para envio à impressora.

Esta função também recebe como parâmetro a porta serial do microterminal onde será enviada a mensagem. Então vamos criar mais um “GroupBox” e dois “RadioButton” (para o Delphi) ou um “Frame” e dois “OptionButton” (para o VB).

Vejamos como ficará nosso formulário:

Abrimos o botão “Impressão pela Serial” para implementar:

- Em Delphi

procedure TForm1.Button8Click(Sender: TObject);
var
  iRetorno: Integer;
  tmp: String;
  Serial: Byte;
  iConta: Integer;
begin
  tmp := Edit5.Text + #10 + #13;
  if ( RadioButton3.Checked = True ) then
    Serial := Ord( ‘S’ )
  else
    Serial := Ord( ‘R’ );

  for iConta := 1 to length( tmp ) do
    begin
      // Comando para enviar o texto a ser impressora pela serial.
      iRetorno := Bematech_FIT_EnviaSerial( strtoint( Edit1.Text ), Ord( tmp[ iConta ] ), Serial );
      if ( iRetorno = 0 ) then
        begin
          ShowMessage( ‘Erro de Comunicação!’ );
          Exit;
        end;
    end;
end;

- Em VB

Private Sub Command8_Click()
  Dim iRetorno As Integer
  Dim Serial As Byte
  Dim iConta As Integer

  If Option3.Value = True Then
    Serial = Asc(”S”)
  Else
    Serial = Asc(”R”)
  End If

  For iConta = 1 To Len(Text5.Text)
    If (Bematech_FIT_EnviaSerial(CInt(Text1.Text), Asc(Mid(Text5.Text, iConta, 1)), Serial)) = 0 Then
      MsgBox “Erro comunicação !”, vbInformation + vbOKOnly, “Atenção”
      iConta = Len(Text5)
    End If
  Next

  ‘ Para descarregar o buffer na impressora ( LF + CR )
  iRetorno = Bematech_FIT_EnviaSerial(CInt(Text1.Text), 10, Serial)
  iRetorno = Bematech_FIT_EnviaSerial(CInt(Text1.Text), 13, Serial)
End Sub

Assim, com estas duas implementações, concluimos nosso mini-curso sobre o microterminal FIT Básico.

Este mini-curso foi desenvolvido com a intenção de apresentar nosso microterminal FIT Básico, suas configurações e sua programação através da BemaSB32.dll com suas funções mais usuais.

Neste mini-curso aprendemos, como utilizar o display, como receber informações do FIT Básico e de como controlá-lo, além de trabalhar com periféricos conectados em suas portas seriais.

Agradecemos muito por sua atenção e nos vemos nos próximos Flash-Tips!

E, boas implementações!

Caro parceiro,

Na edição 35 de nosso Flash Tip para o microterminal FIT Integra, vimos os requisitos básicos para a instalação do FIT DEVELOPER KIT, e como criar e configurar um novo projeto. Fizemos um breve comentário sobre as API´s de comunicação e configuração de nosso projeto para acesso via rede.

Nesta edição, vamos criar o nosso primeiro exemplo imprimindo algumas mensagens no display do microterminal, como compilar o projeto, onde os arquivos são alocados no microteminal após compilação do projeto, e qual é o arquivo do microterminal que devemos configurar para que nosso projeto seja carregado no processo de BOOT.

Então, vamos lá! Desejo a você um bom aprendizado!

Desenvolvendo nosso primeiro exemplo e usando a API de comunicação para o display do microterminal (display do usuário)

O primeiro passo para desenvolver nosso exemplo, é incluirmos a API necessária que irá interpretar as funções específicas usadas em nosso código. Como nosso objetivo nesta edição é desenvolver um exemplo para apresentar mensagens no display do microterminal, devemos usar a API <UDisplay.h> disponível no SDK do FIT Integra. Então, basta efetuarmos um include no início de nosso projeto ex: #include <UDisplay.h>, conforme ilustrado na figura abaixo:

Vamos agora, implementar este exemplo simples que irá imprimir algumas mensagens no display do microterminal:

#include <stdlib.h>

// this is strictly necessary
typedef unsigned char uint8_t;

#include <UDisplay.h>

int main(void)
{
  // Inicializar o display do microterminal (usuário)
  UserDisplayInit();

  // Limpa o display do microterminal (usuário)
  UserDisplayClearAll();

  // Função que deixa o cursor invisível ou visível
  UserDisplaySetCursorVisible(1);

  // Função que escreve no visor na linha 1 e Coluna 1
  UserDisplayPrint(1, 1, “Impressao linha 1 Coluna 1″);

  // Função que escreve no visor na linha 2 e Coluna 2
  UserDisplayPrint(2, 2, “Impressao linha 2 Coluna 2″);

  // Função que escreve no visor na linha 3 e Coluna 3
  UserDisplayPrint(3, 3, “Impressao linha 3 Coluna 3″);

  // Função que escreve no visor na linha 4 e Coluna 4
  UserDisplayPrint(4, 4, “Impressao linha 4 Coluna 4″);

  // Finaliza o uso do Display do microterminal (usuário)
  UserDisplayStop();

  // return success
  return EXIT_SUCCESS;
}

Neste exemplo, usamos as seguintes funções: 

A ação deste exemplo será, simplesmente, imprimir as seguintes mensagens no display do microterminal, após sua compilação:

Impressão Linha 1 Coluna 1
 Impressão Linha 2 Coluna 2
  Impressão Linha 3 Coluna 3
   Impressão Linha 4 Coluna 4#

É importante lembrar que o exemplo é apenas executado no microterminal para que possamos visualizar o seu efeito. Para que ele se torne um aplicativo inicializável, ou seja, que ao ligar o microterminal ele se auto-carregue, é necessário fazer algumas modificações no microterminal, que veremos no decorrer desta edição.

Configurando nosso projeto para compilação

Para realizar a compilação de nosso projeto, o processo é bem simples, porém é extremamente importante que neste ponto a configuração de rede no projeto esteja devidamente configurada, conforme vimos na edição 35.

Então, o primeiro passo para compilar nosso projeto, após a inserção de algumas linhas de código, é definirmos a configuração para “FIT Remote Application”. Para tal processo, devemos clicar no ícone  (”Run”) que fica localizado na barra de ferramentas do projeto, conforme acima. A seguinte janela é apresentada:

 Devemos selecionar a opção “FIT Remote Application” e clicar em “New”. Uma nova janela é apresentada:

Perceba que em “FIT Remote Application” foi criado um novo projeto de compilação chamado “BemaFit”, e na guia ao lado temos as opções de configuração deste projeto. A opção Name é preenchida automaticamente com o nome do projeto, na guia Main a opção Project também é preenchida automaticamente, mas caso não seja para inserir o arquivo de projeto em Browse, seremos direcionado diretamente para a pasta do projeto.

E, finalmente, devemos seguir os mesmos passos para a opção C/C++ Application, porém devemos clicar em Search Project… se a lacuna correspondente não estiver preenchida, e definirmos nosso projeto .gdb. Em seguida basta confirmar as configurações clicando em “Run”, automaticamente já estaremos na tela principal de nosso projeto. Neste momento o projeto já está pronto para ser compilado, e o botão  (”Run”) pode ser pressionado novamente para a compilação.

Note que após clicarmos no botão “Run”, o processo de compilação do projeto é inicializado. Temos a janela de complicação dividida em algumas partes, e na guia Console é possível acompanhar todo o processo de conexão e transferência de nosso código para o microterminal. Caso haja algum erro de comunicação ou erros que possam impedir o processo, certamente serão mostrados na Console.

Onde o projeto é alocado no microterminal após compilação

Após o processo de compilação, automaticamente nosso projeto compilado será alocado para o seguinte File System do microterminal: /mnt/mmc/FitDebug

No entanto, para que nosso projeto seja inicializado automaticamente no momento do BOOT do microterminal, é necessário o definirmos no arquivo de inicialização do mesmo. Para este processo, devemos editar o arquivo userrc que está alocado na pasta “/mnt/mmc” para que seja carregado.

Para realizarmos a mudança necessária no arquivo userrc, antes precisamos acessar o microterminal via FTP, caso contrário não teremos acesso de escrita neste arquivo.

Para acessar o modo FTP, devemos abrir um navegador de arquivo qualquer e digitar a seguinte linha de comando na barra de endereço:

FTP://IP_microterminal/mnt/mmc

Para criação deste exemplo, o micro terminal utilizado estava com o seguinte endereço Ip: 10.10.100.33, neste caso a linha de comando fica como:

FTP://10.10.100.33/mnt/mmc

Obs: Ao ser solicitado usuário e senha informamos, user: root e senha: bematech.

Em seguida basta editarmos o arquivo userrc e definirmos o caminho de nosso projeto. Após isso, basta clicar em salvar e o microterminal já está configurado para carregar nosso primeiro projeto, após próximo BOOT.

Assim, nosso primeiro projeto está pronto!

Próxima edição:

Na próxima edição, iremos avançar um pouco mais nas funcionalidades do display, criando menus de interação.

Não perca!

Até lá e boas implementações!

Caro Parceiro,

Nesta edição de nosso Flash-Tip do mini-curso sobre o microterminal FIT Básico, iremos dar continuidade ao nosso exemplo e implementar as funções mais usuais de acesso ao display do microterminal.

Então, vamos lá!

Limpando o Display

Começamos com a função para limpar o display. Para isso, vamos criar no formulário o botão “Limpar Display”, conforme imagem:

Na codificação dele, iremos criar a variável iRetorno para analisar o retorno da função, conforme já fizemos nos botões anteriores, e usaremos também o número do microterminal para identificarmos qual receberá a execução da função.

Obs: Esta função limpa todas as informações do display, colocando o cursor na primeira coluna da primeira linha.

- Em Delphi

procedure TForm1.Button4Click(Sender: TObject);
var
  iRetorno: Integer;
begin

  iRetorno := Bematech_FIT_LimpaDisplay( strtoint( Edit1.Text ) );

  if ( iRetorno = 0 ) then
    begin
      application.MessageBox( ‘Erro na execução da função!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK );
    end;
end;

- Em VB

Private Sub Command4_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_LimpaDisplay(CInt(Text1.Text))

  If iRetorno = 0 Then
    MsgBox “Erro na execução do comando”, vbInformation + vbOKOnly, “Atenção”
  End If
End Sub

Escrevendo no Display

Vamos agora, enviar uma string para o display do microterminal. Esta string será escrita a partir da posição atual do cursor.

Para isso, vamos implementar no formulário uma caixa de texto para receber um texto qualquer que será enviado ao display e um botão para executar a função correspondente, chamado “Escreve no Display”, conforme imagem:

No código do botão, implementamos:

- Em Delphi

procedure TForm1.Button5Click(Sender: TObject);
var
  iRetorno: Integer;
  Msg: String;
begin
  Msg := Edit2.Text;

  iRetorno := Bematech_FIT_EscreveDisplay( strtoint( Edit1.Text ), Msg );

  if (iRetorno = 0) then
    begin
      Application.MessageBox( ‘Erro na execução do comando!’, ‘ERRO’,MB_ICONINFORMATION + MB_OK );
    end;
end;

- Em VB

Private Sub Command5_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_EscreveDisplay(CInt(Text1.Text), Text2.Text)

  If iRetorno = 0 Then
    MsgBox “Erro na execução do comando”, vbInformation + vbOKOnly, “Atenção”
  End If 
End Sub

Também informamos na função o número do microterminal que receberá a mensagem.

Posicionando o Cursor

Temos uma função que posiciona o cursor no display, onde podemos determinar a linha e a coluna antes de escrever a string. Esta função utiliza dois parâmetros para a posição do cursor, além do parâmetro com o número do microterminal que vamos interagir.

Para implementar esta função, vamos criar duas caixas de texto no formulário para entrar com o número da linha e da coluna, e um botão chamado “Posicionar Cursor”, conforme imagem:

No código deste botão, implementamos:

- Em Delphi

procedure TForm1.Button6Click(Sender: TObject);
var
  iRetorno: Integer;
begin
  iRetorno := Bematech_FIT_PosicionaCursor( StrtoInt( Edit1.Text ), strtoint( Edit3.Text ), strtoint( Edit4.Text ) );
  if ( iRetorno = 0 ) then
    begin
      application.MessageBox( ‘Erro na execução do comando!’, ‘ERRO’,MB_ICONINFORMATION + MB_OK );
    end;
end;

- Em VB

Private Sub Command6_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_PosicionaCursor(CInt(Text1.Text), CInt(Text3.Text), CInt(Text4.Text))

  If iRetorno = 0 Then ‘Verificação de retorno de erro da função’
    MsgBox “Erro na execução do comando”, vbInformation + vbOKOnly, “Atenção”
  End If
End Sub

Próxima edição:

Em nosso último Flash-Tip da série do mini-curso sobre o microterminal FIT-Básico, vamos acessar as portas serias e interagir com periféricos, como impressora não fiscal e leitor de código de barras.

Não perca!

Até lá e boas implementações!

Caro Parceiro,

Vamos implementar agora, a rotina que fará o acesso ao módulo administrativo das bandeiras - o Módulo ADM.

Este módulo permite acessar as funções de cancelamento, emissão de relatórios, fechamento de lote de transações, re-impressão de TEF e demais configurações específicas da bandeira escolhida.

Como já estamos familiarizados com as referências de dlls e também com as funções da classe TEF, podemos ir direto ao ponto, implementando a chamada ao módulo ADM.

Então, criamos um novo botão dando o nome de “FUNÇÕES ADMINISTRATIVAS”, conforme ilustração:

Abrimos o código deste botão e implementamos:

- em C#

private void btnfuncoesadm_Click(object sender, EventArgs e)
{
  try
  {
    // CRIAÇÃO DA CHAMADA DO MÓDULO ADM DAS BANDEIRAS
    SolicitacaoAdministrativa solicitacaoadm = BematechFiscal.TEF.CriarSolicitacaoAdministrativa(); 

    Transacao resp = BematechFiscal.TEF.EnviarSolicitacao(solicitacaoadm);

    if (Convert.ToInt32(resp.QuantidadeLinhas) > 0) 
    {
      while (true)
      {
        try
        {
          BematechFiscal.TEF.TravarTeclado(true);
          BematechFiscal.TEF.Vias = 1;
          BematechFiscal.TEF.Imprimir(resp, true);
          BematechFiscal.TEF.TravarTeclado(false);
          break;
        }
        catch 
        {
          BematechFiscal.TEF.TravarTeclado(false);
          if (MessageBox.Show(”Impressora não responde. Tentar imprimir novamente ?”, “Atenção”, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) == DialogResult.No)
            break;
        }
      }
    }
  }
  catch (GerenciadorInativoException MensagemErro)
  {
    MessageBox.Show( “Mensagem Erro: ” + MensagemErro.Message );
  }
  BematechFiscal.TEF.Vias = 2;
}

- em VB.NET

Private Sub btnfuncoesadm_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnfuncoesadm.Click
  Try
    ‘ CRIAÇÃO DA CHAMADA DO MÓDULO ADM DAS BANDEIRAS 
    Dim solicitacaoadm As SolicitacaoAdministrativa = BematechFiscal.TEF.CriarSolicitacaoAdministrativa()

    Dim resp As Transacao = BematechFiscal.TEF.EnviarSolicitacao(solicitacaoadm)

    If (Convert.ToInt32(resp.QuantidadeLinhas > 0)) Then
      While (True)
        Try
          BematechFiscal.TEF.TravarTeclado(True)
          BematechFiscal.TEF.Vias = 1
          BematechFiscal.TEF.Imprimir(resp, True)
          BematechFiscal.TEF.TravarTeclado(False)
          Exit While
        Catch
          BematechFiscal.TEF.TravarTeclado(False)
          If (MessageBox.Show(”Impressora não responde. Tentar imprimir novamente ?”, “Atenção”, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) = DialogResult.No) Then
            Exit While
          End If
        End Try
      End While
    End If
  Catch MensagemErro As GerenciadorInativoException
    MessageBox.Show(”Mensagem Erro: ” + MensagemErro.Message)
  End Try
  BematechFiscal.TEF.Vias = 2
End Sub

O acesso ao módulo administrativo é bem simples! Em nosso exemplo, criamos um objeto do tipo “SolicitacaoAdministrativa” e enviamos o mesmo ao GP através do método “EnviarSolicitacao”.

Obs: Note que estamos tratando um tipo de exceção que é a “GerenciadorInativoException” exclusiva para retornos relacionados ao GP das bandeiras.

Ao executar o código, teremos a janela do GP aberta para a escolha da bandeira que faremos a operação ADM. Dependendo da operação, podemos ou não ter uma resposta para imprimir, por exemplo, se optarmos por fazer uma re-impressão do TEF, um cancelamento de TEF ou um fechamento de lote, teremos resposta para imprimir. Sendo assim, usamos o método “Imprimir” semelhante a rotina de impressão dos comprovantes do TEF já vista nos Flash-Tips anteriores, porém com uma condição: através do método “QuantidadeLinhas” da classe “Transacao”, sabemos se a transação realizada possui ou não linhas para imprimir, se houverem linhas para impressão executamos a rotina, caso contrário não.

Fazemos também, o teste de verificação com a impressora. Se houver uma falha na comunicação, exibimos uma mensagem ao operador perguntando se deseja continuar a impressão ou não.

Próxima edição:

Em nosso último Flash-TIP da série sobre a “Classe TEF”, vamos explorar mais esta classe e conhecer como tratar o conteúdo do arquivo INTPOS.001 via Flash Builder.

Não perca!

Até lá e boas implementações!

Caro Parceiro,

Dando continuidade ao nosso mini-curso sobre o microterminal FIT Básico, veremos agora como declarar as funções da BemaSB32.dll e de como utilizá-las na aplicação.

Nesta edição, iremos iniciar com as funções de comunicação com o microterminal.

Obs: Não podemos esquecer que na edição 31 fizemos a configuração do microterminal FIT Básico, definindo o seu IP para a comunicação e demais opções, e na edição 33 conhecemos a BemaSB32.dll e sua configuração. É importante estarmos com tudo isso preparado para podermos iniciar o desenvolvimento.

- Declarando as Funções

A declaração das funções varia de acordo com a linguagem de programação que é utilizada. Em nosso mini-curso, utilizaremos o Delphi 7 e o Visual Basic 6 nas implementações.

• Declaração das Funções da BemaSB32.dll em Delphi

function Bematech_FIT_IniciaComunicacao: integer; stdcall; external ‘BEMASB32.DLL’ ;
function Bematech_FIT_FechaComunicacao: integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_SelecionaProtocolo( iProtocolo: integer ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_LimpaDisplay( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_EscreveDisplay( Terminal: byte; Mensagem: string ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_PosicionaCursor( Terminal: byte; Linha: byte; Coluna: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_LerBuffer( Terminal: byte ): char; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_EnviaSerial( Terminal: byte; Dados: byte; Serial: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_ApagaLinha( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_DeslocaCursorCima( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_DeslocaCursorDireita( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_VersaoFirmware( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_ComandoGenerico( Terminal: byte; Comando: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_LeituraCodidoBarras( Terminal: byte ): integer; stdcall; external ‘BEMASB32.DLL’;
function Bematech_FIT_EnviaComando( Comando: string ): integer; stdcall; external ‘BEMASB32.DLL’;

• Declaração das Funções da BemaSB32.dll em Visual Basic

Private Declare Function Bematech_FIT_IniciaComunicacao Lib “BemaSB32.dll” () As Integer
Private Declare Function Bematech_FIT_FechaComunicacao Lib “BemaSB32.dll” () As Integer
Private Declare Function Bematech_FIT_SelecionaProtocolo Lib “BemaSB32.dll” (ByVal Protocolo As Integer) As Integer
Private Declare Function Bematech_FIT_LimpaDisplay Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_EscreveDisplay Lib “BemaSB32.dll” (ByVal Terminal As Byte, ByVal Mensagem As String) As Integer
Private Declare Function Bematech_FIT_PosicionaCursor Lib “BemaSB32.dll” (ByVal Terminal As Byte, ByVal Linha As Byte, ByVal Coluna As Byte) As Integer
Private Declare Function Bematech_FIT_LerBuffer Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_EnviaSerial Lib “BemaSB32.dll” (ByVal Terminal As Byte, ByVal Dados As Byte, ByVal Serial As Byte) As Integer
Private Declare Function Bematech_FIT_ApagaLinha Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_DeslocaCursorCima Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_DeslocaCursorDireita Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_VersaoFirmware Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_ComandoGenerico Lib “BemaSB32.dll” (ByVal Terminal As Byte, ByVal Comando As Byte) As Integer
Private Declare Function Bematech_FIT_LeituraCodidoBarras Lib “BemaSB32.dll” (ByVal Terminal As Byte) As Integer
Private Declare Function Bematech_FIT_EnviaComando Lib “BemaSB32.dll” (ByVal Comando As String) As Integer

- Iniciando a Comunicação

Agora, vamos implementar em nossa aplicação de exemplo algumas funções para a comunicação com o microterminal FIT Básico.

O primeiro passo é implementarmos a função que irá iniciar a comunicação com o microterminal - a função Bematech_FIT_IniciaComunicação. Esta função inicia os sockets de comunicação da dll, abrindo a porta configurada no arquivo BemaSB32.ini para “conversar” com o microterminal via TCP/IP.

Então, vamos criar um botão no formulário para implementar esta função, chamando-o de “Iniciar Comunicação”. Abrindo o botão para codificar, criamos a variável iRetorno do tipo inteira para receber o retorno da função, e a implementamos assim:

- Em Delphi

procedure TForm1.Button1Click(Sender: TObject);
var
  iRetorno: integer;
  begin

  iRetorno := Bematech_FIT_IniciaComunicacao();

  if ( iRetorno = 0 ) then
    Application.MessageBox( ‘Erro de Inicialização!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK );
end;

- Em VB

Private Sub Command1_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_IniciaComunicacao

  If iRetorno = 0 Then ‘Verificação de retorno de erro da função’
    MsgBox “Erro de Inicialização”, vbInformation + vbOKOnly, “Atenção”
  End If
End Sub

Após a implementação do código, executamos o formulário e testamos a comunicação. Se tudo estiver correto, podemos observar a mudança de mensagem no display do microterminal, indicando que a comunicação foi estabelecida:

->

Conforme o código acima, fizemos um teste na variável iRetorno para verificar se a execução foi bem sucedida, apresentando uma mensagem de erro caso não tenha conseguido iniciar os sockets de comunicação.

- Finalizando a Comunicação

Para finalizar a comunicação (sockets) é preciso usar a função Bematech_FIT_FechaComunicacao. Esta função irá apresentar no display do microterminal a mensagem de “Desconectado”, conforme a imagem apresentada acima.

- Em Delphi

procedure TForm1.Button2Click(Sender: TObject);
var
  iRetorno: integer; 
  begin

  iRetorno := Bematech_FIT_FechaComunicacao();

  if ( iRetorno = 0 ) then
    Application.MessageBox( ‘Erro de Fechamento!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK );

end;

- Em VB

Private Sub Command2_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_FechaComunicacao

  If iRetorno = 0 Then
    MsgBox “Erro na Finalização”, vbInformation + vbOKOnly, “Atenção”
  End If
End Sub

Neste código vemos que o procedimento é o mesmo que o de inicialização, até mesmo a forma de verificação da variável iRetorno.

- Selecionando o Protocolo de Comunicação

O microterminal FIT Básico permite trabalhar com dois tipos de protocolo: o VT-100 ESC e o VT-100 STX/ETX. Então, vamos implementar a função “Bematech_FIT_SelecionaProtocolo” que seleciona o protocolo para envio dos comandos, mas antes, usaremos no formulário uma regra para que possa ser escolhido qual protocolo se deseja utilizar.

Para isso, inserimos um “GroupBox” e dois “RadioButton”, um para cada protocolo (conforme imagem abaixo).

Vamos implementar esta função dentro do botão “Iniciar Comunicação”, assim o protocolo já é setado.

- Em Delphi

procedure TForm1.Button1Click(Sender: TObject);
var
  iRetorno: integer;
begin

  iRetorno := Bematech_FIT_IniciaComunicacao();

  if ( iRetorno = 0 ) then
    Application.MessageBox( ‘Erro de Inicialização!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK );

  if ( RadioButton1.Checked = True ) then
    begin
      iRetorno := Bematech_FIT_SelecionaProtocolo( 1 );
    end
  else
    begin
      iRetorno := Bematech_FIT_SelecionaProtocolo( 0 );
    end;

end;

- Em VB

Private Sub Command1_Click()
  Dim iRetorno As Integer

  iRetorno = Bematech_FIT_IniciaComunicacao

  If iRetorno = 0 Then ‘Verificação de retorno de erro da função’
    MsgBox “Erro de Inicialização”, vbInformation + vbOKOnly, “Atenção”
  End If

  If Option1.Value = True Then
    iRetorno = Bematech_FIT_SelecionaProtocolo(1)
  Else
    iRetorno = Bematech_FIT_SelecionaProtocolo(0)
End If

End Sub

- Verificando a Versão do Firmware

Para termos a certeza de que tudo está funcionando corretamente, vamos implementar uma função que retorna do microterminal sua versão de software básico (firmware) - a função “Bematech_FIT_VersaoFirmware”. Além disso, é necessário usar uma outra função que irá trazer a versão do software básico, então implementamos também a função “Bematech_FIT_LerBuffer”.

Antes de implementarmos o código, vamos criar um novo botão chamado “Versão do Firmware”, um “TextBox” para receber o número do terminal que iremos trabalhar e um campo “Memo” no caso do Delphi ou “ListBox” no caso do VB, para receber as informações da versão do firmware, conforme imagem:

No botão “Versão do Firmware” implementamos o código:

- Em Delphi

procedure TForm1.Button3Click(Sender: TObject);
var
  tmp: Char;
  buffer: String;
begin
  iRetorno := Bematech_FIT_VersaoFirmware( strtoint( Edit1.Text ) );
  if ( iRetorno = 0 ) then
    begin
      application.MessageBox(’Erro na execução do comando!’,'ERRO’,MB_ICONINFORMATION + MB_OK );
    end
  else
    begin
      while ( tmp <> #03 ) do
        begin
          sleep( 100 );
          tmp := Bematech_FIT_LerBuffer( strtoint( Edit1.Text ) );
          buffer := buffer + tmp;
        end;
        Memo1.Text := buffer;
    end;
end;

- Em VB

Private Sub Command3_Click()
  Dim iRetorno As Integer
  Dim tmp As Byte
  Dim buffer As String

  iRetorno = Bematech_FIT_VersaoFirmware(CInt(Text1.Text))

  If iRetorno = 0 Then ‘Verificação de retorno de erro da função’
    MsgBox “Erro na execução do comando”, vbInformation + vbOKOnly, “Atenção”
  Else
    buffer = “”
    Do While (Chr(tmp) <> Chr(3))
      Sleep (100)
      tmp = Bematech_FIT_LerBuffer(CInt(Text1.Text))
      buffer = buffer + Chr(tmp)
    Loop
  End If
  List1.AddItem (buffer)
End Sub

A função “Bematech_FIT_LerBuffer” retorna byte-a-byte os dados. Então, a implementamos dentro de um laço de repetição que é quebrado quando o último byte for “ETX” (3), que corresponde ao final da transmissão. Além disso, usamos um “Sleep” de 100 milisegundos para garantir o tráfego de pacotes na rede, assim evitando a perda dos dados. Este timer pode ser modificado dependendo do fluxo da rede.

Próxima edição:

Vamos ter uma interatividade maior com o microterminal FIT Básico, utilizando as funções de controle do Display.

Não perca!

Até lá e boas implementações!

Caro Parceiro,

Após implementarmos as nossas rotinas de cupom fiscal e transações TEF, chegou a hora de conhecermos como realizar um cancelamento da transação. Esta operação também é uma das exigidas no roteiro de implementação do TEF fornecido pelas empresas homologadoras, por isso vamos conhecê-la.

Então, em nosso formulário vamos adicionar um botão com o texto “CANCELAR TRANSAÇÃO TEF” e o name “btncancelartransacoestef”, conforme ilustrado abaixo:

Conforme a edição 34 do Flash Tip, na nossa rotina de impressão dos comprovantes TEF criamos um objeto público chamado “minhacolecao” e nele armazenamos toda a coleção de transações efetuadas. Isso se fez necessário, pois ao final da impressão e confirmação das transações usamos o método “ClearTransacoes” que faz a limpeza das transações realizadas, preparando a classe TEF para as novas transações.

Recordando a rotina…

- em C#

public partial class frmtef : Form
{
// CRIAÇÃO DA VARIÁVEL MINHACOLECAO PARA RECEBER OS CONTADORES DE
// TRANSAÇÕES EXECUTADAS.

Transacoes minhacolecao;
(…)

- em VB.NET

Public Class frmtef
‘ CRIAÇÃO DA VARIÁVEL MINHACOLECAO PARA RECEBER OS CONTADORES DE
‘ TRANSAÇÕES EXECUTADAS.

Public minhacolecao As Transacoes
(…)

Então, antes do início da impressão dos comprovantes do TEF, esse objeto é populado com as transações realizadas, conforme podemos ver nas imagens abaixo, retiradas na execução do cancelamento.

- em C#

- em VB.NET

O objeto “minhacolecao” possui 2 comprovantes gravados, indicando que nossa transação TEF é de múltiplos cartões.

Agora que sabemos como o objeto “minhacolecao” é declarado e utilizado, vamos analisar nosso código do cancelamento:

- em C#

private void btncancelartransacaotef_Click(object sender, EventArgs e)
{
  for (int conta = 0; conta < minhacolecao.Count; conta++)
  {
    while (true)
    {
      try
      {
        SolicitacaoCancelamento cancelamentotef = BematechFiscal.TEF.CriarSolicitacaoCancelamento(minhacolecao[conta]);
        Transacao minhatransacaocancelamento = BematechFiscal.TEF.CancelarTransacao(cancelamentotef);
        if (minhatransacaocancelamento.Status == “0″)
        {
          try
          {
            BematechFiscal.TEF.TravarTeclado(true);
            BematechFiscal.TEF.Imprimir(BematechFiscal.TEF.Transacoes[0], true);
          }
          catch
          {
            BematechFiscal.TEF.TravarTeclado(false);
            if (MessageBox.Show(”Impressora não responde. Tentar imprimir Novamente?”, “Atenção”, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
            {
              BematechFiscal.TEF.Imprimir(BematechFiscal.TEF.Transacoes[conta], true);
              BematechFiscal.TEF.TravarTeclado(false);
            }
            else
            {
              break;
            }
          }
        }
        else
        {
          MessageBox.Show(minhatransacaocancelamento.TextoOperador);
        }
        BematechFiscal.TEF.TravarTeclado(false);
        break;
      }
      catch (TEFException MensagemErro)
      {
        MessageBox.Show(”MensagemErro: ” + MensagemErro.Message);
      }
      catch (FiscalException MensagemErro)
      {
        MessageBox.Show(”MensagemErro: ” + MensagemErro.Message);
      }
    }
    SolicitacaoConfirmacao cancelamentoconfirmacao = BematechFiscal.TEF.CriarSolicitacaoConfirmacao();
    BematechFiscal.TEF.ConfirmarTransacao(cancelamentoconfirmacao);
  }
  BematechFiscal.TEF.TravarTeclado(false);
  BematechFiscal.TEF.ClearTransacoes();
}

- em VB.NET

Private Sub btncancelartransacoestef_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btncancelartransacoestef.Click
  Dim conta As Integer
  Try
    For conta = 1 To minhacolecao.Count()
      Try
        Dim cancelamentotef As SolicitacaoCancelamento = BematechFiscal.TEF.CriarSolicitacaoCancelamento(minhacolecao(conta - 1))
        Dim minhatransacaocancelamento As Transacao = BematechFiscal.TEF.CancelarTransacao(cancelamentotef)
        If (minhatransacaocancelamento.Status = “0″) Then
          Try
            BematechFiscal.TEF.TravarTeclado(True)
            BematechFiscal.TEF.Imprimir(BematechFiscal.TEF.Transacoes(0), True)
          Catch
            BematechFiscal.TEF.TravarTeclado(False)
            If MessageBox.Show(”Impressora não responde. Tentar imprimir novamente?”, “Atenção”, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) = Windows.Forms.DialogResult.Yes Then
              BematechFiscal.TEF.Imprimir(BematechFiscal.TEF.Transacoes(0), True)
              BematechFiscal.TEF.TravarTeclado(True)
            Else
              End
            End If
          End Try
        Else
          MessageBox.Show(minhatransacaocancelamento.TextoOperador)
          End
        End If
        BematechFiscal.TEF.TravarTeclado(False)
      Catch MensagemErro As FiscalException
        MsgBox(”MensagemErro: ” + MensagemErro.Message)
      End Try
      Dim cancelamentoconfirmacao As SolicitacaoConfirmacao = BematechFiscal.TEF.CriarSolicitacaoConfirmacao()
      BematechFiscal.TEF.ConfirmarTransacao(cancelamentoconfirmacao)
      BematechFiscal.TEF.TravarTeclado(False)
    Next
    BematechFiscal.TEF.ClearTransacoes()
  Catch MensagemErro As FiscalException
    MsgBox(”MensagemErro: ” + MensagemErro.Message)
  End Try
End Sub

Esta rotina de cancelamento irá acionar o módulo administrativo da bandeira (nos testes usamos a bandeira American Express). Na janela da bandeira que será exibida, informamos a senha e após confirmá-la o arquivo INTPOS.001 é criado com o texto do cancelamento. Nossa rotina irá fazer a impressão dos comprovantes de cancelamento e também a confirmação dos mesmos.

Em nosso código temos um contador (conta), usado para percorrer as transações. Neste caso específico, enquanto o valor do contador não se igualar ao “Count” do objeto “minhacolecao”, significa que ainda existem comprovantes pendentes para o cancelamento.

O próximo passo é a criação de dois objetos: o primeiro do tipo SolicitacaoCancelamento (objeto cancelamentotef), e o segundo do tipo Transacao (objeto minhatransacaocancelamento) que será responsável pelo envio da transação ao GP (Gerenciado Padrão).

Em seguida, montamos a rotina de impressão dos comprovantes de cancelamento. Podemos verificar a semelhança entre esta impressão com as do comprovante vinculado após a venda, onde é necessário inicialmente travar o teclado para a impressão. Note também que dentro da estrutura “try/catch”, estamos tratando a reimpressão dos comprovantes, caso ocorra algum erro (ex: queda de energia).

No caso de uma transação de múltiplos cartões, após a impressão do primeiro comprovante de cancelamento, precisamos confirmar essa transação através da classe SolicitacaoConfirmacao com o objeto criado “cancelamentoconfirmacao”.

Após a impressão do primeiro comprovante, o laço “While True” ainda terá um comprovante pendente, e um novo processo de impressão irá ocorrer.

Ao final da impressão de todos os comprovantes de cancelamento, destravamos o teclado e executamos o método “ClearTransacoes” que vai limpar todas as transações de cancelamento realizadas.

Próxima edição:

Nesta edição, concluímos a implementação dos métodos relacionados à impressão de cupom fiscal e comprovantes não fiscais (comprovante de crédito e débito).

Na próxima edição do “Flash-Tip Classe TEF”, vamos acionar o módulo administrativo (ADM) das bandeiras pelo Gerenciador Padrão.

Não perca!

Até lá e boas implementações!

Caro parceiro,

Na edição 32 de nosso Bematech Flash Tip para o microterminal FIT Integra, vimos como configurar o microterminal para ter acesso aos recursos de rede. Esta configuração é fundamental e imprescindível para que tenhamos uma comunicação entre o microterminal e o computador (estação que irá compilar, transmitir ou gerenciar dados do microterminal).

Nesta edição, iremos abordar os requisitos básicos para instalação do sistema, o processo para instalação da ferramenta de desenvolvimento (FIT Developer KIT) e os passos iniciais para criar um novo projeto.

Vamos lá!

Requisitos básicos para instalação do FIT Developer KIT

Obs: Recomendamos a distribuição Ubuntu nas versões acima, devido a instalação automática de todas as dependências de pacotes necessárias, que serão utilizadas pela ferramenta de desenvolvimento.

Instalando a ferramenta FIT Developer KIT

O CD de instalação da ferramenta acompanha o microterminal, mas se por algum motivo precisar de uma nova cópia por extravio ou danos físicos, poderemos obte-la a partir do seguinte link:

http://partners.bematech.com.br/files/fit902.iso (+/- 700MB)

O processo de instalação da ferramenta é muito simples, ao inserir a mídia na unidade de CD, automaticamente será apresentada a seguinte janela:

Basta clicarmos em “Executar”. Caso estejamos instalando a ferramenta sem acesso ao usuário Root, será solicitado à confirmação de senha deste usuário, basta informá-la na tela de solicitação:

Após confirmação da senha, basta aguardar o processo de instalação:

Concluído o processo de instalação do FIT Developer KIT, podemos agora localizar o atalho da ferramenta. Se estivermos usando o Ubuntu com sua interface padrão de desktop, basta acessarmos “Aplicativos -> Desenvolvimento -> Eclipse”.

A ferramenta Eclipse será carregada e a partir da janela abaixo, já é possível iniciarmos nosso primeiro projeto:

Passos iniciais para criar o primeiro projeto

Neste espaço iremos abordar de maneira clara e simples, o passo a passo para criarmos o nosso primeiro projeto.

A primeira ação será entrar nas seguintes opções: “File -> New -> Project…”

A janela “Select a Wizard” será apresentada, e devemos selecionar uma modalidade para criar este novo projeto. Então, selecionamos a opção “New FIT Project” da pasta “FIT Developer KIT” e, em seguida, clicamos em “Next”.

Na tela “New FIT Project”, devemos definir um nome para este novo projeto, basta digitarmos este nome na caixa “Project Name” (ex: BemaFit) e clicamos em “Next”.

Nesta etapa a janela abaixo será exibida. Não há necessidade de alterarmos nenhum parâmetro, simplesmente clicamos em “Next”.

Obs: Se após esta janela, aparecer uma caixa de diálogo para associar o projeto em C/C++, basta confirmarmos esta mensagem.

Na janela seguinte, teremos as opções para o tipo de projeto que desejamos começar:

Selecionamos a opção “A Simple FIT Application” e clicamos em “Finish”. O projeto será criado, conforme ilustração abaixo:

Configuração do projeto

• Usando as API´s do FIT Developer KIT na aplicação:

Para usar as API´s proprietárias em nosso projeto é muito simples! Agora que já temos o projeto criado, devemos incluir as bibliotecas necessárias à ele.

Importante: Antes de incluirmos as bibliotecas necessárias em nosso projeto, primeiro devemos incluir os respectivos caminhos de leitura “pthread” para as biblioteca que iremos usar, pois são os paths inseridos que irão orientar o nosso projeto sobre o caminho das API´s, as quais serão responsáveis para interpretar as funções que iremos trabalhar.

Com nosso projeto aberto, para incluir os paths necessários, basta clicarmos no botão “Open FIT Developer Kit settings screen”, conforme ilustrado abaixo:

Após clicarmos neste botão, será aberta uma nova janela de configuração.

Devemos expandir a pasta “FIT Developer KIT” e entrar na opção “FIT Compiler Directories”, onde iremos definir todos os Paths que serão usados. Por default, na criação do projeto FIT Developer KIT, automaticamente estes paths já serão preenchidos, mas caso for necessário preenche-los basta copiarmos os Include´s Directories e os Library Directories, conforme mostra a ilustração:

Aqui temos as API´s disponíveis para uso no projeto:

Para incluirmos as respectivas API’s em nosso projeto, basta efetuarmos um include no início do código, conforme mostra a imagem abaixo:

Após a inserção destas API´s, agora somente nos resta configurar em nosso projeto o recurso TCP/IP para que o microterminal possa receber as informações diretamente do projeto. Basicamente será necessário configurarmos as seguintes opções:

• IP remoto do microterminal.
• Usuário remoto do microterminal (usar Padrão: root).
• Respectiva senha do usuário (senha padrão: bematech).
• GDB Debug Port: 10000.
• GDB time out em milissegundos: 5000.
• Time out de conexão: 1000.

Para realizarmos estas configurações, devemos clicar novamente no botão “Open FIT Developer Kit settings screen”, selecionar a pasta raiz “FIT Developer Kit” e preencher os devidos campos como mostra abaixo:

Finalmente, nosso projeto está criado e totalmente configurado. A partir deste ponto, já podemos começar a programar, debugar e transmitir nosso projeto para o microterminal FIT Integra Bematech.

Próxima edição:

• Na próxima edição, daremos início à programação para o microterminal FIT Integra Bematech.

Caro Parceiro,

Agora que já conhecemos um pouco sobre a classe TEF e seus respectivos métodos/propriedades (Flash-Tip edição 28) e já implementamos uma rotina simples de verificação do Gerenciador Padrão (Flash-Tip edição 30), vamos implementar nesta edição, um cupom fiscal completo e executar transações TEF com um ou múltiplos cartões.

Nosso primeiro passo será adicionar as referências necessárias do Flash Builder ao projeto para impressão do comprovante fiscal e também para as transações TEF.

- em C#

using Bematech;
using Bematech.Fiscal;
using Bematech.Fiscal.ECF;
using Bematech.Fiscal.ECF.CupomFiscal;
using Bematech.Fiscal.TEF;

- em VB.NET

Imports Bematech
Imports Bematech.Fiscal
Imports Bematech.Fiscal.ECF
Imports Bematech.Fiscal.ECF.CupomFiscal
Imports Bematech.Fiscal.TEF

Agora que temos as referências adicionadas, vamos inserir em um formulário os seguintes objetos:

Abaixo, um exemplo de como ficará nosso formulário:

Detalhe: Como já temos nosso objeto fiscal criado no projeto, com o nome “BematechFiscal”, não precisamos construí-lo novamente, basta usarmos durante todo o desenvolvimento.

Abertura do cupom fiscal

Agora, vamos implementar o código do botão “btnabrecupom” para a abertura do cupom fiscal.

- em C#

- em VB.NET

Note que no exemplo optamos por utilizar um dos overloads do Cupom que possui 3 parâmetros, sendo eles CPF/CNPJ do cliente, nome e endereço. Se usássemos uma impressora fiscal que não permitisse a entrada destes parâmetros, o próprio Flash Bulder se encarregaria de compatibilizar, usando apenas o parâmetro aceitável.

Venda de itens

Abrimos o botão “btnvendeitem” e implementamos o código da venda do item. Vamos criar um objeto do tipo “ItemExtendido” e popular este objeto com os parâmetros correspondentes. Lembrando que este tipo de objeto permite várias entradas de parâmetros, igual a função Bematech_FI_VendeItemDepartamento que temos em nossa BemaFI32.dll, como por exemplo, o código e descrição do item com até 49 e até 200 caracteres respectivamente, além da entrada de unidade de medida.

- em C#

- em VB.NET

Inicia fechamento do cupom fiscal

Agora que temos as rotinas de abertura do cupom fiscal e a venda de item prontas, é hora de começar a finalizar o cupom fiscal, através do botão “btniniciafechamento”.

- em C# 

- em VB.NET

Note que neste código, os parâmetros de acréscimo e desconto foram passados com valores zerados.

Efetuar Forma de pagamento

Com o fechamento do cupom fiscal iniciado, vamos lançar as formas de pagamento no botão “btnefetuapagamento”.

- em C# 

- em VB.NET

Note que a rotina foi desenvolvimenta para suportar um processo de venda com múltiplas formas de pagamento e também múltiplas transações TEF.

Detalhe: No exemplo, vamos fazer a impressão da forma de pagamento usando somente a descrição “Cartao”, então o primeiro trecho da nossa rotina vai efetuar o pagamento usando qualquer forma de pagamento que não seja vinculada ao TEF. No segundo trecho da rotina, vamos executar uma solicitação de chamada ao módulo da bandeira, através do objeto “minhasolicitacaocartao”, e também o envio da solicitação usando o objeto “minhatransacao”. As imagens abaixo mostram a execução da forma de pagamento e também a tela do GP ativo.

Vale lembrar que toda a estrutura de execução das formas de pagamento e transações com o GP, estão dentro de um tratamento “Try/Catch”, onde qualquer erro será tratado pelas exceptions: FiscalException e GerenciadorInativoException.

Depois de concluirmos nossa transação TEF, o Flash Builder irá tratar o retorno da bandeira (arquivo INTPOS.001). Note em nosso código que no momento do envio da transação analisamos seu status, e caso ocorra algum problema, exibimos para o operador a mensagem relacionada ao campo 30 do INTPOS.001, tudo isso automaticamente pelo Flash Builder.

Ainda dentro da rotina de execução das formas de pagamento, estamos confirmando as transações TEF efetuadas. Para isso, dentro de um laço de repetição (While (true)) criamos um objeto do tipo minhasolicitacaoconfirmacao, que tem a função de verificar e confirmar todas as transações TEF executadas.

Vamos finalizar o cupom fiscal através do botão “btnfecharcupom”, antes da impressão do TEF.

- em C#

- em VB.NET

Definimos no método “TerminarFechamento” a impressão de uma mensagem promocional como parâmetro único. Esta mensagem pode conter até 08 linhas de 40 colunas.

Com o nosso cupom fiscal já finalizado e nossas transações efetuadas e confirmadas, chegou a hora de imprimir os comprovantes vinculados do TEF.

Vale salientar que aqui estamos populando uma variável chamada “minhacolecao” do tipo “Transacoes” com as transações efetuadas anteriormente, pois iremos usar essa variável mais adiante no processo de cancelamento do TEF para o próximo Flash Tip, explicando melhor a necessidade de armazenar nossa coleção de transações em uma variável pública, lembrando que essa variável é declarada na sessão “Public Class” do projeto, na mesma área onde criamos o objeto “BematechFiscal”.

Chegou a hora de imprimir o comprovante vinculado (Comprovante de Crédito e Débito), dentro do botão “btnimprimetef”.

- em C#

- em VB.NET

Nesta rotina, implementamos inicialmente uma exigência das homologadoras que é o travamento do teclado e do mouse durante a impressão do comprovante TEF.

Criamos um contador (conta) que incrementa todas as transações TEF pendentes de impressão (comprovantes vinculados ou gerenciais no caso de reimpressão). Após o término da impressão dos comprovantes vinculados, podemos ver que o teclado e o mouse são destravados (BematechFiscal.Tef.TravarTeclado(false)), se a impressão ocorrer com sucesso a rotina é finalizada, porém se houve algum problema de queda de energia, ou qualquer outro que trave a impressão dos comprovantes vinculados, é possível reimprimi-los mudamos o valor de um parâmetro do método Imprimir, conforme detalhado abaixo:

(…)
BematechFiscal.TEF.Imprimir(impfiscal.TEF.Transacoes[conta], false);
(…)

Onde “false” indica que a impressão do TEF será em um comprovante não fiscal vinculado (Comprovante de Crédito e Débito) e “true” será em um relatório gerencial.

Nos nossos exemplos, criamos uma condição para esta situação onde qualquer erro de impressão que ocorrer no comprovante não fiscal vinculado, irá emitir uma mensagem na tela do usuário solicitando a reimpressão dos comprovantes que será executada dentro dos relatórios gerenciais.

Como a confirmação das transações já foi efetuada no botão “btnefetuapagamento” nenhum comprovante TEF fica pendente de impressão. Então, podemos executar o método “ClearTransacoes” para limpar todas as transações e evitar que ocorram falhas de impressão, finalizando a operação do TEF.

Importante: Lembre que em nosso exemplo, estamos apenas conhecendo a classe TEF e seus métodos separadamente, portanto não estamos aplicando a regra do roteiro de implementação do TEF fornecido pelas empresas homologadoras.

Próxima edição:

Agora que temos uma rotina completa de emissão de cupom fiscal com transação TEF, no próximo “Flash-Tip Classe TEF”, vamos abordar o cancelamento de uma transação TEF via módulo ADM.

Não perca!

Até lá e boas implementações!

Caro Parceiro,

Agora, vamos conhecer a interface que iremos utilizar na comunicação do microterminal FIT Básico Bematech em nosso aplicativo. Ao longo desta edição de nosso Flash-Tip, iremos entender a dll BemaSB32, sua configuração e suas principais funções.

Antes de qualquer implementação, é importante sabermos o que é a BemaSB32.dll, principalmente para quem ainda esta iniciando no desenvolvimento de microterminais para Automação Comercial.

A BemaSB32 é uma dll de alto-nível que foi desenvolvida para facilitar e dar rapidez na implementação e na comunicação com o microterminal FIT Básico Bematech.

As funções que estão na dll são para o controle do microterminal, permitindo trabalhar com mensagens em seu display, receber informações do teclado e periféricos que estejam conectados nas portas seriais dele.

Configurando a BemaSB32.dll

A BemaSB32.dll possui um arquivo de configuração chamado BemaSB32.ini, onde nos dá algumas opções de configuração:

Importante: A BemaSB32.dll somente está disponível para o microterminal FIT Basico em modo “Client”, conforme as configurações apresentadas no Flash-tip anterior. Ela deverá ficar na pasta do aplicativo, juntamente com seu arquivo de configuração BemaSB32.ini.

Exemplo de conteúdo do arquivo BemaSB32.ini:

[FIT]
Protocolo=0

[Terminais]
Porta=9100
0=10.10.101.116
1=10.10.101.120
2=10.10.101.121

Funções da BemaSB32.dll

A dll possui funções para o controle do microterminal FIT Básico. Estas funções nos dá a possibilidade de controlar todo o hardware, como enviar mensagens ao display, alem das informações capturas do teclado e dos equipamentos conectados em suas portas seriais.

Vamos conhecê-las:

Próxima edição:

Vamos iniciar o desenvolvimento com a BemaSB32.dll. Veremos como é feita a declaração das funções, a configuração e instalação da dll, além de começarmos a utilizar as funções iniciais de comunicação com o FIT Básico Bematech.

Não perca!

Até lá e boas implementações!

Caro parceiro,

Na edição de número 29 de nosso Flash-Tip - FIT Integra, pudemos conhecer os recursos de hardware do microterminal, bem como as interfaces de comunicação, quantidade de teclas, característica do visor, capacidade de memória não volátil e possibilidade de expansão, design e demais recursos.

Nesta edição, iremos aprender como configurar o microterminal FIT Integra para receber o aplicativo.

Entrando na Tela de Configuração (SETUP)

Antes de iniciarmos o processo de configuração do microterminal, é necessário termos os seguintes recursos:

• Um cabo de rede par transado RJ 45 (não há necessidade que a configuração seja Cross-Over) e;
• A configuração corrente da sua rede (basicamente devemos obter um IP disponível na rede, a máscara e o gateway).

Com estas informações em mãos, poderemos partir para a configuração de rede do FIT Integra.

O primeiro passo é ligarmos o microterminal com a tecla <DEL> pressionada, segurando-a por alguns segundos:

Automaticamente, o microterminal irá solicitar uma senha de acesso (password). Basta entrar com a senha padrão 123456 e pressionar <ENTER>.

Configurando a Rede

Após autenticação no microterminal, podemos começar o processo de configuração da rede, neste caso devemos acessar a opção “1-NETWORK”.

Nesta opção, encontraremos as seguintes configurações:

Veja no exemplo abaixo, como ficaria a inserção do IP 192.168.1.10 na opção “2-Local Ip”.

Importante: Não é permitido deixar espaços em brancos entre os números. Repare que na terceira casa de inserção temos “001″ e na quarta casa temos “010″. É obrigatório digitar 001, para que o valor seja inserido corretamente.

Para inserir o Server Ip, basta seguirmos a mesma regra. Não podemos esquecer de configurar também a máscara de rede (opção “4-NET MASK”) conforme regras de nomenclatura de IP.

Próxima edição:

Aprendemos nesta edição de nosso Flash-Tip, como configurar o microterminal FIT Integra, sendo que com esta configuração já é possível comunicarmos com ele via rede, e também enviar programas compilados ou outras informações.

Na próxima edição, iremos:

• Conhecer o FIT DEVELOPER KIT - o SDK de desenvolvimento do FIT Integra.

Não perca!

Até lá e boas implementações!