Amazing Open Source Raspberry Pi Pico 2 Synth, Cutting Edge Power over Skin Research, and much more!

0:00:00 / -

Watch now on YouTube Watch now

Blynk Meets Bluz

Made by gusgonnet

About the project

No Blynk libraries for Bluz? No problem!

Project info

Difficulty: Difficult

Platforms: Bluz, Blynk, Particle

Estimated time: 1 hour

License: Creative Commons Attribution-NonCommercial-ShareAlike CC BY-NC-SA version 4.0 or later (CC BY-NC-SA 4+)

Items used in this project

Hardware components

	LS1021A Internet of Things Gateway	x 1
	Particle Photon this one goes in the gateway shield (BLE to WiFi gateway)	x 1
	2-CH I2C MUX DK GR	x 1

Software apps and online services

Blynk

Story

No official Blynk libraries for Bluz

Connecting my Bluz DK to Blynk was something I wanted to do for a while. There are no libraries available, at least as far as I know (here and here).

However, there are great libraries for Particle Photons (and soooo many other microcontrollers).

While I was working on this Bluz temperature sensor the other day, I realized that the project already has a Particle Photon, so the light bulb turned on in my head...

What are we going to build here?

We are going to build a Blynk app that will display data from a Bluz DK.

As a secondary goal, we will turn on and off an LED with a Blynk button.

The project we will build

From left to right: the Bluz-Blynk Gateway, the Blynk app and the Bluz wireless temperature sensor

The Blynk libraries

The Blynk libraries take care of connecting our micro controllers to the Blynk cloud (or the Blynk Server in the picture below).

Once the connection is done, we can access data from that micro controller on a Blynk app on our phones (or tablets).

We can also control pins or trigger actions from buttons in the Blynk app.

The Blynk architecture

Installing the Blynk libraries

But where? Since there are no libraries for our cherished Bluz DK, what would happen if we installed the Blynk libraries in our Particle Photon instead?

I will tell you what would happen: we would end up with a Bluz Gateway that can run Blynk and that's it. Let's call it Bluz-Blynk Gateway just for fun.

The Bluz-Blynk Gateway is born

So, is this new Bluz-Blynk Gateway aware of the variables, data or functions in our Bluz DK?

No, it isn't. The Gateway just passes information through from BLE (Bluetooth Low Energy) to WiFi, but it knows nothing about that information.

See the challenge here?

I cannot install the Blynk libraries on my Bluz DK and the Gateway is not aware of the data on my Bluz DK.

So what now? Particle events to the rescue...

Events in Particle

There is a publish-subscribe functionality on the Particle Cloud that allows us to pass information around our Particle hardware. The publish sends an event to the cloud, to which we can subscribe from another Particle microcontroller. And even better, this event can contain some data.

Since Bluz DK is part of the Particle family, we can use this events mechanism to pass data from it to the Photon and back.

Particle events between Particle hardware

To send the temperature readings from our Bluz DK we need a publish statement to be executed every now and then:

 Particle.publish("BLUZ_TEMP", temperature, PRIVATE);

And in our Bluz-Blynk Gateway's, we need to subscribe to that event in the setup() function:

 void setup()
{
    Particle.subscribe("BLUZ_TEMP", getRemoteTemp, MY_DEVICES);
}

getRemoteTemp is a function that will get called when the event is received, so we will need to declare it in our firmware.

The architecture

Our project will have a Blynk app running in our phones/tablets. This app will talk to the Blynk libraries installed in the Photon in the Bluz-Blynk Gateway. Finally, the Photon will use events to transmit information back and forth to our Bluz DK.

Just like this:

Magic means BLE, then NRF to Photon then WiFi

The Blynk app

Our app consists of two basic Blynk widgets: a Value Display and a Button. Let's use virtual pins V0 and V1 for them:

Our Blynk app

You can create it yourself or you can clone it by scanning this QR code:

QR code for our Blynk app

Remember: you need to get an Auth Token for your Blynk app and paste it in the firmware, more info here.

The Bluz DK firmware

In this firmware we need to read the thermistor and send an event with that value.

We will need to subscribe to an event that will be triggered from the Photon when we hit the button in our app.

The Bluz-Blynk Gateway firmware

Here we need to write virtual pin V0 and read virtual pin V1.

V0 will contain the temperature sent in the event coming from the Bluz DK.

When we tap the Blynk button in our app, an event will be triggered, the Bluz DK will receive it and it will turn on the onboard LED.

Never used virtual pins before? No worries, read here about how they work.

The video

Once everything is set up and flashed, the project is ready!

Check the temperature and how tapping the button turns on the Bluz onboard LED!

Troubleshooting

There is A LOT going on in this project, and of course Murphy's law dictate that anything that can go wrong will go wrong, so don't lose your hope when you hit trouble.

Have in mind that this project is based on my previous Bluz wireless temperature sensor project, so if something is not explained here, it might be that is explained there. If not, ask in the comments below.

It always helps having strong communities. The bluz community is here, the Particle community is here and the Blynk community here.

Final notes

Finally I have a Blynk app for my Bluz projects! I'm pretty happy with the result. And all this time the solution was staring me in the face...

Need help?

If you require professional help with your projects, don't hesitate to write me a line about your needs at gusgonnet@gmail.com. Thank you!

Check the rest of my projects here!

Schematics, diagrams and documents

The Bluz wireless temperature sensor

Code

Bluz DK code

//**************************************************************************************
// Author: Gustavo Gonnet
// Contact: gusgonnet@gmail.com
// Projects: https://www.hackster.io/gusgonnet/
//
// Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
// This is a human-readable summary of (and not a substitute for) the license.
// Disclaimer
//
// You are free to:
// Share — copy and redistribute the material in any medium or format
// Adapt — remix, transform, and build upon the material
// The licensor cannot revoke these freedoms as long as you follow the license terms.
//
// Under the following terms:
// Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
// NonCommercial — You may not use the material for commercial purposes.
// ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
// No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
//
// Notices:
// You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
// No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.
//
// Free for personal use.
//
// https://creativecommons.org/licenses/by-nc-sa/4.0/

//**************************************************************************************
// Notes:
// when I started this app with a cheap cr 2032 battery it lasted one week
//**************************************************************************************
#include <math.h>
#include "application.h"

#define APP_NAME "BLUZ_thermistor"
String VERSION = "Version 0.01";
int version = 1;

#define EVENT_NAME_TEMP "BLUZ_TEMP"
#define EVENT_NAME_BUTTON "BLUZ_BUTTON"

/*******************************************************************************
 * changes in version 0.01:
       * initial commit
*******************************************************************************/

// by default, the temperature will be displayed in degrees celsius,
//  but if you prefer farenheit please set this to true
bool useFahrenheit = false;

// this is the thermistor used
// https://www.adafruit.com/products/372
// resistance at 25 degrees C
#define THERMISTORNOMINAL 10000
// temp. for nominal resistance (almost always 25 C)
#define TEMPERATURENOMINAL 25
// how many samples to take and average, more takes longer
// but is more 'smooth'
#define NUMSAMPLES 5
// The beta coefficient of the thermistor (usually 3000-4000)
#define BCOEFFICIENT 3950
// the value of the 'other' resistor
#define SERIESRESISTOR 10000

// A7 is not available in bluz!
// source: http://docs.bluz.io/hardware/dk/
// A6 and A7 cannot read analog data even though they are still labeled A6 and A7 (which was done for compatible code). There simple weren't enough ADC pins on the nrf51.
int THERMISTOR = A5;
// this gives power to the thermistor
int VCC_FOR_THERMISTOR = A0;

int LED = D7;

// this variable helps you match the measurement to another source (eg: your thermostat)
// hum, this value is pretty high, I guess is a consecuence of me not using a 1% 10k resistor
// but a less precise 10k resistor
float temperatureCorrection = -5.9;

// store the previous measured temp to check if current measurement needs to be transmited
float previousTemperature;

float currentTemperature;

unsigned long lastTime = 0;

// polling period: 20 mins == 1200000
// adjust to your liking
unsigned long checkPeriod = 10000;

// this variable defines the range where the temp is not updated (not published)
// adjust to your liking
float deltaTemperature = 0.5;

/*******************************************************************************
 * Function Name  : setup
 * Description    : this function runs once at system boot
 *******************************************************************************/
void setup()
{
  pinMode(LED, OUTPUT);
  pinMode(VCC_FOR_THERMISTOR, OUTPUT);
  digitalWrite(VCC_FOR_THERMISTOR, LOW);
  pinMode(THERMISTOR, INPUT);

  Particle.publish(APP_NAME, VERSION, PRIVATE);

  // turn off led to save power
  // comment these two lines below while regular development
  //   RGB.control(true);
  //   RGB.color(0, 0, 0);

  Particle.subscribe(EVENT_NAME_BUTTON, hitButton, MY_DEVICES);

  Particle.function("getTemp", getTemperature);
  Particle.function("getVersion", getVersion);
  Particle.function("pulseLed", pulseLed);
}

/*******************************************************************************
 * Function Name  : loop
 * Description    : this function runs all the time
 *******************************************************************************/
void loop()
{

  System.sleep(SLEEP_MODE_CPU);

  // source: https://community.particle.io/t/millis-and-rollover-tutorial/20429
  unsigned long now = millis();

  if ((now - lastTime) >= checkPeriod)
  {
    lastTime = now;

    // power on the thermistor
    digitalWrite(VCC_FOR_THERMISTOR, HIGH);

    calculateTemperature();

    // power off the thermistor
    digitalWrite(VCC_FOR_THERMISTOR, LOW);
  }
}

/*******************************************************************************
 * Function Name  : calculateTemperature
 * Description    : read the value of the thermistor and convert it to degrees
 * Return         : none
 *******************************************************************************/
void calculateTemperature()
{

  // read and convert the value to resistance
  float average = analogRead(THERMISTOR);
  average = (1023 / average) - 1;
  average = SERIESRESISTOR / average;

  float steinhart;
  steinhart = average / THERMISTORNOMINAL;          // (R/Ro)
  steinhart = log(steinhart);                       // ln(R/Ro)
  steinhart /= BCOEFFICIENT;                        // 1/B * ln(R/Ro)
  steinhart += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To)
  steinhart = 1.0 / steinhart;                      // Invert
  steinhart -= 273.15;                              // convert to C

  // Convert Celsius to Fahrenheit
  // source: http://playground.arduino.cc/ComponentLib/Thermistor2#TheSimpleCode
  if (useFahrenheit)
  {
    steinhart = (steinhart * 9.0) / 5.0 + 32.0;
  }

  currentTemperature = steinhart + temperatureCorrection;

  //   if (abs(currentTemperature - previousTemperature) > deltaTemperature)
  //   {
  //     Particle.publish(EVENT_NAME_TEMP, float2string(currentTemperature), 60, PRIVATE);
  //   }

  Particle.publish(EVENT_NAME_TEMP, float2string(currentTemperature), 60, PRIVATE);

  // keep track of this value
  previousTemperature = currentTemperature;
}

String float2string(float floatNumber)
{
  String stringNumber = String(floatNumber);

  //return only 2 decimals
  // Example: show 19.00 instead of 19.000000
  stringNumber = stringNumber.substring(0, stringNumber.length() - 4);

  return stringNumber;
}

int getTemperature(String dummy)
{
  return (int)(currentTemperature * 100);
}

int getVersion(String dummy)
{
  return version;
}

/*******************************************************************************
 * Function Name  : pulseLed
 * Description    : light up the led
 * Return         : 0
 *******************************************************************************/
int pulseLed(String args)
{
  digitalWrite(LED, HIGH); // sets the LED on
  delay(500);              // waits a bit
  digitalWrite(LED, LOW);  // sets the LED off
  return 0;
}

void hitButton(const char *event, const char *data)
{
  pulseLed("");
}

Bluz-Blynk Gateway code

//**************************************************************************************
// Author: Gustavo Gonnet
// Contact: gusgonnet@gmail.com
// Projects: https://www.hackster.io/gusgonnet/
//
// Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)
// This is a human-readable summary of (and not a substitute for) the license.
// Disclaimer
//
// You are free to:
// Share — copy and redistribute the material in any medium or format
// Adapt — remix, transform, and build upon the material
// The licensor cannot revoke these freedoms as long as you follow the license terms.
//
// Under the following terms:
// Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
// NonCommercial — You may not use the material for commercial purposes.
// ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original.
// No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.
//
// Notices:
// You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation.
// No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material.
//
// Free for personal use.
//
// https://creativecommons.org/licenses/by-nc-sa/4.0/

#include "bluz_gateway.h"

#include "elapsedMillis.h"
#include "BlynkSimpleParticle.h"
#include "blynkAuthToken.h"

#define EVENT_NAME_TEMP "BLUZ_TEMP"
#define EVENT_NAME_BUTTON "BLUZ_BUTTON"

#define APP_NAME "BLUZ_GW_BLYNK"
String VERSION = "Version 0.01";

/*******************************************************************************
 * changes in version 0.01:
    * initial version
*******************************************************************************/

/*******************************************************************************
 Your blynk token goes in another file to avoid sharing it by mistake
 The file containing your blynk auth token has to be named blynkAuthToken.h and it should 
 contain something like this:
  #define BLYNK_AUTH_TOKEN "1234567890123456789012345678901234567890"
 replace with your project auth token (the blynk app will give you one)
*******************************************************************************/
char auth[] = BLYNK_AUTH_TOKEN;
#define BLYNK_DISPLAY_TEMP V0
#define BLYNK_BUTTON V1

//this defines how often the readings are sent to the blynk cloud (millisecs)
#define BLYNK_STORE_INTERVAL 5000
elapsedMillis blynkStoreInterval;

// SYSTEM_MODE(SEMI_AUTOMATIC);
bluz_gateway gateway;

String remoteTemp = "";

void setup()
{

    gateway.init();
    //only set this if you want the nrf51 central to not connect, recomended for Electron gateway
    // gateway.set_ble_local(true);

    Particle.subscribe(EVENT_NAME_TEMP, getRemoteTemp, MY_DEVICES);

    Particle.variable("remoteTemp", remoteTemp);

    Blynk.begin(auth);

    // Serial.begin(9600);
}

void loop()
{
    gateway.loop();

    //all the Blynk magic happens here
    Blynk.run();

    //publish readings to the blynk server every minute so the History Graph gets updated
    // even when the blynk app is not on (running) in the users phone
    updateBlynkCloud();
}

/*******************************************************************************
 * Function Name  : updateBlynkCloud
 * Description    : publish readings to the blynk server every minute so the
                    History Graph gets updated even when
                    the blynk app is not on (running) in the users phone
 * Return         : none
 *******************************************************************************/
void updateBlynkCloud()
{

    //is it time to store in the blynk cloud? if so, do it
    if (blynkStoreInterval > BLYNK_STORE_INTERVAL)
    {

        //reset timer
        blynkStoreInterval = 0;

        Blynk.virtualWrite(BLYNK_DISPLAY_TEMP, remoteTemp);
    }
}

void getRemoteTemp(const char *event, const char *data)
{
    if (data)
    {
        remoteTemp = data;
    }
}

BLYNK_WRITE(BLYNK_BUTTON)
{
    // do this only when blynk sends a 1
    if (param.asInt() == 1)
    {
        Particle.publish(EVENT_NAME_BUTTON, PRIVATE);
    }
}

Credits

gusgonnet

If you need professional help with a project, contact me at gusgonnet@gmail.com

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast