Published August 26, 2017 © GPL3+

Temperature Controller with Blynk and Linkit Duo

My latest project. A temperature controller with Blynk and Linkit Duo.

AdvancedFull instructions provided6 hours1,696

Things used in this project

Hardware components

relay board

Software apps and online services

PUTTY

WinSCP

Visual Studio Code

Arduino IDE

Story

Hello everybody.

It's been a long time since I've found time to write a tutorial. But now I'm back in business, so bare with me, read the tutorial and you'll be rewarded with a nice project and a temperature controller.

Since I'm fan of the IoT I'm always looking for new hardware. So after testing a lot of boards (Raspberry Pi, Banana Pi, Beagle Bone, Arduino etc.) a friend of mine sent me link with an unknown board (at least for me): Linkit Smart Duo. I read the manufacturer description and I was convinced to give it a try and I wasn't disappointed.

As I said I was amazed how easy is to work with this little device. Since I don't like messing with wires I designed a PCB for making a permanent project.

A friend of mine needed a temperature controller and I said to myself that will be a good oportunity to make a standalone device. The result is presented below:

Blynk Interface...

The interface consists of 3 Tabs: Dashboard, Termperature Control, and Log.

Dashboard

Here the controls are self explanatory.

Temperature Control

This is the temperature control tab. The Setpoint Low slider selects the minimum temperature.

The Hysteresis slider selects the difference between the min and max temperature.

Setpoint High is the sum of Setpoint Low value and Hysteresis value.

Now, you have two dropdown controls one is Mode and another is Control. With Mode you can select if the controller it's used for heating or cooling. When in Cooling mode the device will wait until the Setpoint High temperature will be reached. In that moment it will send a command to the relay that is controlling the cooler and the cooler will be turned on. It will stay on until the Setpoint Low temperature will be reached. And the cycle will go on.

In Heating mode the device will wait until Setpoint Low temperature will be reached. From that moment the heater will be turned on and it will stay on until Setpoint High temperature will be reached.

For this to happen the selected Mode must be "Automated". When this mode is active the device will ignore all the commands sent manually (by pushing "T. Controller" button). To control the device manually you will have to switch on Manual control.

Last but not least I used a Graph which will record the temperature and the working cycles of the controller.

Temperature Graph

The last tab is the Log:

The hardware...

As I said I designed a PCB which (hopefully) keeps everything in one place. What I manged to achieve is:

4 isolated digital inputs that can accept voltages from 0 to 24V;

4 digital inputs/outputs connected directly to MCU pins. They can supply 3.3V when are set as outputs and can read 3.3V max when set as inputs;

4 digital outputs connected to an ULN2003 chip. They can be used for driving small loads like relays, dc motors and one bipolar stepper motor. The voltage supply of ULN 2003 can be selected through a jumper. You can supply 5V(the voltage of the board) but also up to 36 V by applying voltage on EXT_POW connector;

1x I2C header for various devices that are using this protocol.

1x 1Wire screw terminal for connecting the famous 1wire sensor DS18B20.

The PCB is placed in a small case that can be mounted on DIN rail. Because of the space available I decided to use an external board with 4 relays.

Note: Because the relays are turned on when digital output is 0 the logic is reversed. Please take this into account if you want to modify the code.

And now pictures!

Board

The PCB

Getting started...

I will not insist on describing the Linkit Duo because you can find all the information on official page .

If this is your first contact with this board before going any further be sure that you followed the tutorials listed on the official page:

Sign in to your new board : Note: if you can't acces http://mylinkit.local you should try to connect directly to the board by typing into the brwoser the folloing address http://192.168.100.1

Update to the latest firmware.

Connect to the internet.

Install Arduino with Linkit Smart support.

Install the ComPort driver.

Fortunately you will have to do all these steps only once.

The next step it's to find the local ip address that your router assigned to your device. To find the address I used a piece of software called Angry IP Scanner. You can download it from here. After you will scan your network you will get something like this:

Now that you know Linkit Duo local IP address it's time to access it using secure shell, in short SSH. For this i used Putty. So download Putty from here, enter your IP address and type in the user (root) and password that you set on first step.

As you can see Linkit Duo it's running a linux distro called OpenWrt. So you can enjoy all the benefits that an OS has, though OpenWrt it's not the most friendly distro.

Now take a deeep breath and proceed to the next step. Since the device has only 32 MB available for storage, with limited read/write cycle you'll wand to mount the file system on a SD card. This is very important. For this you'll have to read the tutorial listed here.

One more step and we are done. Because I want to make things simple for accessing and editing files on Linkit I use a dedicated software called WinSCP. So download and install this piece of software. After installing, login to your Linkit device using the Secure Copy Protocol (SCP):

After a successful login you will have access to Linkit files easy:

At this moment we have the hardware ready. Horrrayyy !! :)

The software...

Now that we installed everything and we have access to the device file system it's time to write the software for making things happen.

As you already know the Linkit Smart Duo consists of a MT7688 Mediatek processor and a ATmega32U4 MCU, more or less an Arduino Mini. The processor and the microcontroller are linked via a virtual bridge like the one it's used for Arduino Yun. If you want to read more please read the Yun documentation on Arduino website. Because the MCU has limited capabilities (8MHz, 32KB ROM) and the project it's pretty complex I decided to split the "job" in two:

The MCU will be responsible for reading sensors and control the hardware;

The MPU will deal with the Blynk server by sending the status of the sensors and reading the commands.

That being said we have to write two programs: one for ATmega32U4 (Arduino) and one that will deal with Blynk server (Node JS).

In code section you will find the Arduino side program. It makes use of 3 libraries:

Tasker - for scheduling tasks (more like timer trigger)

OneWire and DallasTemperature - for dealing with the temperature sensor DS18B20;

As you can see there is no code in loop(). That's because Tasker will take care of everything.

Note: Please read the code comments.

So download the sketch and upload to the microcontroller.

Now login with WinSCP to your device and inside root direcory create a folder called "apps" inside this folder create another called "node" and finally inside of the last created folder (or directory :) ) create a folder named "blynk".

Inside this folder create an empty file and name it app.js. Copy/paste the Node Js code inside and you're done.

The last step is to install the node js libraries inside this folder. For this task ssh your device with Putty and go to your blynk folder by typing:

cd apps/node/blynk

Now that you are inside this folder we have to install the blynk and serialport libraries:

npm install serialport@4.0.7 
npm install blynk-library

Installing serialport it will take forever, so be patient :) !

After everything is in place you will have to run the program:

node apps/node/blynk/app.js

The easiest part is to use Blynk. For this, download the app either for IoS either for Android create an account and scan the QR code below. Blynk is free. But you will only get 2000 credits when the project is started. This project is made with 6400 credits so you will need to buy 5000 credits more. Don't worry it's cheap only 3.99$.

Scan this code from Blynk app

That's it !

Good luck.

Code

#include "Tasker.h"
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS A5
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

/*
  Valid commands list
 * is the character used in readStringUntil
  --------------------------------------------------
  1.Get status -> 0:0:0*
  2.PWM  ->1:pin:value*
  3.Digital out ->2:pin:value*
  4.Set explicitly digital out ->3:pin:value*
*/


Tasker tasker;
char endChar = '*'; // the enchar for a valid command
char splitter = ':';// data delimiter
int nrOfCom = 4;// number of commnds. Not impemented


float temp1 =-128.00;
int inputs[4] = {11, 10, 9, 8};
//int outputs[4] = {7, 6, 5, 4};
int outputs[4] = {A1, A2, A3, A4};
//int in_status[4] = {0, 0, 0, 0};
int out_status[4] = {0, 0, 0, 0};

///////////////////////////////////////////////////
/*
This function will return the status of the 
digital inputs
*/

String readDigitalIn() {
  String s = "";
  for (int i = 0; i < 4; i++) {
    if (digitalRead(inputs[i])) {
      s = s + "0" + ":";
    }
    else {
      s = s + "1" + ":";
    }
  }
  return s.substring(0, s.length() - 1);
}
/////////////////////////////////////////////////
/*
This function will return the status of the 
digital outputs
*/

String readDigitalOut() {
  String s = "";
  for (int i = 0; i < 4; i++) {
    if (out_status[i]) {
      s = s + "1" + ":";
    }
    else {
      s = s + "0" + ":";
    }
  }
  return s.substring(0, s.length() - 1);
}
////////////////////////////////////////////////
/*
This function will set the digital outputs
*/
void setDigitalOut(int pin, int value, boolean mode) {
  if (mode) {
    if (out_status[pin]) {
      out_status[pin] = 0;
      digitalWrite(outputs[pin], LOW);
    }
    else {
      out_status[pin] = 1;
      digitalWrite(outputs[pin], HIGH);
    }
  }
  if (mode == false) {
    digitalWrite(outputs[pin], value);
    out_status[pin] = value;
  }
}
////////////////////////////////////////////////
/*
Here the temperature is read.
*/
void readSensor(int) {
  temp1 = sensors.getTempCByIndex(0);
  Serial.println(temp1);
}
///////////////////////////////////////////////
/*
Here the conversion of temperature is started.
*/
void startConversion(int) {
  sensors.requestTemperatures();
  tasker.setTimeout(readSensor, 750);
}
/////////////////////////////////////////////
/*
This is the core of all things. MCU is checking if there
is somethig received on SerialPort. It will read a string
until it will find the '*' char. Then the string is splitted
and analyzed. The valid commnds are presented at the beginning 
of the listing.
If there is nothing on Serial it will send the current status.
*/
void sendData(int) {
  int index[2];
  if (Serial1.available() > 0) {
    String c = Serial1.readStringUntil(endChar);
    Serial.println(c);
    int j = 0;
    for (int i = 0; i < c.length(); i++) {
      if (c.charAt(i) == splitter) {
        index[j] = i;
        j++;
      }
    }
    String cmd = c.substring(0, index[0]); //command
    String pin = c.substring(index[0] + 1, index[1]); //pin
    String value = c.substring(index[1] + 1); //value

    if (cmd.toInt() == 2) { //digitalOut command
      setDigitalOut(pin.toInt(), value.toInt(),true);
    }
    if (cmd.toInt() == 3) { //digitalOut command
      setDigitalOut(pin.toInt(), value.toInt(),false);
    }
  }  
  String ts = String(temp1);
  Serial1.println(ts + splitter + readDigitalIn() + splitter + readDigitalOut());
}
void report(int){
  String ts = String(temp1);
  Serial1.println(ts + splitter + readDigitalIn() + splitter + readDigitalOut());
  }

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(inputs[i], INPUT);
    pinMode(outputs[i], OUTPUT);
    digitalWrite(outputs[i], HIGH);
  }

  sensors.begin();

  Serial.begin(115200);  // open serial connection to USB Serial
  //port(connected to your computer)
  Serial1.begin(57600);  // open internal serial connection to
  //MT7688

  sensors.setWaitForConversion(false);// the converssion is called separatley
  delay(1000);
  tasker.setInterval(startConversion, 5000);//every 5 sec. a conversion is started
  //after a dealy of 750ms it will read the sensor and update the current temperature
  tasker.setInterval(sendData, 250);// every 250ms SerialPort is checked for a new command
  //if there is a new command it will be executed. If not the current status will be sent.
  //tasker.setInterval(report,3000);
  tasker.run();
}

void loop() {
  // there is no need for loop :)

}

const Blynk=require('blynk-library');
const SerialPort =require('serialport');
const port = new SerialPort('/dev/ttyS0', {
  baudRate: 57600,
  autoOpen:false,
  parser: SerialPort.parsers.readline('\n')
});
/*
Every command will be pushed inside buffer array
*/
var buffer=[];
var oldRes='null';
var firstTime=true;

port.open(function(err){
    if(err){
        console.log('Error on opening port...');
    }
    console.log('Comport found !');
});

port.on('open',function(){
    console.log('Conection estabilished!');
});

/*Every 250ms Arduino will send the current status.
If there is something inside the buffer array it will removed
be send back to Arduino. The values received from Arduino will be
sent to the Blynk server only if they are different than the previous
ones.
*/
port.on('data',function(data){
    //console.log(data);
    //console.log(oldRes);
    if(buffer.length>0){
      port.write(buffer.shift());
      //console.log(buffer);
    }
    if(oldRes != data){
      oldRes=data;
      var res=data.substring(0, data.length - 1).split(':');
      temp.crtTemp=parseFloat(res[0]);
      alarm.state=res.slice(1,5);
      alarm.update();
      buttons.state=res.slice(5);
      buttons.update();
      temp.update();
    }  
});


var blynk = new Blynk.Blynk('ace7db88efbd4433b3412ff02c9abc49');
/*Here is the temeprature object. It contains all the values and 
functions that regard temperature*/
var temp={
  crtTemp:0,//current temperature
  triggerH:true,//this variable is used to raise only once a max temp. alarm
  triggerL:true,//this variable is used to raise only once a min temp. alarm
  update:function(){//here we update the temperature status
    blynk.virtualWrite(0,this.crtTemp);//send to Blynk the current temp.
    ///High temperature alarm
    if(this.crtTemp>termo.setpointHigh && this.triggerH){
      var d = new Date();
      terminal.write(d.getDate()+"/"+d.getMonth()+"@"+d.getHours()+":"+d.getMinutes()+'--- Temperature Alarm: '+temp.crtTemp+" C \n");
      blynk.notify('High Temperature Alarm. Current temperature: '+temp.crtTemp +" C");
      this.triggerH=false;
    }
    if(this.crtTemp<termo.setpointHigh){
      this.triggerH=true;
    }
    ///Low temperature alarm
    if(this.crtTemp<termo.setpointLow && this.triggerL){
      var d = new Date();
      terminal.write(d.getDate()+"/"+d.getMonth()+"@"+d.getHours()+":"+d.getMinutes()+'--- Temperature Alarm: '+temp.crtTemp+" C \n");
      blynk.notify('Low Temperature Alarm. Current temperature: '+temp.crtTemp +" C");
      this.triggerL=false;
    }
    if(this.crtTemp>termo.setpointLow){
      this.triggerL=true;
    }
    ///Set min-max registerd temperatures.
    if(firstTime && this.crtTemp!=0 && this.crtTemp!=-128){
      firstTime=false;
      this.minTemp=this.crtTemp;
      this.maxTemp=this.crtTemp;
      blynk.virtualWrite(1,this.minTemp);
      blynk.virtualWrite(2,this.maxTemp);
    }
    else{
      if(this.crtTemp<this.minTemp && this.crtTemp!=-128){
        this.minTemp=this.crtTemp;
        blynk.virtualWrite(1,this.minTemp);
      }
      if(this.crtTemp>this.maxTemp && this.crtTemp!=-128){
        this.maxTemp=this.crtTemp;
        blynk.virtualWrite(2,this.maxTemp);
      }
    }
  },
  minTemp:0,
  maxTemp:0,
}
/*This is the alarm object. It's linked with digitalIn pins */
var alarm={
  trigger:[true,true,true,true],
  state:[0,0,0,0],
  names:['Backdoor','Main Enterance','Backyard Window','Garage Door'],
  vPins:[20,21,22,23],
  update:function(){
    for(i=0;i<this.vPins.length;i++){
      if(this.state[i]==0){
        blynk.setProperty(this.vPins[i],"color","#129b59");
        blynk.virtualWrite(this.vPins[i],'OK');
        if(this.trigger[i]==false){
          this.trigger[i]=true;
        }
      }
      else{
        blynk.setProperty(this.vPins[i],"color","#c6170d");
        blynk.virtualWrite(this.vPins[i],'ALARM!');
        if(this.trigger[i]){
          this.trigger[i]=false;
          blynk.notify('Alarm on ' + this.names[i]);
          var d = new Date();
          terminal.write(d.getDate()+"/"+d.getMonth()+"@"+d.getHours()+":"+d.getMinutes()+'--- Alarm on ' + this.names[i]+'\n');
        }
      }
    }
  }
}

/*This is the buttons object. It's linked with digitalOut pins */
var buttons={
  state:[0,0,0,0],
  vPins:[40,41,42,43],
  update:function(){
    for(i=0;i<this.vPins.length;i++){
      if(this.state[i]==0){
        blynk.setProperty(this.vPins[i],"color","#129b59");
        blynk.setProperty(this.vPins[i],"onLabel",'ON');
        blynk.virtualWrite(this.vPins[i],1);
      }
      else{
        blynk.setProperty(this.vPins[i],"color","#c6170d");
        blynk.setProperty(this.vPins[i],"offLabel",'OFF');
        blynk.virtualWrite(this.vPins[i],0);
      }
    }
  }
}

/*This is the temperature control object. */
var termo={
  pins:[50,51,52,53,54],//not implemented yet
  ///startup values
  setpointLow:25,
  hys:6,
  setpointHigh:0,
  updateSetpoint:function(){
    this.setpointHigh=this.setpointLow+this.hys;
    blynk.virtualWrite(52,this.setpointHigh);
  },
  mode:1,//1=heating, 2=cooling//
  control:2,// 2=manual, 1=automated
  ///send new variables to server
  updateTermo:function(){
    this.updateSetpoint();
    blynk.virtualWrite(50,this.setpointLow);
    blynk.virtualWrite(51,this.hys);
    blynk.virtualWrite(53,this.mode);
    blynk.virtualWrite(54,this.control);
  },
  ///Automated temperature control.
  autoControl:function(){
    if(this.control==1){ //automated control
      if(this.mode==2){ ////heating
        if(temp.crtTemp<=this.setpointLow){
          buffer.push('3:0:1*');//start heating
        }
        if(temp.crtTemp>=this.setpointHigh){
          buffer.push('3:0:0*');//stop heating
        }
      }
      else { //cooling
        if(temp.crtTemp>=this.setpointHigh){
          buffer.push('3:0:1*');//start cooling
        }
        if(temp.crtTemp<=this.setpointLow){
          buffer.push('3:0:0*');//stop cooling
        }
      } 
    }
  }
}


/*Here the graph is updated */

var updateGraph=setInterval(function(){blynk.virtualWrite(55,temp.crtTemp)},600000);

//////////////Virtual variables !!!!!!!
var terminal=new blynk.WidgetTerminal(60);

var tempControl = new blynk.VirtualPin(40);
var gardenPump= new blynk.VirtualPin(41);
var garageDoor= new blynk.VirtualPin(42);
var basementLight= new blynk.VirtualPin(43);

var sliderLow=new blynk.VirtualPin(50);
var sliderHys=new blynk.VirtualPin(51);
var setHigh=new blynk.VirtualPin(52);
var mode=new blynk.VirtualPin(53);
var control=new blynk.VirtualPin(54);
//////////////Commands from server !!!!!!!

//This button is locked if control is automated.
tempControl.on('write',function(param){
  if(termo.control==2){
    buffer.push("2:0:1*");
  }
  else{
    if(buttons.state[0]==1){
      blynk.setProperty(40,"color","#129b59");
      blynk.setProperty(40,"onLabel",'ON');
      blynk.virtualWrite(40,1);
    }
    else{
      blynk.setProperty(40,"color","#c6170d");
      blynk.setProperty(40,"offLabel",'OFF');
      blynk.virtualWrite(40,0);
    }
  } 
});

/*As you can see commands for Arduino are sent in buffer first */
gardenPump.on('write',function(param){
    buffer.push("2:1:1*");  
});
garageDoor.on('write',function(param){
    buffer.push("2:2:1*") 
});
basementLight.on('write',function(param){
   buffer.push("2:3:1*") 
});

sliderLow.on('write',function(param){
  termo.setpointLow=parseFloat(param[0]);
  termo.updateSetpoint();
})
sliderHys.on('write',function(param){
  termo.hys=parseFloat(param[0]);
  termo.updateSetpoint();
})
mode.on('write',function(param){
  termo.mode=parseInt(param[0]);
});
control.on('write',function(param){
  termo.control=parseInt(param[0]);
});

//////////////On connect
blynk.on('connect', function() { 
  console.log("Blynk ready.");
  termo.updateTermo();
  buttons.update();
  alarm.update();
  temp.update();
  blynk.virtualWrite(55,temp.crtTemp);
  terminal.write('Connected'+'\n');
});
blynk.on('disconnect', function() { 
  console.log("DISCONNECT"); 
});

var x=setInterval(function(){
  termo.autoControl();
  temp.update();
},2000);

Credits

Petrescu Cristian

3 projects • 2 followers

Temperature Controller with Blynk and Linkit Duo

Things used in this project

Hardware components

Software apps and online services

Story

Schematics

Circuit diagram

Code

Arduino code for Linkit Duo

Node Js server for "talking" Blynk

Credits

Petrescu Cristian

Comments

Embed the widget on your own site

Temperature Controller with Blynk and Linkit Duo

Temperature Controller with Blynk and Linkit Duo

Things used in this project

Hardware components

Software apps and online services

Story

Schematics

Circuit diagram

Code

Arduino code for Linkit Duo

Node Js server for "talking" Blynk

Credits

Petrescu Cristian

Comments

Related channels and tags