A common operation handling flowing data and measurements is to compare results and the decision matrix (DM) has plenty of functionality built-in for this. Here we will look at three of the actions available for this.
This action check the value of a variable against a literal and the set the named boolean remote variable to the outcome of the logic operation. So
3.14;eq;pi;myflag
will set the remote variable myflag to true if the remote variable pi is equal to 3.14 (false otherwise) and
32;lt;temp;alarm
will set the boolean remote variable alarm to true when the remote variable alarm have a value that is greater than 32 and to false otherwise.. The last will look like this in its complete form
<row enable="true" groupid="Variable compare" >
<comment>
Test the variables tamp if its greater than 32
every second
</comment>
<mask priority="0"
class="0xFFFF"
type="0xFFFF"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<filter priority="0"
class="65535"
type="5"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<action>0x58</action>
<param>
32;lt;temp;alarm
</param>
</row>
Check variable, set to true
This is just a variant of the above. Instead of the result of the logical compare true is always stored when the calculated result is true.
So the example above
32;lt;temp;alarm
will no actually do the same as before. If the result is true it stores true and false if not.
Check variable, set to false
Another variant of the same. Instead of the result of the logical compare false is always stored when the calculated result is true.
So for the example above
32;lt;temp;alarm
alarm will be false when temp is greater than 32 and vice versa.
Quite often one want to store min and max for measurement values So of course you can do that with the VSCP server just by adding a row to the decision matrix.
The first thing you need is a remote variable to store the min/max in. You can add this remote variable to the variable xml file so it is created when the system starts or add it as a persistent variable to the database. Another way is to create the variable when the server starts right is the DM. We use the last method here as it is makes things clearer in this how-to.
You can create a remote variable minimum and another maximum with the following two DM rows which triggers on the CLASS2.VSCPD, Type=23 Starting up which is feed to the DM once when the VSCP server is started. .
<row enable="true" groupid="Min/max" >
<comment>
Create variable that hold min
when the server is started
( CLASS2.VSCPD, Type=23 ).
</comment>
<mask priority="0"
class="0xFFFF"
type="0xFFFF"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<filter priority="0"
class="65535"
type="23"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<action>0x50</action>
<param>
minimum;float;false;0;0x777;9999999;BASE64:test min
</param>
</row>
<row enable="true" groupid="Min/max" >
<comment>
Create variable that hold min
when the server is started ( CLASS2.VSCPD, Type=23 ).
</comment>
<mask priority="0"
class="0xFFFF"
type="0xFFFF"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<filter priority="0"
class="65535"
type="23"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<action>0x50</action>
<param>
maximum;float;false;0;0x777;-999999;BASE64:test max
</param>
</row>
Here the minimum variable is created as a non-persistent variable (it will not hold its value between sessions), it is created as a float and initiated to a “very high” value (9999999), The maximum variable is also created as a float and initiated to a “very low” number (-999999).
The values for the minimum and maximum variables is selected so that minimum is initiated to a value that is higher than what is expected to be a lowest value that will be received by the system and the same for the maximum but the other way around.
So no we have the two variables. Suppose we now want to check the maximum and minimums for a temperature. This means that we will look for a measurement event with type = 6 temperature. I write “measurement event” here as they come in a couple of flavors. A DM row like the following will handle the collection of minimum data
and it will store the temperature value of the incoming VSCP event if it is lower than the value currently stored in the remote variable minimum. The 1,1 after the variable name in the parameter says that the measurement should have unit=1 (Celsius in this case) and originate from sensor with index=1 on the remote node,
For the maximum the DM row looks like
<row enable="true" groupid="Min/max" >
<comment>
Test for maximum
</comment>
<mask priority="0"
class="0xFFFF"
type="0xFFFF"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<filter priority="0"
class="10"
type="6"
GUID=" 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00" />
<action>0x72</action>
<param>
maximum;1;1
</param>
</row>
action is used here which compares the names variable for a highest value instead of a lowest value.
That it. We now have to variables maximum and minimum that holds the maximum and minimum values for the temperature. We can read (and write) this value in all the interfaces, tcp/op, websocket, mqtt, REST etc and use it for other calculations or present it in a UI. With websocket this presentation is actual trivial using one of the ready-made widgets.
Also not that this work s for all measurement units (that is all SI defined and derived units) in the same way. No coding needed.
One last thing. Suppose you want to daily maximum/minimum instead of an all time maximum/minimum. Easy
which is set to trigger just before midnight. What you get here is a remote variable minimum-YYMMDD where YYMMDD is the current date that is persistent and holds the value of the minimum remote variable collected for that date.
This howto describes linking of VSCP server interfaces. With a server interface we mean the VSCP tcp/ip control interface and especially the the VSCP link interface which is the required tcp/ip commands that all VSCP nodes exporting a VSCP interface must make available. You find the full list here.
A VSCP server has an extended command set that can handle many special task needed on a full server. An embedded node however often just need the more limited set of commands but can of course add any other commands it like to export available if needed.
Why link servers
Why link servers one may ask. There can be many reasons for this Security can be one. You may link a VSCP server to a higher end server with just event going upwards not downwards and by that prevent security threats as it will be impossible for the upward server to send events to the lower server. A typical scenario fr this is a server that show public data to an audience but where the source for the data is a real world system.
You maybe also just want to collect events from many subnets on a higher end server or some type of events on a special server.
Even more common is connections with lower end nodes that implement the tcp/ip interface and where you want to contact them from a server, to collect data, configure, control, instead of the other way around.
How
There are many ways to do this. You can make a special driver. Make JavaScript or Lua scripts that handle this. Build your own application that acts as middleware. But there are of course read made tools available to.
If you want a connection from/to a remote node that is always active, yes it will be maintained, automatically bring up the link if it falls, the tcp/ip link driver is the solution. It lets you set up a link between two machines where one is a VSCP server and where the other machine also can also be a VSCP server but more usually is a lower end node exporting a VSCP tcp/ip interface. The driver is extremely simple to use. Just add it, setup user connection data and set filters for outgoing and incoming events. The tcp/ip link driver is described in full detail here.
If you need to share a smaller selection of events with a remote node or just want to send events to a remote node when special things happen, or just want to filter events very hard, the decision matrix has an action that let you send events to a tcp/ip remote link interface.
Send event to remote host action
Its is the
VSCP_DAEMON_ACTION_CODE_SEND_TO_REMOTE 0x43/67
action that is used for remote connections. A typical DM entry looks like this
Here the temperature event that triggers the action is sent to a remote server (%event). You can of course set up to send any event you like or send an event that is stored in a variable.
A connection is opened and closed each time an event is sent so the driver is much more efficient to use for setups where a lot of events should be sent to a remote location. The actual transfer is on its own thread so timing is pretty constant also for a slow remote connection.
Measurement events is a central part of any VSCP system of course. The standardisation of measurement makes it possible to hook in parts to a system and read write measurement values in a deterministic way.
The VSCP server can collect measurements from many sources, it can convert them, send them further to other destinations, save them in databases, diagram data, well, do a lot with the values of measurements.
Many time one want to compare measurement values. If a certain value is bigger than a set point an alarm may be sounded or some other action may be needed. Usually this is functionality that is handled by program code. This is possible in VSCP also of course. You can even put this code inside the VSCP server using Javascript or Lua or outside in executable files written in any language. But comparing measurement values is also build right into the decision matrix (DM) mechanism of the VSCP server also.
I show the XML format for setting this up here but the database can be used in the same way.
Every DM configuration row can have a measurement part that looks something like this
If this tag is in a DM row additional checks will be performed on an event before an action is triggered. Here the value of the measurement will be compared to the value 5.014567 for equality and if they are equal AND the unit is the same (here 1) the action will be triggered.
A typical full row for a temperature check will look like
Here we have a row that will execute the external script alarm.sh when a temperature event with a temperature given in degrees Celsius (unit=1) is received and the measurement value is equal to 5.014567
You can of course trigger other actions instead. Send another event, run a Javascript or a Lua script, do an http page post…
As you probably have expected you can do other compares to, like greater than, less than and so on. They are all listed here.
If you want to play further with this you have some test setups here.
More info about the decision matrix in the VSCP server is here and info about general decision matrix logic in VSCP is here.
Here the action is allowed to is allowed from prehistoric times and way into the future. We can say it is allowed to occur forever/always. This is always specified in a time range pair <allowed_from> and <allowed_to>. To say forever/always you can also use a ‘*’ like in
which also means forever. Leaving them out and not specifying an allowed time range at all also will be interpreted as forever/always.
allowed_weekdays
The next thing you can do is to select which weekdays the action can occur at. This is always seven characters or a ‘*’ meaning every weekday. Again leaving it out also means all days.
Some samples
Every day of the week <allowed_weekdays>mtwtfss</allowed_weekdays>
Every day of the week <allowed_weekdays>*</allowed_weekdays>
Only on mondays <allowed_weekdays>m------</allowed_weekdays>
Mondays and Fridays <allowed_weekdays>m---f--</allowed_weekdays>
allowed_time
The last tag the <allowed_time> gives most control of when the action should occur. You can be VERY specific as in
<allowed_time>2028-12-02 14:32:30</allowed_time>
and the action can only happen this specific year, date and time down to the second. The allowed date range must always be valid and also the weekday must be set to allowed on this day.
You can also be looser and specify
<allowed_time>2028-*-* *:*:*</allowed_time>
which is anytime in year 2028.
But you can also specify
<allowed_time>*-*-* *:30:*</allowed_time>
which means that things can occur every half hour.
For anytime you can specify
<allowed_time>*</allowed_time>
or
<allowed_time>*-*-* *:*:*</allowed_time>
oer leave the tag out all together.
So how do one specify that something should happen every five minutes?
You have a VSCP system (or other system) setup that control something. and now you want to share some of this information up to the cloud. One typical problem that you will see when doing this in a VSCP system is that data (we call it events in VSCP) is coming in with a higher rate than the rate you would want to publish it to the selected cloud service. To solve this VSCP remote variables are perfect helpers.
A stream from a VSCP interface can typically look like this.
There is a lot of events coming in and often the frequency is even much higher that it is here. All the data above comes from a refrigerator and a fridge that is controlled by two Paris and one Kelvin NTC10K modules. Kelvin modules publish temperatures from a fridge, the kitchen and the upper and lower part of a refrigerator. The Paris module controls the compressors from these temperature measurements (ON/OFF events). The Turn-ON/OFF events originate from the Kelvin modules. So when a temperature goes above a set point Turn-On events are sent from the Kelvin module after each temperature read and similar a Turn-Off event is sent when the temperature goes below the low set point. Nothing fancy really there.
We will look at one specific temperature only here, the fridge temperature.
This temperature comes from a Kelvin NTC10K module with GUID=FF:FF:FF:FF FF:FF:FF:FE B8:27:EB:0A 00:02:00:01 We find this out with the VSCP Works tool which always is our friend when diagnosing a VSCP system.
We also see that the sensor is at index 1 for this particular temperature sensor on the Kelvin NTC10K and that the temperature is sent in Celsius (Unit=1), exactly as we want to present it. Thus no conversions is needed.
Now, one way of sending this data to the cloud is to have a DM (decision matrix ) entry that send the data to the cloud every time it is received.
For this we just add an entry in the DM that calls a script when the temperature event is received. This DM row would look like this
Here the mask says that all bits of the VSCP class is of interest, all bits of the VSCP type is of interest and all bits of the GUID is of interest. This is basically to say that the event we enter in the filter is the one we are interested in. So what we had entered in the filter is VSCP Class = 10 for measurement, VSCP type=6 for temperature and the GUID of the Klevin NTC 10K sensor that send the fridge temperature value.
Action is set to 0x10 (16) which says we should execute an external script. The param is the argument to this script. The first part of the param is the path to the script to execute (which must exist and be executable) and the rest is parameters. So here we execute the script /srv/vscp/scripts/thingspeak.sh and send three parameters
XXEIAQWY1XXNU6XX 2 %measurement.string
to it. The first parameter is the publishing key to the thingspeak service, the second is the number of the Thingspeak field we want to upgrade. The last parameter is the current temperature in the fridge. The %measurement.string will be replaced by the actual temperature before the script is executed. There are plenty of escapes one can use in decision matrices.
The script that is called is simple and looks like this
#!/bin/bash
# Arguments
# =========
# 1 - Write key
# 2 - Filed number 1 .. n
# 3 - Value
#echo() { :; } # comment line to enable debugging
update=$(curl --silent --request POST --header "X-THINGSPEAKAPIKEY: $1" --data "field$2=$3" "http://api.thingspeak.$
echo "Update #$update"
# Uncomment to get debug output
#echo `date` - "$1 field$2=$3" >>debug
Pretty straight forward. Check the documentation up at Thingspeak for the full process.
So what we got now is a DM entry that will update the cloud data as soon as the measurement event comes in. If it, as in this case is received with a frequency less than ten seconds, this may be pretty wasteful of server resources. Better to update the cloud data at even time intervals. How do we do this using the VSCP server?
To do this we first write the fridge temperature to a variable every time the event is received. We select a non persistent variable as it is no use in saving this value between session. The DM entry for this looks like this
<row enable="true" groupid="fridge" >
<comment>
Store current temperature for fridge in remote variable fridge_temp
with typ float (5)
</comment>
<mask priority="0"
class="0xffff"
type="0xffff"
GUID="FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:Ff:FF:FF:FF:FF" />
<filter priority="0"
class="10"
type="6"
GUID="FF:FF:FF:FF:FF:FF:FF:FE:B8:27:EB:0A:00:02:00:01" />
<action>0x50</action>
<param>fridge_temp;5;false;0;0x777;%measurement.string</param>
<allowed_from>0000-01-01 00:00:00</allowed_from>
<allowed_to>9999-12-31 23:59:59</allowed_to>
<allowed_weekdays>mtwtfss</allowed_weekdays>
<allowed_time>*-*-* *:*:*</allowed_time>
<index measurementindex="true">1</index>
</row>
So now whenever the event that holds the fridge temperature comes in it is written to the VSCP remote variable fridge_temp .
With VSCP Works we can list check that the variable is available
and it is, fridge temperature is currently -19.43 degrees Celsius. As you can see we have added the other measurements of the fridge and the refrigerator to variables as well.
Now with the fridge temperature in a variable we can easily access the fridge_temperature remotely using websockets in a webpage or if we prefer the REST interface better it can be used instead. But also the TCP/IP interface or the MQTT interface of the VSCP server can be used. Actually display the fridge temperature in a widget on a web pages is just connecting it to the variable.
But here we want to send the value to Thingspeak every minute so we add another row in the DM that looks like this
In this DM row we use the same script as above but now instead of triggering on the Class=10,Type=6 (A temperature measurement) we trigger on Class=65535, Type=6 which is the internal minute event. So now the fridge temperature will be sent up to the cloud server every minute instead of each time the measurement event is received. We can do this for all other fridge/refrigerator measurements also and send them all in one call up to the cloud server. Much more efficient.
Note the abstractions here. A driver on the VSCP server can collect data from a device of any type, transported over any net using any protocol etc and it will end up well-defined here. This also works the other way around as the data can be sent out over any protocol, using any carrier and ending up on any device. One simple driver is all that distinguish one type from another and this driver can make everything look like it is a VSCP aware thingi from the VSCP servers point of view.
Task completed.
Hardware Setup: Here the VSCP Server is running on a Raspberry Pi. The fridge and the refrigerator and the modules is connected with CAN and the Pi uses the CAN4VSCP driver with the Frankfurt RS-232 module with a serial USB adapter to talk to the bus. Ethernet, Wifi, sub MHz RF, or whatever could have been used instead of CAN, but the powered CAN4VSCP bus is both low-cost, reliable and perfect in many other ways for a setup like this.
We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.
