转载:老外的esp8266双路31855温度计

//heat and food temp monitor
//MAX31855 (2 pieces)
//Blynk
//Piezo alarm - TBC
//OLED display
//OTA update = http://192.168.0.5/update

#include< ESP8266WiFi.h>
#include< ESP8266mDNS.h>
#include< WiFiUdp.h>
#include< ArduinoOTA.h>
#include< ESP8266WebServer.h>
#include< ESP8266mDNS.h>
#include< ESP8266HTTPUpdateServer.h>
#include< BlynkSimpleEsp8266.h>
#include< SimpleTimer.h>
#include< Wire.h>
#include< MAX31855.h>
#include< Adafruit_GFX.h>
#include< Adafruit_SSD1306.h>
#include< TimeLib.h>
#include< WidgetRTC.h>
#include "RunningMedian.h"

#define debug 1 // turns debugging serial prints on/off.
#define BLYNK_PRINT Serial //this is the debugging for Blynk

#define MISO 12 //data/"signal out"
#define SCK 13 // clock
#define heatCS 14 //chip select
#define foodCS 16 //chip select
#define piezoBuzzer 2 // pin for piezo buzzer, is ALSO the internal ESP8266 blue LED...
// NB - pins 4& 5 are SDA& SCL for OLED on ESP8266
#define OLED_RESET 3 //CAREFUL OF CHANGING THIS PIN ASSIGNMENT!!!!!!!!! (try to remove it later on...)

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2
#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH  16
static const unsigned char PROGMEM logo16_glcd_bmp[] =
{ B00000000, B11000000,
   B00000001, B11000000,
   B00000001, B11000000,
   B00000011, B11100000,
   B11110011, B11100000,
   B11111110, B11111000,
   B01111110, B11111111,
   B00110011, B10011111,
   B00011111, B11111100,
   B00001101, B01110000,
   B00011011, B10100000,
   B00111111, B11100000,
   B00111111, B11110000,
   B01111100, B11110000,
   B01110000, B01110000,
   B00000000, B00110000
};

Adafruit_SSD1306 display(OLED_RESET);

MAX31855 foodProbe = MAX31855(MISO, foodCS, SCK);
MAX31855 heatProbe = MAX31855(MISO, heatCS, SCK);

RunningMedian samplesFoodTemperature = RunningMedian(20); //this takes XX samples
RunningMedian samplesHeatTemperature = RunningMedian(20); //this takes XX samples

WidgetRTC rtc;

WiFiClient client;
ESP8266WebServer httpServer(80);
ESP8266HTTPUpdateServer httpUpdater;
IPAddress gateway(192, 168, 0, 1);
IPAddress subnet(255, 255, 255, 0);

SimpleTimer timer;

const char* host = "esp8266_DUAL_MAX31855"; // will be "esp8266_XYZ.local/update" in web browser

const char* ssid = "abc";
const char* password = "123";
char authBlynk[] = "Costas_rulez";

int startHeat, heatTime, startHeatTime, heatTimerTimer;
int startFood, foodTime,  startFoodTime, foodTimerTimer;

int heatTemperature, foodTemperature;
int medianHeatTemperature, medianFoodTemperature;
int heatTemperatureMax = 0;
int foodTemperatureMax = 0;
int displayFreq = 2000L; // sets display update frequency
int displayTimer2, displayTimer3; //timers to call display update functions

int tempChangeFreq = 120L * 1000L; //time period to check temp changes
int tempChangeTimer; //name of timer to call temp change calculation function
int previousHeatTemperature, previousFoodTemperature; // to track temp changes over time
int oldPreviousHeatTemperature, oldPreviousFoodTemperature;
int newHeatTemperature, newFoodTemperature;
int heatTempChangePercent, foodTempChangePercent; //the variables produced from the calculation

int foodWarningTemp, heatWarningTemp; //temp that the notify is set to go off at
int heatWarningOffset = 12; //this is how much below the full warning temp the "pre" warning temp is.
int foodWarningOffset = 4; //this is how much below the full warning temp the "pre" warning temp is.

int food_h, food_m, food_s; //used for the food timer
int heat_h, heat_m, heat_s; //used for the heat timer

int setMode; //this is for the Blynk menu widget with a few commands in it, like reset temps and changing the warning parameters...

unsigned long notifyPeriodHeat = 0;
const long notifyTimeHeat = 60L * 1000L; //means its XX seconds between Heat notifications
unsigned long notifyPeriodFood = 0;
const long notifyTimeFood = 60L * 1000L; //means its XX seconds between Food notifications

unsigned long tempChangePeriodFood = 0;
const long tempChangeTimeFood = 15L * 1000L; //means its XX seconds between Food calcs
unsigned long tempChangePeriodHeat = 0;
const long tempChangeTimeHeat = 15L * 1000L; //means its XX seconds between Heat calcs

BLYNK_WRITE(V1)   // start heat timer button
{
   startHeat = param.asInt();
   if (startHeat == 1)
   {
   startHeatTime = now();
   heatTimer();
   }
}

void heatTimer()
{
   heatTimerTimer = timer.setTimeout(20L * 1000L, heatTimer);// timing counts every XX seconds
   if (startHeat == 1)
   {
   heat_s = (now() - startHeatTime);
   heat_m = heat_s / 60;
   heat_h = heat_s / 3600;
   heat_s = heat_s - heat_m * 60;
   heat_m = heat_m - heat_h * 60;
   Blynk.virtualWrite(V5, heat_h, "h ", heat_m, "m");
   }
}

BLYNK_WRITE(V2)   // start food timer button
{
   startFood = param.asInt();
   if (startFood == 1)
   {
   startFoodTime = now();
   foodTimer();
   }
}

void foodTimer()
{
   foodTimerTimer = timer.setTimeout(20L * 1000L, foodTimer);// timing counts every XX seconds
   if (startFood == 1)
   {
   food_s = (now() - startFoodTime);
   food_m = food_s / 60L;
   food_h = food_s / 3600L;
   food_s = food_s - food_m * 60L;
   food_m = food_m - food_h * 60L;
   Blynk.virtualWrite(V6, food_h, "h ", food_m, "m");
   }
}

BLYNK_WRITE(V10)  // food warning stepper
{
   foodWarningTemp = param.asInt();
   Blynk.virtualWrite(V4, foodWarningTemp, "'C");
}

BLYNK_WRITE(V9)  // heat warning stepper
{
   heatWarningTemp = param.asInt();
   Blynk.virtualWrite(V3, heatWarningTemp, "'C");
}

BLYNK_WRITE(V0) // mode selection drop down menu
{
   setMode = param.asInt();
   {
   if (setMode == 1) // reset max temps
   {
     foodTemperatureMax = 0;
     heatTemperatureMax = 0;
     Blynk.virtualWrite(V7, 0);
     Blynk.virtualWrite(V8, 0);
   }
   else if (setMode == 2) // heat pre-warning offset up
   {
     heatWarningOffset = heatWarningOffset + 1;
     Blynk.virtualWrite(V13, heatWarningOffset, "'C");
   }
   else if (setMode == 3) // heat pre-warning offset dwn
   {
     heatWarningOffset = heatWarningOffset - 1;
     Blynk.virtualWrite(V13, heatWarningOffset, "'C");
   }
   else if (setMode == 4) // food pre-warning offset up
   {
     foodWarningOffset = foodWarningOffset + 1;
     Blynk.virtualWrite(V14, foodWarningOffset, "'C");
   }
   else if (setMode == 5) // food pre-warning offset dwn
   {
     foodWarningOffset = foodWarningOffset - 1;
     Blynk.virtualWrite(V14, foodWarningOffset, "'C");
   }
   else if (setMode == 6) // spare
   {
     ///TBA
   }
   }
}

void readMAX31855HeatProbe()
{
   heatTemperature = heatProbe.readThermocouple(CELSIUS);
   Blynk.virtualWrite(V15, heatTemperature, "'C");
   switch ((int) heatTemperature)
   {
   case FAULT_OPEN:
     Serial.println("heatprobe: FAULT_OPEN");
     break;
   case FAULT_SHORT_GND:
     Serial.println("heatprobe: FAULT_SHORT_GND");
     break;
   case FAULT_SHORT_VCC:
     Serial.println("heatprobe: FAULT_SHORT_VCC");
     break;
   case NO_MAX31855:
     Serial.println("heatprobe: NO_MAX31855");
     break;
   default:
     Serial.print("heatprobe: ");
     Serial.println(heatTemperature);
     break;
   }

   medianHeatTemperature = samplesHeatTemperature.getMedian();
   samplesHeatTemperature.add(heatTemperature);

   if ((medianHeatTemperature< 888)&& (heatTemperatureMax >= medianHeatTemperature))
   {
   Blynk.virtualWrite(V11, medianHeatTemperature);
   }
   else if ((medianHeatTemperature< 888)&& (heatTemperatureMax< medianHeatTemperature))
   {
   Blynk.virtualWrite(V11, medianHeatTemperature);
   heatTemperatureMax = medianHeatTemperature;
   Blynk.virtualWrite(V7, heatTemperatureMax, "'C");
   }
   else if (medianHeatTemperature > 888)
   {
   Blynk.virtualWrite(V11, 999);
   }
   readMAX31855FoodProbe();
}

void readMAX31855FoodProbe()
{
   foodTemperature = foodProbe.readThermocouple(CELSIUS);
   Blynk.virtualWrite(V16, foodTemperature, "'C");
   switch ((int) foodTemperature)
   {
   case FAULT_OPEN:
     Serial.println("foodprobe: FAULT_OPEN");
     break;
   case FAULT_SHORT_GND:
     Serial.println("foodprobe: FAULT_SHORT_GND");
     break;
   case FAULT_SHORT_VCC:
     Serial.println("foodprobe: FAULT_SHORT_VCC");
     break;
   case NO_MAX31855:
     Serial.println("foodprobe: NO_MAX31855");
     break;
   default:
     Serial.print("foodprobe: ");
     Serial.println(foodTemperature);
     break;
   }

   medianFoodTemperature = samplesFoodTemperature.getMedian();
   samplesFoodTemperature.add(foodTemperature);

   if ((medianFoodTemperature< 888)&& (foodTemperatureMax >= medianFoodTemperature))
   {
   Blynk.virtualWrite(V12, medianFoodTemperature);
   }
   else if ((medianFoodTemperature< 888)&& (foodTemperatureMax< medianFoodTemperature))
   {
   Blynk.virtualWrite(V12, medianFoodTemperature);
   foodTemperatureMax = medianFoodTemperature;
   Blynk.virtualWrite(V8, foodTemperatureMax, "'C");
   }
   else if (medianFoodTemperature > 888)
   {
   Blynk.virtualWrite(V12, 999);
   }
   checkHeatTemp();
}

void checkHeatTemp()
{
   unsigned long currentMillis = millis();
   if ((medianHeatTemperature< heatWarningTemp)&& ((medianHeatTemperature + heatWarningOffset) > heatWarningTemp))
   {
   if (((currentMillis - notifyPeriodHeat) > notifyTimeHeat)&& (medianHeatTemperature< 888))
   {
     Blynk.notify(String("Heat temp APPROACHING warning temp: ") + medianHeatTemperature + ("'C - go check it..."));
     notifyPeriodHeat = currentMillis;
   }
   }
   else if (medianHeatTemperature >= heatWarningTemp)
   {
   if (((currentMillis - notifyPeriodHeat) > notifyTimeHeat)&& (medianHeatTemperature< 888))
   {
     Blynk.notify(String("Heat temp getting TOOOO HIGHHH: ") + medianHeatTemperature + ("'C - go check it!!!"));
     notifyPeriodHeat = currentMillis;
   }
   //runAlarmFunction();
   }
   Blynk.virtualWrite(V13, "-", heatWarningOffset, "'C");
   checkFoodTemp();
}

void checkFoodTemp()
{
   unsigned long currentMillis = millis();
   if ((medianFoodTemperature< foodWarningTemp)&& ((medianFoodTemperature + foodWarningOffset) > foodWarningTemp))// temp creeping up
   {
   if (((currentMillis - notifyPeriodFood) > notifyTimeFood)&& (medianFoodTemperature< 169))
   {
     Blynk.notify(String("Food temp APPROACHING warning temp: ") + medianFoodTemperature + ("'C - go check it..."));
     notifyPeriodFood = currentMillis;
   }
   }
   else if (medianFoodTemperature >= foodWarningTemp)
   {
   if (((currentMillis - notifyPeriodFood) > notifyTimeFood)&& (medianFoodTemperature< 169))
   {
     Blynk.notify(String("Food temp getting TOOO HIGGHHH: ") + medianFoodTemperature + ("'C - go check it!!!"));
     notifyPeriodFood = currentMillis;
   }
   //runAlarmFunction();
   }
   Blynk.virtualWrite(V14, "-", foodWarningOffset, "'C");
   displayUpdate1();
}

void checkTempChange()
{
   previousHeatTemperature = heatTemperature;
   previousFoodTemperature = foodTemperature;
   timer.setTimeout(10000L, checkTempChange1);
}

void checkTempChange1()
{
   oldPreviousFoodTemperature = previousFoodTemperature;
   timer.setTimeout(10000L, checkTempChange2);
}

void checkTempChange2()
{
   newHeatTemperature = heatTemperature;
   heatTempChangePercent = (((newHeatTemperature - oldPreviousHeatTemperature) * 100) / newHeatTemperature);
   Blynk.virtualWrite(V3, heatTempChangePercent, "%");

   newFoodTemperature = foodTemperature;
   foodTempChangePercent = (((newFoodTemperature - oldPreviousFoodTemperature) * 100) / newFoodTemperature);
   Blynk.virtualWrite(V4, foodTempChangePercent, "%");
   Blynk.virtualWrite(V17, oldPreviousFoodTemperature);
   Blynk.virtualWrite(V18, newFoodTemperature);
}

void displayUpdate1()
{
   display.clearDisplay();
   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 0);
   display.println("ELAPSED HEAT TIME:");

   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 16);
   display.print(heat_h);
   display.print("h ");
   display.print(heat_m);
   display.println("m");

   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 32);
   display.println("ELAPSED COOK TIME:");

   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 48);
   display.print(food_h);
   display.print("h ");
   display.print(food_m);
   display.println("m");
   display.display();

   displayTimer2 = timer.setTimeout(displayFreq, displayUpdate2);
}

void displayUpdate2()
{
   display.clearDisplay();
   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 0);
   display.println("HEAT WARNING TEMP:");

   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 16);
   display.print(heatWarningTemp);
   display.print((char)247);
   display.println("C");

   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 32);
   display.println("FOOD WARNING TEMP:");

   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 48);
   display.print(foodWarningTemp);
   display.print((char)247);
   display.println("C");
   display.display();

   displayTimer3 = timer.setTimeout(displayFreq, displayUpdate3);
}

void displayUpdate3()
{
   display.clearDisplay();
   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 0);
   display.println("HEAT PROBE TEMP:");

   if (medianHeatTemperature > 1000)
   {
   medianHeatTemperature = 0;
   }
   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 16);
   display.print(medianHeatTemperature);
   display.print((char)247);
   display.println("C");

   display.setTextSize(1);
   display.setTextColor(WHITE);
   display.setCursor(0, 32);
   display.println("FOOD PROBE TEMP:");

   if (medianFoodTemperature > 1000)
   {
   medianFoodTemperature = 0;
   }
   display.setTextSize(2);
   display.setTextColor(WHITE);
   display.setCursor(32, 48);
   display.print(medianFoodTemperature);
   display.print((char)247);
   display.println("C");
   display.display();
   Serial.println(F("__________"));
}


void runAlarmFunction()
{ //tone(piezoBuzzer, 1000); // Send 1KHz sound signal...
   //delay(1000);       // ...for 1 sec
   //noTone(piezoBuzzer);     // Stop sound...
   //delay(1000);       // ...for 1sec
}

void setup()
{
   Serial.begin(115200);
   Serial.println(F(""));
   Serial.println(F("Cooking heat& food temp MONITOR"));
   Serial.print(F("File name: "));
   Serial.println(__FILE__);

   //Blynk.begin(authBlynk, ssid, password); // this is for roaming profile
   Blynk.begin(authBlynk, ssid, password, IPAddress(192, 168, 0, 7));

   ArduinoOTA.setHostname("Multi-MAX31855-Node08");

   ArduinoOTA.onStart([]() {
   Serial.println("Start");
   });
   ArduinoOTA.onEnd([]() {
   Serial.println("\nEnd");
   });
   //ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
   //  Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
   //});
   ArduinoOTA.onError([](ota_error_t error) {
   Serial.printf("Error[%u]: ", error);
   if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
   else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
   else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
   else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
   else if (error == OTA_END_ERROR) Serial.println("End Failed");
   });
   ArduinoOTA.begin();
   Serial.println("Ready - OTA Success!!!");
   Serial.print("IP address: ");
   Serial.println(WiFi.localIP());
   MDNS.begin(host);
   httpUpdater.setup(&httpServer);
   httpServer.begin();
   MDNS.addService("http", "tcp", 80);
   String ipaddress = WiFi.localIP().toString();
   String chipID = String(ESP.getChipId(), HEX);
   char charChipID[10];
   chipID.toCharArray(charChipID, sizeof(charChipID));
   char charipaddress[16];
   ipaddress.toCharArray(charipaddress, sizeof(charipaddress));
   Serial.printf("Now open http://%s.local/update in your browser or \n", host);
   Serial.printf("http://%s/update or http://%s.lan/update if you prefer.\n", charipaddress, charChipID);

   Serial.println(F("Where's Blynk??"));
   while (!Blynk.connect())
   {
   delay(50);
   Serial.print(F(". "));
   }

   Serial.println(F(""));
   Serial.println(F("Found some WiFi!"));
   Serial.println(F("------------"));

   Blynk.virtualWrite(V1, 0);
   Blynk.virtualWrite(V2, 0);
   Blynk.virtualWrite(V5, 0);
   Blynk.virtualWrite(V6, 0);
   Blynk.virtualWrite(V7, 0);
   Blynk.virtualWrite(V8, 0);
   Blynk.virtualWrite(V11, 0);
   Blynk.virtualWrite(V12, 0);
   Blynk.virtualWrite(V13, 0);
   Blynk.virtualWrite(V14, 0);

   bool isFirstConnect = true; // Keep this flag not to re-sync on every reconnection

   BLYNK_CONNECTED(); // This function will run every time Blynk initial connection is established
   {
   if (isFirstConnect)
   {
     Blynk.syncAll();
     isFirstConnect = false;
   }
   }
   rtc.begin();

   Serial.println(F("We operate under< SimpleTimer.h> now..."));
   timer.setInterval(8000L, readMAX31855HeatProbe);
   timer.setInterval(20L * 1000L, checkTempChange);

   display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3_
   display.display();
   display.clearDisplay();
}

void loop()
{
   Blynk.run(); // Initiates Blynk
   timer.run(); // Initiates SimpleTimer
   ArduinoOTA.handle();
   httpServer.handleClient();
}