Will Z-Way run on my specific platform?

Z-Way itself will compile and run on any POSIX-compliant platform including Linux, Mac OS X and other Unix-like systems. It also runs on Windows.

But Z-Way relies on several libraries:

  • libv8 (3.24.37) *
  • libcurl (4) *
  • libarchive (13)
  • libxml2 (2)
  • libcrypto (1.0)
  • libz (1)
  • libssl (1.0) *
  • libwebsockets * (optional, WebSocket support)
  • libcares * (optional, async DNS resolver support)
  • libdns_sd (1), libavahi_client (3) * (optional, HomeKit support)
  • and their dependencies

* – needed only for full Z-Way solution including HTTP API and JavaScript engine.

Most of them are provided by OS, some requires latest versions to be compiled (like libxml2 and libcrypto). This is ususally not a big deal to do.

But there is one library — libv8 — that requires good knowledge of your CPU to be compiled. Google v8 (https://code.google.com/p/v8/) is a very performant open source JavaScript engine. Z-Way uses it for highlevel JavaScript API and home automation scripting.

Therefore to make sure Z-Way will run on your platform one need to make sure v8 can be compiled and executed on the specific OS/CPU. Since v8 compiles JavaScript code into native code, it is very sensitive to CPU specific options. Even if v8 compiles with wrong compilation parameters, it might not run on your platform crashing with SigIll (illegal instruction signal). This is the most evident symptome of bad compilation parameters.

So, before considering Z-Way as your Z-Wave controller software make sure v8 runs on your platform.

Do I really need this v8 to use Z-Way?

Not really if you only need C API of Z-Way library. Some of our clients are happy to use C-level interface.

But for JavaScript level API and JavaScript home automation scripts you need v8 engine.

How to check is v8 runs on my platform?

Take a copy of v8 source code (we use a specific commit) and compile it. Once done, go to v8/out/XXX.release/ and run d8 binary. If it runs, your platform is 99{1d1191fed6e3290748e508d280eb0c3f79873bce23e30ab31de419dee3b285af} supported by Z-Way. If not, read further. May be some advices would help you.

The snipplet below shows commands you need to execute for most common cases.

git clone https://github.com/v8/v8
(cd v8 && git checkout 3606220e348799e7b5332d191a456bfd4ab67df1)
make -C v8 dependencies
LINK="g++" LD="g++" make -C v8 i18nsupport=off library=shared x64.release

Change x64 to ia32 or arm or mipsel depending on your CPU. MIPS big endian is not supported by v8, but we have our own port to this platform tested on some CPUs. Please contact us if you need MIPS big endian.

If you are using cross-compilation, prior to compilation you need to define CC, CXX, AR and RANLIB environment variables and CFLAGS and LDFLAGS. Here are some examples:


export CFLAGS = -EL
export LDFLAGS = -EL -Wl,-rpath,$(LIB_DIR)

Here LIB_DIR is the path to libraries for the target arch. You need to compile mipsel.release target

Raspberry Pi:

export CFLAGS = -march=armv6 -mfpu=vfp -mfloat-abi=hard
export CXXFLAGS = -march=armv6 -mfpu=vfp -mfloat-abi=hard

In this example we define specific ARM EABI and set VFP variant. You need to compile arm.release armv7=false hardfp=on snapshot=off armfpu=vfp armfloatabi=hard (these params instructs v8 to build the code with hardfp EABI).

For some ARMv6 processors you will need to apply our patch:

patch -p0 <<END
--- v8/src/cpu.cc       2014-02-11 13:02:05.810134031 +0400
+++ v8/src/cpu.cc       2014-02-11 13:04:09.118128534 +0400
@@ -379,7 +379,12 @@ CPU::CPU() : stepping_(0),
     // an ARMv6-one. For example, the Raspberry Pi is one popular
     // ARMv6 device that reports architecture 7.
     if (architecture_ == 7) {
-      char* processor = cpu_info.ExtractField("Processor");
+      char* processor;
+      processor = cpu_info.ExtractField("Processor");
+      if (HasListItem(processor, "(v6l)")) {
+        architecture_ = 6;
+      }
+      processor = cpu_info.ExtractField("model name");
       if (HasListItem(processor, "(v6l)")) {
         architecture_ = 6;