Last active
October 11, 2018 19:15
-
-
Save mathieu-fanduel/df15751ebf109702dfdcd03190e8abec to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// 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); | |
} | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#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)"); | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
// 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];
// }
// }