Diff: main.cpp

Revision:

3:e060cff29402

Parent:

2:7e518b8dcda8

Child:

4:9d435331bbc7

--- a/main.cpp	Thu Apr 09 05:41:39 2015 +0000
+++ b/main.cpp	Thu Apr 09 07:12:52 2015 +0000
@@ -4,8 +4,16 @@
 #include "string.h"
 using namespace std;
 
-#define     Si          1
-#define     No          0
+#define     Si              1
+#define     No              0
+#define     numMuestreos    5
+#define     CoeficienteB    3950
+#define     NominalTermistor    10000
+#define     TempNominal     25
+#define     ResistSerie     100
+#define     Encendido       0
+#define     Apagado         1
+
 
 
 
@@ -21,21 +29,22 @@
 float tempSen2;           // Temperatura del sensor 2   
 float tempSen3;           // Temperatura del sensor 3  
 float tempSen4;           // Temperatura del sensor 4 
-float volSen1;            // Voltaje para conversión sensor 1 
-float volSen2;            // Voltaje para conversión sensor 2 
-float volSen3;            // Voltaje para conversión sensor 3 
-float volSen4;            // Voltaje para conversión sensor 4 
-uint16_t adcTempSen1;     // Variable para almacenar valor de voltaje sensor 1
-uint16_t adcTempSen2;     // Variable para almacenar valor de voltaje sensor 2 son variables nuevas 
-uint16_t adcTempSen3;     // Variable para almacenar valor de voltaje sensor 3
-uint16_t adcTempSen4;     // Variable para almacenar valor de voltaje sensor 4
+float proSen1;            // Promedio para conversión sensor 1 
+float proSen2;            // Promedio para conversión sensor 2 
+float proSen3;            // Promedio para conversión sensor 3 
+float proSen4;            // Promedio para conversión sensor 4 
+uint16_t adcTempSen1[numMuestreos];     // Variable para almacenar valor de adc sensor 1
+uint16_t adcTempSen2[numMuestreos];     // Variable para almacenar valor de adc sensor 2  
+uint16_t adcTempSen3[numMuestreos];     // Variable para almacenar valor de adc sensor 3
+uint16_t adcTempSen4[numMuestreos];     // Variable para almacenar valor de adc sensor 4
 Timer timmer;             // Timer para medir el tiempo transcurrido
 bool inicioProceso = No;  // Variable para determinar si el proceso se inicia    
 bool pausaProceso = No;   // Variable para pausar
 bool finProceso = No;     // Variable finalizar el proceso  
 char comando;             // Variable para leer el comando a ejecutar en el proceso  
 char sTiempo[10];         // stringtiempo
-char sTemperatura[10];    // string temperatura 
+char sTemperatura[10];    // string temperatura
+bool curadoIniciado = No; 
 
   
 
@@ -56,7 +65,8 @@
 
 // --------------------------------------------------------------------------- Prototipos
 void LeerSerie (void);         // Función para leer el puerto serie  
-void LeerSensores (void);      // Función para leer temperatura delos sensores                
+void LeerSensores (void);      // Función para leer temperatura delos sensores 
+float convertirTemp(float promedio); // Función para convertir la lectura ADC a temperatura               
 
 
 // --------------------------------------------------------------------------- Programa principal
@@ -65,7 +75,6 @@
     pc.baud(9600);
     pc.printf("Iniciando\n\r");        // Se imprime y se da enter
     pc.attach(&LeerSerie);
-    pc.attach(&LeerSensores);
     
     while(inicioProceso == No)
     {
@@ -74,18 +83,97 @@
     }// Espera a recibir comando 
     
     pc.printf("Proceso Iniciado\r\n");
+    // Encender Ventiladores
+    ventilador1 = 1;  
+    ventilador2 = 1;
+    pc.printf("Ventiladores Encendidos\r\n");
+    reflector1 = Encendido;
+    reflector2 = Encendido;
+    reflector3 = Encendido;
+    reflector4 = Encendido;
+    pc.printf("Reflectores Encendidos\r\n");
     
-  
+    
+    // Espera a que todos los sensores alcancen la temperatura de trabajo, que el curado inicie
+    while(curadoIniciado == No)
+    {
+        LeerSensores();
+        if((tempSen1 >= tempTrabajo) && (tempSen2 >= tempTrabajo) && (tempSen3 >= tempTrabajo) && (tempSen4 >= tempTrabajo))
+        {
+            curadoIniciado = Si;
+        }
+    }
+    
+    pc.printf("Curado Iniciado\r\n");
+    // Activar timer
+      
 // --------------------------------------------------------------------------- PROCESO
     while(finProceso == No) 
     {
         
+        LeerSensores();
         
+        // ------------------------------ Controlar Reflector 1
+        if(tempSen1 > tempTrabajo)
+        {
+            reflector1 = Apagado;
+            pc.printf("Reflector 1: Apagado\r\n");
+        }
+        else if(tempSen1 < tempTrabajo)
+        {
+            reflector1 = Encendido;
+            pc.printf("Reflector 1: Encendido\r\n");
+        }
+        
+        // ------------------------------ Controlar Reflector 2
+        if(tempSen2 > tempTrabajo)
+        {
+            reflector2 = Apagado;
+            pc.printf("Reflector 2: Apagado\r\n");
+        }
+        else if(tempSen2 < tempTrabajo)
+        {
+            reflector2 = Encendido;
+            pc.printf("Reflector 2: Encendido\r\n");
+        }
+        
+        // ------------------------------ Controlar Reflector 3
+        if(tempSen3 > tempTrabajo)
+        {
+            reflector3 = Apagado;
+            pc.printf("Reflector 3: Apagado\r\n");
+        }
+        else if(tempSen3 < tempTrabajo)
+        {
+            reflector3 = Encendido;
+            pc.printf("Reflector 3: Encendido\r\n");
+        }
+        
+        // ------------------------------ Controlar Reflector 4
+        if(tempSen4 > tempTrabajo)
+        {
+            reflector4 = Apagado;
+            pc.printf("Reflector 4: Apagado\r\n");
+        }
+        else if(tempSen4 < tempTrabajo)
+        {
+            reflector4 = Encendido;
+            pc.printf("Reflector 4: Encendido\r\n");
+        }
         
         while(pausaProceso == Si)  // ---------------------------------------- Proceso Pausado
         {
             pc.printf("Proceso Puasado\r\n");
-            wait(0.1);
+             // Apagar Ventiladores
+            ventilador1 = 0;  
+            ventilador2 = 0;
+            pc.printf("Ventiladores Apagados\r\n");
+            reflector1 = Apagado;
+            reflector2 = Apagado;
+            reflector3 = Apagado;
+            reflector4 = Apagado;
+            pc.printf("Reflectores Apagados\r\n");
+            wait(1);
         }
     }
     
@@ -129,39 +217,101 @@
                 break;
         
     }
+}
+
     
  //----------------------------------------------------Leer temperatura  
 void LeerSensores(void)
 {
-        adcTempSen1 = pinSen1.read_u16();
-        volSen1 = adcTempSen1 *5 / 65535;
-        tempSen1 =
-        pc.printf("Senor1: %1, %.2f volts, %.2f celcius. /r /n " ,  adcTempSen1, volSen1, tempSen1);
-        
-        adcTempSen2= pinSen2.read_u16();
-        volSen2= adcTempSen2*5 / 65535;
-        tempSen2=
-        pc.printf("Senor2: %1, %.2f volts, %.2f celcius. /r /n " ,  adcTempSen2, volSen2, tempSen2);
+        int i;
+        //-------------------------------------------------------------------------- sensor 1
+        //----------------------------- Se realizan múltiples lecturas para sacar un promedio de voltaje
+        for ( i=0; i< numMuestreos; i++) 
+        {
+         adcTempSen1[i] = pinSen1.read_u16();
+         wait(0.01);
+        }
+        // ---------------------------- Se calcula el promedio
+        proSen1 = 0;
+        for (i=0; i< numMuestreos; i++) 
+        {
+            proSen1 += adcTempSen1[i];
+        }
+        proSen1 /= numMuestreos;
+        tempSen1 = convertirTemp(proSen1);
         
-        adcTempSen3= pinSen3.read_u16();
-        volSen3= adcTempSen3*5 / 65535;
-        tempSen3=
-        pc.printf("Senor3: %1, %.2f volts, %.2f celcius. /r /n " ,  adcTempSen3, volSen3, tempSen3);
+        //-------------------------------------------------------------------------- sensor 2
+        //----------------------------- Se realizan múltiples lecturas para sacar un promedio de voltaje
+        for ( i=0; i< numMuestreos; i++) 
+        {
+         adcTempSen2[i] = pinSen2.read_u16();
+         wait(0.01);
+        }
+        // ---------------------------- Se calcula el promedio
+        proSen2 = 0;
+        for (i=0; i< numMuestreos; i++) 
+        {
+            proSen2 += adcTempSen2[i];
+        }
+        proSen2 /= numMuestreos;
+        tempSen2 = convertirTemp(proSen2);
         
-        adcTempSen1 = pinSen1.read_u16();
-        volSen1 = adcTempSen1 *5 / 65535;
-        tempSen1 =
-        pc.printf("Senor4: %1, %.2f volts, %.2f celcius. /r /n " ,  adcTempSen4, volSen4, tempSen4);
+        //-------------------------------------------------------------------------- sensor 3
+        //----------------------------- Se realizan múltiples lecturas para sacar un promedio de voltaje
+        for ( i=0; i< numMuestreos; i++) 
+        {
+         adcTempSen3[i] = pinSen3.read_u16();
+         wait(0.01);
+        }
+        // ---------------------------- Se calcula el promedio
+        proSen3 = 0;
+        for (i=0; i< numMuestreos; i++) 
+        {
+            proSen3 += adcTempSen3[i];
+        }
+        proSen3 /= numMuestreos;
+        tempSen3 = convertirTemp(proSen3);
+        
+        //-------------------------------------------------------------------------- sensor 4
+        //----------------------------- Se realizan múltiples lecturas para sacar un promedio de voltaje
+        for ( i=0; i< numMuestreos; i++) 
+        {
+         adcTempSen4[i] = pinSen4.read_u16();
+         wait(0.01);
+        }
+        // ---------------------------- Se calcula el promedio
+        proSen4 = 0;
+        for (i=0; i< numMuestreos; i++) 
+        {
+            proSen4 += adcTempSen4[i];
+        }
+        proSen4 /= numMuestreos;
+        tempSen4 = convertirTemp(proSen4);
         
         
-        wait(0.1);
+        
+        pc.printf("Sensor1: %.2f C. /r /n ", tempSen1);
+        pc.printf("Sensor2: %.2f C. /r /n ", tempSen2);
+        pc.printf("Sensor3: %.2f C. /r /n ", tempSen3);
+        pc.printf("Sensor4: %.2f C. /r /n ", tempSen4);
         
-  
-  
-  
+}
+
+// --------------------------------------------------------------------------- convertirTemp
+float convertirTemp(float promedio)
+{
+  float temperatura;
   
-  }
-    
-    
-    
-}
\ No newline at end of file
+   // convertir el promedio a resistencia
+  promedio = 65535 / promedio - 1;
+  promedio = ResistSerie / promedio;
+  temperatura = promedio / NominalTermistor;     // (R/Ro)
+  temperatura = log(temperatura);                // ln(R/Ro)
+  temperatura /= CoeficienteB;                   // 1/B * ln(R/Ro)
+  temperatura += 1.0 / (TempNominal + 273.15);   // + (1/To)
+  temperatura = 1.0 / temperatura;               // Invertir
+  temperatura -= 273.15;                         // convertir a C
+  return temperatura;
+}
+
+    
\ No newline at end of file