What's New
Sign Up

Cookie Notification

We use cookies to personalize your experience. Learn more here.

I Accept
I Don't Accept
  1. Home
  2. Categories
  3. All Things Tech
  4. iolinker FPGA IO Interface Board
x
Ratings for products on Gadget Flow are based on quality, competitive features, aesthetics, price, and more. We also take feedback from our users seriously. Products with negative feedback (shipping delays, quality issues, etc.) will go down in rating. Feel free to report your experience with this brand and we will investigate.

iolinker FPGA IO Interface Board

Editor's Rating
4.8?
Discovered on 2017-02-16

Extend the functionality of your systems with the iolinker FPGA IO Interface Board. Compatible with Arduino, Raspberry Pi, and PC, this is the ultimate interface. You can use the iolinker FPGA boards to rewire and self-test your circuitry totally. The chainable IO extender comes pre-programmed to handle your systems. With the IO-linking feature, you can connect your devices, LCD, keypad, LEDs, and more to the GPIO. This compact yet powerful system saves you time in rewiring so you can focus on creating. In addition, the iolinker helps you to test and verify your systems before they go live. Additionally, the iolinker can detect and notify you of errors. With simple software changes, you can hang on to your hardware and be more efficient than ever before.

LoadingSave119 Users Saved This Product
Overview
Overview & Specs
Includes :
FPGA board, 8GB USB stick
FPGA Board :
49 GPIOs
Compatibility :
Arduino, Raspberry Pi, PC
Discovered on:
Report this

Comments

45
Write your comment ...
Comments
Kickstarter Comments (45)

Leave a Reply

avatar
300
  Subscribe  
Notify of
Julian von Mendel
Review from Kickstarter
Hi Mark, can you take a photo of both and mail it to iolinker@jinvent.de? I am curious what happened there. When you order one board, this is what it should look like: https://twitter.com/maker_mccoy/status/880924870372073472 USB stick on the left, partly assembled iolinker board in the middle, header pack on the right.
An iolinker board without assembled SMT parts shouldn't exist.
Mark
Review from Kickstarter
Received both items a couple days ago and just opened them. I haven't tried them yet, but hopefully this coming weekend. I had a question, it seems that I received a separate JI11x-81L-B PCB without most of the components on it, was this intentional?
RonF
Review from Kickstarter
Julian, with EN tied to GND it worked! For my first test I just unpacked the board (no soldering) and followed update 16. Thanks!
Julian von Mendel
Review from Kickstarter
Ron, please make sure that the EN jumper is set, only then the software goes active. Does that work?
RonF
Review from Kickstarter
I got my board (JI112-81L-B SPI board) today (Germany). Tested the board as described in update 16, both LEDs light up, however, the push button shows no effect. I measured that the button is OK. Any clue?
Julian von Mendel
Review from Kickstarter
Haha, many thanks Keith!
For any help setting things up, please inquire via PM. :)
Keith Burston
Review from Kickstarter
Got mine today. Not tried it yet, but looks good. Nice project. Took a while to work out that the USB stick rotates out, not pulls out :-). Congratulations.
Julian von Mendel
Review from Kickstarter
Regarding the first comment far far below and Robo's idea of using stackable headers on the FPGA board:
I looked into it and then thought female headers pointing upwards and male headers pointing downwards isn't as useful as male headers on each side would be. Can anyone give me an opinion on this? If we are quick, I may still be able to offer these instead or additionally for backers. I am thinking of connectors such as these, that would allow to have roughly equally long male parts on both sides of the board: https://www.digikey.com/products/en…
Maker MCCoy
Review from Kickstarter
Looking forward to creating a project! Great job!
Tzukasa
Review from Kickstarter
Ha! its done :D
Julian von Mendel
Review from Kickstarter
Thank you all for taking part in this! :)
Already set things in motion to get production started in time.
Philippe Coupe
Review from Kickstarter
let cross the fingers and hope you will reach the target in the next few hours
Julian von Mendel
Review from Kickstarter
Thank you Robo for the reminder! :)
Robo Durden
Review from Kickstarter
You should post in the German roboternetz and in the microcontroller forum.
Julian von Mendel
Review from Kickstarter
Time is running out... omg, please help people :) I wanna produce now! Haha.
Tzukasa
Review from Kickstarter
Nice almost done. 900 Euro and we reach our goal :)
Mario Ilecko
Review from Kickstarter
Hi Julian, thank you for your answers. Providing more examples or tutorials for custom code is over the scope of this project indeed, thanks for the LED blink example (haven't seen it before), that's completely enough and a good "quick start" guide, just what I was looking for. Hey the goal is not too far now, almost there, fingers crossed you make it!
Julian von Mendel
Review from Kickstarter
Hi Mario, hi everyone! I hope update #7 proves exciting for all of you. Visuino will provide a more advances graphical programming interface for the iolinker boards soon, we agreed on cooperating today. I sure can't wait to see this grow. Let me know what you think :) https://www.kickstarter.com/projects/jinvent/iolinker-fpga-boards-rewire-and-extend-microcontro/posts/1826159
Julian von Mendel
Review from Kickstarter
Book recommendation: Verilog by Example, Blaine Readler
Quick read!
Julian von Mendel
Review from Kickstarter
Complete lpf files for pin definitions that are specific to this board will follow, they'd help you jump start any development of your own applications as they contain all pin specifications. All the rest is basically specific to VHDL, Verilog and the Lattice software -- documentation for that is out there and extensive; if we tried to recreate it there'd be no end to it, I feel.
Julian von Mendel
Review from Kickstarter
Hi Mario, thanks for your interest; that I share. Diving deeper into extensive VHDL / Verilog examples and all that is involved is unfortunately beyond the scope of this project. Showing how to get your program onto the board is done; an LED flash example you can download (see the end of https://jinvent.de/article/iolinker-flashing). The recommended toolchain is the Lattice Diamond software and Programmer. I hope you understand. Still if interest exists we could talk about creating a kind of community webpage or board where examples can be collected. On the other hand, the internet has quite a few FPGA communities already, so my primary intention wasn't to compete here -- Verilog and VHDL code can usually taken as it is; and Lattice also provides some example projects on their webpage. Maybe a link collection to resources out there would be a wiser decision?
Mario Ilecko
Review from Kickstarter
Hi Julian, working with FPGA may be considered hard for a hobbyist, therefore if your board could serve as an easy introduction into the field, I think it would attract more people. Although I appreciate the idea of a handy signal dispatcher, I personally don't find practical use for it (but I don't do much with Arduinos either)... I'm a lot more interested in the "use your own FPGA code" part. Do you have a demo, or tutorial with examples, of what could be achieved with gate array of this complexity (it does not need to be too complex :) if it shown how much work or effort is needed to implement certain standard circuits or peripherals (counters, dividers, oscillators, i2c slave that drives RGB LEDs with PWM, maybe an USART) on your board, using the toolchain you recommend, and explain that the design consumes such and such percentage of available logic blocks / cells, that would be great.
Julian von Mendel
Review from Kickstarter
Hi, a new example application video is at https://www.youtube.com/watch…
An article detailing the setup can be found at https://jinvent.de/article/iolinker-with-arduinos-and-raspberry
Tzukasa
Review from Kickstarter
yeah take your time and make something cool. we need more backers :)
Julian von Mendel
Review from Kickstarter
Hi Tzukasa, I am preparing something -- give me 2 days. Lots of other things to take care of as well.
Tzukasa
Review from Kickstarter
Julian do some more examples. little projects or what ever. show the people what they might be able to get.
Julian von Mendel
Review from Kickstarter
(For many low-power devices, supplying power directly through the iolinker board will be fine. But you can't overcome... certain electrical restrictions physics impose on us, so there are limits to that. This applies to ANY electronics you construct, and to any microcontroller or FPGA device out there.)
Julian von Mendel
Review from Kickstarter
Hi, thanks againf or your input. A few corrections, for there seem to be some misunderstandings. "No analog features, Vcc and Gnd still need wires": This is a digital device, for digital low-power signals. Overcoming this for ANY reasonable price with the kind of high-speed expectations that this board satisfies, is an impossibility with current technology. Sorry. Note that a microcontroller with a couple of analog pins could never satisfy the parallel high-speed requirements solved by an FPGA and required for the IO linking functionality. "and we all learn from the first blink example that the io pins get defined in the beginning of our code anyway.": This is not a requirement or limitation of this board. The application transfers the configuration *dynamically, live* and in the examples also changed it within microseconds (which is a requirement for reading in a matrix keypad). E.g. a graphical user interface can change it on the fly in any way you please. "My best idea so far: use these extra long headers I mentioned below": I plan to make a survey in the end asking people what headers they'd prefer, or maybe we can even include both. Which headers you solder on in what direction is your decision and depends on your plans (e.g. stick the board onto another, stick it onto a breadboard, use flywires). That is a primary reason why the headers are attached for self-assembly. Cheers,
Robo Durden
Review from Kickstarter
(bin morgen auf schönem Flohmarkt in Kelheim) I wish I could help you :-/
But I no longer see why an Arduino/Esp8266 hobbyist could make use of your nice device.
No analog features, Vcc and Gnd still need wires and we all learn from the first blink example that the io pins get defined in the beginning of our code anyway. My best idea so far: use these extra long headers I mentioned below and offer a test board containing most of the cheap i2c and spi devices which will be plugged on top of the io linker, while the Arduino /esp / rpi nano goes below.
This test board should have a clever way to permanently add new devices like
http://s.aliexpress.com/fayuyMVR Then we could prototype entirely in software
And then you find a cheap Chinese company where we can order small production runs simply by hitting an "upload" button. 80% of the hobbyist IoT projects could be developed that way.
And that way I could make small IoT solutions so quickly that all my neighbours would get nice IoT things every week. You see, that would be something to easily make this campaign succeed.
Julian von Mendel
Review from Kickstarter
Neat board. (No idea how they get it that cheap, the FPGA alone costs more than that board at http://www.mouser.de/) * Altera vs. Lattice
* FPGA capability is hard to compare; better try in the respective applications with your actual software. I developed to original iolinker prototype a few years back on an Altera EP1C3 chip (25% smaller than that one you linked) and think it was roughly comparable.
* Not preprogrammed, but an empty FPGA board: not the advertised iolinker functionality, no library or web interface on the microcontroller / PC side for that aspect
* Size
* No neat Arduino / Level shift shield :p If you want to develop FPGA applications for Altera, go for it. It's a good offer.
Robo Durden
Review from Kickstarter
Creator, what is the big difference to www.ebay.de/itm/272432854692 ?
Tzukasa
Review from Kickstarter
so LED, Servo etc shouldn't be a problem :)
Julian von Mendel
Review from Kickstarter
To stay on the safe side, don't go beyond 8mA per IO, Robo. Stick with digital signals. An LCD background light is nothing to route through an FPGA (or a microcontroller, for that matter) directly ;)
Robo Durden
Review from Kickstarter
How much mA can the io pins provide/accept? Can I plug in spi and i2c devices like displays and route gnd and 3.3v to the according pins of these nice little boards ?
Julian von Mendel
Review from Kickstarter
The Instructable talks of a bidirectional level converter -- that would be the general solution.
The Arduino shield is such a bidirectional converter itself. Arduino Uno + Adapter shield + FPGA board => works.
Arduino Uno + manually wired up bidirectional converter + FPGA board => works too, but you need to wire up yourself and get it right.
(Same thing with Arduino Leonardo.)
Julian von Mendel
Review from Kickstarter
Check out the instructable (http://www.instructables.com/id/How-to-Make-Electronics-More-Reusable-With-Reconfi/) for details on the usage with Arduino.
To answer directly: Yes, this will work perfectly with your Arduino! With the standard Arduino Uno, you will need the adapter shield for voltage conversion down to 3.3V.
I prefer the Arduino Pro Mini 3.3V devices myself (super cheap!), these can be connected directly. :)
Tzukasa
Review from Kickstarter
thx for your answer. have to read and check it tomorrow. :) one more question to go: to point 2) so i can use my Arduino uno to upload the program to the board? my Arduino works already fine with my mac so it would be make less problems. :D i already use a FTDI to sketch something to my Arduino mini.... but it didn't work.... seems like my mac don't like FTDI or the device was broken (ordered already a new one should be arrive in a few weeks.)
Julian von Mendel
Review from Kickstarter
Sorry, forgot the self testing question: In embedded devices that have reached a certain consistency, you may be interested in doing certain test operations, to verify that the device is in the state it is supposed to be, and connections are alright. There are two aspects to that: A simple read-in of all relevant inputs lets you know what pins are low and what pins are high. Compare that to the "known good" state to determine whether there may be a problem. Short-circuit testing can be implemented as follows:
* Output a series of high / low pulses on GPIOs where you know that it does not cause electrical issues, while all other GPIOs are configured as inputs.
* After every state change of the output, verify that none of the inputs changed state.
* If they consistently have the same value as the output GPIO everytime the output changed state, you can assume a short-circuit on the GPIOs. Now wherever you use the iolinker FPGA to route digital signals from one point to another, you can also integrate the self test aspect: If the self test fails, you don't even connect the digital signals, but could rather switch to an error mode that could display what pins are experiencing issues.
Julian von Mendel
Review from Kickstarter
Hi Tzukasa, thanks for your support and comment! 1) It works out of the box in the IO extender function that is described in the text. That is, because it is preprogrammed. If you intend to use the FPGA for another functionality than the one that is described -- because you are or intend to become an FPGA developer -- you can reprogram it with the seperate JTAG cable. I plan to take a demo video or do a write-up on how the FPGA reprogramming would work in the next 2 weeks. 2) You can use the preprogrammed IO extension functionality with any UART device -- 3.3V devices if you only get the FPGA board, also 5V devices if you get the adapter. If you intend to use the board in combination with a PC, you can connect its 1x6 header directly to a 3.3V TTL cable such as http://www.ftdichip.com/Products/Cables/USBTTLSerial.htm (nicer) or https://www.amazon.de/XCSOURCE-Serielles-Adaptermodul-Anschluss-TE203/dp/B00HSX3CXE (cheaper) 3) To use the IO extender, you need to send a series of binary commands. You can write to the serial port with ease from most programming languages. So far, I only prepared examples in C++ and Bash. Check out https://github.com/jvm123/iolinker and our code generator https://jinvent.de/iolinker_designer for that. An introduction on the library usage in combination with an Arduino -- but it works mostly the same for Raspberry Pi or PC -- can also be found in this Instructable: http://www.instructables.com/id/How-to-Make-Electronics-More-Reusable-With-Reconfi/ The binary command set is documented in a datasheet here: https://jinvent.de/resources/iolinker_datasheet.pdf I am working solely on Linux, so it hasn't been used on a Mac; but with the libraries and gcc installed, it should work there as well. (To get it to work on Windows, the serial interface part in the C++ library would likely have to be rewritten...)
Tzukasa
Review from Kickstarter
Hi i dont understand the part with the self testing. never worked with FPGA in the past. could you give me an easy example? how could imagine it? to reprogram the FPGA i will need a 21€ cable? you say it works out of the box? but how without a cable? or did i get something wrong? does it work with macOS? thx
Julian von Mendel
Review from Kickstarter
I love brainstorming. What you are proposing is more of a long-term project however; and I can't make any promises in that direction for now. I think we should draw up a few example scenarios on a whiteboard and think about how far such a tool chain actually has a chance to solve that task well. Still, I perceive it as a somewhat seperate project, for it is not actually specific to this board: Such a toolchain could just as well be used with different hardware or microprocessor boards, of different voltages and capabilities, and so on. There's a lot to consider then. E.g. a 5V Arduino can interface with this chip, a 3.3V Arduino or a 3.3V FPGA board can interface with that chip; a microcontroller with a built-in DAC or a board with a DAC can solve other interfacing tasks that a digital only FPGA board couldn't, and so on. The FPGA board can't replace required components such as capacitors or similar. So doesn't it come down to "Part x requires schematic y, and if the connections on this connector z are made to a microcontroller or FPGA board of compatible voltage, the part can be debugged by software; and the remaining layout & manufacturing process is the same as it has always been"? Then the news in the toolchain would be nothing more than a netlist import and the requirement of an extensive schematics library (with marked interface signals) -- since the EDA part has essentially been solved by the high-tech software out there. Btw., your use cases sound to me a little as if the bus pirate might be your kind of toy: http://dangerousprototypes.com/docs/Bus_Pirate To defend.. sorry, to justify the project as it is: a) Arduino, Raspberry, PC & Co.: This is also a powerful IO extender, that I am certain will be useful to many. b) Research & Development: I know from personal experience that PCB prototyping of complex microcontroller applications faces uncertain IO wiring issues (particularly when using lots of hardened chip functions such as timers, PWM, DMA, AWEX, several UARTs -- the IO planning here can get challenging) that can get very costly, and would have loved to have this board as an interface between microcontrollers and periphery on some of those PCBs. Actually, I believe that it could have saved weeks of development time in some projects I worked in. Admittedly, this is probably more relevant to professional PCB developers than to Arduino users. c) More complex hobby projects: The messy robot picture there in the video was of a hobby project classmates and I had built ten years ago. The PCB was our own; with three microcontrollers, three motor controllers, a dozen sensors, three servos, it did get messy, particularly as software and hardware was in flux. My answer to that was to have rows of jumpers in front of the microcontrollers, that allowed to "rewire" the IOs using jumper cables. More mess, more confusion (everytime you change the jumper cable wiring without taking a note, your software version state becomes inconsistent, and rollbacks are more than painful). This project solves issues a) to c) very elegantly, I feel.
Everything else, we need to discuss :)
Robo Durden
Review from Kickstarter
greetings from Amberg ;-) hier also dasRoland.de an derJulian.net :-) Toolchain was the word, not workflow.
You see Julian, i have seen quite a lot of such fpga-campaigns here as well as other cracy electronic boards campaigns that i am happy to not have backed because i simply don't have time (time equeals happiness) to spend on only playing with a new technology.
I am fine with breadboard testing where i can quickly change some parts and connections. But then soldering the parts onto these little prototype pcbs is what i would like to get rid of.
Just yesterday i dreamed to print cuircuits with conductive filament. Only to then plug in the components, put the bottom of the pcb into sulfuric acid and galvanize the conductive connections as well as contacting the pins of the parts via galvanization. Somehow it can be done. Yet right now, a cnc-mill add-on for a 3d printer to fabricate that pcb might be more realistic. So why would i need your ioLinker ? Yes, Fritzing could be part of the tool chain. And your ioLinker the universal prototype tester. A toolchain where i design the hardware functionality on the computer, the computer tells me where to plug in the electronic parts into the ioLinker and like magic the ioLinker will connect the parts according to the circuit diagram.
But this would not already be awesome. I could do this more quickly with a breadboard.
So the toolchain has to go on !!!!!
The circuit diagram is already in the computer, so let the computer auto-route the pcb and last tool in the chain: a cheap pcb-maker to fabricate the boards.
Yes, that toolchain could end with me finally having to solder the parts into the board. (smd pick and place is indeed a bit out of scope here). And i think the programms for that toolchain should already be out there.
And turning all these open source 3d printers into a simple pcb maker can be done. I think, such a toolchain with your ioLinker allowing to test any circuit while not really stop working at the computer could be a scope to make this campaign a BIG success.
When you say that it is largely about your hardware & FPGA programming ... maybe there is a FPGA community out there to back you. All we arduino and esp8266 tinkeres won't really have time for that. Just brainstorming, only trying to help - give us a toolchain :-)
das Roland und Gute Nacht.
Julian von Mendel
Review from Kickstarter
An interesting idea may be to try to integrate with a software like Fritzing (http://fritzing.org/home/). But again, the project scope here would go way beyond what we can promise in this Kickstarter campaign, that is largely about our hardware & FPGA programming.
Julian von Mendel
Review from Kickstarter
Hi Robo, that's a lot you just mentioned. Thanks for your comments and ideas! 0) Those headers are what we are already using for the stackable Arduino shield. I didn't consider them for the FPGA board itself so far; but it's actually a nice idea! Should we ship with stackable headers by default, and if someone wants normal ones, they have to get them themselves? 1-4) Quite some work here, plus I am missing several of the components. But there will definitely be a more hands on video about the IO linking feature. 5) So actually, I took a very very bad demo video that displays the working IO linking & circuit reconfiguration: https://www.youtube.com/watch…
It is a push button, an LED, and an NE555. The software on the PC, once started, cycled through different circuit configurations (NE555 -> LED, LED high, LED low, Button -> LED). The source for that was very simple, basically that what our web interface (https://jinvent.de/iolinker_designer) generates plus a few delay statements. It runs on a PC, a Raspberry and an Arduino alike. A more proper video will follow. 6 / 7) You got me confused there. You are talking of a workflow for exporting the pin connections from the web interface to a schematics program / as a netlist? About netlist export, we can surely talk. But the amount of handwork involved in creating a proper PCB makes this a little far fetched and way beyond the scope of this project, I am afraid. EDA software tools are complex, and a big market, that we did not intend to enter here. Cheers,
Julian
Robo Durden
Review from Kickstarter
Could you add such headers as well ? www.aliexpress.com/item/Promotion-D166-Free-shipping-10PCS-2-54MM-10MM-Long-Needle-Female-Pin-Header-Strip-Stackable-Header/32784226299.html And could make a demo video, where you
1. just plug in an "i2c oled lcd", a "push button", an "rgb led", "1k resistors", "DHT22" (and even a 3.3V relay ?)
2. enter the parts in some nice software at the same places
3. easily draw some connections in that software
4. write them to the board and see an ESP8266 (D1 mini) bringing the parts to life.
5. Hit a button and the circuit gets autorouted.
6. A 3d printer cnc-mill (ask www.reach3dprinters.com to join you...) makes the pcb
7. Solder in the parts and be happy. Can you provide such a nice workflow ?
My projects are small and i am quite happy with these prototype breadboards, so why should i "plug in" components twice ? But with the parts and autorooting AND with one of my 3d printers turned into a pcb maker.. maybe even with the transition to smd parts when making the final pcbs - that would be awesome :-) Robo Durden, the little physicist :-)