Blinking LED with Altera EPM3064 CPLD

  • Posted on: 13 November 2016

FPGA's and CPLD's are certainly very cool devices. It is possible to create you own logical circuits and emulate real hardware chips on the lowest level. For this test project we will use Alera CPLD which is also known as MAX3000A and it's full code is ALTERA  EPM3064ATC44-10. It has a programming capacity of 64 macrocells. A macrocell is the smallest programmable part inside a CPLD. The capacity of 64 is not very large compared for example to Altera Cyclone IV EP4CE6E22C8N FPGA chip which has 6272 logical elements, but it will be suitable for small projects. Certainly enough to create a blinking led.

We will be using Quartus II 13.0.1 Webedition version, which is a free IDE to develop and test your projects. The correct version is important, as it needs to support our MAX3000 device.

To program your Altera device you will need a JTAG programmer as USB Blaster. In this blog I will not cover how to do a full set up or this JTAG programmer, there are plenty of tutorials online. I will only focus on the block diagram and the VHDL code to blink the led.

First we will need to create a new project in Quartus. This can be done by selecting the New Project Wizard in File menu. Specify the directory for your project and the name. In our case it will be blinking_led.

Click next in the step 2 of the wizard and in step 3 select Device family MAX3000A. In the Name filter you need to type in: EPM3064ATC44-10. You will see that this device is powered by 3.3V. Click on Finish and your project will be created.

Create a new file which is of type Block Diagram/Schematic file.

Double click on the canvas and this will pop-up a dialog where you can insert a input and a output pin.

This is how it will look after you have completed the step above. Click ctrl-s (or select File -> Save in the menu). Safe the file as blinking_led.bdf. The program should already suggest that name. Note that it is important to name this file the same as your project, otherwise you will get compiling errors.

Now create a new file and this time select VHDL file. You will get an empty editor window. Paste in the code from below and save the file again as something like clock.vhd. The variable tick will determine how fast your led will blink.

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

entity slow_clock is
    port (
        sysclk:         in     std_logic;
        clk_out:        out     std_logic
    );
end entity slow_clock;

architecture ar_clock of slow_clock is
    signal led_state: std_logic := '0';    
begin
    clock : process(sysclk)
        variable tick : integer := 25000000;
        variable count_clk : integer range 0 to tick;
    begin
    
        if (rising_edge(sysclk)) then
            if (count_clk = tick) then
                count_clk := 0;
                led_state <= not led_state;
            else
                count_clk := count_clk + 1;
            end if;
        end if;
    end process clock;
    
    clk_out <= led_state;

end architecture ar_clock;

Now switch to Files tab (next to the Hierarchy tab in the Project Navigator window) and right click on the clock.vhd file and select Create Symbol Files for Current File. This step is important as it will allow you te add a block diagram of our created clock.

Now close he compilation report tab, go back to your blinking_led.bdf (block diagram file) and double click on the canvas. In the Libraries you will see a new group Project and a new schematic which is called show_clock. Insert it in your block diagram by clicking OK.

Now place it on the canvas and connect the sysclk to the input pin and the clk_out to the output pin. Just like in the screenshot below.

Now start the compilation of the project. (Processing -> Start Compilation or press Ctrl+L). Save any changes if prompted. The compilation should be succesful (with some warnings that can be safely ignored).

The compilation window will show that we have used 59% of the total of all microcells. You can also see that we have used 6 of 34 pins. You may think that this is not true, because we have only used 2. But actually the 4 other pins are reserved for the JTAG programmer.

They are:

  1. TDI (Test Data In)
  2. TDO (Test Data Out)
  3. TCK (Test Clock)
  4. TMS (Test Mode Select)

Now it's time to open the Pin Planner dialog and assign the input and output pins from to physical pin on the chip. This is done by clicking on the Pin Planner icon (or menu Assignments -> Pin planner).

Here you can select pin_name1 (which is our input pin) and assign it to the global clock pin which in our case is PIN_37. The LED on our board is connected to PIN_43, so we select the Location of pin_name2 to this pin.

Now we are going to connect our board to the JTAG programmer and power supply. The JTAG cable does not supply power so we need to provide it from an external source. Without power the board will not program.

I am using this breadboard power supply which has 3.3V option simply be setting the correct jumpers.

On the CPLD board supply the power to those 2 pins in the corner. I have used a multimeter to pinpoint the correct ones. Ground is in the corner pin and +3.3V is just below it. I could not prick in into the breadboard, because the DIP spacing is different (2.0mm), so this is the reason for the 2 wires.

It is time to finilize our project. First we will re-compile it and then go the Programmer dialog, which is located in Tools menu. In this dialog make sure that you have selected the correct JTAG programmer. In my case it is USB-Blaster. Then select the Program/Configure and Verify checkboxes. If you press the [Start] button it will program the EEPROM memory of the CPLD chip.

You should get a green 100% bar and the led on your board should start blinking.

I hope this small test project will encourage you to play around with FPGA and CPLD devices. If you have any questions don't hesitate to contact me.

 

Tags: 
Category: