Программируемые логические интегральные схемы плис. Что такое плис и зачем они нужны

Altera-Cyclone and Arduino

Суть вопроса. Разница между ПЛИС и микроконтроллером

Каждый начинающий микропрогер на определенном этапе своего развития задается вопросом в чем же разница между ПЛИС (фирм Altera или Xilinx) и микроконтроллером (микропроцессором)?

Читаешь форумы — знатоки дела пишут, что это совершенно разные вещи, которые нельзя сравнить, аргументируя это тем, что у них разная архитектура . Читаешь мануал по Verilog или C++ — и тот и другой используют похожие операторы со схожим функционалом, даже синтаксис похож, а почему разные? Заходишь на марсоход — там светодиодами (или даже просто лампочками) с помощью FPGA моргают, смотришь проекты на Arduino — там роботами управляют. СтОп!

А вот теперь остановимся и спросим себя: почему с ПЛИС — тупо лампочка, а Ардуино — умно робот? Ведь и первый и второй вроде как программируемое устройство, неужели у ПЛИС возможностей для робота не хватает?

В какой-то степени суть вопроса «В чем разница между ПЛИС и микроконтроллером ?» раскрывается именно на таком примере.

Отметим сразу. Функционал ПЛИС изначально не уступает микроконтроллеру (и микропроцессору, кстати, тоже), точнее — основные функции у одного и второго по сути идентичны — выдавать логические 0 или 1 при определенных условиях, а если говорить о быстродействии, количестве выводов(ножек) и возможностях конвейерной обработки, то микроконтроллеру до ПЛИС а вообще далеко. Но есть одно «но». Время на разработку одного и того же программного алгоритма на двух разных устройствах (ПЛИС и микроконтроллер ) различается в разы, а то и в десятки раз. Именно ПЛИС здесь в 99% случаев сильно уступает МК. И дело вовсе не в замороченности языков Verilog , VHDL или AHDL , а в устройстве самой ПЛИС .

О взаимодействии программного языка с архитектурой ПЛИС и микроконтроллера

FPGA : в ПЛИС и нет сложных автоматизированных цепочек(делающих часть работы за вас). Есть только железные проводные трассы и магистрали, входы, выходы, логические блоки и блоки памяти. Среди трасс есть особый класс — трасса для тактирования(привязанная к определенным ножкам, через которые рекомендуется проводить тактовую частоту).

Основной состав:

Трасса — металл, напаянный на слои микросхемы, является проводником электричества между блоками.

Блоки — отдельные места в плате, состоящие из ячеек. Блоки служат для запоминания информации, умножения, сложения и логических операций над сигналами вообще.

Ячейки — группы от нескольких единиц до нескольких десятков транзисторов.

Транзистор — основной элемент ТТЛ логики.

Выводы (ножки микросхемы) — через них происходит обмен ПЛИС с окружающим миром. Есть ножки специального назначения, предназначенные для прошивки, приема тактовой частоты, питания, а так же ножки, назначение которых устанавливаются пользователем в программе. И их, как правило, гораздо больше, чем у микроконтроллера .

Тактовый генератор — внешняя микросхема, вырабатывающая тактовые импульсы, на которых основывается большая часть работы ПЛИС .

Архитектура ПЛИС. Взаимосвязь составляющих элементов

Трассы подключаются к блокам с помощью специальных КМОП-транзисторов. Эти транзисторы способны сохранять свое состояние(открытое или закрытое) на протяжении длительного периода времени. Изменяется состояние транзистора при подаче сигнала по определенной трассе, которая используется только при программировании ПЛИС . Т.е., в момент прошивки осуществляется именно подача напряжения на некоторый набор КМОП-транзисторов. Этот набор определяется прошивочной программой. Таким образом происходит сложное построение огромной сети трасс и магистралей внутри ПЛИС , связывающей сложным образом между собой огромное количество логических блоков. В программе вы описываете какой именно алгоритм нужно выполнять, а прошивка соединяет между собой элементы, выполняющие функции, которые вы описываете в программе. Сигналы бегают по трассе от блока к блоку. А сложный маршрут задается программой.

Архитектура ПЛИС (FPGA)

Архитектура Микроконтроллера

В этом элементе ТТЛ логики все операции по обработкам отдельных сигнальчиков проводятся независимо от вас. Вы лишь указываете что делать с тем или иным набором принятых сигналов и куда выдавать те сигналы, которые нужно передать. Архитектура микроконтроллера состоит совсем из других блоков, нежели ПЛИС . И связи между блоками осуществляются по постоянным магистралям(а не перепрошиваемым). Среди блоков МК можно выделить основные:

Постоянная память (ПЗУ) — память, в которой хранится ваша программа. В нее входят алгоритмы действий и константы. А так же библиотеки(наборы) команд и алгоритмов.

Оперативная память (ОЗУ) — память, используемая микроконтроллером для временного хранения данных(как триггеры в ПЛИС ). Например, при вычислении в несколько действий. Допустим, нужно умножить первое пришедшее число на второе(1-е действие), затем третье на четвертое(2 действие) и сложить результат(3 действие). В оперативную память при этом занесется результат 1 действия на время выполнения второго, затем внесется результат 2 действия. А затем оба этих результата пойдут из оперативной памяти на вычисление 3 действия.

Процессор — это калькулятор микроконтроллера . Он общается с оперативной памятью, а так же с постоянной. С оперативной происходит обмен вычислениями. Из постоянной процессор получает команды, которые заставляют процессор выполнять определенные алгоритмы и действия с сигналами на входах.

Средства (порты) ввода-вывода и последовательные порты ввода-вывода — ножки микроконтроллера , предназначенные для взаимодействия с внешним миром.

Таймеры — блоки, предназначенные для подсчета количества циклов при выполнении алгоритмов.

Контроллер шины — блок, контролирующий обмен между всем блоками в микроконтроллере . Он обрабатывает запросы, посылает управляющие команды, организовывает и упорядочивает общение внутри кристалла.

Контроллер прерываний — блок, принимающий запросы на прерывание от внешних устройств. Запрос на прерывание — сигнал от внешнего устройства, информирующий о том, что ему необходимо совершить обмен какой-либо информацией с микроконтроллером .

Внутренние магистрали — трассы, проложенные внутри микроконтроллера для информационного обмена между блоками.

Тактовый генератор — внешняя микросхема, вырабатывающая тактовые импульсы, на которых основывается вся работа микроконтроллера .

Взаимосвязь составляющих блоков микроконтроллера

В микроконтроллере , в отличии от ПЛИС , работа происходит между вышеперечисленными блоками, имеющими сложную архитектуру , облегчающую процесс разработки программ. При прошивке вы изменяете только постоянную память, на которую опирается вся работа МК.

Основное отличие ПЛИС и микроконтроллера

ПЛИС прошивается на уровне железа, практически по всей площади кристалла. Сигналы проходят через сложные цепочки транзисторов. Микропроцессор же прошивается на уровне программы для железа, сигналы проходят группами, от блока к блоку — от памяти к процессору, к оперативной памяти, от оперативной к процессору, от процессору к портам ввода-вывода, от портов ввода-вывода к оперативной памяти, от оперативной памяти… и так далее. Вывод: за счет архитектуры ПЛИС выигрывает в быстродействии и более широких возможностях конвеерной обработки, МК выигрывает в простоте написания алгоритмов. За счет более простого способа описания программ, фантазия разработчика Микроконтроллера менее скованна временем на отладку и разработку, и, таким образом, время на программирование того же робота на МК и ПЛИС будет отличаться во многие и многие разы. Однако робот, работающий на ПЛИС будет гораздо шустрее, точнее и проворнее.

Железо и программа.

В ПЛИС всю работу нужно делать самому, вручную: для того, чтобы реализовать какую-либо программу на ПЛИС , нужно отследить каждый сигнальчик по каждому проводку, приходящему в ПЛИС , расположить какие-то сигнальчики в ячейки памяти, позаботиться о том, чтобы в нужный момент именно к этим ячейкам памяти обратился другой сигнальчик, который вы так же отслеживаете или даже генерируете, и в итоге набор сигнальчиков, задержанный в памяти задействовал нужный вам сигнальчик, который, например, пойдет на определенную выходную ножку и включит светодиодик, который к ней подключен. Часть сигнальчиков идет не в память, а например на запуск определенной части алгоритма(программы). То есть, говоря языком микропрогера, эти ножки являются адресными. Например, имеем на нашей плате в нашей программе три адресные ножки для включения неких не связанных(или связанных) друг с другом алгоритмов, которые мы реализовали на языке Verilog в ПЛИС . Также в программе, кроме трех адресных ножек, у нас есть еще например 20 информационных ножек, по которым приходит набор входных сигнальчиков(например с разных датчиков) с какой-либо информацией (например температура воды в аквариуме с датчика температуры воды в аквариуме). 20 ножек = 20 бит. 3 ножки -3 бита. Когда приходит адресный сигнал 001(с трех ножек адреса) — запускаем первый алгоритм, который записывает 20 информационных сигнальчиков в 20 ячеек памяти(20 триггеров), затем следующие 20 сигнальчиков умножаем на полученные ранее 20, а результат умножения записываем в память, а потом отсылаем по другим ножкам например в терморегулятор воды в аквариуме. Но Отошлем мы этот результат только тогда, когда на наши адресные ножки придет код например 011 и запустит алгоритм считывания и передачи. Ну, естественно «отсылаем», «считываем» и еще что-то прописываем в ручную. Ведем каждый сигнальчик в каждый такт работы ПЛИС по определенному пути, не теряем. Обрабатываем или записываем. Складываем или умножаем. Не забываем записать. Не забываем принять следующий сигнал и записать в другие триггеры. Еще добавьте сюда работу, привязанную к тактовой частоте, синхронизацию (которая так же реализуется вручную), неизбежные ошибки на этапах разработки и отладки и кучу других проблем, которые в данной статье рассматривать просто бессмысленно. Трудно. Долго. Но зато на выходе работает супер оперативно, без глюков и тормозов. Железно!

Теперь микроконтроллер . 20 ножек на прием информации — для большинства микроконтроллеров физически невозможная задача. А вот 8 или 16 — да пожалуйста! 3 информационных — в легкую! Программа? По адресу 001 умножить первое пришедшее число на второе, по адресу 011 отсылай результат в терморегулятор. Все! Быстро. Легко. Не супер, но оперативно. Если очень грамотно написать программу- без глюков и тормозов. Программно!

Железо и Программа! Вот главное отличие между ПЛИС и Микроконтроллером .

В микроконтроллере большинство замороченных, но часто используемых алгоритмов уже вшиты железо(в кристалл). Нужно лишь вызвать программным способом нужную библиотеку, в которой этот алгоритм хранится, назвать его по имени и он будет делать всю грязную работу за вас. С одной стороны это удобно, требует меньшего количества знаний о внутреннем устройстве микросхемы. Микрик берет на себя заботу об отслеживании принятых, генерируемых и результирующих сигналов, об их складировании, обработке, задержке. Все делает сам. В большинстве микропрогерских задач это то, что нужно. Но если безграмотно использовать все эти удобства, то возникает вероятность некорректной работы. Железо и Программа!

Заключение

Современные разработчики процессоров и микропроцессоров изначально разрабатывают свои устройства на ПЛИС . Да-да, вы правильно догадываетесь: сначала они имитируют создаваемую архитектуру микроконтроллера с помощью разработки и прошивки программы на ПЛИС , а затем измеряют скорость выполнения алгоритмов при том или ином расположении имитируемых блоков МК и том или ином наборе функционала каждого блока отдельно.

По характеристикам выдаваемого сигнала, ПЛИС чаще всего рассчитана на 3,3В, 20мА, Микроконтроллер на 5В, 20мА.

Под микроконтроллер AVR, успешно внедренный в платформу Arduino, написано множество открытых программ, разработано великое множество примочек в виде датчиков, двигателей, мониторчиков, да всего, чего только душе угодно! Arduino в настоящее время больше похож на игровой конструктор для детей и взрослых. Однако не стоит забывать, что ядро этого конструктора управляет «умными домами», современной бытовой электроникой, техникой, автомобилями, самолетами, оружием и даже космическими аппаратами. Несомненно, такой конструктор будет являться одним из лучших подарков для любого представителя сильной половины человечества.

В принципе, все просто!

Остались вопросы? Напишите комментарий. Мы ответим и поможем разобраться =)

Недавно я все-таки сделал свой первый шаг к ПЛИС и призвал вас за собой . Мое фанатическое увлечение ПЛИС и идея о том, что ПЛИС является лучшей платформой для создания любых устройств приобрела религиозный характер. Моя секта ПЛИСоводов проповедует полный отказ от микроконтроллеров, а особо экстремистская ветвь проповедует отказ не только от софт процессоров , но и вообще от последовательных вычислений!

Как всегда, постижению истин помогло решение реальных задач. В сегодняшней проповеди я хотел бы рассказать об испытаниях, которые выпадают на долю молодого ПЛИСовода. Преодолевая испытания мы постигаем истину. Но остаются вопросы, на которые я не нашел ответов. Поэтому я бы очень хотел, чтобы братья-хабровчане - ПЛИСоводы с опытом, поучаствовали в обсуждении, протянули руку помощи своим младшим собратьям.

Эта статья для новичков. В ней я опишу типичные проблемы, вопросы, заблуждения, ошибки, которые могут появиться в самом начале обучения (потому что они появились у меня). Однако, контекст статьи ограничен тем, что разработка ведется на ПЛИС от Altera в среде Quartus на языке Verilog .

Трудно жить ничего не делая, но мы не боимся трудностей!

Одна из причин, по которой многие не начинают изучать Verilog вот прямо сейчас - это отсутствие реальной ПЛИС. Кто-то не может заказать, потому что дорого, а кто-то потому, что не знает, что именно взять (вопрос выбора рассмотрен в предыдущей статье). Кому-то ПЛИС пока еще едет по почте.

Но в своих разработках я пришел к тому, что наличие реальной ПЛИС мне требуется уже на финальном этапе разработки, когда нужно протестировать проект «в железе». Речь о том, что бóльшую часть времени я провожу в отладке своего кода с помощью симуляторов.

Поэтому мой совет: отсутствие ПЛИС - это не повод бездействовать. Пишите и отлаживайте модули для ПЛИС в симуляторах!

Симулятор для Verilog

Итак, чем же развлечь себя скучными длинными рабочими днями (если они таковыми являются)? Конечно же освоеним ПЛИС! Но как же затащить на работу целую среду разработки от Altera, если она весит 3 ежемесячных рабочих лимита интернета? Можно принести на флешке! Но если предметом изучения является Verilog, то можно ограничиться блокнотом, компилятором IcarusVerilog, а результат смотреть в GTK Wave.

Попробовать прямо сейчас

Для начала работы в среде Windows, достаточно скачать по ссылке http://bleyer.org/icarus/ файл установки iverilog-20130827_setup.exe (development snapshot)

Установка трудностей не вызывает. Теперь немного забежим вперед: создадим папку для проекта и в ней пару файлов с пока что не понятным содержимым:

Файл-модуль с кодом для тестирования модулей - bench.v

`timescale 1ns / 100 ps module testbench(); reg clk; initial begin $display("start"); $dumpfile("test.vcd"); $dumpvars(0,testbench); clk <= 0; repeat (100) begin #10; clk <= 1; #10; clk <= 0; end $display("finish"); end

В файле bench.v описан тестовый модуль testbench, в нем создан тестовый источник сигнала clk (меандр). Другие модули будут создаваться в отдельных файлах, либо логику можно протестировать сначала в этом модуле, а потом вынести в отдельный модуль. Потом в модуль testbench будут добавляться экземпляры этих модулей, где мы будем подавать на их входы тестовые сигналы и получать из них результаты. Из модулей мы можем строить иерархию, думаю это понятно всем.

BAT Файл, который скомпилирует и просимулирует главный модуль, добавив другие модули из текущей папки - makev.bat

iverilog -o test -I./ -y./ bench.v vvp test pause

После запуска этого файла мы увидим на экране текст, заданный в $display (это отладочный вывод), значение же сигналов и регистров схемы будут находиться в файле test.vcd. Кликаем по файлу и выбираем программу для просмотра - GTKWave (в моем случае D:\iverilog\gtkwave\bin\gtkwave.exe). Еще пару кликов и мы увидим наш clk.

Практически, каждый свой новый модуль я создаю в блокноте и отлаживаю IcarusVerilog. Следующим этапом после такой отладки идет проверка модулей в Quartus. Хотя в Quartus тоже есть свой симулятор, но я его использую реже. Причина в простоте обновления кода и просмотра результата в IcarusVerilog: сохранил изменения в файле, запустил BAT, нажал кнопку «обновить» в GTKWave - все! В ModelSim для этого требуется чуть больше движений, но он тоже не плох, особенно на данных сложных структур.

После симуляции наступает пора запуска Quartus. Но загружать прошивку в ПЛИС пока еще рано. Нужно убедиться, что божественная вычислительная машина правильно поняла, какую схему мы хотим получить, изложив свои мысли в виде Verilog"а.

Разница между симуляцией и работой в реальном железе

Первое время я, подобно слепому котенку, бился головой об косяки. Казалось бы правильный код, не работает совсем, либо работает не так, как предполагаешь. Либо вот только что работал, а теперь внезапно перестал!

Пытливый котенок, начинает искать взаимосвязь между своими действиями и результатом («голубиное суеверием»).

Самая большая драма

Ниже будет список странностей, но сначала самая большая драма, с которой я столкнулся: не все конструкции Verilog могут быть синтезированы в железе . Это связано с тем, что на Verilog описывается не только аппаратная логика, которая объединяется в модули и работает в железе. На том же Verilog описываются тестовые модули, которые объединяют тестируемые модули, подают на их входы тестовые сигналы и в целом существуют только для проверки на компьютере. Изменение значений сигналов во времени задается конструкциями, содержащим знак "#" в тексте Verilog. Такой знак означает задержку во времени. В примере выше именно так генерируется сигнал CLK. И я грешным делом думал, что таким же образом внутри настоящей ПЛИС можно генерировать, к примеру, последовательность бит для отправки сообщения по RS232. Ведь на вход ПЛИС подан сигнал от генератора 50 МГц! Может быть она как-то на него ориентируется. Как оказалось, я не единственный, кто надеялся на чудо: , , , , . Реальность как всегда оказывается более суровой: ПЛИС это набор логики и временная задержка в ней может появиться при использовании счетчика, значение которого увеличивается тактами от генератора до заданной величины, либо как-то иначе (но всегда аппаратно).

Список найденных странностей

Удивительные вещи, однако, прочтение книг проливает свет на эту бесовщину. Более того, обретается благодать.

Если обозначить reg, то не факт, что он будет создан

Как я пришел к проблеме? Допустим есть один модуль, на вход которого я должен подавать значение (по типу параметра). В перспективе, этот параметр должен будет изменяться во времени в зависимости от каких-то внешних событий. Поэтому значение должно хранится в регистре (reg). Но реализация приема внешних событий пока не реализована, поэтому я регистр не меняю, а просто задаю ему изначальное значение, которое в дальнейшем не меняется.

//задаю 8 битный регистр reg val; //инициирую его значением initial val <= 8"d0240; //wire к которому подключим выход из модуля wire out_data; //неведомый модуль, называется bbox //экземпляр этого модуля называется bb_01 //будем считать, что в модуле есть входной порт in_data и выходной out_data //во входной порт подаем значение с регистра val, а выход подключаем к wire - out_data bbox bb_01(.in_data(val), .out_data(out_data));
Казалось бы в чем подвох? В императивных ЯП мы часто задаем переменные в качестве констант и потом ни разу их не меняем и все работает. Что же мы видим в железе?


Во-первых, мы не видим регистра. Во-вторых, на вход модуля подано 8"hFF вместо наших 8"d0240! И этого уже достаточно для того, чтобы схема заработала не так, как мы планировали. То, что регистра нет - это нормально. В Verilog можно описывать логику разными способами, в то же время, синтезатор всегда оптимизирует аппаратную реализацию. Даже если написать блок always и в нем работать с регистрами, но при этом выходное значение всегда будет определяться входными, то применение регистра тут окажется лишним и синтезатор его не поставит. И наоборот, если при каких то значениях входных данных выходное значение не меняется, то тут никак не обойтись без регистра-защелки и синтезатор его создаст. (Книга 1 стр. 88-89). Что из этого следует? Если мы начнем менять значение регистра, например, в зависимости от нажатии кнопок, то геристр уже будет создан и все будет работать так, как нужно. Если же окажется, что кнопки ничего не меняют, то синтезатор его опять же выкинет и опять все поломается. Что же делать с константой? Нужно подать ее напрямую на вход модуля:

Bbox bb_01(.in_data(8"d0240), .out_data(out_data));
Теперь на входе модуля мы имеем правильное значение:

Остается загадкой, почему при сокращении регистра, его значение в initial не подставляется на вход модуля.

Размерность wire лучше задавать самому.

При разработке в среде Quartus, допускается не задавать линии wire заранее. В этом случае они будут созданы автоматически, но об этом будет выдано предупреждение (warning). Проблема заключается в том, что разрядность wire будет 1-бит, а если порты будут иметь разрядность больше 1 бита, то значение не будет передано.

Bbox bb_01(.in_data(8"d0240), .out_data(int_data)); other_bbox bb_02(.in_data(int_data), .out_data(out_data));
Предупреждение
Warning (10236): Verilog HDL Implicit Net warning at test.v(15): created implicit net for "int_data"
Результат:

Как видим, один бит подключен, а остальные 7 бит получаются не подключены (NC). Чтобы такой проблемы не было - нужно создать wire самостоятельно. Не зря компилятор IcarusVerilog выдает не warning, а ошибку, если wire не задан заранее.

Wire int_data; bbox bb_01(.in_data(8"d0240), .out_data(int_data)); other_bbox bb_02(.in_data(int_data), .out_data(out_data));

Компьютер не будет лазать по модулям, смотреть, какая разрядность портов. К тому же, разрядность может оказаться разной, а на вход модуля или с выхода берутся не все биты, а какие-то определенные.

Нельзя использовать выход логической функции, в качестве тактового сигнала

Иногда в проекте требуется снизить тактовую частоту, либо ввести временную задержку в N тактов. Новичёк может применить счетчик и дополнительную схему определения достижения счетчиком определенного значения (схема сравнения). Однако, если напрямую использовать выход со схемы сравнения в качестве тактового, то могут возникнуть проблемы. Это связано с тем, что логической схеме требуется некоторое время для установки стабильного значения на выходе. Эта задержка смещает фронт сигнала, проходящего через разные части логической схемы относительно тактового, в итоге получаются гонки, метастабильность, асинхронщина. Даже довелось однажды услышать реплику об этом в качестве критики ПЛИС: «с ПЛИС постоянные проблемы - гонки сигналов».

Если прочитать хотя бы парочку статей:
Метастабильность триггера и межтактовая синхронизация
Пару слов о конвейерах в FPGA

То становится ясно, каким образом разрабатываются устройства на ПЛИС: вся задача делится на аппаратные блоки, а данные между ними движутся по конвеерам, синхронно защелкиваясь в регистрах по тактовому сигналу. Таким образом, зная общую тактовую частоту, синтезатор рассчитывает максимальную частоту работы всех комбинаторных схем, определяет, укладывается ли их скорость к период такта и делает вывод - будет или не будет работать схема в ПЛИС. Все это происходит на этапе синтеза. Если схемы укладываются в параметры, то можно прошивать ПЛИС.

Таким образом, для разработчиков устройств на базе ПЛИС созданы все необходимые методологии, и если их придерживаться, то проблем не будет.

А что, если я хочу пойти против системы?

Порядок разработки и поведение синтезатора схем подводит нас к выводу о том, что же такое ПЛИС на аппаратном уровне. Это синхронные схемы. Поэтому, среди целей синтезатора - уложиться во временные интервалы. Для этого он, к примеру, упрощает логические выражения, выбрасывает из синтеза части схем, которые не используются другими схемами и не привязаны к физическим выводам ПЛИС. Асинхронные решения и аналоговые трюки не приветствуются, потому что их работа может быть непредсказуемой и зависеть от чего угодно (напряжение, температура, техпроцесс, партия, поколение ПЛИС), а поэтому не дает гарантированного, повторяемого, переносимого результата. А всем же нужен стабильный результат и общие подходы к проектированию!

Но что же делать, если вы не согласны с мнением синтезатора о том, что нужно выкидывать неизменяемые регистры, сокращать логические схемы? Как быть, если хотите делать схемы с асинхронной логикой? Нужна тонкая настройка? А может быть вы сами хотите собрать схему на низкоуровневых компонентах ПЛИС? Легко! Спасибо разработчикам Altera за такую возможность и подробную документацию!

Как это сделать? Можно попробовать графический редактор схем. Вы, возможно, слышали о том, что Quartus позволяет рисовать схемы? Можно самому выбрать стандартные блоки и соединить их. Но это не решение! Даже нарисованная схема будет оптимизирована синтезатором, если на это будет возможность.

В итоге мы приходим к старой истине: если ничего не помогает - прочитайте инструкцию . А именно «Altera Handbook» часть под названием «Quartus II Synthesis Options» .

Начнем с того, что описывая архитектуру на Verilog определенным образом, можно получить определенный результат. Вот примеры кода для получения синхронного и асинхронного RS триггера:

//модуль синхронного RS триггера module rs(clk, r, s, q); input wire clk, r,s; output reg q; always @(posedge clk) begin if (r) begin q <= 0; end else if (s) begin q <= 1; end end endmodule
В этом случае получится синхронный триггер.

Если не брать во внимание тактовый сигнал и переключаться в зависимости от любых изменений r и s, то в результате получится элемент с асинхронной установной значений - защелка (latch).

//пример модуль асинхронного RS триггера module ModuleTester(clk, r, s, q); input wire clk, r,s; output reg q; always @(r or s) begin if (r) begin q <= 0; end else if (s) begin q <= 1; end end endmodule

Module ModuleTester(clk, r, s, q); input wire clk, r,s; output reg q; DLATCH lt(.q(q), .clrn(~r), .prn(~s)); endmodule

В итоге, весь «обвес» на входе защелки, который синтезатор посчитал нужным, исчезнет и мы получим именно то, что хотели:

Список существующих примитивов можно посмотреть на сайте Altera.

А теперь небольшой пример про асинхронность и сокращение. Задумал я, к примеру, сделать генератор по тому же принципу, как это было принято делать раньше, но только на ПЛИС:

Но для увеличения периода я возьму 4 элемента, но только один из них будет с инверсией:

Module ModuleTester(q); output wire q; wire a,b,c,d; assign a = b; assign b = c; assign c = d; assign d = ~a; assign q = a; endmodule

Но получается сокращение (1 элемент, вместо четырех). Что логично. Но мы то задумывали линию задержки.

Но если поставить синтезатору условие, что линии a,b,c,d не сокращать, то получится то, что мы задумали. Для подсказки синтезатору применяются директивы . Один из способов указания - это текст в комментарии:

Module ModuleTester(q); output wire q; wire a,b,c,d /* synthesis keep */; // ^^^--- это директива для синтезатора assign a = b; assign b = c; assign c = d; assign d = ~a; assign q = a; endmodule
А вот и результат - цепочка из четырех элементов:

И это далеко не все! Оставлю на радость самостоятельного изучения: работу с case и директиву для реализации его в качестве RAM/ROM или логической схемой; работу со встроенными блоками памяти (RAM/ROM); выбор реализации умножения - аппаратным умножителем или логической схемой.

Начну свою первую статью с того, что сообщу: в предмете статьи я сам новичок, но выбрал именно такую тему. Объясню почему. Читаю хабр уже достаточно долго и мне всегда были интересны топики тех, кто сам в настоящий момент изучает то, о чем повествует. Такие статьи всегда понятны, всегда находят свою аудиторию и всегда предают читающему интерес и энтузиазм автора, который у новичков в любой области обычно зашкаливает!

ПЛИС (Программируемая логическая интегральная схема) – один из видов электронных устройств, применяемый для реализации различных логических устройств самой разной сложности, от двоичных счетчиков, несложных логических схем (замены стандартных интегральных схем - рассыпухе) до специализированных процессоров и нейрочипов.

С назначением разобрались, вопрос – как? Внутри ПЛИС находятся некие базовые элементы, которые соединяются на основе конфигурационной записи. Возможные базовые элементы, вид и место хранения конфигурационной записи зависят от вида ПЛИС и от конкретной модели. В современных ПЛИС выделяют два вида: CPLD и FPGA, уделим им по абзацу.

CPLD (complex programmable logic device - сложные программируемые логические устройства) - ПЛИС, базовыми элементами которой являются макроячейки и простые логические вентили (И(-НЕ)/ИЛИ(-НЕ)). Обычно содержит меньше базовых элементов, чем FPGA, но является более быстродействующей. Также обычно содержит энергонезависимую конфигурационную память прямо на кристалле, но имеет ограниченное число циклов конфигурирования.

FPGA (field-programmable gate array - Программируемая пользователем вентильная матрица) – ПЛИС, которые обычно имеют целый букет видов базовых блоков, это и настраиваемые логические элементы (таблицами истинности) и блоки сложения-умножения (Digital signal processing - DSP) и PLL (Phase-Locked Loop) для деления и умножения частоты и некоторые другие в зависимости от модели. Обычно имеют энергозависимую внутреннюю память и функционал для загрузки конфигурации с внешней энергонезависимой памяти.

Определения этих видов ПЛИС и разницы между ними можно встретить самые различные, как в книгах, так и в интернете. Поэтому не стоит зацикливаться на этой разнице, производители сами классифицируют выпускаемые ими ПЛИС. Если вы не запомнили аббревиатур или не поняли значений некоторых слов – не страшно, главное чтобы появилось общее понятие о ПЛИС, надеюсь я этого добился. А теперь к практике!

Начнем с обсуждения инструментов. Я буду пользоваться стартовым набором разработчика Altera Cyclone II FPGA Starter Board, это готовая плата, на которой установлена FPGA серии Cyclone II – EP2C20F484C7N, а также различная периферия и интерфейсы. В этой статье мы используем светодиоды и семисегментные индикаторы. Мы не будем использовать никаких специальных блоков данной серии FPGA, поэтому при желании вы можете использовать почти любую другую ПЛИС (FPGA и CPLD).

Сильно заинтересовавшиеся могут купить себе один из наборов разработчика или самим собрать устройство, что является достаточно сложной для новичка, но вполне выполнимой задачей. Схемы программаторов и схемы подключения самих ПЛИС легко гуглятся, к тому же, кто ранее занимался любительской прошивкой AVR, может обнаружить у себя подходящий программатор Altera Byte Blaster. В общем, схемную реализацию я предоставляю тебе хабраюзер (В конце статьи схема моей Starter Board). Кто хочет попробовать без денежных затрат и увидеть результат работы – можно использовать встроенный в Quartus II симулятор (в этой статье работа с ним не описана).

Из ПО мы будем использовать Quartus II, free версию которого вы сможете найти на сайте производителя (Altera), как в Windows, так и в Linux вариантах.

И вот мы подошли к практике вплотную! Запускаем наш САПР Quartus II и создаем проект. Первыми шагами визарда указываем имя проекта и его место дислокации, затем пропустим шаг добавления файлов (еще успеем). Закончим создание проекта на этапе выбора устройства, если делаем на железяке – точно знаем имя ПЛИС, его и выбираем. Если просто делаем проект для ПЛИС выберем что-нибудь помощней, например третий циклон. Я же выбираю FPGA которая установлена в моем стартер ките.

Жмем Finish – проект создан. Структура проекта в Quartus – иерархическая, нам необходимо выбрать верхушку иерархии (Top-Level Entity). Мы можем использовать для проектирования схемные файлы и файлы с описанием логики на одном из HDL (Hardware description language – язык описания аппаратуры). Мое мнение – наглядней всего в качестве верхушки иерархии использовать схемный файл с основными блоками логики, а сами блоки реализовывать на HDL. Мнения могут быть разными, пока выбирал, прочитал немало холиварных тем, но остановился пока на такой модели, вы можете сделать свой выбор. В качестве HDL языка проекта я выбрал VHDL ((Very high speed integrated circuits) Hardware Description Language), вы можете использовать любой другой, например Verilog или AHDL, все зависит от ваших предпочтений.

Создаем наш первый файл проекта (File – New..) выбираем Block Diagram/Schematic File. Теперь давайте нарисуем простейшую схему, добавим один Input, один Output и соединим их (в реальной ПЛИС эта схема будет передавать сигнал с одной ножки на другую). Для этого Double Click на пустом месте схемы и в открывшемся диалоге Symbol выбираем необходимый элемент.

Соединяем просто так, линией. Дадим пинам имена (Double Click по элементам), input назову CLOCK_27, а output назову LEDR. Имена выбраны не случайно – CLOCK_27 я затем ассоциирую с входом генератора 27Mhz, а LEDR с нулевым красным светодиодом. Сохраняем файл, оставив галочку добавления в проект. Теперь установим полученный файл вершиной иерархии проекта. Для этого окне Project Navigator, во вкладке Files, в контекстном меню нашего файла выбираем Set as Top-Level Entity. Hello, world готов. Компилируем проект (Processing – Start Compilation), если видим Info: Quartus II Full Compilation was successful. – радуемся и считаем, что первый этап пройден.

Теперь разберемся с нашими целями. Наше устройство будет при включении питания начинать отсчет минут и часов. Значит нам понадобится четыре семисегментных индикатора «ЧЧ: ММ». Для отсчета времени нам нужен более-менее точный сигнал 1Hz. Его мы получим путем деления частоты 27Mhz, затем мы будем отсчитывать его на 60 (секунды), потом еще раз на 60 (минуты), а потом на 24 (часы). С последних двух блоков двоичное число минут и часов будет поступать на декодер Bin -> BCD (binary-coded decimal) -> 7seg. Вот, в общем, и все устройство. Сразу оговорюсь, что схема будет асинхронная (Минуты заводятся от секунд, а часы от минут), для простоты и наглядности.

Итак, создадим наш первый блок - блок деления частоты. Создадим новый файл, как мы уже умеем, только тип файла будет VHDL File. Вставим в него код:

Library ieee;
use ieee.std_logic_1164.all;

Entity Div_27Mhz_to_1Hz is
port(clk:in std_logic; clk_out:out std_logic);
end Div_27Mhz_to_1Hz;

Architecture div_behavior of Div_27Mhz_to_1Hz is
begin
process(clk)
variable cnt: integer range 0 to 27000000;
begin
then

If(cnt >= 13500000)
then
clk_out <= "1";
else
clk_out <= "0";
end if;

If(cnt = 27000000)
then
cnt:= 0;
else
cnt:= cnt + 1;
end if;

End if;
end process;
end div_behavior;

Пропущу служебные директивы (можно посмотреть в справочнике, ссылки в конце), уделю внимание только логике работы. Вначале мы объявляем сущность, т.е. сам блок. Указываем его входы и выходы, их типы и имена. Тип std_logic в простонародье значит бит. Далее мы описываем внутреннюю архитектуру этого блока. Архитектура состоит из параллельных процессов. Каждый процесс имеет свой список чувствительности, например единственный процесс в примере выше чувствителен к изменениям на входе clk. Для процесса можно объявить переменные, в нашем примере это переменная типа integer range 0 to 27000000. Далее в теле процесса задается элементарная логика: пока не прошла половина периода - пихаем в выход логический ноль, как половина прошла – пихаем единицу, при этом не забываем считать и обнулять счетчик по достижению 27000000. На идеальный код не претендую – пока учусь, буду рад поправкам:)

Сохраняем файл с кодом и создаем символ (File – Create/Update – Create Symbol Files For Current Files), это необходимо для того чтобы вставить данный блок в нашу главную схему. Найти свои символы можно в папке Project в диалоге вставки символа. Теперь пробежимся по остальным блокам менее подробно.

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

Entity cnt_0_to_59 is
port(clk:in std_logic; c59:out std_logic; vector:out std_logic_vector(5 downto 0));
end cnt_0_to_59;

Architecture cnt_behavior of cnt_0_to_59 is
begin
process(clk)
variable cnt: integer range 0 to 59;
begin
if(clk"event and clk = "1")
then
if(cnt = 59)
then
cnt:= 0;
c59 <= "1";
vector <= CONV_STD_LOGIC_VECTOR(cnt, 6);
else
cnt:= cnt + 1;
c59 <= "0";
vector <= CONV_STD_LOGIC_VECTOR(cnt, 6);
end if;
end if;
end process;
end cnt_behavior;

Это блок счета от нуля до 59, который мы используем для счета минут и секунд. Из новинок тут тип выхода std_logic_vector(5 downto 0), который определяет группу битов (битовый вектор), а также функция CONV_STD_LOGIC_VECTOR(cnt, 6), которая преобразует переменную в битовый вектор указанной длины.

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

For CONV_STD_LOGIC_VECTOR:
use ieee.std_logic_arith.all;

Entity cnt_0_to_23 is
port(clk:in std_logic; vector:out std_logic_vector(4 downto 0));
end cnt_0_to_23;

Architecture cnt_behavior of cnt_0_to_23 is
begin
process(clk)
variable cnt: integer range 0 to 23;
begin
if(clk"event and clk = "1")
then
if(cnt = 23)
then
cnt:= 0;
vector <= CONV_STD_LOGIC_VECTOR(cnt, 5);
else
cnt:= cnt + 1;
vector <= CONV_STD_LOGIC_VECTOR(cnt, 5);
end if;
end if;
end process;
end cnt_behavior;

Выше счетчик часов. Ничего нового.

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

For CONV_STD_LOGIC_VECTOR:
use ieee.std_logic_arith.all;

Entity bin2bcd_5bit is
port(bin:in std_logic_vector(4 downto 0);
bcd1:out std_logic_vector(3 downto 0);
bcd10:out std_logic_vector(3 downto 0)
);

End bin2bcd_5bit;

Architecture converter_behavior of bin2bcd_5bit is
begin
process(bin)
variable i: integer range 0 to 23;
variable i1: integer range 0 to 9;
begin
i:= conv_integer(bin);
i1:= i / 10;
bcd10 <= CONV_STD_LOGIC_VECTOR(i1, 4);
i1:= i rem 10;
bcd1 <= CONV_STD_LOGIC_VECTOR(i1, 4);
end process;
end converter_behavior;

Преобразователь Binary в BCD, по сути, просто разбивает одно бинарное число на два, каждое из которых представляет разряд десятичного числа. Из новинок – оператор rem, остаток от деления. Аналогично написан и преобразователь для шести бит, его приводить не буду.

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

Entity BCD_to_7seg is
port(
BCD:in std_logic_vector(3 downto 0);
seg:out std_logic_vector(6 downto 0)
);

End BCD_to_7seg;

Architecture conv_behavior of BCD_to_7seg is
begin
process(BCD)
begin
if BCD = "0000" then seg <= "0000001";--0
elsif BCD = "0001" then seg <= "1001111";--1
elsif BCD = "0010" then seg <= "0010010";--2
elsif BCD = "0011" then seg <= "0000110";--3
elsif BCD = "0100" then seg <= "1001100";--4
elsif BCD = "0101" then seg <= "0100100";--5
elsif BCD = "0110" then seg <= "0100000";--6
elsif BCD = "0111" then seg <= "0001111";--7
elsif BCD = "1000" then seg <= "0000000";--8
elsif BCD = "1001" then seg <= "0000100";--9
else seg <= "1001001";--err
end if;
end process;
end conv_behavior;

Преобразователь одного разряда в семисегментный код, реализованный простой таблицей истинности. Сам семисегментный код представляет собой битовое представление горящих сегментов на индикаторе в порядке abcdefg, в моем случае еще и инверсное.

По мере развития цифровых микросхем возникло противоречие между возможной степенью интеграции и номенклатурой выпускаемых микросхем. Экономически оправдано было выпускать микросхемы средней интеграции, таких как , . Более сложные схемы приходилось создавать из этих узлов. Разместить более сложную схему на полупроводниковом кристалле не было проблем, но это было оправдано либо очень большой серийностью аппаратуры, либо ценой аппаратуры (военная, авиационная или космическая). Заказные микросхемы не могли удовлетворить возникшую потребность в миниатюризации аппаратуры. Решение могло быть только одним — предоставить разработчикам аппаратуры возможность изменять внутреннюю структуру микросхемы (программировать).

История развития программируемых логических интегральных схем (ПЛИС) начинается с появления программируемых постоянных запоминающих устройств. Первое время программируемые ПЗУ использовались исключительно для хранения данных, однако вскоре их стали применять для реализации цифровых комбинационных устройств с произвольной таблицей истинности. В качестве недостатка подобного решения следует отметить экспоненциальный рост сложности устройства в зависимости от количества входов. Добавление одного дополнительного входа цифрового устройства приводит к удвоению требуемого количества ячеек памяти ПЗУ. Это не позволяет реализовать многовходовые .

Для реализации цифровых комбинационных устройств с большим числом входов были разработаны программируемые логические матрицы (ПЛМ). В иностранной литературе они получили название — Programmable Logic Arrays (PLA). Именно программируемые логические матрицы можно считать первыми программируемыми логическими интегральными схемами (Programmable Logic Devices — PLDs). ПЛМ получили широкое распространение в качестве первых универсальных микросхем большой интеграции.

Классификация ПЛИС

В настоящее время программируемые логические интегральные схемы развиваются по нескольким направлениям, поэтому возникла необходимость как то различать эти микросхемы. Классификация программируемых логических интегральных схем (ПЛИС) приведена на рисунке 1.

Рисунок 1. Классификация программируемых логических интегральных схем (ПЛИС)