Guest User

Etternell

a guest
Oct 23rd, 2016
101
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //    ------------------------------------------------------------------------------------------
  2. //    |////////////////////////////////////////////////////////////////////////////////////////|
  3. //    |///////////////////////////////// LIBRAIRIES ///////////////////////////////////////////|
  4. //    |////////////////////////////////////////////////////////////////////////////////////////|
  5. //    ------------------------------------------------------------------------------------------
  6.  
  7. #include <OneWire.h>                         // SONDE PH
  8. #include <LiquidCrystal.h>                   // ECRAN LCD
  9.  
  10. //    ------------------------------------------------------------------------------------------
  11. //    |////////////////////////////////////////////////////////////////////////////////////////|
  12. //    |///////////////////////////////// CAPTEUR TEMPERATURE //////////////////////////////////|
  13. //    |////////////////////////////////////////////////////////////////////////////////////////|
  14. //    ------------------------------------------------------------------------------------------
  15.  
  16. #define DS18B20 0x28                        // ADRESSE SONDE TEMPERATURE
  17. #define BROCHE_ONEWIRE 31                   // PIN DE LA SONDE TEMPERATURE
  18.  
  19. OneWire ds(BROCHE_ONEWIRE);                 // CREATION ENTREE
  20. const int TEMPMAX = 27.00;                  // TEMPERATURE MAX DE L'EAU
  21. const int TEMPMIN = 23.00;                  // TEMPERATURE MINIMUM
  22. const int TEMPCHAUFFAGE = 24.00;            // TEMPERATURE ACTIVATION CHAUFFAGE
  23. int LED_TEMP_BAD = 22;                      // PIN LED INDICATION PROBLEME TEMPERATURE EAU
  24. int LED_TEMP_OK = 23;                       // PIN LED INDICATION BONNE TEMPERATURE EAU
  25. int RELAIS_CHAUFFAGE = 28;
  26.  
  27. boolean getTemperature(float *temp)
  28. {
  29.   byte data[9], addr[8];
  30.   if (!ds.search(addr))                     // Recherche un module 1-Wire
  31.   {
  32.     ds.reset_search();                      // Réinitialise la recherche de module
  33.     return false;                           // Retourne une erreur
  34.   }
  35.   if (OneWire::crc8(addr, 7) != addr[7])    // Vérifie que l'adresse a été correctement reçue
  36.     return false;                           // Si le message est corrompu on retourne une erreur
  37.   if (addr[0] != DS18B20)                   // Vérifie qu'il s'agit bien d'un DS18B20
  38.     return false;                           // Si ce n'est pas le cas on retourne une erreur
  39.   ds.reset();                               // On reset le bus 1-Wire
  40.   ds.select(addr);                          // On sélectionne le DS18B20
  41.   ds.write(0x44, 1);                        // On lance une prise de mesure de température
  42.   delay(800);                               // Et on attend la fin de la mesure
  43.   ds.reset();                               // On reset le bus 1-Wire
  44.   ds.select(addr);                          // On sélectionne le DS18B20
  45.   ds.write(0xBE);                           // On envoie une demande de lecture du scratchpad
  46.   for (byte i = 0; i < 9; i++)              // On lit le scratchpad
  47.     data[i] = ds.read();                    // Et on stock les octets reçus
  48.   *temp = ((data[1] << 8) | data[0]) * 0.0625;
  49.   return true;
  50. }
  51.  
  52. //    ------------------------------------------------------------------------------------------
  53. //    |////////////////////////////////////////////////////////////////////////////////////////|
  54. //    |///////////////////////////////// ECRAN LCD ////////////////////////////////////////////|
  55. //    |////////////////////////////////////////////////////////////////////////////////////////|
  56. //    ------------------------------------------------------------------------------------------
  57.  
  58. LiquidCrystal lcd(8, 9, 10, 11, 12, 13);      // PINS de l'ecran
  59.  
  60. //    ------------------------------------------------------------------------------------------
  61. //    |////////////////////////////////////////////////////////////////////////////////////////|
  62. //    |///////////////////////////////// SONDE PH /////////////////////////////////////////////|
  63. //    |////////////////////////////////////////////////////////////////////////////////////////|
  64. //    ------------------------------------------------------------------------------------------
  65.  
  66. #define SensorPin 0          //pH meter Analog output to Arduino Analog Input 0
  67. unsigned long int avgValue;  //Store the average value of the sensor feedback
  68. float b;
  69. int buf[10], PH;
  70. int PH_LED_BAD = 27;                       // PIN LED INDICATION PROBLEME DE PH
  71. int PH_LED_OK = 26;                        // PIN LED INDICATION BON PH
  72. const int PHMAX = 8.20;                    // PIN PH MAXIMUM
  73. const int PHMIN = 6.80;                    // PIN PH MINIMUM
  74.  
  75.  
  76. void setup()
  77.  
  78.  
  79. {
  80.   Serial.begin(9600);                       // VITESSE EN BAUDS
  81.   lcd.begin(16, 2);                         // DEMARRAGE ECRAN EN 16X2
  82.   lcd.clear();                              // NETTOYAGE ECRAN
  83.   pinMode (A0, INPUT);                      // ENTREE SONDE PH
  84.   //pinMode (A1, INPUT);                    //
  85.   //pinMode (A2, INPUT);                    //
  86.   //pinMode (A3, INPUT);                    //
  87.   //pinMode (A4, INPUT);                    //
  88.   //pinMode (A5, INPUT);                    //
  89.   //pinMode (A6, INPUT);                    //
  90.   //pinMode (A7, INPUT);                    //
  91.   //pinMode (A8, INPUT);                    //
  92.   //pinMode (A9, INPUT);                    //
  93.   //pinMode (A10, INPUT);                   //
  94.   //pinMode (A11, INPUT);                   //
  95.   //pinMode (A12, INPUT);                   //
  96.   //pinMode (A13, INPUT);                   //
  97.   //pinMode (A14, INPUT);                   //
  98.   //pinMode (A15, INPUT);                   //
  99.   //pinMode (0, OUTPUT);                    //
  100.   //pinMode (1, OUTPUT);                    //
  101.   //pinMode (2, INPUT);                     //
  102.   //pinMode (3, OUTPUT);                    //
  103.   //pinMode (4, OUTPUT);                    //
  104.   //pinMode (5, OUTPUT);                    //
  105.   //pinMode (6, OUTPUT);                    //
  106.   //pinMode (7, OUTPUT);                    //
  107.   pinMode (8, OUTPUT);                      // SORTIE ECRAN   (D8/RS)
  108.   pinMode (9, OUTPUT);                      // SORTIE ECRAN   (DE/E)
  109.   pinMode (10, OUTPUT);                     // SORTIE ECRAN   (D10/DB4)
  110.   pinMode (11, OUTPUT);                     // SORTIE ECRAN   (D11/DB5)
  111.   pinMode (12, OUTPUT);                     // SORTIE ECRAN   (D12/DB6)
  112.   pinMode (13, OUTPUT);                     // SORTIE ECRAN   (D13/DB7)
  113.   //pinMode (14, OUTPUT);                   //
  114.   //pinMode (15, OUTPUT);                   //
  115.   //pinMode (16, OUTPUT);                   //
  116.   //pinMode (17, OUTPUT);                   //
  117.   //pinMode (18, OUTPUT);                   //
  118.   //pinMode (19, OUTPUT);                   //
  119.   //pinMode (20, OUTPUT);                   //
  120.   //pinMode (21, OUTPUT);                   //
  121.   pinMode (22, OUTPUT);                     // SORTIE LED_TEMP_BAD
  122.   pinMode (23, OUTPUT);                     // SORTIE LED_TEMP_OK
  123.   pinMode (24, OUTPUT);                     // SORTIE BUZZER ALERTE
  124.   //pinMode (25, OUTPUT);                   //
  125.   pinMode (26, OUTPUT);                     // SORTIE PH_LED_OK
  126.   pinMode (27, OUTPUT);                     // SORTIE PH_LED_BAD
  127.   pinMode (28, OUTPUT);                     // SORTIE RELAIS CHAUFFAGE
  128.   //pinMode (29, OUTPUT);                   //
  129.   //pinMode (30, OUTPUT);                   //
  130.   pinMode (31, INPUT);                      // ENTREE SONDE TEMPERATURE
  131.   //pinMode (32, OUTPUT);                   //
  132.   //pinMode (33, OUTPUT);                   //
  133.   //pinMode (34, OUTPUT);                   //
  134.   //pinMode (35, OUTPUT);                   //
  135.   //pinMode (36, OUTPUT);                   //
  136.   //pinMode (37, OUTPUT);                   //
  137.   //pinMode (38, OUTPUT);                   //
  138.   //pinMode (39, OUTPUT);                   //
  139.   //pinMode (40, OUTPUT);                   //
  140.   //pinMode (41, OUTPUT);                   //
  141.   //pinMode (42, OUTPUT);                   //
  142.   //pinMode (43, OUTPUT);                   //
  143.   //pinMode (44, OUTPUT);                   //
  144.   //pinMode (45, OUTPUT);                   //
  145.   //pinMode (46, OUTPUT);                   //
  146.   //pinMode (47, OUTPUT);                   //
  147.   //pinMode (48, OUTPUT);                   //
  148.   //pinMode (49, OUTPUT);                   //
  149.   //pinMode (50, OUTPUT);                   //
  150.   //pinMode (51, OUTPUT);                   //
  151.   //pinMode (52, OUTPUT);                   //
  152.   //pinMode (53, OUTPUT);                   //
  153. }
  154.  
  155.  
  156. void loop()
  157.  
  158.  
  159. { //DEBUT PROGRAMME
  160.  
  161.   //    ------------------------------------------------------------------------------------------
  162.   //    |////////////////////////////////////////////////////////////////////////////////////////|
  163.   //    |///////////////////////////////// EXECUTION SONDE TEMPERATURE //////////////////////////|
  164.   //    |////////////////////////////////////////////////////////////////////////////////////////|
  165.   //    ------------------------------------------------------------------------------------------
  166.  
  167.   {
  168.     float temp;
  169.     if (getTemperature(&temp))
  170.  
  171.       // AFFICHAGE TEMPERATURE
  172.  
  173.     {
  174.       lcd.setCursor(0, 0);
  175.       lcd.print(" T:");
  176.       lcd.print(temp, 1);
  177.       lcd.print(" |");
  178.  
  179.       // GESTION LED ROUGE TEMPERATURE
  180.  
  181.       if (temp < TEMPMIN)
  182.         digitalWrite (LED_TEMP_BAD, HIGH);
  183.       else if (temp > TEMPMAX)
  184.         digitalWrite (LED_TEMP_BAD, HIGH);
  185.       else
  186.         digitalWrite (LED_TEMP_BAD, LOW);
  187.  
  188.       // GESTION LED VERTE TEMPERATURE
  189.  
  190.       if (temp < TEMPMIN)
  191.         digitalWrite (LED_TEMP_OK, LOW);
  192.       else if (temp > TEMPMAX)
  193.         digitalWrite (LED_TEMP_OK, LOW);
  194.       else
  195.         digitalWrite (LED_TEMP_OK, HIGH);
  196.  
  197.       // GESTION RELAIS CHAUFFAGE
  198.  
  199.       //if (temp < TEMPCHAUFFAGE)
  200.         //digitalWrite (RELAIS_CHAUFFAGE);
  201.     }
  202.   }
  203.  
  204.   //    ------------------------------------------------------------------------------------------
  205.   //    |////////////////////////////////////////////////////////////////////////////////////////|
  206.   //    |///////////////////////////////// EXECUTION SONDE PH ///////////////////////////////////|
  207.   //    |////////////////////////////////////////////////////////////////////////////////////////|
  208.   //    ------------------------------------------------------------------------------------------
  209.  
  210.   {
  211.     for (int i = 0; i < 10; i++) //Get 10 sample value from the sensor for smooth the value
  212.     {
  213.       buf[i] = analogRead(SensorPin);
  214.       delay(10);
  215.     }
  216.     for (int i = 0; i < 9; i++) //sort the analog from small to large
  217.     {
  218.       for (int j = i + 1; j < 10; j++)
  219.       {
  220.         if (buf[i] > buf[j])
  221.         {
  222.           PH = buf[i];
  223.           buf[i] = buf[j];
  224.           buf[j] = PH;
  225.         }
  226.       }
  227.     }
  228.     avgValue = 0;
  229.     for (int i = 2; i < 8; i++)               //take the average value of 6 center sample
  230.       avgValue += buf[i];
  231.     float phValue = (float)avgValue * 5.0 / 1024 / 6; //convert the analog into millivolt
  232.     phValue = 3.5 * phValue;                  //convert the millivolt into pH value
  233.  
  234.     lcd.setCursor (9, 0);
  235.     lcd.print(" PH:");
  236.     lcd.print(phValue, 1);
  237.  
  238.     // GESTION LED ROUGE PH
  239.  
  240.     if (phValue < PHMIN)
  241.       digitalWrite (PH_LED_BAD, HIGH);
  242.     else if (phValue > PHMAX)
  243.       digitalWrite (PH_LED_BAD, HIGH);
  244.     else
  245.       digitalWrite (PH_LED_BAD, LOW);
  246.  
  247.     // GESTION LED VERTE PH
  248.  
  249.     if (phValue < PHMIN)
  250.       digitalWrite (PH_LED_OK, LOW);
  251.     else if (phValue > PHMAX)
  252.       digitalWrite (PH_LED_OK, LOW);
  253.     else
  254.       digitalWrite (PH_LED_OK, HIGH);
  255.   }
  256.  
  257.  
  258. }// FIN DU PROGRAMME
RAW Paste Data