/****************************************************************************** * 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); }