//--------------------------------------------------------------------------- // DIALOGO CON EL BUR BROWN //--------------------------------------------------------------------------- #include #include "Dialogo.h" #include "Principal.h" //--------------------------------------------------------------------------- #pragma hdrstop #pragma package(smart_init) //--------------------------------------------------------------------------- DWORD DWContadorID,DWAUTID,DWPSEID,DWPSSID,DWALBID; BYTE byTiempoEsperaAUT; BYTE byTiempoEsperaPSE; BYTE byTiempoEsperaPSS; BYTE byTiempoEsperaALB; BYTE byTiempoEsperaRespOCA; char *pszPeriodicaBBDIA[NUM_PERIODICA_AUT]; //--------------------------------------------------------------------------- // void DialogoAutorizacion(hDBIDb Form1->hBaseDatos) // Entrada: // hDBIDb Form1->hBaseDatos:Puntero a la Base de Datos //--------------------------------------------------------------------------- void DialogoAutorizacion(void) { FILE *pTransfer; TRAPERDat sTRAPERIODICADat[NUM_MAXIMO_PERIODICA]; TRAOCADat sTRAOCASIONALDat; BYTE byi,byj,byEstado,byNumPer; DatosAutorizacion sDatos; char sSentencia[TAM_MAXIMO_OCASIONAL]; char sNumeroEle[3]; char *pszMensaje; char cServidor,cReferencia,cReferenciaTemp,cDatoCorrecto; char cDiez[2],cTrece[2]; char sDatoTecleado[NUM_MAX_TECLAS]; long lDesplazamiento; int nValorPERBBDIA,nError; bool bRespuestaPER; bool bFinalizaAUT,bTipoEntrada,bRepetido; //Inicializamos variables cDiez[0]=10; cDiez[1]=0; cTrece[0]=13; cTrece[1]=0; byEstado=0; cServidor='1'; cReferencia=1; nValorPERBBDIA=0; //Leemos la estructura de la periodica Transfer->LeerEstructura(sTRAPERIODICADat,&sTRAOCASIONALDat); //Obtenemos el Servidor con el que vamos a trabajar byNumPer=0; while(strcmp(sTRAPERIODICADat[byNumPer].cTipoIDTRAPER,"BBRAUT") && byNumPerEscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); //Inicializamos el caracter y esperamos a que sea la respuesta correcta memset(pszPeriodicaBBDIA[0],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; //Mientras la referencia o el dato no sean los correctos while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[0],sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat,1,pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[0]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[0]+UBICACION_DATO_CORRECTO); } if(byTiempoEsperaAUT) { //Ponemos por defecto el Numero de Elemento de Cisterna strcpy(sNumeroEle,NUM_ELE_CIS_TAR); memset(sNumeroEle,0,2); //Obtenemos el valor de la respuesta if(bTipoEntrada) { nValorPERBBDIA=atoi(pszPeriodicaBBDIA[0]+UBICACION_DATO_LEIDO_TAR); memcpy(sNumeroEle,pszPeriodicaBBDIA[0]+UBICACION_ELEMENTO_TAR,2); } else nValorPERBBDIA=atoi(pszPeriodicaBBDIA[0]+UBICACION_DATO_LEIDO_TEC); //Comprobamos si la respuesta es Correcta if( !strstr(pszPeriodicaBBDIA[0]+UBICACION_DATO_LEIDO_TEC,"F") && nValorPERBBDIA>0 && nValorPERBBDIA<10000 && strstr(sNumeroEle,NUM_ELE_CIS_TAR) ) { bRespuestaPER=true; //Comprobamos la Cisterna Formatea(sDatoTecleado,NUM_MAX_TECLAS,"%04d",nValorPERBBDIA); nError=Autorizacion->ComprobarCisterna(sDatoTecleado,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_CIS_CORRECTO) byEstado=1; else MostrarResultado(cServidor,"BBRAUT",nError); } else if( !strstr(sNumeroEle,NUM_ELE_CIS_TAR) ) MostrarResultado(cServidor,"BBRAUT",TAR_CIS_INVALIDA); else { if( strstr(pszPeriodicaBBDIA[0]+UBICACION_DATO_LEIDO_TEC,"F5") ) MostrarResultado(cServidor,"BBRAUT",DIA_CANCELADO); else if( strstr(pszPeriodicaBBDIA[0]+UBICACION_DATO_LEIDO_TEC,"F") ) MostrarResultado(cServidor,"BBRAUT",TEC_FUNCION_INVALIDA); else MostrarResultado(cServidor,"BBRAUT",ENT_TECLADO_INVALIDA); } } } break; //************************************SEGUNDA PARTE DEL DIALOGO****************************/ case 1: //Inicializamos la sentencia memset(sSentencia,0,TAM_MAXIMO_OCASIONAL); memset(sDatoTecleado,0,NUM_MAX_TECLAS); //Conseguimos la referencia ConseguirReferencia(&cReferencia); //Peticion del codigo del Conductor if(bTipoEntrada) Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TARJETA,cReferencia,"14","Intro Tarj Con"); else Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TECLADO,cReferencia,"13","Intro Cod Con"); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); //Inicializamos el caracter y esperamos a que sea la respuesta correcta memset(pszPeriodicaBBDIA[1],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; byTiempoEsperaAUT=30; while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[1], sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat , 1, pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[1]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[1]+UBICACION_DATO_CORRECTO); } //Si no paso el tiempo de espera if(byTiempoEsperaAUT) { //Ponemos por defecto el Numero de Elemento de Cisterna strcpy(sNumeroEle,NUM_ELE_CON_TAR); memset(sNumeroEle,0,2); //Obtenemos el tamaņo de la respuesta if(bTipoEntrada) { nValorPERBBDIA=atoi(pszPeriodicaBBDIA[1]+UBICACION_DATO_LEIDO_TAR); memcpy(sNumeroEle,pszPeriodicaBBDIA[1]+UBICACION_ELEMENTO_TAR,2); } else nValorPERBBDIA=atoi(pszPeriodicaBBDIA[1]+UBICACION_DATO_LEIDO_TEC); //Comprobamos si la respuesta es Correcta if( !strstr(pszPeriodicaBBDIA[1]+UBICACION_DATO_LEIDO_TEC,"F") && nValorPERBBDIA>0 && nValorPERBBDIA<10000 && strstr(sNumeroEle,NUM_ELE_CON_TAR) ) { bRespuestaPER=true; //Comprobamos el Conductor Formatea(sDatoTecleado,NUM_MAX_TECLAS,"%04d",nValorPERBBDIA); nError=Autorizacion->ComprobarConductor(sDatoTecleado,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_CON_CORRECTO) byEstado=2; else MostrarResultado(cServidor,"BBRAUT",nError); } else if( !strstr(sNumeroEle,NUM_ELE_CIS_TAR) ) MostrarResultado(cServidor,"BBRAUT",TAR_CON_INVALIDA); else if( strstr(pszPeriodicaBBDIA[1]+UBICACION_DATO_LEIDO_TEC,"F5") ) { MostrarResultado(cServidor,"BBRAUT",DIA_CANCELADO); byEstado=0; } else { if( strstr(pszPeriodicaBBDIA[1]+UBICACION_DATO_LEIDO_TEC,"F") ) MostrarResultado(cServidor,"BBRAUT",TEC_FUNCION_INVALIDA); else MostrarResultado(cServidor,"BBRAUT",ENT_TECLADO_INVALIDA); } } else { MostrarResultado(cServidor,"BBRAUT",SUP_TIEMPO_ENT_TECLADO); byEstado=0; } break; //************************************TERCERA PARTE DEL DIALOGO****************************/ case 2: //Inicializamos las variables memset(sSentencia,0,TAM_MAXIMO_OCASIONAL); //Conseguimos la referencia ConseguirReferencia(&cReferencia); //Peticion del codigo de Tractor Autorizacion->LeerEstructura(&sDatos); pszMensaje = (char *) malloc ( sizeof("Tractor ") + sizeof(sDatos.pszMatriculaTraCis) ); strcpy(pszMensaje,"TRAC. "); StrCat(pszMensaje,sDatos.pszMatriculaTraCis); Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TECLADO,cReferencia,"16",pszMensaje); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); free(pszMensaje); //Guardamos el valor adecuado memset(pszPeriodicaBBDIA[2],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; byTiempoEsperaAUT=30; while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[2], sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat, 1, pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[2]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[2]+UBICACION_DATO_CORRECTO); } //Si no paso el tiempo de espera if(byTiempoEsperaAUT) { //Comprobamos si la respuesta es Correcta if( strstr(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC,"F4") ) { bRespuestaPER=true; //Comprobamos el Tractor nError=Autorizacion->ComprobarTractor(sDatos.pszMatriculaTraCis,NULL,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_TRA_CORRECTO) byEstado=3; else MostrarResultado(cServidor,"BBRAUT",nError); } else if (strstr(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC,"F8") ) { //Inicializamos las variables memset(sSentencia,0,TAM_MAXIMO_OCASIONAL); memset(sDatoTecleado,0,NUM_MAX_TECLAS); //Pedimos por codigo por teclado ConseguirReferencia(&cReferencia); //Pedimos memoria para el mensaje pszMensaje = (char *) malloc ( sizeof("Intro Cod Tract") ); strcpy(pszMensaje,"Intro Cod Tract"); Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TECLADO,cReferencia,"15",pszMensaje); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); //Liberamos mensaje free(pszMensaje); //Guardamos el valor adecuado memset(pszPeriodicaBBDIA[2],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; byTiempoEsperaAUT=30; while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[2], sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat, 1, pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[2]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[2]+UBICACION_DATO_CORRECTO); } //Si no paso el tiempo de espera if(byTiempoEsperaAUT) { //Obtenemos el tamaņo de la respuesta nValorPERBBDIA=atoi(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC); if( !strstr(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC,"F") && nValorPERBBDIA>0 && nValorPERBBDIA<1000 ) { bRespuestaPER=true; //Comprobamos el Conductor Formatea(sDatoTecleado,NUM_MAX_TECLAS,"%03d",nValorPERBBDIA); nError=Autorizacion->ComprobarTractor(NULL,sDatoTecleado,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_TRA_CORRECTO) byEstado=3; else MostrarResultado(cServidor,"BBRAUT",nError); } else MostrarResultado(cServidor,"BBRAUT",TEC_FUNCION_INVALIDA); } else { MostrarResultado(cServidor,"BBRAUT",SUP_TIEMPO_ENT_TECLADO); byEstado=0; } } else if (strstr(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC,"F5") ) { MostrarResultado(cServidor,"BBRAUT",DIA_CANCELADO); byEstado=0; } else { if (strstr(pszPeriodicaBBDIA[2]+UBICACION_DATO_LEIDO_TEC,"F1") ) MostrarResultado(cServidor,"BBRAUT",TEC_FUNCION_INVALIDA); else MostrarResultado(cServidor,"BBRAUT",ENT_TECLADO_INVALIDA); } } else { MostrarResultado(cServidor,"BBRAUT",SUP_TIEMPO_ENT_TECLADO); byEstado=0; } break; //************************************CUARTA PARTE DEL DIALOGO*****************************/ case 3: //Inicializamos las variables memset(sSentencia,0,TAM_MAXIMO_OCASIONAL); memset(sDatoTecleado,0,NUM_MAX_TECLAS); //Conseguimos la referencia ConseguirReferencia(&cReferencia); //Peticion del codigo de Suministrador Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TECLADO,cReferencia,"13","Intro Cod Sum"); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); //Guardamos el valor adecuado memset(pszPeriodicaBBDIA[3],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; byTiempoEsperaAUT=30; while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[3], sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat, 1, pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[3]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[3]+UBICACION_DATO_CORRECTO); } //Si no paso el tiempo de espera if(byTiempoEsperaAUT) { //Obtenemos el tamaņo de la respuesta nValorPERBBDIA=atoi(pszPeriodicaBBDIA[3]+UBICACION_DATO_LEIDO_TEC); //Comprobamos si la respuesta es Correcta if( !strstr(pszPeriodicaBBDIA[3]+UBICACION_DATO_LEIDO_TEC,"F") && nValorPERBBDIA>0 && nValorPERBBDIA<10 ) { bRespuestaPER=true; //Comprobamos el Suministrador Formatea(sDatoTecleado,NUM_MAX_TECLAS,"%01d",nValorPERBBDIA); nError=Autorizacion->ComprobarSuministrador(sDatoTecleado,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_SUM_CORRECTO) byEstado=4; else MostrarResultado(cServidor,"BBRAUT",nError); } else if( strstr(pszPeriodicaBBDIA[3]+UBICACION_DATO_LEIDO_TEC,"F5") ) { MostrarResultado(cServidor,"BBRAUT",DIA_CANCELADO); byEstado=0; } else { if( strstr(pszPeriodicaBBDIA[3]+UBICACION_DATO_LEIDO_TEC,"F") ) MostrarResultado(cServidor,"BBRAUT",TEC_FUNCION_INVALIDA); else MostrarResultado(cServidor,"BBRAUT",ENT_TECLADO_INVALIDA); } } else { MostrarResultado(cServidor,"BBRAUT",SUP_TIEMPO_ENT_TECLADO); byEstado=0; } break; //************************************QUINTA PARTE DEL DIALOGO*****************************/ case 4: //Inicializamos el numero de pedidos byi=4; byTiempoEsperaAUT=30; bFinalizaAUT=false; while(byTiempoEsperaAUT && !bFinalizaAUT) { //Inicializamos la respuesta correcta bRespuestaPER=false; byTiempoEsperaAUT=30; //Mientras no haya respuesta correcta o timeout while( !bRespuestaPER && byTiempoEsperaAUT ) { //Inicializamos las variables memset(sSentencia,0,TAM_MAXIMO_OCASIONAL); memset(sDatoTecleado,0,NUM_MAX_TECLAS); //Conseguimos la referencia ConseguirReferencia(&cReferencia); //Peticion del numero de Pedido //Formateamos la sentencia Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,"BBRAUT",BB_ENTRADA_TECLADO,cReferencia,"16","Intro Num Pedido"); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,"BBRAUT") ); //Guardamos el valor adecuado memset(pszPeriodicaBBDIA[byi],0,sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat); cReferenciaTemp=0; cDatoCorrecto='0'; byTiempoEsperaAUT=30; while( (cReferenciaTemp!=cReferencia || cDatoCorrecto!='S') && byTiempoEsperaAUT) { //Nos situamos en la posicion del Bur Brown de Autorizacion fseek(pTransfer, lDesplazamiento, SEEK_SET); //Leemos el caracter de referencia fread(pszPeriodicaBBDIA[byi], sTRAPERIODICADat[byNumPer].lTamPeriodicaTRAPERDat, 1, pTransfer); cReferenciaTemp=*(pszPeriodicaBBDIA[byi]+UBICACION_REFERENCIA); cDatoCorrecto=*(pszPeriodicaBBDIA[byi]+UBICACION_DATO_CORRECTO); } //Si no paso el tiempo de espera if(byTiempoEsperaAUT) { //Obtenemos el tamaņo de la respuesta nValorPERBBDIA=atoi(pszPeriodicaBBDIA[byi]+UBICACION_DATO_LEIDO_TEC); //Comprobamos si la respuesta es Correcta if( !strstr(pszPeriodicaBBDIA[byi]+UBICACION_DATO_LEIDO_TEC,"F") && nValorPERBBDIA>0 && nValorPERBBDIA<10000000000 ) { bRespuestaPER=true; //Comprobamos el Pedido itoa(nValorPERBBDIA,sDatoTecleado,10); nError=Autorizacion->ComprobarPedidos(sDatoTecleado,Form1->hBaseDatos); //Si fue correcto pasamos al siguiente estado if(nError==AUT_ORC_CORRECTO) { bRepetido=false; for(byj=4;byj4) MostrarResultado(cServidor,"BBRAUT",OPERACION_OK); else { MostrarResultado(cServidor,"BBRAUT",AUT_SIN_PED_SELECCIONADOS); bFinalizaAUT=false; bRespuestaPER=false; } } else if( strstr(pszPeriodicaBBDIA[byi]+UBICACION_DATO_LEIDO_TEC,"F5") ) MostrarResultado(cServidor,"BBRAUT",DIA_CANCELADO); } } } else MostrarResultado(cServidor,"BBRAUT",SUP_TIEMPO_ENT_TECLADO); } } byEstado=0; break; } //************************************TERMINAMOS LA FUNCION********************************/ } //Cerramos el fichero fclose(pTransfer); Sleep(100); } } //--------------------------------------------------------------------------- void DialogoPesoEntrada(void) { //Bucle infinito while(1) { Sleep(100); } } //--------------------------------------------------------------------------- void DialogoPesoSalida(void) { //Bucle infinito while(1) { Sleep(100); } } //--------------------------------------------------------------------------- void DialogoAlbaran(void) { //Bucle infinito while(1) { Sleep(100); } } //--------------------------------------------------------------------------- bool ComprobarTecladoTarjeta(void) { dbiTabla TPrm; bool bTipoEntrada; char *pszTipoEntrada; //Damos por defecto que es Tarjeta bTipoEntrada=true; //Reservamos memoria para la Tolerancia AbrirTablaBDE(&TPrm,"SIMICPRM",NULL,false,Form1->hBaseDatos); pszTipoEntrada=ReservarMemoria(&TPrm,"PRMTACPRM"); LeerCampoNBDE(&TPrm,"PRMTACPRM",pszTipoEntrada,NULL); CerrarTablaBDE(&TPrm); if( !strcmp(pszTipoEntrada,"T") ) bTipoEntrada=false; return bTipoEntrada; } //--------------------------------------------------------------------------- void Temporizador(void) { //Inicializamos los contadores de tiempo byTiempoEsperaAUT=0; byTiempoEsperaPSE=0; byTiempoEsperaPSS=0; byTiempoEsperaALB=0; byTiempoEsperaRespOCA=0; //4 lineas temporales byTiempoEsperaPSE=30; byTiempoEsperaPSS=20; byTiempoEsperaALB=10; while(1) { if(byTiempoEsperaAUT) byTiempoEsperaAUT--; if(byTiempoEsperaPSE) byTiempoEsperaPSE--; if(byTiempoEsperaPSS) byTiempoEsperaPSS--; if(byTiempoEsperaALB) byTiempoEsperaALB--; if(byTiempoEsperaRespOCA) byTiempoEsperaRespOCA--; //Los 4 Form son temporales para ver que funciona Form1->Edit2->Text=byTiempoEsperaAUT; Form1->Edit3->Text=byTiempoEsperaPSE; Form1->Edit4->Text=byTiempoEsperaPSS; Form1->Edit5->Text=byTiempoEsperaALB; Sleep(TIEMPO_CONTADOR_SEGUNDO); } } //--------------------------------------------------------------------------- BYTE CargarThreads(void) { BYTE byValorDevuelto; //Inicializamos las variables byValorDevuelto=0; //Inicializamos el Thread de contadores del Dialogo Form1->HDContadores=CreateThread( 0, 0, (LPTHREAD_START_ROUTINE) Temporizador, 0, 0, &DWContadorID); if(Form1->HDContadores==0) byValorDevuelto=THREAD_CONT_NO_INICIADO; //Inicializamos el Thread de Autorizacion Form1->HDAUT=CreateThread( 0, 0, (LPTHREAD_START_ROUTINE) DialogoAutorizacion, 0, 0, &DWAUTID); if(Form1->HDAUT==0) byValorDevuelto=THREAD_AUT_NO_INICIADO; //Inicializamos el Thread del Peso de Entrada Form1->HDPSE=CreateThread( 0, 0, (LPTHREAD_START_ROUTINE) DialogoPesoEntrada, 0, 0, &DWPSEID); if(Form1->HDPSE==0) byValorDevuelto=THREAD_PSE_NO_INICIADO; //Inicializamos el Thread del Peso de Salida Form1->HDPSS=CreateThread( 0, 0, (LPTHREAD_START_ROUTINE) DialogoPesoSalida, 0, 0, &DWPSSID); if(Form1->HDPSS==0) byValorDevuelto=THREAD_PSS_NO_INICIADO; //Inicializamos el Thread del Albaran Form1->HDALB=CreateThread( 0, 0, (LPTHREAD_START_ROUTINE) DialogoAlbaran, 0, 0, &DWALBID); if(Form1->HDALB==0) byValorDevuelto=THREAD_ALB_NO_INICIADO; return byValorDevuelto; } //--------------------------------------------------------------------------- void TerminarThread(HANDLE ThreadID) { bool bResult; BYTE byi; DWORD dwEstado; if(ThreadID!=NULL) { bResult = GetExitCodeThread(ThreadID,&dwEstado); if(bResult && (dwEstado == STILL_ACTIVE) ) { if(ThreadID==Form1->HDAUT) { //Pedimos memoria para la Periodica for(byi=0;byiEscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,pszTipoID) ); } //-------------------------------------------------------------------------------------------- void ConseguirReferencia(char *cReferencia) { (*cReferencia)++; if( (*cReferencia)==100 ) (*cReferencia)=1; } //-------------------------------------------------------------------------------------------- bool EsperarRespuestaOcasional(char cServidor,char *pszTipoId) { bool bRespuestaOCA,bRespuestaOk; char sTexto[TAM_MAXIMO_OCASIONAL]; char sRespuestaOCA[TAM_MAXIMO_OCASIONAL];//Estructura de la respuesta //Inicializamos las variables memset(sRespuestaOCA,0,TAM_MAXIMO_OCASIONAL); memset(sTexto,0,TAM_MAXIMO_OCASIONAL); bRespuestaOCA=false; bRespuestaOk=false; //Asignamos la respuesta que esperamos sRespuestaOCA[0]=cServidor; memcpy(sRespuestaOCA+1,pszTipoId,6); sRespuestaOCA[7]='S'; byTiempoEsperaRespOCA=2; //Mientras la Respuesta no sea ok while(!bRespuestaOk && byTiempoEsperaRespOCA) { //Mientras no haya respuesta leemos while(!bRespuestaOCA && byTiempoEsperaRespOCA) { Transfer->LeerOcasional(sTexto,NUM_OCASIONAL); if(strcmp(sTexto,"")) bRespuestaOCA=true; } //Si la respuesta fue correcta if( !memcmp(sRespuestaOCA,sTexto,7)) bRespuestaOk=true; } return bRespuestaOk; } //-------------------------------------------------------------------------------------------- void MostrarResultado(char cServidor,char *sTipoID,int nResultado) { char cDiez[2],cTrece[2],sTamano[3],cReferencia; char sSentencia[TAM_MAXIMO_OCASIONAL]; char *pszMensaje; bool bEntro; //Inicializamos variables cDiez[0]=10; cDiez[1]=0; cTrece[0]=13; cTrece[1]=0; cReferencia=1; bEntro=true; //En funcion del Resultado enviamo una cadena switch(nResultado) { case AUT_CIS_VALOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO EXISTE") ); strcpy(pszMensaje,"CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO EXISTE"); strcpy(sTamano,"19"); break; case AUT_CIS_BORRADO: pszMensaje = (char *) malloc ( sizeof("CISTERNA BORRADA") ); strcpy(pszMensaje,"CISTERNA BORRADA"); strcpy(sTamano,"16"); break; case AUT_CIS_TARJETA_CADUCADA: pszMensaje = (char *) malloc ( sizeof("CADUCADA TARJETA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("TRANSPORTE") ); strcpy(pszMensaje,"CADUCADA TARJETA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"TRANSPORTE"); strcpy(sTamano,"28"); break; case AUT_CIS_ADR_CADUCADO: pszMensaje = (char *) malloc ( sizeof("A.D.R. CADUCADO") ); strcpy(pszMensaje,"A.D.R. CADUCADO"); strcpy(sTamano,"15"); break; case AUT_CIS_ITV_CADUCADO: pszMensaje = (char *) malloc ( sizeof("I.T.V. CADUCADO") ); strcpy(pszMensaje,"I.T.V. CADUCADO"); strcpy(sTamano,"15"); break; case AUT_CIS_SEGURO_CADUCADO: pszMensaje = (char *) malloc ( sizeof("POLIZA SEGURO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("CADUCADA") ); strcpy(pszMensaje,"POLIZA SEGURO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"CADUCADA"); strcpy(sTamano,"23"); break; case AUT_EST_CIS_YA_DENTRO: pszMensaje = (char *) malloc ( sizeof("CISTERNA YA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("AUTORIZADA") ); strcpy(pszMensaje,"CISTERNA YA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"AUTORIZADA"); strcpy(sTamano,"23"); break; case AUT_CON_VALOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("CONDUCTOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO EXISTE") ); strcpy(pszMensaje,"CONDUCTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO EXISTE"); strcpy(sTamano,"20"); break; case AUT_CON_BORRADO: pszMensaje = (char *) malloc ( sizeof("CONDUCTOR") + sizeof(cDiez) + sizeof(cTrece) + sizeof("BORRADO") ); strcpy(pszMensaje,"CONDUCTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"BORRADO"); strcpy(sTamano,"18"); break; case AUT_CON_CARNET_CADUCADO: pszMensaje = (char *) malloc ( sizeof("CARNET CADUCADO") ); strcpy(pszMensaje,"CARNET CADUCADO"); strcpy(sTamano,"15"); break; case AUT_CON_ADR_CADUCADO: pszMensaje = (char *) malloc ( sizeof("A.D.R. CADUCADO") ); strcpy(pszMensaje,"A.D.R. CADUCADO"); strcpy(sTamano,"15"); break; case AUT_EST_CON_YA_DENTRO: pszMensaje = (char *) malloc ( sizeof("CONDUCTOR YA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("AUTORIZADO") ); strcpy(pszMensaje,"CONDUCTOR YA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"AUTORIZADO"); strcpy(sTamano,"24"); break; case AUT_TRA_VALOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("TRACTOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO EXISTE") ); strcpy(pszMensaje,"TRACTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO EXISTE"); strcpy(sTamano,"18"); break; case AUT_TRA_BORRADO: pszMensaje = (char *) malloc ( sizeof("TRACTOR BORRADO") ); strcpy(pszMensaje,"TRACTOR BORRADO"); strcpy(sTamano,"15"); break; case AUT_TRA_TARJETA_CADUCADA: pszMensaje = (char *) malloc ( sizeof("CADUCADA TARJETA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("TRANSPORTE") ); strcpy(pszMensaje,"CADUCADA TARJETA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"TRANSPORTE"); strcpy(sTamano,"28"); break; case AUT_TRA_ADR_CADUCADO: pszMensaje = (char *) malloc ( sizeof("A.D.R. CADUCADO") ); strcpy(pszMensaje,"A.D.R. CADUCADO"); strcpy(sTamano,"15"); break; case AUT_TRA_ITV_CADUCADO: pszMensaje = (char *) malloc ( sizeof("I.T.V. CADUCADO") ); strcpy(pszMensaje,"I.T.V. CADUCADO"); strcpy(sTamano,"15"); break; case AUT_TRA_SEGURO_CADUCADO: pszMensaje = (char *) malloc ( sizeof("CADUCADA POLIZA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("SEGURO") ); strcpy(pszMensaje,"CADUCADA POLIZA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"SEGURO"); strcpy(sTamano,"23"); break; case AUT_EST_TRA_YA_DENTRO: pszMensaje = (char *) malloc ( sizeof("TRACTOR YA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("AUTORIZADO") ); strcpy(pszMensaje,"TRACTOR YA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"AUTORIZADO"); strcpy(sTamano,"22"); break; case AUT_SUM_VALOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("SUMINISTRADOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO EXISTE") ); strcpy(pszMensaje,"SUMINISTRADOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO EXISTE"); strcpy(sTamano,"24"); break; case AUT_SUM_BORRADO: pszMensaje = (char *) malloc ( sizeof("SUMINISTRADOR") + sizeof(cDiez) + sizeof(cTrece) + sizeof("BORRADO") ); strcpy(pszMensaje,"SUMINISTRADOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"BORRADO"); strcpy(sTamano,"22"); break; case AUT_ORC_PEDIDO_DUPLICADO: pszMensaje = (char *) malloc ( sizeof("PED. DUPLICADO") ); strcpy(pszMensaje,"PED. DUPLICADO"); strcpy(sTamano,"14"); break; case AUT_ORC_VALOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("PED. NO EXISTE") ); strcpy(pszMensaje,"PED. NO EXISTE"); strcpy(sTamano,"14"); break; case AUT_ORC_BORRADO: pszMensaje = (char *) malloc ( sizeof("PED. BORRADO") ); strcpy(pszMensaje,"PED. BORRADO"); strcpy(sTamano,"12"); break; case AUT_ORC_ESTADO_ACABADO: pszMensaje = (char *) malloc ( sizeof("PED.") + sizeof(cDiez) + sizeof(cTrece) + sizeof("NO PENDIENTE") ); strcpy(pszMensaje,"PED."); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO PENDIENTE"); strcpy(sTamano,"18"); break; case AUT_ORC_OTRO_SUMINISTRADOR: pszMensaje = (char *) malloc ( sizeof("PED. OTRO") + sizeof(cDiez) + sizeof(cTrece) + sizeof("SUMINISTRADOR") ); strcpy(pszMensaje,"PED. OTRO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"SUMINISTRADOR"); strcpy(sTamano,"24"); break; case AUT_ORC_OTRA_CISTERNA: pszMensaje = (char *) malloc ( sizeof("PED.") + sizeof(cDiez) + sizeof(cTrece) + sizeof("OTRA CISTERNA") ); strcpy(pszMensaje,"PED."); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"OTRA CISTERNA"); strcpy(sTamano,"19"); break; case AUT_ORC_FECHA_MENOR_QUE_HOY: pszMensaje = (char *) malloc ( sizeof("PED. CADUCADO") ); strcpy(pszMensaje,"PED. CADUCADO"); strcpy(sTamano,"13"); break; case AUT_SIN_PED_SELECCIONADOS: pszMensaje = (char *) malloc ( sizeof("SIN PEDIDO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("SELECCIONADO") ); strcpy(pszMensaje,"SIN PEDIDO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"SELECCIONADO"); strcpy(sTamano,"24"); break; case AUT_SUP_NUM_MAX_PED: pszMensaje = (char *) malloc ( sizeof("SUPERADO NUMERO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("PEDIDO MAXIMO") ); strcpy(pszMensaje,"SUPERADO NUMERO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"MAXIMO DE PEDIDO"); strcpy(sTamano,"33"); break; case AUT_PED_YA_INTRODUCIDO: pszMensaje = (char *) malloc ( sizeof("PEDIDO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("YA INTRODUCIDO") ); strcpy(pszMensaje,"PEDIDO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"YA INTRODUCIDO"); strcpy(sTamano,"22"); break; case PEE_ESTADO_NO_AUTORIZADO: pszMensaje = (char *) malloc ( sizeof("ESTADO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO AUTORIZADO") ); strcpy(pszMensaje,"ESTADO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO AUTORIZADO"); strcpy(sTamano,"21"); break; case PEE_PESO_FUERA_DE_TOLERANCIA: pszMensaje = (char *) malloc ( sizeof("PESO FUERA DE")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("TOLERANCIA") ); strcpy(pszMensaje,"PESO FUERA DE"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"TOLERANCIA"); strcpy(sTamano,"25"); break; case PEE_TRACTOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("TRACTOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADO") ); strcpy(pszMensaje,"TRACTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADO"); strcpy(sTamano,"22"); break; case PEE_CISTERNA_NO_ENCONTRADA: pszMensaje = (char *) malloc ( sizeof("CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADA") ); strcpy(pszMensaje,"CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADA"); strcpy(sTamano,"23"); break; case PEE_CISTERNA_SIN_ORDEN: pszMensaje = (char *) malloc ( sizeof("CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("SIN ORDEN") ); strcpy(pszMensaje,"CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"SIN ORDEN"); strcpy(sTamano,"19"); break; case PEE_CONDUCTOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("CONDUCTOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADO") ); strcpy(pszMensaje,"CONDUCTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADO"); strcpy(sTamano,"24"); break; case PES_CISTERNA_SIN_ORDEN: pszMensaje = (char *) malloc ( sizeof("CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("SIN ORDEN") ); strcpy(pszMensaje,"CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"SIN ORDEN"); strcpy(sTamano,"19"); break; case PES_ESTADO_NO_CARGADO: pszMensaje = (char *) malloc ( sizeof("ESTADO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO CARGADO") ); strcpy(pszMensaje,"ESTADO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO CARGADO"); strcpy(sTamano,"18"); break; case PES_PESO_FUERA_DE_TOLERANCIA: pszMensaje = (char *) malloc ( sizeof("PESO FUERA DE")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("TOLERANCIA") ); strcpy(pszMensaje,"PESO FUERA DE"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"TOLERANCIA"); strcpy(sTamano,"25"); break; case PES_CISTERNA_NO_ENCONTRADA: pszMensaje = (char *) malloc ( sizeof("CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADA") ); strcpy(pszMensaje,"CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADA"); strcpy(sTamano,"23"); break; case PES_TRACTOR_NO_ENCONTRADO: pszMensaje = (char *) malloc ( sizeof("TRACTOR")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADO") ); strcpy(pszMensaje,"TRACTOR"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADO"); strcpy(sTamano,"22"); break; case ALB_CAR_NO_ENCONTRADA: pszMensaje = (char *) malloc ( sizeof("CARGA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO ENCONTRADA") ); strcpy(pszMensaje,"CARGA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO ENCONTRADA"); strcpy(sTamano,"20"); break; case ALB_ESTADO_NO_AUTORIZADO: pszMensaje = (char *) malloc ( sizeof("ESTADO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("NO AUTORIZADO") ); strcpy(pszMensaje,"ESTADO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"NO AUTORIZADO"); strcpy(sTamano,"21"); break; case TAR_CIS_INVALIDA: pszMensaje = (char *) malloc ( sizeof("TARJETA CISTERNA")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("INVALIDA") ); strcpy(pszMensaje,"TARJETA CISTERNA"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"INVALIDA"); strcpy(sTamano,"26"); break; case TAR_CON_INVALIDA: pszMensaje = (char *) malloc ( sizeof("TARJETA COND.")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("INVALIDA") ); strcpy(pszMensaje,"TARJETA COND."); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"INVALIDA"); strcpy(sTamano,"23"); break; case TEC_FUNCION_INVALIDA: pszMensaje = (char *) malloc ( sizeof("TECLAS FUNCION")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("INVALIDAS") ); strcpy(pszMensaje,"TECLAS FUNCION"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"INVALIDAS"); strcpy(sTamano,"25"); break; case ENT_TECLADO_INVALIDA: pszMensaje = (char *) malloc ( sizeof("ENTRADA TECLADO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("INVALIDA") ); strcpy(pszMensaje,"ENTRADA TECLADO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"INVALIDA"); strcpy(sTamano,"25"); break; case SUP_TIEMPO_ENT_TECLADO: pszMensaje = (char *) malloc ( sizeof("SUPERADO TIEMPO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("ENTRADA DATO") ); strcpy(pszMensaje,"SUPERADO TIEMPO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"ENTRADA DATO"); strcpy(sTamano,"29"); break; case DIA_CANCELADO: pszMensaje = (char *) malloc ( sizeof("DIALOGO")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("CANCELADO") ); strcpy(pszMensaje,"DIALOGO"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"CANCELADO"); strcpy(sTamano,"18"); break; case OPERACION_OK: pszMensaje = (char *) malloc ( sizeof("OPERACION OK") ); strcpy(pszMensaje,"OPERACION OK"); strcpy(sTamano,"12"); break; default: bEntro=false; } if(bEntro) { //Conseguimos la referencia ConseguirReferencia(&cReferencia); //Formateamos la sentencia Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,sTipoID,BB_MENSAJE_BLOQUEO,cReferencia,sTamano,pszMensaje); do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while( !EsperarRespuestaOcasional(cServidor,sTipoID) ); Sleep(TIEMPO_MENSAJE_PANTALLA); free(pszMensaje); } } //----------------------------------------------------------------------- void AnimacionMontrel(char cServidor,char *sTipoID,char cReferencia) { int ni,nj; char sMontrel[7]; char *pszMensaje; char sSentencia[TAM_MAXIMO_OCASIONAL]; char cDiez[2],cTrece[2]; //Inicializamos variables cDiez[0]=10; cDiez[1]=0; cTrece[0]=13; cTrece[1]=0; nj=0; strcpy(sMontrel,"MONTREL"); pszMensaje = (char *) malloc (16); memset(pszMensaje,0,16); while(nj<7) { ni=14; while(ni>=nj) { memset(pszMensaje+nj,' ',(14-nj)); memcpy(pszMensaje+ni,sMontrel+nj,1); //Formateamos la sentencia Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,sTipoID,BB_MENSAJE_BLOQUEO,cReferencia,"14",pszMensaje); Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); Sleep(200); ni--; } EsperarRespuestaOcasional(cServidor,"BBRAUT"); nj++; } free(pszMensaje); //Creamos el mensaje pszMensaje = (char *) malloc ( sizeof("MONTREL")+ sizeof(cDiez) + sizeof(cTrece) + sizeof("ING. ELECTRICA") ); strcpy(pszMensaje,"MONTREL"); StrCat(pszMensaje,cDiez); StrCat(pszMensaje,cTrece); StrCat(pszMensaje,"ING. ELECTRICA"); //Formateamos la sentencia Formatea(sSentencia,TAM_MAXIMO_OCASIONAL,"%c%s%s%c%s%s",cServidor,sTipoID,BB_MENSAJE_BLOQUEO,cReferencia,"23",pszMensaje); //Mientras no recibamos una respuesta correcta do Transfer->EscribirOcasional(sSentencia,NUM_OCASIONAL); while(!EsperarRespuestaOcasional(cServidor,"BBRAUT")); free(pszMensaje); }