Close
0%
0%

TinyFPGA A-Series

Low-cost, open-source FPGA boards in a tiny form factor.

luke-valentyLuke Valenty
Following
Liked Like project

Just one more thing

To make the experience fit your profile, pick a username and tell us what interests you.

Pick an awesome username
hackaday.io/
Your profile's URL: hackaday.io/username. Max 25 alphanumeric characters.
Pick a few interests
Projects that share your interests
People that share your interests

We found and based on your interests.

Choose more interests.

OK, I'm done! Skip
Similar projects worth following
13.7k views
9 comments
129 followers
View Gallery
The TinyFPGA A-Series boards are tiny bare-bones FPGA boards with a low cost per logic element. They are programmed via their built-in JTAG interface and only contain the bare-minimum of components for the FPGA to function. They measure 18mm x 30.5mm and fit well in breadboards.

Features

The A-series boards use either XO2-256 or XO2-1200 FPGAs from Lattice. It's a good idea to reference the MachXO2 Family Data Sheet for details.

See the TinyFPGA A-Series User Guide for all the information you need to get your FPGA project up and running.

FPGA Feature Summary

TinyFPGA A1TinyFPGA A2
FPGA ChipXO2-256XO2-1280
Logic Cells2561200
Distributed RAM2 KBits10 KBit
Block RAM64 KBit
User Flash64 KBit
Phase Lock Loops1
User IO Pins2121

Common Features

  • Small form-factor that is breadboard friendly; plenty of space on either side for connecting jumpers or components.
  • Easily accessible JTAG interface pins located both on the side IO connectors as well as a header on the top of the board. This is an inexpensive way to support in circuit programming and testing.
  • Low-power and low-cost design relies on integrated FPGA functionality: internal configuration flash memory, internal clock generator, and fixed 3.3v power supply requirement. External memory, clocks, and power supplies can be added external to the board.

Building your own TinyFPGA A1 or A2 Boards

The TinyFPGA A-Series boards are possible to build in an adequately equipped home lab. The resistors and capacitors are 0603 surface mount parts, and the FPGA is in a QFN32 package which can be soldered either by hand or with solder paste and a reflow oven. It can be tricky to solder the QFN32 package by hand, but it is possible. However it is much easier to use solder paste and a stencil along with a hot air-gun or reflow oven. The following parts, supplies, and tools will help ensure a successful build:

Buy TinyFPGA A1 or A2 Boards

If you don't want to go through the hassle of ordering parts, tools, and supplies and assembling the boards yourself you can order professionally assembled and tested boards from the TinyFPGA Store or Tindie. These boards are fabricated and assembled in a professional PCB fab that manufactures and assembles many other consumer, industrial and military electronics. They go through an automated testing and programming process to ensure the board is healthy and ready to program over JTAG.

License

The TinyFPGA A-Series project is an open source project licensed under GPLv3. Please see the included LICENSE file for details. If you do wish to distribute boards derived from this open source hardware project then you must also release the source files for the boards under GPLv3. You are free to do this, but please improve upon the original design and provide a tangible benefit for users of the board.

  • 1 × LCMXO2-256HC-4SG32C or LCMXO2-1200HC-4SG32C Lattice MachXO2 FPGA in QFN32 Package
  • 1 × RC0603FR-074K7L 4.7k resistor, 0603 package
  • 1 × GRM188R60G106ME47J 10uF multilayer ceramic capacitor, 0603 package
  • 1 × GRM188R61A105KA61J 1uF multilayer ceramic capacitor, 0603 package
  • 5 × GRM188R71H104KA93D 100nF multilayer ceramic capacitor, 0603 package

View all 7 components

  • TinyFPGA AX Boards in Production

    Luke Valenty • 01/03/2018 at 06:35 • 0 comments

    The TinyFPGA AX boards are currently in production.  The PCBs are all fabricated and are now headed for assembly.  If all goes well I should be getting them back by the end of January.

  • New AX Revision with LEDs!

    Luke Valenty • 12/25/2017 at 07:13 • 0 comments

    My A1 and A2 stock is running low and I have ordered a new manufacturing run.  The major complaint of the A-series boards is that they are missing LEDs.  I've added a power LED as well as a user-controllable LED to the boards.  This will help with initial setup of the boards when just getting started and will allow for some basic trouble-shooting as well.

    In addition to the LEDs the layout has been cleaned up somewhat with the power rail on the bottom layer being pushed to the edges to allow for a better ground plane.  The silkscreen has also been updated to simply show "Ax TinyFPGA" as the board name.  It will still be available with MachXO2-256 parts as well as MachXO2-1200 parts.

    Everything else about the board is the same.  These boards are fabricated and are awaiting FPGAs for assembly.  Stay tuned in January and February for their arrival and sale!

  • Schematic PDF Available

    Luke Valenty • 10/07/2017 at 03:06 • 0 comments

    I've finally gone over the schematics of all my projects and organized them a little bit so they are nice and easy to follow.  For people that don't have KiCad installed, making the schematics available in PDF form is much more convenient and easy to share for quick reference.

    You can view the PDF directly on GitHub: https://github.com/tinyfpga/TinyFPGA-A-Series/blob/master/board/TinyFPGA-A.pdf, or you can take a look at the image included below.

    I've also started a new Hackaday.io project, #The Hobbyist's Guide to FPGAs.  I'll be posting articles, tutorials, and hands on labs using the TinyFPGA boards as project logs.  If this sounds interesting to you then follow the project to be updated when new content is posted.

  • TinyFPGA Programmer For Sale!

    Luke Valenty • 09/27/2017 at 03:09 • 0 comments

    The TinyFPGA Programmer boards are now for sale!

    You can purchase them for $9 at the TinyFPGA Store.   Unfortunately I'm unable to login to Tindie to update my Tindie store, but once that has been resolved they will be listed there as well.

    For instructions on programming #TinyFPGA A-Series boards with the new programmer have a look at the updated TinyFPGA A-Series Guide.

    Enjoy!

  • EEVBlog Mailbag

    Luke Valenty • 09/06/2017 at 14:43 • 2 comments

    I sent in some boards a few weeks ago to the EEVBlog Mailbag.  That "Crazy Aussie Bloke" had some fun poking at my soldering hall of shame and looking at some A-series boards.  Check it out: 

  • TinyFPGA B-Series Project Page

    Luke Valenty • 08/16/2017 at 05:52 • 0 comments

    I'm due to get the production run of TinyFPGA B2 boards delivered in the next few days.  There's a bit of work left to do for the B-series boards in terms of fixing some bugs in the USB device and building a pogo tester/programmer.  I've started a dedicated project page for the B-series to log progress: https://hackaday.io/project/26848-tinyfpga-b-series

    A picture of a panel I received from the assembly house:

    And an x-ray image of the BGA package (with 0.4mm pitch!):

  • TinyFPGA Programmer Project Page

    Luke Valenty • 08/16/2017 at 01:01 • 0 comments

    Assembled the first TinyFPGA Programmer boards and started a dedicated project page.  Take a look: https://hackaday.io/project/26836-tinyfpga-programmer

  • TinyFPGA A-Series Programmer PCB

    Luke Valenty • 08/05/2017 at 05:17 • 0 comments

    I will be out of town next week so I decided I might as well design and order some TinyFPGA Programmer boards now so they might be ready by the time I get back.  It's a very simple design.  It follows the breadboard circuit closely while substituting through hole components with their surface mount counterparts.  

    The schematic and PCB layout are currently available on GitHub if you want to take a closer look: https://github.com/tinyfpga/TinyFPGA-A-Programmer

    If you look closely at J2 and J3 you'll see that the holes are offset a bit.  I did this because I thought it would nice if some quick and dirty programming could be done without having to solder on headers.  My thought for this board was to be a cheap and convenient alternative to the FTDI based programmers, 5-pin female sockets are relatively expensive around $0.70.  That makes it the second most expensive part right behind the PIC16F1455.  We'll see how well this works in practice when the boards come back.

    I ordered the PCBs from OSH Park, stencils from OSH Stencils, and parts from Mouser.  Should have some fun assembling them when I'm back in town.  At that point I'll need to create a separate project page for the programmer.

  • Low-cost (or Free) A-Series Programmer

    Luke Valenty • 08/03/2017 at 05:39 • 0 comments

    I'm working on a low-cost (or free) JTAG programmer for the A-series boards.  There are some relatively low-cost JTAG programmers available on eBay, but it doesn't sit right with me to recommend people get those as the best available solution.  They can be an unknown quality and it's a hassle to connect the jumper cables to the JTAG header.  And the job could be done for a better price.

    Here comes the A-series programmer.  Based on a low-cost PIC16F1455 microcontroller it should handily beat the cost of a FTDI-based JTAG programmer.  The downside is we lose compatibility with the official Lattice Programmer software, but this is not a big loss.  The upside is a small, easy to use, low-cost, OSH JTAG programmer.  I think that is worthwhile.

    In addition to the PIC16F1455 firmware I will also be developing firmware that will work on Arduino compatible boards.  If you have an Arduino compatible board then you'll be able to save a few bucks and use that to program your TinyFPGA boards.


    Above is the protoype I'm using to validate my circuit design.  The PIC16F1455 is able to calibrate its internal oscillator based on timing information from the USB host, this means no crystal is required which means a lower BOM cost.  This microcontroller requires very little extra components to function.  Awesome.

    I've posted the initial PIC firmware to a new github project: https://github.com/tinyfpga/TinyFPGA-A-Programmer

    I've elected to make the firmware "dumb" and the software running on the host computer "smart".  So the firmware will be more like a GPIO controller.  This way it is easy to reuse the same board for other purposes or fix bugs in the JTAG protocol by modifying some python code.

    Next step is developing a nice Python library for controlling the GPIO pins, then a JTAG library on top of that, and finally a MachXO2 JTAG programmer on top of that.  When I prove that JTAG programming works well with this circuit I'll design a PCB, send it to OSH Park, and assemble a few prototypes for further testing.

    Stay tuned!

View all 9 project logs

  • 1
    Evaluate your PCB surface mount soldering/reflow equipment

    The FPGA for these boards is in a QFN32 package which is possible, but very difficult to solder with an iron. It is much easier to use the solder paste reflow method to assemble these boards.

    The following tools and supplies will be necessary to reflow a TinyFPGA A-Series board:

  • 2
    Order components, PCBs, solder-paste, and stencil

    Order parts and supplies needed specifically for the TinyFPGA A-Series board:

  • 3
    Wait for all your tools, parts, and supplies to arrive

    Once you have all the tools, parts, and supplies you can assemble board(s). First step of assembly is applying the solder paste. Solder paste tends to only last a couple hours before you reflow it, so you should plan on being able to assemble and reflow the board(s) in one sitting.

View all 11 instructions

Enjoy this project?

Share

Discussions

fabian wrote 04/20/2018 at 16:12 • point

ispossible to learn neural network on this? 256 is good idea to making big network.

  Are you sure? yes | no

Bartosz wrote 09/26/2017 at 12:51 • point

please create a board with 4 fpga

  Are you sure? yes | no

Luke Valenty wrote 09/27/2017 at 02:45 • point

Hey Bartosz, I've actually thought about doing this, but with the larger iCE40 FPGA found in the #TinyFPGA B-Series boards.  It would be neat, but I'm not sure there's a great use-case for it yet.  Do you have any ideas in mind?

  Are you sure? yes | no

EngineerAllen wrote 09/05/2017 at 04:09 • point

its like an mcu in disguise 

  Are you sure? yes | no

Xark wrote 08/09/2017 at 00:56 • point

Hello,

I have been enjoying playing around with your TinyFPGA-A2 board (got one from Tindie, thanks for fast delivery).  I thought I would share another JTAG option that can be used with these boards (and other Lattice FPGAs).  The "standard" JTAG board that Lattice supports (in Diamond Programmer) is pretty much just a standard FTDI 2232H chip (e.g., as you can see in the schematics for their MachXO2 evaluation breakout board).  Using the standard programmer in Diamond is quite convenient (and I believe can also allow use of their "Reveal" on-chip logic-analyzer tool).

Because of this, you can just use a generic "FTDI 2232H breakout board" hooked to the TinyFPGA-A and have it work like a "real" Lattice JTAG interface device (similar cost as the "clone" JTAG devices and more flexible for other uses).  I have been using a Dangerous Prototypes FTDI 2232H board available from Seeed Studios (~$27 from https://www.seeedstudio.com/FT2232H-USB-2.0-Hi-Speed-breakout-board-p-737.html).  There are lots of other similar FTDI 2232H boards on ebay as well (many even more inexpensive).  While likely these won't be as inexpensive as your PIC based programmer board, having "standard" Lattice JTAG software compatibility is nice.  As an additional benefit, you can use the second serial channel (channel B) for a USB serial connection to PC (if your project needs that) without disconnecting and reconnecting between tests (or using two USB ports on your PC).

To use a FTDI 2232H board for Lattice JTAG, connect these FTDI connections to the JTAG pins on the TinyFPGA:  ADBUS0/TXD-A to TCK, ADBUS1/RXD-A to TDI, ADBUS2/RTS#-A to TDO and ADBUS3/CTS#-A to TMS (and of course, GND to GND).  After these are connected (and with proper power to TinyFPGA and FTDI board) the "JTAG scan" in Diamond Programmer should automatically detect JTAG device and the FPGA chip (but you may need to tell it XO2-1200 vs XO2-640 manually).  I have had no trouble using this to program the TinyFPGA-A2 (with "Fast Static RAM" for .BIT files during development, and "Flash Programming" with .JED files for non-volatile flash).

Here is a picture of the setup I am using with FTDI-2232H board hooked to TinyFPGA JTAG (working on a little FPGA project to generate composite video for a simple CPU core): https://justpaste.it/19unv

Enjoy,
Xark

  Are you sure? yes | no

Luke Valenty wrote 08/09/2017 at 02:06 • point

Hey Xark, I'm glad the A2 board is working out for you! Do you have your project posted online anywhere?  I'd like to check it out when it's ready.  I'm really curious to know what CPU core you are using and how you have your video generator setup.

I thought about using the FTDI chip since it will work with the Diamond Programmer software like you mentioned, but it's just so expensive.  With the PIC microcontroller I can sell a JTAG programmer for less than $10 to get people started.  I think that will be great for budget projects.  Then if someone needs the features of the FTDI-based programmer they could upgrade to that.  Not sure if I'll be making my own FTDI board, we will see.

  Are you sure? yes | no

Xark wrote 08/09/2017 at 04:06 • point

Hi, thanks for your reply.  It is early days for my VHDL project, but it is a safe bet it will be on Github when ready.  I am thinking a very simple CPU core (I am considering one like the SAP core in Ben Eater's computer, since people may understand that architecture due to his excellent videos).  Then use some simple B&W video to "show the workings" instead of all the LEDs and 7-segments.  I'll keep you posted.

I totally understand that the FTDI chip (and breakout boards) are not all that inexpensive (and not "loved" by all).  I just wanted to mention the 2232H option since people may have a breakout board already, like I did (for OpenOCD or other JTAG use).  They also seem a reasonable choice vs the dedicated Lattice JTAG programmers (similar price for more flexibility).

Your PIC board sounds perfect for an inexpensive solution that just "gets the job done".    

  Are you sure? yes | no

chmod775 wrote 08/01/2017 at 18:36 • point

I was searching for a small form factor FPGA for YEARS! Thanks you very much for sharing this project Luke. Really looking forward to finish some future project with this!

  Are you sure? yes | no

Luke Valenty wrote 08/02/2017 at 00:57 • point

Let me know what you make with it.  I'm really excited to see all the different ways people will use these boards. :)

  Are you sure? yes | no

Similar Projects

Smalls mint tin sized BeagleBone (KiCAD version)
Project Owner Contributor

Pocketbone KiCAD

michael-wellingMichael Welling

A near-Arduino Nano form factor and Arduino compatible board based around a "better" and cheaper AVR MCU (currently an ATtiny1616)
Project Owner Contributor

The Launchpad - A $2 Arduino Nano alternative

clyde-d-corpuzClyde D. Corpuz

Recreation of some classic solderable prototype boards from RadioShack
Project Owner Contributor

Classic RadioShack ProtoBoards

daves-dev-labDave's Dev Lab

Replacement boards for a cheap commercial cable tester
Project Owner Contributor

Attiny24 Network Cable Tester

jnp-3rJNP-3R

Does this project spark your interest?

Become a member to follow this project and never miss any updates

Going up?

About Us Contact Hackaday.io Give Feedback Terms of Use Privacy Policy Hackaday API

© 2024 Hackaday

Yes, delete it Cancel

Report project as inappropriate

You are about to report the project "TinyFPGA A-Series", please tell us the reason.

Send message

Your application has been submitted.

Remove Member

Are you sure you want to remove yourself as a member for this project?

Project owner will be notified upon removal.