Available for download on Source Forge and on GitHub.

Enjoy!
/Ake
akhe@grodansparadis.com

or the story about staying on the job and not give up…  😉

VSCP

OpenHAB

IoT

Running VSCP & Friends Linux version on Windows. Yes it sound strange but this is actually possible now in windows 10 build 14316 which have Ubuntu Linux incorporated into the system.  No it’s not a virtual machine its the real thing. Life just got easier for developers of cross platform tools.

Well how to use this new stuff?

First you need to switch your Windows 10 system to the Fast Ring. You do this by going “System Settings > Advanced Windows Update options” and selecting your Insider Preview update setting to the far right. This sets your Windows 10 update to the the Fast Ring.

Now you must turn on Developer Mode via “Settings > Update & security > For developers“. Search for “Windows Features” and choose “Turn Windows features on or off” and enable Windows Subsystem for Linux (Beta).

Restart the machine.

Open up a console and type “bash“.  Well you are done. After some work by the machine  you can install the VSCP & Friends system as on any other Linux machine.

This is release 1.12.0 of VSCP & Friends

From now on releases will come closer on all platforms. There will not be as much fuzz about therm as before.

Download here or here.

This release may not be the choice for a critical installation as it contains many changes from the previous release.

Enjoy
/Ake

A new VSCP firmware is released as version 1.6.0.

The main difference in this release is that the segment controller check has been removed.  This means that the node control that was present in register 131/0x83  is now replaced by the error counter.  Thus read the current error counter value from this register.  Reset the error counter by writing anything to the register.

With the same segment check removed a node that is moved from one segment to another now must be manually initialized after it has been started up.

Previously one control byte was used to check for initialized EEPROM.  Now this is two bytes. The callbacks for this purpose has therefore been changed.

///////////////////////////////////////////////////////////////////////////////
// setVSCPControlByte
//

void vscp_setControlByte( uint8_t idx, uint8_t ctrl )
{
    if ( idx > 1 ) return;
    eeprom_write( VSCP_EEPROM_CONTROL1 + idx, ctrl );
}

///////////////////////////////////////////////////////////////////////////////
// getVSCPControlByte
//

uint8_t vscp_getControlByte( uint8_t idx )
{
    if ( idx > 1 ) return 0;
    return eeprom_read( VSCP_EEPROM_CONTROL1 + idx );
}

Another callback has been added that do the actual initialization of the EEPROM

///////////////////////////////////////////////////////////////////////////////
// vscp_init_pstorage
//
void vscp_init_pstorage( void )
{
    init_app_eeprom();
}

An addition is added if you define

VSCP_FIRMWARE_ENABLE_ERROR_REPORTING

which will give access to a method for VSCP standard error reporting

/*!
    Send error event (CLASS=508).
    http://www.vscp.org/docs/vscpspec/doku.php?id=class1.error
    idx can be used to identify the internal part ("submodule") that was the
    origin of the error. Both zone and sub zone are always set to zero.
    @param type This is the VSCP type
    @param idx Index to identify possible sub module. Normally set to zero.
    @return True if event was sent.
*/
#ifdef VSCP_FIRMWARE_ENABLE_ERROR_REPORTING
uint8_t vscp_sendErrorEvent( uint8_t type, uint8_t idx );
#endif

Just remember that over CAN it is no use in reporting communication problems as doing so will most likely make them worse.

Another addition is added if you define

VSCP_FIRMWARE_ENABLE_LOGGING

which gives access to a method for standard VSCP logging.

/*!
    Send log event (CLASS=509). 
    http://www.vscp.org/docs/vscpspec/doku.php?id=class1.log
    For loging first send Type = 2(0x01) Log Start then logging events and when 
    log is closed send Type = 3 (0x03) Log Stop. To log several things use a 
    unique if for each and open/close each.  
    @param type VSCP logevent type.
    @param id Identifier for the logging channel.
    @param level Loglevel for this log event.
    @param idx index for multiframe log event starting at zero.
    @param pData Log data (Allways 5 bytes).
    @return TRUE if event was sent.
 */
#ifdef VSCP_FIRMWARE_ENABLE_LOGGING
uint8_t vscp_sendLogEvent( uint8_t type, 
                            uint8_t id, 
                            uint8_t level, 
                            uint8_t idx, 
                            uint8_t data );
#endif

As always the Paris project and the Kelvin NTC10K project can be used as reference code.

The release is available here.

Enjoy!
/Ake

This is simple. Every protocol that is entering the scene today is dubbed an IoT protocol. Hmmm… are they really… or are they transport mechanisms (which we already have plenty of) or is they just useless vertical solutions (well not useless for the company who made it).  And hey… it does not have anything to do with Internet or wireless. It’s about connecting things.

So

1.) Does the protocol connect things together? If so, item under test is a candidate for an IoT protocol.

2.) Ask ten people in ten different areas of the earth without contact with each other to send a measurement of there current temperature over the protocol. If the receiver on the other end know what he/she receives from all ten the protocol  is a candidate for an IoT protocol.

3.) Ask the ten people to send an ON command and then an OFF command to turn on/off a lamp at the receiving end.  If all actually does this the protocol is a candidate for an  IoT protocol.

So 1+2+3 and success on all, yes and hurray, it’s an Iot protocol. If not it may still be a useful protocol  for other things.

Åke Hedman
Paradise of the Frog AB

If there was time…

… then I would have put more time on UX components for VSCP. YES the infrastructure is there. We where one of the first with a websocket interface to interface UX components. We have the REST interface and the tcp/ip interface. I would dare to say there is no system/framework available today that makes it easier to visualize result from sensors out there and also to interact with them in such an easy way. A few lines of code is all that is needed. Some demos are here (User:admin Password: secret).

But we (the VSCP world) don’t have users that have the skill or interest to take this further.  That users would do that  was my hope when I once set this up. That others, interested in user interface design, would take over the job. Needed because I am and will always be a low end developer doing drivers and other nitty gritty low end things. You need other skills for UX design then I have. It is a wast if I try to do this. Well it was a waste me doing the Javascript libraries. But someone had to do it so I did it.

I was disappointed of course.  This could have been great and a lot of fun to. Giving lots of credits to the ones that worked with it. Probably money to.

I have asked for help so many times and do so one last time.  So

Well there is plenty of things to do. No need to list them really as it is apparent that most UX components are missing. I will still try to come up with a list in order of importants what I would have liked to see being realized.

1.) Samples, samples, samples and more samples using the Javascript library , the websocket interface and the REST interface. Just to show what is possible and as a tool for others to build upon.

2.) More HTML5 websocket widgets.

3.) I am not a big fan of OpenHAB, “the big elefant”, but one thing I have always liked in it is the user interface component they came up with early.  The demo site is apparently down at the moment but here are some screen shots

In my world this is typically something defined in an XML file and read by an app. which put up the interface. The XML file can be fetched from a VSCP daemon that is localized through its multicast interface or is pointed out by the user. The XML file can be served by the web server or through the websocket interface stored in a variable.

Inside the XML file there is a hierarchy of pages. Each page consisting of one or several lines.

Each line is a HTML5 element.  Looking at the switch above

a line can be single line (others can be multiline or page) and in this case a widget to the left (the lamp), the text in the middle (which also is a widgets, the statebutton to the right. So in this case the text may be static but the lamp widget show the actual dynamic state for a lamp or something and the switch actually do the toggle of that state.

A line like this have the same general components but the arrow just bring up a new page.

And a line like this has the same components. Here the temperature is shown dynamically but the iconic thermometer to the right could be used to show alarms etc or that could be done in the text.

Not a big thing really to implement on an Android, IPhone or desktop machine but something that takes time and needs a feeling for UI design to be usable.

They have a new version now which is demoed here and which dynamically adopt to the screen size.

4.) I have a quite similar project, Merlin, that is a drag a HTML5  component to a page and thereby adding active UI components to that page. I never get time to finish it as it looks.

Live here (User:admin Password: secret).

A typical example shown here with active buttons places on a floor plan of a house.  Right click on the component to set it up. When done, generate the web page.

5.)The MDF (Module Description File) of VSCP defines a module and tells how it can be configured. The MDF nowadays also contains the possibility to set up wizards to help user to do specific setup tasks step by step in a generic way.

As all VSCP modules have information about this MDF in them they all have the ability to tell the world how they work, what they can do and how they should be setup to do just that. Yes gatekeepers prevent everyone from messing around with a module. But that is another issue which we leave out here.

An iBeacon or an EddyStone/physical web capable machine can send out the MDF URL for the world to see. So can a NFC equipped device do when taped.  So a machine that see this can get information that there is a device with certain capabilities available and it can from there open up a UI that  allow the end user to discover the unit’s capabilities and also configure it to do the things it is designed to do. This could be limited to just get information from the node or even status from it or to really go into it and be allowed to edit it’s configuration.

To understand this it is important to know that VSCP with it’s register abstraction model and the MDF allow for it’s  unique one application can configure all functionality.

So with this UX functionality a user of some equipment can set it up in a uniform way. He/she will be comfortable with the setup procedure from other equipment. But it can be used by a service technician to configure/diagnose something when he/she is out on the field. Of course it would also be possible to do this remotely equally good when needed.

A general setup/configure/presentation interface for VSCP  that is.  Target platforms phones/tablets/desktops.

7-9999).  Well they are there to of course. But we take them another day…

Ake Hedman
Maintainer of VSCP

Developers, we all use tools. So does VSCP & Friends to of course. Everything else would be stupid. Reuse is the thing in an open source world. Yes in the closed source word to. The two most important tools we use are wxWidgets and Cesanta Mongoose.

The choice of using wxWidgets came about because we wanted everything to work cross platform back then. This was actually a hard choice. Two competing systems where available. QT and wxWidgets. The problem at the time was that QT was not free and open on the Windows platform so in the end the choice to use wxWidgets was on that had to be taken.  Well  I like QT more. But to rewrite everything. A million lines of code. Forget it. In the end it does not matter much anyway.

The other tool is the Mongoose library. This is a communication library (and a webserver) that I strongly can recommend. Well it is actually not a library. It uses amalgamation.  So instead of linking in a library you add the project files. Convenient and easy. So the mos of the tcp/ip stuff we use are built on this tool.

Well it is great, works great, but is quite badly documented. Have few examples. Furthermore it was previously divided into mongoose and net_skeleton.  This was how it was when I discovered it. But when I released the code net_skeleton was transformed into fossa and changed in many, many, many. many ways so parts I rewrote for fossa leaving the parts that used mongoose as they had a dependency  on net_skeleton and then the guys over at Cesenta decided to move everything from fossa back in mongoose… Yepp you all understand. It’s was a mess.

So now if I want to port to the new mongoose code it’s  a hard work to do. It has been changed a lot. It’s a major project I can tell you. A MAJOR PROJECT!

Well, even if this is really bad practice from a tool maker, REALLY BAD, this is good tools. So one only can hope that this moving around has come to a stop now and they will say as good usable tools.

So this major rewrite is what I do now. fossa and  net_skeleton is going away and mongoose is coming in. A change that affect almost every file in many, many places, Changed calls, changed parameters, changed functionality really put me to the test.  Yes this will take some time to complete. And I will probably still recommend the tools. They are great. And maybe the changes they did was needed in the end. At least I think things are a bit more easy to understand now than it was before.

So now you know why it’s so quite form our corner… It’s called hard work…