- 1. Introdução
- 2. Pré Requisitos
- 3. Definição do método
- 4. Declaração do método
- 5. Como utilizar os comandos
- 6. 1º Byte → Status da impressora
- 7. 2º Byte → Retorno de status da impressora
- 8. 3º Byte → Status de erro da impressora
- 9. 4º Byte → Cabeça de impressão e comandos executados
- 10. 5º Byte → versão do firmware e revisão
- 11. Implementação do método em Delphi 7
- 12. Considerações finais
- 13. Suporte
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. |
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;
///////////////////////////////////////////////////////////////////- Neste exemplo o Form apresenta os valores no evento OnCreate.
- O parâmetro do método deve ser declarado como array of byte.
- É necessário alocar espaço de memória para o array de byte, então foi aplicado um SetLength.
- 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.
Qualquer dúvida, é só chamar nossos especialistas no Chat Online!
Abraço e até a próxima!