Engineers might think wireless communications always involves
complicated protocols such as Wi-Fi, ZigBee, Bluetooth and others. This kit from Synapse Wireless will dispel that
notion as engineers and designers set up experiments and work through
demonstrations of wireless control and data exchange. The kit includes two
transceiver/MCU boards, called RF Engines, an experiment "protoboard"
and software. I enjoyed working with the kit and recommend it highly, even
though I hit a few rough patches while performing this review.
Synapse created the Synapse Network Appliance Protocol (SNAP)
that lets a network of Synapse RF Engine modules operate as peer-to-peer
devices. Each RF Engine uses an IEEE 802.15-4-compliant transceiver, the same
type of radio used for ZigBee, 6LoPAN and other network protocols. A SNAP-based
network, though, requires no hub or central network coordinator, but you can connect
a PC to a network through an RF Engine and the Synapse Portal software. Because
each engine includes a microcontroller, in addition to wireless communications,
you have as many as 19 I/O lines for digital, analog and serial signals.
The MCU in each RF Engine includes a SNAPpy interpreter that
operates on a subset of Python-language commands. Developers load a SNAPpy
script into the MCU's Flash memory - via a wired or wireless link - to control
local operations. A network of Synapse RF Engines requires no start-up time to
"configure" itself, so setup of communications will occur almost
instantly. The engine modules automatically form a multi-hop mesh network that
offers a sustained throughput rate of 38.4 kbits/sec, according to Synapse.
I quickly located the documents and manuals on the included
CD-ROM and printed those needed to run experiments. A Quick Start Guide
described and illustrated the hardware Synapse provides on the protoboard, on
which I mounted one of the RF Engine modules. Diagrams clearly showed jumper
locations and pin legends, and text explained what I/O pins and jumpers connect
to LEDs, a pushbutton and a serial port. The 19 I/O pins from the RF Engine
connect to screw terminals and to a 24-pin header, which makes the signals
readily available for experiments and development work. Instead of using the
supplied batteries and battery holder to power the protoboard, I used the 9-V
The 51-page "EK2100 Evaluation Kit Users Guide"
includes tutorial information and lab exercises, as well as information about
other reference documents and about the RF Engine modules and how they work. An
out-of-the-box exercise let me set up the hardware and confirm a wireless link
existed between the two RF Engine modules. The Synapse Portal software I
installed on a lab PC could then act as the "control center" for
module configuration and for loading Python scripts into the modules. The
Portal software that comes with the kit operates with as many as six nodes, but
you can purchase a license for the Synapse Portal software when you need to
move beyond six nodes. A final network
does not need a PC, but it can offer advantages I'll explain later.
During installation I went through the usual Windows set-up operations
for a new USB device - the "bridge" RF Engine module connected to the
lab PC that will communicate with the same type of module on the protoboard.
(You can connect a "bridge" transceiver to a PC through a serial port
instead of using a USB port.) The Users Guide includes many helpful screen
images and information about the kit's software and hardware. And the
demonstration exercises or experiments include good step-by-step instructions
and helpful illustrations.
The second demonstration required connecting three LEDs and a
photocell to the screw terminals on the protoboard and loading new scripts into
the two RF Engine modules. Sometime during the loading steps I made an error
and the RF Engine on the USB port stopped communicating. It took a lot of time
and trial-and-error work to solve this problem.
No matter what I tried, I could not re-establish communications.
The Portal software indicated it had discovered a SNAP USB device, but I still
couldn't figure out how to get it to communicate with the protoboard. The Users
Guide lacked troubleshooting information, so I registered for the Synapse
Forums and found a suggestion about clearing out any Python scripts. That
technique didn't do the trick.
Eventually, I unplugged the USB stick and connected the
protoboard to a lab PC through a serial port. (You'll need your own 9-conductor
cable for serial-port communications.) Then I reloaded the firmware (ver.
2.2.16) in each RF Engine, which solved the problem. I cannot say my
trial-and-error approach will always get modules back "on the air." I
hope Synapse includes troubleshooting information in the next version of its
documentation. Information about how to get an unresponsive RF Engine back to
basic communications would help, too.
The remaining exercises went well and I could flash LEDs, detect
light levels and log sensor data. A temperature-sensing experiment didn't work
quite as expected, but when I substituted a small potentiometer for the
thermistor, the program gave a good result.
The final experiment used a Python script on the lab PC to
display sensor data on a scrolling graph. Python on a PC gives developers a
wider range of capabilities than the Python subset that runs on the RF Engine
modules. Thus, you can use the Synapse Portal software and an RF Engine to act
like just another node, but with enhanced capabilities. A Python script could,
for example, fire off an e-mail alert to you if a sensor output goes over or
under set limits. Or, you could get regular updates of sensor information as
text messages. To me, that aspect of the Synapse kit should make it attractive
to engineers and other product creators.
The SNAP Reference manual provides a bit of information about how
to send e-mail, and a Google search will help uncover useful information about
how to use Python on a PC to create and send such messages.
The Synapse website will link you to the Forum site to download
manuals, software and documents. This section
Forum is difficult to find, so here's a direct link: http://forums.synapse-wireless.com/showthread.php?t=9
You must register, but registration doesn't ask for much information.
While trying to run the final experiment, I encountered an
ambiguous instruction that caused me to wonder how to proceed:
Step 1 - Switch back to the Node View pane in Portal and Upload
the script call "PortalManyMeter.py" to the Portal node. This file will be
located in the "My Documents\Portal" folder.
I tried to upload the script but got an error message. The
instruction should say ...
Step 1 - Switch back to the Node View pane in Portal and click on
the Portal node. Then click on "Change Portal Base File" in the Node
Information window for the Portal node. Select the script called
"PortalManyMeter.py," located in the "My Documents\Portal"
folder. Then click on Open. This action uploads the new file to the Portal
Those are the type of seemingly minor problems that can
temporarily derail someone. Also, the Synapse documents use Portal in several
contexts to identify the Synapse Portal software, to identify certain devices,
and so on. I found that "looseness" confusing in a few places.
I had a couple of other "nits" to pick with the Portal
software. First, the software displays Python scripts in a helpful format that
uses colors to identify statements, comments, functions and variables. But, the
software lacks a way to print those listings. I don't want to have to cut and
paste listings into a text editor before I can print them.
Second, the Portal software can download scripts, but it has no
inherent debug capabilities. One Forum member suggested flashing an LED on the
protoboard to indicate a Python script continued to operate properly. That
takes me back to debug techniques on the '70s. I suppose you can use one of the
serial ports to transmit debug information back to a PC's "terminal"
program, such as HyperTerminal. But that means you must include code in the script
to control the serial port - assuming you don't need it in your application.
And you need a PC with a serial port or a USB-to-serial-port adapter.
Again, I liked this kit and the Synapse hardware and software.
I'd jump at the chance to learn more and run some of my own experiments - after
gaining some experience using Python.