ECF no Linux

rmg · Mensagem por **rmg** » 27 Out 2006 07:52

Bem amigos,

Me deparo com o seguinte problema. Utilizo o xHarbour no Conectiva Linux 10 e um de meus clientes precisa de um programa para ECF. Busquei no site da Bematech, os fontes em .C da lib300fi, com funções para impressora MP20fiII.
Coloquei o arquivo no meu makefile e compilou blz, sem problemas, mas aí surge a necessidade de começar a utilizar as funções normalmente no .PRG. Só que se eu puxar direto a função numa linha do prg, na hora de compilar me é informado que não existe a função.
Tendo este problema em mãos, tentei utilizar as funções dentro do PRG, usando #pragma BEGINDUMP e #pragma ENDDUMP.
Já tenho rotinas em .C dentro dos meus PRGs rodando normalmente usando o #pragma, mas como a lib300fi da bematech não são somente funções mais todo um cabeçalho de programação em .C, não consigo utilizar as funções dentro do meu código.
Gostaria de saber de algum colega, como poderia fazer isso. Se posso simplesmente compilar direto o arquivo .C no makefile, sem precisar chamar as funções dentro de um HB_FUNC(), e utilizar as funções dentro dos PRG´s de alguma forma, ou realmente preciso compilar as funções em .C dentro do PRG, utilizando o #pragma BEGINDUMP / #pragma ENDDUMP.
Realmente já tentei de diversas formas utilizar essa lib300fi da bematech, mas não consigo utilizar as funções dela.
Se algum amigo, quiser me ajudar ou souber como fazer, eu agradeço desde já.
O link para download da biblioteca da bematech é http://www.bematech.com.br/suporte/down ... b300FI.zip

Obrigado.

Mensagem por **vagucs** » 27 Out 2006 09:40

vc fez tudo correto, so precisa agora criar as rotinas em C no padrão do xHarbour para que ele enchergue as rotinas, este arquivo já existe tem o nome de SIAR9998.C, nao sei se tiveram mudanças, mas usei a um ano e meio atras e tava tudo funcionando beleza, o arquivo é este abaixo, so colocar em um .C e colocar no seu makefile tambem

Código: Selecionar todos

/* ============================================================ 
 * Biblioteca de Funcoes em Flagship interagindo com fonte em C      
 * da Biblioteca Lib300fi.a da BEMATECH, e LibNorteBema.c
 * Com indicacao da literatura por Jorge Somers leia-se FSWEB. 
 * Data...: 19/04/2000
 * Codigo Escrito por Frank Sipoli / Manoel (Manvfran)
 * =========================================================== */
#include   "hbapi.h"
#include   "stdio.h"
#include   "string.h"
/* --------------------------------------- *
 * Funcao para abrir porta serial recebendo
 * parametro externo de um fonte .prg       
 * Comandos FlagShip interno ao prog em C  */

HB_FUNC(BEMATECH_FI_ABREPORTASERIAL) {
  unsigned char *nporta;
  int erro;
  char Var[3000];
  memset(Var,  '\x0',3000);
  nporta = hb_parc(1);
  if (( erro = Bematech_FI_AbrePortaSerial(nporta)) != 0 ) {
//     Var[0] =(char) (erro);      
     hb_retni(erro);
   }
//   Var[0] =(char) (erro);      
   hb_retni(erro);
 }

/* --------------------------------------- *
 * Funcao para fechar porta serial 
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_FECHAPORTA) {
  int       erro;
  char Var[3000];
  memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_FechaPorta()) != 0 ) {
      hb_ret();
   }
 }

/* --------------------------------------- *
 * Funcao para ver aliquotas cadastradas.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_LEITURAALIQUOTAS) {
   char      aliq [] = "|26|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_LeituraAliquotas(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver cgc cadastrado.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_CGCIE) {
   char     ncgc [] = "|35|2|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_CGCIE(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver o estado de pouco papel.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_MONITORAMENTOPAPEL) {
   char     npapel [] = "|62|54|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   Retorno[0] = 0; Retorno[1] = 0; Retorno[2] = 0; Retorno[3] = 0;
   if (( erro = Bematech_FI_MonitoramentoPapel(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver numero do caixa
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_NUMEROCAIXA) {
   char    term [] = "|35|14|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_NumeroCaixa(Var, &Retorno)) != 0 ) {
       hb_ret();
   }
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para ver numero da Loja responsavel
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_NUMEROLOJA) {
   char    term [] = "|35|14|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_NumeroLoja(Var, &Retorno)) != 0 ) {
       hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver numero do cupom fiscal
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_NUMEROCUPOM) {
   char    ncup [] = "|30|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_NumeroCupom(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para abrir cupom fiscal 
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_ABRECUPOM) {
   char    acup [] = "|00|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_AbreCupom("", &Retorno)) != 0 ) {
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para enviar item ao cupom fiscal
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_VENDEITEM) {
   int lng;
   unsigned char *itemcf;
   unsigned char *codig;
   unsigned char *descri;
   unsigned char *aliq;
   unsigned char *quant;
   unsigned char *valo;
   unsigned char *descont;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   codig    = hb_parc(1);
   descri   = hb_parc(2);
   aliq     = hb_parc(3);
   quant    = hb_parc(4);
   valo     = hb_parc(5);
   descont  = hb_parc(6);
   
   if (( erro = Bematech_FI_VendeItem(codig,descri,aliq,quant,valo,descont, &Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para enviar item ao cupom fiscal
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_VENDEITEM3CASASVALOR) {
   int lng;
   unsigned char *itemcf;
   unsigned char *codig;
   unsigned char *descri;
   unsigned char *aliq;
   unsigned char *quant;
   unsigned char *valo;
   unsigned char *descont;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   codig    = hb_parc(1);
   descri   = hb_parc(2);
   aliq     = hb_parc(3);
   quant    = hb_parc(4);
   valo     = hb_parc(5);
   descont  = hb_parc(6);
   
   if (( erro = Bematech_FI_VendeItem3CasasValor(codig,descri,aliq,quant,valo,descont, &Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para totalizar o cupom fiscal
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_INICIAFECHAMENTOCUPOM) {
   int lng;
   unsigned char *ndesc;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   unsigned char *tpdesc;
   unsigned char *vrdesc;
   char Aux;
   memset(Var,  '\x0',3000);
   tpdesc = hb_parc(1);
   vrdesc = hb_parc(2);
   if (( erro = Bematech_FI_IniciaFechamentoCupom(tpdesc,vrdesc,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver numero do cupom fiscal
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_TERMINAFECHAMENTOCUPOM) {
   int lng;
   unsigned char *msgvar;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   msgvar = hb_parc(1);
   if (( erro = Bematech_FI_TerminaFechamentoCupom(msgvar,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para cancelar cupom fiscal anterior
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_CANCELACUPOM)
{
   char ncanc [] = "|14|";
   int erro, cond;
   char resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,'\x0',3000);
   if (( erro = Bematech_FI_CancelaCupom(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para cancelar item anterior
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_CANCELAITEMANTERIOR) {
   char    stat [] = "|13|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_CancelaItemAnterior(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para consultar e cadastrar forma 
 * de pagamento retornando o indice na qual 
 * esta cadastrada na impressora fiscal.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_VERIFICAFORMAPAGAMENTO) {
   int lng;
   unsigned char *wcforma;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   wcforma = hb_parc(1);
   if (( erro = Bematech_FI_VerificaFormaPagamento(wcforma, Var ,&Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para consultar forma de pgto de 
 * vendeer na forma p/ o cupom fiscal.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_EFETUAFORMAPAGAMENTO) {
   unsigned char *indforma;
   unsigned char *vrtota;
   unsigned char *descri;
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   memset(Var,  '\x0',3000);
   indforma = hb_parc(1);
   vrtota   = hb_parc(2);
   descri   = hb_parc(3);
   if (( erro =Bematech_FI_EfetuaFormaPagamento(indforma,vrtota,descri,&Retorno)) != 0 ) {
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para consultar forma de pgto de 
 * vendeer na forma p/ o cupom fiscal.
 * Comandos FlagShip interno ao prog em C  */
/*HB_FUNC(BEMATECH_FI_FORMAPAGAMENTOMP20FI) {
   unsigned char *desco;
   unsigned char *vrtota;
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   memset(Var,  '\x0',3000);
   desco    = hb_parc(1);
   vrtota   = hb_parc(2);
   if (( erro =Bematech_FI_FormaPagamentoMp20fi(desco,vrtota,&Retorno)) !=0 )
   { 
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
*/
/* --------------------------------------- *
 * Funcao para emitir leitura X   
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_LEITURAX) {
   char    aleix [] = "|06|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_LeituraX(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para emitir leitura X   
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_LEITURAXSERIAL) {
   char    aleix [] = "|06|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_LeituraXSerial(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para efetuar reducao Z  
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_REDUCAOZ) {
   char    aredz [] = "|05|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_ReducaoZ(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para cadastrar aliquota na IMP  
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_ADICIONAALIQUOTA) {
   int lng;
   int Retorno[4];
   unsigned char *aliqu;
   unsigned char *temiss;
   int       erro, cond;
   char      resp [1024];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   Retorno[0] = 0; Retorno[1] = 0; Retorno[2] = 0; Retorno[3] = 0;
   aliqu  = hb_parc(1);
   temiss = hb_parc(2);
   if (( erro = Bematech_FI_AdicionaAliquota(aliqu,temiss,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para abrir cupom nao fiscal 
 * Comandos FlagShip interno ao prog em C  
 * Manoel Vicente 08/09/2000 */
HB_FUNC( BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO) {
   int lng;
   unsigned char *formapgt;
   unsigned char *wn_valor;
   unsigned char *wn_cupom;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   formapgt = hb_parc(1);
   wn_valor = hb_parc(2);
   wn_cupom = hb_parc(3);
   if (( erro = Bematech_FI_AbreComprovanteNaoFiscalVinculado(formapgt,wn_valor,wn_cupom, &Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para imprimir o cupom nao fiscal
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  08/09/2000 */
HB_FUNC( BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO) {
   int lng;
   unsigned char *finalcup;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   finalcup = hb_parc(1);
   if (( erro = Bematech_FI_UsaComprovanteNaoFiscalVinculado(finalcup, &Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para fechar Cupom nao Fiscal
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente 08/09/2000  */
HB_FUNC(BEMATECH_FI_FECHACOMPROVANTENAOFISCALVINCULADO) {
   char     ncgc [] = "|21|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_FechaComprovanteNaoFiscalVinculado(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver a ultima reducao Z.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_DADOSULTIMAREDUCAO) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_DadosUltimaReducao(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver os Totalizadores Parciais.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_LEITURATOTALIZADORESPARCIAIS) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_LeituraTotalizadoresParciais(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver os Totalizadores Parciais.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(SUBTOTAL_C) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_SubTotal(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para ver os Totalizadores Parciais.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_NUMEROREDUCOES) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_NumeroReducoes(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para ver os Totalizadores Parciais.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_FLAGSISS) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_FlagsISS(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver os Totalizadores Parciais.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC( BEMATECH_FI_FLAGSFISCAIS) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_FlagsFiscais(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para imprimir a leitura memoria fiscal por data
 * recebendo a data inicial e final
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  09/06/2001 */
HB_FUNC(BEMATECH_FI_LEITURAMEMORIAFISCALDATA) {
   int lng;
   unsigned char *dtini;
   unsigned char *dtfim;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   dtini = hb_parc(1);
   dtfim = hb_parc(2);
   if (( erro = Bematech_FI_LeituraMemoriaFiscalData(dtini,dtfim,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para imprimir a leitura memoria fiscal por data pela saida serial
 * recebendo a data inicial e final
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  09/06/2001 */
HB_FUNC(BEMATECH_FI_LEITURAMEMORIADISCALDATASERIAL) {
   int lng;
   unsigned char *dtini;
   unsigned char *dtfim;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   dtini = hb_parc(1);
   dtfim = hb_parc(2);
   if (( erro = Bematech_FI_LeituraMemoriaFiscalDataSerial(dtini,dtfim,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/*--------------------------------------------------------------------------
 * Funcao para imprimir a leitura memoria fiscal por reducao 
 * recebendo o numero inicial e final
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  09/06/2001 */
HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAO) {
   int lng;
   unsigned char *rdzini;
   unsigned char *rdzfim;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   rdzini = hb_parc(1);
   rdzfim = hb_parc(2);
   if (( erro = Bematech_FI_LeituraMemoriaFiscalReducao(rdzini,rdzfim,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/*--------------------------------------------------------------------------
 * Funcao para imprimir a leitura memoria fiscal por reducao pela serial
 * recebendo o numero inicial e final
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  09/06/2001 */
HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAOSERIAL) {
   int lng;
   unsigned char *rdzini;
   unsigned char *rdzfim;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   rdzini = hb_parc(1);
   rdzfim = hb_parc(2);
   if (( erro = Bematech_FI_LeituraMemoriaFiscalReducaoSerial(rdzini,rdzfim,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/*--------------------------------------------------------------------------
 * Funcao para testar o estado da impressora fiscal
 * retornando ACK, ST1 e ST2
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  19/06/2001 */

HB_FUNC(BEMATECH_FI_ESTADOIMPRESSORA) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_EstadoImpressora(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/*--------------------------------------------------------------------------
 * Funcao para ler o numero de serie da impressora fiscal
 * retornando variavel com 16 caracteres
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  04/07/2001 */

HB_FUNC( BEMATECH_FI_NUMEROSERIE) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_NumeroSerie(Var,&Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/*--------------------------------------------------------------------------
 * Funcao para ler a data e a hora da impressora Fiscal
 * retornando variavel com 13 caracteres
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  26/07/2001 */

HB_FUNC(BEMATECH_FI_DATAHORA) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_DataHora(Var,&Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para impressao do Relatorio Gerencial
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente 25/09/2001  */
HB_FUNC( BEMATECH_FI_RELATORIOGERENCIAL) {
   char     ncgc [] = "|21|";
   int       erro, cond;
   char      resp [1024];
   unsigned char *txtger;
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   txtger = hb_parc(1);
   if (( erro = Bematech_FI_RelatorioGerencial(txtger,&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/* --------------------------------------- *
 * Funcao para Fechamento do Relatorio Gerencial
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente 25/09/2001  */
HB_FUNC( BEMATECH_FI_FECHARELATORIOGERENCIAL) {
   char     ncgc [] = "|21|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_FechaRelatorioGerencial(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }
/*--------------------------------------------------------------------------
 * Funcao para programar o horario de verao da impressora Fiscal
 * retornando variavel com 13 caracteres
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  26/07/2001 */

HB_FUNC(BEMATECH_FI_PROGRAMAHORARIOVERAO) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_ProgramaHorarioVerao(Var,&Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }
/*--------------------------------------------------------------------------
 * Funcao para verificar se a Impressora Fiscal esta com a opcao Truncamento
 * ativa [1=sim 2=nao]
 * retornando variavel com 13 caracteres
 * Comandos FlagShip interno ao prog em C 
 * Manoel Vicente  26/07/2001 */

HB_FUNC(BEMATECH_FI_PROGRAMATRUNCAMENTO) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_ProgramaTruncamento(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

HB_FUNC( BEMATECH_FI_PROGRAMAARREDONDAMENTO) {
   int lng;
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_ProgramaArredondamento(&Retorno)) != 0 ) {
      hb_ret();
   }
   Var[0] = (char)(Retorno[0]);
   Var[1] = (char)(Retorno[1]);
   Var[2] = (char)(Retorno[2]);
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver a data da ultima reducao Z.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(BEMATECH_FI_DATAULTIMAREDUCAO) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_DataUltimaReducao(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/* --------------------------------------- *
 * Funcao para ver a data do movimento.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(DTMOVIM_C) {
   char     ncgc [] = "|62|55|";
   int       erro, cond;
   char      resp [1024];
   int Retorno[4];
   char Var[3000];
   char Aux;
   memset(Var,  '\x0',3000);
   if (( erro = Bematech_FI_DataMovimento(Var, &Retorno)) != 0 ) {
      hb_ret();
   }
   hb_retc(Var);
 }

/*HB_FUNC(LERARQC) {
  int lng;
  unsigned char *nporta,*xfile,*nfile;
  int       erro, cond;
  int ptr;
  unsigned char *resp[101];
  char *pxarq;
  int Retorno[4];
  char Var[3000];
  char Aux;
  memset(Var,  '\x0',3000);
  resp[0] = 0;
  resp[1] = hb_parc(1);
  resp[2] = hb_parc(2);
  if (( erro = Siar_FI_Leitura(2,hb_parc(1) ,hb_parc(2))) != 0 ) {
      hb_ret();
   }
   hb_ret();
 }
*/
/* --------------------------------------- *
 * Funcao para ver a data do movimento.
 * Comandos FlagShip interno ao prog em C  */
HB_FUNC(LERARQ_C)
{ int count,c;
  FILE *IPFile;
  FILE *OPFile;
  IPFile = fopen(hb_parc(1),"r");
  OPFile = fopen(hb_parc(2),"w");
  while ((c = fgetc(IPFile)) != EOF) { fputc(c, OPFile); }
  fclose(IPFile);
  fclose(OPFile);
   hb_ret();
   }

rmg · Mensagem por **rmg** » 27 Out 2006 10:41

Wagner,

As rotinas que vc me mandou já é uma mão na roda.
Coloquei em um arquivo .C e compilei junto do meu makefile.
Mas surgiram alguns erros informando o seguinte, irei mostrar somente um pedaço do código:

...
lib300fi.c: In function `HB_FUN_BEMATECH_FI_TERMINAFECHAMENTOCUPOM':
lib300fi.c:261: warning: implicit declaration of function `Bematech_FI_TerminaFechamentoCupom'
lib300fi.c:252: warning: unused variable `lng'
lib300fi.c:254: warning: unused variable `cond'
lib300fi.c:255: warning: unused variable `resp'
lib300fi.c:258: warning: unused variable `Aux'
lib300fi.c: In function `HB_FUN_BEMATECH_FI_CANCELACUPOM':
lib300fi.c:275: error: syntax error before "erro"
lib300fi.c:281: warning: implicit declaration of function `Bematech_FI_CancelaCupom'
lib300fi.c:276: warning: unused variable `resp'
lib300fi.c:279: warning: unused variable `Aux'
lib300fi.c: In function `HB_FUN_BEMATECH_FI_CANCELAITEMANTERIOR':
lib300fi.c:294: error: syntax error before "erro"
lib300fi.c:300: warning: implicit declaration of function `Bematech_FI_CancelaItemAnterior'
...

O que poderia ser meu amigo?

Desde já lhe agradeço...

Mensagem por **vagucs** » 27 Out 2006 11:38

vc colocou o arquivo que eu te mandei junto com o outro fonte em C?

Como vc criou ele ai?

rmg · Mensagem por **rmg** » 27 Out 2006 13:52

Wagner,

Realmente a princípio eu tinha excluído meu arquivo .C e colocado sozinho o que vc me passou.
Mas agora, eu manti meu arquivo lib300fi.c, da mesma forma que baixei no site da bematech, peguei os fontes que vc me passou e criei um arquivo bematech.c. E os dois estão dentro do makefile.
Mas os erros persistem.

Estou fazendo da forma correta? Onde estou errando?

Resumindo, eu tenho dois arquivos .C . Um é o da bematech mesmo. E o outro é o que está com seus códigos. Os dois linkados dentro da makefile. Seria isto mesmo?

Obrigado pela sua paciência.

Mensagem por **vagucs** » 27 Out 2006 14:58

Usei este programa tem muito tempo, so para testes, funciona bem, veja que as warnings nao impedem seu programa de rodar, tente resolver o erro, corrigindo o fonte, eu compilava isto em linux e nao apresentava erro algum, mas faz tempo isto.

Eu usava um script shell para compilar era este abaixo

Código: Selecionar todos


#!/bin/sh
rm -f libbema.a
rm *.o -f
gcc -c -osiar9998.o -I/usr/include/xharbour siar9998.c
gcc -c -olib300fi.o lib300fi.c
ar cru libbema.a lib300fi.o siar9998.o
echo copiando...
cp libbema.a /usr/lib/xharbour

Isso gerava a lib LIBBEMA.A que era só colocar no script do xHarbour e usar a vontade, isto nao apresentava nenhuma linha de erro na tela, usava com Conectiva 10 e gcc 2.92 me parece.

rmg · Mensagem por **rmg** » 27 Out 2006 15:01

Olha só Wagner,

Eu que estava fazendo besteira.

Era só compilar junto mesmo.
Tava fazendo besteira. Estava copiando aqui no site e colando direto no "vi" pelo putty, aí fica difícil né. Aí quando fui olhar, tava faltando um monte de comandos. rsrs.

Mas agora já está compilando 100%. Cara, muito obrigado mesmo.

E o nosso Ipanema? Está como? Cara, tô com saudades velho... Vê se não vai esquecer dos amigos não, viu??? Abraço bem apertado pra vc e que Deus continue te iluminando e te abençoado.
Eu, vc pode ficar tranquilo que não esqueço de vc não. Nunca. Sinto sinceras saudades de vc, meu camarada.
Abraço bem apertado meu amigo.

Seu amigo de sempre,
Renato Martins Gomes.

Mensagem por **vagucs** » 27 Out 2006 15:15

Rapaz, nem sabia que o "rmg" era vc uai, por isso me chamou no MSN hoje né, eu nao tava no PC na hora, tomara que dê tudo certo ai, abraços.

dopi · Mensagem por **dopi** » 07 Nov 2006 17:48

Olá Colegas,

Talvez o link abaixo possa ser do interesse de quem precise ECF no Linux (até mesmo via SSH)

ACBrMonitor

Mensagem por **vagucs** » 07 Nov 2006 21:44

Daniel, vc mecheu na classe que começamos a fazer ai para o xHarbour falar com a ACBR? Colocou o controle de fluxo no protocolo? se tiver precisando de ajuda ainda, inicio do ano to lvire para viajar de novo, to com umas novidades para xHarbour aqui que acho que vc e o jeferson vão gostar.

dopi · Mensagem por **dopi** » 13 Nov 2006 09:20

Olá Wagner,

Fiz algumas melhorias na estabilidade do ACBrMonitor e várias correções no ACBrECF...

Ainda não inserir um check-sum no protocolo, mas até agora não foi necessário... não tive problemas de transmissão TCP/IP mesmo em redes remotas...

Quanto a Classe do ACBr para xHarbour, não terminei... pois estou usando um Fonte compatível com CLIPPER e xHarbour... (obviamente a comunicação TCP/IP com o ACBrMonitor está disponível apenas no xHarbour)

PC Toledo

ECF no Linux

ECF no Linux

Está quase...

ECF

Wagner, muito obrigado mesmo.