Embedded - 66: As Simple as Possible

Episode Date: September 3, 2014

Jack Gassett (@gadgetfactory) is the creator of the open source FPGA Papiliodevelopment board. He joins Chris and Elecia to answer the age-old question of how to get started with FPGAs. Jack's company is Gadget Factory. Chris got the Papilio Pro and Arcade MegaWing. Recommended reading: Mike Field's book Introducing the Spartan 3E FPGA and VHDL (FREE! With code!) Mealy and Tappero's Free Range VHDL (FREE!) Sundar Rajan's Essential VHDL : RTL Synthesis Done Right Roger Tokheim Digital Electronics: Principles and Applications Thomas Floyds Digital Logic Fundamentals (also see the latest edition) Chris and Elecia will be recording live at Hacker Dojo in Mountain View, CA on Monday, September 8, 2014 at 7 P.M. RSVP!

Welcome to Embedded, the show for people who love gadgets. I'm Elysia White, here with co-host Christopher White, and our guest is Jack Gassett, designer of the Papilio boards and founder of the Gadget Factory. We're going to be talking about field programmable gate arrays. And before we get started, I'd like to remind you that Chris and I will be recording a live show at Mountain View's Hacker Dojo on Monday, September 8th. So please come out and give us a heckle. Now back to our guest. What time? Oh, uh, seven? Sure. I'll edit it if it isn't. Hi, Jack. Thank you for being on the show.

Hi, Alicia. Thank you for having me. It's a pleasure to be on the show with you guys. Hi, Jack. Could you tell us a little about your background and what you're up to? Sure. Yeah, so I'm a longtime computer and electronics hacker. I started out when I was 13 and then just pretty much have been hacking on both for my entire life.

And then maybe about eight, nine years ago, I was working a cushy corporate job when I found myself constantly daydreaming about inventing stuff and being an inventor. And so I spent a couple of years saving up money to pay off all my debt and save some money to live off for a couple of years. And then I started the gadget factory. And one of the first things that I did was the open bench logic sniffer with Ian Lesnett from Dangerous Prototypes. And that kind of got me started in open source hardware. And then I went into making the Papilio fpga boards which was originally intended to be my invention platform and uh that's kind of it in a nutshell and now the papilio when i look on the website it says it provides an easy introduction to fpga digital electronics and

system on a chip design what so easy introduction versus platform for future development seems different. Yeah, so exactly. It started out originally as my, that was how it was conceived originally, was my invention platform to be an inventor. And then it kind of evolved into i wanted to make it into something that was usable by you know a much wider audience than just myself and i started looking at the arduino platform and really studying what they did with the arduino platform and uh doing you know and i've gone on this long journey to figure out and i'm still on the journey to figure out, and I'm still on the journey, to figure out how we can make an FPGA that is as easy to use and as accessible as the Arduino and as useful as the Arduino.

And it's still, you know, it's in progress. So the journey is still happening. It's not complete, but, you know, we're getting further and further along every day. Well, that's a very tall order. I mean, the Arduino is very geared to be as simple as possible and sometimes even simpler. Yes, and that's exactly true. FPGAs are a black box. I mean, I work in embedded embedded systems I use microcontrollers

all the time Arduino is trivial but FPGAs are scary right exactly it's such a blank canvas compared to just normal software where you've got and it's been a real challenge to try and pull that off so that's been the goal have I done a great job so far

you know I'm not real satisfied with the job I've done so far job so far you know i'm not real satisfied with the job i've done so far but i think i'm right on the verge of of attaining those goals or at least making a good shot at it and you know so kind of when you look at the arduino what they did really well is they took something that was very scary to a lot of people which is c c or c plus plus programming you know before the ar the Arduino, you went out and you asked the average electronic hobbyist or the electronic people or the average person that is using Arduinos now,

if you would have said, do you see yourself programming in C++? They would have said, never, no. And the Arduino took something that was very scary and they did an excellent job of making it accessible to just everyday people. And so that's kind of my inspiration, which is, well, if they were able to do that with C++, can we do the same thing with FPGA technology? Because it's equally as scary as Cs are what a lot of my hardware engineers use, but now they're using FPGAs to do fast timing synchronization sorts of problems. but mostly it's doing all the logic stuff, adding I2C buses or additional SPI buses to a chip that doesn't have enough.

Yeah, and it's good at that sort of thing, but really, you know, what I try and explain the FPGA is, so just think of, and I have a new board called the Papilio Duo where we're coupling the Arduino, the chip, the AVR chip or the Atmel chip that's used in the Arduino Leonardo. We're coupling it with an FPGA. And so the way I describe it is to think of the FPGA as a circuit board or a circuit laboratory that's connected to the Arduino chip. So yes, it is very good at those sorts of things that you brought up like timing and high-speed tasks. But really, it's good at that stuff

because it's a blank circuit board. And if you have the right VHDL or the right cores, it can do any of those things in parallel very quickly. So it's like being able to design a circuit and have it realized instantly where you don't have to go out and have the PCB manufactured and then solder it all together and all that good stuff. I always thought it was like designing a chip, which I guess is sort of a circuit board.

Yes. So it's using digital logic to design a circuit. And chips, that's ultimately what chips are, is they are a circuit designed using either VHDL, some kind of hardware description language, or in the older days they used to use schematic entry. It's just without kind of the hardware portions. So like, you know, differential signaling and that sort of thing. You have to do that off the chip.

So when I got, I got my husband some of the yearboards for his birthday in the spring, early summer. And he, and I thought it was all FPGAs and was expecting, I don't know, signal processing or logic things or robot things to happen. And the next thing I hear, he's downloaded it to be an Arduino. So you're doing cores as well as logic, and you're using cores from the web. Right. So basically, you know, we're coupling a core.

Well, you consider any component. So if you take it back to the circuit board analogy, cores would be like a chip that you would put on the circuit board. So one of the things that we have the ability to do is take a core that is an implementation using VHDL. Well, we've used VHDL. I shouldn't say we. An open source developer made of a core that implements an AVR compatible soft processor.

And we can take that and put that in the FPGA. And it's really great for control logic. So when you're designing a solution on an FPGA, one of the things that's very hard to do in VHDL is control logic. So how you tie everything together, how you control it. It's difficult to do in VHDL.

I like to liken it to, you can design a circuit using all 7400 series chips but you wouldn't want to you know try and set your control logic up using 7400 series chips you would always put a you would put a microcontroller or a processor because that makes the tasks trivial so it's the same thing with an fpga um you want to want to save yourself a whole lot of headache by using a soft processor to tie everything together and to do the sequential type logic. was, not the board itself, but the concept of FPGAs being so wide open. Normally you get a microcontroller and it has almost you know how many elements you have on it the timing you can actually achieve across the across the chip from one end to the other so it's it you can look at this thing go i can do anything with this right and it can be really

really fast i mean i can implement some signal processing thing or some video processing thing and it can be many many tens of or hundreds of times faster than on a cpu and so i just sat there looking at it going well i have no idea what to do with this but exactly uh going back to what you're saying about vhdl one of the things i ran across in the reading was okay this is this looks like software vhdl and verilog look like software so it's almost deceptive to a software developer to look at this and go, oh, this is sort of C-like. I get it.

Very C-like. But nothing operates in the same manner that you're used to. Like you're saying, everything's happening all at once or is clocked all at once. So doing the standard kind of this happens and then this happens if then that

that's not easy and that that's where you have to twist your brain around and that's one of the things that that's the control logic so from an education standpoint how do you how do you encourage people or how do you uh bridge that gap between say somebody who's used to programming and c and here's an fpga i can do anything with it but you have to think a lot bridge that gap between, say, somebody who's used to programming in C and here's an FPGA. I can do anything with it, but you have to think a lot differently. Yeah, so I think the first thing

to wrap your mind around, and when I was first learning how to use FPGAs, I had my first breakthrough because I did the exact same thing. I'm like, oh, I know how to code. And so I took the approach of, hey, I'm like oh i know how to code and you know and so i i took the approach of hey i'm gonna code something with vhdl you know and i tried to put all of that same thinking and that way of doing things into vhdl or verilog verilog is even worse because

it's c-like um and that's a that's a mistake uh because really you need to start off from the get-go understanding that an FPGA, you're really designing circuits that go on the FPGA. And, you know, maybe that's a bit of a simplification, but I think that it works. That if you go into it thinking of it as, okay, I've got an Atmel chip with a circuit laboratory connected to it so when i'm going to write something in vhdl i'm not writing code i'm writing hardware description i'm describing hardware and so vhdl is not writing code it's actually describing circuits that will run on your FPGA. So it's sort of textual schematics? Yes, exactly. Yes. And so I had my big breakthrough with FPGAs when I stopped thinking of it as a program, VHDL as a programming language, but as a high level way to design circuits or design schematics. And so basically what helped me, also what helped me was I bought every Digital Logic book

that I could find on eBay. I just spent a hundred bucks or something and bought as many used books as I could find. And then I studied all the basic building blocks for digital design. You know, I understand things like shift registers, comparators, you know, all the basic building blocks, multiplexers, decoders, all that stuff. And then when you're thinking how to solve a problem with an FPGA, break it down to how would you design a circuit to do that and what are these what are

the equivalent digital building blocks that i can use uh and then how do i describe that digital building block with vhdl and you can quite often find the examples on the web or even in the xilinx isc they have what's called the design template or the language templates where they break it down. How do you describe an 8-bit shift register with VHDL and then you just copy and paste it? Well, with the Papilia board, there was this idea that you could do it from VHDL or you could just copy things from the web. I mean, we mentioned the Arduino, but there were lots of other cores and then you just put them all together and then you stick on the arcade wing that we got too and now you have a little arcade machine and you've done no coding and not necessarily a lot of learning

except how to download these things. Right. And that kind of goes to kind of the timeframe of... So I've been working for four or five years now trying to crack this nut of how to do the same thing for FPGAs that the Arduino did for C++ and microcontrollers. And so, like I said, I haven't been really successful.

I'm not happy with the results because I think in the beginning, initially, what I was trying to do is I was trying to provide a lot of examples because what worked for me was to learn from examples so I thought you know what if I uh provide a lot of examples so you know and make a lot of different examples work with the papilio people can look at these projects so a good example is those arcade projects right which are fantastic I'm not dissing them at all. No, totally. I totally understand. And, you know, they came from Mike Johnson at FPGA Arcade. He made all these examples, and they were such wonderful... Wrap your mind around what's possible with an FPGA,

that in the very beginning, that was kind of where my focus and where my emphasis was. And so, you know know i designed the arcade hardware mega wing and then i got all of those excellent arcade games working because if you dive into the vhdl code for those video games it's really cool because what what they're doing what mike johnson did is he would study the and and i think it was it was also a group of people it was a community that did a lot of the different pieces but mike johnson brought it all together um mike jay and if you look at the source code it's really cool because you see that he studied to like implement pac-man he studied the original schematics for the pac-man motherboard And then every chip that's on that Pac-Man motherboard,

he recreated it in VHDL. Amazing. And then he tied it all together. So it's basically shrinking that entire Pac-Man motherboard onto one chip and doing it all with VHDL. And so, you know, like I said in the beginning, I thought that, well, this is the way to do it. This is, you know, provide all

these examples and then people can study these examples and learn from it. And then, you know, it's kind of evolved that, okay, that's really not the answer. That's cool and that's fun and that's, you know, it's a valid learning tool and I don't regret all that work, but the direction that I'm heading in now has evolved much further beyond that. Whereas now, what I'm trying to do is trying to, because VHDL, the realization that I've come to is VHDL, and I mean, everyone knows this, and I knew this from the beginning, but I thought maybe I could make VHDL easier to learn also. So that was kind of the next step. So I thought, okay, well, maybe the solution is to make VHD't have to learn the difficult control logic. You can just plop in this soft processor into your designs. And then all you have to worry about is the peripherals,

which it's much easier to code VHDL for simple things like, you know, a UART or, you know, something like that. It's easier than, you know, doing your own control logic with a finite state machine. That gets really hard. And it's actually kind of the first wall that you run into with most FPGA boards is it's pretty easy to do basic stuff like blinking LEDs, you know, reading, UART, you know, a lot of that stuff is really easy. But when you try and make a full system that actually does something that normally you would use a microcontroller or something

in a circuit to implement, that's the brick wall that most people hit with FPGAs and they throw their hands up and they're like, I don't know where to go from here. I don't know what to do from here. And what's your advice to those people? Well, that's actually the phase that I'm in now. So, moving beyond just providing an Arduino compatible soft processor. Wait a minute, before we go on.

I want to get back to that. But when you say Arduino-compatible soft processor, these are things you can download, and you have one that's like an Arduino on steroids. It's 100 megahertz and 8 megabytes of code space. Yeah, this is the thing about FPGA. I mean, it's not an Arduino processor. They have a lot of power. Anything is possible with an FPGA. I mean, it's not an Arduino processor. They have a lot of power.

Anything is possible with an FPGA, and that's the beauty, and that's the wonder of it, but it also can be overwhelming, and that's what we're trying to do with the Popilio is to make it not overwhelming and to provide the tools and the resources necessary to, right out of the gate, be able to do meaningful and useful things with an FPGA. But, you know, back to your question of, so yeah, we have a, we call it the AVR8,

which is, it's a VHDL implementation of an Atmega 103 chip. So the guy who made it, his name is Ruslan Lep leptinic i don't i i'm sure i'm not pronouncing that right i apologize um but he you know he studied the data sheets for the at mega 103 and then wrote vhdl code to implement everything described in those data sheets so that this core works in the exact same way that the ATmega103 does so that includes all the peripherals that so the USART the SPI master the PWM the timers it all works exactly the same way it has the exact same registers using it is exactly the same as using an app mega 103 um and then we then what i did is i took that core i made it work on the

papilio i made it work um because originally it needed a an external programmer you needed to use the app mega uh external programmer so i i did the work to make it so that it would just program over the papilio serial port um and then i integrated it into the arduino ide so um you know i took the the core files that defined and it wasn't you know it wasn't crazy it wasn't really super hard. But because the Arduino IDE, one of the beautiful genius things that they've done is they kind of have like a hardware abstraction layer

that is really designed from the beginning to support any type of microcontroller. So all I had to do was copy their existing core, which is targeted for the Yatmega 8, I think it was at the time, and change all of the registers to be compatible with the Yatmega 103. And then I had to change the code a little bit to support my loader application. And then, bam, you've got Arduino compatible soft processor running on FPGA. So you could take the majority of the Arduino code out there and run it on the Papilio. But the benefit is that you have access to the complete source code of that processor.

So you can tweak it or modify it or expand it in any way that you want. If you need... You know, the serial port. Right. Ten serial ports. Right, exactly. You need ten serial ports,

you have that capability. Or you need a bunch more PWMs so that you can do some robotics fun. Yeah, I hadn't considered that option of taking the soft core ability or you need a bunch more pwm so that you can do some robotics fun yeah that's that's i hadn't considered that option of taking the soft core and then twisting it to your right to your desires okay right and then if you if you want to directly so so that was kind of the first step then the next step is um a guy named alvaro lopez along, and he's a FPGA rock star. So he's way above and beyond my capabilities with FPGAs.

And he's the one that implemented the ZPUino, which is that Arduino on steroids. It's a 32-bit soft processor running at 100 megahertz, and it has a SDRAM controller, so the code runs out of 8 megabits of SDRAM. And then he also did the same thing. He did the same thing with the Arduino IDE, where he took their core implementation, implementation and he adjusts or he changed the libraries to provide support for all the peripherals on his zpuino so the timers are different on the zpuino and he made changes to the arduino core to use his timers instead of the atmega8 timers and so so on so forth um so the end result is that you can load the zpu zpuino bit file to the fpga um plug it in bring up our modified version of the arduino ide and then select the zpuino as your processor or your board type and then take your arduino code and as long as it doesn't do anything

special directly with the hardware it all works so the truth is is that there are some libraries some arduino libraries that they directly manipulate uh registers in the app mega chips and those have to be ported yeah so okay so let's say i had a board and i got it just immediately maybe chris could tell me some of this too um and i wanted to be able to download some arduino code to it do i have to start by downloading fpga code yeah i think i think so but there was an easy loader and stuff. Right, so, okay, yes and no. If you want to modify the soft processor, then yes, you need to download the Xilinx tool chain, and it's free, by the way. So the Xilinx software, you would have to download that if you want to modify the soft processor.

So if you wanted to add more serial ports ports or you want to change where the pins connect and that sort of thing. But we have built into the Arduino IDE or our version of the Arduino IDE, which we currently call ZAP, which is short for ZPUino, Arduino, Papilio. But the next step is we're changing it to Design Lab. And I'll tell you more about those changes

because that's kind of the next cool thing, the next phase of how we're going to make FPGAs more accessible. But anyway, it's all integrated into the IDE, and if you just simply want to run code, everything is there with that one 300-megabyte download to do that. But then I'm stuck with being an arduino although maybe yes super powered arduino right and so that's exactly there's not a whole lot of value to doing that unless you want to start it right unless you want to learn you know it provides you a baseline for starting in with FPGAs and making sure everything works.

So if you are going to dive into modifying, adding more UARTs and that sort of thing, it's a quick way to get a baseline up and running while you're waiting for the rest of the tools to download. But you're waiting for the rest of the tools to download but but you're right there you know and that was one of the the realizations i came to is okay i've you know there's the soft processors now but what are we doing to make this better than not necessarily better but as useful as the arduino in its own way okay so so Christopher, you got the Papilio Pro and the Arcade Mega Boy.

What were the things you actually did with them? Well, I did what Jack's talking about, and I put the Arduino core on and played around with that. And then I did a lot of reading, actually, and tried to sort of decide what I wanted to do next

and then got overwhelmed. Well, there was a blinking light stage, too. Yeah, there's some easy or semi-easy VHDL examples for things like counters and blinking lights that you can plug in. So I played with some of that stuff. There were, on the website, there were a number of, I seem to recall there was a number of

small examples of that kind of thing and there was a good sort of intro to vhdl and fpga's ebook on there that took you through some of the concepts and things so i read through that one of my kind of pie in the sky goals is to kind of recreate the apple 2 and an fpga so yeah you know or or maybe not go as far as that but to design a really stupid cpu to learn how to do to learn you know processor design and just to not necessarily to go anywhere with it but just to explore that and to see what that's like and the fpGA provides that capability. You can really do that. But one of my questions as going through it was, okay, there are these things that are educational,

like making your own CPU. There's these things like taking a known soft core and if I have to modify it for my needs, changing peripherals. What are some other things that only FPGAs can do that the sort of the hobbyist would want to to use these devices for beyond just getting a microcontroller

and to my mind it was things that required different different uh high speed kind of things or maybe radio or maybe different kinds of networking that you can't easily get um think simultaneity serial communication that kind of thing but but in your mind what have you yeah thought of other pieces like that yes uh so those are really the kind of the big ones there is one is being able to create something that just doesn't exist anywhere else you know for example uh i have the retrocade synth project that i put together and that was awesome yes oh thank you thank you and so basically what that does is it takes all the audio chips from all the classic uh computing systems like the Commodore 64 SID chip and the Atari YM2149 chip,

and then the Pokey, I'm sorry, no, that was the Yamaha, but it was using the Atari ST. And then like the Pokey chip, and then connecting them all to the ZPUino soft processor and making a synthesizer that has all three of these classic audio chips all together on one one uh circuit board with one solution and you can play all three of them at the same time so something like that has never

existed before and that was relatively easy to do with an fpga um so something like that has never existed before. And that was relatively easy to do with an FPGA. So something like that, something unique that doesn't exist anywhere else. Or you need 10 serial ports like the SoundPuddle project. It drives 20,000 RGB LEDs and it uses nine SPI masters to do so. And those SPI masters are, are memory mapped to some internal memory. And so they, they're really just acting as big giant displays because to control it,

you change the memory, the bits in memory. And then it just automatically VHDL code automatically spits it out over the the nine spi masters and it's a really cool thing that there's no chip out there that does that you know it doesn't exist uh so that's the kind of cool things you could do and then also just high speed stuff like um you know fpgas can operate very quickly. So like a logic analyzer was one of the things I did with the OpenBench logic sniffer

that it wouldn't really be feasible with a microcontroller because you would really struggle to get 32 channels sampling at 100 megahertz altogether at the same time. The simultaneousness yeah the parallel operations that that's the type because keep in mind it's a circuit board you know it's you're implementing circuits and and that's what i'm really trying to emphasize to make it clear easy to understand in people's heads is that you know because the questions always come up like oh well are you emulate with the arcade game heads is that you know because the questions always come up like oh well are you emulate with the arcade game stuff well are you emulating the arcade games are you

you know running a soft processor that translates the code and it's like no it's actually you know taking the original pac-man motherboard and recreating those circuits on an fpga and so i'm rambling i'm getting off on a tangent a little bit there but back to the question so the high speed stuff like logic analyzer or driving uh these new rgb leds that require at least 20 megahertz uh they require you to drive them at at least 20 megahertz. They require you to drive them at least 20 megahertz. And Arduino can barely do it, but you can't do much with it. And in our demo for the Papilio Duo, Alvaro Lopez, or Alvi Lopez,

he put together a demo driving two of those displays and actually putting 24-bit full color video on it so you know we're running like the intro to to the simpsons and star trek clips and that sort of thing which as far as i know the arduino wouldn't be capable of doing that so you've mentioned the duo and the new interface, DesignLogic? DesignLab, yes. DesignLab. Yes.

What do you have cooking? Yeah, so that's kind of the next phase of, and this is where I think we're just about to crack the nut with the long-time goal of making an FPGA as useful and accessible as the Arduino. Because like Chris said, it's like, you know, there's these cool projects and then there's a soft processor. And you said it as well, which is, you know, how is this better than just using an Arduino? Well, it's not, you know, and that's something that, but it's's the first step it was the first thing that had to happen in the in the journey was to have that capability so now we're poised i think to take it

to that final step and really have something special and i'm really excited about it so Okay, let me gather myself. And so in a nutshell, what we're doing is we're going to eliminate the requirement to learn VHDL to use an FPGA. And the way we're going to do that is by using schematic-based entry. And so to make... What? He's going to go from something I know how to do to something i don't know how to do i don't know i don't know how to do either so yeah what are you going to use for schematic entry kai cat no no um ltm no the so the xilinx isc has a really passable schematic editor. So we're using that. So we're taking the path of least resistance.

They already have that. You know, it will get the job done because really what we're trying to, the end goal here is to have it so that anyone can pick up the Papilio and do make a useful and meaningful system using it so a system on chip and vhdl has too much overhead with it there's too much learning that you have to do to get proficient enough to be able to do a lot much with it so you know like we were talking about

you can blink lights pretty easily you can you know input and output pretty easily but then you hit a brick wall and you can't it's you have to have several years of experience to to really pull off a useful system you know and like i said one of the biggest problems is control logic now if, if we kind of follow the path that the Arduino provided, and so they took C++ and they figured out a way to make it easy to use and leverage C++. And the way they did that is they have the libraries that do all the heavy lifting. And really what you're doing when you program on an arduino is you're doing c++ client programming meaning you don't have to learn the intricacies of classes and how to make libraries and polymorphism and all that crazy

stuff that you know most people don't even need or will never use so a client programmer is just going to need to know how to instantiate objects and the way that you learn how to use those objects and then use those objects so you know with the arduino you download a library you instantiate that object and then you're calling the the properties and the the methods of the that object, and then you're calling the properties and the methods of that object to do meaningful work. And it's very easy to learn, and it's very easy to use, and it's very powerful. I'm going to disagree, actually. It is very, very easy to learn, and it is very powerful. But it's a good starting place.

And most of the Arduinoduino people i speak with they start there and then they quickly discover they need to learn all of this other stuff i mean once you get past moving a motor and blinking a light and you start wanting to do what you want to do instead of what the library wants you to do, that's where they start learning. And I love that point. That's the tipping point of I'm a hobbyist to I'm an enthusiast. Exactly.

And I agree completely with you. And so that's the point that I'm making is that there's a ramp there. There's a ramp where you start, and then there's a clear ramp up where you start with client programming and then you run into something where you're like man i need to make my own library so you learn and you have the resources and you learn how to make libraries and then the next thing you know you're doing c++ programming and you do care about classes and you do care about all these things but you can learn it in a gentle rap. It's not just, bam, you have to do C++ programming to do anything. But isn't that like downloading the soft cores and using the VHDL? You were saying they have widgets, although I forgot the name.

Cores, cores. Not just the cores, but like the soft timers and all of these, the blocks that other people have made that are in the xilinx isc and so you you start out with a core and you use it like a core and then you say hey i want some more pwms and then you go and you replicate the pwm blocks and until at some point you're like oh yeah okay i could write this from scratch because i've been playing with it for a year and a half. Exactly. Yeah, and so that's what we're trying to do with Design Lab

is that we're trying to take, we're trying to recreate that ramp for FPGA. So the same ramp that you have with the Arduino where you can start out with just client programming and you can learn it over a weekend or a couple of weeks period and actually be doing interesting things with it because there's libraries that you can download and implement

and use that do the stuff that you need. We're trying to do the same thing for FPGAs, and the way we're doing that is it starts with the soft processors, but what we've done is we have converted the soft processors to schematic form. And then each soft processor has what's called the wishbone bus. And it's kind of like the ISA bus on a computer where you would plug. So we're back to, with an FPGA, you're making circuits. The Wishbone bus allows you to pretty much plug in, think of it as a way to plug into this soft processor,

a way to plug in a chip. And the cores kind of equate to chips. Give me an example of the chip you would want to plug in. The Commodore 64 SID chip, the audio chip. So if you wanted to plug in six, well, it depends on the size of your FPGA, but we have 15 wishbone slots on our schematic. So if the FPGA chip was big enough, which it's not, but for the sake of an example, if it was big enough,

you could put 16 or 15 SID audio chips into these 15 wishbone slots and they would all be, and you would do it by simply dragging and dropping using the schematic editor. And then you generate the bit file, load it to the Papilio, and then it's all integrated. So Design Lab is a fork of the Arduino IDE. But what we've done is we've added the ability to manage circuits into Design Lab. So when you have a sketch sketch your sketch also has a circuit component so every sketch you know it's comprised of code so arduino compatible code and then any libraries um so for example there's a library for that sid chip chip. So if you use that SID chip, you don't just have to study the data sheet

for the SID chip and go, okay, if I want to make this tone, I have to write these values to these registers. No, we have Arduino style libraries where it's as simple as instantiating a SID object and then you tell it which wishbone slot you've connected, you've placed that SID chip, and then you have all these methods and properties,

such as load this frequency into this SID voice, and then there's a method to play. So you've extended Arduino with customizable hardware. Right, yes. It sounds pretty familiar actually to me because years ago on a professional project we had to use an fpga to provide custom uh custom interconnect and some peripherals to a pc standard embedded computer with pci so we needed an fpga and we needed to stick pci on it and we needed some i squared c masters and some other things

like that yes and the electrical things like that. Yes. And the electrical engineer doing that, he didn't know VHDL. Right. So he pieced things together from the soft cores and blocks that came with, I think it was Altera at the time. Mm-hmm. And he didn't, you know, I think he obviously had electrical engineering knowledge,

so he could do some glue interconnects that probably I couldn't do or a software engineer couldn't do but it was in essence putting together blocks and there was some small amount of verilog we ended up doing um for some tiny pieces but yeah that's that's sort of how it worked and you could do a lot with with that kind of methodology right and so that's kind of the ramp that we're talking about which is okay so would i ever make something with the schematic editor no it would anyone who knows vhdl or verilog well enough to not use a schematic editor would they use it no however to get started in a in a very easy to learn and easy to use way, it's very valid. And underneath the covers, it's still all is VHDL or Verilog.

So each one of these cores, so like the SID, when you drag and drop the SID chip and you connect it to a Wishbone slot, you can just double click on that SID chip and bam, you're in the VHDL. So you can study it, you can expand it, you can copy it. And so the schematic,

so our goal now is to make everything work with the schematic editor so that it's that very easy introduction. And right off the bat, if you can draw, if you can drag and drop blocks and, you know, then you can use an FPGA and make something as long as we've provided the blocks you know that you are interested in using you can very quickly and easily make a working solution um and then when you want to move beyond that there's all these examples each one of these

blocks that you've been using already and are familiar with and comfortable with, it's all done in VHDL. So you can just copy a block. If there's a block that does 90% of what you need, then you just copy. And it's the same with the Arduino. You find a library that does 90% of what you need, then you just copy that library

and you learn enough C++ to implement the remaining 10% that you need. And so we're trying to implement that framework that allows you to have that easy ramp. Okay, so this is kind of like when Mindstorms from Lego came out with what seemed to me a very labVIEW-ish sort of visual display, and that let people use their mouse. Instead of typing in long strings, they could just click and pop and drop. Am I getting the right idea? I think it's more than that, because keep in mind,

it really is, it's the it's design link schematic editor so you can do anything with that that you could do with vhdl or verilog so it's not limiting you know it's and that's another reason why we wouldn't use kicad or or some other better schematic application because they they've already put so much time and energy into allowing you to draw circuits so you know if somebody just wasn't comfortable with vhdl and and they wanted to make a circuit using the entirely using the um schematic editor you know and like i said it always comes back down anyway for me at least to what are the digital building blocks to implement something you know so they could take the schematic version of those digital building blocks and wire them up and it would be indistinguishable from a vhdl solution so i can see how how making it more apparent that what you're doing in the FPGA is making an electronics

board in the schematic. That makes a lot of sense to me, although since my version of schematics indubitably involves a pen and a piece of paper and begging someone to make it real, the schematic capture. The schematic capture is not, I would rather type it. I would rather learn Verilog than learn schematic capture and then learn Verilog. Have you seen it?

I have actually. I have done a fair amount of Verilog. I just wanted to make sure. I'm definitely playing the straight woman. But I have seen Verilog. I have done CPLD programming. Yeah. But it's not, it's not easy.

So one of the reasons... And it gets frustrating because there's things... So VHDL and Verilog, they both started out as a way to simulate circuits. And so then kind of after the fact is when FPGAs and CPLDs and PLAs started coming around, you know, originally they would, like they said, well, we can use these VHDL and Verilog, these HDL languages that are already out there to simulate circuits. We could use them to actually implement, synthesize real circuits on the FPGA or the PLAs in the beginning. And so then what they did is they kind of had to twist the language because it wasn't originally intended for that use. So they had to twist the language to be able to support their hardware. And so what you run into is you have to learn these weird ways,

not, well, I shouldn't say weird, not obvious ways to implement certain things. So, you know, if you want to register... Which leads me to my next question. Right. I think we've really dug a big hole here. So I kind of want to get back to a little bit of getting into this. We've really, gotten uh off track um so what are the basic building blocks that someone who just picked

up a board um and and wants to do it in vhdl because i mean design lab seems neat, but it's all about me. What are the basic building blocks of VHDL and FPGAs that I need to understand to implement my own project? Right. What I would recommend for someone in your shoes who you just want to go straight into VHDL and, you know, what I did I think worked well for me which was learn get books on digital logic and learn all of the basic digital logic building blocks that are available to you and then find a real world solution that you want to tackle something that's easy for me it was I wanted to program a flash chip so I wanted to use the parallel port on my computer to program a flash chip and so you know to tackle that problem I had all these books on digital building blocks I understood all the digital building blocks

and then I sat down and draw drew out like okay how would i design a circuit to do this and so you know you're going to need a uh you know a parallel to serial shift register you're going to need this you're going to need that you're going to need some registers here and then once you have that blueprint then then use VHDL. Figure out how you implement each one of those building blocks in VHDL. And then that's the best way to proceed, I believe. So what digital logic books would you suggest for a software engineer? You know what?

It's been so long. We're talking like eight, nine years ago. So I'm looking at my bookshelf and mostly textbooks are what I have. I've got one by Floyd. It says Digital Fundamentals, 6th Edition, Digital Electronics by Thompson. So really, I think the majority of what I bought were old college-level textbooks. And they're discontinued. So if courses aren't teaching them anymore,

then you could get them for really cheap off of eBay or Amazon. So like here, okay, I got one here. Digital Fundamentals, 6th Edition by Floyd Prentice-Hall. Here's another. Instructors Annotated Edition, Digital Electronics, Principles and Applications, 5th Edition by Tokheim. I found those very useful, very helpful. And that wasn't obvious.

When you're going to learn VHDL, it's not obvious at all how to go about learning VHDL. And so the fundamentals of digital electronics helped me tremendously. And then also knowing that there's a difference between simulation and synthesis. And don't bother learning the simulation in the beginning. Make sure that whatever VHDL book you're looking at and you're learning from make sure that it is geared towards synthesis rather than simulation because that so the difference is uh simulation is useful for after you've designed a circuit or when you've designed something in vhdl you use simulation to uh generate the uh test

bench to test it to provide the input that makes sense uh to see and then you look at the waveforms uh you look at the waveforms uh to make sure that it operates the way that you expect it to operate. But simulation, so the constructs that you use for simulation don't work in synthesis. So, you know, one of the things that tripped me up when I was first learning is I was trying to write code. I was finding all these VHDL books and examples that were geared towards simulation. And so I would code something up that would be a simulation construct and it would work in simulation.

But then as soon as you go to synthesize it, to run on an FPGA, it's throwing up all these error messages and you're throwing your hands up in frustration and going, why isn't this working? Well, it took me quite a while to realize that, Hey, you know, they're not coming out and saying that this is simulation and that this will only work in simulation. So, you have to make sure that you're learning from a book that is geared for synthesis. Why would you ever want it to be simulation and not synthesis? Because VHDL and Verilog are used for DVT.

So if you're designing something, all the test people in your company are running that and testing your design to make sure it's doing what it's supposed to. It's like test-driven development except for hardware. But why would you do that in an FPGA environment? You wouldn't, but that's where the languages came from. Right, exactly. So keep in mind it comes back to verilog and vhdl was designed designed originally to simulate hardware

to simulate circuits and so later down the road when fpgas came into the picture or the precursors the fpgas is when they took a subset of vhdl and Verilog to make so that you could have a textual way to program FPGAs. Do you think there's a movement or any interest in getting beyond that and saying, look, we've had these for a long time and maybe they're not the best thing in the world? And I know you're trying to do that with the schematic designer, but is there a third way? Like a new descriptive language? Something that's clearer

or easier or doesn't have the same baggage? Yeah, there's a lot of attempts out there, like Objective-C. No, no. I think that's what it is.

I might be... Objectiveive C is Apple's thing no yeah I'm sorry it's like oh good I don't pay a lot of attention to it I'm sorry no that's fine there's

you know there's Python Python attempts and there's MyHDL there's a lot of different attempts and there's my HDL. There's a lot of different attempts out there. But what you generally hear from people is once you know VHDL or Verilog, you're pretty happy with it. I mean, most people don't, there's not a lot of support for these things.

Yeah. Okay. You know, because in the industry, it's just everyone that I've talked to, one, would never want to use a schematic editor, and two, would never use any of these other solutions that have come out. But it's very hard to change. Yeah, they feel that VHDL and Verilog is completely adequate. The people that are doing this every day are pretty comfortable with the tools, and they don't have much interest in these other.

So I haven't seen anything that really looks that good out there. Well, that's the challenge and the contours of your challenge in getting hobbyists and enthusiasts interested in this. You have a bunch of professional class of people who are perfectly happy with tools that require years of study. Yeah, yeah. And so, right, and so, you know, what Design Lab is geared for the people, the hobbyists and the DIY, do-it-yourself,

and the people who are trying to get into this, it's geared for them, you know. It's not useful not that useful for me because I'm comfortable with VHDL. And the people who are designing cores and that sort of thing, they're going to use VHDL or Verilog. But where it is useful

and why I'm putting so much time and energy into it is because it's that ramp. I believe that this provides a ramp to get more people to bring FPGAs into more of the mainstream. Well, and I asked for book suggestions, and you gave a couple, and I'll put those links on the show notes. But don't you have a book on your website we have a uh ebook that um yeah the uh hamster or mike fields aka hamster aka hamster wrote and it's a great book and it's targeted for uh the papilio and the logic start um and is it a good place i mean, it must be synthesis and not simulation. Yes, it is a good place to start, but it's the same. So there's tons of really great books, VHDL books out there.

And the one that Mike Fields wrote is excellent. And a lot of people love it. But it's the same problem, which you hit a brick wall with VHDL that can't be overcome until you have years of experience under your belt. And you want to make it as simple as Arduino, but it can build Arduino. So how can it possibly be as simple as there has to be a layer of additional complexity? Are you trying to make something that's actually really complicated so simple anybody can use it and then we'll end up at that star trek episode where nobody knows how to fix anything uh you know logical train of thought right everybody passed through the train yeah i'm not sure i saw that episode but you know it's the i I believe that the Arduino team did something that was pretty incredible, which is they took something that was scary, you know, to a lot of people, which is C++ programming, and they made it every day.

And so I'm making an attempt to do the same thing for FPGAs. Will I be successful? I haven't been successful yet. But I think it's a worthy goal and it's something that I'm continuing to work towards. Will I get there? I hope so. Will it be something that people can make stuff and they can't fix? I think that depends on the ramp.

You know, I think that, you know, the C++ was hard for people to learn. You know, I know I certainly was scared to death of it when I was in my, you know, when I was in my teenage years. But as you get more experience and you're dealing with C++ projects on the client programming level and you get more exposure to it, all of a sudden it's not as scary and you hit a tipping point, like you said.

I believe there could be the same tipping point with VHDL. And you do recommend VHDL over Verilog? I personally do, and there's a lot of some people, it's kind of a religious, it comes down to kind of a religious discussion a lot of times. Because people who love Verilog really love Verilog, and people who love VHDL really love VHDL. They're both good languages and my reason for preferring VHDL is because from the perspective of a beginner, I think it's better for beginners because it's more it's Verilog is so C++ or C-like that you get this

false sense of hey I can I could do things just like I can in C and it really feeds into when you're dealing with FPGAs and you're writing V8 or you're using an HDL you can't think of it as you would a programming language because it's not a programming language. It's a hardware description language. You're describing hardware. You're not programming a processor. Okay. So as far as that goes, yes.

But what about the debug aspect? How do you debug VHDL code? Yeah, so there's two ways um since you're describing hardware you use the same exact method methodology that you would use to debug a circuit board how do i fit my oscilloscope probes in there that's part of what we're doing with design lab is it's difficult to do that in vhdl however if we implement everything schematically, so the top level is schematically. So one of the things, one of the building blocks that we're providing with Design Lab is a logic analyzer. And so one of the things that you can drag out of the tool

band and drop onto your schematic is a fully featured logic analyzer which is uh you know it's comes from my work on the open bench logic sniffer so that's how you would debug that's one way to debug using design lab is that you would connect the probes you know if you've got a uart and you want to see you know is it generating the correct timing and is it what is the data that it's sending over you just connect the the logic analyzer probes to those pins inside the schematic and bam you've got all that information in front of you okay so that's one way is you would use the standard tools and the standard methodology that you would use to debug a circuit board so whenever i design available in the xilinx isc as well they're um

they have a solution they have a solution called chip scope uh which is expensive so it's not free so all of this stuff that i'm doing yes it exists except that it's professional level tools that are have professional level cost what i'm doing is open source. So I'm providing an open source solution for these things. So, yes, Chipscope. Altera has their own. I think it's called TAP something. Yeah, they're all pretty expensive.

But you mentioned the ISE was free with the Papilio to be able to download stuff and to develop, but not the debugging suite. Exactly. So that's a missing piece, really. Oh, that kind of sucks. Right. And so that's also one of the challenges of one of the things that makes FPGAs hard. But also, if you look at the Arduino, there's no debugger.

And there's no need for it because, you know because the people that are doing the high-level libraries are probably using a debugger. But the people using those libraries, those libraries are tested. And just in the same way, what we're doing with Design Lab is the cores that we're providing will be tested. And so there will be less of a need for a debugger is the thinking um but so learning without a debugger is very difficult yeah because i like to step through things and see what's happening and where what's going here and there although you know not all arduino libraries are very well tested. Yeah, that's true. Would you like a list? But, you know, it's, for the beginner at least, you know, once you get to the intermediate level,

yes, you want a debugger. And you're like, how did I ever survive without a debugger? You know, but people do. You know, people manage to do some pretty cool stuff with the Arduino. And I think they'll be able to manage to do some pretty cool stuff with the Arduino, and I think they'll be able to manage to do some pretty cool stuff once we put these tools in their hands, the Design Lab tools with FPGAs. Okay, so back to the question of how do you debug an FPGA.

So like I said, first of all, if you're debugging the hardware, once it's on the FPGA, you use pretty much the same methodology you would to debug a circuit board. So whenever I design a new FPGA board or a new arcade mega wing, you know, when I run into problems, that's what I do is I bust out the logic analyzer, you know, or I bust out, you know, just basically the log. Yeah. You can't, you're really using an Oscope on a FEJ, but there's not really a need because you're not looking really at the physical attributes.

And so to debug, you're like toggling a line that says, I'm in this part or I'm in that part. There's no part really. So you're thinking more of sequential C++. So you're thinking as a programmer right now, so it's not like you're in this section of code. It's more of this. But you could do things like you could bring out a signal to a pin.

Exactly. To say I want to look at this internal i want to look at this internal state and you can look at that logic and that's exactly it so you would maybe look at a register inside the fpga and you could bring it out to um you know a set of pins a set of pins or you could bring it out into the top level of your schematic and connect a logic analyzer to it so yes so so it's all the same things you your schematic and connect a logic analyzer to it. So yes, so all the same things you would do with the circuit board, that's what you're doing with FPGA hardware. Okay, so now there's something that's a little nicer

when you're designing VHDL or a schematic or whatever intended for an FPGA, which is the simulation. So when you're designing it, before you ever synthesize it for the FPGA, really what you should be doing is have it set so you make a test plan. I'm sorry, a test bench that's going to provide the input, the stimulus, that will be as close to the real-world stimulus as you can get it. And then you simulate it, and you'll get a printout of all the waveforms that are generated.

And then you can debug your code, your VHDL code or Verilog code at various points. Before you've even put it in the hardware. Right. Okay. And do you, is the simulation part of ISE free? Yes. Or is that?

That's free, yes. Oh, that's nice. Yes. What kind of pitfalls and traps do most beginners hit? I mean, clearly the sequential versus non-sequential is going to be one that a lot of programmers have a hard time with. Right. Are there other ones that are just really common? Yeah, so I think the whole simulation thing trips up a lot of people.

It certainly tripped up me. And it's easy to tell what's intended for simulation and what's intended for what's not. Because the most telling sign usually with simulation is that it has some kind of a time associated with it. Do this for 49 nanoseconds. That's a dead giveaway that that's not going to work in synthesis. So that kind of stuff, that's a big trip. The other thing that trips you up a lot when you're beginning

is that um fpgas don't have latches natively they have registers instead and so if you do something that uh infers if you write your vhdl like i said so there's weird you have to do things in a very specific way to get exactly what you intended so if you're trying to make a register you have to do a very specific uh couple lines of code to implement that in vhdl and if you get one of those lines just a little bit off you're going to infer a latch instead of a register and so when you do that and you have latches being inferred it's kind of like a low-key warning in the tools that just say oh you inferred a latch and they think they assume that you know what you're doing but latches don't work generally whenever you have a problem with getting... So it'll work in simulation just fine.

But then when you go to run it on your hardware and you're beating your head up against the wall, why is it not working? The number one thing to do is go back at your code, go back on your synthesis report and see if any latches were inferred. And if they were, study that piece of code, fix it so that it's not making a latch, so that it's making a register or whatever else

you intended and then 9 out of 10 times that fixes that problem then what are the other things that trip people up? Just the fundamental what is FPGAs used for and I think people have the misconception I think what really helps out is to say you're designing circuits and that does seem like a really good thing for people to realize um so I I guess well let's see uh you mentioned open source. Your boards are open source as well as your software, right?

Yes. So everything that I do that can be open source is open source because I strongly believe in open source. However, the Xilinx tool chains are not open source and that's outside of my control um because they pretty tightly protect those um like to generate a bit stream only only the vendor has the information of it necessary to be able to do that final step for an fpga and generate the do the placing and routing to generate the the bit file uh so you know we're not completely open source but that's outside of our control everything that i work on and that i release uh and that i touch is is open source and parallax just opened their core their um propeller one do you have any comments about that yeah i think that's really cool um i they run it on a Papilio board?

Yeah, I mean, I was really excited about it. And a lot of people in the Papilio forum were excited about it. And people made attempts pretty quickly. But what we found is that you generally need a larger FPGA, like a Spartan 6 LX 25 to implement the that design so the LX the Popelio Pro uses Spartan 6 LX 9 and as well as the Popelio Duo they use the LX 9 and the chip is just too small to implement all I think it's like eight cores i think the the propeller one is eight cores so people have been saying that maybe if we used fewer cores like maybe half the cores we could get it to fit but then you know is it still useful at that point yeah i mean it was a

neat it's a neat processor wow yeah cool but it but. Yeah, but that's exactly what's so cool about FPGAs is that stuff like... So pretty much every chip that's out there, they're using some kind of a hardware description language to make it. And theoretically, you know, if that trend started to happen more, where companies that are making chips release the source code of those chips, then they would all be able to run on an FPGA, and we'd be limited just by the size.

It does seem likely that people are going to more custom things, just because that seems very likely all over. Well, prices drop on FPGAs, then it becomes more compelling to use them, too. That's always been the problem, is as a hobbyist, it's like, oh, if I want an FPGA, well, I've got to get this chip, I've got to get this development system from Palter or Xilinx and all these things that are very expensive. And now this project is kind of driving things more to being able to be used by anyone.

And that's the cool thing, I think. Yeah, and the cost, one of the Papilio boards is $38. The chips themselves are not that expensive right you know um like the the lx9 is i believe it's like when you get it in bulk it's it's not that far off from some of the the the processors out there so it's like, I want to say anywhere from $6 to $13. So FPGAs aren't necessarily that much more expensive. What drives up the cost? So the variables that drive up the cost are, one, you need to add a chip like the FT-2232 to be able to program it and communicate with it.

Those get expensive. You can't just use the FT-232. You need the dual-channel one that can do JTAG programming. So that adds expense. And then, you know, we have to have it assembled and manufactured, and we're not doing it in the volume. Yeah, we're not doing it in the volume

that some of the bigger companies are. Well, no, once you get good volume on FPGA, you spin an ASIC and... Yeah, yeah. Well, I think we're about out of time. Are there any last thoughts you'd like to leave us with? No, I think that's it. I really appreciate you guys having me on.

It was a great time. Thank you so much for being here. Thanks, Jack. Okay. My guest has been Jack Gassett, founder of Gadget Factory, designer of the Papilio boards, the open source FPGA development boards. Very cool. You can buy the boards and daughter cards on SparkFun,

but also from the Buy button on papilio.cc. A link will be in the show notes. Very big and special thank you goes out this week to listener Punky for not only suggesting we ask Jack to be on the show, but also for writing half my outline. Normally I get cranky when people try to do this, but this time it's all gratitude. Good job, Punky.

As always, thank you also to Christopher White for producing and for co-hosting. And thank you all for listening. If you've got comments, questions, or suggestions, email us show at embedded.fm or hit the contact link on embedded.fm. Final thought for this week. I had a lot of really good ones, but listener John said that we got another Mark Twain quote wrong. It's sad. All of the grumpy, funny things get attributed to Mark Twain, but he didn't actually have a monopoly on being curmudgeonly. So I'm going to do this one properly. William Allen White was a prominent newspaper editor in Emporia, Kansas And here's the whole story of the very and damn quote According to Quote Investigator, one of my new favorite websites

I was in a meeting with several fledgling newspaper men And Mr. White was the sage of Emporia. So the Cubs asked him to give them some advice about newspaper writing. He said, I never give advice, but there's one thing I wish you would do when you sit down to write news stories, and that is this.

Never use the word very. It is the weakest word in the English language. It doesn't mean anything. If you feel the urge of very coming on, just write the word damn in its place. Very. The editor will strike out the word damn and you'll have a good sentence. Okay. Okay.