About this project
Logitraxx Tracked Robot
This is an open source design under the Creative Commons Attribution-Share-Alike 4.0 International License. Schematic and board drawing information will be provided at product release.
SL Interphase - Electronics Design Services
In the press...
“You see lots of FPGA-based projects on Kickstarter, but few as cool as the Logitraxx…” - Steve's blog Xilinx
"Mega-Cool FPGA Powered Tracked Robot" - Max EETimes
Let’s start with the Robot Specs:
Spartan 6 LX9 FPGA
2MB RAM onboard connected to FPGA (prototype has PSRAM, may switch to DDR2)
16MB Flash onboard connected to FPGA
4MB PROM for FPGA configuration storage
40 GPIO (with access to 2.5v, 3.3v, 5v, and VCHARG power input)
3 axis accelerometer with i2C interface connected to FPGA
18 User definable LEDs, including right angle LEDs for headlights/taillights
2 IR Sensor/Detectors in the front connected to FPGA
1 IR Sensor/Detector underneath the board connected to FPGA
Lithium battery charges from USB (can also charge from VCHARG)
FTDI USB to Serial connected to FPGA (can be rerouted to GPIO)
USB to JTAG for configuring PROM/FPGA
20Mhz oscillator connected to FPGA
32.768kHz oscillator connected to FPGA (Save gates by dividing down this clock for slow functions like blinking LEDs)
Push Button (Momentary) works great as a "reset" or "start" feature.
NOTE: Any device connected to the FPGA can be rerouted to the GPIO, even the onboard RAM/FLASH can be accessed by GPIO with the appropriate FPGA configuration. All GPIO is 3.3v
A little history on the Logitraxx
The idea came to me after watching one of my kids assemble a Tamiya Vehicle Chassis Kit. It seemed like a great learning platform, easy to assemble and easy to use. Then I started seeing variations of robotic kits offered online using various Tamiya components. However, these designs were based on micro controllers with very limited capability. With a background in FPGAs, some of which are robotic systems using FPGAs, I knew that an FPGA based system would far out perform anything with a CPU and also entail a much shorter integration time. Joined by my sons we set out with a goal to build a small tracked robot that would be FPGA powered and demonstrate the power and ease of programming with an FPGA. The design also needed to be feature rich offering the same types of interfaces that a traditional microprocessor based robot might have. We wanted the Logitraxx to be outfitted with lots of standard features rather than something that is bare-bones requiring you to purchase those separately. Things like Lithium battery that charges from USB, a USB to serial port, and configuring from USB. By adding some sensors to the base design would allow you to make your robot do something interesting right out of the box. Also, the tool used to write the code needed to be free. What you see below is something that we think far exceeds those goals in a fun package.
Can I drive the Logitraxx features and I/O from Arduino?
Yes, you can. You can access any I/O and control system on-board with your Arduino or any other microcontroller based system for that matter. Or you can off-load some duties to hardware (FPGA) while keeping other control functions in the hands of your Arduino. Use the FPGA to accelerate features in hardware that the Arduino may struggle with, similar to the way a modern PC relies on its external graphics card to handle hardware acceleration of 3D graphics. Allow the two to work together while you learn more about FPGAs. We'll have plenty of sample code for you to look at.
So why use an FPGA vs a traditional Micro?
The maker world of hobbyist electronics is flush with small low cost microcontrollers with products like the Arduino, Raspberry Pi, and Beaglebone. While easy to use they offer lots of quick access to building your gadgets quickly and affordably. However, one drawback with these systems is the low performance and limited I/O options offered can keep your solutions from really accomplishing exciting things. This is generally due to the low cost, low performance micros used as the main system processor.
If you’ve ever worked in a company that engineers its own embedded or industrial products, you may be familiar with a world of components virtually unknown to the maker/hobbyist world. Many hobbyists are programmers with a good working knowledge of C and those systems often require operating systems, drivers, and application layers, all of which saddle an already overwhelmed micro to duties that have little to do with their project, but are needed as the foundation layer prior to making their gadget to perform even the simplest task.
But that wasn't always so. Before the days of the microprocessor, many electronic gadgets relied on straight forward logic components to process data and control the I/O. As the microprocessor became more mainstream, more and more logic was pulled into software and controlled by the CPU. Today, to perform something as simple as an “AND” operation between two input signls can sometimes require tens of thousands of lines of OS/Application layer to be installed first!
The world of logic driven devices hasn't gone away though. They've been busy in the realm of programmable logic devices like PLDs and FPGAs (Field Programmable Gate Array). Quietly evolving in the background operating in electronic devices rarely seen by the average consumer all while the modern day CPU/Software structure reigned in the consumer electronics market. And so today's FPGA is incredibly sophisticated with internal reconfigurable RAM blocks and DSP slices that you can assemble like silicon legos into some very powerful hardware. An FPGA can accomplish things no CPU can. Its time for the FPGA to step out of the background as mere heavy lift network switches, defense electronics, and industrial applications and into the hands of makers revealing to the world what they can do!
An FPGA is not a CPU, but you can build a CPU in an FPGA! Your next question might be, “Well, ok then can I build an ARM core in the FPGA and run Linux on it? The short answer is, “Yes”, though not trivial if you’re a beginner to FPGAs. The folks over at www.opencores.org could help you with that.
What is an FPGA?
Field Programmable Gate Arrays (FPGAs) are semiconductor devices that are based around a matrix of configurable logic blocks (CLBs) connected via programmable interconnects. FPGAs can be reprogrammed to desired application or functionality requirements after manufacturing. You can reprogram the Xilinx Spartan 6 as often as you like, constantly redesigning its functionality and capability.
The unit in the video above is using the Tamiya 70168 gearbox setup in high gear. One thing you may notice in the video is that the IR based steering still tends to be tricky with the ambient light (which contains IR as well as visible light). The unit tends to avoid well lit areas preferring instead to lurk under the couch vs. running out in the open. We are working on ways to compensate for this. Though IR may never be an ideal obstacle avoidance solution, perhaps with some adjustments though we'll be able to coax the unit out from under the sofa :~)
Did you know?
That most if not all of the robotic functions you code into your Arduino or Raspberry Pi can be programmed into an FPGA with a fraction amount of steps necessary to make it work? No Operating system to debug, no layered object oriented code drivers to figure out, all with little to no overhead! An FPGA does things at the logic level and although it can be configured to operate like a processor it isn’t limited to the familiar world of “single-instruction-execution” like a processor. An FPGA can do things in parallel, even many things simultaneously. An FPGA can process functions fast, very fast, sometimes thousands of times faster than any processor. This is why they are very popular in heavy industrial and military applications.
For the picture above with sonic distance sensor, there are about 10 different processes operating in parallel feeding the FSM real time data for decision making. Imagine your subroutines running without a "return" statement. Yeah, that's weird, but in a way that is what we are talking about here. There is no need for a CPU or any software to handle this.
Instead of one mind (CPU core) having one thought at a time, the FPGA can process many "thoughts" at once. It's not just multiple threads. Because even multiple threads in a multicore CPU will still generally share some resources. I don't have to think faster to do more (aka Clock the CPU faster), in an FPGA, I just have to add more thought processes and clock them together.
FPGA Firmware is NOT Software
FPGA firmware and microprocessor software are very different things. Software is a list of instructions for a CPU to execute in sequential order. Software is basically a task list of work to perform. Firmware for FPGAs is not a list of instructions or “task” list, but instead a description of hardware “circuits” and their behavior wired up within the fabric of the FPGA. The syntax for FPGA circuit description and behavior is very similar to the syntax for a software language, though it shares little in common operationally. A common syntax method for use in the description of circuits and their behavior within FPGAs is called “VHDL” or Very-High-Speed Hardware Descriptive Language, developed by the department of defense with a purpose to describe the behavior of ASICs. An ASIC and an FPGA are very similar in how they can be used with one very important difference. The FPGA can be reprogrammed in the field (aka. At your desk) where the ASIC cannot be reprogrammed once it leaves the factory. If you’re already familiar with writing your own software, then you’ll catch on quickly with VHDL. And by the way, FPGAs don't boot, they configure. Well, unless they have a CPU core described inside in which they configure first, then boot :~)
So how do I make use of this in Robotics?
Keep in mind that the compiled form of VHDL is pure hardware and not commands to be executed like a CPU. So, how does this translate to robotics? Simply outline the “behavior” you’re trying to execute in software in an operational flow diagram. Now translate that to a “hardware” behavioral description coded in VHDL. Avoid obstacles with intelligent navigation, communicate with peripherals, interact with sensors like accelerometers, sonic and infrared, even visual recognition are all things that once you have running in hardware, you’ll love the simplicity and reliability. Most importantly though, you’ll enjoy the speed lift over those same tasks written in software that are all too often heavily dependent on operating systems, multiple cores and CPU clock speed. Operating systems just get in the way. You don’t need it with Logitraxx.
Easy to Learn – Easy to Use
With a basic understanding of Boolean logic, VHDL, or Verilog, you’ll be on your way to programming your first FPGA in minutes. There are a number of different FPGA development tools you can run on a PC to write and compile your FPGA firmware. While some FPGA development tool suites can have costly seat license requirements, Xilinx offers a fully featured free version of their professional development ISE tool called the “Webpack”.
Xilinx ISE Webpack free download
The webpack tool is now part of the main tool suite. When you install it, you install the full tools and then when you license, you license it with a web pack license. The webpack license is all that’s needed to write, compile, and program on the Logitraxx.
Upon successful funding
Board Rev => April-May
Small Qty Board Assembly/Test => May - June
Integrate/Test VHDL on rev 2 design "sample build" => June - July
Early bird production build assembly/test = July - Aug
Early Birds shipment = Sept
Main production build assembly/test = Aug - September
Final Shipments = October
This schedule reflects the risks and so would be considered a max time line. If the project advances quickly then the ship dates will be sooner.
Development of Logitraxx
A tracked robot is a great way to learn how to program with an FPGA. The Tamiya Vehicle Chassis Kit makes a great starting platform since it is not complex electrically, but includes the basic mechanicals to build out your robot. It has the motor and gearbox, but there is not much definition beyond a battery and switch. Our mock-up was literally drawing out where components could be placed on the wood chassis that comes in the kit.
We soon realized we needed more space and since the Tamiya kit comes with extra length tracks, we lengthened the board design to accommodate our component layout needs.
From here we were able to finalize where components would be placed in order to produce the first boards pictured below. Not shown is the battery mounted underneath. Our robot also needed to be expandable and so we equipped it with two 40 pin headers giving you access up to 40 GPIO and most of the internal power rails for your own adaptions that are plugged in.
In addition to the Tank top with turret, we are also working on a second "M3 Half Track" vehicle chassis top which will support additional sensors/LEDs. The front half will have servo controlled front wheels (you supply the servo and any other identified parts). We are working on this now. There is a TBD third body top to come next. We'll upload these to Thingiverse where you can download and print them on your own 3D printer, add the servo, and further customize your Logitraxx.
Risks and challenges
There is one item on the board with a long lead time with the estimated quantities we are assuming we'll reach. The timeline above has this factored in. The early birds will ship in September with the remaining production batch shipped in October. If I get them ready early, then I'll ship them to you early. I will not hold on to it. We have prototypes of the Logitrax assembled and running most of its on-board sensors today. We even have some basic obstacle avoidance firmware working. So we are pretty confident in the design itself, though there is still work to do. We can't say how smart the autonomous drive will be at launch, however we'll provide you with the source firmware we have at the time we ship it.
I have quotes for the board assembly and supply chain for all the components except for the PSRAM on the board. We may have to switch to the more readily available DDR2 SDRAM. I prefer the PSRAM simply because its actually DRAM that operates like SRAM. The DRAM controller is built inside the memory chip. If we switch to the DDR2 memory, then we'll need to add a DDR controller inside the FPGA. Easy enough to accomplish, but does use up some CLBs which I would rather keep available to you for your robotic functions. So, Rev 2 of the board should have all this worked out.
The other risk item is the IR sensors for obstacle avoidance. They have limited range and are somewhat dependent on ambient IR tuning before they work. Sonic sensing would be much better for reaching out long distances particularly if you have the tank top on and want to avoid that gun on the turret from bumping into things. I just didn't like how big the sonic sensors were and figured if you would rather use those then you could plug them into the GPIO and place them where you want them. We'll upload the tank model to Thingiverse when the product ships and perhaps someone can modify the body and integrate a sonic sensor into its housing.Learn about accountability on Kickstarter
Support this project
- (30 days)