/******************************************************************************
* Funcao: resetPrint *
* "Abre" e configura comunicacao impressora interna do POS *
* *
* Retornos: POS_ERRO *
* POS_SUCESS *
******************************************************************************/
STAT
resetPrint ( void )
{
struct Opn_Blk mblk; /* estrutura de programacao da porta serial */
if (hPrint >= 0) /* Impressora Aberta */
{
close (hPrint); /* fecha */
hPrint = -1;
}
/* Abertura disposito */
if ((hPrint = open (DEV_COM4, 0)) < 0)
return POS_ERRO;
/* configura porta serial */
memset (&mblk,0,sizeof(mblk));
mblk.rate = Rt_19200;
mblk.format = Fmt_A8N1 | Fmt_RTS | Fmt_auto;
mblk.protocol = P_char_mode;
set_opn_blk( hPrint, &mblk);
SVC_WAIT ( 100 ); /* adormece por 100 ms */
/* Inicializacao da impressora. */
p3700_init (hPrint, 6);
SVC_WAIT ( 200 ); /* adormece por 200 ms */
p3700_select_font (hPrint, 3, 0); /* seleciona fonte 8x14 X 32 colunas */
return POS_SUCESS;
}
int main()
{
init();
{
char *ptr = 0, *ptr1 = 0, *ptr2 = 0, *ptr4 = 0, *ptr5 = 0, *ptr6 = 0, *ptr7 = 0;
// Test MALLOC
ptr = (char*)DEBUG_MALLOC(256);
strcpy(ptr, "ptr");
// Test MALLOC
ptr1 = (char*)DEBUG_MALLOC(256);
strcpy(ptr1, "ptr1");
// Test malloc
ptr2 = (char*)malloc(256);
strcpy(ptr2, "ptr2");
// Test new
int* ptr3 = DEBUG_NEW int(65);
{
// checkpoint_charlie takes care of the checkpoint, giving it a name,
// and dumping out any memory leaks detected after scope drop
leaks::checkpoint_charlie checkpoint1("CHECKPOINT 1");
// Test new[]
ptr4 = DEBUG_NEW char[256];
strcpy(ptr4, "ptr4");
ptr5 = DEBUG_NEW char[256];
strcpy(ptr5, "ptr5");
//}
//{
leaks::checkpoint_charlie checkpoint2("CHECKPOINT 2");
ptr6 = new char[256];
strcpy(ptr6, "ptr6");
ptr7 = (char*)DEBUG_MALLOC(256);
strcpy(ptr7, "ptr7");
ptr7 = (char*)DEBUG_REALLOC(ptr7, 256);
}
// Housekeeping
LOG_PRINTF(("Housekeeping"));
DEBUG_FREE(ptr);
DEBUG_FREE(ptr1);
free(ptr2);
delete ptr3;
delete [] ptr4;
delete [] ptr5;
delete [] ptr6;
// Dump the current leaks
DEBUG_DUMP();
}
while(true) SVC_WAIT(1000); // Stay here
}
/******************************************************************************
* Funcao: get_milli_sec *
* Retorna o numero de "ticks" de clock decorrido. *
* *
* Retornos: ticks em millisegundos *
******************************************************************************/
ulong
get_milli_sec ( void )
{
ulong millitm;
SVC_WAIT ( 10 );
SVC_TICKS ( 1, (long*)&millitm );
return ((ulong)(millitm * 1)); /* milezimos */
}
/******************************************************************************
* Funcao: resetSDLC *
* "Abre" e configura modem SDLC *
* *
* Retornos: POS_ERRO *
* POS_SUCESS *
******************************************************************************/
STAT
resetSDLC ( void )
{
int i;
char aux[16];
struct Opn_Blk mblk;
if (stsSDLC == SDLC_RESETED) return POS_SUCESS; /* Se dispositivo resetado apenas retorna */
if (hComModem >= 0) /* Com modem Aberta */
{
get_port_status (hComModem, aux); /* Obtem status do modem */
if ((aux[3] & 0x08) != 0) /* Portadora presente! */
{
aux[0] = 0; /* derruba DTR & RTS */
set_serial_lines ( hComModem, aux );
}
xmdm_hangup (hComModem, -1, 0); /* fecha antes de programar */
xmdm_close (hComModem, 0, 0);
hComModem = -1;
SVC_WAIT ( 100 );
}
hComModem = open (DEV_COM3, 0); /* abertura */
debugH ("handle Modem:[%d]\n", hComModem);
aux[0] = 0; /* derruba DTR & RTS */
set_serial_lines ( hComModem, aux );
/*
* Define: Baud Rate + Paridade + protocolo
*/
mblk.rate = Rt_19200;
mblk.format = Fmt_A7E1 | Fmt_DTR;
mblk.protocol = P_char_mode;
set_opn_blk ( hComModem, &mblk );
for (i = AT_INIT_SDLC; i <= AT_FIN_SDLC; i++)
{
if (ATCmdSDLC (i, 0) != POS_SUCESS)
{
debugH ("ERRO ATCMD\n", hComModem);
return POS_ERRO;
}
}
stsSDLC = SDLC_RESETED;
return POS_SUCESS;
}
// *Date params will be deleted by this function
closure* telaRelatorio(closure* cl, char* beginDate, char* endDate)
{
relatorio_t* relatorio;
int isFinished = FALSE, refresh = TRUE;
char buf[MAXBUF];
const char* evId = (const char*)cl->param;
point center = getScreenCenter();
memset (buf,'\0',sizeof(buf));
snprintf(buf,MAXBUF,"Gerando relatório...");
WRITE_AT(buf,center.x-10,center.y*2-1);
CHECK(NULL!=evId);
CHECK(SUCCESS==initAmbiente());
CHECK(SUCCESS==get_relatorio(beginDate,endDate,evId,&relatorio));
CHECK(NULL!=relatorio);
while (!isFinished) {
char szKey;
long lOSEvent = wait_event();
if (refresh /*if there's no check it will keep rewriting constantly*/) {
clrscr ();
show_bmp(LOGO_FILENAME);
WRITE_AT_CENTERED("Relatorio",center.x,center.y-3);
snprintf(buf,MAXBUF,"Inicio: %s\0",relatorio->begin_date);
WRITE_AT(buf,center.x-10,center.y);
snprintf(buf,MAXBUF,"Fim: %s\0",relatorio->end_date);
WRITE_AT(buf,center.x-10,center.y+1);
snprintf(buf,MAXBUF,"Valor: %s\0",valor_withCurrency(relatorio->value));
WRITE_AT(buf,center.x-10,center.y+2);
WRITE_AT("1> Imprimir",center.x-10,center.y+4);
WRITE_AT("#> Tela Anterior",center.x-10,center.y+5);
refresh = FALSE;
}
if (lOSEvent & EVT_KBD) {
if (read(g_conHandle, &szKey, 1) > 0) {
szKey = convertKey (szKey);
if (KEY_HASH == szKey || KEY_BACK == szKey || KEY_ESC == szKey) {
isFinished = TRUE;
} else if (szKey == KEY_1) {
char msg[MAX_BUFF_SIZE];
if(relatorio_hasError(relatorio, msg, MAX_BUFF_SIZE)) {
clrscr();
write_multilineCentered(msg);
SVC_WAIT(2000);
refresh = TRUE;
} else {
CHECK(SUCCESS==print_relatorio(relatorio));
}
}
}
}
}
delete_relatorio(relatorio);
return popClosure(cl);
}
char KeyWait(int col, int row)
{
// Clear keyboard and keywait
get_console(1);
unsigned t = 0;
while(!HasKey())
{
if (read_ticks() > t + 1000)
{
DisplayBattery(col, row);
t = read_ticks();
}
SVC_WAIT(50);
}
return GetKey();
}
/******************************************************************************
* Funcao: debugH *
* Funcao que imprime conteudo de variaveis para auxilio *
* ao desenvolvedor (habilitado quando utilizado define DEBUG_H) *
******************************************************************************/
void
debugH ( char * acFormato, ... )
{
#ifdef DEBUG_H
char acMostrar[1024];
va_list vArgs;
va_start (vArgs, acFormato);
vsprintf (acMostrar, acFormato, vArgs);
va_end (vArgs);
if (hPrint >= 0)
p3700_print (hPrint, (uchar *)acMostrar);
SVC_WAIT (50);
#endif
}
/******************************************************************************
* Funcao: sndSDLC *
* envia bytes para o modem SDLC *
* *
* Retornos: POS_SUCESS - transmissao sem erros *
* POS_ERRO - falha transmissao *
* POS_CANCEL - timeout trasmissao *
******************************************************************************/
STAT
sndSDLC ( char * inBuf, int sz )
{
char xbuff[32];
ulong tempoCOM;
int st;
tempoCOM = COM_TIMEOUT * 1000; /* tempo em milisegundos */
tempoCOM += get_milli_sec (); /* hora de vencimento do timeout */
flushMDM (); /* elimina buffer interno de recebimento antes do envio */
while (sz > 0 && tempoCOM >= get_milli_sec ())
{
for (st = 0; get_port_status (hComModem, xbuff) != 0 && st < 50; st++)
{
SVC_WAIT ( 20 );
}
st = sz; /* tamanho do fragmento */
if (write (hComModem, inBuf, st) > 0)
{ /* OK. transferencia feita */
inBuf += st;
sz -= st;
}
else /* FALHA. Houve algum problema */
{
return POS_ERRO;
}
}
if ( sz > 0 ) /* saida por time out */
return POS_CANCEL;
tmoRespSDLC = read_ticks () + 60000l; /* aciona time-out de P2 */
return POS_SUCESS;
}
void Platform_yield_ms(unsigned int ms) {
// If there is other processing that should be called while the UI wants to sleep(e.g. network comms), this should be called here.
SVC_WAIT(ms);
}
void Platform_sleep_ms(unsigned int ms) {
SVC_WAIT(ms);
}
ret_code loginScreenInit(int* cancel)
{
ret_code ret = ERROR;
point top, bottom;
const char* err;
signed char login_buf[200];
char pwd_buf[100];
short len;
int ret_val;
memset (login_buf, '\0', sizeof (login_buf));
memset (pwd_buf, '\0', sizeof (pwd_buf));
getScreenDims(&top, &bottom);
for (;SUCCESS!=ret;) {
int ret_val, len, height = bottom.y/2, width = bottom.x/2;
memset (login_buf, '\0', sizeof (login_buf));
window(top.x,top.y,bottom.x,bottom.y);
clrscr ();
CHECK(SUCCESS==set_cursor(1));
show_bmp(LOGO_FILENAME);
WRITE_AT("Operador:", 3, height-1);
WRITE_AT("Senha:", 6, height);
window (13, height-1, 29, height-1);
gotoxy (1, 1);
ret_val = getkbd_entry (h_clock, "", (signed char *) login_buf, 0/*no timeout*/, NUMERIC,
(char *) szKeyMapVx680, sizeof (szKeyMapVx680), 10, 1);
if (ret_val>0) {
ret = op_checkId(login_buf,NULL,&err);
if (SUCCESS!=ret) {
CHECK(SUCCESS==set_cursor(0));
clrscr();
window(top.x,top.y,bottom.x,bottom.y);
WRITE_AT(err, bottom.x/2-strlen(err)/2, 5);
SVC_WAIT(2000);
} else {
// Now get the pwd
window (13, height, 29, height);
gotoxy(1, 1);
ret_val = getkbd_entry (h_clock, "", (signed char *) pwd_buf, 0/*no timeout*/, NUMERIC,
(char *) szKeyMapVx680, sizeof (szKeyMapVx680), 10, 1);
if (ret_val>0) {
ret = op_checkId(login_buf,pwd_buf,&err);
if (SUCCESS!=ret) {
CHECK(SUCCESS==set_cursor(0));
clrscr();
window(top.x,top.y,bottom.x,bottom.y);
WRITE_AT(err, bottom.x/2-strlen(err)/2, 5);
SVC_WAIT(2000);
}
}
}
} else if(-3==ret_val) {
/* go to prev screen when user presses ESC*/
*cancel = 1;
ret = SUCCESS;
}
}
CHECK(SUCCESS==set_cursor(0));
window(top.x,top.y,bottom.x,bottom.y);
if (0==*cancel) {
memset (login_buf, '\0', sizeof (login_buf));
sprintf (login_buf, "Bem-vindo %s", g_operador);
SCREEN_WARNING(login_buf);
}
return ret;
}
/******************************************************************************
* Funcao: recvSDLC *
* obtem bytes recebidos pelo modem SDLC *
* *
* Retornos: POS_SUCESS - transmissao sem erros *
* POS_ERRO - falha transmissao *
* POS_CANCEL - timeout trasmissao *
******************************************************************************/
STAT
recvSDLC ( char * outBuf, int * sz )
{
// Devido ao teste SDLC, funcao de recepcao esta em sua forma mais simples sem considerar tamanho de resposta ou protocolos...
char respBuf[1024];
int ct = 0;
if (!outBuf && !sz)
return POS_ERRO;
while (TRUE)
{
get_port_status ( hComModem, respBuf ); /* status da portadora */
if ((respBuf[3] & 0x08) == 0) /* Portadora NAO presente! caiu conexao*/
{
debugH ("[recvSDLC]PORTADORA NAO PRESENTE\n");
return POS_CANCEL;
}
/* Verifica se ha dados no buffer fisico da COM. */
SVC_WAIT (20);
get_port_status (hComModem, (char *)respBuf );
if (respBuf[0] == 0) /* NAO ha novos dados */
{
if (read_ticks () < tmoRespSDLC)
{
continue;
}
else
{
debugH ("[recvSDLC]OCORREU TIMEOUT P2\n");
return POS_ERRO; /* excedeu time-out */
}
}
else
break; /* chegou dados */
}
/* Ha dados. Transfere para o buffer sincrono. */
*sz = 0;
SVC_WAIT (1000);
while ((ct = read (hComModem, &outBuf[*sz], 1024)) > 0) /* desconsiderado tratamento de fragmentos */
*sz += ct; /* desconsiderado tratamento de lixo */
if (*sz > 0)
{
debugH ("[recvSDLC]chegou [%d]bytes\n", *sz);
return POS_SUCESS;
}
if (ct < 0)
{
debugH ("[recvSDLC]falha recepcao\n", *sz);
return POS_CANCEL;
}
return POS_ERRO;
}
/******************************************************************************
* Funcao: chk_sdlc *
* "verifica status da conexao SDLC *
* *
* Retornos: POS_ERRO *
* POS_SUCESS *
******************************************************************************/
STAT
chk_sdlc ( void )
{
struct Opn_Blk Com3ob;
int status;
int ct;
char mdm_buff[42];
STAT ret;
get_port_status (hComModem, mdm_buff);
if ((mdm_buff[3] & DCD_ON) == 0)
{
ret = ATCmdSDLC (-1, 2); /* ainda nao conectado, obtem resposta */
debugH ("chk_sdlc-ret[0x%0.4X]\n", ret);
if (ret == SDLC_ATCMD_TMO || ret == SDLC_CONNECTED)
{
if (read_ticks () < tmoDiscSDLC)
return POS_SUCESS; /* discando... */
else /* time-out discagem */
{
stsSDLC = SDLC_NO_ANSWER;
return POS_ERRO;
}
}
stsSDLC = ret;
debugH ("[chk_sdlc]ERRO_DISC:stsSDLC=0x%0.4X\n", stsSDLC);
return POS_ERRO; /* falha */
}
debugH ("SDLC_CONECTADO\n");
/* portadora presente, trata outros sinais */
ct = 5;
do {
mdm_buff[0] = DTR_RTS_ON;
status = set_serial_lines (hComModem, mdm_buff);
SVC_WAIT (100);
} while (status != 0 && --ct > 0);
ct = 5;
do {
status = get_port_status (hComModem, mdm_buff);
SVC_WAIT (20);
} while ((mdm_buff[3] & CTS_ON) == 0 && --ct > 0);
Com3ob.rate = Rt_19200;
Com3ob.format = Fmt_SDLC | Fmt_DTR | Fmt_RTS;
Com3ob.protocol = P_sdlc_mode;
Com3ob.trailer.sdlc_parms.address = 0x30;
Com3ob.trailer.sdlc_parms.option = P_sdlc_sec;
ct = 5;
do {
status = set_opn_blk (hComModem, &Com3ob);
SVC_WAIT (50);
} while (status != 0 && --ct > 0);
ct = 5;
do {
mdm_buff[0] = DTR_RTS_ON;
status = set_serial_lines (hComModem, mdm_buff);
SVC_WAIT (100);
} while (status != 0 && --ct > 0);
if (status == 0) status = 5;
stsSDLC = SDLC_CONNECTED;
debugH ("SDLC_SINCRONIZADO\n");
return ( POS_SUCESS ); /* conexao OK */
}
/******************************************************************************
* Funcao: waitTime *
* "adormece" pelo tempo determinado em t *
* *
* t : tempo em milisegundos *
* *
* Retornos: POS_SUCESS *
******************************************************************************/
STAT
waitTime ( ulong t)
{
SVC_WAIT (t);
return POS_SUCESS;
}
void show_data_incorreta(const point* bottom)
{
const char* msg = "Data Incorrecta";
WRITE_AT(msg,bottom->x/2-strlen(msg)/2,bottom->y-1);
SVC_WAIT(1000);
}
