|Demand Peripherals Robotics and Automation Made Easy|
Demand Peripherals makes it easier to build a robots or other automation for two main reasons. First, our system is complete. That is, it includes the hardware, the firmware, and all of the API software to let your application control the peripherals. No more buying cards from SparkFun or Adafruit and having to write all of the software layers up to you application.
The second reason the DPI system makes things easier is that our system is FPGA based. This lets YOU decide which peripherals to include in the system. No more trying to squeeze everything you need into the peripherals in one Arduino or trying to figure out how to network together a handfull of Arduinos.
Our system is divide into three parts. Daughter cards contain the electronic components needed. The daughter card might contain the IMU chip, the H-Bridge FETs, or the headers to coneect to servo motors. Each daughter card connects to the FPGA card over an eight-wire IDC cable. The cable has power lines and four pins from the FPGA.
Open the menu to the left to a list of daughter cards. Each description contains the schematic and meaning of each pin that connects to the FPGA. Note the the daughter card designs are all open source so you can combine all the cards needed for your project onto one PCB card if and when you want.
Peripherals are implemented in the FPGA using Verilog. Peripherals have the timing and logic needed to drive the four pins to each daughter card. For example, the dc2 peripheral does the timing for the H-bridges that control two different DC motors. The FPGA has an internal address and data bus and each peripheral has a set of 8-bit registers which configure the peripheral. The dc2 peripheral, for example, lets you set the mode (brake, coast, forward, or reverse) of the motor as well as the duty cycle of the H-bridge FETs. The address of a peripheral is set at FPGA compile time and has to match the connector where the daughter card connects.
The FPGA cards connects to the host computer over a USB link. It is the job of the dpserver daemon to multiplex the the commands and data to and from the logically separate peripherals over the USB link to the FPGA. Drivers are loadable modules that provide the API between your application and the registers in the FPGA peripherals. Drivers hide the complexity and detail of the peripheral register and give your application a high-level language to control the system.
The following diagram shows the relationship between daughter cards, the FPGA card, dpserver, and your application.
The API to dpserver consists of newline terminated ASCII commands over a TCP connection. If you have multiple FPGA cards you can run different instances of dpserver with each listening on a unique TCP port.
The command to write a configuration value is dpset.
The command to read a value is dpget, and the
command to start a stream of sensor data is dpcat.
We use the term resource to refer to a configuration
parameter or sensor reading. For example, the command to
set the PWM frequency to 20 KHz on the dual DC motor controller
Sensor readings are reported as space separate values terminated by a newline. Values may be given as either decimal or hex depending on the peripheral. You can start a stream of sensor reading over the TCP connection using the dpcat command. To stop the stream of sensor readings just close the TCP connection. In most appliations you'll find that you have one TCP connection for each sensor stream and one more connection for sending configuration commands. One of the nice things about dpserver is that sensor streams work with select() and epoll(). That is, you don't have to poll for data yourself, the data will come to you. This feature makes it easier to build event driven applications.
Having an ASCII over TCP API lets you write your high
level application in any language. You can even use
the shell as your programming language since we've written
TCP wrappers around all of the commands. For example,
you can set the LEDs on the FPGA card by opening a TCP
connection (default is port 8887) and writing the following
down the connection:
A list of daughter cards and some card design notes can be found cards.
A list of the FPGA peripherals and a description of the protocol from the host to the FPGA card can be found here.
A list of the drivers and a full description of the dpserver and its protocol can be found here.