Category: esp8266

Making of an ESP8266 Vibrator Development Board – traps and pitfalls

About a year ago I made a ESP8266 based design for a vibrator development board including IMU, motor driver and battery charging. The design was based on the Adafruit ESP Huzaah, but I used components of Seeedstudio Open Parts Library. This is a library of parts (IC, connector, resistors) which are stocked at Seeedstudio especially for their PCBA (printed circuit board assembly) service. PCBA is really great. Instead of tinkering and soldering on your own you can send the design to Seeedstudio, they make the printed circuit board and assemble all parts. Unfortunately the main part – the ESP8266 microcontroller – was missing in the Open Part Library . So I turned to use the affordable ready-made WeMos ESP8266 boards (see here).

In June 2017 I took a closer look at the PCBA service. At that time the OPL offered two variants of the ESP8266. But even better: You could order almost any part. The difference between using OPL parts and other parts was the time for the assembly as it takes more time to order parts which are not on stock.

So I ordered two boards. The boards are round with a diameter of 5 cm (that’s the size of a wireless charging coil). As I had a coupon the two boards were only about 50US$. Including delivery! And even better: Seeedstudio delivers from a logistic company in Germany. So I had not to pay any taxes. Great. But… unfortunately … I made beginner’s mistakes…during design.

  1. Problem: As the board should be programmable by USB connection you need a USB to serial bridge eg. one of the FTDI ICs. This bridge has two important connections TX (transfer) and RX (receive). And the ESP8266 has the same TX and RX. But don’t connect them. Instead you have to connect RX to TX and vice versa. (Well I should have know, when I soldered null modems maybe 20 years ago or more…)

    Taken from Sparkfun

  2. Problem: When using the serial monitor of the Arduino IDE you need another connection: RTS (ready to send). Unfortunately the used serial bridge – the FTDI FX230XS IC – had no RTS. (There is a circuit which works without RTS, but I didn’t know.)
  3. Problem: I used GPIO0 for driving the motor, that’s why auto reset doesn’t work. So I had to short-cut GPIO0 and GROUND for uploading a script.

So I tried to fix the problem. At first I had to cut the wrong connections. On the bottom side of the board the RX and TX wires are quit good accessible. So I could cut them using a dremel.

In the next step I had to connect the RX and TX headers of the FTDI chip with the ESP 8266…

The green clamps were used to shortcut another wrong connection.

Finally upload with the Arduino IDE was possible, but no debugging using the serial monitor. Battery charging seemed to work, too, although this needs more time for testing. WiFi worked. Essentially I could upload a script which made one LED blinking. And I could start the WiFi manager.

Debugging such a complex thing like a ESP8266 without serial connection is almost impossible. But then I found RealTerm. This is the only terminal program for Windows where you have all options to use or not use serial sync mechanisms like DTR, RTS etc. It is made to make a serial connection work even if you have only TX, RX and GROUND.

Here you can decide to ignore RTS and/or DTR by pressing “Clear”. (Read more about this here.)

.

And finally it worked. The ESP8266 sends debug text to the serial monitor. The transmission maybe scrambled, but it is still readable. Realterm – a really great tool for debugging serial connections.

Readings of the MPU9250 (accelerometer, gyro)

Probably it is more reasonable to use a bread board for the development of a design. But customizing an open source design on the PC and then get it assembled for a reasonable price – for me it’s like a dream come true. But as you see – all your efforts can be worthless.

But I will do it again…

 

 

Basic Node for the Internet of Sex Toys – part 3: software

This the third part of the tutorial which has the following parts:

part 1: Basic Node for the Internet of Sex Toys

part 2: Molding the Basic Node

part 3: Software for the Basic Node

For the basic node a simple software realizes all features like Mqtt communication, Web server, basic web user interface, reading data from the accelerometer. Please use the code at github and send request over github. Now the imported parts of the code are explained.

To communicate with the IOT Mqtt is used (read more here). This is a fast protocol for data transmission. Therefore we need a Mqtt server. You can install one on your local computer or use a cloud-based Mqtt server. We use the free CloudMqtt. The following variables must be initiated with the data  of your server. Please get your own account at CloudMqtt or use my server (but don’t spam it, please). Please remember: Transmission is not encrypted, everybody can read it.

const char* mqtt_server = "m12.cloudmqtt.com";
uint16_t mqtt_port = 15376;
const char* mqtt_user = "nvcuumkf";
const char* mqtt_password = "C-X6glwisHOP";

We have now  7 different modes. In each mode the basic node behaves different.

const int offMode = 0;
const int maxMode = 1;
const int sinusMode = 2;
const int motionMode = 3;
const int constantMode = 4;
const int listenMode = 5;
const int listenAndMotionMode = 6;

In off mode the basic node is off, in max mode the vibration is maximum. In sinus mode the vibration speed is altered according to a sinus curve.

Web user interface of the basic node

In motion mode the vibration changes according to the movement of the basic node. When moved fast the speed goes up, when moved slowly or movement stops, the speed goes down. In constant mode any vibration speed can be set to any strength. This feature is only available by Mqtt messages eg. from the IOT node-RED user interface. The listen mode is still experimental. In this mode the speed will be changed by OTHER basic nodes. Finally in the listenAndMotionMode the speed is changed by movements of the basic node and by other nodes. This feature was already available with the body interaction 1 development board as standard mode!

The basic node starts a web server (see image). A web page is generated which build up the user interface. There are buttons for every mode. In addition the speed and the battery power is displayed. This is done in this function:

void generateWebpage() {

The next lengthy procedure is this:

void mqttCallback(char* topic, byte* payload, unsigned int length) {

This is a call back function which is executed whenever a Mqtt message comes in. It parses the Mqtt message which is in the popular JSON format. The commands which are communicated within JSON are explained here. In principle there is a command for every mode, when the command “set mode to off” is send the mode is set to offMode.

In the setup() part of the code you will find a lot of lines like that:

httpServer.on("/MOTOR=MAX", []() {

They corresponds to the generateWebpage() function. When say the max button on the web page is pressed than the affiliated httpServer function is executed. So for every button on the webpage you need a corresponding httpServer function to implement the functionality. In this case (MOTOR=MAX) the mode is set to the constant speed maxMode.

Finally in the loop section of the code the following functions are implemented:

  • reading the accelerometer data
  • change the vibration motor speed according to the mode
  • generate a new JSON message which is send out via Mqtt
  • do the timing

Not mentioned is the OTA (over the air update) function, which is integrated in the code.

Node-RED

For controlling the toy via the internet you can use node-Red. You can find the code at github via this link.

The flow is explained here and here.

 

Basic Node for the Internet of Sex Toys – part 2: 3d printed form, assembly, molding

In this series of posts we describe how-to make a vibrating sex toy which is part of the Internet of Things.

part 1: Basic Node for the Internet of Sex Toys

part 2: Molding the Basic Node

part 3: Software for the Basic Node

In part 2 we describe how-to make a mold form for the basic node. We need three forms:

  • the mold form which consists of two parts
  • the inlay which protects the electronics of the basic node
  • a “hanging” for the inlay

 

 

 

We used Tinkercad to construct the parts. The molding form is based on Tinkercad’s banana form. You can edit and share them from your browser:

Inlay: https://tinkercad.com/things/h5fFOBqlmjw

Hanging: https://tinkercad.com/things/jUxc2oAamww

Form: https://tinkercad.com/things/6HS3XScOsCM

Instructions

Print out all forms. The STL files are available at Thingiverse. You might want to use XTC or similar for smoothing the inner part of the mold form.

Assembling the Inlay

We use the inlay to protect the electronics.

Simply put the electronics inside so that the upper body of the switch is on the same level as the upper inlay. We use hot glue to fix the basic node.

Then fix the receiver coil of the wireless charging module on top of the inlay. The next step is to fix the hanging at the inlay.

Now fix the LiPo battery on the bottom side of the inlay using hot glue or similar. Fix the wires. Finally you might fix the wires of the vibration motor next to the middle of the LiPo battery.

Use tinkering wire to fix both parts of the molding form.

Put the inlay in the form. Fix the hanging with a tape or similar. The motors shouldn’t touch the inner part of the form.

Now prepare the silicone. We use Shore A 45 silicone (approx. 250 ml) from Silikonfabrik.de. It is hard but still a bit flexible. You may add color, too. You have about 10 minutes to stir the silicone and poor it in the form.

After some hours you can remove the form. As you can see there is overhang which make removing the form very hard. The form could break when removing. Better preparation of the form (eg rasping) could improve the results.

If the blue LED of the Wemos board is still active you were successful.

Now you need a charging station. The construction is shown here. It is also possible to connect the sender (or transmitter) module with a 5V power source (eg. from the USB port). Just put the bottom of the molded basic node on the sender coil.

 

In the next part we introduce an updated version of the software including over the air update and WiFi management.

Basic Node for the Internet of Sex Toys (part 1)

Wemos mini modules: ESP8266, motor driver and battery charging (in the middle); Wireless charging module (right side); wireless charging coil (top side); encapsulated vibration motors (left side)

In previous posts we showed how to build a vibrating sex toy in principle as part of the Internet of Things (IOT). In addition we have selected a hardware platform – the popular ESP8266 – for controlling a vibrator motor, gathering motion data and connecting to the internet. Now we want to build the toy itself.

part 1: Basic Node for the Internet of Sex Toys

part 2: Molding the Basic Node

part 3: Software for the Basic Node

Brief Review of development boards

There are a lot of development boards which are equipped with the ESP8266. The popular NodeMCU was already introduced here. Here is a quick overview and comparison:

NodeMCU

  • plus: very popular, cheap, USB connector for programming
  • minus: quite large (for being part of a sex toy), no support for battery charging

Adafruit Feather Huzaah ESP

  • plus: USB connector for programming and battery charging, smart form factor (only 23 mm wide), very good support (libraries, tutorials)
  • minus: quite expensive

WeMos D1 mini (pro)

  • plus: very cheap, USB connector for programming, additional stackable modules (eg. battery charging, TFT screens, motor driver), good form factor
  • minus: no real support (but there is a forum, problems with modules reported

ESP8285 (variant of the ESP8266)

  • plus: really small (!!!) and smart form factor, USB programming and battery charging, optional sensors on board (but no motion sensors)
  • minus: quite expensive, only 1MB memory (nevertheless enough for a lot of application)

For our project we selected the WeMos mini cause we get almost everything we need:

  • USB connector for programming
  • module for battery charging
  • module for a motor driver
  • good form factor (eg. to be put in a vibrator handle or in the base of a dildo)
  • cheap, fast delivery

But there is no shield for motion detection (accelerometer,gyroscope). So we have to use an additional board eg equipped with the MPU9250.

But there is a problem with the WeMos motor shield: After a few seconds it stopped working. And in addition the MPU9250 stopped working, too. Hours and hours we tried different configurations, changed the libraries … The problem was the motor driver shield itself. Fortunately there is an easy work around. Read here.

Another issue is the battery shield. It has an extra USB connector for charging the battery. So you have two USB connectors (one for battery charging and one for uploading). Two USB connectors are not handy. Fortunately we can do without the USB connector for uploading as it is possible to update the software over the air (OTA) using WiFi.

Material

As the body interaction philosophy uses motion for controlling the device we have to add the MPU. Again we use the MPU9250 which has an accelerometer, gyroscope and magnetometer.

Another insight was that you need at least a switch for rebooting. As we want to mold everything the switch must meet the IP67 requirements, which means it is water- (and silicone) proof. If you don’t want to mold the electronics you can use the RESET button on the WeMos mini board.

A perfect basic node has a wireless charging option, too.

Material list for the basic node:

  • Wemos mini board
  • Wemos motor driver shield
  • Wemos battery shield
  • Wemos prototyping board
  • Wemos set of pins
  • LiPo battery (eg. 3,7V 650mAh, 2C, JST plug, available at ebay)
  • MPU 9250 board (for motion control)
  • 1 or 2 encapsulated vibration motors, 3V, available at Alibabaexpress
  • Optional: Switch IP 67 protected (eg. Cherry Switches DC1C-K8AA IP67) – for molding
  • Optional: Wireless charging receiver 5V eg from Seeed Studio

Material: battery shield, Wemos mini ESP8266, motor shield, MCU9250 (first row), LiPo battery, switch, vibration motor (second row)

 

Soldering the basic node

We use one connector (part of the Wemos set of pins) to connect the Wemos mini with the battery shield and the motor shield. This is done to save space. If your application has enough space you would use one connector for every shield.

Battery shield, Wemos mini ESP 8266, motor shield (from top to bottom)

Now have a look at the bottom side where the motor shield should be. We can connect up to 2 motors. Solder motor 1 to A1 and A2. Motor 2 has to be soldered to B1 and B2. In addition we need input power for the motor. We just use the 5V provided by the Wemos mini battery shield. Connect 5V to VM and GND (from the pins) and GND. But you could use other (more powerful) power sources, too.

Wemos offers a prototyping board. We use it for mounting the switch and for the MPU9250. Connect the MPU9250 to the bottom side of the prototyping board. Therefore 4 pins have to be soldered

Solder pin (1 row, 4 pins)  on the top side next to TX, RX, D1, D2

 

Now look at the bottom side of the prototyping board. Put the MPU 9250 so that VCC, GND, SDA, SCL are connected to the pins.

Next, solder the MPU 9250.

Then add more pins to the prototyping board at both sides. The picture shows the bottom side of the prototyping board.

Now wire the prototyping board. The picture shows the top side.

Now you can add the switch. Place it in the middle of the board on the top side. Connect GND and RST to the switch. Now you have a switch for rebooting which can be molded.

Now we have both parts ready and can stack them together.

Stack them together!

Now add the LiPo battery, which should have a JST header. Now your basic node is ready.

Wireless charging option

Especially for sex toys a wireless charging option is reasonable as this is a requirement for silicone molding of the toy.  And when the toy is molded it is safe and washable.

The wireless charging module consists of a sender (or transmitter module) and a receiver module. You have to solder the receiver module to the battery shield. Don’t mix the modules.

unfortunately there is only  a USB connector. If you don’t want to remove the USB connector you can solder the red (+) wire to the R330 resistor as shown on the pictures. The black (-) wire can be soldered to any pin labeled (GND).

Now put the receiver module on top of the battery module.

Now stack the protoytping board on top of the battery shield.  And connect the battery.To charge the battery connect the sender (or transmitter) module to 5V. To power the sender module you may use a USB port power source which has about 500mAh or more. Place sender and receiver coil about each other.  For a more professional charging solution you need a charging station. The making of a charging station using 3d printing is described here.

Learn how to construct the mold form in part 2:

part 2: Molding the basic node

part 3: Software for the basic node

Smooth 3d printed vibrator form for silicone molding

shinybluemoreorlesscompleteWe started with printing sex toys (see here, here and here), then moved to printing mold forms for sex toys and finally we made sex toys which are partially silicone molded and partially printed. The best results were achieved with printing mold forms and fill them with silicone. But even there we have the problem that the surface isn’t really smooth and that it is hard to clean.

 

xtcTo overcome this problem we use a 3d print smoothing (XTC 3D) to smooth the surface. Application is very easy. It is like applying a transparent varnish. The results are impressive: The silicone gets a smooth shiny surface.

Shiny blue vibrator with vibration motor and air bubble in silicone formBut you can still see printer artefacts. To overcome this issue you could apply a thicker layer of XTC-3D. If you use a better printer than my daVinci 1.0 the “staircase effect” shouldn’t be a  problem at all. Another problem are tiny – sometimes quite large – air bubbles. To remove this air bubbles you need a vacuum chamber. So it is still not perfect, but it works and looks quite good…shinybluecomplete

Internet of (sex) things – part 4: Building a sex toy dashboard with Node-RED

In the fourth part of the tutorial we explain the development of a dashboard for our sex toy.

The series has 4 parts:

part 1: Exploring the internet of (sex) things

part 2: MQTT messages

part 3: Node-RED

part 4: Building a sex toy dashboard with Node-RED

The dashboard is used to visualize certain data eg. the speed of the vibration motor and the movements of the vibrator. In addition it can have some control elements eg. for changing the vibration pattern.

ui-all

The window above is called a tab. You can have multiple tabs. The Motor, Data, Status and Controls – windows are called groups. The Controls – group has buttons to set the motor mode. In addition there is a slider which will set the motor to a constant speed. And there is an on/off button for the LED.

You have to install the Node-RED dashboard. Therefore you need at least version 0.14 of Node-RED. At the time this text was written the standard Node-RED installation is version 0.13 which is not sufficient for the dashboard.

Therefore check your Node-RED version. If it is equal or better than 0.14, skip this step:

  • Download & unzip the latest version from github (eg. https://github.com/node-red/node-red/releases/tag/0.15.2).
  • Now change to newly created directory eg “node-red-0.15.2”
  • On Windows: Start a command shell in adminstration mode
  • Execute “npm install” to install Node-RED.

If your Node-RED version is 0.14 or better install the dashboard:

Some  remarks:

Let’s start and have a look at the new Node-RED interface: On the left side you will find the dashboard or user interface nodes. And on the right side there is new dashboard – tab. It contains all dashboard nodes which are used in the flow ordered hierarchical.

node-red-ui

But where is the dashboard? Just open your browser and go to one of the URLs:

http://localhost:1880/ui/#/0 or
http://127.0.0.1:1880/ui/#/0

How can I get all the flows? You can download all flows here: bi-ui-node-red. Unzip the file and you will get a text file. Open the text file in an editor. Select the text and copy it to the clipboard.

Now we will explain two flows in detail.

Now go the Node-RED window, open the menu (it is on the left top side), select Import -> Clipboard.import1

A new window will open where you can insert the text (CTRL+V). Then press the Import-button.

import2

nodemcu prototype breadboardThe Arduino sketch was updated for the dashboard. Please download the Arduino sketch from here: iost-part4-v12. Unzip the file. Compile and upload to your hardware (see part 1 of the tutorial).

 

In the first flow we will receive some vibration motor sex toy data which are sent by the MQTT protocol. We will display the data using a gauge and a graph element.

Let’ start with the MQTT input node. There is nothing new. Just connect to the MQTT server and subscribe the topic “BIoutTopic2” – which the sex toy uses to send out data.mqtt-in

Now add the function node “JSON” which will parse the incoming message and places the result in “payload”.

But we want to know the motor speed only. Therefore we need a function node which passes the vibration motor speed as payload and deletes all other data. Please use the following JavaScript code:

get-motor-speed-function-node

To display the speed we need to more nodes. The gauge node gauge-node displays the actual speed. Connect the gauge node with the function node. You can add the range – the minimum and maximum value (0 and 1023).motor-gauge

 

Now add a chart node chart-nodeand connect it with the function node, too.

 

Next we want the chart node and the gauge node to be together as shown in the next image.

motor

We have to make a group and put both nodes into the group. Have a look on the dashboard at the right side. Make a new group and move the gauge and chart node below the group called “Motor”.

dashboard-top

slider-nodeNow we explain the second flow. It is used to send commands to the sex toy. We will use a slider to control the speed. But there is one problem: the slider should display the actual speed of the vibration motor. Therefore we manipulate the slider. To display the actual motor speed we have to move the slider appropriate to the actual speed. The slider will be part of the control group:

controls

Now get the slider node and edit the node as follows:

slider-motor-speed

Then connect the node with the “get motor speed” function which was introduced in the first flow.

construct-json-motor-speed-function-nodeFinally comes the trick part. Get a new function node and connect it with the slider. This node will construct the JSON message which will be sent to the sex toy using MQTT. The JavaScript code of the function node is as follows:

function-node-for-constructing-json-speed-command

msg.payload={messageType:"execute", actuator:"motor1",
             actuatorMode:"constant", actuatorValue:msg.payload}
msg.topic = "BIinTopic";
return msg;

Now connect the function node with a new MQTT output node. Leave the topic empty as it will be passed from the input nodes:

mqtt-out-message-to-bi

Using Node-RED with the Node-RED dashboard we are able to make a user interface for our sex toy(s). We could easily display the motion of the sex toy as well as the vibration motor speed. You could argue that we had a (very simple) user interface already in part 1 of the tutorial, without having to use MQTT, Node-RED and the Node-RED dashboard. That’s true. But imagine you have several sex toys and want to control them. You could easily add a tab in Node-RED for each sex toy. Or you could build more sophisticated flows incorporating several sex toy. Why not interconnecting the vibrating necklace with a penis ring and one of the plugs or dildos?

There are a lot of flows and nodes already available at http://flows.nodered.org/. (Of course not in the sex toy domain)

Why not play music for a given sex toy vibrator mode? Or control the sex toy using another IOT device…

Internet of (sex) things – part 3: Node-RED

in the second part of this tutorial we have seen how to use the MQTT protocol to send data across the internet. In the third part we show how to add additional functionalities to our sex toys.

The series has 4 parts:

part 1: Exploring the internet of (sex) things

part 2: MQTT messages

part 3: Node-RED

part 4: Building a sex toy dashboard with Node-RED

We want to enable sex toys to communicate and  to connect to social media. Although there are a lot of solutions from the Internet of Things (IoT) community Node-RED is outstanding as you could connect devices without or with little knowledge of programming languages: “NodeRED is a visual tool for wiring together hardware devices, APIs and online services – for wiring the Internet of Things.”  (Wikipedia). There are standard building blocks (called nodes) which are categorized as input, output, function and social nodes. You can select nodes and wire them to create a flow. A typical flow would look like that: input node- function node- output node. If you want to know more you can should have a look at this very good tutorial: http://noderedguide.com/

In this part of the tutorial we will receive and display data from the sex toy. And we want to send control commands to the sex toy. This can be achieved with a few flows in Node-RED:

node-red-overview

Installation of Node-RED:

  1. First you have to install “node.js”. Follow the instructions here.
  2. Now follow the node-red installation instruction.
    For Windows: Press the Windows button. Type in “CMD”. Windows should suggest the command shell app. Now RIGHT-click on the command shell app and select “open as administrator”. In the new command shell window type in

    npm install -g --unsafe-perm node-red
  3. Change to the Node-RED directory and start Node-RED by the command “node red” or “node red.js”
  4. Go to your browser and open http://127.0.0.1:1880/

If you don’t want to make a local installation of Node-RED the online service FRED (https://fred.sensetecnic.com/) offers a good alternative. FRED comes with additional nodes with extra functionalities.

Let’s start with a first flow. We want to control the LED and the motor of our IoT sex toys. Therefore we need two nodes: The input node “INJECT” and the output node “MQTT”. Select both nodes and drag them into the flow window in the middle. Wire both nodes. Then open the Inject-node (just double-click the node). Change the  payload to type “string” and type in the command for switching the LED. This command is taken from the second part of the tutorial:

{messageType : "execute",  actuator : "LED",  actuatorValue : 1 }

In addition you have to enter the topic that will be used for the MQTT message. It is “BIinTopic” – the “in” refers to the sex toy. Select a name like “set LED on”:inject-mode-led-on

Then edit the MQTT node. The name of the MQTT server must be entered. Leave the Topic field empty and the MQTT node will use the topic from the predecessor node INJECT.

mqtt-out-message-to-biNow press the deploy button. You should see the message “successful deployed”.

Now you can press one of the INJECT node button (the button is on the left side of the node) and the LED of the sex toy should go on.controlbi2byrednode

You can use the JSON commands from part 2 of the tutorial and make an INJECT node for each command. With just 5 flows you can control all functions of the vibrator from everywhere. Instead of the INJECT node you could use an Email or Twitter node (instead of the INJECT node) to control the sex toy eg by Email.

There are no file open or save menus in Node-RED. Instead the visual flow can be imported and exported using a simple text file. If you want to import the flow above download and unzip this text file. Select Import -> from clipboard and copy the text from the file to the clipboard. If you want to save the flow, select Export -> from clipboard and copy the text of the clipboard in a new text file.

Now let’s receive messages from the vibrator and parse them. You need a MQTT input node, a JSON function node, a SWITCH node and two DEBUG output node.

We will show how to retrieve the status of the LED. When the LED is on the JSON file includes: “LEDstatus: 1”. Otherwise the JSON file includes: “LEDstatus: 0”.

Edit the MQTT input node and enter the URL of the Mosquitto server and the topic “BIoutTopic”.

mqtt-in

Then add a DEBUG node and select “complete msg”. Wire MQTT and DEBUG node. This node will display the MQTT message in the debug slider (on the rights side). This is only for debugging – you will see if the message from the vibrator comes in (or not).

Now add a JSON function node and connect the MQTT node with the JSON node. The JSON function node will parse the text string which was sent via MQTT and transforms it to a JSON object.

Now select a SWITCH node. As property enter “payload.LEDstatus”. The switch node branches the flow according to LED status which was reported in the JSON file. Now we can test, if the LEDstatus is 0 or 1. For each comparison a line will be added.json-switch-node

Finally make two DEBUG output nodes and wire them with the SWITCH node. Complete the “msg” by adding “payload.LEDstatus”. If the flow reaches the DEBUG nodes you will see a message in the debug slider on the right.

ouputnodeled

 

Now you are ready and can press the deploy button. It should look like that:

analyse-json

Again, the visual flow can be imported. If you want to import the flow above download and unzip this text file. Select Import -> from clipboard and copy the text from the file to the clipboard.

Let us test the flow. You have to set the LED on. Press the “turn on” button in your browser as explained in part 2.vibr iot controlnodemcu prototype breadboard

 

Now have a look at the “debug” slider where you should see the result of the action. The first entry is the JSON file which was received. It is displayed by the DEBUG node “message”. In the second entry the DEBUG node (wired with the SWITCH node) displays 1 which means the LED is on.debug-window-led-on

 

With Node-RED you can add a SQL database to store all data, you can connect to social media and especially you can connect MULTIPLE sex toys and let them interact. Read the excellent guides for parsing JSON files and MQTT:

http://noderedguide.com/index.php/2015/10/28/node-red-lecture-3-basic-nodes-and-flows/#h.5zaw60nvfsyj

What we have achieved: In part 1 we have developed a wifi-enabled sex toy prototype based on the ESP8266. The toy was controlled through a web browser on a local smart phone / laptop. Local refers to the access point. Both the local smart phone / laptop and the ESP8266 must have access to the same access point (eg your router at home.)

In part 2 we opened our connections to the internet. With the fast MQTT protocol we are able to send and receive messages from anywhere. For data transmission  we use the JSON file format. We have sketched a protocol for sending data, commands and messages between sex toys and users.

In this part we introduced Node-RED a visual programming tool for the Internet of Things. With this tool we are able to connect sex toys at different locations, to store sensor data and to get social.

In the fourth part of the tutorial we will introduce User Interfaces to create a sex toy dashboard.

%d bloggers like this: