Home    Bloggers    Messages    Webinars    Resources   
Tw  |  Fb  |  In  |  Rss
Duane Benson
Latest Content
Page 1 / 2   >   >>
Discovering FPGAs: Robot + ZedBoard + Linux
Duane Benson  
5/20/2013   8 comments
Duane has decided that the time is ripe to get his ZedBoard bolted onto his robot with a Linux distribution up and running. That was the ultimate plan anyway, so why wait?
Discovering FPGAs: Implementing SPI & I2C Interfaces, Part 6
Duane Benson  
5/13/2013   8 comments
Now it's time to delve deeper into the state machine I'm using to control my I2C interface.
Discovering FPGAs: Implementing SPI & I2C Interfaces, Part 5
Duane Benson  
5/6/2013   4 comments
The three states associated with bi-directional "inout" pins can cause confusion for the unwary.
Discovering FPGAs: Implementing SPI & I2C Interfaces, Part 4
Duane Benson  
4/29/2013   10 comments
It's time to jump into unexplored territory -- the state machine that will control Duane Benson's I2C interface.
Discovering FPGAs: Implementing SPI & I2C Interfaces, Part 3
Duane Benson  
4/15/2013   16 comments
We're now ready for the I2C master to transmit a command set to a remote device.
Discovering FPGAs: Implementing SPI & I2C Interfaces, Part 2
Duane Benson  
4/8/2013   36 comments
Duane Benson has his SPI interface working. At some point, he'll want to rewrite the Verilog code, but first he wants to get the I2C interface up and running.
Discovering FPGAs: Implementing SPI & I2C Interfaces
Duane Benson  
4/2/2013   59 comments
In the case of my robot avatar project, I'm going to need both SPI and I2C interfaces to receive data from the sensors, and to monitor and control the motors.
My Role Fixing the Mars Curiosity Rover
Duane Benson  
4/1/2013   36 comments
On February 28, 2013, the Curiosity Rover's A-side computer experienced a corrupted-memory glitch, causing it to go into safe mode.
Discovering FPGAs: Using a Software Simulator, Part 5
Duane Benson  
3/26/2013   46 comments
Duane Benson finally persuades the simulator to display the results he wants to see. Did he do this the right way?
Discovering FPGAs: Using a Software Simulator, Part 4
Duane Benson  
3/11/2013   38 comments
After tweaking his code, Duane Benson can finally use the software simulator to run his test bench on his design and view the results.
Discovering FPGAs: Using a Software Simulator, Part 3
Duane Benson  
3/4/2013   15 comments
We've now reached the stage of creating a testbench file that instantiates my counter as a sub-circuit module.
Discovering FPGAs: Using a Software Simulator, Part 2
Duane Benson  
2/26/2013   15 comments
Although I'm following along with the official tutorial, I'm not seeing the same results as the tutorial's authors. It's time to take a step back and come at things from a different direction.
Discovering FPGAs: Using a Software Simulator
Duane Benson  
2/18/2013   23 comments
In the context of electronic design automation (EDA), a software simulator is an application written in software that is used to simulate the operation (the function and/or timing) of an electronic device or system.
Discovering FPGAs: Returning to VHDL, Part 3
Duane Benson  
2/11/2013   198 comments
Based on the feedback to my previous blog, I'm revisiting the question of VHDL libraries, removing obsolete code, and generally making things much "spiffier."
Discovering FPGAs: Returning to VHDL, Part 2
Duane Benson  
2/4/2013   74 comments
If there were a choice in both VHDL and Verilog, would you prefer to keep your signal declarations all in one place, or spread them throughout the HDL code, declaring them near to where they are used?
Discovering FPGAs: Returning to VHDL
Duane Benson  
1/28/2013   54 comments
Not knowing VHDL makes it much more difficult to translate help given by non-Verilog users, so I've decided it’s time to go back in time and see what I can do with VHDL.
Discovering FPGAs: Using On-Chip Block RAM, Part 4
Duane Benson  
1/21/2013   74 comments
Learning how to program, configure, and use FPGAs has been pretty much as different as anything I've ever done.
Discovering FPGAs: Using On-Chip Block RAM, Part 3
Duane Benson  
1/14/2013   23 comments
Duane's previous column left him with a counter that was unexpectedly outputting a random sequence. In this blog, he divides his code up and sets out to conquer each section separately.
Discovering FPGAs: Using On-Chip Block RAM, Part 2
Duane Benson  
1/8/2013   46 comments
In this column, I take my earlier serial peripheral interface (SPI) example and modify it to use the contents of an on-chip RAM block, but first I need to load my RAM with data.
Discovering FPGAs: Using On-Chip Block RAM
Duane Benson  
1/3/2013   45 comments
In earlier columns, I've used the Core Generator to insert ChipScope cores, and I've instantiated modules, but I know nothing about "inferring" things.
Discovering FPGAs: ZedBoards & Tele-Presence Robots
Duane Benson  
12/24/2012   11 comments
I have been visited by the FPGA elves, who have addressed my need for more computational and programmable power in the form of my very own Zynq-7000 All Programmable SoC-based ZedBoard.
Discovering FPGAs: Using the SPI Interface, Part 4
Duane Benson  
12/17/2012   13 comments
Following my previous blog, I discovered that I'd missed a number of fundamental concepts and introduced a few errors, but now I'm well on the way to having my own SPI core up and running.
Discovering Wireless Mesh Networks
Duane Benson  
12/11/2012   11 comments
A new kit from Synapse Wireless lets you create applications on your PC in Python and download them into wireless modules over the air.
Discovering FPGAs: Using the SPI Interface, Part 3
Duane Benson  
12/10/2012   10 comments
I've incorporated advice from the comments on my previous blog in this project. Now I'm using only a single clock resource and I can transmit a byte of data.
Discovering FPGAs: Using the SPI Interface, Part 2
Duane Benson  
12/3/2012   25 comments
Originally, I had been thinking that it would be easier to create a slave in the FPGA, but I subsequently decided that creating the master will be a lot more useful in the long run.
Discovering FPGAs: Using the SPI Interface
Duane Benson  
11/27/2012   49 comments
After everything I've done with my FPGA thus far, I'm itching to move a little further into the chip, which I will do by taking a look at an SPI (serial peripheral interface) bus interface.
Discovering FPGAs: De-Bouncing Around
Duane Benson  
11/19/2012   58 comments
The common de-bounce methodology, as I used it in my earlier column, can cause annoying delays for the user. So in this blog we implement an alternative approach that provides the user with an instant result.
Discovering FPGAs: Running Things in Parallel
Duane Benson  
11/12/2012   15 comments
In order to wrap my brain around the concept of performing tasks in parallel, I'm taking some outputs from one side of my FPGA and feeding them back as inputs into the other side of the device.
Discovering FPGAs: Powering-Up My Papilio
Duane Benson  
11/5/2012   26 comments
My Spartan 6 FPGA development board won't have enough I/Os for my robot avatar. I'm thinking that my Papilio's 48 I/Os will get me a lot further than the Spartan 6 LX9's 16 accessible pins.
Discovering FPGAs: I See Clocks Everywhere!
Duane Benson  
10/29/2012   11 comments
I started to look at dynamic reconfiguration, but after quite a bit of reading I decided that I may not yet be 100 percent ready for this journey, which means I need an alternate strategy.
Discovering FPGAs: Becoming a Clock Wizard
Duane Benson  
10/22/2012   19 comments
There are quite a few basic FPGA features that I still need to learn, and clocking is probably one of the more important. Thankfully, Xilinx has a lot of good tutorials and wizards, including the Clock Wizard.
Discovering FPGAs: Debugging a Motor Driver
Duane Benson  
10/15/2012   19 comments
Changes to a motor driver produced spikes in one of the signals when running the motor forward. Interestingly, the spikes go away when driving the motor in reverse.
Discovering FPGAs: My Logic Analyzer Takes Shape
Duane Benson  
10/8/2012   26 comments
Even if I wasn't on my way to building FPGAs into my robot, I'd find this particular project useful for my MCU projects.
Discovering FPGAs: Building a Two-Stage Synchronizer
Duane Benson  
10/1/2012   21 comments
Duane Benson takes us step by step through his process for building a two-stage synchronizer module for his external inputs.
Discovering FPGAs: Selecting a Syntax
Duane Benson  
9/24/2012   13 comments
I now realize that I didn't have a good understanding of "instantiation" in my head when I wrote my recent Modules in Modules blog. This is somewhat ironic, because instantiation was pretty much the point of the blog.
Discovering FPGAs: Creating a Logic Analyzer
Duane Benson  
9/17/2012   20 comments
I've decided to use the ChipScope virtual logic analyzer to implement a simple real/physical logic analyzer.
Discovering FPGAs: Modules in Modules
Duane Benson  
9/11/2012   16 comments
Duane creates some simple modules and then uses (HDL coders say "instantiates") these modules in a higher-level module.
Discovering FPGAs: Observing Switch Bounce With ChipScope
Duane Benson  
9/3/2012   43 comments
Now we're really "cooking on a hot stove," because we can use ChipScope to observe the effects of physical switch bounce...
Discovering FPGAs: Getting to Grips With ChipScope
Duane Benson  
8/27/2012   14 comments
Having resolved his licensing issues, Duane manages to get the ChipScope virtual logic analyzer up and running, so he can start to observe the signals changing inside his FPGA.
Discovering FPGAs: Alternative Latching Strategies
Duane Benson  
8/20/2012   34 comments
Duane modifies his previous program to latch the value on the 7-segment display while leaving his four-bit counter display running.
Discovering FPGAs: The ChipScope Virtual Logic Analyzer
Duane Benson  
8/13/2012   9 comments
Microprocessor expert Duane Benson is learning about FPGAs from the ground up. In this installment, he takes a look at the ChipScope virtual logic analyzer.
Discovering FPGAs: Driving a 7-Segment Display
Duane Benson  
8/6/2012   28 comments
In this column, Duane adds a binary to seven-segment decoder to the binary counting configuration we've seen previously.
Discovering FPGAs: Adding in the Switches
Duane Benson  
7/30/2012   41 comments
In this column we plug some external switches into our FPGA development board and then use these switches to "Start" and "Stop" the count sequence being displayed on the LEDs.
Discovering FPGAs: Playing With LEDs & Switches
Duane Benson  
7/23/2012   61 comments
Now it's time to start branching out on our own. In this column we will add some switches that we can use to "Start" and "Stop" the count sequence being displayed on the LEDs.
Discovering FPGAs: Loading the .BIT File
Duane Benson  
7/16/2012   28 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan-6-based development board. In this installment, Duane walks us through the process of loading the .BIT configuration file into the FPGA.
Discovering FPGAs: Creating the .BIT File
Duane Benson  
7/9/2012   28 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan-6-based development board. In this installment, Duane walks us through the process of creating the .BIT configuration file.
Discovering FPGAs: Bringing Up the IDE
Duane Benson  
7/2/2012   12 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan-6-based development board. Thus far, Duane has been working in command-line mode. In this issue, he brings up the supplied IDE (integrated development environment) for the first time.
Discovering FPGAs: Adding LEDs & Modifying the Verilog
Duane Benson  
6/25/2012   9 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan 6-based development board. In this issue, Duane modifies the provided tutorial to add two more LEDs to his FPGA development board and Verilog code.
Discovering FPGAs: More About the UCF
Duane Benson  
6/19/2012   11 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan-6-based development board. In this issue, Duane examines the contents of the UCF (user constraint file) in more detail.
Discovering FPGAs: Flashing the LEDs
Duane Benson  
6/11/2012   33 comments
Microcontroller expert Duane Benson learns all about FPGAs using a Xilinx Spartan-6-based development board. In this issue, Duane manages to get the light-emitting diodes (LEDs) on his development board to flash.
Page 1 / 2   >   >>




latest blogs
To celebrate Geek Pride Day, Sylvie Barak has created a mega-cool infographic that depicts how geeks have been building the Internet since 1832.
When traversing serial links with optics or backplanes, high-speed signals are degraded by impairments in the link, such as insertion loss, reflections, crosstalk, and optical dispersion.
Can statistical or heuristic verification really work for FPGA designs?
One of the things I've been wondering is whether or not the "okWireOR" module is really just a giant OR, or if the order in which things are attached matters.
I am shocked and horrified. It appears that those little scamps at Planet Analog are writing blogs pertaining to field-programmable issues.
flash poll
follow us on twitter
follow Xilinx on twitter
like us on facebook
like Xilinx on facebook
All Programmable Planet     About Us     Contact Us     Help     Register     Twitter     Facebook     RSS