Published March 2, 2019 © GPL3+

Alexa, Tell My Steak to Be Medium Rare

A smart home sous-vide cooker with Sony Spresense.

BeginnerShowcase (no instructions)20 hours806

Things used in this project

Hardware components

Sony Spresense boards (main & extension)

Adafruit RGB Backlight LCD - 16x2

WS401 Temperature Chip

433MHz Sender & Receiver

Immersion Coil

Remote Power Socket

Button

313

Jumper wires (generic)

Espressif ESP8266 ESP-12E

Speaker Chinch Audio

Micro SD Card

Hand tools and fabrication machines

Wood

Story

Because it's not BBQ time in Europe currently, I have to cook my steak in the pan. Making the steak perfectly medium rare or well-done is a science for itself. Therefore, I decided to create something like a sous-vide cooker with my Sony Spresense, connected as smart home device to Amazon Alexa, and with audio output when finished cooking. I can either start the cooking process by Alexa with the command "Alexa, tell my steak to be medium rare," or use some buttons connected to the Spresense to set temperature and duration. Of course, besides steak it's also possible to cook vegetables inside the with water filled pot at different temperatures and durations.

I'm using an immersion coil to heat up the water. A thermistor is measuring the temperature. To heat or stop heating, I decided to not use a MOSFET or relay, because I didn't want to cut the power cable. I came up with the idea of using a remote power socket, controlable by 433MHz frequency. They are cheap and it was no problem because the coil doesn't have a start button that needs to be pushed to start.

Temperature Sensor

At first, I needed to measure the temperature. My WS401 had a water resistant thermistor which suits perfect. To read the temperature, you measure the resistance, or better the voltage division. Therefore you need the know the default restistance of your thermistor. In my case I used a multimeter and measured 10k Ohm resistance. With the help of another resistor with the same resistance, you can create a small circuit for measurement. See Using a thermistor for some more information. Unfortunately, the Spresense only accepts 5V analog reading, also the link suggests to use 1.1V internal reference for more precise readings.

To calculate the temperature, you can use the Steinhart Equation. But it requires some unknown constants a, b and c, which was the second challenge with the thermistor. Also, I don't have a ntc-thermistor, what makes me not able to use the transformed β parameter equation that works without those unknown constants. To estimate the values, I have measure the resitance at three differnt temperatures 2°C, 50°C and 85°C, and used the gauß method to solve three steinhart equations, each with one of the measured temperature and resistance. The resistance needs to be calculated by equation R = 10K / (1023/ADC - 1). Afterwards, I had my unkown constants a, b and c for the calculation of all temperatures in between.

Remote Power Socket

The next step was dealing with the radio frequency to control the 433MHz power socket. I have a receiver and a sender. You need the receiver to retrieve the codes to power on and power off the socket. See 433MHhz for more information on how to use a 433MHz receiver and sender. For the final circuit, I only need the sender.

LCD Panel and Buttons

Having all those connected, I was able to read the temperature and switch the socket (and therefore the immersion coil) on and off. Connecting the buttons to the Spresense was quite easy. Using an interrupt, I have conneted the buttons to the pins PIN-2, PIN-3 and PIN-4 of the Spresense's extension board. The interrupts execute when the pins get LOW. The result has 4 states, set temperature, set duration, cooking and finished. The temperature and the duration can be increased und decreased with one pin each. The last pin is to confirm and switch the states. An LCD was added to show the states and enable the user to define the paramters for the cooking.

LCD panel

Up to now, the solution was able to work independently and fullfill the main requirements.

Alexa Voice Control

As for Smart Home standards, the device needs to be controlable by remote. I decided to use the Alexa for starting the cooking process. Unfortunately, the Spresense doesn't have a WiFi connection. After some problems with other remote technologies (such as RF24L01) I decided used an ESP2866 to receive the remote actions and pass them via UART serial communication to the Spresense. Currently, it's a one-way communication only, but this can be extended by yourself if needed. For the UART communication you must connect the pin RX of the Spresense with the TX of ESP, and the TX with the RX. The next important information is to use Serial2 of the Spresense for receiving commands. Similar to one of my previous projects Herb Box Eco System I have created an Alexa Skill with the intents to start the cooking process. The intent's parameters are forwarded to a website (php + mySQL database), wich is further requested by the ESP. A new action entry is removed and send via UART to the Spresense.

The intents inside the Alexa skill are:

"tell my steak to be [option]" (option: "medium rare" = 52°C and 90 minutes, "well done" = 60°C and 60 minutes)
"start cooking with [degrees] degrees for [minutes] minutes" (degrees and minutes are numbers)
"start cooking for [minutes] minutes with [degrees] degrees" (degrees and minutes are numbers)

Last but not least, I added audio to give feedback when the cooking process is done. For the audio, I used the tutorial from Hackster. I was able to run an mp3 file from a SD card once and connected an external speaker by the audio jack. Here is still some optimization possible, because the speaker needs to be alive for the full time and the audio was only able to play once (https://stackoverflow.com/questions/54305160/repeatedly-play-audio-on-sony-spresense your help is welcome).

Result

I put the meat into a sous-vide vacuum film.

Steak in vacuum film

I asked Alexa to make my steak medium rare. This started the cooker for 90 minutes with 52°C.

Full circuit in action, while cooking

I enjoyed the dish afterwards.

Delicious result

Code

#ifndef CONFIGURATION_H
#define CONFIGURATION_H

// --- general ---
#define SERIAL_BAUD 115200

// --- 433MHz ---
#define RC_SND_PIN  5
#define RC_POWER_ON    "010001000001110100000011"
#define RC_POWER_OFF   "010001000001110100001100"

// --- Thermistor ---
#define THERM_VCC_PIN  6
#define THERM_ARD_PIN  A0
#define THERM_CNT_RD   3
#define THERM_SHE_A    3.49004e-03
#define THERM_SHE_B    1.38558e-04
#define THERM_SHE_C   -1.94967e-06

#endif

// Free Text to mp3
// https://www.texttomp3.online/

#include <RCSwitch.h>
#include "Configuration.h"
#include "RcHandler.h"

RCSwitch *rcSwitch = NULL;

void RcHandler::setup(byte sndPin, byte rcvPin, int protocol, int pulseLength) {
  Serial.print(F("[433Mhz] Initialize switch... "));
  rcSwitch = new RCSwitch();
  rcSwitch->enableTransmit(sndPin);
  rcSwitch->enableReceive(rcvPin);
  rcSwitch->setProtocol(protocol);
  rcSwitch->setPulseLength(pulseLength);
  Serial.println(F("done"));
}

void RcHandler::powerOn() {
  noInterrupts();
  Serial.println(F("[433Mhz] Power On"));
  rcSwitch->send(RC_POWER_ON);
  interrupts();
}

void RcHandler::powerOff() {
  noInterrupts();
  Serial.println(F("[433Mhz] Power Off"));
  rcSwitch->send(RC_POWER_OFF);
  interrupts();
}

void RcHandler::loop() {
  if (rcSwitch->available()) {
    noInterrupts();
    Serial.println(F("[433MHz] >> Signal received:"));
    output(
      rcSwitch->getReceivedValue(),
      rcSwitch->getReceivedBitlength(),
      rcSwitch->getReceivedDelay(),
      rcSwitch->getReceivedRawdata(),
      rcSwitch->getReceivedProtocol());
    rcSwitch->resetAvailable();
    Serial.println(F("[433MHz] << Signal received"));
    interrupts();
  }
}

void RcHandler::output(unsigned long decimal, unsigned int length, unsigned int delay, unsigned int* raw, unsigned int protocol) {

  const char* b = dec2binWzerofill(decimal, length);
  Serial.print(F("Decimal: "));
  Serial.print(decimal);
  Serial.print(F(" ("));
  Serial.print(length);
  Serial.print(F("Bit) Binary: "));
  Serial.print(b);
  Serial.print(F(" Tri-State: "));
  Serial.print(bin2tristate( b));
  Serial.print(F(" PulseLength: "));
  Serial.print(delay);
  Serial.print(F(" microseconds"));
  Serial.print(F(" Protocol: "));
  Serial.println(protocol);

  Serial.print(F("Raw data: "));
  for (unsigned int i = 0; i <= length * 2; i++) {
    Serial.print(raw[i]);
    Serial.print(F(","));
  }
  Serial.println();
}

char* RcHandler::bin2tristate(const char* bin) {
  static char returnValue[50];
  int pos = 0;
  int pos2 = 0;
  while (bin[pos] != '\0' && bin[pos + 1] != '\0') {
    if (bin[pos] == '0' && bin[pos + 1] == '0') {
      returnValue[pos2] = '0';
    } else if (bin[pos] == '1' && bin[pos + 1] == '1') {
      returnValue[pos2] = '1';
    } else if (bin[pos] == '0' && bin[pos + 1] == '1') {
      returnValue[pos2] = 'F';
    } else {
      return "not applicable";
    }
    pos = pos + 2;
    pos2++;
  }
  returnValue[pos2] = '\0';
  return returnValue;
}

char* RcHandler::dec2binWzerofill(unsigned long Dec, unsigned int bitLength) {
  static char bin[64];
  unsigned int i = 0;

  while (Dec > 0) {
    bin[32 + i++] = ((Dec & 1) > 0) ? '1' : '0';
    Dec = Dec >> 1;
  }

  for (unsigned int j = 0; j < bitLength; j++) {
    if (j >= bitLength - i) {
      bin[j] = bin[ 31 + i - (j - (bitLength - i)) ];
    } else {
      bin[j] = '0';
    }
  }
  bin[bitLength] = '\0';

  return bin;
}

#ifndef RCHANDLER_H
#define RCHANDLER_H

#include <Arduino.h>

// 433MHz device
class RcHandler {
public:
  static void setup(byte sndPin, byte rcvPin, int protocol = 1, int pulseLength = 185); // pin 16 (D0)
  static void loop();
  static void output(unsigned long decimal, unsigned int length, unsigned int delay, unsigned int* raw, unsigned int protocol);
  static char* bin2tristate(const char* bin);
  static char* dec2binWzerofill(unsigned long Dec, unsigned int bitLength);

  static void powerOn();
  static void powerOff();
};
#endif

#include <Audio.h>
#include <LiquidCrystal.h>
#include <OneButton.h>
#include <SDHCI.h>
#include "Configuration.h"
#include "RcHandler.h"
#include "Thermistor.h"

float targetTemperature = 27.0; // in degree celsius
int targetDuration = 120; // in seconds

float currentTemperature;
unsigned long totalDuration, currentMillis, startMillis, lastDecision;
int decisionInterval = 5000;
bool finished;
volatile int currentState = 0;
char tMin[3], tSec[2], cMin[3], cSec[2];

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
OneButton button1(2, true);
OneButton button2(3, true);
OneButton button3(4, true);

void isrButton1();
void isrButton2();
void isrButton3();
void click1();
void click2();
void click3();
void longPress1();
void longPress2();
void tickButtons();
void delayWithTicks(int delayMilli);

static void audioErrorCallback(const ErrorAttentionParam *atprm);
bool initializeSound();

SDClass theSD;
AudioClass *theAudio;
File soundFileFinished;
File soundFileStart;
bool useSound, soundFinished;

void setup() {
  Serial.begin(SERIAL_BAUD);
  while (!Serial);
  RcHandler::setup(RC_SND_PIN, 6);

  lcd.begin(16, 2);
  lcd.print("Welcome");
  lcd.setCursor(0, 1);
  lcd.print("I'm booting...");

  button1.attachClick(click1);
  button2.attachClick(click2);
  button3.attachClick(click3);
  button1.attachDuringLongPress(longpress1);
  button2.attachDuringLongPress(longpress2);

  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  attachInterrupt(2, tickButtons, LOW);
  attachInterrupt(3, tickButtons, LOW);
  attachInterrupt(4, tickButtons, LOW);

  currentState = 0;
  useSound = initializeSound();
  Serial.print("[SOUND] Use sound: ");
  Serial.println(useSound);

  Serial.println("[SETUP] Done...");
}

void loop() {
  tickButtons();
  switch (currentState) {
    case 0: selectDuration(); break;
    case 1: selectTemperature(); break;
    case 2: executeCooking(); break;
    case 3: finishedCooking(); break;
  }
  delayWithTicks(500);
  readSerial();
}

void showLcdState1() {
  String firstLine, secondLine;

  lcd.clear();
  firstLine.concat("Set Temperature");
  secondLine.concat(targetTemperature);
  secondLine.concat(" C");

  lcd.setCursor(0, 0);
  lcd.print(firstLine);
  lcd.setCursor(0, 1);
  lcd.print(secondLine);
}

void showLcdState0() {
  String firstLine, secondLine;
  sprintf(tMin, "%02d", targetDuration / 60);
  sprintf(tSec, "%02d", targetDuration % 60);

  lcd.clear();
  firstLine.concat("Set Duration");
  secondLine.concat(tMin);
  secondLine.concat("min ");
  secondLine.concat(tSec);
  secondLine.concat("sec");

  lcd.setCursor(0, 0);
  lcd.print(firstLine);
  lcd.setCursor(0, 1);
  lcd.print(secondLine);
}

void showLcdState2() {
  sprintf(tMin, "%02d", targetDuration / 60);
  sprintf(tSec, "%02d", targetDuration % 60);
  sprintf(cMin, "%02d", (currentMillis - startMillis) / 1000 / 60);
  sprintf(cSec, "%02d", (currentMillis - startMillis) / 1000 % 60);

  String firstLine, secondLine;

  lcd.clear();
  firstLine.concat(cMin);
  firstLine.concat(":");
  firstLine.concat(cSec);
  firstLine.concat(" / ");
  firstLine.concat(tMin);
  firstLine.concat(":");
  firstLine.concat(tSec);
  firstLine.concat(" m");
  secondLine.concat(currentTemperature);
  secondLine.concat(" / ");
  secondLine.concat(targetTemperature);
  secondLine.concat(" C");

  lcd.setCursor(0, 0);
  lcd.print(firstLine);
  lcd.setCursor(0, 1);
  lcd.print(secondLine);
}

void showLcdState3() {
  String firstLine, secondLine;

  lcd.clear();
  firstLine.concat(" -- Finished -- ");
  secondLine.concat(currentTemperature);
  secondLine.concat(" C");
  secondLine.concat("  -  [OK]");

  lcd.setCursor(0, 0);
  lcd.print(firstLine);
  lcd.setCursor(0, 1);
  lcd.print(secondLine);
}

void selectDuration() {
  showLcdState0();
}

void selectTemperature() {
  showLcdState1();
}

void executeCooking() {
  currentTemperature = Thermistor::readTemperature();

  if (!finished) {
    currentMillis = millis();

    if ((currentMillis - lastDecision) >= decisionInterval) {
      lastDecision = currentMillis;
      if (currentTemperature < targetTemperature) {
        RcHandler::powerOn();
      } else {
        RcHandler::powerOff();
      }
    }

    if ((currentMillis - startMillis) >= totalDuration) {
      finished = true;
      RcHandler::powerOff();
    }

  } else {
    RcHandler::powerOff();
    currentState = 3;
  }

  showLcdState2();
}

void finishedCooking() {
  currentTemperature = Thermistor::readTemperature();
  showLcdState3();

  if (!soundFinished) {
    int err = theAudio->writeFrames(AudioClass::Player0, soundFileFinished);
    if (err == AUDIOLIB_ECODE_FILEEND)
    {
      Serial.println("[SOUND] Finished sound!\n");
      soundFinished = true;
      theAudio->stopPlayer(AudioClass::Player0);
      soundFileFinished.close();
    }
  }

}

void tickButtons() {
  noInterrupts();
  button1.tick();
  button2.tick();
  button3.tick();
  interrupts();
}

void delayWithTicks(int delayMillis) {
  int split = delayMillis / 10;
  for (int i = 0; i < split; i++) {
    tickButtons();
    delay(10);
  }
}

void click1() {
  noInterrupts();
  switch (currentState) {
    case 0: {
        targetDuration += 5;
        showLcdState0();
        break;
      }
    case 1: {
        targetTemperature += 0.2;
        showLcdState1();
        break;
      }
    case 2: {
        targetTemperature += 0.2;
        showLcdState2();
        break;
      }
    case 3: break;
  }
  interrupts();
}

void longpress1() {
  noInterrupts();
  switch (currentState) {
    case 0: {
        targetDuration += 20;
        showLcdState0();
        break;
      }
    case 1: {
        targetTemperature += 1;
        showLcdState1();
        break;
      }
    case 2: {
        targetTemperature += 1;
        showLcdState2();
        break;
      }
    case 3: break;
  }
  interrupts();
}

void click2() {
  noInterrupts();
  switch (currentState) {
    case 0: {
        targetDuration -= 5;
        showLcdState0();
        break;
      }
    case 1: {
        targetTemperature -= 0.2;
        showLcdState1();
        break;
      }
    case 2: {
        targetTemperature -= 0.2;
        showLcdState2();
        break;
      }
    case 3: break;
  }
  interrupts();
}

void longpress2() {
  noInterrupts();
  switch (currentState) {
    case 0: {
        targetDuration -= 20;
        showLcdState0();
        break;
      }
    case 1: {
        targetTemperature -= 1;
        showLcdState1();
        break;
      }
    case 2: {
        targetTemperature -= 1;
        showLcdState2();
        break;
      }
    case 3: break;
  }
  interrupts();
}

void click3() {
  noInterrupts();
  switch (currentState) {
    case 0: {
        currentState = 1;
        showLcdState1();
        break;
      }
    case 1: {
        currentState = 2;
        initializeCooking();
        showLcdState2();
        break;
      }
    case 2: {
        currentState = 3;
        finished = true;
        soundFinished = false;
        theAudio->startPlayer(AudioClass::Player0);
        RcHandler::powerOff();
        showLcdState3();
        break;
      }
    case 3: {
        currentState = 0;
        initializeCooking();
        showLcdState0();
        break;
      }
  }
  interrupts();
}

void initializeCooking() {
  totalDuration = targetDuration * 1000;
  startMillis = millis();
  currentMillis = startMillis;
  lastDecision = startMillis - decisionInterval;
  finished = false;
}

void readSerial() {
  if (Serial2.available()) {
    if (Serial2.read() == '#') {
      float rcvdTemperature = Serial2.readStringUntil('#').toFloat();
      float rcvdDurationSeconds = Serial2.readStringUntil('#').toFloat();

      targetTemperature = rcvdTemperature;
      targetDuration = rcvdDurationSeconds / 60;

      initializeCooking();
      currentState = 2;
    }
  }
}

static void audioErrorCallback(const ErrorAttentionParam *atprm) {
  if (atprm->error_code >= AS_ATTENTION_CODE_WARNING)
  {
    // ErrEnd = true;
  }
}

bool initializeSound() {
  theAudio = AudioClass::getInstance();
  theAudio->begin(audioErrorCallback);
  theAudio->setRenderingClockMode(AS_CLKMODE_NORMAL);
  theAudio->setPlayerMode(AS_SETPLAYER_OUTPUTDEVICE_SPHP, AS_SP_DRV_MODE_LINEOUT);
  err_t err = theAudio->initPlayer(AudioClass::Player0, AS_CODECTYPE_MP3, "/mnt/sd0/BIN", AS_SAMPLINGRATE_AUTO, AS_CHANNEL_STEREO);
  if (err != AUDIOLIB_ECODE_OK) {
    Serial.println("Player0 initialize error\n");
    return false;
  }
  soundFileFinished = theSD.open("itIsSteakTime.mp3");
  if (!soundFileFinished) {
    Serial.println("Error opening finish sound");
    return false;
  }
  soundFileStart = theSD.open("startingCooking.mp3");
  if (!soundFileStart) {
    Serial.println("Error opening start sound");
    return false;
  }
  err = theAudio->writeFrames(AudioClass::Player0, soundFileFinished);
  if ((err != AUDIOLIB_ECODE_OK) && (err != AUDIOLIB_ECODE_FILEEND)) {
    printf("File Read Error! =%d\n", err);
    soundFileFinished.close();
    return false;
  }
  theAudio->setVolume(-160);
  // theAudio->startPlayer(AudioClass::Player0);
  return true;
}

#include "Configuration.h"
#include "Thermistor.h"

float Thermistor::readTemperature() {
  return calculateTemperature(getSmoothReading());
}

float Thermistor::getSmoothReading() {
  digitalWrite(THERM_VCC_PIN, HIGH);
  delay(10);

  for (int i = 0; i < 2; i++) {
    analogRead(THERM_ARD_PIN);
  }

  int readings[THERM_CNT_RD];
  for (int i = 0; i < THERM_CNT_RD; i++) {
    readings[i] = analogRead(THERM_ARD_PIN);
  }
  digitalWrite(THERM_VCC_PIN, LOW);

  float average;
  for (int i = 0; i < THERM_CNT_RD; i++) {
    average += readings[i];
  }
  average = average / THERM_CNT_RD;

  // Serial.print("[THERM] Avg Reading: ");
  // Serial.println(average);
  return average;
}

float Thermistor::calculateTemperature(float analogValue) {
  float R = 10000 / (1023 / analogValue - 1);
  float Tc = 1 / (THERM_SHE_A + THERM_SHE_B * log(R) + THERM_SHE_C * pow(log(R), 3)) - 273.15;
  float Tf = (Tc * 9.0) / 5.0 + 32.0;

  Serial.print("[THERM] Temperature: ");
  Serial.print(Tc);
  Serial.print("C (");
  Serial.print(Tf);
  Serial.println("F)");

  return Tc;
}

Credits

Walter Heger

4 projects • 83 followers

Alexa, Tell My Steak to Be Medium Rare

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Temperature Sensor

Remote Power Socket

LCD Panel and Buttons

Alexa Voice Control

Result

Schematics

Circuit

Code

Configuration.h

RcHandler.cpp

RcHandler.h

src.ino

Thermistor.cpp

Thermistor.h

Credits

Walter Heger

Comments

Embed the widget on your own site

Alexa, Tell My Steak to Be Medium Rare

Alexa, Tell My Steak to Be Medium Rare

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Temperature Sensor

Remote Power Socket

LCD Panel and Buttons

Alexa Voice Control

Result

Schematics

Circuit

Code

Configuration.h

RcHandler.cpp

RcHandler.h

src.ino

Thermistor.cpp

Thermistor.h

Credits

Walter Heger

Comments

Related channels and tags