A prototype is a preliminary model of something. Projects that offer physical products need to show backers documentation of a working prototype. This gallery features photos, videos, and other visual documentation that will give backers a sense of what’s been accomplished so far and what’s left to do. Though the development process can vary for each project, these are the stages we typically see:
Proof of Concept
Explorations that test ideas and functionality.
Demonstrates the functionality of the final product, but looks different.
Looks like the final product, but is not functional.
Appearance and function match the final product, but is made with different manufacturing methods.
Appearance, function, and manufacturing methods match the final product.
About this project
iolinker boards are flexible IO interfaces, controlled via UART, SPI or I2C, that offer
and PWM generation.
Up to 127 iolinker boards can be chained, to allow for enormous IO extension where needed. (They each have their own address, encoded with 0K resistors.)
The FPGA board presented here features 49 GPIOs, all usable for IO extension with an easy to use library, on Arduino, Raspberry and on your PC. For a quick introduction on how to use it, check out our Instructable.
This is what gives this product its name. When you link two GPIOs, say P5 to P1, pin P1 turns into an input, and all incoming signals are forwarded to the output pin P5. (Essentially creating a matrix of IO connections.)
If you are an embedded developer, you will be excited with these new opportunities!
Ultra flexible IO interfaces.
Transferring the circuitry of your digital signals to the iolinker chip; keeping circuitswithin your software.
Perfect version control.
Self-testing: iolinker chips can be used to verify the digital levels on all of their pins, and detect plus locate short-circuits. This is a dream come true for product design.
Simplified bus design: You want to hook up several chips, and simplify your life? Let iolinker hook up any of two UART devices on the fly; and switch to the next one afterwards. For example connect 24 Arduino UARTs to the iolinker adapter ontop of your first Arduino -- that can now decidewho talks to whom.
Complex, self-testing plug'n'play bus: Verify signal levels and check for short-circuits, before you hook up new devices with your shared bus.
Less tedious jumper cable wiring.
Enjoy easier to see through prototype designs.
Less hardware changes reduce cost and time effort.
Create bus designs more easily, with simplified software.
Make self-testing end products.
IO linking works for digital signals up to 29.56 MHz.
Want to control the brightness of an LED or control the speed of a DC motor? Our PWM functionality is very basic for now, but maybe suits your needs.
The FPGA boards feature a JTAG interface that you can use for reprogramming. Use a Lattice HW-USBN-2A compatible USB cable (21€ on eBay) and the free Lattice Diamond software to get the job done. A video on this will follow!
Flexibility in your hardware designs will save you time and costs. And it will reduce electronics waste.
This Kickstarter campaign is about our first two iolinker products:
1) A Lattice FPGA board, with 49 GPIOs, that is using a 4300 LUT LCMXO3L-4300E-5UWG81CTR50 chip. The FPGA runs internally at 1.2V, but the GPIO voltage is 3.3V. You can connect your 3.3V devices directly.
The preprogrammed software we will ship with has the following features:
All 49 GPIOs can be used for IO extension and IO linking, and 10 of them for PWM output as well. Note that the interface is UART, SPI or I2C and specific to the software version you chose.
2) We provide you with a level shift adapter that acts as an Arduino shield adapter at the same time! You can use the adapter with or without Arduino to level shift the 49 GPIOs from your FPGA board to 5V. When put ontop of an Arduino, our Arduino library allows easy interfacing of the iolinker GPIOs. Check out our Github repository at https://jvm123.github.io/iolinker/. The adapter connects the UART, SPI or I2C interface of your FPGA board to the Arduino. There are 0K resistors in place to quickly change connections.
You can also connect your PC directly to the adapter board, using a USB 3.3V TTL cable (http://www.ftdichip.com/Products/Cables/USBTTLSerial.htm), and control one or many iolinker boards.
iolinker software: New features ahead
The FPGA software is complex, and uses up the hardware of the FPGA entirely. We can offer different features and there will be more product versions in the future. But you can also reprogram the FPGA with the other software versions. Among our ideas for those are:
A specialized PWM version, with 49 PWM outputs.
More PWM features.
Versions that allow for extra UART or SPI interfaces, and communication with those from the UART / SPI / I2C interface used for configuring the iolinker chip.
Versions that translate Low / High to Tristate / High or Low / High to Low / Tristate output, for parallel bus designs.
A board with microcontroller (cheap ATtiny / ATmega?) on it as well, that stores default pin configuration in its EEPROM, and integrates the self-test part (i.e. verify digital levels and test for short-circuits), to save the user application the extra work.
Your feedback decides what else we make.
By adding 20 EUR extra to your pledge, you get free lifetime access to iolinker software versions compatible with your FPGA board! Rather than buying specialized board versions, you can reflash and make it into another. This is a special offer for Kickstarter backers.
From our opensource library and web interface, you will profit either way.
Prototypes for these boards are very costly to manufacture; but we did design a few more that may be of interest. With your help we can test and offer these as well -- and opensource their hardware designs. Prototypes so far:
A very cheap board with 64 IOs, that could be used for first FPGA tryouts and IO extension (TQFP-100, 256 LUTs, LCMXO256C-3TN100C)
A super cute board with 14 IOs (WLCSP-36, 1300 LUTs, LCMXO3L-1300E-5UWG36CTR50)
A big board with 192 IOs (CABGA-256, 1300 LUTs, LCMXO3L-1300C-5BG256C)
An Arduino shield with 104 IOs (CABGA-256, 1300 LUTs, LCMXO3L-1300C-5BG256C)
We plan to begin production of the initial two boards in early April, and to ship in late May.
Quite a few people have worked on this project by now and are still actively taking part.
Delivery time should be about 2 weeks, and VAT / custom duties may apply, depending on where you live. Customs may cause extra delay in the shipment process. Production & shipping origin is in China.
iolinker prototypes are tested and working in their UART version. SPI and I2C software versions should be done after one or two weeks of development, that can proceed in parallel to the board production.
We have acquired manufacturers and have taken care of fulfillment.
Yet, there are always risks:
* Slight modifications will be made to the boards we want to deliver to you, to make the product even more useful: 3.3V power will be generated on board, to avoid trouble. The changes shouldn't cause any problems. But in the unlikely case that they did, it would cause up to 6 weeks delay.
* The chips used in this product can have high lead times. We accounted for average lead times. (Moderate risk, but we are talking of only 2 weeks delay or similar.)
* We do not have backup for every individual involved in this project. In the worst case, finding replacements could cause a few weeks delay. (Low risk)
* Things can always get lost or delayed when shipping. The shipping prices are for tracked air parcel, that should get to you within two weeks and keep costs low. Customs may cause extra delay. Please inquire if you would like to afford for faster shipping.
We'd like to bring this to you in combination with an excellent software & documentation experience, but if we lack behind, please bear with us, ask us, give us a chance to better prioritize and to help you out personally.