Dash React Home Automation

Dash React

Login or Register to see price!


Dash React is the quintessential solution when it comes to automation programming.   It provides the capability to program reactively rather than imperatively.  This means that your system is reacting to various events rather than being told what to do each step of the way.  Dash React can provide an exponential increase in the speed, quality, and capabilities of your systems.  You can easily multi-task, sync activities & rooms, conduct recalls and macro interrupts, build automated procedures, and so much more.  Dash React provides anything from simple event execution to it’s capability to be the core operating system for all of your Automation Systems.


Sold by: Dash OS
SKU: dash-react. Categories: , .

Product Description

Take a second to think about Home Automation.  What is the coolest, most effective, or most powerful concepts you can imagine?  Now how would you accomplish that in programming with your specific system(s)?  Are you sweating yet?  Dash React was built to provide a new way to build and think about Home Automation Programming.  Our team & community has spent years thinking about the intricacies of Automation; it’s obstacles, it’s key concepts, and how these things all need to be brought together.  Dash React is the result of that thinking.

The Game Changer!

At it’s core, Dash React is an Artificial Intelligence Platform (AIP) which is capable of understanding and adapting to your systems context (environment) automatically.  It takes simple text as input (Reactive Variables) and based on your configuration intelligently executes various tasks within your system.  Execution of any tasks are done asynchronously (concurrently) rather than synchronously (linearly) (more on what this means later).  What is truly powerful about React is how simple and straightforward it all is to program.  While it likely sounds complex and confusing, you will quickly realize how simple programming even advanced automation concepts becomes.

Features

Below we will list just a few of the many features Dash React provides.  As a framework it can be used in so many ways it is almost impossible to list them all – and may may not make sense without understanding in what way they are being used.  See the documentation for more information and details.

  • Replaces URC Variable System with a simple, significantly more powerful “Reactive Variable System.”
  • Setup unlimited “listeners” on your variables that trigger macros based upon the value of the variable.
  • Triggers all your macros simultaneously for an exponential increase in speed.
  • Many ways to control your variable values such as Set, Append, Delete, Map, Sync, Save, Get, and more.
  • Dynamically “Sync” variables together (Example: Room Syncing).  Whenever one is changed while synced, it will change all others to reflect those changes immediately.
  • Create Recalls which can save the current state of the system and revert it back to that state at any time.  For example, when a doorbell rings you can switch a source, play a doorbell tone, then switch all rooms back to where they were – all with just a few commands!
  • Save variable values and retrieve them from the MRX Disk – allowing you to persist variable values through restarts and keep the system state in-tact.
  • Conduct mathematics on variables directly or run expressions based on the values of multiple variables.
  • Integrate with other Dash Apps for an entirely new level of functionality.

How it Works

Dash React essentially replaces the URC Variable System.  Your “Reactive Variables” actually become the mechanism that trigger your system to take action.  You are able to program any number of reactions that constantly watch a Reactive Variable’s value and trigger each macro that matches, simultaneously.

Dash React provides many ways to work with your variables and change them to fit the growing context of the system.  You can append, delete, copy from and to, save & recall, revert and restore, sync multiple variables together, and much more (more information on each is in the documentation).  Since each variables values trigger your macros, this means React has an infinite number of possibilities!

React’s list of features is huge, but let’s first consider some important points that React was built upon:

  • Simple – When we say simple, we say it because React allows you to think about your system in a different way. Each action is “compartmentalized” in a way it becomes easy to understand what each part of your system is doing and why – and with Cloud Logs it becomes simple to do what used to be impossible!
  • Powerful – Once you start programming with React you’ll quickly realize that anything you can do with the system you’ve designed can be done without much programming.  New possibilities will quickly emerge!
  • Fast – Speed is probably the first thing you are going to notice when using this framework.  We have achieved speeds up to 98% faster than standard methods of control!
  • Lightweight – Using only the most modern and powerful programming techniques we were able to fit the entire React Framework into the smallest module ever released – only 280 kb!  It’s as-if it isn’t even there yet completely changing what is possible with your systems!

Examples

To introduce how React might work in one situation, we will build up a concept and discuss how the system will handle each part of it.  This is one of an almost unlimited number of ways you can utilize React on your projects.  While you read through this, don’t think about how we are accomplishing this.  Instead think only about what we are actually accomplishing.

Lets say we have created a Reactive Variable which we will name “FrontDoor”  This variable will become the “controller” of our Front Door and how it needs to act based upon the context (environment) of our system and the many states it may be in.

To start lets consider what a Door Lock does and each part of how we might interact with that door lock:

  • A Door Lock can be sent commands to “Unlock” and “Lock” from the system.
  • A Door Lock may be “Unlocked” or “Locked” at any point by the System, a key, or by entering a PIN Code.  It will report it’s state to us whenever it is changed.

Simple enough!  So now that we know how the lock is going to operate, lets start to build a Reactive Solution which provides a powerful & contextual solution to the end-user.

Dash React gives us the capability to setup “listeners” (Device Events) which will trigger based upon the value of the variable they “watch.”  So lets start by creating two simple listeners on our “FrontDoor” variable.  Whenever a listeners parameters are met, it will trigger the macro we attach to it.  Written in plain english, here are the parameters for our first two listeners:

1. When the variables value is equal to “Lock”

2. When the variables value is equal to “Unlock”

Ok, simple enough!  We now have two listeners setup on our variable which will trigger macros when their parameters are met.   We will add the “Lock” and “Unlock” commands to those macros accordingly.

As it stands, we can lock and unlock the door but it really isn’t doing much else.  Lets extend this to include a kind of “confirmation” that the door successfully locked or unlocked.  This will also tell us the “current state” of the door lock automatically and will always remain up-to-date.

To accomplish this we will program a Device Event upon the Front Door which will change our variables value whenever the door actually locks or unlocks.  So if we take a step back, here is what we are doing so far:

  • Whenever the variable is “Lock” the Front Door will immediately be told to lock.
  • Whenever the variable is “Unlock” the Front Door will immediately be told to unlock.
  • Whenever the door is locked, our variable will be changed to “Locked.”
  • Whenever the door is unlocked, our variable will be changed to “Unlocked.”

Now we can begin to introduce some of the more advanced “listening” capabilities that Dash React has to offer.  Lets take a look at some parameters we may want to add to our “FrontDoor” Variable:

  • When the Variable has included “Unlocked” for 10 Consecutive Minutes
  • When the Variable has included “Lock” OR “Unlock” for 5 Consecutive Minutes

Now, without any extensive IF/ELSE Logic, or the need to use other modules, we have the ability to do some really cool things.  If our user has left their door unlocked for 10 consecutive minutes, perhaps we will send a notification to the user asking if they would like to lock the door now, or perhaps we will automatically lock the door for them should it be left open after dark – or better yet a mixture of both of these solutions.

With the second listener we are confirming that the door lock successfully locked or unlocked when we asked it to.  If it never changes from “Lock” or “Unlock” we know that the command wasn’t successful and can either automatically try it again or warn the user that something may  be wrong via Push or Email Notifications.

With React, you have the option to make your system respond in pretty much any way you may need it to.  Here are a few other listeners we might add in various situations – all accomplished without using a single IF/ELSE Statement:

  • While the variable includes “Unlocked” … trigger this every 10 Minutes…
  • When the variable includes “Unlocked” AND “by User1” …
  • When the variable includes “Unlocked” AND “by User2” …
  • When the variable includes “Unlocked” AND “User3” OR “User4” …
  • When the variable includes “LowBattery” …

Now we just accomplished a lot in this example, and should this be your first look at Dash React, it’s easy to imagine your head may be spinning.   Stop and think for a moment about how much programming that may have taken to accomplish….  we called it a “simple example” for a reason!  The entire process above and all the logic to accomplish it took exactly 4 lines in all the macros we created to accomplish!  When we created the demo file (available in the documentation), it took exactly 6 minutes and 20 seconds from the moment we clicked “new file” including the TRF-ZW1 Configuration.

Available TCL Commands

  • Set Variable (String) – Set the variable to an exact value as specified in the command parameters.
  • Set Variable (Integer) – Set the variable to an exact integer as specified in the command parameters.
  • Append to Variable – Append a value to the current value of the variable.  For example, if value is “A” and you append “B” the variable becomes “AB.”
  • Delete From Variable – Deletes the given value from the variable while leaving all other parts of the variables value intact.  For example deleting “B” from our value “AB” will make the value “A.”
  • Math on Variable (Integer) – Run an expression against the current value of an integer variable.  For example, if our value is 23 and we choose to multiply by 2, it will become 46.  Add, Subtract, Divide, Multiply currently available.
  • Variable Operates on Variable (Integer) – Runs an expression from the values of two variables and saves to the given variable.  For example if “Variable A” is 2 and “Variable B” is 6 we could run “A * B” and save the value (12) to either A or B or another variable entirely.
  • Get Variable Value (String) – Get the value of a variable and save to a URC String Variable.
  • Get Variable Value (Integer) – Get the value of a variable and save to a URC Integer Variable (if the value is an integer).
  • Copy Value to Variable – Take the value of one variable and copy it onto the value of another variable.
  • Refresh Last Events – Takes the current value of the variable and re-triggers any macros that were triggered when it was set to that value originally.
  • Variable to Previous Value – Set the given variable to the value it was previously, triggering any macros as-necessary.
  • Recall: Save Variable Value – Save a variable’s value onto a Recall Variable for later use.
  • Recall: Save Given Value – Set a Recall Variable to the given value directly.
  • Recall: Copy Value from Recall ID – Set the current value of a Recall Variable onto any Reactive Variable.
  • Persistent Store – Save the value of a Reactive Variable or Recall Variable onto disk storage so it can be retrieved later, even after a reset or system download.
  • Persistent Get – Retrieve the stored value and save it onto a Reactive Variable or Recall Variable.
  • Variable Syncing – Create a “Sync” between any variables so that changing one will change all while they are synced.  For example, for Room Syncing, Volume Syncing, and much more.
  • Variable Unsync – Remove a variable or all variables from a previously created sync.
  • Control Rule ID – When using Rule ID’s when creating your variable listeners, this allows you to “pause” and “resume” matching events from triggering,  Useful for system modes and settings.
  • Alias Variable – An advanced command normally for use with template creation, this allows you to create an “Alias” of a variable.  For example, if we had a variable “Variable A” and we alias it to “LivingRoom” – both “Variable A” and “LivingRoom” would act as-if it were one variable.
  • Extra Commands – Access extra commands that are meant to be helpful shortcuts to use while programming.

Available Device Events

  • Simple Variable Event – Program a listener on a variable to trigger when a variable becomes a value, was a value, or a combination of both.
  • Advanced Variable Event – Program a listener on a variable with many included options and the ability to set logic directly within the event itself.  You can specify based on the value the variable has become or was or a combination of both.
  • For Variable… (Delayed Actions) – Program a listener to occur once the variable matches the specified parameters for the given amount of time.  It must match the value for the entire period of time or it is reset (see Event Triggers if you desire similar but custom behavior).
  • While Variable… (Intervals) – Program a listener to occur at the given interval for as long as the variable value meets the given parameters.
  • Rule ID Event – Program an event to occur if a command Pauses or Resumes listener events for the given Rule ID.

Dash App Documentation Overview

This page will guide you through the installation, configuration, and programming of the specified Dash App.  You can navigate to various sections of the documentation by using the menu to the left.  New information is always being added to Dash’s Documentation so be sure to check back often to discover new ways to utilize your apps!

Download App:

Driver Location:

My > IP Database > AUX > Dash Apps > React

Driver File:

Dash – React.csd

Dash OS Update History

Whenever an update is available for a Dash App, a log of the major changes in the version will be provided below.  This does not necessarily reflect every change that was made as some minor changes may have been made that are undocumented, but it should reflect any changes that affect the operation of the Dash App.

Version 1.0

  • Initial Release of Dash React!

Download & Import the Dash App

In order for the Dash App to become recognized by the URC Programming Software we will need to import the provided TCM File into the Software.  Once this has been done properly the Dash App should show up in the “Add Other Devices” programming step in the “Accelerator Location” provided on the overview tab.

Import TCM

In your Programming Software locate the “Import TCM Files” button in the File tab of the top menu toolbar.  Click it to open the Windows File Browsing window.  Browse to the TCM file you wish to import and select it.

Import Dialog

Based on the Dash App / Module you are importing, a dialog similar to the below will appear.  This window indicates what interfaces are supported by the TCM File you selected.

System Plugins may only show “Driver” and “Base Station Files” when no User Interface is provided by the module.

Restart

After Importing your TCM File it is always safe to quickly restart your Accelerator Software to make sure your changes are properly made.  While this isn’t required every time, it is a good step to make sure everything is changed as needed.

Confirm

Confirm that the Dash App was successfully imported.  You can do this by navigating to the driver where the Dash App is installed (see Overview Tab) and making sure a checkbox is provided for “8. Select 2-Way Modules for Network Remotes / Keypads”

Non URC Network Setup

Network Setup is a step that is required regardless of if the module is communicating with a physical device.  This step will go over how your Network Setup should be configured for this Dash App.  You will generally find the Dash App under “Network Setup > Non URC Device” in your URC Program.

This Dash App does not require that a specific IP Address is setup for it to operate.  However, it should be assigned an “Instance ID.”  When a module does not require a specific IP Address be setup, you can assign any IP Address to the Dash App that is unique from any other device in the list.

Your IP Address will be used as an “Instance ID” which will separate it from any other Dash Apps or URC Modules you have setup.  This ID is helpful when you want to create jumps to the Dash App / Module in multiple rooms / areas of your programming.

In the example below we have added two Dash Apps, “System Monitor” and “Time Tools.”  Each has been given a unique value “0.0.0.1” and “0.0.0.2.”  If they were assigned the same value the Dash App would result in an error and would not start up properly.

Step 11. 3rd Party 2-Way Settings

Properly configuring the Dash App Parameters in your Automation Programming Software is important in order to make the App work as you want it to.  These Parameters will be used each time the App starts up to configure how the App will operate.  Below we will go over each available parameter.

No Parameters Currently Available!

Available in the Dash OS Community Forums

Due to the need for many guides and walkthroughs, Dash React has a special section in the Community Forums specific to guides & walkthroughs made by the Dash Team and our users.  This is where you should go to get more information about Dash React as well as ask any questions you have about how to implement, what is possible, and more.

Note: You will need to login to the forums with your Dash Username & Password before you can view these forums.

Dash App Integration with React provides a mechanism to not only use React’s many features to run logic and events against the current state of other Dash Apps, but it also provides a powerful means that allows communication between Dash Apps in a way that was not previously possible.

The initial Dash App Integrations are in Beta Testing, but you can expect most Dash Apps will eventually have integration.

Integration works in multiple ways –

  1. It can allow a Dash App to directly set or get a variable’s value.
  2. It can create many variables that are two-way synced to the Dash App.  For example, it can create a Reactive Variable for every Lutron Integration ID.  If the lights are changed, the Reactive Variable will also immediately change.  If you manually change the variable it will automatically change that lights level.
  3. Dash iOS … any action in Dash iOS can set any variable or multiple variables as you specify.  This is actually already working in Beta Testing!  Below is a screenshot from Cloud Logging showing the “Dash OS” module setting the value of a React Variable.

 

Dash Cloud Logging

More Information on this Coming Soon!