Discovering Wireless Mesh Networks

I love new toys, so you can only imagine my delight when I received one in the mail -- an EK2100 wireless evaluation kit from Synapse Wireless.

I have experimented with a few small microcontroller wireless systems in the past, but this one's a little different. The other systems I've handled come with some level of MCU code stack and are programmed fully within the MCU itself. The EK2100 is programmed on a PC using the Python language. The MCUs on the remote modules (or wireless nodes) can communicate with the outside world and/or other devices like MCUs or FPGAs via RS232, RS485, I2C, SPI, ESP, or regular general-purpose input/outputs (GPIOs), of which it has 19. OK, so the ESP (extra sensory perception) is a bit of an exaggeration -- the "extern void do_what_I’m_thinking()" command hasn't been coded up yet -- maybe in the next revision.

As shown below, the EK2100 kit comes with a wireless node that plugs into a USB port on your computer. (This is the board with the lit green LED in the upper righthand corner of this image.) The kit also includes a remote wireless node (the SN171 ProtoBoard shown in the bottom lefthand corner), a few discrete components for use with the provided tutorial, and a 2 x AA battery pack for the SN171 (shown in the upper lefthand corner). My picture does not show the kit's wall-bug power supply, also for the SN171.

The basic idea is that you write programs on your PC in Synapse's modified version of Python. You then load that code wirelessly into the remote module. You can also access the command functions directly through the IDE (which Synapse calls Portal).

To test this out, I went back to one of my earlier Papilio projects: running things in parallel. In that project, I used the Papilio Spartan 3E FPGA development board coupled with the switch/button wing (from the Gadget Factory). My implementation reads the state of a switch connected to one of the FPGA's input pins and writes the corresponding value to one of the FPGA's output pins. That output runs through a physical external wire to an input on the other side of the FPGA, which then flashes a light-emitting diode (LED) using logic inside the FPGA.

In order to test my new wireless device, I pulled the switch/LED wing off the Papilio and wired one of the Synapse SN171 module's GPIOs (GPIO 0) in its place. Here is the resulting setup.

Now it's time to see everything work with the EK2100 in the mix. As the following video shows, I bring up the Portal IDE. I select the "setPinDir(pin, isOutput)" function to direct Portal to transmit a message to the SN171 receiver to indicate that GPIO 0 will be an output. Then I use the "writePin(pin, isHigh)" function to set GPIO 0 to high. This replaces the wing switch previously plugged into the same FPGA input pin.

Including a power supply in the kit is a nice touch. It's pretty annoying to have to hunt down power for a new device. I have plenty of supplies, but they're often either in a box someplace or being used on another project. Then there's the risk of picking up a supply with the wrong voltage or polarity. Including the supply eliminates all of that. Including the battery pack is another nice touch, because it means one less cable.

Something else I didn't expect on this device is the extensive I/O and peripheral set on the SN171 module. It has the aforementioned GPIOs, including several pulse-width modulated (PWM) outputs and analog-to-digital (A2D) inputs. The bottom line is that it's got a pretty powerful MCU built into it.

Now my plan is to use this with my telepresence robot for some programming and short-range control. The next step is to connect this to my ZedBoard (which I haven't shown you yet). I'm going to use the ZedBoard as the main brain for controlling the sensors and the motors. Now I just have to learn Python.

Related posts:

• Discovering FPGAs: What's This All About?
• Discovering FPGAs: Opening the Package
• Discovering FPGAs: Sorting Out the Pins
• Discovering FPGAs: Flashing the LEDs
• Discovering FPGAs: More About the UCF
• Discovering FPGAs: Adding LEDs & Modifying the Verilog
• Discovering FPGAs: Bringing Up the IDE
• Discovering FPGAs: Creating the .BIT File
• Discovering FPGAs: Loading the .BIT File
• Discovering FPGAs: Playing With LEDs & Switches
• Discovering FPGAs: Adding in the Switches
• Discovering FPGAs: Driving a 7-Segment Display
• Discovering FPGAs: The ChipScope Virtual Logic Analyzer
• Discovering FPGAs: Alternative Latching Strategies
• Discovering FPGAs: Getting to Grips With ChipScope
• Discovering FPGAs: Observing Switch Bounce With ChipScope
• Discovering FPGAs: Modules in Modules
• Discovering FPGAs: Creating a Logic Analyzer
• Discovering FPGAs: Selecting a Syntax
• Discovering FPGAs: Building a Two-Stage Synchronizer
• Discovering FPGAs: Debugging a Motor Driver
• Discovering FPGAs: Becoming a Clock Wizard
• Discovering FPGAs: I See Clocks Everywhere!
• Discovering FPGAs: Powering-Up My Papilio
• Discovering FPGAs: De-Bouncing Around
• Discovering FPGAs: Using the SPI Interface
• Discovering FPGAs: Using the SPI Interface, Part 2
• Discovering FPGAs: Using the SPI Interface, Part 3