🔥 Apps, books, system as a service, podcast and more



Curso ECF C# . Tratamento de Erro e Aviso . DarumaFramework.dll

Olá pessoal! No artigo de hoje veremos como fazer o tratamento de retorno com a DLL DarumaFramework.

Os tratamentos desses retornos são de extrema importância, pois com eles conseguimos visualizar o que aconteceu em determinadas situações de não execução dos métodos,  e também de execução dos métodos.

Antes de começar com o código, falarei um pouco dos retornos e erros.

Existem alguns retornos dos métodos, que são:
 [1] quando o método é executado com sucesso, método foi realizado, efetivado.
[-1] quando existe erro no método, não executado em nenhum sentido.
[-6] quando a impressora está desligada ou desconectada. Quando o sistema não consegue comunicação com o ECF.
[-12] quando o método é executado, contudo alguma coisa aconteceu, por exemplo:
Erro: Cupom Fiscal Aberto
Aviso: Pouco Papel

Tecnicamente o tratamento de retorno é feito baseando-se no retorno -12, por quê?
Simples. Pelo fato de que os demais retornos são fixos, já sabendo o que de fato ocorreu.
O -12 é um retorno sem muitas explicações. Ele avisa que o método foi de fato executado, contudo algo ocorreu. Agora que fica mais legal: mas afinal, o que acontece?
Para responder essa e outras dúvidas, estamos criando este artigo! Vamos explicar como realizar o tratamento de retorno dos métodos da DarumaFramework.dll

Mãos a obra! Vamos alterar um pouco o layout do nosso projeto, nomeei a Janela do meu Form1 para Janela ECF. Aproveitei e alterei o nome do Class1 para Declarações_DLL_DarumaFramework.

Aproveitando o Class1 ele aberto, vamos inserir os métodos que precisaremos. Utilizarei três métodos para isso. São elas:

//Tratamento Erro e AViso
        [DllImport("DarumaFrameWork.dll")]
        public static extern int rStatusUltimoCmdInt_ECF_Daruma(ref int piErro, ref int piAviso);
        [DllImport("DarumaFrameWork.dll")]
        public static extern int eInterpretarErro_ECF_Daruma(int iErro, StringBuilder pszDescErro);
        [DllImport("DarumaFrameWork.dll")]
        public static extern int eInterpretarAviso_ECF_Daruma(int iAviso, StringBuilder pszDescAviso);
Com isso pronto, criaremos um GroupBox em nossa Janela ECF, e vamos inserir 10 Labels. 5 deles levarão o título, e os outros 5 receberão os retornos. Nomeei as cinco que receberão o retorno de:
label_retornometodo label_coderro label_stringerro label_codaviso label_stringaviso
Os labels que recebem o nome ficaram com o nome padrão (Label1, Label2...). Os asteriscos coloridos são os labels que citei acima, na ordem.

Então, a Janela ECF ficou desta forma:

Feito esses pequenos ajustes, vamos ao código.
Vamos criar uma função que realizará todo o tratamento de retorno. Podemos fazer o tratamento método a método, e isso não deixará seu programa lento. Optei por fazer dessa forma por ser mais rápido e prático.

Ao invés de falar linha a linha, copiei e colei o tratamento de retorno com todas as linhas comentadas.

//função tratamento de erro e aviso
        // TratamentoRetorno é o nome da função. Você pode trocar se preferir.
        // int RetornoFuncao recebe o retorno do método ( 1, -1, -6 , -12)
        private void TratamentoRetorno(int RetornoFuncao)
        {
            int iErro=0; //declara iErro
            int iAviso = 0; //declara iAviso
            //monta a string eErro com tamanho 300
            StringBuilder eErro = new StringBuilder(300);
            //monta a string eAviso com tamanho 300
            StringBuilder eAviso = new StringBuilder(300);
            label_coderro.Text = ""; //Limpa o Label
            label_codaviso.Text = ""; //Limpa o Label
            label_stringerro.Text = ""; //Limpa o Label
            label_stringaviso.Text = ""; //Limpa o Label
            //Mostra o retorno do método
            label_retornometodo.Text = RetornoFuncao.ToString();
            //trata os status de erro e aviso do ultimo comando
            ECF_Daruma.rStatusUltimoCmdInt_ECF_Daruma(ref iErro, ref iAviso);
           //Parte que interpreta os valores das variaveis da funcão acima.
            ECF_Daruma.eInterpretarErro_ECF_Daruma(iErro, eErro); //interpreta o iErro inteiro e mostra como eErro string
            ECF_Daruma.eInterpretarAviso_ECF_Daruma(iAviso, eAviso); //interpreta o iAviso inteiro e mostra como eAviso string
            //mostra nos labels os retornos
            label_coderro.Text = iErro.ToString();//Mostra codigo erro no label
            label_codaviso.Text = iAviso.ToString(); //mostra codigo aviso no label
            label_stringerro.Text = eErro.ToString(); //mostra string erro no label
            label_stringaviso.Text = eAviso.ToString(); //mostra string aviso no label
        }

Com o código acima, nossa função tratará qualquer retorno do método. Isso não é interessante. Por quê?

Pense comigo: se o método retorna 1 sempre que executado com sucesso, eu não preciso tratar os retornos quando o meu retorno for igual a 1, certo? Não há sentido em tratar algo que não contém erros.

Por isso, vamos colocar uma condição if , para executar os métodos apenas quando minha variável int RetornoFuncao, for diferente de [1].

Colocaremos o if abaixo do início da nossa função.

        private void TratamentoRetorno(int RetornoFuncao)
        {
            if (RetornoFuncao != 1)
            {
                            .
.
.
                label_stringaviso.Text = eAviso.ToString(); //mostra string aviso no label
            }
        }

Pronto! Estrutura de tratamento de retorno criada com sucesso! Agora é hora de aplicar isso em nossas funções já criadas.

Até agora nós criamos as seguintes funções:

ECF_Daruma.iLeituraX_ECF_Daruma()
ECF_Daruma.iReducaoZ_ECF_Daruma("", "")
ECF_Daruma.iCFAbrir_ECF_Daruma("11111111111", "Rafael", "VisualStudio")
ECF_Daruma.iCFVender_ECF_Daruma("F1", "1,000", "01,40", "D%", "0,00", "123456", "UN", "COCA COLA 2LT")
ECF_Daruma.iCFTotalizarCupom_ECF_Daruma("D%", "0,00")
ECF_Daruma.iCFEfetuarPagamento_ECF_Daruma("Dinheiro", "5,00", "Volte Sempre")
ECF_Daruma.iCFEncerrar_ECF_Daruma("0", "Aplicativo Teste")
Para que tratemos os retornos das funções acima, devemos inserir o nome da nossa função de tratamento de retorno antes delas.
Ficará algo desse tipo:
            TratamentoRetorno(ECF_Daruma.iLeituraX_ECF_Daruma());
            TratamentoRetorno(ECF_Daruma.iReducaoZ_ECF_Daruma("", ""));
            TratamentoRetorno(ECF_Daruma.iCFAbrir_ECF_Daruma("11111111111", "Rafael", "VisualStudio"));
            TratamentoRetorno(ECF_Daruma.iCFVender_ECF_Daruma("F1", "1,000", "01,40", "D%", "0,00", "123456", "UN", "COCA COLA 2LT"));
            TratamentoRetorno(ECF_Daruma.iCFTotalizarCupom_ECF_Daruma("D%", "0,00"));
           TratamentoRetorno(ECF_Daruma.iCFEfetuarPagamento_ECF_Daruma("Dinheiro", "5,00", "Volte Sempre"));
            TratamentoRetorno(ECF_Daruma.iCFEncerrar_ECF_Daruma("0", "Aplicativo Teste"));
Prontinho! Nossos métodos já são tratados para qualquer erro ou aviso!
Faremos um teste!

Compile seu sistema e mande abrir um cupom fiscal. Depois de aberto, execute novamente o comando de abrir o cupom. Veja o que acontece com os labels!

Agora, pessoal, vamos fazer alguns ajustes. Em nosso próximo artigo, falaremos do arquivo XML. O que é ele afinal? Para que serve?

Basicamente ele é um arquivo de configuração. É o local onde a DLL armazena informações para seu correto funcionamento, tais como porta serial que a impressora está instalada, velocidade de trabalho. Existe uma chave dentro desse arquivo que modifica também o nosso tratamento de retorno. Falarei brevemente dela, pois alguém pode ter um problema com o tratamento de retorno com o condicional if .

Neste XML existe uma chave chamada <RetornarAvisoErro>0</RetornarAvisoErro>. Com ela DESABILITADA ( 0 ), a dll sempre retornará [1] no método. Nesse caso, nem sempre o retorno [1] significa que ocorreu tudo certo.

Vou dar um exemplo:
Eu mandei abrir um cupom, a impressora imprimiu. Eu mandei novamente o comando de abertura do cupom e o que acontece? O retorno do método é [1]. Aí você vem e diz: Mas aí tá errado, não pode ser assim! Depende. O método ser executado não está ligado a ter sido impresso ou não. O método foi executado, contudo o ECF emitiu um erro.
Se tirarmos o if e deixamos a função tratando TODOS retornos, vamos ter o seguinte cenário.

Abri o cupom.
Mandei abrir novamente
Retorno do método [1] – Com Sucesso
Função de tratamento é acionada.
Interpretação de erro e aviso acionada.
Retorno da função eInterpretarErro = 78
String do Erro: CF Aberto
Visualmente temos o seguinte:

Agora, se essa chave está habilitada (1), o tratamento é dispensável quando RetornoFunção  = [1].

Dúvidas sobre o XML? Não deixe de ler nosso próximo artigo!

Espero que vocês tenham entendido. Qualquer dúvida, postem ou entre em contato conosco!

Sign up to our newsletter

Receive our latest updates about programming languages, software, database, books, ebooks, classes, jobs and more.

Top