Retorno Estendido na dll M2032

Home » Impressoras » Retorno Estendido na dll M2032
Impressoras, Middleware, mp2032 Nenhum Comentário

1. Introdução

O material abaixo busca fornecer orientação detalhada para a utilização de comandos diretos para captura de status das impressoras Bematech. Ela permite ao desenvolvedor validar possíveis problemas de impressão e também situações de erros na impressora.

2. Pré Requisitos

  • mp2032.dll versão 4.3.0.10 ou superior;
  • SiUSBXp.dll;
  • Impressora térmica modelo:
    • MP-4200 TH;
    • MP-5100 TH;
Important

Esse método é compatível somente com as impressoras citadas acima, MP-4200 TH e MP-5100 TH.

3. Definição do método

O Retorno estendido é obitido pelo método:

LeituraStatusEstendido(status)

Sendo o parâmetro “status” um array de byte ou de char.

4. Declaração do método

  • Em Delphi
function LeituraStatusEstendido( A: array of byte ): integer; stdcall; far; external 'MP2032.DLL';
  • Em VB6
Public Declare Function LeituraStatusEstendido Lib "MP2032.DLL" (ByVal A() As Byte) As Integer

5. Como utilizar os comandos

Os comandos de leitura de status estendido devem ser utilizados com parcimônia, pois se executados de maneira constante, podem apresentar algumas situações de exceção bem específicas, tais como: impressora ocupada e falha de comunicação.

Como boas práticas sugerimos que a cada envio de comando de impressão (bloco de texto) seja feita a execução de captura de status estendido, e tão somente após a obtenção do retorno de status é que um novo comando ou bloco de impressão seja enviado à impressora.

Esse comando irá retornar 5 bytes da impressora, com os quais poderemos avaliar o real status da impressora.

6. 1º Byte → Status da impressora

7 6-5 4 3 2 1 0
1 BufStat Wait Offline OVR 0 0

Bit 0 → Não se aplica – retorno 0.

Bit 1 → Não se aplica – retorno 0.

Bit 2 → OVR – Erro de sobrecarga. Se enviar mais conteúdo o mesmo será perdido.

Bit 3 → Offline:

  • 0 – Impressora on-line;
  • 1 – Impressora off-line;

Bit 4 → Wait – Aguardando:

  • 0 – Buffer limpo (aguardando mais dados ou comandos);
  • 1 – Impressora ocupada (imprimindo).

Bit 5 e 6 → BufStat – Buffer Status:

  • 00 – Buffer limpo.
  • 01 – Menos 1/3 da capacidade do buffer utilizado:
  • 10 – Mais de 1/3 da capacidade do utilizado;
  • 11 – Mais de ¾ do buffer utilizado;

Bit 7 → Não se aplica – retorno 1.

7. 2º Byte → Retorno de status da impressora

7 6 5 4 3 2 1 0
Tampa Error Sem Papel Drawer 0 PS PNES 0

Bit 0 → Não se aplica – retorno 1.

Bit 1 → PNES –Sensor de fim de papel:

  • 0 – Papel não está próximo ao fim;
  • 1 – Papel próximo ao fim;

Bit 2 → PS – Sensor de Papel:

  • 0 – Impressora tem papel;
  • 1 – Impressora sem papel;

Bit 3 → Não se aplica – retorno 0.

Bit 4 → Drawer – Gaveta de dinheiro:

  • 0 – Sensor de gaveta baixo (lógico 0);
  • 1 – Sensor de gaveta alto (logico 1);

Bit 5 → Sem Papel:

  • 0 – Impressora tem papel
  • 1 – Impressora sem papel

Bit 6 → Error – Erro:

  • 0 – Sem erros reportados pela impressora.
  • 1 – Existe um erro reportado pela impressora.

Bit 7 → Tampa:

  • 0 – Tampa aberta.
  • 1 – Tampa fechada.

8. 3º Byte → Status de erro da impressora

7 6 5 4 3 2 1 0
1 RE NRE 1 CE CA 0 0

Bit 0 → Não se aplica – retorno 0.

Bit 1 → Não se aplica – retorno 0.

Bit 2 → CA – Guilhotina ausente

  • 0 – Guilhotina presente
  • 1 – Guilhotina ausente

Bit 3 → CE – Erro guilhotina

  • 0 – Sem erro reportado na guilhotina
  • 1 – Erro encontrado na guilhotina

Bit 4 → Não se aplica – retorno 1.

Bit 5 → NRE – Erro não recuperável

0 – Condição NRE não detectado 1 – Condição NRE detectada

Bit 6 → RE – Erro recuperável

  • 0 – Condição RE não encontrada
  • 1 – Condição RE encontrada

Bit 7 → Não se aplica – retorno 1.

9. 4º Byte → Cabeça de impressão e comandos executados

7 6 5 4 3 2 1 0
1 CMD 0 1 0 HOH 0 1

Bit 0 → Não se aplica – retorno 1.

Bit 1 → Não se aplica – retorno 0.

Bit 2 → HOH – Head Overheat (Aquecimento cabeça de impressão)

  • 0 – Cabeça de impressão com temperatura normal
  • 1 – Cabeça de impressão sobreaquecida

Bit 3 → Não se aplica – retorno 0.

Bit 4 → Não se aplica – retorno 1.

Bit 5 → Não se aplica – retorno 0.

Bit 6 → CMD – Conjunto de comandos atual – 0 – ESC/Bema – 1 – ESC/Pos

10. 5º Byte → versão do firmware e revisão

7 6-4 3-0
0 Versão Firmware Revisão Firmware

Bit 0 a 3 → Revisão Firmware.

Bit 5 → Não se aplica – retorno 0.

Bit 4 a 6 → Versão Firmware.

11. Implementação do método em Delphi 7

Segue um exemplo de implementação utilizando o Delphi 7, apresentando todos os valores em uma tela.

Table 1. Componentes Utilizados

Componente Nome
Form FormRetornoEstendido
Button Usado para voltar ao Form principal.
Edit Usados para apresentar o valor de cada bit, com 8 componentes Edit pra cada byte.
Memo Descrição de cada bit de retorno do byte.
Código de implementação
procedure TFormRetornoEstendido.FormCreate(Sender: TObject); (1)
var
buffer: array of byte; (2)
h1,h2,h3,h4,h5 : PAnsiChar;
h1x,h2x,h3x,h4x,h5x : PAnsiChar;
b1,b2,b3,b4,b5 : string;
c10, c11, c12, c13, c14, c15, c16, c17,
c20, c21, c22, c23, c24, c25, c26, c27,
c30, c31, c32, c33, c34, c35, c36, c37,
c40, c41, c42, c43, c44, c45, c46, c47,
c50, c51, c52, c53, c54, c55, c56, c57 : string;
i_retorno : integer;

begin

try
SetLength(buffer, 20); (3)
begin
    i_retorno:=LeituraStatusEstendido(buffer);

    // Converte o retorno de cada byte para Hexa, com alocação de 20 caracteres
    h1 := PChar(IntToHex(buffer[0],20));
    h2 := PChar(IntToHex(buffer[1],20));
    h3 := PChar(IntToHex(buffer[2],20));
    h4 := PChar(IntToHex(buffer[3],20));
    h5 := PChar(IntToHex(buffer[4],20));

    // pega somente os últimos 2 digitos dos 20 retornados de cada byte
    h1x := PChar(Copy(h1,18,2));
    h2x := PChar(Copy(h2,18,2));
    h3x := PChar(Copy(h3,18,2));
    h4x := PChar(Copy(h4,18,2));
    h5x := PChar(Copy(h5,18,2));

    // Converte os dois digitos Hexa para Binários com 8 digitos
    b1 := HexToBin(h1x);
    b2 := HexToBin(h2x);
    b3 := HexToBin(h3x);
    b4 := HexToBin(h4x);
    b5 := HexToBin(h5x);


    // Separa bit a bit e mostra em tela (4)

    // 1º Byte
    c10 := Copy(b1,0,1);
    Edit1.Text := c10;
    c11 := Copy(b1,1,1);
    Edit2.Text := c11;
    c12 := Copy(b1,2,1);
    Edit3.Text := c12;
    c13 := Copy(b1,3,1);
    Edit4.Text := c13;
    c14 := Copy(b1,4,1);
    Edit5.Text := c14;
    c15 := Copy(b1,5,1);
    Edit6.Text := c15;
    c16 := Copy(b1,6,1);
    Edit7.Text := c16;
    c17 := Copy(b1,7,1);
    Edit39.Text := c17;

    // 2º Byte
    c20 := Copy(b2,0,1);
    Edit8.Text := c20;
    c21 := Copy(b2,1,1);
    Edit9.Text := c21;
    c22 := Copy(b2,2,1);
    Edit10.Text := c22;
    c23 := Copy(b2,3,1);
    Edit11.Text := c23;
    c24 := Copy(b2,4,1);
    Edit12.Text := c24;
    c25 := Copy(b2,5,1);
    Edit13.Text := c25;
    c26 := Copy(b2,6,1);
    Edit14.Text := c26;
    c27 := Copy(b2,7,1);
    Edit40.Text := c27;

    // 3º Byte
    c30 := Copy(b3,0,1);
    Edit15.Text := c30;
    c31 := Copy(b3,1,1);
    Edit16.Text := c31;
    c32 := Copy(b3,2,1);
    Edit17.Text := c32;
    c33 := Copy(b3,3,1);
    Edit18.Text := c33;
    c34 := Copy(b3,4,1);
    Edit19.Text := c34;
    c35 := Copy(b3,5,1);
    Edit20.Text := c35;
    c36 := Copy(b3,6,1);
    Edit21.Text := c36;
    c37 := Copy(b3,7,1);
    Edit41.Text := c37;

    // 4º Byte
    c40 := Copy(b4,0,1);
    Edit22.Text := c40;
    c41 := Copy(b4,1,1);
    Edit23.Text := c41;
    c42 := Copy(b4,2,1);
    Edit24.Text := c42;
    c43 := Copy(b4,3,1);
    Edit25.Text := c43;
    c44 := Copy(b4,4,1);
    Edit26.Text := c44;
    c45 := Copy(b4,5,1);
    Edit27.Text := c45;
    c46 := Copy(b4,6,1);
    Edit28.Text := c46;
    c47 := Copy(b3,7,1);
    Edit42.Text := c47;

    // 5º Byte
    c50 := Copy(b5,0,1);
    Edit29.Text := c50;
    c51 := Copy(b5,1,1);
    Edit30.Text := c51;
    c52 := Copy(b5,2,1);
    Edit31.Text := c52;
    c53 := Copy(b5,3,1);
    Edit32.Text := c53;
    c54 := Copy(b5,4,1);
    Edit33.Text := c54;
    c55 := Copy(b5,5,1);
    Edit34.Text := c55;
    c56 := Copy(b5,6,1);
    Edit35.Text := c56;
    c57 := Copy(b3,7,1);
    Edit38.Text := c57;
end
except
begin
  ShowMessage('Erro ao obter o status estendido...');
end;
end;
end;
///////////////////////////////////////////////////////////////////
// Função para converter Hexa para Binario //<4> ////////////////////////
///////////////////////////////////////////////////////////////////
function TFormRetornoEstendido.HexToBin(Hexadecimal: string): string;
const
  BCD: array [0..15] of string =
    ('0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111',
    '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111');
var
  I : integer;
begin
  for I := Length(Hexadecimal) downto 1 do
    Result := BCD[StrToInt('$' + Hexadecimal[i])] + Result;
end;
///////////////////////////////////////////////////////////////////
  1. Neste exemplo o Form apresenta os valores no evento OnCreate.
  2. O parâmetro do método deve ser declarado como array of byte.
  3. É necessário alocar espaço de memória para o array de byte, então foi aplicado um SetLength.
  4. Os valores estão sendo mostrados no Form separando cada bit e trazendo a definição de cada um.

12. Considerações finais

Este exemplo dado em Delphi serve para entendimento da implementação, com asa conversões necessárias para se obter o resultado correto. Se ocorrerem problemas ao interpretar algum dos parâmetros, com valores que não condizem com o real, não é descartado a hipótese de problemas com o equipamento.

13. Suporte

Nossos canais de suporte ao desenvolvedor

0800-644-7277 – exclusivo aos Desenvolvedores

Chat Online no Portal de Desenvolvedores – http://bematechpartners.com.br/