distributeur.ino

//  Configuration
const int minTimeInSec = 5 * 60; // attente en sec quand le potentiometre est au mini
const int midTimeInSec = 60 * 60; // attente en sec quand le potentiometre est au max
const int maxTimeInSec = 120 * 60; // attente en sec quand le potentiometre est au max

const int minServoSpeed = 8;  // vitesse min du servo
const int maxServoSpeed = 8; // vitesse max du servo

const int nbDelivery = 1; // nombre de fois on ouvre la trape
const int closed = 180;  // angle du servo quand la trape est fermee
const int opened = 0; // angle du servo quand la trape est ouverte
const int openTimeInMs = 0; // Le temps ou la trappe reste ouverte a fond en Ms


// fin de la configuration


// debut du programme
#include <Servo.h>
const int timerPin = 0;
const int servoSpeedPin = 1;
const int ledPin = 13;
const int servoPin = 9;

const String SEC = " sec";
const String SPACE = " - ";
const String MIN = " min";


int servoDelayBetweenStep; 
Servo servo;

void setup()
{
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  servo.attach(servoPin);
  servo.write(closed);
  digitalWrite(ledPin, HIGH);
  delay(1500);
}

void loop()
{
  deliver(nbDelivery);
  int delayInSec = getDelayInSec();
  sleep(delayInSec); 
}


int getDelayInSec(){
  int read = analogRead(timerPin);
  if(read < 750){
    return map(analogRead(timerPin), 0, 750, minTimeInSec, midTimeInSec );  // read the value every time
  }
  return map(analogRead(timerPin), 750, 1023, midTimeInSec, maxTimeInSec );  // read the value every time
}

void sleep(int sec) {
  
  for (int i = 0; i < sec ; i++) {
    Serial.println(sec-i+SEC+SPACE+(getDelayInSec()/60)+MIN);
    digitalWrite(ledPin, LOW);
    delay(500);
    digitalWrite(ledPin, HIGH);
    delay(500);
  }
}

void deliver(int times) {
  for (int i = 0; i < times ; i++) {
    
        int pos;
        for (pos = closed; pos >= opened; pos -= 3) { 
          servoDelayBetweenStep = sq(map(analogRead(servoSpeedPin), 0, 670, minServoSpeed, maxServoSpeed ));  // read the value every time
          servo.write(pos);
          delay(servoDelayBetweenStep);
        }
        
        delay(openTimeInMs);

        for (pos = opened; pos <= closed; pos += 3) { 
          servoDelayBetweenStep = sq(map(analogRead(servoSpeedPin), 0, 670, minServoSpeed, maxServoSpeed ));  // read the value every time
          servo.write(pos);
          delay(servoDelayBetweenStep);
        }

 
  }
}

thermostat.ino

#include <Adafruit_NeoPixel.h>
#include <Servo.h>

//  Configuration

const int minWaitTimeInSec = 2; // le temps minimum en sec entre chaque ouverture quand temperature est entre dessous de 3 C thermosta
const int mediumWaitTimeInSec = 6; // le temps  en sec entre chaque ouverture quand temperature est entre 3 C et 0C en dessous thermosta
const int maxWaitTimeInSec = 24; // temps max en sec entre chaque ouverture quand la temperature > thermosta

const int infoUpdateFrequencyInSec =  2; // 5; // frequence d'affichage de info

const float minWantedTemp = 14.0;
const float maxWantedTemp = 25.0;

const int servoSpeed = 1; // vitesse du servo

const int nbDelivery = 1; // nombre de fois on ouvre la trape
const int closed = 0; // angle du servo quand la trape est fermee
const int opened = 180; // angle du servo quand la trape est ouverte
const int openTimeInMs = 500; // Le temps ou la trappe reste ouverte a fond en Ms

// fin de la configuration

// debut du programme

#define arefVoltage 3.3 // we tie 3.3V to ARef and measure it with a multimeter!
#define PIN 2   // input pin Neopixel is attached to
#define NUMPIXELS 12 // number of neopixels in Ring
#define ARRAY_SIZE 20 
const int wantedTempPin = 0;
const int thermoPin = 1;
const int distancePin = 2;
const int ledPin = 13;
const int multiCurrentTempPin = 11;
const int multiWantedTempPin = 6;
const int servoPin = 9;

const String SEC = " sec";

int lastDelivery = 0;
long clockTime = 0;

float temperatures[ARRAY_SIZE];

int servoDelayBetweenStep;
Servo servo;
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);


void setup() {
  Serial.begin(9600);
  analogReference(EXTERNAL);
  pinMode(ledPin, OUTPUT);
  pinMode(multiCurrentTempPin, OUTPUT);
  pinMode(multiWantedTempPin, OUTPUT);
  pixels.begin();
  servo.attach(servoPin);
  servo.write(closed);
  digitalWrite(ledPin, HIGH);
  delay(1500);
  Serial.print("Pot: "); Serial.println(analogRead(wantedTempPin));
}

void loop() {
  outputTempAsVoltage();
  printDebugInfo();
  updatePixels();
  deliver(nbDelivery);

  int nextDeliveryTime = getNextDeliveryTime();
  while (lastDelivery < nextDeliveryTime) {
    outputTempAsVoltage();
    printDebugInfo();
    updatePixels();
    wait1SecAndBlink();
    clockTime++;
    lastDelivery++;
    nextDeliveryTime = getNextDeliveryTime();
  }
}

void updatePixels(){
  float t = getTemperature();
  float wt = getWantedTemperature();
  int temp = map(b((int) (t+0.5)),(int) minWantedTemp,(int) maxWantedTemp,0, NUMPIXELS-1);
  int wanted = map(b((int) (wt+0.5)),(int) minWantedTemp,(int) maxWantedTemp,0, NUMPIXELS-1);
  int timer = map(lastDelivery,0,getNextDeliveryTime(),0, NUMPIXELS-1);
  
  for (int i = 0; i < NUMPIXELS; i++) {
    int red =0;
    int green =0;
    int blue =0;
    pixels.setPixelColor(i,pixels.Color(0, 0, 0));
    if(wanted >= i){
     if( t >= wt ){
        green = 10;
     }else {
        green = map(bounded((int) ( wt- t + 0.5), 0, 5), 0,5,50,120);
     }
  }
    
  if ( lastDelivery % 2 == 0 && temp == i ) {
      if( (int) (t+0.5) < minWantedTemp || (int) (t+0.5)> maxWantedTemp){
        green = 0;
        red = 20;
        blue = 20;
      }else{
        blue = 20;
        green = 0;
      }
    }
    if(timer == i ){
      red =  red+10;
      green =  green+10;
      blue =  blue+10;
    }
    pixels.setPixelColor(i, pixels.Color(red, green, blue));

  }
  pixels.show();
}

int b(int value){
  return bounded( value, minWantedTemp,maxWantedTemp);
}
int bounded(int value, int min, int max){
  if(value<min){
    return min;
  }
  if(value>max){
    return max;
  }
  return value;
}
  
void wait1SecAndBlink(){
  if(getDifferenceTemperature()>0){
    if (lastDelivery % 4 < 2 ) {
        digitalWrite(ledPin, LOW);
      delay(1000);
      return;
    }else{
        digitalWrite(ledPin, HIGH);
      delay(1000);
      return;
    }
  }else{
    digitalWrite(ledPin, LOW);
    delay(250);
    digitalWrite(ledPin, HIGH);
    delay(250);
    digitalWrite(ledPin, LOW);
    delay(250);
    digitalWrite(ledPin, HIGH);
    delay(250);
    return;
  }
}

void outputTempAsVoltage(){
  analogWrite(multiCurrentTempPin, map(abs(getTemperature()*10), 0, 500, 0,255));
  analogWrite(multiWantedTempPin, map(abs(getWantedTemperature()*10), 0, 500, 0,255));
}


int getNextDeliveryTime() {
  float diff = getDifferenceTemperature();
  
  if (diff < -3) {
    return minWaitTimeInSec;
  }

  if (diff < 0) {
    return mediumWaitTimeInSec;
  }
  return maxWaitTimeInSec;
}

float getDifferenceTemperature() {
  return getTemperature() - getWantedTemperature();
}

float getWantedTemperature() {
  return mapf(analogRead(wantedTempPin), 3, 1023, maxWantedTemp, minWantedTemp);
}

double mapf(double val, double in_min, double in_max, double out_min, double out_max) {
  return (val - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

float getSingleTemperature() {
   int tempReading = analogRead(thermoPin);

  // converting that reading to voltage, which is based off the reference voltage
  float voltage = tempReading * arefVoltage;
  voltage /= 1024.0;
  float temperatureC = (voltage - 0.5) * 100; //converting from 10 mv per degree wit 500 mV offset
  //to degrees ((voltage - 500mV) times 100)
   return temperatureC;
}

float getTemperature() {
   temperatures[clockTime % ARRAY_SIZE] = getSingleTemperature();
   return avg(temperatures);
}


float avg( float values[]){
  int elements = 0;  
  float sum = 0.0;
  for(int i = 0; i < ARRAY_SIZE ; i++){
    if(values[i] != 0.0){
      sum = values[i] + sum;
      elements++;
    }
  }
  return sum / (float) elements;
}

void deliver(int times) {
  for (int i = 0; i < times; i++) {

    int pos;
    for (pos = closed; pos <= opened; pos += 3) {
      servoDelayBetweenStep = sq(servoSpeed);
      servo.write(pos);
      delay(servoDelayBetweenStep);
    }
    delay(openTimeInMs);
    for (pos = opened; pos >= closed; pos -= 3) {
      servoDelayBetweenStep = sq(servoSpeed); 
      servo.write(pos);
      delay(servoDelayBetweenStep);
    }
  }
  lastDelivery = 0;
}



void printDebugInfo() {
  if( infoUpdateFrequencyInSec == -1){
    return;
  }
  if (lastDelivery % infoUpdateFrequencyInSec != 0) {
    return;
  }
  float ta = getTemperature();
  float tv = getWantedTemperature();
  Serial.print("[");
  for(int i = 0; i<30; i++){
     if((int)tv >i){
      Serial.print("#");
    }else{
      Serial.print("."); 
    }
    if((int)ta == i){
      Serial.print("*");
    }
  }
  Serial.println("]");
  Serial.print("Temperature: Ambiante: ");  Serial.print(ta);  Serial.print("C, "); 
  Serial.print("Voulue: ");  Serial.print(tv);  Serial.print("C ("); Serial.print(tv - ta); Serial.print("C) ");
  if (ta > tv) {
    Serial.println("pas besoin de chauffer");
  } else {
    Serial.println("besoin de chauffer");
  }
  Serial.print("Ouverture: Derniere: "); Serial.print(lastDelivery); Serial.print("sec, ");
  int nextDeliveryTime = getNextDeliveryTime();
  Serial.print("Prochaine: "); Serial.print(nextDeliveryTime); Serial.print("sec (dans "); 
  Serial.print(nextDeliveryTime - lastDelivery);
  Serial.println("sec)");
}

// int nbMeasurements = 10;
// float measurements[nbMeasurements];
// for ( int i = 0; i < nbMeasurements; i = i + 1) {
// measurements[i] = getTemperature();
// }
// float temp = median(measurements);
// Serial.print("median temp:"); Serial.print(temp); Serial.print("C, ");
// Serial.print("temp:"); Serial.print(getTemperature()); Serial.println("C, ");
//
//
// float median(float x[]) {
// int n = sizeof(x);
// float temp;
// int i, j;
// // the following two loops sort the array x in ascending order
// for(i=0; i<n-1; i++) {
// for(j=i+1; j<n; j++) {
// if(x[j] < x[i]) {
// // swap elements
// temp = x[i];
// x[i] = x[j];
// x[j] = temp;
// }
// }
// }
//
// if(n%2==0) {
// // if there is an even number of elements, return mean of the two elements in the middle
// return((x[n/2] + x[n/2 - 1]) / 2.0);
// } else {
// // else return the element in the middle
// return x[n/2];
// }
// }