Sua aplicação está preparada para executar o comando para desprogramar o horário de verão nas ECFs Bematech?

Neste ano, segundo o Decreto nº 6.558 de 8 de setembro de 2008 publicado no Diário Oficial da União, a partir das 0:00h do dia 18 de outubro (domingo), entrou em vigor o horário de verão no país com duração até as 0:00h do dia 21 de fevereiro de 2010 (válido para as regiões Sul, Sudeste e Centro-Oeste).

Neste dia 21, os relógios deverão retroceder 1 hora, bem como os sistemas/softwares e as ECFs.

Então, preparamos esta edição do Flash Tip com dicas de programação para ajudá-lo a ajustar o horário de verão nas impressoras fiscais Bematech.

Como devemos retroceder o horário em 1 hora, não podemos realizar esta operação logo após a impressão da redução Z, pois as ECFs não executariam tal comando. Por que isso ocorre? O documento da redução Z armazenado na memória fiscal da impressora estará com uma hora a mais, em relação ao retrocesso. Então, devemos executar o comando de ajuste do horário de versão com no mínimo 1 hora e 1 segundo, após a última redução Z impressa.

BemaFI32.dll

Para quem usa a BemaFI32.dll, a função que deve ser executada para desprogramar na impressora o horário de verão é, simplesmente, Bematech_FI_ProgramaHorarioVerao().

• em VB 6

iRetorno = Bematech_FI_ProgramaHorarioVerao()

• em Delphi

iRetorno := Bematech_FI_ProgramaHorarioVerao();

Bematech Flash Builder

Inclua a classe Bematech.Fiscal.ECF.Inicializacao no projeto e execute o método AjustarHorarioVerao.

• em VB .NET

Imports Bematech.Fiscal.ECF.Inicializacao
.
.
.
<objeto>.BematechFiscal.Inicializacao.AjustarHorarioVerao()

• em C#

using Bematech.Fiscal.ECF.Inicializacao;
.
.
.
<objeto>.BematechFiscal.Inicializacao.AjustarHorarioVerao();

Bematech MONITOR (WTS ou Citrix)

Da mesma forma que na BemaFI32.dll, basta chamar a função Bematech_FI_ProgramaHorarioVerao().

Bematech MONITOR local (via arquivo)

Crie o arquivo BemaFI32.cmd com o comando “066|” e copie para o caminho onde o Bematech MONITOR está monitorando.

Componente WEB BemaFisc

Basta chamar o método ProgramaHoraVerao do objeto WEB criado.

Bemafi.exe (ambiente DOS)

Crie o arquivo Bemafi.cmd com o comando abaixo e execute o Bemafi.exe.

chr( 27 ) + chr( 251 ) + “18|” + chr( 27 )

Protocolo de Comunicação Direto

Envie o comando ESC 18d (27d + 18d) ou ESC 12h (1Bh + 12h).

LibBemaFiscal.so (Linux)

Execute a função Bematech_FI_ProgramaHorarioVerao, da mesma forma que na BemaFI32.dll.

iRetorno = Bematech_FI_ProgramaHorarioVerao()

BemaFILX.out (executável Linux)

Crie o arquivo BemaFILX.cmd com o comando abaixo e execute o BemaFILX.out.

chr( 27 ) + “|18|” + chr( 27 )

Qualquer dúvida que surgir, nossa equipe de suporte técnico está a disposição para esclarece-la. Você pode nos contatar pelo:

suporte@bematech.com.br

suporte.andre@bematech.com.br (MSN e Email)

suporte.iohannes@bematech.com.br (MSN e Email)

suporte.sidnei@bematech.com.br (MSN e Email)

suporte.andre.luiz (SKYPE)

suporte.iohannes (SKYPE)

suporte.sidnei (SKYPE)

Ou ligue-nos no 0800 644 7277.

Dando continuidade à série de Flashtips sobre o tema “Explorando a MFD nas impressoras fiscais Bematech“, nesta edição iremos abordar dois assuntos muito importantes para quem está preparando a aplicação para as homologações do PAF-ECF - a geração do Arquivo MFD e do Espelho MFD.

Para recordarmos, o Arquivo e o Espelho MFD fazem parte do “Requisito VII” do Roteiro de Análise Funcional, mais especificamente os itens 5 e 6, e estão presentes no Menu Fiscal do PAF:

ITEM 5: “Espelho MFD”, para gerar arquivo eletrônico da Memória de Fita Detalhe, no formato de “espelho” dos documentos nela contidos, com possibilidade de seleção por período de data e por intervalo de COO, devendo assiná-lo digitalmente inserindo ao final do arquivo uma linha com o registro tipo EAD…

ITEM 6: “Arq. MFD” para gerar arquivo eletrônico da Memória de Fita Detalhe conforme leiaute estabelecido no Ato COTEPE/ICMS 17/04 com possibilidade de seleção por período de data e por intervalo de COO, devendo assiná-lo digitalmente inserindo ao final do arquivo uma linha com o registro tipo EAD…

Então, iremos conhecer como implementar estas duas funcionalidades, através das novas funções da BemaFI32.dll, completas e incluindo a assinatura EAD.

Vamos lá!

Espelho MFD

O arquivo no formato de espelho da MFD, ou seja, a reprodução na íntegra dos documentos emitidos pelo ECF, é um dos itens exigidos no PAF. Este arquivo é gerado a partir de uma única função “Bematech_FI_EspelhoMFD“.

• Declaração em VB

Public Declare Function Bematech_FI_EspelhoMFD Lib “BEMAFI32.DLL” ( ByVal cNomeArquivoDestino As String, ByVal cDadoInicial As String, ByVal cDadoFinal As String, ByVal cTipoDownload As String, ByVal cUsuario As String, ByVal cChavePublica As String, ByVal cChavePrivada As String ) As Integer

• Declaração em Delphi

function Bematech_FI_EspelhoMFD( cNomeArquivoDestino: String; cDadoInicial: String; cDadoFinal: String; cTipoDownload: String; cUsuario: String; cChavePublica: String; cChavePrivada: String ): Integer; StdCall; External ‘BEMAFI32.DLL’;

• Exemplo em VB

iRetorno = Bematech_FI_EspelhoMFD(”C:\TESTE.TXT”, _
“000100″, _
“000200″, _
“C”, _
“1″, _
“A499F300F731F6892F44B83A5DD9D97CFFFD0ABE96E29B4B4B4E
B2F9E5BCFFCF0A52EAFDF05779F90B3A199BE5776B13373CB2E7
1D8AB67F4080CE27B226FFF032B6A7182C90C935EF2F4D343A74
3B60307EE4961F0C5EB02B1CEEF48D647C02E9BE164DC404B833
F80C5B4268C04039547E7D5E242537B02360674B569208BD”, _
“D19598300478932ACFFE16CB6903552F15FDBD2D3B9659FAD79C
3603C07B875919E9D8B28919B8F4C20C6AE23268A636D1206F5E
6BC79D89B6152804B15A9781C90E0A2D5064FB5B7CC01048AD8C
66768F76D71647E7D39F8EDD714044CEA68F2A40106849132B01
D14DDEB3FBA6FC1A9FBE9EA71BAB9293707A4EAD29CB6F3D”)

• Exemplo em Delphi

cArquivo := ‘C:\TESTE.TXT’;
cDataInicial := ‘000100′;
cDataFinal := ‘000200′;
cTipo := ‘C’;
cUsuario := ‘1′;
cChavePublica := ‘A499F300F731F6892F44B83A5DD9D97CFFFD0ABE96E29B4B4B4E
B2F9E5BCFFCF0A52EAFDF05779F90B3A199BE5776B13373CB2E7
1D8AB67F4080CE27B226FFF032B6A7182C90C935EF2F4D343A74
3B60307EE4961F0C5EB02B1CEEF48D647C02E9BE164DC404B833
F80C5B4268C04039547E7D5E242537B02360674B569208BD’;
cChavePrivada := ‘D19598300478932ACFFE16CB6903552F15FDBD2D3B9659FAD79C
3603C07B875919E9D8B28919B8F4C20C6AE23268A636D1206F5E
6BC79D89B6152804B15A9781C90E0A2D5064FB5B7CC01048AD8C
66768F76D71647E7D39F8EDD714044CEA68F2A40106849132B01
D14DDEB3FBA6FC1A9FBE9EA71BAB9293707A4EAD29CB6F3D’;

iRetorno := Bematech_FI_EspelhoMFD( pchar( cArquivo ), pchar( cDataInicial ), pchar( cDataFinal ), pchar( cTipo ), pchar( cUsuario ), pchar( cChavePublica ), pchar( cChavePrivada ) );

No exemplo acima, estamos gerando o espelho MFD dos cupons (COOs) “100″ ao “200″. A função irá realizar um download da MFD compreendido entre estes cupons e gerar o “TESTE.TXT” em “C:\”, conforme informado, trazendo o espelho automaticamente.

Vamos detalhar os parâmetros desta função:

Repare também que informamos as chaves pública e privada para que a função já assine o arquivo texto gerado (registro EAD). Estas chaves podem ser criadas pela função genkkey da sign_bema.dll, conforme já apresentado na edição 43 de nosso Flashtip.

Vale a dica: As chaves pública e privada são geradas apenas uma única vez e é exclusiva de software-house para software-house, independente de cliente, modelo e marca de ECF. Então, gere uma única vez estas chaves e use-as para assinar todos os arquivos necessários para o PAF-ECF. A sign_bema.dll pode ser utilizada para qualquer marca de ECF, pois a geração das chaves e a assinatura do arquivo são diretas através de funções, ou seja, não é necessário estar conectado ao ECF para assinar o arquivo.

Arquivo MFD

Sendo um dos itens presentes no Menu Fiscal, o Arquivo MFD possui como layout o “Ato Cotepe 17/04″, que é gerado também através de uma única função - a “Bematech_FI_ArquivoMFD“.

A função realiza o download da MFD do período informado e gera o arquivo no layout, assinando-o automaticamente.

• Declaração em VB

Public Declare Function Bematech_FI_ArquivoMFD Lib “BEMAFI32.DLL” ( ByVal cNomeArquivoOrigem As String, ByVal cDadoInicial As String, ByVal cDadoFinal As String, ByVal cTipoDownload As String, ByVal cUsuario As String, ByVal iTipoGeracao As Integer, ByVal cChavePublica As String, ByVal cChavePrivada As String, ByVal iUnicoArquivo As Integer ) As Integer

• Declaração em Delphi

function Bematech_FI_ArquivoMFD( cNomeArquivoOrigem: String; cDadoInicial: String; cDadoFinal: String; cTipoDownload: String; cUsuario: String; iTipoGeracao: integer; cChavePublica: String; cChavePrivada: String; iUnicoArquivo: integer ): Integer; StdCall; External’BEMAFI32.DLL’;

• Exemplo em VB

iRetorno = Bematech_FI_ArquivoMFD(”", _
“01/08/2009″, _
“31/08/2009″, _
“D”, _
“01″, _
2, _
“A499F300F731F6892F44B83A5DD9D97CFFFD0ABE96E29B4B4B4E
B2F9E5BCFFCF0A52EAFDF05779F90B3A199BE5776B13373CB2E7
1D8AB67F4080CE27B226FFF032B6A7182C90C935EF2F4D343A74
3B60307EE4961F0C5EB02B1CEEF48D647C02E9BE164DC404B833
F80C5B4268C04039547E7D5E242537B02360674B569208BD”, _
“D19598300478932ACFFE16CB6903552F15FDBD2D3B9659FAD79C
3603C07B875919E9D8B28919B8F4C20C6AE23268A636D1206F5E
6BC79D89B6152804B15A9781C90E0A2D5064FB5B7CC01048AD8C
66768F76D71647E7D39F8EDD714044CEA68F2A40106849132B01
D14DDEB3FBA6FC1A9FBE9EA71BAB9293707A4EAD29CB6F3D”, _
1)

• Exemplo em Delphi

cTipoDownload := ‘D’;
cUsuario := ‘01′;
iTipoGeracao := 2;
cDadoInicial := ‘01/08/2009′;
cDadoFinal := ‘31/08/2009′;
cChavePublica := ‘A499F300F731F6892F44B83A5DD9D97CFFFD0ABE96E29B4B4B4E
B2F9E5BCFFCF0A52EAFDF05779F90B3A199BE5776B13373CB2E7
1D8AB67F4080CE27B226FFF032B6A7182C90C935EF2F4D343A74
3B60307EE4961F0C5EB02B1CEEF48D647C02E9BE164DC404B833
F80C5B4268C04039547E7D5E242537B02360674B569208BD’;
cChavePrivada := ‘D19598300478932ACFFE16CB6903552F15FDBD2D3B9659FAD79C
3603C07B875919E9D8B28919B8F4C20C6AE23268A636D1206F5E
6BC79D89B6152804B15A9781C90E0A2D5064FB5B7CC01048AD8C
66768F76D71647E7D39F8EDD714044CEA68F2A40106849132B01
D14DDEB3FBA6FC1A9FBE9EA71BAB9293707A4EAD29CB6F3D’;
iUnicoArquivo := 1;

iRetorno := Bematech_FI_ArquivoMFD( pchar( ” ), pchar( cDadoInicial ), pchar( cDadoFinal ), pchar( cTipoDownload ), pchar( cUsuario ), iTipoGeracao, pchar( cChavePublica ), pchar( cChavePrivada ), iUnicoArquivo );

Neste exemplo, pedimos para a função gerar o arquivo a partir da memória da impressora e por intervalo de datas, entre 01/08/2009 a 31/08/2009.

Vamos detalhar os parâmetros desta função:

Repare no exemplo que o formato do arquivo será TDM que corresponde aos dados da MF (Memória Fiscal) e também da MFD (Memória de Fita-detalhe) da impressora. Além disso, temos as chaves pública e privada previamente criadas.

Vimos como é simples implementar estas duas funcionalidades para o PAF-ECF.

Esperamos que este Flashtip tenha sido útil para o seu entendimento e para a integração destas funções em seu aplicativo PAF, e qualquer dúvida que surgir, estamos a disposição para esclarecê-la. Contate-nos pelo:

• suporte@bematech.com.br
• 0800 644 7277

Sua aplicação já está preparada para executar o comando de horário de verão nas ECFs Bematech?

Neste ano, segundo o Decreto nº 6.558 de 8 de setembro de 2008 publicado no Diário Oficial da União, a partir das 0:00h do dia 18 de outubro (próximo domingo), entrará em vigor o horário de verão no país com duração até 21 de fevereiro de 2010 (válido para as regiões Sul, Sudeste e Centro-Oeste). Nesse período, não somente nossos relógios devem ser ajustados, como também os sistemas/softwares e as ECFs.

Então, preparamos nesta edição do Flash Tip, dicas de programação para ajudá-lo a ajustar o horário de verão nas impressoras fiscais Bematech.

O ajuste do horário de verão nas ECFs Bematech deve ser realizado após a impressão da redução Z, ou seja, não pode haver qualquer movimento na impressora para que o comando seja executado com sucesso. A impressora irá imprimir uma mensagem informando que entrou no horário de verão.

BemaFI32.dll

Para quem usa a BemaFI32.dll, a função que deve ser executada para programar na impressora o horário de verão é, simplesmente, Bematech_FI_ProgramaHorarioVerao().

• em VB 6

iRetorno = Bematech_FI_ProgramaHorarioVerao()

• em Delphi

iRetorno := Bematech_FI_ProgramaHorarioVerao();

Bematech Flash Builder

Inclua a classe Bematech.Fiscal.ECF.Inicializacao no projeto e execute o método AjustarHorarioVerao.

• em VB .NET

Imports Bematech.Fiscal.ECF.Inicializacao
.
.
.
<objeto>.BematechFiscal.Inicializacao.AjustarHorarioVerao()

• em C#

using Bematech.Fiscal.ECF.Inicializacao;
.
.
.
<objeto>.BematechFiscal.Inicializacao.AjustarHorarioVerao();

Bematech MONITOR (WTS ou Citrix)

Da mesma forma que na BemaFI32.dll, basta chamar a função Bematech_FI_ProgramaHorarioVerao().

Bematech MONITOR local (via arquivo)

Crie o arquivo BemaFI32.cmd com o comando “066|” e copie para o caminho onde o Bematech MONITOR está monitorando.

Componente WEB BemaFisc

Basta chamar o método ProgramaHoraVerao do objeto WEB criado.

Bemafi.exe (ambiente DOS)

Crie o arquivo Bemafi.cmd com o comando abaixo e execute o Bemafi.exe.

chr( 27 ) + chr( 251 ) + “18|” + chr( 27 )

Protocolo de Comunicação Direto

Envie o comando ESC 18d (27d + 18d) ou ESC 12h (1Bh + 12h).

LibBemaFiscal.so (Linux)

Execute a função Bematech_FI_ProgramaHorarioVerao, da mesma forma que na BemaFI32.dll.

iRetorno = Bematech_FI_ProgramaHorarioVerao()

BemaFILX.out (executável Linux)

Crie o arquivo BemaFILX.cmd com o comando abaixo e execute o BemaFILX.out.

chr( 27 ) + “|18|” + chr( 27 )

Qualquer dúvida que surgir, nossa equipe de suporte técnico está a disposição para esclarece-la. Você pode nos contatar pelo:

• suporte@bematech.com.br
• suporte.andre@bematech.com.br (MSN e Email)
• suporte.iohannes@bematech.com.br (MSN e Email)
• suporte.sidnei@bematech.com.br (MSN e Email)
• suporte.andre.luiz (SKYPE)
• suporte.iohannes (SKYPE)
• suporte.sidnei (SKYPE)

Ou ligue-nos no 0800 644 7277.

Muitos nos questionam sobre a usabilidade das impressoras fiscais com tecnologia MFD, de como capturar um determinado cupom emitido há dias na impressora, sendo que neste modelo de impressora não há segunda via impressa, ou em atender as legislações vigentes de software aproveitando os recursos da impressora e etc.

Então, estamos preparando uma série de Flash Tips, aonde iremos conhecer as principais vantagens e recursos de se utilizar uma impressora fiscal com tecnologia MFD da Bematech, e de como tudo isso pode nos ajudar em nosso dia a dia no desenvolvimento.

Vamos lá!

Recuperando cupons

Todos nós sabemos que as impressoras com MFD (Memória de Fita-Detalhe) não possuem segunda via, referente aos cupons, impressa (aquela cópia da primeira via que ficava rebobinada nas impressoras fiscais matriciais, lembra?). Com isso se tornou difícil conferir ou confrontar os cupons emitidos no dia com as informações armazenadas em banco, certo? Por exemplo, na RZ impressa no final do dia aparece um valor de cancelamento que não está no banco de dados, então você desenrolava a segunda via rebobinada e examinava cada cupom impresso para saber se ocorreu um erro no sistema ou se o “bendito” cancelamento foi realizado fora do sistema (não era mais ou menos isso que você fazia?). Isso sim, era um procedimento chato e demorado de fazer.

Com a tecnologia MFD você consegue capturar facilmente um determinado cupom, o movimento do dia inteiro, do mês inteiro ou até mesmo todo o movimento contido na impressora desde quando ela foi colocada em produção.

Nas impressoras fiscais térmicas MFD Bematech todo este processo é muito simples, fácil e rápido, através da BemaFI32.dll Windows, utilitários em Linux ou via protocolo direto.

Vamos conhecer cada ferramenta e como utilizá-las na aplicação.

BemaFI32.dll

Através da dll de altonível BemaFI32.dll precisamos de apenas duas funções: a Bematech_FI_DownloadMFD para realizar o download da MFD e a Bematech_FI_FormatoDadosMFD para transformar o download em texto.

Veja como usá-las:

• em VB 6

(…)
iRetorno = Bematech_FI_DownloadMFD(”C:\DOWNLOAD.MFD”, “2″, “000010″, “000100″, “1″)
(…)

• em Delphi

(…)
cArquivo      := ‘C:\DOWNLOAD.MFD’;
cTipoDownload := ‘2′;
cCOOInicial   := ‘000010′;
cCOOFinal     := ‘000100′;
cUsuario      := ‘1′;

iRetorno := Bematech_FI_DownloadMFD( pchar( cArquivo ), pchar( cTipoDownload ), pchar( cCOOInicial ), pchar( cCOOFinal ), pchar( cUsuario ) );
(…)

Nestes exemplos, usamos como parâmetros: um nome de arquivo MFD, o tipo de download por COO, o COO inicial, o COO final e o número do usuário da impressora. Estamos fazendo um download do intervalo de cupons compreendido entre o cupom 10 e o cupom 100. Se precisássemos de apenas um cupom, bastaria informar o número dele no COO inicial e final.

Depois do download da MFD realizado, podemos facilmente convertê-lo para o formato texto e visualizar os documentos emitidos naquele intervalo, através da função Bematech_FI_FormatoDadosMFD, veja:

• em VB 6

(…)
iRetorno = Bematech_FI_FormatoDadosMFD(”C:\DOWNLOAD.MFD”, “C:\IMAGEM.TXT”, “0″, “2″, “000010″, “000100″, “1″)
(…)

• em Delphi

(…)
cArquivoOrigem  := ‘C:\DOWNLOAD.MFD’;
cArquivoDestino := ‘C:\IMAGEM.TXT’;
cTipoFormato    := ‘0′;
cTipoDownload   := ‘2′;
cCOOInicial     := ‘000010′;
cCOOFinal       := ‘000100′;
cUsuario        := ‘1′;

iRetorno := Bematech_FI_FormatoDadosMFD( pchar( cArquivoOrigem ), pchar( cArquivoDestino ), pchar( cTipoFormato ), pchar( cTipoDownload ), pchar( cCOOInicial ), pchar( cCOOFinal ), pchar( cUsuario ) );
(…)

Repare que os parâmetros são basicamente os mesmos usados na função de download da MFD, apenas com o acréscimo dos parâmetros “cArquivoDestino” e “cTipoFormato” que correspondem ao caminho+nome do arquivo de saída e o formato para texto, respectivamente.

Este procedimento de conversão é necessário, devido ao fato da MFD da impressora estar compactada e criptografada, assim assegurando os dados contidos nela.

O fantástico de tudo isso, é que esta pequena rotina pode ser aplicada à geração do arquivo “Espelho MFD”, atendendo a um dos requisitos do PAF-ECF!

LinuxMFD e BemaMFD / BemaMFD2

Em ambiente Linux, temos dois aplicativos que nos auxiliam no processo de download e conversão para texto da MFD da impressora.

Utilizando o LinuxMFD, fazemos o download da MFD da impressora, assim:

./linuxmfd /dev/ttyS0 download.mfd 2 000010 000100 1

E, após ter capturada a MFD, podemos convertê-la para texto, assim:

./bemamfd2 imagem.txt download.mfd 2 000010 000100 1

No aplicativo LinuxMFD, temos os seguintes parâmetros:

a) Porta serial onde a impressora esta conectada. Ex: /dev/ttyS0
b) Arquivo a ser gerado. Ex: download.mfd
c) Tipo de download:
    0 - download MFD total
    1 - download MFD por data
    2 - download MFD por COO
    3 - download MF
d) Parametro Inicial: Data inicial (DDMMAA) ou COO inicial (com ate 6 digitos).
e) Parametro Final : Data final (DDMMAA) ou COO final (com ate 6 digitos).
f) Número de ordem do proprietário do ECF com ate 3 digitos. (obrigatório se o tipo de download for por
COO).

No aplicativo BemaMFD2, temos estes parâmetros:

a) Nome do arquivo texto de saída.
b) Nome do arquivo contendo o download da MFD da impressora.
c) Tipo de processamento a ser feito:
    0 - Total
    1 - Por Datas
    2 - Por COO
    3 - AC17/04 - MF Total
    4 - AC17/04 - MF Por Datas
    5 - AC17/04 - MF Por COO
    6 - AC17/04 - MFD Total
    7 - AC17/04 - MFD Por Datas
    8 - AC17/04 - MFD Por COO
    9 - AC17/04 - TDM Total
    10 - AC17/04 - TDM Por Datas
    11 - AC17/04 - TDM Por COO
d) Data (DDMMAA) ou COO inicial (máximo 6 dígitos).
e) Data (DDMMAA) ou COO final (máximo 6 dígitos)
f) Número de ordem do proprietário do ECF com ate 3 dígitos. (obrigatório se o tipo de download for por
COO).

Repare que podemos gerar também o “Arquivo MFD” no formato do Ato Cotepe 17/04 (MF, MFD ou TDM), conforme exigido no PAF-ECF.

Protocolo Direto

A impressora fiscal térmica MFD Bematech possui também um comando para a geração do espelho MFD direto da impressora. Neste caso, não necessitamos realizar a captura da MFD para posteriormente efetuar a conversão para texto, o próprio comando já processa estas duas tarefas. Vamos ver como fica:

O comando é 1Bh + 3Eh + 45h ou chr(27) + chr(62) + chr(69) para o formato decimal e seus parâmetros são:

Par1 no tamanho de 1 byte: “D”para intervalo de data ou qualquer outro caracter para intervalo de COO;

Se o Par1 for “D”:

Par2 no tamanho de 2 bytes com o dia inicial;
Par3 no tamanho de 2 bytes com o mês inicial;
Par4 no tamanho de 2 bytes com o ano inicial;
Par5 no tamanho de 2 bytes com o dia final;
Par6 no tamanho de 2 bytes com o mês final e;
Par7 no tamanho de 2 bytes com o ano final.

Se o Par1 for diferente de “D”:

Par2 no tamanho de 6 bytes com o COO inicial;
Par3 no tamanho de 6 bytes com o COO final e;
Par4 no tamanho de 3 bytes com o número do usuário.

O retorno do espelho da MFD virá assim:

3 ou 5 bytes com o status da impressora (ACK, ST1, ST2 e ST3 (dois bytes)), seguidos da imagem dos documentos no formato ASCII e terminando com ETX (03h). Neste caso, a dica é ficar em um loop até que receba o byte ETX que corresponde ao final da transmissão, tendo assim todos os documentos emitidos no intervalo solicitado.

Sintegra a partir da MFD

Outro recurso interessante, é a geração dos registros do Sintegra diretamente da MFD da impressora. Através de uma única função da BemaFI32.dll, é possível gerar os registros do Sintegra pertinentes ao ECF, como os registros 60M (Mestre), 60A (Analítico), 60D (Diário), 60I (Item), 60R (Resumo Mensal) e 75, além dos registros 10, 11 e 90. Basicamente, o Sintegra completo!

Vejamos a simplicidade que é:

• em VB 6

(…)
iRetorno = Bematech_FI_RelatorioSintegraMFD(63, “SINTEGRA.TXT”, “10″, “2009″, “Empresa S/A”, “Rua Sem Nome”, “123″, “Complemento”, “Bairro”, “Cidade”, “12345678″, “99 9999-9999″, “11 1111-1111″, “Fulano de Tal” )
(…)

• em Delphi

(…)
cArquivo     := ‘SINTEGRA.TXT’;
cMes         := ‘10′;
cAno         := ‘2009′;
cRazaoSocial := ‘Empresa S/A’;
cEndereco    := ‘Rua Sem Nome’;
cNumero      := ‘123′;
cComplemento := ‘Complemento’;
cBairro      := ‘Bairro’;
cCidade      := ‘Cidade’;
cCEP         := ‘12345678′;
cTelefone    := ‘99 9999-9999′;
cFax         := ‘11 1111-1111′;
cContato     := ‘Fulano de Tal’;

iRetorno := Bematech_FI_RelatorioSintegraMFD( 63, pchar( cArquivo ), pchar( cMes ), pchar( cAno ), pchar( cRazaoSocial ), pchar( cEndereco ), pchar( cNumero ), pchar( cComplemento ), pchar( cBairro ), pchar( cCidade ), pchar( cCEP ), pchar( cTelefone ), pchar( cFax ), pchar( cContato ) );
(…)

E, os parâmetros que temos, são:

Par1 no tamanho de 1 byte com a somatória dos registros que se deseja gerar, onde: 
    1: gera o relatório tipo 60M (Mestre);
    2: gera o relatório tipo 60A (Analítico);
    4: gera o relatório tipo 60D (Diário);
    8: gera o relatório tipo 60I (Item);
    16: gera o relatório tipo 60R (Resumo Mensal) e;
    32: gera o relatório tipo 75.

Exemplo: Se desejarmos gerar somente os registros tipo 60M, 60A e 75, o Par1 deve possuir o valor 35.

Par2 com o caminho+nome do arquivo de destino no formato TXT. Exemplo: “C:\SINTEGRA.TXT”;
Par3 no tamanho de 2 bytes com o mês, no formato “MM”;
Par4 no tamanho de 4 bytes com o ano, no formato “AAAA”;
Par5 no tamanho de 35 bytes com a razão social do cliente;
Par6 no tamanho de 34 bytes com o endereço do cliente;
Par7 no tamanho de 5 bytes com o número do endereço do cliente;
Par8 no tamanho de 22 bytes com o complemento;
Par9 no tamanho de 15 bytes com o bairro;
Par10 no tamanho de 30 bytes com a cidade;
Par11 no tamanho de 8 bytes com o CEP;
Par12 no tamanho de 12 bytes com o telefone;
Par13 no tamanho de 10 bytes com o número do FAX e;
Par14 no tamanho de 18 bytes com o nome de contato do cliente.

Abaixo temos a imagem de um arquivo do Sintegra gerado pela função Bematech_FI_RelatorioSintegraMFD:

Próxima edição:

Esperamos que este primeiro Flash Tip da série “Explorando a MFD nas impressoras fiscais Bematech” tenha sido útil e esclarecedor. Caso você tenha alguma sugestão de tema, envie-nos pelo email partners@bematech.com.br.

Continuaremos explorando os recursos da MFD na próxima edição desta série.

Não perca!

Até lá e boas implementações!

Na edição anterior de nosso Flash Tip, vimos como realizar a comunicação do microterminal utilizando uma impressora não fiscal, na qual emitimos algumas linhas de texto através da porta serial COM1. Vimos também como enviar mensagens ao display do cliente (Customer Display), através da porta serial COM2, usando as bibliotecas <NFPrint.h> e <CDisplay.h>, respectivamente.

Nesta edição, faremos um pequeno complemento da edição anterior. O objetivo será mostrar a captura do código de barras através do leitor, utilizando a biblioteca <Barcode.h>.

Então, vamos lá!

Configurando o projeto

Antes de iniciarmos nosso exemplo, devemos inserir em nosso projeto a biblioteca que irá interpretar as funções do leitor de código de barras. Então, basta inserirmos no início do nosso código a biblioteca #include <Barcode.h>. Precisamos também entrar nas propriedades do projeto e inserimos o vinculo aos recursos da <Barcode.h> - BarcodeReader, conforme sequência ilustrada abaixo:

A janela abaixo, está dividida em três colunas, na primeira coluna selecionamos a opção: C/C++ Build, na coluna do meio clicamos duas vezes sobre a opção: libraries, em seguida clicamos na opção: Add da terceira coluna.

Em seguida será exibida uma nova janela para inserção da biblioteca BarcodeReader, simplesmente digitamos na lacuna (conforme ilustrado) e pressione OK nas janelas para confirmar a alteração.

Não podemos esquecer que, para este nosso exemplo, também precisamos inserir a biblioteca para Display do Usuário e a biblioteca Allegro, que irá habilitar os recursos do teclado. Para o uso destas bibliotecas, basta inserirmos no início do nosso código os respectivos includes: #include <UDisplay.h> e #include <allegro.h>. 

Após as configurações do projeto, basta copiarmos e colarmos o código abaixo, sendo que temos comentários dentro do código para um melhor entendimento.

#include <allegro.h>
#include <UDisplay.h>
#include <stdio.h>
#include <Barcode.h>

int main(void)
{

  /* instrução necessário para inicializar o a biblioteca allegro */
  if (allegro_init() != 0)
    return 1;

  /* Instala o teclado */
  install_keyboard();

  // Inicializar o display do usuario
  UserDisplayInit();

  // Limpa o display do usario 
  UserDisplayClearAll();

  if (keypressed())
    readkey(); // Flush

  // string usada para armazenar o código de barras, máximo 19 caracteres.
  char codeBuffer[20];

  // Atribui 0 para variável bclength 
  size_t bclength = 0;

  // Realiza a abertura da porta de comunicação.
  if (BarcodeConfig(”SERIAL1″) != BS_SUCCESS) 
    return EXIT_FAILURE;

  // inicializa funções do código de barras 
  BarcodeInit();

  // Resumes the Barcode Reader
  // NOTE: BarcodeInit() must be called before doing this
  BarcodeResume();

  while (1)
  {
    UserDisplayClearAll();

    UserDisplayPrint(1, 1, “Leia o produto:”);
    UserDisplayPrint(2, 1, “Cod:”);

    // Início do Do While, irá sempre monitor código oriundo da porta serial
    do
    {
      // Captura informação da serial - Código que será lido
      memset(codeBuffer,0,sizeof(codeBuffer));
      BarcodeGetCode(codeBuffer, 20,5, &bclength);

      // Irá entrar no if se o valor de codeBuffer for maior que 0 
      if (strlen(codeBuffer) > 0)
      { 
        // motra código na tela
        UserDisplayPrint(2, 6, codeBuffer);

        // inicializa bclength para que loop continue infinito
        bclength=strlen(codeBuffer);

        // Pausa na impressão 
        readkey();
        UserDisplayClearAll();
      }
    }
    while (bclength == 0);
  }
}

Após a compilação de nosso código, e o projeto devidamente alocado no microterminal, teremos o resultado como o exemplo abaixo:

Leia o produto:
Cod:

Na prática, ao passar o produto no leitor de código de barras, automaticamente será apresentado no visor do microterminal o código lido, exemplo:

Leia o produto:
Cod:7898907590112

E, ao pressionarmos <ENTER> no microterminal, teremos as informações do display remontadas aguardando nova leitura de produto, e assim, sucessivamente.

Com isso, finalizamos mais uma edição de nosso Flash Tip, com dicas que irão lhe auxiliar nas rotinas de leitura de código de barras no microterminal FIT Integra Bematech.

Próxima edição:

Na próxima edição, finalizamos nossa sequência de Flash Tips sobre o FIT Integra, acessando o microterminal remotamente.

Não perca!

Até lá e boas implementações!

Se você está preparando sua aplicação para homologar o PAF-ECF, já deve ter se deparado com o “Requisito VII” do Roteiro de Análise Funcional, mais especificamente os itens 5 e 6, onde tratam da geração do espelho MFD por intervalo de COO e data, e geração do Ato Cotepe 17/04 com base no arquivo MFD também por intervalo de COO e data, respectivamente.

Reprodução dos itens 5 e 6:

ITEM 5: “Espelho MFD”, para gerar arquivo eletrônico da Memória de Fita Detalhe, no formato de “espelho” dos documentos nela contidos, com possibilidade de seleção por período de data e por intervalo de COO, devendo assiná-lo digitalmente inserindo ao final do arquivo uma linha com o registro tipo EAD…

ITEM 6: “Arq. MFD” para gerar arquivo eletrônico da Memória de Fita Detalhe conforme leiaute estabelecido no Ato COTEPE/ICMS 17/04 com possibilidade de seleção por período de data e por intervalo de COO, devendo assiná-lo digitalmente inserindo ao final do arquivo uma linha com o registro tipo EAD…

Então, o objetivo deste Flash Tip é orientá-lo a como atender estes dois itens, com dicas de programação usando nossa dll de alto-nível BemaFI32.dll, e também as BemaMFD.dll e BemaMFD2.dll na geração do Ato Cotepe 17/04.

Vamos lá!

- ITEM 5:

O espelho MFD nada mais é do que a imagem, na íntegra, dos cupons emitidos no ECF. Para atender este item, devemos usar simplesmente duas funções encontrada na BemaFI32.dll:

1. Bematech_FI_DownloadMFD. Função que faz a captura da memória de fita-detalhe (MFD) da impressora e;
2. Bematech_FI_FormatoDadosMFD. Função que formata a MFD para arquivo texto.

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

Importante: Se o tipo do download for “Total”, não será necessário informar os parâmetros par3, par4 e par5. Neste caso, estes parâmetros são informados com string nula.

• Em VB, temos esta função implementada assim:

iRetorno = Bematech_FI_DownloadMFD(”C:\DOWNLOAD.MFD”, “2″, “000500″, “001000″, “1″)

• Em Delphi, temos esta função implementada assim:

cArquivo := ‘C:\DOWNLOAD.MFD’;
cTipoDownload := ‘2′;
cCOOInicial := ‘000500′;
cCOOFinal := ‘001000′;
cUsuario := ‘1′;

iRetorno := Bematech_FI_DownloadMFD( pchar( cArquivo ), pchar( cTipoDownload ), pchar( cCOOInicial ), pchar( cCOOFinal ), pchar( cUsuario ) );

Neste exemplo, estamos fazendo um download da MFD da impressora por intervalo de COO do “000500″ ao “001000″ e para o usuário “1″.

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

Importante: Se o tipo do download for “Total”, não será necessário informar os parâmetros par5, par6 e par7. Neste caso, estes parâmetros são informados com string nula.

• Em VB, temos esta função implementada assim:

iRetorno = Bematech_FI_FormatoDadosMFD(”C:\DOWNLOAD.MFD”, “C:\ESPELHO.TXT”, “0″, “2″, “000500″, “001000″, “1″)

• Em Delphi, temos esta função implementada assim:

cArquivoOrigem := ‘C:\DOWNLOAD.MFD’;
cArquivoDestino := ‘C:\ESPELHO.TXT’;
cTipoFormato := ‘0′;
cTipoDownload := ‘2′;
cCOOInicial := ‘000500′;
cCOOFinal := ‘001000′;
cUsuario := ‘1′;

iRetorno := Bematech_FI_FormatoDadosMFD( pchar( cArquivoOrigem ), pchar( cArquivoDestino ), pchar( cTipoFormato ), pchar( cTipoDownload ), pchar( cCOOInicial ), pchar( cCOOFinal ), pchar( cUsuario ) );

Neste exemplo, estamos gerando um espelho em texto da MFD da impressora por intervalo de COO do “000500″ ao “001000″ e para o usuário “1″.

Assim, atendemos o item 5 do requisito VII do PAF-ECF.

- ITEM 6:

Este item pede para gerar o arquivo de download da MFD no formato do Ato Cotepe 17/04, o mesmo exigido para a Nota Fiscal Paulista, porém assinado (registro EAD). Para isso, precisamos também de apenas duas funções:

1. Bematech_FI_DownloadMFD (função já vista anteriormente). Usaremos esta função para fazer a captura da MFD da impressora, pois iremos passar no primeiro parâmetro da função abaixo, o arquivo .mfd previamente gerado e;
2. BemaGeraRegistrosTipoE. Função encontrada na BemaMFD.dll e BemaMFD2.dll para geração dos registros tipo E pertencentes ao layout do Ato Cotepe 17/04.

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

• Em VB, temos esta função implementada assim:

cArqMFD = “C:\DOWNLOAD.MFD”
cArqTXT = “C:\COTEPE1704.TXT”
cRazao = “Bematech S/A”
cEndereco = “Rua ABCDEF, 1234″
cCMD = “2″
cDataIni = “01062009″ ‘ DDMMAAAA
cDataFim = “30062009″ ‘ DDMMAAAA

iRetorno = BemaGeraRegistrosTipoE(cArqMFD, cArqTXT, cDataIni, cDataFim, cRazao, cEndereco, “”, cCMD, “”, “”, “”, “”, “”, “”, “”, “”, “”, “”, “”, “”, “”)

• Em Delphi, temos esta função implementada assim:

cArqMFD := ‘C:\DOWNLOAD.MFD’;
cArqTXT := ‘C:\COTEPE1704.TXT’;
cRazao := ‘Bematech S/A’;
cEndereco := ‘Rua ABCDEF, 1234′;
cCMD := ‘2′;
cDataIni := 01062009; // DDMMAAAA
cDataFim := 30062009; // DDMMAAAA

iRetorno := BemaGeraRegistrosTipoE(pchar(cArqMFD), pchar(cArqTXT), pchar(cDataIni), pchar(cDataFim), pchar(cRazao), pchar(cEndereco), ”, pchar(cCMD), ”, ”, ”, ”, ”, ”, ”, ”, ”, ”, ”, ”, ”);

Importante:

• Para os modelos de impressoras fiscais MP-2000 TH FI e MP-6000 TH FI, a função BemaGeraRegistrosTipoE deve ser chamada da BemaMFD.dll.
• Para os modelos de impressoras fiscais MP-2100 TH FI, MP-3000 TH FI, MP-4000 TH FI, MP-6100 TH FI e MP-7000 TH FI, a função BemaGeraRegistrosTipoE deve ser chamada da BemaMFD2.dll.

No exemplo acima, temos a geração do Ato Cotepe 17/04 por intervalo de datas. Podemos também realizar esta geração por intervalo de COOs. Para isso, temos dois exemplos prontos disponíveis para baixar através dos links:

- em VB: http://www.bematech.com.br/suporte/downloads/fisc_win/RegistrosTipoE_VB.zip

- em Delphi: http://www.bematech.com.br/suporte/downloads/fisc_win/RegistrosTipoE_Delphi.zip

Assim, atendemos o item 6 do requisito VII do PAF-ECF.

Além disso, não podemos esquecer que tanto o arquivo contendo o espelho da MFD quanto o arquivo do Ato Cotepe 17/04 devem ser assinados (registro EAD). Sendo assim, podemos usar facilmente a sign_bema.dll.

Maiores detalhes sobre estas funções, podemos consultar no help on-line da BemaFI32.dll, disponível na WEB.

Boas implementações!

Na edição 44 de nosso Flash Tip, criamos um exemplo simples que nos possibilitou realizar uma interação entre usuário e microterminal. Na ocasião, usamos o switch/case para montagem do menu de opções e a função readkey() que permitiu a captura do teclado.

Nesta edição, iremos utilizar o microterminal no acesso a periféricos. Vamos usar as bibliotecas <NFPrint.h> para acessar a impressora não fiscal e <CDisplay.h> para acessar o display do cliente (Customar Display).

Lembrando que estamos dando continuidade ao desenvolvimento para o microterminal FIT Integra. Caso tenha perdido alguma edição anterior do Flash Tip, basta consultá-la em nosso Bemacast a partir do link:

http://partners.bematech.com.br/bemacast/flashtip/

Então, vamos lá!

Configurações iniciais

Antes de iniciarmos nosso exemplo de acesso aos periféricos, devemos inserir em nosso projeto a biblioteca <NFPrint.h> responsável pelas funções de operação com a impressora não fiscal. Então, incluímos no início do nosso projeto, junto com a lista de includes, a linha “#include <NFPrint.h>“.

Além disso, também necessitamos inserir a biblioteca nas propriedades de nosso projeto, então, basta clicarmos com o botão direito em cima de nosso projeto “BemaFit” e irmos em propriedades, conforme mostra ilustração:

Após entrarmos nas propriedades do projeto, temos a janela abaixo dividida em três colunas. Na primeira coluna, selecionamos a opção C/C++ Build. Na coluna do meio, clicamos duas vezes sobre a opção Libraries e, em seguida, em Add (ícone representado pelo sinal de +).

Será exibida uma nova janela para inserção da biblioteca “NFPrint“.

Simplesmente, informamos o nome da biblioteca, conforme ilustrado, e pressionamos OK nas janelas para confirmar as alterações.

Também iremos utilizar o display do cliente (Customer Display) em nosso exemplo, então precisamos inserir a biblioteca CDisplay em nosso projeto, porém para inserção desta biblioteca não será necessário seguir os mesmos passos descritos acima, basta a incluirmos no início do projeto usando um include, pois esta biblioteca já está presente na lista de bibliotecas do projeto.

Após as configurações, basta simplesmente copiarmos e colarmos o código abaixo em nosso projeto.

#include <allegro.h>
#include <UDisplay.h>
#include <stdio.h>
#include <CDisplay.h>
#include <NFPrint.h>

int main(void)
{
  char ch;

  /* instrução necessario para inicializar o a biblioteca allegro */
  if (allegro_init() != 0)
    return 1;

  do
  {
    /* Instala o teclado */
    install_keyboard();

    char buff[256];

    // Inicializar o display do usuario
    UserDisplayInit();

    // Limpa o display do usario 
    UserDisplayClearAll();

    if (keypressed())
      readkey(); // Flush

    // Monta menu no display do usuario
    UserDisplayPrint(1, 1, “1 - Impressao COM1″);
    UserDisplayPrint(2, 1, “2 - Impressao display”);
    UserDisplayPrint(3, 1, “Opcao:”);

    memset(buff, 0, 256);
    ch = readkey();

    switch (ch)
    {
      case ‘1′:
      {
        int j;

        // String utilizada para receber texto com tamanho de buffer 49
        char bufferImp[49];

        // Tipo de corte, para guilhotina - Parcial
        papperCut_t ncut = CUT_PARTIAL;

        // baud rate
        rs232Baudrate_t baud = RS232_BAUD_9600;

        // Configura a impressora para estabelecer comunicação.
        // - logicalPort = SERIAL1;
        // - baudRate = baud;
        // - lineFeeds = 3;
        // - cutType = CUT_PARTIAL.
        NFPrinterConfg(”SERIAL1″, baud, 3, ncut);

        // inicializa impressora.
        // Nota: A configuração da impressora deve ser efetuada antes da execução
        // das funções abaixo.
        NFPrinterInit();

        j = 0;

        // Variável que irá checar o resultado da execução da função.
        int result = BS_SUCCESS;

        // Laço para realizar impressão
        while (j < 40)
        {
          // Imprime a string armazenada em bufferImp, na qual o 
          // tamanho foi definido em srtlen(bufferImp)

          sprintf(bufferImp, “%02d %s %02d\r\n”, j, “Teste de impressao FIT integra”, result);
          result = NFPrinterPrint(bufferImp, strlen(bufferImp));
          for (int i = 100; result != BS_SUCCESS && i >= 0; i–) 
          {
            usleep(100000);
            result = NFPrinterPrint(bufferImp, strlen(bufferImp));
          }
          j++;
        }
        j = 0;

        // Avanço de 4 linha
        NFPrinterLineFeed(4);

        // Acionamento parcial da Guilhotina
        NFPrinterCutPper(ncut);

        // Finaliza mode impressão
        NFPrinterStop();

        UserDisplayClearAll();
        UserDisplayPrint(2, 1,(result != BS_SUCCESS) ? “Erro na ultima impressao” :
“Verifique impressao”);

        // Fim impressao nao fiscal 
        readkey();
      }
      break;
      case ‘2′:
      { 
        // Configura o display na serial 2(port = SERIAL2, e o tipo do
        // display = CD_LD220)

        CustomerDisplayConfig(”SERIAL2″, CD_LD220);

        // inicializa o display do cliente
        CustomerDisplayInit();

        // Limpa display do usuário
        // NOTA: O display do usuário deve ser previamente inicializado
        // CustomerDisplayClear();
        // Define como o texto será apresentado no display.
        CustomerDisplaysetStatus(BLINKING);

        // Emite o texto 
        // - “Teste linha 1!” será apresentado na primeira linha” the first line of
        // the Customer Display
        CustomerDisplayprint(0, “Teste linha 1!”);

        // Emite o texto 
        // - “Teste linha 2!” será apresentado na primeira linha” 
        CustomerDisplayprint(1, “Teste linha 2!”);
      }
      UserDisplayClearAll();
      UserDisplayPrint(2, 1, “Verifique Display!”);
      readkey();
      break;
      default:
        UserDisplayClearAll();
        UserDisplayPrint(2, 1, “Programa encerrado!”);
        readkey();
        return EXIT_SUCCESS;
      break;
    }

    /* wait for a key press */
    readkey();
  }
  while (ch != ‘9′);
}

Depois de compilado, ao executarmos será exibido o seguinte menu no display do microterminal:

1 - Impressão COM1
2 - Impressão display
Opção:

Obs: Para que possamos ver na prática as funcionalidades de nosso exemplo, é necessário conectarmos na porta COM1 do microterminal 1 impressora não fiscal, e na porta COM2 conectarmos 1 display do cliente.

Caso a escolha no menu seja 1, automaticamente a ação tomada será a impressão do seguinte texto na bobina da impressora.

00 Teste de impressão FIT Integra 00
01 Teste de impressão FIT Integra 00
02 Teste de impressão FIT Integra 00
03 Teste de impressão FIT Integra 00
04 Teste de impressão FIT Integra 00
05 Teste de impressão FIT Integra 00
06 Teste de impressão FIT Integra 00
07 Teste de impressão FIT Integra 00
08 Teste de impressão FIT Integra 00
09 Teste de impressão FIT Integra 00
…

Caso a escolha no menu seja 2, simplesmente será exibida no display do cliente a seguinte mensagem:

Teste linha 1!
Teste linha 2!

Assim, temos um pequeno exemplo demonstrando o uso das funções das bibliotecas NFPrint e CDisplay de nosso FT Developer KIT para o microterminal FIT Integra.

Próxima edição:

Na próxima edição, vamos implementar o leitor de código de barras e acessar o microterminal remotamente.

Na edição 40 de nosso Flash Tip, vimos como criar o primeiro exemplo e imprimir algumas mensagens no display do usuário, como compilar o projeto, onde os arquivos são alocados no microteminal e qual o arquivo que devemos configurar para que a aplicação seja carregada no processo de BOOT do microterminal.

Nesta edição, iremos desenvolvedor um pequeno exemplo que nos permita interagir com o microterminal, enviando mensagens para o display e recebendo informações do teclado. Basicamente neste exemplo, usaremos o tão famoso “switch/case”, além das funções nativas do SDK.

Configurações Iniciais

Antes de iniciarmos nosso exemplo, devemos inserir em nosso projeto a biblioteca “allegro”, a qual possui uma função específica que irá receber dados do teclado, ou seja, uma função similar ao getchar() do C - a função readkey().

Não há necessidade de inserir recursos opcionais para trabalharmos com a “allegro”, devido ela já estar presente na instalação do ambiente de desenvolvimento. Então, para inserirmos a biblioteca “allegro” em nosso projeto, devemos seguir os seguintes passos:

• Na estrutura de pastas, clicamos com o botão direito do mouse sobre a pasta do projeto e em seguida selecionamos “Properties” (nesta ilustração nosso projeto recebe o nome de BemaFit).

• Temos a janela de propriedades do projeto dividida em três colunas. Na primeira coluna selecionamos a opção C/C++ Build. Na coluna do meio, clicamos duas vezes sobre a opção Libraries, em seguida clicamos na opção Add da terceira coluna (ilustrada com um círculo).
  
• Será exibida uma nova janela para inserção da biblioteca “allegro”. Simplesmente informamos “alleg” e damos um OK em todas as janelas para confirmar a alteração.

Após a inserção desta biblioteca, já é possível inserimos nosso código no projeto.

Abaixo temos o código pronto que irá testar as funções de display e teclado, conforme mencionamos nesta edição. Basta então, copiá-lo e inserí-lo no projeto, inclusive com seus includes.

#include <allegro.h>
#include <UDisplay.h>
#include <stdio.h>

int main(void)
{
  char ch;

  /* instrução necessária para inicializar a biblioteca allegro */
  if (allegro_init() != 0)
    return 1;

  do
  { 
    /* inicializa funções do teclado */
    install_keyboard();

    char buff[256];

    // Inicializar o display do usuario
    UserDisplayInit();

    // Limpa o display do usario 
    UserDisplayClearAll();

    // Monta menu principal no display o usuário
    UserDisplayPrint(1,1, “1 - Escolha um “);
    UserDisplayPrint(2,1, “2 - Escolha dois”);
    UserDisplayPrint(3,1, “Opcao:”);
    memset(buff, 0, 256);
    ch=readkey();

    switch(ch)
    { 
      case ‘1′: 
        UserDisplayClearAll(); 
        UserDisplayPrint(2,1, “Key 1 Pressionada!”);
        readkey();
      break;
      case ‘2′: 
        UserDisplayClearAll(); 
        UserDisplayPrint(2,1, “Key 2 Pressionada!”);
        readkey();
      break;
      default:
        UserDisplayClearAll(); 
        UserDisplayPrint(2,1, “Programa encerrado!”);
        readkey();
        return EXIT_SUCCESS;
      break;
    } 
    /* Pausa na execução */
    readkey();

  }
  while (ch != ‘9′);
}

Após realizarmos a compilação do projeto, devemos simplesmente definir no arquivo userrc (localizado dentro do microterminal), o local aonde está nosso projeto compilado para que ele seja carregado na inicialização do microterminal (processo que já abordamos na edição 40 do Flash Tip).

Basicamente, ao executar o projeto teremos as seguinte opções no display do usuário:

1 - Escolha um
2 - Escolha dois
Opção:

E, ao pressionar 1 teremos a mensagem “Key 1 Pressionada!” e ao pressionar 2 teremos a mensagem “Key 2 Pressionada!”. Se for pressionado algo diferente, teremos “Programa encerrado!”.

Assim, temos um pequeno exemplo demonstrando o uso das funções de display e de interação com o microterminal, capturando entradas via teclado.

Próxima Edição:

Na próxima edição, vamos avançar um pouco mais no desenvolvimento e realizar a comunicação do microterminal com alguns periféricos.

Não perca!

Até lá e boas implementações!

Primeiramente, gostaríamos de agradecer os feedbacks que temos recebido desde o lançamento de nossa dll que gera as chaves pública e privada, e a assinatura EAD no arquivo para o PAF - a dll sign_bema.dll.

Sem dúvida, esta dll veio para auxiliar nossa comunidade de desenvolvedores na implementação de um dos requisitos mais complexos do PAF-ECF - a Assinatura Digital do arquivo.

Nesta edição extra do Flash-Tip, queremos contribuir ainda mais com nossa comunidade, exemplificando o uso da sign_bema.dll e de suas funções, e mostrar a simplicidade que é gerar estas chaves e o registro EAD no arquivo.

1º passo - A declaração das funções

Nosso primeiro passo, é conhecer a declaração das funções da sign_bema.dll. Vamos fazê-la em Delphi e VB.

- em Delphi:

function genkkey( cChavePublica: String; cChavePrivada: String ): integer; stdcall; external ’sign_bema.dll’;

function setLibType( iTipo: integer ): integer; stdcall; external ’sign_bema.dll’;

function generateEAD( cNomeArquivo: String; cChavePublica: String; cChavePrivada: String; cEAD:String; iSign: Integer): integer; stdcall; external ’sign_bema.dll’;

function validateFile( cNomeArquivo: String; cChavePublica: String; cChavePrivada: String ): integer; stdcall; external ’sign_bema.dll’;

- em VB:

Private Declare Function genkkey Lib “sign_bema.dll” (ByVal cChavePublica As String, ByVal cChavePrivada As String) As Integer

Private Declare Function setLibType Lib “sign_bema.dll” (iTipo as Integer) As Integer

Private Declare Function generateEAD Lib “sign_bema.dll” (ByVal cNomeArquivo As String, ByVal cChavePublica As String, ByVal cChavePrivada As String, ByVal cEAD As String, ByVal iSign As Integer) As Integer

Private Declare Function validateFile Lib “sign_bema.dll” (ByVal cNomeArquivo As String, ByVal cChavePublica As String, ByVal cChavePrivada As String) As Integer

2º passo - Conhecer as funções que serão usadas

A sign_bema.dll possui 4 funções. Dentre elas, temos 2 funções que são usadas para a geração das chaves e da assinatura do arquivo, ou seja, basicamente precisamos de apenas 2 funções para atender ao requisito do PAF-ECF. São elas:

• genkkey
• generateEAD

A função genkkey é responsável pela geração das chaves pública e privada, e a função generateEAD é responsável pela assinatura do arquivo, gerando e inserindo o registro EAD.

3º passo - Usar as funções

Veja como é simples a implementação destas duas funções. Vamos codificá-las em Delphi e VB.

- em Delphi:

(…)

setlength( cChavePublica, 256 );
setlength( cChavePrivada, 256 );

iRetorno := genkkey( cChavePublica, cChavePrivada );

if ( iRetorno = 0 ) then
  application.MessageBox( ‘Erro de execução!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK )
else
  application.MessageBox( ‘Sucesso!’, ‘Atenção’, MB_ICONINFORMATION + MB_OK );

(…)

setlength( cRegistroEAD, 256 );
cNomeArquivo := “C:\Espelho.txt”;

iRetorno := generateEAD( cNomeArquivo, cChavePublica, cChavePrivada, cRegistroEAD, 1 );

if ( iRetorno = 0) then
  application.MessageBox( ‘Erro de execução!’, ‘ERRO’, MB_ICONINFORMATION + MB_OK )
else
  application.MessageBox( ‘Sucesso!’, ‘Atenção’, MB_ICONINFORMATION + MB_OK );

(…)

- em VB:

(…)

cChavePublica = Space(256)
cChavePrivada = Space(256)

iRetorno = genkkey(cChavePublica, cChavePrivada)

If (iRetorno = 0) Then
  MsgBox “Erro de execução!”, vbInformation + vbOKOnly, “ERRO”
Else
  MsgBox “Sucesso!”, vbInformation + vbOKOnly, “Atenção”
End If

(…)

cRegistroEAD = Space(256)
cNomeArquivo = “C:\Espelho.txt”

iRetorno = generateEAD( cNomeArquivo, cChavePublica, cChavePrivada, cRegistroEAD, 1 )

If ( iRetorno = 0 ) Then
  MsgBox “Erro de execução!”, vbInformation + vbOKOnly, “ERRO”
Else
  MsgBox “Sucesso!”, vbInformation + vbOKOnly, “Atenção”
End If

(…)

Detalhando um pouco mais estas duas funções, temos na função genkkey dois parâmetros já inicializados com 256 bytes, um para receber a geração da chave pública e outro para a chave privada, ambas automaticamente.

Tendo em mãos estas duas chaves, podemos assinar o arquivo com a função generateEAD. Esta função possui como parâmetros, o nome do arquivo que será assinado, a chave pública, a chave privada (previamente geradas pela função genkkey), o registro EAD e uma flag que indica se desejamos que o registro EAD já seja incluído no arquivo ou não (1 para sim ou 0 para não). Em relação ao 4º parâmetro (registro EAD), este precisa ser inicializado antes com 256 bytes, pois ele receberá a geração automática da assinatura.

Estas funções retornam um int, onde 1 (um) corresponde ao sucesso da execução e 0 (zero) a algum erro que tenha ocorrido.

Pronto, implementado, validado e funcionando na aplicação! Uma dll com funções simples, que ajudam a atender este requisito do PAF-ECF de forma fácil, rápida e segura.

Quero agora, compartilhar com você algumas dicas importantes para a validação do arquivo:

1) O Fisco possui um programa chamado “eECFc” que faz a validação do arquivo com base na chave pública informada.

2) A software-house deve criar um arquivo XML com o seguinte conteúdo:

<?xml version=”1.0″ ?>
<empresa_desenvolvedora>
  <nome></nome>
  <chave>
    <modulo></modulo>
    <expoente_publico>03</expoente_publico>
  </chave>
</empresa_desenvolvedora>

Onde:

• Na TAG <nome> deve ser informado o nome da software-house.
• Na TAG <modulo> deve ser informada a chave pública gerada.
• Na TAG <expoente_publico> deve ser informado o expoente de validação. Para Bematech o expoente é 03.

 3) A nomenclatura deste arquivo é formada pelo nome da sofware-house mais a extensão “.xml”, exemplo: “EMPRESA.xml”.

4) O arquivo .xml deve ser salvo na pasta “SHOUSE”, localizada onde o “eECFc” foi instalado.

Estamos à disposição para qualquer dúvida que venha a surgir, através dos canais:

Boas implementações!

Ao longo desse mini-curso sobre nossa ferramenta Bematech Flash Builder - em especial a “Classe TEF” - aprendemos algumas particularidades da ferramenta, criamos uma rotina completa de cupom fiscal e transações de venda a cartão, e também acesso ao módulo administrativo das bandeiras.

Agora, nesse último Flash-Tip da série sobre a “Classe TEF”, vamos voltar nosso foco a uma particularidade importante dessa classe que é a possibilidade de modificação no arquivo Intpos.001.

Essa modificação pode ser necessária em alguns testes durante a homologação nas bandeiras, onde pode ser solicitada a alteração do conteúdo do arquivo ou de verificação de divergências do mesmo, por parte da aplicação.

Como já vimos nos Flash-Tips anteriores, o envio da transação é feito antes da execução da forma de pagamento “Cartão” através do método “CriarSolicitacaoCartao”, portanto em nosso exemplo vamos implementar os métodos de modificação do arquivo Intpos.001 logo após popularmos o objeto com os dados da transação.

O processo de modificação do arquivo é simples! Como a ferramenta Flash Builder só cria o arquivo Intpos.001, efetivamente no momento da transação, os dados do arquivo ficam armazenados em um “.xml” dentro da pasta da aplicação (TransacoesTEF.xml), permitindo a alteração do conteúdo antes da criação efetiva do arquivo.

Todo este processo é executado com base no objeto criado pelo método “CriarSolicitacaoCartao” (em nosso exemplo, pelo objeto “minhasolicitacaocartao”), através da propriedade Buffer.

Abaixo, podemos ver alguns métodos da propriedade Buffer:

Nessa imagem, temos o método que usaremos para inserir linhas no arquivo Intpos.001.

Vale lembrar que as linhas do arquivo Intpos.001 são contadas a partir da posição 0 (zero), sendo então 0 (zero) a primeira linha do arquivo, 1 (um) a segunda, 2 (dois) a terceira e, assim, sucessivamente.

Modificando o conteúdo do Intpos.001 (inserir e apagar linhas inteiras)

Para modificar uma linha completa no arquivo, podemos usar os dois métodos descritos abaixo:

Modificando linhas específicas do arquivo Intpos.001

Além de podermos adicionar ou remover linhas do arquivo Intpos.001, também temos a possibilidade de modificar linhas específicas no arquivo. Abaixo temos as principais modificações que podem ser feitas no arquivo:

Vamos visualizar na prática, um exemplo de mudança do header do arquivo:

- em C#

private void btnefetuapagamento_Click(object sender, EventArgs e)
{
  try
  {
    // MÉTODO PARA EXECUÇÃO DA FORMA DE PAGAMENTO QUANDO NÃO UTILIZARMOS
    // A OPÇÃO DE “Cartao”.
    if (txtdescforma.Text != “Cartao”)
    {
      BematechFiscal.Cupom.EfetuarPagamento( txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text ) );
    }
    else
    {
      // MÉTODO PARA CRIAÇÃO DA CHAMADA AO MÓDULO DA BANDEIRA, 
      // PARA EXECUÇÃO DA TRANSAÇÃO TEF

      SolicitacaoCartao minhasolicitacaocartao;

      minhasolicitacaocartao = BematechFiscal.TEF.CriarSolicitacaoCartao( txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text ) );

      // ALTERAÇÃO DO HEADER DO ARQUIVO

      minhasolicitacaocartao.Header = “CHQ”;

      // MÉTODO PARA ENVIO DA SOLICITAÇÃO (CRIAÇÃO DO OBJETO ENVIAR SOLICITAÇÃO)
      // E ENVIO AO GP.

      Transacao minhatransacao = BematechFiscal.TEF.EnviarSolicitacao( minhasolicitacaocartao );
      if (minhatransacao.Status != “0″)
      {
        MessageBox.Show(minhatransacao.TextoOperador);
        return;
      }
      else
      {
        MessageBox.Show(minhatransacao.TextoOperador);
      }

      // EXECUÇÃO DA FORMA DE PAGAMENTO NA IMPRESSORA FISCAL.

      BematechFiscal.Cupom.EfetuarPagamento(txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text ) );
      while (true)
      {
        try
        {

          // CRIAÇÃO DO OBJETO MINHASOLICITACAOCONFIRMACAO PARA INICIAR A CONFIRMAÇÃO
          // DAS TRANSAÇÕES TEF

          SolicitacaoConfirmacao minhasolicitacaoconfirmacao = BematechFiscal.TEF.CriarSolicitacaoConfirmacao();
          BematechFiscal.TEF.ConfirmarTransacao(minhasolicitacaoconfirmacao);
          break;
        }
        catch (TEFException ErroTEF)
        {
          MessageBox.Show(ErroTEF.Message);
        }
      }
    }
  }
  catch (FiscalException MensagemErro)
  {
    MessageBox.Show(”MensagemErro: ” + MensagemErro.Message);
  }
  catch (GerenciadorInativoException MensagemErro)
  {
    MessageBox.Show(”MensagemErro: ” + MensagemErro.Message);
  }
}

- em VB.NET

Private Sub btnefetuapagamento_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnefetuapagamento.Click
  Try
    ‘ MÉTODO PARA EXECUÇÃO DA FORMA DE PAGAMENTO QUANDO NÃO UTILIZARMOS 
    ‘ A OPÇÃO DE “Cartao”.

    If (txtdescforma.Text <> “Cartao”) Then
      BematechFiscal.Cupom.EfetuarPagamento( txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text ) )
    Else

      ‘ MÉTODO PARA CRIAÇÃO DA CHAMADA AO MÓDULO DA BANDEIRA, PARA EXECUÇÃO 
      ‘ DA TRANSAÇÃO TEF

      Dim minhasolicitacaocartao As SolicitacaoCartao = BematechFiscal.TEF.CriarSolicitacaoCartao(txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text))

      ‘ ALTERAÇÃO DO HEADER DO ARQUIVO

      minhasolicitacaocartao.Header = “CHQ”

      ‘ MÉTODO PARA ENVIO DA SOLICITAÇÃO (CRIAÇÃO DO OBJETO ENVIAR SOLICITAÇÃO) E ENVIO
      ‘ AO GP

      Dim minhatransacao As Transacao = BematechFiscal.TEF.EnviarSolicitacao( minhasolicitacaocartao)
      If (minhatransacao.Status <> “0″) Then
        MessageBox.Show(minhatransacao.TextoOperador)
        Return
      Else
        MessageBox.Show(minhatransacao.TextoOperador)
      End If

      ‘ EXECUÇÃO DA FORMA DE PAGAMENTO NA IMPRESSORA FISCAL

      BematechFiscal.Cupom.EfetuarPagamento(txtdescforma.Text, Convert.ToDecimal( txtvalorforma.Text))
      While (True)
        Try
          ‘ CRIAÇÃO DO OBJETO MINHASOLICITACAOCONFIRMACAO PARA INICIAR A CONFIRMACÃO DAS
          ‘ TRANSAÇÕES TEF EFETAUDAS

          Dim minhasolicitacaoconfirmacao As SolicitacaoConfirmacao = BematechFiscal.TEF.CriarSolicitacaoConfirmacao()
          BematechFiscal.TEF.ConfirmarTransacao(minhasolicitacaoconfirmacao)
          Exit While
        Catch MensagemErro As TEFException
          MsgBox(”MensagemErro: ” + MensagemErro.Message)
        End Try
      End While
    End If
  Catch MensagemErro As FiscalException
    MsgBox(”MensagemErro: ” + MensagemErro.Message)
  Catch MensagemErro As GerenciadorInativoException
    MsgBox(”MensagemErro: ” + MensagemErro.Message)
  End Try
End Sub

Neste exemplo, como estamos fazendo uma venda TEF, o header do arquivo é identificado como “CRT” que indica que a transação executa é do tipo “Cartão”:

Nesta imagem, percebemos a modificação do header do arquivo para “CHQ” (Cheque), e na execução do código teremos um alerta de erro, devido à diferença de conteúdo deste arquivo:

Assim, concluindo nosso aprendizado sobre a “Classe TEF” da ferramenta Bematech Flash Builder.

Esperamos que esta edição e todas as demais apresentadas, tenham sido de grande ajuda à você nosso parceiro de software que desenvolve para a plataforma .NET, e que procurava uma ferramenta de altíssimo nível em facilidade de integração, compreensão e rapidez.

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

Caso deseja receber os exemplos em C# ou VB.NET apresentados nestas edições, nos envie um email para partners@bematech.com.br.

Boas implementações!