25 enero, 2011

Arranque del módulo Telit

          Esta es una forma sencilla de arrancar el módulo y ha de quedar claro que las variables y llamadas a otros subprogramas puedem quedar en otro lugar. Es un ejemplo que se puede seguir para la puesta en marcha.
          Si se desea el proyecto entero hay que pedirlo al correo electrónico o mediante un comentario. Este procedimiento se corresponde al esquema presentado en el enlace.

>>- - - - - - --
// arranque.c Arranca el módulo Telit
// SE inicia enviando un AT y tiene que responder ok.
void arranca(){
     do {
          inicbuff2(); // Borro buffer.
          puerto_b= 0;
          rcvchar=0x00; // último caracter recibido
          Rxnum=0x00; // Identifica la cantidad de bytes recibidos
          TimerCero=0x00;
          Timer_=0x00; //Variable de tiempo a temporizar en 10miliseg
          Retornos=0x00; //CAntidad de retornos a contar
          VarRetornos=0x00; //CAntidad de retornos a contar
          Desplaza=0x00; //cantidad de puestos que ha de desplazar para leer
          flagcommand=0; // Flag para indicar comando disponible
          flagOK=1;
          flagPrimero=0; //Flag de primer \n
          flagATOK = 1; //Flag de confirmación de interpretación correcta.
          repeat=1; //Repetir la función que se está ejecutando
          NoAutorizado= 1; //Flag de control de telefonos autorizados
// EstadoAlarma=0; //Estado de alarma activa al inicio

          output_high(PIN_C1); //Activa el reset
          delay_ms(610);
          output_low(PIN_C1); //desActiva el reset
          output_high(PIN_C0); //Activa el reset
          delay_ms(1110);
          output_low(PIN_C0); //desActiva el reset
          delay_ms(300); //Fin del reset
//_________________________________
          cargar();
          VarRetornos=2; // Espera la llegada del OK
          Desplaza = 0x07; //posiciona el la O de ok
          printf ("ATE0\r"); //1 Comando de no Eco (con cero al final)
          TempRecibe(300); //activa la temporización en la recepción
          while ((flagATOK) && (flagOK)) ; //Fin de recepción
          procesa();
          if (flagATOK == 0){//1
                    delay_ms(200); //Fin del reset
                    cargar();
                    VarRetornos=2; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    printf ("AT+CMEE=1\r"); //2 Comando PARA DEVOLUCION DE ERRORES
                    TempRecibe(550); //activa la temporización en la recepción
                    while (flagATOK && flagOK) ; //Fin de recepción
                    procesa();
                    if (flagATOK == 0){//2
                              delay_ms(100); //Fin del reset
                              cargar();
                              VarRetornos=2; // Espera la llegada del OK
                              Desplaza = 0x02; //posiciona el la O de ok
                              printf ("AT+IPR=9600\r"); //3 Comando PARA DEVOLUCION DE ERRORES
                              TempRecibe(2020); //activa la temporización en la recepción
                              while (flagATOK && flagOK) ; //Fin de recepción
                              procesa();
                              if (flagATOK == 0){//3
                                        delay_ms(1000); //Fin del reset
                                        cargar();
                                        VarRetornos=2; // (4)Espera la llegada del OK
                                        Desplaza = 0x02; //posiciona el la O de ok
                                        TempRecibe(2020); //activa la temporización en la recepción
                                        printf ("AT+CPIN\r"); //5 Comando PARA DEVOLUCION DE ERRORES
                                        while (flagATOK && flagOK) ; //Fin de recepción
                                        procesa();
                                        if (flagATOK == 0){//4
                                                  output_high(PIN_B4);
                                                  delay_ms(14000); //Tiempo para que conecte con repetidor
                                                  output_low(PIN_B4);
                                                  do{
                                                            delay_ms(1010); //Fin del reset
                                                            cargar();
                                                            VarRetornos=2; // Espera la llegada del OK
                                                            Desplaza = 0x02; //posiciona el la O de ok
                                                            printf ("AT+CREG\r"); //Comando ESTADO CONEXION
                                                            TempRecibe(2500); //activa la temporización en la recepción
                                                            while (flagATOK && flagOK) ; //Fin de recepción
                                                            procesa();
                                                  }while(repeat);
                                                  delay_ms(500); //Fin del reset
                                                  if (flagATOK == 0){//5
                                                            cargar();
                                                            VarRetornos=4; // Espera la llegada del OK
                                                            Desplaza = 0x02; //posiciona el la O de ok
                                                            printf ("AT+CSQ\r"); //Comando CANTIDAD DE SEÑAL
                                                            TempRecibe(550); //activa la temporización en la recepción
                                                            while (flagATOK && flagOK) ; //Fin de recepción
                                                            procesa();
                                                            delay_ms(500); //Fin del reset
                                                            if (flagATOK == 0){//6
                                                                      cargar();
                                                                      VarRetornos=2; // Espera la llegada del OK
                                                                      Desplaza = 0x02; //posiciona el la O de ok
                                                                      printf ("AT+CMGF=1\r"); //Comando MODO TEXTO
                                                                      TempRecibe(550); //activa la temporización en la recepción
                                                                      while (flagATOK && flagOK) ; //Fin de recepción
                                                                      procesa();
                                                                      delay_ms(500); //Fin del reset
                                                                      if (flagATOK == 0){//7
                                                                                cargar();
                                                                                VarRetornos=2; // Espera la llegada del OK
                                                                                Desplaza = 0x02; //posiciona el la O de ok
                                                                                printf ("AT+CLIP=1\r"); //Comando MODO TEXTO
                                                                                TempRecibe(20000); //activa la temporización en la recepción
                                                                                while (flagATOK && flagOK) ; //Fin de recepción
                                                                                procesa();
                                                                                delay_ms(500); //Fin del reset delay_ms(1201); //Fin del reset
                                                                                if (flagATOK == 0){//8
                                                                                          cargar();
                                                                                          VarRetornos=2; // Espera la llegada del OK
                                                                                          Desplaza = 0x02; //posiciona el la O de ok
                                                                                          printf ("AT+CNMI=1,1,0,0,0\r"); //Configura el SMS
                                                                                          // TempRecibe(5050); //activa la temporización en la recepción
                                                                                          while (flagATOK) ; //Fin de recepción
                                                                                          procesa();
                                                                                } //8 /* */
                                                                      } //7
                                                            } //6
                                                  } //5
                                        } //4
                              } //3
                    } //2
          } //1

// } //O
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
          if (flagATOK == 0) {
                    cargar();
                    VarRetornos=4; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    //Lo deja preparado para la recepción
                    repeat = 0;
                    output_high(PIN_B7);
          }
          else {
                    repeat = 1;
                    output_high(PIN_B6);
          }
          if( EstadoAlarma==1)
                    output_high(PIN_B4);
                    delay_ms(2000);
          // output_low(PIN_B4);
          inicbuff2();
          }while (repeat); //Secuencia de repeticion constante
} //Fin arranca
//_________________________________________________________
void cargar(void){
          output_high(PIN_B3); //Activa Transmision
          inicbuff2(); // Borro buffer.
          flagPrimero=0 ;
          flagOK = 1;
          flagATOK = 1;
          Rxnum =0 ; //Contador de entrada de bytes
          repeat= 1;
          Retornos=0;
          fagTiempo=1;
          rcvchar=0x00;
          TimerCero=0x00;
          Timer_=0x00; //Variable de tiempo a temporizar en 10miliseg
}
// VarRetornos=0x00; //CAntidad de retornos a contar
// NoAutorizado= 1; //Flag de control de telefonos autorizados
// EstadoAlarma=0; //Estado de alarma activa al inicio
//_______Activa temporización en transmisión______________________
void TempRecibe(long Temp){
          enable_interrupts(int_rtcc);
          disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          output_low(PIN_B3); //desactiva transmision
          Timer_ = Temp;
          set_rtcc(0); /* Se inicializa el timer a cero */
          enable_interrupts(int_rtcc); // Habilita Interrupción RDA
          flagOK=1;
          fagTiempo=1;
}
//________________________________________________________
void inicbuff2(void){ // Inicia a \0 cbuff -------------------
          int i;
          for(i=0;i
                    cbuff[i]=0x00; // caracteres en el buffer
                    }
          xbuff=0x00; // Inicializo el indice de siguiente
          // caracter
}
//________Identifica si hay o no que enviar el PIN
//_____________________ Tratamiento de errores____________________
void errores (void){
          int i = 15; // situta puntero en el numero de averia
          // disable_interrupts(int_rtcc);;
          switch(cbuff[i]) {
          case '0': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x00;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '1': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x01;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '2': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x02;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '3': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x03;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '4': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x04;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '5': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x05;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '6': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x06;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '7': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x07;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          default:flagATOK =1; //error en la transmision
          }
}
//__________ Comprueba si hay señal suficiente para ejecutar el proceso
void senyal (){
          int i= 8; // situta puntero al inicio de la averia
          disable_interrupts(int_rtcc);;
          if ((cbuff[i]>='1')&& (cbuff[i]<='3')&& (cbuff[(i+1)]>='0')&& (cbuff[(i+1)]<='9' )) {
                    flagATOK = 0;
                    }else {
                    flagATOK =1;
                    puerto_b= 0xE0;
                    bloqueo ();
          }
}
//__ Comprueba el estado de la conexion
void conection (){
          int i= 11; // situta puntero al inicio
          disable_interrupts(int_rtcc);;
          output_high(PIN_B7);
          delay_ms(20); // espera la llegada del OK
          switch(cbuff[i]) {
                    case ('0'): { //Comprueba si el primer
                    repeat = 1;
                    } break;
                    case ('1'): { //Comprueba si el primer
                    repeat = 0;
                    } break;
                    case ('2'): { //Comprueba si el primer
                    repeat = 1;
                    } break;
                    default:{
          flagATOK =1; //error en la transmision
          repeat = 1 ; //sale del bucle al tener un error seguramente.
          puerto_b= 0xE0;
          bloqueo();
          }
          }
}
//_____________________________________________________________
void procesa(){
          int i ;
          i= Desplaza;
          disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          if (flagOK==1){//PP
                    // disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
                    if (cbuff[2]!= '+'){// 1
                              switch(cbuff[i]){
                              case 'O': { //Comprueba si el primer valor recibido es sincronizacion
                              flagATOK =0;
                              } break;
                              case 'R': { // RING Comprueba sI ES UNA LLAMADA
                              delay_ms(500);
                              llamada ();
                              } break;
                              default:flagATOK =1; //error en la transmision
                   }
          }//1
          else{ // sIGNIFICA QUE HA LLEGADO UN + ***************************
                    i= 4; // situta puntero al inicio de la averia
                    switch(cbuff[i]) {
                    case 'P': { //CPI Comprueba si el primer valor recibido es sincronizacion
                    // Enviar a tratamiento del pin
                    verPin ();
                    } break;
                    case 'M': { //CME Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de error
                    // delay_ms(50);
                    errores();
                    } break;
                    case 'S': { //CSQ Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de señal
                    senyal ();
                    } break;
                    case 'R' : { //CRE Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de señal
                    conection ();
                    } break;
                    default:flagATOK =1; //error en la transmision
                    }
          }
          }//PP
}
//__________________________________________________
void verPin(void){
          int i= 9; //Situa al inicio de la palabra P ó S
          disable_interrupts(int_rtcc);;
          if (cbuff[i]== 'R'){ //Significa que es Ready por tanto vuelve sin más
                    flagATOK = 0; //No hace falta hacer nada (no envia pin)
                    delay_ms(700); //Espera a recibir el ok
          }
          else {
                    i=14;
                    delay_ms(700); //Espera a recibir el ok
                    if (cbuff[i]== 'I'){ //Tiene que enviar el Pin
                    cargar(); //Envia el Pin
                    VarRetornos=2; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    printf ("AT+CPIN=4340\r"); //Comando ENVIA EL CODIGO PIN**
                    TempRecibe(2010); //activa la temporización en la recepción
                    while (flagATOK && flagOK){ //Fin de recepción
          } //Espera a que termine de recibir
          // disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          i=2;
          if (cbuff[i]== 'O') //Si ha llegado el Ok continua
                    flagATOK = 0; //hA SIDO CORRECTO
                    else flagATOK = 1; // Algo ha fallado en la recpecion del 0k final.
          }
          else {
                    puerto_b= 0xF0; //precisa del PUKV???
                    bloqueo();
          }
}
}

No hay comentarios:

Publicar un comentario